ClearScreen();

const char *header;

std::string desc;

if(SS.GW.LockedInWorkplane()) {

header = "in plane: ";

desc = SK.GetEntity(SS.GW.ActiveWorkplane())->DescriptionString();

} else {

header = "drawing / constraining in 3d";

desc = "";

}

// Navigation buttons

if(withNav) {

Printf(false, " %Fl%Lh%fhome%E %Ft%s%E%s",

(&TextWindow::ScreenHome), header, desc.c_str());

} else {

Printf(false, " %Ft%s%E%s", header, desc.c_str());

}

// Leave space for the icons that are painted here.

Printf(false, "");

Printf(false, "");

GraphicsWindow::MenuEdit(Command::UNSELECT_ALL);

SS.TW.GoToScreen(Screen::GROUP_INFO);

SS.TW.shown.group.v = v;

hGroup hg = { v };

Group *g = SK.GetGroup(hg);

g->visible = !(g->visible);

// If a group was just shown, then it might not have been generated

// previously, so regenerate.

SS.GenerateAll();

bool state = link == 's';

for(hGroup hg : SK.groupOrder) {

Group *g = SK.GetGroup(hg);

g->visible = state;

}

SS.GW.persistentDirty = true;

SS.GW.activeGroup.v = v;

SK.GetGroup(SS.GW.activeGroup)->Activate();

SS.GW.ClearSuper();

SS.GW.ClearSuper();

SS.TW.GoToScreen(Screen::GROUP_SOLVE_INFO);

SS.TW.shown.group = hg;

SS.ScheduleShowTW();

if(SS.GW.activeGroup.v != v) {

ScreenActivateGroup(link, v);

}

SS.TW.GoToScreen(Screen::GROUP_SOLVE_INFO);

SS.TW.shown.group.v = v;

const char *radioTrue = " " RADIO_TRUE " ",

*radioFalse = " " RADIO_FALSE " ",

*checkTrue = " " CHECK_TRUE " ",

*checkFalse = " " CHECK_FALSE " ";

Printf(true, "%Ft active");

Printf(false, "%Ft shown dof group-name%E");

bool afterActive = false;

bool backgroundParity = false;

for(hGroup hg : SK.groupOrder) {

Group *g = SK.GetGroup(hg);

std::string s = g->DescriptionString();

bool active = (g->h == SS.GW.activeGroup);

bool shown = g->visible;

bool ok = g->IsSolvedOkay();

bool warn = (g->type == Group::Type::DRAWING_WORKPLANE &&

g->polyError.how != PolyError::GOOD) ||

((g->type == Group::Type::EXTRUDE ||

g->type == Group::Type::LATHE) &&

SK.GetGroup(g->opA)->polyError.how != PolyError::GOOD);

int dof = g->solved.dof;

char sdof[16] = "ok ";

if(ok && dof > 0) {

if(dof > 999) {

strcpy(sdof, "###");

} else {

sprintf(sdof, "%-3d", dof);

}

}

std::string suffix;

if(g->forceToMesh || g->IsTriangleMeshAssembly()) {

suffix = " (∆)";

}

bool ref = (g->h == Group::HGROUP_REFERENCES);

Printf(false,

"%Bp%Fd "

"%Ft%s%Fb%D%f%Ll%s%E "

"%Fb%s%D%f%Ll%s%E "

"%Fp%D%f%s%Ll%s%E "

"%Fp%Ll%D%f%s%E%s",

// Alternate between light and dark backgrounds, for readability

backgroundParity ? 'd' : 'a',

// Link that activates the group

ref ? " " : "",

g->h.v, (&TextWindow::ScreenActivateGroup),

ref ? "" : (active ? radioTrue : radioFalse),

// Link that hides or shows the group

afterActive ? " - " : "",

g->h.v, (&TextWindow::ScreenToggleGroupShown),

afterActive ? "" : (shown ? checkTrue : checkFalse),

// Link to the errors, if a problem occurred while solving

ok ? (warn ? 'm' : (dof > 0 ? 'i' : 's')) : 'x',

g->h.v, (&TextWindow::ScreenHowGroupSolved),

ok ? ((warn && SS.checkClosedContour) ? "err" : sdof) : "",

ok ? "" : "ERR",

// Link to a screen that gives more details on the group

g->suppress ? 'g' : 'l',

g->h.v, (&TextWindow::ScreenSelectGroup), s.c_str(),

suffix.c_str());

if(active) afterActive = true;

backgroundParity = !backgroundParity;

}

