Entity *p = SK.GetEntity(hp);

Vector pos = p->PointGetNum();

UpdateDraggedNum(&pos, mx, my);

p->PointForceTo(pos);

Entity *p = SK.GetEntity(hp);

// If an entity and its points are both selected, then its points could

// end up in the list twice. This would be bad, because it would move

// twice as far as the mouse pointer...

List<hEntity> *lhe = &(pending.points);

for(hEntity *hee = lhe->First(); hee; hee = lhe->NextAfter(hee)) {

if(*hee == hp) {

// Exact same point.

return;

}

Entity *pe = SK.GetEntity(*hee);

if(pe->type == p->type &&

pe->type != Entity::Type::POINT_IN_2D &&

pe->type != Entity::Type::POINT_IN_3D &&

pe->group == p->group)

{

// Transform-type point, from the same group. So it handles the

// same unknowns.

return;

}

}

pending.points.Add(&hp);

Entity *e = SK.GetEntity(he);

if(e->IsPoint()) {

AddPointToDraggedList(e->h);

} else if(e->type == Entity::Type::LINE_SEGMENT ||

e->type == Entity::Type::ARC_OF_CIRCLE ||

e->type == Entity::Type::CUBIC ||

e->type == Entity::Type::CUBIC_PERIODIC ||

e->type == Entity::Type::CIRCLE ||

e->type == Entity::Type::TTF_TEXT ||

e->type == Entity::Type::IMAGE)

{

int pts;

EntReqTable::GetEntityInfo(e->type, e->extraPoints,

NULL, &pts, NULL, NULL);

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

AddPointToDraggedList(e->point[i]);

}

}

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

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

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

StartDraggingByEntity(s->entity);

}

// The user might select a point, and then click it again to start

// dragging; but the point just got unselected by that click. So drag

// the hovered item too, and they'll always have it.

if(hover.entity.v) {

hEntity dragEntity = ChooseFromHoverToDrag().entity;

if(dragEntity != Entity::NO_ENTITY) {

StartDraggingByEntity(dragEntity);

}

}

bool middleDown, bool rightDown, bool shiftDown, bool ctrlDown)

{

if(window->IsEditorVisible()) return;

if(context.active) return;

SS.extraLine.draw = false;

if(!orig.mouseDown) {

// If someone drags the mouse into our window with the left button

// already depressed, then we don't have our starting point; so

// don't try.

leftDown = false;

}

if(rightDown) {

middleDown = true;

shiftDown = !shiftDown;

}

if(SS.showToolbar) {

if(ToolbarMouseMoved((int)x, (int)y)) {

hover.Clear();

return;

}

}

if(!leftDown && (pending.operation == Pending::DRAGGING_POINTS ||

pending.operation == Pending::DRAGGING_MARQUEE))

{

ClearPending();

Invalidate();

}

Point2d mp = Point2d::From(x, y);

currentMousePosition = mp;

if(rightDown && orig.mouse.DistanceTo(mp) < 5 && !orig.startedMoving) {

// Avoid accidentally panning (or rotating if shift is down) if the

// user wants a context menu.

return;

}

orig.startedMoving = true;

// If the middle button is down, then mouse movement is used to pan and

// rotate our view. This wins over everything else.

if(middleDown) {

hover.Clear();

double dx = (x - orig.mouse.x) / scale;

double dy = (y - orig.mouse.y) / scale;

if(!(shiftDown || ctrlDown)) {

double s = 0.3*(PI/180)*scale; // degrees per pixel

if(SS.turntableNav) { // lock the Z to vertical

projRight = orig.projRight.RotatedAbout(Vector::From(0, 0, 1), -s * dx);

projUp = orig.projUp.RotatedAbout(

Vector::From(orig.projRight.x, orig.projRight.y, orig.projRight.y), s * dy);

} else {

projRight = orig.projRight.RotatedAbout(orig.projUp, -s * dx);

projUp = orig.projUp.RotatedAbout(orig.projRight, s * dy);

}

NormalizeProjectionVectors();

} else if(ctrlDown) {

double theta = atan2(orig.mouse.y, orig.mouse.x);

theta -= atan2(y, x);

SS.extraLine.draw = true;

SS.extraLine.ptA = UnProjectPoint(Point2d::From(0, 0));

SS.extraLine.ptB = UnProjectPoint(mp);

Vector normal = orig.projRight.Cross(orig.projUp);

projRight = orig.projRight.RotatedAbout(normal, theta);

projUp = orig.projUp.RotatedAbout(normal, theta);

NormalizeProjectionVectors();

} else {

offset.x = orig.offset.x + dx*projRight.x + dy*projUp.x;

offset.y = orig.offset.y + dx*projRight.y + dy*projUp.y;

offset.z = orig.offset.z + dx*projRight.z + dy*projUp.z;

}

orig.projRight = projRight;

orig.projUp = projUp;

orig.offset = offset;

orig.mouse.x = x;

orig.mouse.y = y;

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

if(havePainted) {

SS.ScheduleShowTW();

}

}

Invalidate();

havePainted = false;

return;

}

