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 rawAccel = 0;

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

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

rawAccel = Menu[i].accel;

break;

}

}

Platform::KeyboardEvent accel = {};

accel.type = Platform::KeyboardEvent::Type::PRESS;

if(rawAccel & SHIFT_MASK) {

accel.shiftDown = true;

}

if(rawAccel & CTRL_MASK) {

accel.controlDown = true;

}

if(rawAccel & FN_MASK) {

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

accel.num = rawAccel & 0xff;

} else {

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

accel.chr = (char)(rawAccel & 0xff);

}

return accel;

using Platform::KeyboardEvent;

if(event.type == KeyboardEvent::Type::RELEASE)

return true;

if(event.key == KeyboardEvent::Key::CHARACTER) {

if(event.chr == '\b') {

// Treat backspace identically to escape.

MenuEdit(Command::UNSELECT_ALL);

return true;

} else if(event.chr == '=') {

// Treat = as +. This is specific to US (and US-compatible) keyboard layouts,

// but makes zooming from keyboard much more usable on these.

// Ideally we'd have a platform-independent way of binding to a particular

// physical key regardless of shift status...

MenuView(Command::ZOOM_IN);

return true;

}

}

// On some platforms, the OS does not handle some or all keyboard accelerators,

// so handle them here.

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

if(AcceleratorForCommand(Menu[i].cmd).Equals(event)) {

ActivateCommand(Menu[i].cmd);

return true;

}

}

return false;

bool unique = false;

Platform::MenuBarRef mainMenu = Platform::GetOrCreateMainMenu(&unique);

if(unique) mainMenu->Clear();

Platform::MenuRef currentSubMenu;

std::vector<Platform::MenuRef> subMenuStack;

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

while(Menu[i].level > 0 && Menu[i].level <= (int)subMenuStack.size()) {

currentSubMenu = subMenuStack.back();

subMenuStack.pop_back();

}

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());

Platform::GetSettings()->FreezeString("Locale", locale.Culture());

SS.UpdateWindowTitles();

PopulateMainMenu();

SS.GW.EnsureValidActives();

});

}

} else if(Menu[i].fn == NULL) {

subMenuStack.push_back(currentSubMenu);

currentSubMenu = currentSubMenu->AddSubMenu(label);

} else {

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

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

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

menuItem->SetAccelerator(AcceleratorForCommand(Menu[i].cmd));

}

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

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

showGridMenuItem = menuItem;

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

dimSolidModelMenuItem = menuItem;

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

perspectiveProjMenuItem = menuItem;

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

explodeMenuItem = 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_MM) {

unitsMmMenuItem = menuItem;

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

unitsMetersMenuItem = menuItem;

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

unitsInchesMenuItem = menuItem;

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

unitsFeetInchesMenuItem = 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, [=]() {

if(FileExists(pathname)) {

onTrigger(pathname);

} else {

Error(_("File '%s' does not exist."), pathname.raw.c_str());

}

}, /*mnemonics=*/false);

}

}

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

// OkayToStartNewFile could mutate recentFiles, which will invalidate path (which is a

// reference into the recentFiles vector), so take a copy of it here.

Platform::Path pathCopy(path);

if(!SS.OkayToStartNewFile()) return;

SS.Load(pathCopy);

});

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

Group::MenuGroup(Command::GROUP_LINK, path);

});

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

ssassert(!SK.groupOrder.IsEmpty(),

"Group order can't be empty since we will activate the last group.");

activeGroup = *SK.groupOrder.Last();

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

showWorkplanes = false;

showNormals = true;

showPoints = true;

showConstruction = true;

showConstraints = ShowConstraintMode::SCM_SHOW_ALL;

showShaded = true;

showEdges = true;

showMesh = false;

showOutlines = false;

showFacesDrawing = false;

showFacesNonDrawing = true;

drawOccludedAs = DrawOccludedAs::INVISIBLE;

showTextWindow = true;

showSnapGrid = false;

dimSolidModel = true;

context.active = false;

toolbarHovered = Command::NONE;

if(!window) {

window = Platform::CreateWindow();

if(window) {

using namespace std::placeholders;

// Do this first, so that if it causes an onRender event we don't try to paint without

// a canvas.

window->SetMinContentSize(720, /*ToolbarDrawOrHitTest 636*/ 32 * 18 + 3 * 16 + 8 + 4);

window->onClose = std::bind(&SolveSpaceUI::MenuFile, Command::EXIT);

window->onContextLost = [&] {

canvas = NULL;

persistentCanvas = NULL;

persistentDirty = true;

};

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

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

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

window->onSixDofEvent = std::bind(&GraphicsWindow::SixDofEvent, this, _1);

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

PopulateMainMenu();

}

}

if(window) {

canvas = CreateRenderer();

if(canvas) {

persistentCanvas = canvas->CreateBatch();

persistentDirty = true;

}

}

// 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();

// Get Z pointing vertical, if we're on turntable nav mode:

if(SS.turntableNav) {

Vector normalRight = quatf.RotationU();

Vector normalUp = quatf.RotationV();

Vector normal = normalRight.Cross(normalUp);

if(normalRight.z != 0) {

double theta = atan2(normalUp.z, normalRight.z);

theta -= atan2(1, 0);

normalRight = normalRight.RotatedAbout(normal, theta);

normalUp = normalUp.RotatedAbout(normal, theta);

quatf = Quaternion::From(normalRight, normalUp);

}

}

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

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