Printf(true, " %Fl%Ls%fshow all%E / %Fl%Lh%fhide all%E",

&(TextWindow::ScreenShowGroupsSpecial),

&(TextWindow::ScreenShowGroupsSpecial));

Printf(true, " %Fl%Ls%fline styles%E /"

" %Fl%Ls%fview%E /"

" %Fl%Ls%fconfiguration%E",

&(TextWindow::ScreenShowListOfStyles),

&(TextWindow::ScreenShowEditView),

&(TextWindow::ScreenShowConfiguration));

SS.GW.hover.Clear();

hGroup hg = { v };

SS.GW.hover.entity = hg.entity(0);

SS.GW.hover.emphasized = true;

SS.GW.hover.Clear();

hEntity he = { v };

SS.GW.hover.entity = he;

SS.GW.hover.emphasized = true;

SS.GW.hover.Clear();

hRequest hr = { v };

SS.GW.hover.entity = hr.entity(0);

SS.GW.hover.emphasized = true;

if(!SS.GW.showConstraints) return;

hConstraint hc = { v };

SS.GW.hover.Clear();

SS.GW.hover.constraint = hc;

SS.GW.hover.emphasized = true;

SS.GW.ClearSelection();

GraphicsWindow::Selection sel = {};

hEntity he = { v };

sel.entity = he;

SS.GW.selection.Add(&sel);

SS.GW.ClearSelection();

GraphicsWindow::Selection sel = {};

hRequest hr = { v };

sel.entity = hr.entity(0);

SS.GW.selection.Add(&sel);

SS.GW.ClearSelection();

GraphicsWindow::Selection sel = {};

sel.constraint.v = v;

SS.GW.selection.Add(&sel);

SS.UndoRemember();

Group *g = SK.GetGroup(SS.TW.shown.group);

switch(link) {

case 's': g->subtype = Group::Subtype::ONE_SIDED; break;

case 'S': g->subtype = Group::Subtype::TWO_SIDED; break;

case 'k': g->skipFirst = true; break;

case 'K': g->skipFirst = false; break;

case 'c':

if(g->type == Group::Type::EXTRUDE) {

// When an extrude group is first created, it's positioned for a union

// extrusion. If no constraints were added, flip it when we switch between

// union/assemble and difference/intersection modes to avoid manual work doing the same.

if(g->meshCombine != (Group::CombineAs)v && g->GetNumConstraints() == 0) {

// I apologise for this if statement

if((((Group::CombineAs::DIFFERENCE == g->meshCombine) ||

(Group::CombineAs::INTERSECTION == g->meshCombine)) &&

(Group::CombineAs::DIFFERENCE != (Group::CombineAs)v) &&

(Group::CombineAs::INTERSECTION != (Group::CombineAs)v)) ||

((Group::CombineAs::DIFFERENCE != g->meshCombine) &&

(Group::CombineAs::INTERSECTION != g->meshCombine) &&

((Group::CombineAs::DIFFERENCE == (Group::CombineAs)v) ||

(Group::CombineAs::INTERSECTION == (Group::CombineAs)v)))) {

g->ExtrusionForceVectorTo(g->ExtrusionGetVector().Negated());

}

}

}

g->meshCombine = (Group::CombineAs)v;

break;

case 'P': g->suppress = !(g->suppress); break;

case 'r': g->relaxConstraints = !(g->relaxConstraints); break;

case 'e': g->allowRedundant = !(g->allowRedundant); break;

case 'D': g->suppressDofCalculation = !(g->suppressDofCalculation); break;

case 'v': g->visible = !(g->visible); break;

case 'd': g->allDimsReference = !(g->allDimsReference); break;

case 'f': g->forceToMesh = !(g->forceToMesh); break;

}