if(pending.operation == Pending::NONE) {

double dm = orig.mouse.DistanceTo(mp);

// If we're currently not doing anything, then see if we should

// start dragging something.

if(leftDown && dm > 3) {

Entity *e = NULL;

hEntity dragEntity = ChooseFromHoverToDrag().entity;

if(dragEntity.v) e = SK.GetEntity(dragEntity);

if(e && e->type != Entity::Type::WORKPLANE) {

Entity *e = SK.GetEntity(dragEntity);

if(e->type == Entity::Type::CIRCLE && selection.n <= 1) {

// Drag the radius.

ClearSelection();

pending.circle = dragEntity;

pending.operation = Pending::DRAGGING_RADIUS;

} else if(e->IsNormal()) {

ClearSelection();

pending.normal = dragEntity;

pending.operation = Pending::DRAGGING_NORMAL;

} else {

if(!hoverWasSelectedOnMousedown) {

// The user clicked an unselected entity, which

// means they're dragging just the hovered thing,

// not the full selection. So clear all the selection

// except that entity.

ClearSelection();

MakeSelected(e->h);

}

StartDraggingBySelection();

if(!hoverWasSelectedOnMousedown) {

// And then clear the selection again, since they

// probably didn't want that selected if they just

// were dragging it.

ClearSelection();

}

hover.Clear();

pending.operation = Pending::DRAGGING_POINTS;

}

} else if(hover.constraint.v &&

SK.GetConstraint(hover.constraint)->HasLabel())

{

ClearSelection();

pending.constraint = hover.constraint;

pending.operation = Pending::DRAGGING_CONSTRAINT;

}

if(pending.operation != Pending::NONE) {

// We just started a drag, so remember for the undo before

// the drag changes anything.

SS.UndoRemember();

} else {

if(!hover.constraint.v) {

// That's just marquee selection, which should not cause

// an undo remember.

if(dm > 10) {

if(hover.entity.v) {

// Avoid accidentally selecting workplanes when

// starting drags.

MakeUnselected(hover.entity, /*coincidentPointTrick=*/false);

hover.Clear();

}

pending.operation = Pending::DRAGGING_MARQUEE;

orig.marqueePoint =

UnProjectPoint(orig.mouseOnButtonDown);

}

}

}

} else {

// Otherwise, just hit test and give up; but don't hit test

// if the mouse is down, because then the user could hover

// a point, mouse down (thus selecting it), and drag, in an

// effort to drag the point, but instead hover a different

// entity before we move far enough to start the drag.

if(!leftDown) {

// Hit testing can potentially take a lot of time.

// If we haven't painted since last time we highlighted

// something, don't hit test again, since this just causes

// a lag.

if(!havePainted) return;

HitTestMakeSelection(mp);

}

}

return;

}

// If the user has started an operation from the menu, but not

// completed it, then just do the selection.

if(pending.operation == Pending::COMMAND) {

HitTestMakeSelection(mp);

return;

}

// We're currently dragging something; so do that. But if we haven't

// painted since the last time we solved, do nothing, because there's

// no sense solving a frame and not displaying it.

if(!havePainted) {

if(pending.operation == Pending::DRAGGING_POINTS && ctrlDown) {

SS.extraLine.ptA = UnProjectPoint(orig.mouseOnButtonDown);

SS.extraLine.ptB = UnProjectPoint(mp);

SS.extraLine.draw = true;

}

return;

}

