int level; // 0 == on menu bar, 1 == one level down

const char *label; // or NULL for a separator

Command cmd; // command ID

int accel; // keyboard accelerator

MenuKind kind;

MenuHandler *fn;

for(int i = 0; Menu[i].level >= 0; i++) {

if(cmd == Menu[i].cmd) {

(Menu[i].fn)((Command)Menu[i].cmd);

break;

}

}

int accel = 0;

for(int i = 0; Menu[i].level >= 0; i++) {

if(cmd == Menu[i].cmd) {

accel = Menu[i].accel;

break;

}

}

std::string label;

if(accel & CTRL_MASK) {

#ifdef __APPLE__

label += "⌘+";

#else

label += "Ctrl+";

#endif

}

if(accel & SHIFT_MASK) {

label += "Shift+";

}

accel &= ~(CTRL_MASK | SHIFT_MASK);

if(accel & FN_MASK) {

label += ssprintf("F%d", accel & ~FN_MASK);

} else if(accel == '\t') {

label += "Tab";

} else if(accel == ' ') {

label += "Space";

} else if(accel == '\e') {

label += "Esc";

} else if(accel == '\x7f') {

label += "Del";

} else if(accel != 0) {

label += (char)(accel & 0xff);

}

return label;

Platform::MenuBarRef mainMenu = Platform::CreateMenuBar();

Platform::MenuRef currentSubMenu;

for(int i = 0; Menu[i].level >= 0; i++) {

if(Menu[i].label == NULL) {

currentSubMenu->AddSeparator();

continue;

}

std::string label = Translate(Menu[i].label);

if(Menu[i].level == 0) {

currentSubMenu = mainMenu->AddSubMenu(label);

} else if(Menu[i].cmd == Command::OPEN_RECENT) {

openRecentMenu = currentSubMenu->AddSubMenu(label);

} else if(Menu[i].cmd == Command::GROUP_RECENT) {

linkRecentMenu = currentSubMenu->AddSubMenu(label);

} else if(Menu[i].cmd == Command::LOCALE) {

Platform::MenuRef localeMenu = currentSubMenu->AddSubMenu(label);

for(const Locale &locale : Locales()) {

localeMenu->AddItem(locale.displayName, [&]() {

SetLocale(locale.Culture());

CnfFreezeString(locale.Culture(), "Locale");

SS.UpdateWindowTitles();

PopulateMainMenu();

});

}

} else {

Platform::MenuItemRef menuItem = currentSubMenu->AddItem(label);

menuItem->onTrigger = std::bind(Menu[i].fn, Menu[i].cmd);

if(Menu[i].accel != 0) {

Platform::KeyboardEvent accel = {};

if(Menu[i].accel & SHIFT_MASK) {

accel.shiftDown = true;

}

if(Menu[i].accel & CTRL_MASK) {

accel.controlDown = true;

}

if(Menu[i].accel & FN_MASK) {

accel.key = Platform::KeyboardEvent::Key::FUNCTION;

accel.num = Menu[i].accel & 0xff;

} else {

accel.key = Platform::KeyboardEvent::Key::CHARACTER;

accel.chr = (char)(Menu[i].accel & 0xff);

}

menuItem->SetAccelerator(accel);

}

menuItem->SetIndicator(Menu[i].kind);

if(Menu[i].cmd == Command::SHOW_GRID) {

showGridMenuItem = menuItem;

} else if(Menu[i].cmd == Command::PERSPECTIVE_PROJ) {

perspectiveProjMenuItem = menuItem;

} else if(Menu[i].cmd == Command::SHOW_TOOLBAR) {

showToolbarMenuItem = menuItem;

} else if(Menu[i].cmd == Command::SHOW_TEXT_WND) {

showTextWndMenuItem = menuItem;

} else if(Menu[i].cmd == Command::FULL_SCREEN) {

fullScreenMenuItem = menuItem;

} else if(Menu[i].cmd == Command::UNITS_INCHES) {

unitsInchesMenuItem = menuItem;

} else if(Menu[i].cmd == Command::UNITS_MM) {

unitsMmMenuItem = menuItem;

} else if(Menu[i].cmd == Command::SEL_WORKPLANE) {

inWorkplaneMenuItem = menuItem;

} else if(Menu[i].cmd == Command::FREE_IN_3D) {

in3dMenuItem = menuItem;

} else if(Menu[i].cmd == Command::UNDO) {

undoMenuItem = menuItem;

} else if(Menu[i].cmd == Command::REDO) {

redoMenuItem = menuItem;

}

}

}