SS.MarkGroupDirty(g->h);

SS.GW.ClearSuper();

SS.UndoRemember();

Group *g = SK.GetGroup(SS.TW.shown.group);

SS.TW.ShowEditControlWithColorPicker(3, g->color);

SS.TW.edit.meaning = Edit::GROUP_COLOR;

Group *g = SK.GetGroup(SS.TW.shown.group);

SS.TW.ShowEditControl(11, ssprintf("%.2f", g->color.alphaF()));

SS.TW.edit.meaning = Edit::GROUP_OPACITY;

SS.TW.edit.group = g->h;

Group *g = SK.GetGroup(SS.TW.shown.group);

SS.TW.ShowEditControl(10, ssprintf("%d", (int)g->valA));

SS.TW.edit.meaning = Edit::TIMES_REPEATED;

SS.TW.edit.group.v = v;

Group *g = SK.GetGroup(SS.TW.shown.group);

SS.TW.ShowEditControl(12, g->DescriptionString().substr(5));

SS.TW.edit.meaning = Edit::GROUP_NAME;

SS.TW.edit.group.v = v;

Group *g = SK.GetGroup(SS.TW.shown.group);

SS.TW.ShowEditControl(13, ssprintf("%.3f", g->scale));

SS.TW.edit.meaning = Edit::GROUP_SCALE;

SS.TW.edit.group.v = v;

Group *g = SK.GetGroup(SS.TW.shown.group);

double pitch = g->valB/SS.MmPerUnit();

SS.TW.ShowEditControl(3, ssprintf("%.8f", pitch));

SS.TW.edit.meaning = Edit::HELIX_PITCH;

SS.TW.edit.group.v = v;

Group *g = SK.GetGroup(SS.TW.shown.group);

if(g->valB == 0.0) {

g->valB = SK.GetParam(g->h.param(7))->val * PI /

(SK.GetParam(g->h.param(3))->val);

} else {

g->valB = 0.0;

}

SS.GW.Invalidate();

SS.UndoRemember();

hGroup hg = SS.TW.shown.group;

if(hg == SS.GW.activeGroup) {

SS.GW.activeGroup = SK.GetGroup(SS.GW.activeGroup)->PreviousGroup()->h;

}

// Reset the text window, since we're displaying information about

// the group that's about to get deleted.

SS.TW.ClearSuper();

// This is a major change, so let's re-solve everything.

SK.group.RemoveById(hg);

SS.GenerateAll(SolveSpaceUI::Generate::ALL);

// Reset the graphics window. This will also recreate the default

// group if it was removed.

SS.GW.ClearSuper();

Group *g = SK.GetGroup(shown.group);

const char *s = "???";

if(shown.group == Group::HGROUP_REFERENCES) {

Printf(true, "%FtGROUP %E%s", g->DescriptionString().c_str());

goto list_items;

} else {

Printf(true, "%FtGROUP %E%s [%Fl%Ll%D%frename%E/%Fl%Ll%D%fdel%E]",

g->DescriptionString().c_str(),

g->h.v, &TextWindow::ScreenChangeGroupName,

g->h.v, &TextWindow::ScreenDeleteGroup);

}