havePainted = false;

switch(pending.operation) {

case Pending::DRAGGING_CONSTRAINT: {

Constraint *c = SK.constraint.FindById(pending.constraint);

UpdateDraggedNum(&(c->disp.offset), x, y);

orig.mouse = mp;

Invalidate();

return;

}

case Pending::DRAGGING_NEW_LINE_POINT:

if(!ctrlDown) {

SS.GW.pending.hasSuggestion =

SS.GW.SuggestLineConstraint(SS.GW.pending.request, &SS.GW.pending.suggestion);

} else {

SS.GW.pending.hasSuggestion = false;

}

// fallthrough

case Pending::DRAGGING_NEW_POINT:

UpdateDraggedPoint(pending.point, x, y);

HitTestMakeSelection(mp);

SS.MarkGroupDirtyByEntity(pending.point);

orig.mouse = mp;

Invalidate();

break;

case Pending::DRAGGING_POINTS:

if(shiftDown || ctrlDown) {

// Edit the rotation associated with a POINT_N_ROT_TRANS,

// either within (ctrlDown) or out of (shiftDown) the plane

// of the screen. So first get the rotation to apply, in qt.

Quaternion qt;

if(ctrlDown) {

double d = mp.DistanceTo(orig.mouseOnButtonDown);

if(d < 25) {

// Don't start dragging the position about the normal

// until we're a little ways out, to get a reasonable

// reference pos

orig.mouse = mp;

break;

}

double theta = atan2(orig.mouse.y-orig.mouseOnButtonDown.y,

orig.mouse.x-orig.mouseOnButtonDown.x);

theta -= atan2(y-orig.mouseOnButtonDown.y,

x-orig.mouseOnButtonDown.x);

Vector gn = projRight.Cross(projUp);

qt = Quaternion::From(gn, -theta);

SS.extraLine.draw = true;

SS.extraLine.ptA = UnProjectPoint(orig.mouseOnButtonDown);

SS.extraLine.ptB = UnProjectPoint(mp);

} else {

double dx = -(x - orig.mouse.x);

double dy = -(y - orig.mouse.y);

double s = 0.3*(PI/180); // degrees per pixel

qt = Quaternion::From(projUp, -s*dx).Times(

Quaternion::From(projRight, s*dy));

}

orig.mouse = mp;

// Now apply this rotation to the points being dragged.

List<hEntity> *lhe = &(pending.points);

for(hEntity *he = lhe->First(); he; he = lhe->NextAfter(he)) {

Entity *e = SK.GetEntity(*he);

if(e->type != Entity::Type::POINT_N_ROT_TRANS) {

if(ctrlDown) {

Vector p = e->PointGetNum();

p = p.Minus(SS.extraLine.ptA);

p = qt.Rotate(p);

p = p.Plus(SS.extraLine.ptA);

e->PointForceTo(p);

SS.MarkGroupDirtyByEntity(e->h);

}

continue;

}

Quaternion q = e->PointGetQuaternion();

Vector p = e->PointGetNum();

q = qt.Times(q);

e->PointForceQuaternionTo(q);

// Let's rotate about the selected point; so fix up the

// translation so that that point didn't move.

e->PointForceTo(p);

SS.MarkGroupDirtyByEntity(e->h);

}

} else {

List<hEntity> *lhe = &(pending.points);

for(hEntity *he = lhe->First(); he; he = lhe->NextAfter(he)) {

UpdateDraggedPoint(*he, x, y);

SS.MarkGroupDirtyByEntity(*he);

}

orig.mouse = mp;

}

break;

case Pending::DRAGGING_NEW_CUBIC_POINT: {

UpdateDraggedPoint(pending.point, x, y);

HitTestMakeSelection(mp);

hRequest hr = pending.point.request();

if(pending.point == hr.entity(4)) {

// The very first segment; dragging final point drags both

// tangent points.

Vector p0 = SK.GetEntity(hr.entity(1))->PointGetNum(),

p3 = SK.GetEntity(hr.entity(4))->PointGetNum(),

p1 = p0.ScaledBy(2.0/3).Plus(p3.ScaledBy(1.0/3)),

p2 = p0.ScaledBy(1.0/3).Plus(p3.ScaledBy(2.0/3));

SK.GetEntity(hr.entity(1+1))->PointForceTo(p1);

SK.GetEntity(hr.entity(1+2))->PointForceTo(p2);

} else {

// A subsequent segment; dragging point drags only final

// tangent point.

int i = SK.GetEntity(hr.entity(0))->extraPoints;

Vector pn = SK.GetEntity(hr.entity(4+i))->PointGetNum(),

pnm2 = SK.GetEntity(hr.entity(2+i))->PointGetNum(),

pnm1 = (pn.Plus(pnm2)).ScaledBy(0.5);

SK.GetEntity(hr.entity(3+i))->PointForceTo(pnm1);

}

orig.mouse = mp;

SS.MarkGroupDirtyByEntity(pending.point);

break;

}

case Pending::DRAGGING_NEW_ARC_POINT: {

UpdateDraggedPoint(pending.point, x, y);

HitTestMakeSelection(mp);

hRequest hr = pending.point.request();

Vector ona = SK.GetEntity(hr.entity(2))->PointGetNum();

Vector onb = SK.GetEntity(hr.entity(3))->PointGetNum();

Vector center = (ona.Plus(onb)).ScaledBy(0.5);

SK.GetEntity(hr.entity(1))->PointForceTo(center);

orig.mouse = mp;

SS.MarkGroupDirtyByEntity(pending.point);

break;

}

case Pending::DRAGGING_NEW_RADIUS:

case Pending::DRAGGING_RADIUS: {

Entity *circle = SK.GetEntity(pending.circle);

Vector center = SK.GetEntity(circle->point[0])->PointGetNum();

Point2d c2 = ProjectPoint(center);

double r = c2.DistanceTo(mp)/scale;

SK.GetEntity(circle->distance)->DistanceForceTo(r);

SS.MarkGroupDirtyByEntity(pending.circle);

break;

}

case Pending::DRAGGING_NORMAL: {

Entity *normal = SK.GetEntity(pending.normal);

Vector p = SK.GetEntity(normal->point[0])->PointGetNum();

Point2d p2 = ProjectPoint(p);

Quaternion q = normal->NormalGetNum();

Vector u = q.RotationU(), v = q.RotationV();

if(ctrlDown) {

double theta = atan2(orig.mouse.y-p2.y, orig.mouse.x-p2.x);

theta -= atan2(y-p2.y, x-p2.x);

Vector normal = projRight.Cross(projUp);

u = u.RotatedAbout(normal, -theta);

v = v.RotatedAbout(normal, -theta);

} else {

double dx = -(x - orig.mouse.x);

double dy = -(y - orig.mouse.y);

double s = 0.3*(PI/180); // degrees per pixel

u = u.RotatedAbout(projUp, -s*dx);

u = u.RotatedAbout(projRight, s*dy);

v = v.RotatedAbout(projUp, -s*dx);

v = v.RotatedAbout(projRight, s*dy);

}

orig.mouse = mp;

normal->NormalForceTo(Quaternion::From(u, v));

SS.MarkGroupDirtyByEntity(pending.normal);

break;

}

case Pending::DRAGGING_MARQUEE:

orig.mouse = mp;

Invalidate();

return;

case Pending::NONE:

case Pending::COMMAND:

ssassert(false, "Unexpected pending operation");

}