PopulateRecentFiles();

SS.UndoEnableMenus();

window->SetMenuBar(mainMenu);

std::vector<Platform::Path> pathnames,

std::function<void(const Platform::Path &)> onTrigger) {

menu->Clear();

if(pathnames.empty()) {

Platform::MenuItemRef menuItem = menu->AddItem(_("(no recent files)"));

menuItem->SetEnabled(false);

} else {

for(Platform::Path pathname : pathnames) {

Platform::MenuItemRef menuItem = menu->AddItem(pathname.raw);

menuItem->onTrigger = [=]() { onTrigger(pathname); };

}

}

PopulateMenuWithPathnames(openRecentMenu, SS.recentFiles, [](const Platform::Path &path) {

if(!SS.OkayToStartNewFile()) return;

SS.Load(path);

});

PopulateMenuWithPathnames(linkRecentMenu, SS.recentFiles, [](const Platform::Path &path) {

//FIXME

});

if(!window) {

window = Platform::CreateWindow();

if(window) {

using namespace std::placeholders;

window->onClose = std::bind(&SolveSpaceUI::Exit, &SS);

window->onRender = std::bind(&GraphicsWindow::Paint, this);

window->onMouseEvent = std::bind(&GraphicsWindow::MouseEvent, this, _1);

window->onKeyboardEvent = std::bind(&GraphicsWindow::KeyboardEvent, this, _1);

window->onEditingDone = std::bind(&GraphicsWindow::EditControlDone, this, _1);

PopulateMainMenu();

window->SetVisible(true);

}

}

if(!canvas) {

canvas = CreateRenderer();

if(canvas) {

persistentCanvas = canvas->CreateBatch();

persistentDirty = true;

}

}

scale = 5;

offset = Vector::From(0, 0, 0);

projRight = Vector::From(1, 0, 0);

projUp = Vector::From(0, 1, 0);

// Make sure those are valid; could get a mouse move without a mouse

// down if someone depresses the button, then drags into our window.

orig.projRight = projRight;

orig.projUp = projUp;

// And with the last group active

activeGroup = SK.groupOrder.elem[SK.groupOrder.n - 1];

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

showWorkplanes = false;

showNormals = true;

showPoints = true;

showConstraints = true;

showShaded = true;

showEdges = true;

showMesh = false;

showOutlines = false;

drawOccludedAs = DrawOccludedAs::INVISIBLE;

showTextWindow = true;

showSnapGrid = false;

context.active = false;

// Do this last, so that all the menus get updated correctly.

ClearSuper();

if(!LockedInWorkplane()) return;

Entity *w = SK.GetEntity(ActiveWorkplane());

Quaternion quatf = w->Normal()->NormalGetNum();

Vector offsetf = (SK.GetEntity(w->point[0])->PointGetNum()).ScaledBy(-1);

AnimateOnto(quatf, offsetf);

// Get our initial orientation and translation.

Quaternion quat0 = Quaternion::From(projRight, projUp);

Vector offset0 = offset;

// Make sure we take the shorter of the two possible paths.

double mp = (quatf.Minus(quat0)).Magnitude();

double mm = (quatf.Plus(quat0)).Magnitude();

if(mp > mm) {

quatf = quatf.ScaledBy(-1);

mp = mm;

}

double mo = (offset0.Minus(offsetf)).Magnitude()*scale;

// Animate transition, unless it's a tiny move.

int32_t dt = (mp < 0.01 && mo < 10) ? (-20) :

(int32_t)(100 + 1000*mp + 0.4*mo);

// Don't ever animate for longer than 2000 ms; we can get absurdly

// long translations (as measured in pixels) if the user zooms out, moves,

// and then zooms in again.

if(dt > 2000) dt = 2000;

int64_t tn, t0 = GetMilliseconds();

double s = 0;

Quaternion dq = quatf.Times(quat0.Inverse());

do {

offset = (offset0.ScaledBy(1 - s)).Plus(offsetf.ScaledBy(s));

Quaternion quat = (dq.ToThe(s)).Times(quat0);

quat = quat.WithMagnitude(1);

projRight = quat.RotationU();

projUp = quat.RotationV();

window->Redraw();

tn = GetMilliseconds();

s = (tn - t0)/((double)dt);

} while((tn - t0) < dt);

projRight = quatf.RotationU();

projUp = quatf.RotationV();

offset = offsetf;

Invalidate();

// If the view screen is open, then we need to refresh it.

SS.ScheduleShowTW();

double *wmin, bool usePerspective)