if(g->type == Group::Type::LATHE) {

Printf(true, " %Ftlathe plane sketch");

} else if(g->type == Group::Type::EXTRUDE || g->type == Group::Type::ROTATE ||

g->type == Group::Type::TRANSLATE || g->type == Group::Type::REVOLVE ||

g->type == Group::Type::HELIX) {

if(g->type == Group::Type::EXTRUDE) {

s = "extrude plane sketch";

} else if(g->type == Group::Type::TRANSLATE) {

s = "translate original sketch";

} else if(g->type == Group::Type::HELIX) {

s = "create helical extrusion";

} else if(g->type == Group::Type::ROTATE) {

s = "rotate original sketch";

} else if(g->type == Group::Type::REVOLVE) {

s = "revolve original sketch";

}

Printf(true, " %Ft%s%E", s);

bool one = (g->subtype == Group::Subtype::ONE_SIDED);

Printf(false,

"%Ba %f%Ls%Fd%s one-sided%E "

"%f%LS%Fd%s two-sided%E",

&TextWindow::ScreenChangeGroupOption,

one ? RADIO_TRUE : RADIO_FALSE,

&TextWindow::ScreenChangeGroupOption,

!one ? RADIO_TRUE : RADIO_FALSE);

if(g->type == Group::Type::ROTATE || g->type == Group::Type::TRANSLATE) {

if(g->subtype == Group::Subtype::ONE_SIDED) {

bool skip = g->skipFirst;

Printf(false,

"%Bd %Ftstart %f%LK%Fd%s with original%E "

"%f%Lk%Fd%s with copy #1%E",

&ScreenChangeGroupOption,

!skip ? RADIO_TRUE : RADIO_FALSE,

&ScreenChangeGroupOption,

skip ? RADIO_TRUE : RADIO_FALSE);

}

int times = (int)(g->valA);

Printf(false, "%Bp %Ftrepeat%E %d time%s %Fl%Ll%D%f[change]%E",

(g->subtype == Group::Subtype::ONE_SIDED) ? 'a' : 'd',

times, times == 1 ? "" : "s",

g->h.v, &TextWindow::ScreenChangeExprA);

}

} else if(g->type == Group::Type::LINKED) {

Printf(true, " %Ftlink geometry from file%E");

Platform::Path relativePath = g->linkFile.RelativeTo(SS.saveFile.Parent());

if(relativePath.IsEmpty()) {

Printf(false, "%Ba '%s'", g->linkFile.raw.c_str());

} else {

Printf(false, "%Ba '%s'", relativePath.raw.c_str());

}

Printf(false, "%Bd %Ftscaled by%E %# %Fl%Ll%f%D[change]%E",

g->scale,

&TextWindow::ScreenChangeGroupScale, g->h.v);

} else if(g->type == Group::Type::DRAWING_3D) {

Printf(true, " %Ftsketch in 3d%E");

} else if(g->type == Group::Type::DRAWING_WORKPLANE) {

Printf(true, " %Ftsketch in new workplane%E");

} else {

Printf(true, "???");

}

Printf(false, "");

if(g->type == Group::Type::HELIX) {

Printf(false, "%Ft pitch - length per turn%E");

if (fabs(g->valB) != 0.0) {

Printf(false, " %Ba %# %Fl%Ll%f%D[change]%E",

g->valB / SS.MmPerUnit(),

&TextWindow::ScreenChangeHelixPitch, g->h.v);

} else {

Printf(false, " %Ba %# %E",

SK.GetParam(g->h.param(7))->val * PI /

( (SK.GetParam(g->h.param(3))->val) * SS.MmPerUnit() ),

&TextWindow::ScreenChangeHelixPitch, g->h.v);

}

Printf(false, " %Fd%f%LP%s fixed",

&TextWindow::ScreenChangePitchOption,

g->valB != 0 ? CHECK_TRUE : CHECK_FALSE);

Printf(false, ""); // blank line

}