pending.points.Clear();

pending.requests.Clear();

pending = {};

if(scheduleShowTW) {

SS.ScheduleShowTW();

}

for(auto &req : pending.requests) {

if(req == r) return true;

}

return false;

for(auto &req : pending.requests) {

if(req == before) {

req = after;

}

}

if(window->IsEditorVisible()) return;

orig.offset = offset;

orig.projUp = projUp;

orig.projRight = projRight;

orig.mouse.x = x;

orig.mouse.y = y;

orig.startedMoving = false;

SS.extraLine.draw = false;

Invalidate();

// Don't show a context menu if the user is right-clicking the toolbar,

// or if they are finishing a pan.

if(ToolbarMouseMoved((int)x, (int)y)) return;

if(orig.startedMoving) return;

if(context.active) return;

if(pending.operation == Pending::DRAGGING_NEW_LINE_POINT && pending.hasSuggestion) {

Constraint::TryConstrain(SS.GW.pending.suggestion,

Entity::NO_ENTITY, Entity::NO_ENTITY, pending.request.entity(0));

}

if(pending.operation == Pending::DRAGGING_NEW_LINE_POINT ||

pending.operation == Pending::DRAGGING_NEW_CUBIC_POINT)

{

// Special case; use a right click to stop drawing lines, since

// a left click would draw another one. This is quicker and more

// intuitive than hitting escape. Likewise for new cubic segments.

ClearPending();

return;

}