{

double w;

Vector pp = ProjectPoint4(p, &w);

// If usePerspective is true, then we calculate a perspective projection of the point.

// If not, then we do a parallel projection regardless of the current

// scale factor.

if(usePerspective) {

pp = pp.ScaledBy(1.0/w);

}

pmax->x = max(pmax->x, pp.x);

pmax->y = max(pmax->y, pp.y);

pmin->x = min(pmin->x, pp.x);

pmin->y = min(pmin->y, pp.y);

*wmin = min(*wmin, w);

const std::vector<Constraint *> &constraints,

const std::vector<hEntity> &faces,

Point2d *pmax, Point2d *pmin, double *wmin,

bool usePerspective, bool includeMesh) {

for(Entity *e : entities) {

if(e->IsPoint()) {

HandlePointForZoomToFit(e->PointGetNum(), pmax, pmin, wmin, usePerspective);

} else if(e->type == Entity::Type::CIRCLE) {

// Lots of entities can extend outside the bbox of their points,

// but circles are particularly bad. We want to get things halfway

// reasonable without the mesh, because a zoom to fit is used to

// set the zoom level to set the chord tol.

double r = e->CircleGetRadiusNum();

Vector c = SK.GetEntity(e->point[0])->PointGetNum();

Quaternion q = SK.GetEntity(e->normal)->NormalGetNum();

for(int j = 0; j < 4; j++) {

Vector p = (j == 0) ? (c.Plus(q.RotationU().ScaledBy( r))) :

(j == 1) ? (c.Plus(q.RotationU().ScaledBy(-r))) :

(j == 2) ? (c.Plus(q.RotationV().ScaledBy( r))) :

(c.Plus(q.RotationV().ScaledBy(-r)));

HandlePointForZoomToFit(p, pmax, pmin, wmin, usePerspective);

}

} else {

// We have to iterate children points, because we can select entites without points

for(int i = 0; i < MAX_POINTS_IN_ENTITY; i++) {

if(e->point[i].v == 0) break;

Vector p = SK.GetEntity(e->point[i])->PointGetNum();

HandlePointForZoomToFit(p, pmax, pmin, wmin, usePerspective);

}

}

}

for(Constraint *c : constraints) {

std::vector<Vector> refs;

c->GetReferencePoints(GetCamera(), &refs);

for(Vector p : refs) {

HandlePointForZoomToFit(p, pmax, pmin, wmin, usePerspective);

}

}

if(!includeMesh && faces.empty()) return;

Group *g = SK.GetGroup(activeGroup);

g->GenerateDisplayItems();

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

STriangle *tr = &(g->displayMesh.l.elem[i]);

if(!includeMesh) {

bool found = false;

for(const hEntity &face : faces) {

if(face.v != tr->meta.face) continue;

found = true;

break;

}

if(!found) continue;

}

HandlePointForZoomToFit(tr->a, pmax, pmin, wmin, usePerspective);

HandlePointForZoomToFit(tr->b, pmax, pmin, wmin, usePerspective);

HandlePointForZoomToFit(tr->c, pmax, pmin, wmin, usePerspective);

}