SS.ScheduleShowTW();

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.

int64_t t0 = GetMilliseconds();

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

(int32_t)(SS.animationSpeed*0.75*mp + SS.animationSpeed*0.0005*mo);

// Apply a minimum animation time, for small moves. This gets overridden by the maximum setting

// so setting the animation speed to 0 disables animations entirely.

dt = std::max(dt, 100 /* ms */);

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

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

// and then zooms in again.

dt = std::min(dt, SS.animationSpeed);

// If the resulting animation time is very short, disable it completely.

if (dt < 10) dt = -20;

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

if(!animateTimer) {

animateTimer = Platform::CreateTimer();

}

animateTimer->onTimeout = [=] {

int64_t tn = GetMilliseconds();

if((tn - t0) < dt) {

animateTimer->RunAfterNextFrame();

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

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

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

projRight = quat.RotationU();

projUp = quat.RotationV();

} else {

projRight = quatf.RotationU();

projUp = quatf.RotationV();

offset = offsetf;

}

window->Invalidate();

};

animateTimer->RunAfterNextFrame();

double *wmin, bool usePerspective,

const Camera &camera)

{

double w;

Vector pp = camera.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,

const Camera &camera) {

for(Entity *e : entities) {

if(e->IsPoint()) {

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

} 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, camera);

}

} else {

// We have to iterate children points, because we can select entities 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, camera);

}

}

}

for(Constraint *c : constraints) {

std::vector<Vector> refs;

c->GetReferencePoints(camera, &refs);

for(const Vector &p : refs) {

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

}

}

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[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, camera);

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

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

}

if(!includeMesh) return;

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

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

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

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

}

}

if(!window) return;

scale = ZoomToFit(GetCamera(), includingInvisibles, useSelection);

bool includingInvisibles, bool useSelection) {

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[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,

camera);

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

double scale;

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

scale = 5;

} else {

double scalex = 1e12, scaley = 1e12;

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

if(EXACT(dy != 0)) scaley = 0.9*camera.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,

camera);

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

if(wmin < 0.1) {

double k = camera.tangent;

// 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));

}

return scale;

double offsetRight = offset.Dot(projRight);

double offsetUp = offset.Dot(projUp);

double width, height;

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

double righti = currentMousePosition.x / scale - offsetRight;

double upi = currentMousePosition.y / scale - offsetUp;

// zoomMultiplyer of 1 gives a default zoom factor of 1.2x: zoomMultiplyer * 1.2

// zoom = adjusted zoom negative zoomMultiplyer will zoom out, positive will zoom in

//

scale *= exp(0.1823216 * zoomMultiplyer); // ln(1.2) = 0.1823216

double rightf = currentMousePosition.x / scale - offsetRight;

double upf = currentMousePosition.y / scale - offsetUp;

offset = offset.Plus(projRight.ScaledBy(rightf - righti));

offset = offset.Plus(projUp.ScaledBy(upf - upi));

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

if(havePainted) {

SS.ScheduleShowTW();

}

}

havePainted = false;

Invalidate();

switch(id) {

case Command::ZOOM_IN:

SS.GW.ZoomToMouse(1);

break;

case Command::ZOOM_OUT:

SS.GW.ZoomToMouse(-1);

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;

SS.GW.EnsureValidActives();

SS.GW.Invalidate();

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

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

}

break;

case Command::DIM_SOLID_MODEL:

SS.GW.dimSolidModel = !SS.GW.dimSolidModel;

SS.GW.EnsureValidActives();

SS.GW.Invalidate(/*clearPersistent=*/true);

break;

case Command::PERSPECTIVE_PROJ:

SS.usePerspectiveProj = !SS.usePerspectiveProj;

SS.GW.EnsureValidActives();

SS.GW.Invalidate();

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."));

}

break;

case Command::EXPLODE_SKETCH:

SS.explode = !SS.explode;

SS.GW.EnsureValidActives();

SS.MarkGroupDirty(SS.GW.activeGroup, true);

break;

case Command::ONTO_WORKPLANE:

if(SS.GW.LockedInWorkplane()) {

SS.GW.AnimateOntoWorkplane();

break;

} // if not in 2d mode use ORTHO logic

// fallthrough

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), if all are

// allowed. If the user is in turn-table mode, the

// isometric view must have the z-axis facing up, leaving

// 8 possible views (2*1*2*2).

bool require_turntable = (id==Command::NEAREST_ISO && SS.turntableNav);

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

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

if(i == j) continue;

if(require_turntable && (j!=2)) continue;

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

for(int 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.ClearSelection();

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

} 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_FEET_INCHES:

SS.viewUnits = Unit::FEET_INCHES;

SS.ScheduleShowTW();

SS.GW.EnsureValidActives();

break;

case Command::UNITS_MM:

SS.viewUnits = Unit::MM;

SS.ScheduleShowTW();

SS.GW.EnsureValidActives();

break;

case Command::UNITS_METERS:

SS.viewUnits = Unit::METERS;

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 == Group::HGROUP_REFERENCES)) {

// Not using range-for because this is used to find an index.

int i;

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

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

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[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 != activeGroup && 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;

}

}

if(!window) return;

// 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::METERS:

case Unit::INCHES:

case Unit::FEET_INCHES:

break;

default:

SS.viewUnits = Unit::MM;

break;