if(g->type == Group::Type::EXTRUDE || g->type == Group::Type::LATHE ||

g->type == Group::Type::REVOLVE || g->type == Group::Type::LINKED ||

g->type == Group::Type::HELIX) {

bool un = (g->meshCombine == Group::CombineAs::UNION);

bool diff = (g->meshCombine == Group::CombineAs::DIFFERENCE);

bool intr = (g->meshCombine == Group::CombineAs::INTERSECTION);

bool asy = (g->meshCombine == Group::CombineAs::ASSEMBLE);

Printf(false, " %Ftsolid model as");

Printf(false, "%Ba %f%D%Lc%Fd%s union%E "

"%f%D%Lc%Fd%s assemble%E ",

&TextWindow::ScreenChangeGroupOption,

Group::CombineAs::UNION,

un ? RADIO_TRUE : RADIO_FALSE,

&TextWindow::ScreenChangeGroupOption,

Group::CombineAs::ASSEMBLE,

(asy ? RADIO_TRUE : RADIO_FALSE));

Printf(false, "%Ba %f%D%Lc%Fd%s difference%E "

"%f%D%Lc%Fd%s intersection%E ",

&TextWindow::ScreenChangeGroupOption,

Group::CombineAs::DIFFERENCE,

diff ? RADIO_TRUE : RADIO_FALSE,

&TextWindow::ScreenChangeGroupOption,

Group::CombineAs::INTERSECTION,

intr ? RADIO_TRUE : RADIO_FALSE);

if(g->type == Group::Type::EXTRUDE || g->type == Group::Type::LATHE ||

g->type == Group::Type::REVOLVE || g->type == Group::Type::HELIX) {

Printf(false,

"%Bd %Ftcolor %E%Bz %Bd (%@, %@, %@) %f%D%Lf%Fl[change]%E",

&g->color,

g->color.redF(), g->color.greenF(), g->color.blueF(),

ScreenColor, top[rows-1] + 2);

Printf(false, "%Bd %Ftopacity%E %@ %f%Lf%Fl[change]%E",

g->color.alphaF(),

&TextWindow::ScreenOpacity);

}

if(g->type == Group::Type::EXTRUDE || g->type == Group::Type::LATHE ||

g->type == Group::Type::REVOLVE || g->type == Group::Type::LINKED ||

g->type == Group::Type::HELIX) {

Printf(false, " %Fd%f%LP%s suppress this group's solid model",

&TextWindow::ScreenChangeGroupOption,

g->suppress ? CHECK_TRUE : CHECK_FALSE);

}

Printf(false, "");

}

Printf(false, " %f%Lv%Fd%s show entities from this group",

&TextWindow::ScreenChangeGroupOption,

g->visible ? CHECK_TRUE : CHECK_FALSE);

if(!g->IsForcedToMeshBySource() && !g->IsTriangleMeshAssembly()) {

Printf(false, " %f%Lf%Fd%s force NURBS surfaces to triangle mesh",

&TextWindow::ScreenChangeGroupOption,

g->forceToMesh ? CHECK_TRUE : CHECK_FALSE);

} else {

Printf(false, " (model already forced to triangle mesh)");

}

Printf(true, " %f%Lr%Fd%s relax constraints and dimensions",

&TextWindow::ScreenChangeGroupOption,

g->relaxConstraints ? CHECK_TRUE : CHECK_FALSE);

Printf(false, " %f%Le%Fd%s allow redundant constraints",

&TextWindow::ScreenChangeGroupOption,

g->allowRedundant ? CHECK_TRUE : CHECK_FALSE);

Printf(false, " %f%LD%Fd%s suppress dof calculation (improves solver performance)",

&TextWindow::ScreenChangeGroupOption,

g->suppressDofCalculation ? CHECK_TRUE : CHECK_FALSE);

Printf(false, " %f%Ld%Fd%s treat all dimensions as reference",

&TextWindow::ScreenChangeGroupOption,

g->allDimsReference ? CHECK_TRUE : CHECK_FALSE);

if(g->booleanFailed) {

Printf(false, "");

Printf(false, "The Boolean operation failed. It may be ");

Printf(false, "possible to fix the problem by choosing ");

Printf(false, "'force NURBS surfaces to triangle mesh'.");

}

list_items:

Printf(false, "");

Printf(false, "%Ft requests in group");

int a = 0;

for(auto &r : SK.request) {

if(r.group == shown.group) {

std::string s = r.DescriptionString();

Printf(false, "%Bp %Fl%Ll%D%f%h%s%E",

(a & 1) ? 'd' : 'a',

r.h.v,

(&TextWindow::ScreenSelectRequest),

&(TextWindow::ScreenHoverRequest),

s.c_str());

a++;

}

}

if(a == 0) Printf(false, "%Ba (none)");

a = 0;

Printf(false, "");