if(!includeMesh) return;

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

SContour *sc = &(g->polyLoops.l.elem[i]);

for(int j = 0; j < sc->l.n; j++) {

HandlePointForZoomToFit(sc->l.elem[j].p, pmax, pmin, wmin, usePerspective);

}

}

ssassert(window != NULL, "Cannot zoom to fit without a window");

double width, height;

window->GetSize(&width, &height);

std::vector<Entity *> entities;

std::vector<Constraint *> constraints;

std::vector<hEntity> faces;

if(useSelection) {

for(int i = 0; i < selection.n; i++) {

Selection *s = &selection.elem[i];

if(s->entity.v != 0) {

Entity *e = SK.entity.FindById(s->entity);

if(e->IsFace()) {

faces.push_back(e->h);

continue;

}

entities.push_back(e);

}

if(s->constraint.v != 0) {

Constraint *c = SK.constraint.FindById(s->constraint);

constraints.push_back(c);

}

}

}

bool selectionUsed = !entities.empty() || !constraints.empty() || !faces.empty();

if(!selectionUsed) {

for(Entity &e : SK.entity) {

// we don't want to handle separate points, because we will iterate them inside entities.

if(e.IsPoint()) continue;

if(!includingInvisibles && !e.IsVisible()) continue;

entities.push_back(&e);

}

for(Constraint &c : SK.constraint) {

if(!c.IsVisible()) continue;

constraints.push_back(&c);

}

}

// On the first run, ignore perspective.

Point2d pmax = { -1e12, -1e12 }, pmin = { 1e12, 1e12 };

double wmin = 1;

LoopOverPoints(entities, constraints, faces, &pmax, &pmin, &wmin,

/*usePerspective=*/false, /*includeMesh=*/!selectionUsed);

double xm = (pmax.x + pmin.x)/2, ym = (pmax.y + pmin.y)/2;

double dx = pmax.x - pmin.x, dy = pmax.y - pmin.y;

offset = offset.Plus(projRight.ScaledBy(-xm)).Plus(

projUp. ScaledBy(-ym));

// And based on this, we calculate the scale and offset

if(EXACT(dx == 0 && dy == 0)) {

scale = 5;

} else {

double scalex = 1e12, scaley = 1e12;

if(EXACT(dx != 0)) scalex = 0.9*width /dx;

if(EXACT(dy != 0)) scaley = 0.9*height/dy;

scale = min(scalex, scaley);

scale = min(300.0, scale);

scale = max(0.003, scale);

}

// Then do another run, considering the perspective.

pmax.x = -1e12; pmax.y = -1e12;

pmin.x = 1e12; pmin.y = 1e12;

wmin = 1;

LoopOverPoints(entities, constraints, faces, &pmax, &pmin, &wmin,

/*usePerspective=*/true, /*includeMesh=*/!selectionUsed);

// Adjust the scale so that no points are behind the camera

if(wmin < 0.1) {

double k = SS.CameraTangent();

// w = 1+k*scale*z

double zmin = (wmin - 1)/(k*scale);

// 0.1 = 1 + k*scale*zmin

// (0.1 - 1)/(k*zmin) = scale

scale = min(scale, (0.1 - 1)/(k*zmin));

}