// The current mouse location

Vector v = offset.ScaledBy(-1);

v = v.Plus(projRight.ScaledBy(x/scale));

v = v.Plus(projUp.ScaledBy(y/scale));

Platform::MenuRef menu = Platform::CreateMenu();

context.active = true;

if(!hover.IsEmpty()) {

MakeSelected(&hover);

SS.ScheduleShowTW();

}

GroupSelection();

bool itemsSelected = (gs.n > 0 || gs.constraints > 0);

if(itemsSelected) {

if(gs.stylables > 0) {

Platform::MenuRef styleMenu = menu->AddSubMenu(_("Assign to Style"));

bool empty = true;

for(const Style &s : SK.style) {

if(s.h.v < Style::FIRST_CUSTOM) continue;

uint32_t v = s.h.v;

styleMenu->AddItem(s.DescriptionString(), [v]() {

Style::AssignSelectionToStyle(v);

});

empty = false;

}

if(!empty) styleMenu->AddSeparator();

styleMenu->AddItem(_("No Style"), []() {

Style::AssignSelectionToStyle(0);

});

styleMenu->AddItem(_("Newly Created Custom Style..."), [this]() {

uint32_t vs = Style::CreateCustomStyle();

Style::AssignSelectionToStyle(vs);

ForceTextWindowShown();

});

}

if(gs.n + gs.constraints == 1) {

menu->AddItem(_("Group Info"), [this]() {

hGroup hg;

if(gs.entities == 1) {

hg = SK.GetEntity(gs.entity[0])->group;

} else if(gs.points == 1) {

hg = SK.GetEntity(gs.point[0])->group;

} else if(gs.constraints == 1) {

hg = SK.GetConstraint(gs.constraint[0])->group;

} else {

return;

}

ClearSelection();

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

SS.TW.shown.group = hg;

SS.ScheduleShowTW();

ForceTextWindowShown();

});

}

if(gs.n + gs.constraints == 1 && gs.stylables == 1) {

menu->AddItem(_("Style Info"), [this]() {

hStyle hs;

if(gs.entities == 1) {

hs = Style::ForEntity(gs.entity[0]);

} else if(gs.points == 1) {

hs = Style::ForEntity(gs.point[0]);

} else if(gs.constraints == 1) {

hs = SK.GetConstraint(gs.constraint[0])->GetStyle();

} else {

return;

}

ClearSelection();

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

SS.TW.shown.style = hs;

SS.ScheduleShowTW();

ForceTextWindowShown();

});

}

if(gs.withEndpoints > 0) {

menu->AddItem(_("Select Edge Chain"),

[this]() { MenuEdit(Command::SELECT_CHAIN); });

}

if(gs.constraints == 1 && gs.n == 0) {

Constraint *c = SK.GetConstraint(gs.constraint[0]);

if(c->HasLabel() && c->type != Constraint::Type::COMMENT) {

menu->AddItem(_("Toggle Reference Dimension"),

[]() { Constraint::MenuConstrain(Command::REFERENCE); });

}

if(c->type == Constraint::Type::ANGLE ||

c->type == Constraint::Type::EQUAL_ANGLE)

{

menu->AddItem(_("Other Supplementary Angle"),

[]() { Constraint::MenuConstrain(Command::OTHER_ANGLE); });

}

}

if(gs.constraintLabels > 0 || gs.points > 0) {

menu->AddItem(_("Snap to Grid"),

[this]() { MenuEdit(Command::SNAP_TO_GRID); });

}

if(gs.points == 1 && gs.point[0].isFromRequest()) {

Request *r = SK.GetRequest(gs.point[0].request());

int index = r->IndexOfPoint(gs.point[0]);

if((r->type == Request::Type::CUBIC && (index > 1 && index < r->extraPoints + 2)) ||

r->type == Request::Type::CUBIC_PERIODIC) {

menu->AddItem(_("Remove Spline Point"), [this, r]() {

int index = r->IndexOfPoint(gs.point[0]);

ssassert(r->extraPoints != 0,

"Expected a bezier with interior control points");

SS.UndoRemember();

Entity *e = SK.GetEntity(r->h.entity(0));

// First, fix point-coincident constraints involving this point.

// Then, remove all other constraints, since they would otherwise

// jump to an adjacent one and mess up the bezier after generation.

FixConstraintsForPointBeingDeleted(e->point[index]);

RemoveConstraintsForPointBeingDeleted(e->point[index]);

for(int i = index; i < MAX_POINTS_IN_ENTITY - 1; i++) {

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

Entity *p0 = SK.GetEntity(e->point[i]);

Entity *p1 = SK.GetEntity(e->point[i + 1]);

ReplacePointInConstraints(p1->h, p0->h);

p0->PointForceTo(p1->PointGetNum());

}

r->extraPoints--;

SS.MarkGroupDirtyByEntity(gs.point[0]);

ClearSelection();

});

}

}

if(gs.entities == 1 && gs.entity[0].isFromRequest()) {

Request *r = SK.GetRequest(gs.entity[0].request());

if(r->type == Request::Type::CUBIC || r->type == Request::Type::CUBIC_PERIODIC) {

Entity *e = SK.GetEntity(gs.entity[0]);

int addAfterPoint = e->GetPositionOfPoint(GetCamera(), Point2d::From(x, y));

ssassert(addAfterPoint != -1, "Expected a nearest bezier point to be located");

// Skip derivative point.

if(r->type == Request::Type::CUBIC) addAfterPoint++;

menu->AddItem(_("Add Spline Point"), [this, r, addAfterPoint, v]() {

int pointCount = r->extraPoints +

((r->type == Request::Type::CUBIC_PERIODIC) ? 3 : 4);

if(pointCount >= MAX_POINTS_IN_ENTITY) {

Error(_("Cannot add spline point: maximum number of points reached."));

return;

}

SS.UndoRemember();

r->extraPoints++;

SS.MarkGroupDirtyByEntity(gs.entity[0]);

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

Entity *e = SK.GetEntity(r->h.entity(0));

for(int i = MAX_POINTS_IN_ENTITY; i > addAfterPoint + 1; i--) {

Entity *p0 = SK.entity.FindByIdNoOops(e->point[i]);

if(p0 == NULL) continue;

Entity *p1 = SK.GetEntity(e->point[i - 1]);

ReplacePointInConstraints(p1->h, p0->h);

p0->PointForceTo(p1->PointGetNum());

}

Entity *p = SK.GetEntity(e->point[addAfterPoint + 1]);

p->PointForceTo(v);

SS.MarkGroupDirtyByEntity(gs.entity[0]);

ClearSelection();

});

}

}

if(gs.entities == gs.n) {

menu->AddItem(_("Toggle Construction"),

[this]() { MenuRequest(Command::CONSTRUCTION); });

}

if(gs.points == 1) {

Entity *p = SK.GetEntity(gs.point[0]);

Constraint *c;

IdList<Constraint,hConstraint> *lc = &(SK.constraint);

for(c = lc->First(); c; c = lc->NextAfter(c)) {

if(c->type != Constraint::Type::POINTS_COINCIDENT) continue;

if(c->ptA == p->h || c->ptB == p->h) {

break;

}

}

if(c) {

menu->AddItem(_("Delete Point-Coincident Constraint"), [this, p]() {

if(!p->IsPoint()) return;

SS.UndoRemember();

SK.constraint.ClearTags();

Constraint *c;

for(c = SK.constraint.First(); c; c = SK.constraint.NextAfter(c)) {

if(c->type != Constraint::Type::POINTS_COINCIDENT) continue;

if(c->ptA == p->h || c->ptB == p->h) {

c->tag = 1;

}

}

SK.constraint.RemoveTagged();

ClearSelection();

});

}

}

menu->AddSeparator();

if(LockedInWorkplane()) {

menu->AddItem(_("Cut"),

[this]() { MenuClipboard(Command::CUT); });

menu->AddItem(_("Copy"),

[this]() { MenuClipboard(Command::COPY); });

}

} else {

menu->AddItem(_("Select All"),

[this]() { MenuEdit(Command::SELECT_ALL); });

}