Printf(false, "%Ft constraints in group (%d DOF)", g->solved.dof);

for(auto &c : SK.constraint) {

if(c.group == shown.group) {

std::string s = c.DescriptionString();

Printf(false, "%Bp %Fl%Ll%D%f%h%s%E %s",

(a & 1) ? 'd' : 'a',

c.h.v,

(&TextWindow::ScreenSelectConstraint),

(&TextWindow::ScreenHoverConstraint),

s.c_str(),

c.reference ? "(ref)" : "");

a++;

}

}

if(a == 0) Printf(false, "%Ba (none)");

SS.UndoRemember();

Group *g = SK.GetGroup(SS.TW.shown.group);

g->allowRedundant = true;

SS.MarkGroupDirty(SS.TW.shown.group);

SS.TW.shown.screen = Screen::GROUP_INFO;

SS.TW.Show();

Group *g = SK.GetGroup(shown.group);

if(g->IsSolvedOkay()) {

// Go back to the default group info screen

shown.screen = Screen::GROUP_INFO;

Show();

return;

}

Printf(true, "%FtGROUP %E%s", g->DescriptionString().c_str());

switch(g->solved.how) {

case SolveResult::DIDNT_CONVERGE:

Printf(true, "%FxSOLVE FAILED!%Fd unsolvable constraints");

Printf(true, "the following constraints are incompatible");

break;

case SolveResult::REDUNDANT_DIDNT_CONVERGE:

Printf(true, "%FxSOLVE FAILED!%Fd unsolvable constraints");

Printf(true, "the following constraints are unsatisfied");

break;

case SolveResult::REDUNDANT_OKAY:

Printf(true, "%FxSOLVE FAILED!%Fd redundant constraints");

Printf(true, "remove any one of these to fix it");

break;

case SolveResult::TOO_MANY_UNKNOWNS:

Printf(true, "Too many unknowns in a single group!");

return;

default: ssassert(false, "Unexpected solve result");

}

for(int i = 0; i < g->solved.remove.n; i++) {

hConstraint hc = g->solved.remove[i];

Constraint *c = SK.constraint.FindByIdNoOops(hc);

if(!c) continue;

Printf(false, "%Bp %Fl%Ll%D%f%h%s%E",

(i & 1) ? 'd' : 'a',

c->h.v, (&TextWindow::ScreenSelectConstraint),

(&TextWindow::ScreenHoverConstraint),

c->DescriptionString().c_str());

}

if(g->solved.timeout) {

Printf(true, "%FxSome items in list have been omitted%Fd");

Printf(false, "%Fxbecause the operation timed out.%Fd");

}

Printf(true, "It may be possible to fix the problem ");

Printf(false, "by selecting Edit -> Undo.");

if(g->solved.how == SolveResult::REDUNDANT_OKAY) {

Printf(true, "It is possible to suppress this error ");

Printf(false, "by %Fl%f%Llallowing redundant constraints%E in ",

&TextWindow::ScreenAllowRedundant);

Printf(false, "this group.");

}

SS.TW.edit.meaning = Edit::STEP_DIM_FINISH;

std::string edit_value;

if(SS.TW.stepDim.isDistance) {

edit_value = SS.MmToString(SS.TW.stepDim.finish, true);

} else {

edit_value = ssprintf("%.3f", SS.TW.stepDim.finish);

}

SS.TW.ShowEditControl(12, edit_value);

hConstraint hc = SS.TW.shown.constraint;

Constraint *c = SK.constraint.FindByIdNoOops(hc);