switch(id) {

case Command::ZOOM_IN:

SS.GW.scale *= 1.2;

SS.ScheduleShowTW();

break;

case Command::ZOOM_OUT:

SS.GW.scale /= 1.2;

SS.ScheduleShowTW();

break;

case Command::ZOOM_TO_FIT:

SS.GW.ZoomToFit(/*includingInvisibles=*/false, /*useSelection=*/true);

SS.ScheduleShowTW();

break;

case Command::SHOW_GRID:

SS.GW.showSnapGrid = !SS.GW.showSnapGrid;

if(SS.GW.showSnapGrid && !SS.GW.LockedInWorkplane()) {

Message(_("No workplane is active, so the grid will not appear."));

}

SS.GW.EnsureValidActives();

SS.GW.Invalidate();

break;

case Command::PERSPECTIVE_PROJ:

SS.usePerspectiveProj = !SS.usePerspectiveProj;

if(SS.cameraTangent < 1e-6) {

Error(_("The perspective factor is set to zero, so the view will "

"always be a parallel projection.\n\n"

"For a perspective projection, modify the perspective "

"factor in the configuration screen. A value around 0.3 "

"is typical."));

}

SS.GW.EnsureValidActives();

SS.GW.Invalidate();

break;

case Command::ONTO_WORKPLANE:

if(SS.GW.LockedInWorkplane()) {

SS.GW.AnimateOntoWorkplane();

SS.ScheduleShowTW();

break;

} // if not in 2d mode fall through and use ORTHO logic

case Command::NEAREST_ORTHO:

case Command::NEAREST_ISO: {

static const Vector ortho[3] = {

Vector::From(1, 0, 0),

Vector::From(0, 1, 0),

Vector::From(0, 0, 1)

};

double sqrt2 = sqrt(2.0), sqrt6 = sqrt(6.0);

Quaternion quat0 = Quaternion::From(SS.GW.projRight, SS.GW.projUp);

Quaternion quatf = quat0;

double dmin = 1e10;

// There are 24 possible views; 3*2*2*2

int i, j, negi, negj;

for(i = 0; i < 3; i++) {

for(j = 0; j < 3; j++) {

if(i == j) continue;

for(negi = 0; negi < 2; negi++) {

for(negj = 0; negj < 2; negj++) {

Vector ou = ortho[i], ov = ortho[j];

if(negi) ou = ou.ScaledBy(-1);

if(negj) ov = ov.ScaledBy(-1);

Vector on = ou.Cross(ov);

Vector u, v;

if(id == Command::NEAREST_ORTHO || id == Command::ONTO_WORKPLANE) {

u = ou;

v = ov;

} else {

u =

ou.ScaledBy(1/sqrt2).Plus(

on.ScaledBy(-1/sqrt2));

v =

ou.ScaledBy(-1/sqrt6).Plus(

ov.ScaledBy(2/sqrt6).Plus(

on.ScaledBy(-1/sqrt6)));

}

Quaternion quatt = Quaternion::From(u, v);

double d = min(

(quatt.Minus(quat0)).Magnitude(),

(quatt.Plus(quat0)).Magnitude());

if(d < dmin) {

dmin = d;

quatf = quatt;

}

}

}

}

}

SS.GW.AnimateOnto(quatf, SS.GW.offset);

break;

}

case Command::CENTER_VIEW:

SS.GW.GroupSelection();

if(SS.GW.gs.n == 1 && SS.GW.gs.points == 1) {

Quaternion quat0;

// Offset is the selected point, quaternion is same as before

Vector pt = SK.GetEntity(SS.GW.gs.point[0])->PointGetNum();

quat0 = Quaternion::From(SS.GW.projRight, SS.GW.projUp);

SS.GW.AnimateOnto(quat0, pt.ScaledBy(-1));

SS.GW.ClearSelection();

} else {

Error(_("Select a point; this point will become the center "

"of the view on screen."));

}

break;

case Command::SHOW_TOOLBAR:

SS.showToolbar = !SS.showToolbar;

SS.GW.EnsureValidActives();

SS.GW.Invalidate();

break;

case Command::SHOW_TEXT_WND:

SS.GW.showTextWindow = !SS.GW.showTextWindow;

SS.GW.EnsureValidActives();

break;

case Command::UNITS_INCHES:

SS.viewUnits = Unit::INCHES;

SS.ScheduleShowTW();

SS.GW.EnsureValidActives();

break;

case Command::UNITS_MM:

SS.viewUnits = Unit::MM;

SS.ScheduleShowTW();

SS.GW.EnsureValidActives();

break;

case Command::FULL_SCREEN:

SS.GW.window->SetFullScreen(!SS.GW.window->IsFullScreen());

SS.GW.EnsureValidActives();

break;

default: ssassert(false, "Unexpected menu ID");

}