if((!SS.clipboard.r.IsEmpty() || !SS.clipboard.c.IsEmpty()) && LockedInWorkplane()) {

menu->AddItem(_("Paste"),

[this]() { MenuClipboard(Command::PASTE); });

menu->AddItem(_("Paste Transformed..."),

[this]() { MenuClipboard(Command::PASTE_TRANSFORM); });

}

if(itemsSelected) {

menu->AddItem(_("Delete"),

[this]() { MenuClipboard(Command::DELETE); });

menu->AddSeparator();

menu->AddItem(_("Unselect All"),

[this]() { MenuEdit(Command::UNSELECT_ALL); });

}

// If only one item is selected, then it must be the one that we just

// selected from the hovered item; in which case unselect all and hovered

// are equivalent.

if(!hover.IsEmpty() && selection.n > 1) {

menu->AddItem(_("Unselect Hovered"), [this] {

if(!hover.IsEmpty()) {

MakeUnselected(&hover, /*coincidentPointTrick=*/true);

}

});

}

if(itemsSelected) {

menu->AddSeparator();

menu->AddItem(_("Zoom to Fit"),

[this]() { MenuView(Command::ZOOM_TO_FIT); });

}

menu->PopUp();

context.active = false;

SS.ScheduleShowTW();

if(rememberForUndo) SS.UndoRemember();