if(c) {

SS.UndoRemember();

double start = c->valA, finish = SS.TW.stepDim.finish;

SS.TW.stepDim.time = GetMilliseconds();

SS.TW.stepDim.step = 1;

if(!SS.TW.stepDim.timer) {

SS.TW.stepDim.timer = Platform::CreateTimer();

}

SS.TW.stepDim.timer->onTimeout = [=] {

if(SS.TW.stepDim.step <= SS.TW.stepDim.steps) {

c->valA = start + ((finish - start)*SS.TW.stepDim.step)/SS.TW.stepDim.steps;

SS.MarkGroupDirty(c->group);

SS.GenerateAll();

if(!SS.ActiveGroupsOkay()) {

// Failed to solve, so quit

return;

}

SS.TW.stepDim.step++;

const int64_t STEP_MILLIS = 50;

int64_t time = GetMilliseconds();

if(time - SS.TW.stepDim.time < STEP_MILLIS) {

SS.TW.stepDim.timer->RunAfterNextFrame();

} else {

SS.TW.stepDim.timer->RunAfter((unsigned)(time - SS.TW.stepDim.time - STEP_MILLIS));

}

SS.TW.stepDim.time = time;

} else {

SS.TW.GoToScreen(Screen::LIST_OF_GROUPS);

SS.ScheduleShowTW();

}

SS.GW.Invalidate();

};

SS.TW.stepDim.timer->RunAfterNextFrame();

}

Constraint *c = SK.constraint.FindByIdNoOops(shown.constraint);

if(!c) {

shown.screen = Screen::LIST_OF_GROUPS;

Show();

return;

}

Printf(true, "%FtSTEP DIMENSION%E %s", c->DescriptionString().c_str());

if(stepDim.isDistance) {

Printf(true, "%Ba %Ftstart%E %s", SS.MmToString(c->valA).c_str());

Printf(false, "%Bd %Ftfinish%E %s %Fl%Ll%f[change]%E",

SS.MmToString(stepDim.finish).c_str(), &ScreenStepDimFinish);

} else {

Printf(true, "%Ba %Ftstart%E %@", c->valA);

Printf(false, "%Bd %Ftfinish%E %@ %Fl%Ll%f[change]%E",

stepDim.finish, &ScreenStepDimFinish);

}

Printf(false, "%Ba %Ftsteps%E %d %Fl%Ll%f%D[change]%E",

stepDim.steps, &ScreenStepDimSteps);

Printf(true, " %Fl%Ll%fstep dimension now%E", &ScreenStepDimGo);

Printf(true, "(or %Fl%Ll%fcancel operation%E)", &ScreenHome);

switch(link) {

case 'r': {

SS.TW.edit.meaning = Edit::TANGENT_ARC_RADIUS;

SS.TW.ShowEditControl(3, SS.MmToString(SS.tangentArcRadius, true));

break;

}

case 'a': SS.tangentArcManual = !SS.tangentArcManual; break;

case 'm': SS.tangentArcModify = !SS.tangentArcModify; break;

}

Printf(true, "%FtTANGENT ARC PARAMETERS%E");

Printf(true, "%Ft radius of created arc%E");

if(SS.tangentArcManual) {

Printf(false, "%Ba %s %Fl%Lr%f[change]%E",

SS.MmToString(SS.tangentArcRadius).c_str(),

&(TextWindow::ScreenChangeTangentArc));

} else {

Printf(false, "%Ba automatic");

}

Printf(false, "");

Printf(false, " %Fd%f%La%s choose radius automatically%E",

&ScreenChangeTangentArc,

!SS.tangentArcManual ? CHECK_TRUE : CHECK_FALSE);

Printf(false, " %Fd%f%Lm%s modify original entities%E",

&ScreenChangeTangentArc,

SS.tangentArcModify ? CHECK_TRUE : CHECK_FALSE);

Printf(false, "");

Printf(false, "To create a tangent arc at a point,");

Printf(false, "select that point and then choose");

Printf(false, "Sketch -> Tangent Arc at Point.");

Printf(true, "(or %Fl%Ll%fback to home screen%E)", &ScreenHome);

edit.showAgain = false;