SS.GW.Invalidate();

bool change = false;

// The active group must exist, and not be the references.

Group *g = SK.group.FindByIdNoOops(activeGroup);

if((!g) || (g->h.v == Group::HGROUP_REFERENCES.v)) {

int i;

for(i = 0; i < SK.groupOrder.n; i++) {

if(SK.groupOrder.elem[i].v != Group::HGROUP_REFERENCES.v) {

break;

}

}

if(i >= SK.groupOrder.n) {

// This can happen if the user deletes all the groups in the

// sketch. It's difficult to prevent that, because the last

// group might have been deleted automatically, because it failed

// a dependency. There needs to be something, so create a plane

// drawing group and activate that. They should never be able

// to delete the references, though.

activeGroup = SS.CreateDefaultDrawingGroup();

// We've created the default group, but not the workplane entity;

// do it now so that drawing mode isn't switched to "Free in 3d".

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

} else {

activeGroup = SK.groupOrder.elem[i];

}

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

change = true;

}

// The active coordinate system must also exist.

if(LockedInWorkplane()) {

Entity *e = SK.entity.FindByIdNoOops(ActiveWorkplane());

if(e) {

hGroup hgw = e->group;

if(hgw.v != activeGroup.v && SS.GroupsInOrder(activeGroup, hgw)) {

// The active workplane is in a group that comes after the

// active group; so any request or constraint will fail.

SetWorkplaneFreeIn3d();

change = true;

}

} else {

SetWorkplaneFreeIn3d();

change = true;

}

}

// And update the checked state for various menus

bool locked = LockedInWorkplane();

in3dMenuItem->SetActive(!locked);

inWorkplaneMenuItem->SetActive(locked);

SS.UndoEnableMenus();

switch(SS.viewUnits) {

case Unit::MM:

case Unit::INCHES:

break;

default:

SS.viewUnits = Unit::MM;

break;

}

unitsMmMenuItem->SetActive(SS.viewUnits == Unit::MM);

unitsInchesMenuItem->SetActive(SS.viewUnits == Unit::INCHES);

SS.TW.window->SetVisible(SS.GW.showTextWindow);

showTextWndMenuItem->SetActive(SS.GW.showTextWindow);

showGridMenuItem->SetActive(SS.GW.showSnapGrid);

perspectiveProjMenuItem->SetActive(SS.usePerspectiveProj);

showToolbarMenuItem->SetActive(SS.showToolbar);

fullScreenMenuItem->SetActive(SS.GW.window->IsFullScreen());

if(change) SS.ScheduleShowTW();

Group *g = SK.group.FindByIdNoOops(activeGroup);

if(g) {

return g->activeWorkplane;

} else {

return Entity::FREE_IN_3D;

}

if(!showTextWindow) {

showTextWindow = true;

showTextWndMenuItem->SetActive(true);

SS.TW.window->SetVisible(true);

}

// Rewrite any point-coincident constraints that were affected by this

// deletion.

Request *r;

for(r = SK.request.First(); r; r = SK.request.NextAfter(r)) {

if(!r->tag) continue;

FixConstraintsForRequestBeingDeleted(r->h);

}