Request r = {};

r.group = activeGroup;

Group *g = SK.GetGroup(activeGroup);

if(g->type == Group::Type::DRAWING_3D || g->type == Group::Type::DRAWING_WORKPLANE) {

r.construction = false;

} else {

r.construction = true;

}

r.workplane = ActiveWorkplane();

r.type = type;

SK.request.AddAndAssignId(&r);

// We must regenerate the parameters, so that the code that tries to

// place this request's entities where the mouse is can do so. But

// we mustn't try to solve until reasonable values have been supplied

// for these new parameters, or else we'll get a numerical blowup.

r.Generate(&SK.entity, &SK.param);

SS.MarkGroupDirty(r.group);

return r.h;

Entity *e = SK.GetEntity(he);

if(e->IsPoint()) return e->PointGetNum();

SEdgeList *edges = e->GetOrGenerateEdges();

double minD = -1.0f;

double k;

const SEdge *edge = NULL;

for(const auto &e : edges->l) {

Point2d p0 = ProjectPoint(e.a);

Point2d p1 = ProjectPoint(e.b);

Point2d dir = p1.Minus(p0);

double d = pp.DistanceToLine(p0, dir, /*asSegment=*/true);

if(minD > 0.0 && d > minD) continue;

minD = d;

k = pp.Minus(p0).Dot(dir) / dir.Dot(dir);

edge = &e;

}

if(edge == NULL) return UnProjectPoint(pp);

return edge->a.Plus(edge->b.Minus(edge->a).ScaledBy(k));

if(!hover.entity.v) return false;

Entity *point = SK.GetEntity(pt);

Entity *e = SK.GetEntity(hover.entity);

if(e->IsPoint()) {

point->PointForceTo(e->PointGetNum());

Constraint::ConstrainCoincident(e->h, pt);

return true;

}

if(e->IsCircle()) {

if(projected != NULL) {

Vector snapPos = SnapToEntityByScreenPoint(*projected, e->h);

point->PointForceTo(snapPos);

}

Constraint::Constrain(Constraint::Type::PT_ON_CIRCLE,

pt, Entity::NO_ENTITY, e->h);

return true;

}