switch(edit.meaning) {

case Edit::TIMES_REPEATED:

if(Expr *e = Expr::From(s, /*popUpError=*/true)) {

SS.UndoRemember();

double ev = e->Eval();

if((int)ev < 1) {

Error(_("Can't repeat fewer than 1 time."));

break;

}

if((int)ev > 999) {

Error(_("Can't repeat more than 999 times."));

break;

}

Group *g = SK.GetGroup(edit.group);

g->valA = ev;

if(g->type == Group::Type::ROTATE) {

// If the group does not contain any constraints, then

// set the numerical guess to space the copies uniformly

// over one rotation. Don't touch the guess if we're

// already constrained, because that would break

// convergence.

if(g->GetNumConstraints() == 0) {

double copies = (g->skipFirst) ? (ev + 1) : ev;

SK.GetParam(g->h.param(3))->val = PI/(2*copies);

}

}

SS.MarkGroupDirty(g->h);

}

break;

case Edit::GROUP_NAME:

if(s.empty()) {

Error(_("Group name cannot be empty"));

} else {

SS.UndoRemember();

Group *g = SK.GetGroup(edit.group);

g->name = s;

}

break;

case Edit::GROUP_SCALE:

if(Expr *e = Expr::From(s, /*popUpError=*/true)) {

double ev = e->Eval();

if(fabs(ev) < 1e-6) {

Error(_("Scale cannot be zero."));

} else {

Group *g = SK.GetGroup(edit.group);

g->scale = ev;

SS.MarkGroupDirty(g->h);

}

}

break;

case Edit::HELIX_PITCH: // stored in valB

if(Expr *e = Expr::From(s, /*popUpError=*/true)) {

double ev = e->Eval();

Group *g = SK.GetGroup(edit.group);

g->valB = ev * SS.MmPerUnit();

SS.MarkGroupDirty(g->h);

}

break;

case Edit::GROUP_COLOR: {

Vector rgb;

if(sscanf(s.c_str(), "%lf, %lf, %lf", &rgb.x, &rgb.y, &rgb.z)==3) {

rgb = rgb.ClampWithin(0, 1);

Group *g = SK.group.FindByIdNoOops(SS.TW.shown.group);

if(!g) break;

g->color = RgbaColor::FromFloat((float)rgb.x, (float)rgb.y, (float)rgb.z,

g->color.alphaF());

SS.MarkGroupDirty(g->h);

SS.GW.ClearSuper();

} else {

Error(_("Bad format: specify color as r, g, b"));

}

break;

}

case Edit::GROUP_OPACITY:

if(Expr *e = Expr::From(s, /*popUpError=*/true)) {

double alpha = e->Eval();

if(alpha < 0 || alpha > 1) {

Error(_("Opacity must be between zero and one."));

} else {

Group *g = SK.GetGroup(edit.group);

g->color.alpha = (int)(255.1f * alpha);

SS.MarkGroupDirty(g->h);

SS.GW.ClearSuper();

}

}

break;

case Edit::TTF_TEXT:

SS.UndoRemember();

if(Request *r = SK.request.FindByIdNoOops(edit.request)) {

r->str = s;

SS.MarkGroupDirty(r->group);

}

break;

case Edit::STEP_DIM_FINISH:

if(Expr *e = Expr::From(s, /*popUpError=*/true)) {

if(stepDim.isDistance) {

stepDim.finish = SS.ExprToMm(e);

} else {

stepDim.finish = e->Eval();

}

}

break;

case Edit::STEP_DIM_STEPS:

stepDim.steps = min(300, max(1, atoi(s.c_str())));

break;

case Edit::TANGENT_ARC_RADIUS:

if(Expr *e = Expr::From(s, /*popUpError=*/true)) {

if(e->Eval() < LENGTH_EPS) {

Error(_("Radius cannot be zero or negative."));

break;

}

SS.tangentArcRadius = SS.ExprToMm(e);

}

break;

default: {

int cnt = 0;

if(EditControlDoneForStyles(s)) cnt++;

if(EditControlDoneForConfiguration(s)) cnt++;

if(EditControlDoneForPaste(s)) cnt++;

if(EditControlDoneForView(s)) cnt++;

ssassert(cnt == 1, "Expected exactly one parameter to be edited");

break;

}

}

SS.GW.Invalidate();

SS.ScheduleShowTW();

if(!edit.showAgain) {

HideEditControl();

edit.meaning = Edit::NOTHING;

}