// and then delete the tagged requests.

SK.request.RemoveTagged();

// An edit might be in progress for the just-deleted item. So

// now it's not.

window->HideEditor();

SS.TW.HideEditControl();

// And clear out the selection, which could contain that item.

ClearSuper();

// And regenerate to get rid of what it generates, plus anything

// that references it (since the regen code checks for that).

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

EnsureValidActives();

SS.ScheduleShowTW();

if(!LockedInWorkplane()) return p;

EntityBase *wrkpl = SK.GetEntity(ActiveWorkplane()),

*norm = wrkpl->Normal();

Vector wo = SK.GetEntity(wrkpl->point[0])->PointGetNum(),

wu = norm->NormalU(),

wv = norm->NormalV(),

wn = norm->NormalN();

Vector pp = (p.Minus(wo)).DotInToCsys(wu, wv, wn);

pp.x = floor((pp.x / SS.gridSpacing) + 0.5)*SS.gridSpacing;

pp.y = floor((pp.y / SS.gridSpacing) + 0.5)*SS.gridSpacing;

pp.z = 0;

return pp.ScaleOutOfCsys(wu, wv, wn).Plus(wo);

switch(id) {

case Command::UNSELECT_ALL:

SS.GW.GroupSelection();

// If there's nothing selected to de-select, and no operation

// to cancel, then perhaps they want to return to the home

// screen in the text window.

if(SS.GW.gs.n == 0 &&

SS.GW.gs.constraints == 0 &&

SS.GW.pending.operation == Pending::NONE)

{

if(!(TextEditControlIsVisible() ||

SS.GW.window->IsEditorVisible()))

{

if(SS.TW.shown.screen == TextWindow::Screen::STYLE_INFO) {

SS.TW.GoToScreen(TextWindow::Screen::LIST_OF_STYLES);

} else {

SS.TW.ClearSuper();

}

}

}

SS.GW.ClearSuper();

SS.TW.HideEditControl();

SS.nakedEdges.Clear();

SS.justExportedInfo.draw = false;

SS.centerOfMass.draw = false;

// This clears the marks drawn to indicate which points are

// still free to drag.

Param *p;

for(p = SK.param.First(); p; p = SK.param.NextAfter(p)) {

p->free = false;

}

if(SS.exportMode) {

SS.exportMode = false;

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

}

SS.GW.persistentDirty = true;

break;

case Command::SELECT_ALL: {

Entity *e;

for(e = SK.entity.First(); e; e = SK.entity.NextAfter(e)) {

if(e->group.v != SS.GW.activeGroup.v) continue;

if(e->IsFace() || e->IsDistance()) continue;

if(!e->IsVisible()) continue;

SS.GW.MakeSelected(e->h);

}

SS.GW.Invalidate();

SS.ScheduleShowTW();

break;

}

case Command::SELECT_CHAIN: {

Entity *e;

int newlySelected = 0;

bool didSomething;

do {

didSomething = false;

for(e = SK.entity.First(); e; e = SK.entity.NextAfter(e)) {

if(e->group.v != SS.GW.activeGroup.v) continue;

if(!e->HasEndpoints()) continue;

if(!e->IsVisible()) continue;

Vector st = e->EndpointStart(),

fi = e->EndpointFinish();

bool onChain = false, alreadySelected = false;

List<Selection> *ls = &(SS.GW.selection);

for(Selection *s = ls->First(); s; s = ls->NextAfter(s)) {

if(!s->entity.v) continue;

if(s->entity.v == e->h.v) {

alreadySelected = true;

continue;

}

Entity *se = SK.GetEntity(s->entity);

if(!se->HasEndpoints()) continue;

Vector sst = se->EndpointStart(),

sfi = se->EndpointFinish();

if(sst.Equals(st) || sst.Equals(fi) ||

sfi.Equals(st) || sfi.Equals(fi))

{

onChain = true;

}