if(e->type == Entity::Type::LINE_SEGMENT) {

if(projected != NULL) {

Vector snapPos = SnapToEntityByScreenPoint(*projected, e->h);

point->PointForceTo(snapPos);

}

Constraint::Constrain(Constraint::Type::PT_ON_LINE,

pt, Entity::NO_ENTITY, e->h);

return true;

}

return false;

using Platform::MouseEvent;

double width, height;

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

event.x = event.x - width / 2;

event.y = height / 2 - event.y;

switch(event.type) {

case MouseEvent::Type::MOTION:

this->MouseMoved(event.x, event.y,

event.button == MouseEvent::Button::LEFT,

event.button == MouseEvent::Button::MIDDLE,

event.button == MouseEvent::Button::RIGHT,

event.shiftDown,

event.controlDown);

break;

case MouseEvent::Type::PRESS:

if(event.button == MouseEvent::Button::LEFT) {

this->MouseLeftDown(event.x, event.y, event.shiftDown, event.controlDown);

} else if(event.button == MouseEvent::Button::MIDDLE ||

event.button == MouseEvent::Button::RIGHT) {

this->MouseMiddleOrRightDown(event.x, event.y);

}

break;

case MouseEvent::Type::DBL_PRESS:

if(event.button == MouseEvent::Button::LEFT) {

this->MouseLeftDoubleClick(event.x, event.y);

}

break;

case MouseEvent::Type::RELEASE:

if(event.button == MouseEvent::Button::LEFT) {

this->MouseLeftUp(event.x, event.y, event.shiftDown, event.controlDown);

} else if(event.button == MouseEvent::Button::RIGHT) {

this->MouseRightUp(event.x, event.y);

}

break;

case MouseEvent::Type::SCROLL_VERT:

this->MouseScroll(event.x, event.y, (int)event.scrollDelta);

break;

case MouseEvent::Type::LEAVE:

this->MouseLeave();

break;

}

return true;

orig.mouseDown = true;

if(window->IsEditorVisible()) {

orig.mouse = Point2d::From(mx, my);

orig.mouseOnButtonDown = orig.mouse;

window->HideEditor();

return;

}

SS.TW.HideEditControl();

if(SS.showToolbar) {

if(ToolbarMouseDown((int)mx, (int)my)) return;

}

// This will be clobbered by MouseMoved below.

bool hasConstraintSuggestion = pending.hasSuggestion;

Constraint::Type constraintSuggestion = pending.suggestion;

// Make sure the hover is up to date.

MouseMoved(mx, my, /*leftDown=*/false, /*middleDown=*/false, /*rightDown=*/false,

/*shiftDown=*/false, /*ctrlDown=*/false);

orig.mouse.x = mx;

orig.mouse.y = my;

orig.mouseOnButtonDown = orig.mouse;

Point2d mouse = Point2d::From(mx, my);

// The current mouse location

Vector v = offset.ScaledBy(-1);

v = v.Plus(projRight.ScaledBy(mx/scale));

v = v.Plus(projUp.ScaledBy(my/scale));

hRequest hr = {};

hConstraint hc = {};

switch(pending.operation) {

case Pending::COMMAND:

switch(pending.command) {

case Command::DATUM_POINT:

hr = AddRequest(Request::Type::DATUM_POINT);

SK.GetEntity(hr.entity(0))->PointForceTo(v);

ConstrainPointByHovered(hr.entity(0), &mouse);

ClearSuper();

break;

case Command::LINE_SEGMENT:

case Command::CONSTR_SEGMENT:

hr = AddRequest(Request::Type::LINE_SEGMENT);

SK.GetRequest(hr)->construction = (pending.command == Command::CONSTR_SEGMENT);

SK.GetEntity(hr.entity(1))->PointForceTo(v);

ConstrainPointByHovered(hr.entity(1), &mouse);

ClearSuper();

AddToPending(hr);

pending.operation = Pending::DRAGGING_NEW_LINE_POINT;

pending.request = hr;

pending.point = hr.entity(2);

pending.description = _("click next point of line, or press Esc");

SK.GetEntity(pending.point)->PointForceTo(v);

break;

case Command::RECTANGLE: {

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

Error(_("Can't draw rectangle in 3d; first, activate a workplane "

"with Sketch -> In Workplane."));

ClearSuper();

break;

}