zcy
/
solvespace
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
solvespace/src/mouse.cpp

1538 lines
56 KiB
C++
Raw Normal View History

Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
//-----------------------------------------------------------------------------
// Anything relating to mouse, keyboard, or 6-DOF mouse input.
Changes in preparation for the release of SolveSpace under the GPL, to add that license, and change all copyright notices to me, not Useful Subset, LLC. [git-p4: depot-paths = "//depot/solvespace/": change = 2211]
2013-07-28 22:08:34 +00:00
//
// Copyright 2008-2013 Jonathan Westhues.
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
//-----------------------------------------------------------------------------
#include "solvespace.h"
void GraphicsWindow::UpdateDraggedPoint(hEntity hp, double mx, double my) {
Entity *p = SK.GetEntity(hp);
Vector pos = p->PointGetNum();
UpdateDraggedNum(&pos, mx, my);
p->PointForceTo(pos);
}
void GraphicsWindow::UpdateDraggedNum(Vector *pos, double mx, double my) {
*pos = pos->Plus(projRight.ScaledBy((mx - orig.mouse.x)/scale));
*pos = pos->Plus(projUp.ScaledBy((my - orig.mouse.y)/scale));
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
}
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
void GraphicsWindow::AddPointToDraggedList(hEntity hp) {
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->v == hp.v) {
// Exact same point.
return;
}
Entity *pe = SK.GetEntity(*hee);
if(pe->type == p->type &&
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
pe->type != Entity::Type::POINT_IN_2D &&
pe->type != Entity::Type::POINT_IN_3D &&
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
pe->group.v == p->group.v)
{
// Transform-type point, from the same group. So it handles the
// same unknowns.
return;
}
}
pending.points.Add(&hp);
}
void GraphicsWindow::StartDraggingByEntity(hEntity he) {
Entity *e = SK.GetEntity(he);
if(e->IsPoint()) {
AddPointToDraggedList(e->h);
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
} 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)
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
{
int pts;
Trim trailing whitespace.
2015-03-29 00:30:52 +00:00
EntReqTable::GetEntityInfo(e->type, e->extraPoints,
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
NULL, &pts, NULL, NULL);
for(int i = 0; i < pts; i++) {
AddPointToDraggedList(e->point[i]);
}
}
}
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void GraphicsWindow::StartDraggingBySelection() {
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
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.
Choose entities to select in a way appropriate for the operation. Before this commit, when an entity is clicked at or dragged, and it shares a place with other entities, which of them is selected is decided more or less at random. This is particularly annoying when dragging. After this commit, when clicking, an entity from the current group is given preference, and when dragging, an entity from a request is given preference. This allows e.g. dragging points of a sketch even when an extrusion of that sketch is active.
2016-07-21 17:58:18 +00:00
if(hover.entity.v) StartDraggingByEntity(ChooseFromHoverToDrag().entity);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
}
void GraphicsWindow::MouseMoved(double x, double y, bool leftDown,
bool middleDown, bool rightDown, bool shiftDown, bool ctrlDown)
{
if(GraphicsEditControlIsVisible()) return;
if(context.active) return;
Add a screen to edit the view parameters; scale, translation, rotation. Also clean up the handling of units, by putting the conversion factors in only one place, and clean up the expression-parsing but removing all the copies of the same error message. [git-p4: depot-paths = "//depot/solvespace/": change = 2093]
2010-01-04 00:35:28 +00:00
SS.extraLine.draw = false;
Split cubic splines and periodic splines too; which is a pain, because it can't be C2 continuous after splitting (since I'm doing uniform splines only, and the parametrization changes). So just knock everything down to cubic Beziers. Also draw lines to indicate angle and origin when Ctrl+dragging to rotate in plane of screen. [git-p4: depot-paths = "//depot/solvespace/": change = 2075]
2009-11-10 03:57:24 +00:00
Add ability to set a background image. I import a png with libpng, load it as a texture, and show it instead of a flat-color background. Includes user interface to specify scale and translation of image, but the rotation is always aligned to the view. [git-p4: depot-paths = "//depot/solvespace/": change = 2071]
2009-11-08 01:11:38 +00:00
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;
}
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
if(rightDown) {
middleDown = true;
shiftDown = !shiftDown;
}
if(SS.showToolbar) {
if(ToolbarMouseMoved((int)x, (int)y)) {
hover.Clear();
return;
}
}
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
if(!leftDown && (pending.operation == Pending::DRAGGING_POINTS ||
pending.operation == Pending::DRAGGING_MARQUEE))
Add marquee selection, a view-aligned rectangle such that everything even partially within that rectangle gets selected when I release. Also make deselecting a point deselect all coincident points too; otherwise there now exist ways to select both coincident points, which meant that it was impossible to deselect the lower one. And fix text window to show selection info even if just constraints are selected, seems more consistent. [git-p4: depot-paths = "//depot/solvespace/": change = 2066]
2009-11-04 07:52:58 +00:00
{
A monster change to add support for filled paths. This requires us to assemble Beziers into outer and inner loops, and find those loops made up of entities with filled styles. The open paths are maintained in a separate list, and we assemble as many closed paths as possible even when open paths exist. This changes many things. The coplanar check is now performed on the Beziers, not the resulting polygon. The way that the polygon is used to determine loop directions is also modified. Also fix the mouse behavior when dragging a point: drop it when the mouse is released, even if it is released outside the window, but don't drop it if the pointer is dragged out of and then back into our window. Also special-case SSurface::ClosestPointTo() for planes, for speed. [git-p4: depot-paths = "//depot/solvespace/": change = 2058]
2009-10-29 07:16:28 +00:00
ClearPending();
Add marquee selection, a view-aligned rectangle such that everything even partially within that rectangle gets selected when I release. Also make deselecting a point deselect all coincident points too; otherwise there now exist ways to select both coincident points, which meant that it was impossible to deselect the lower one. And fix text window to show selection info even if just constraints are selected, seems more consistent. [git-p4: depot-paths = "//depot/solvespace/": change = 2066]
2009-11-04 07:52:58 +00:00
InvalidateGraphics();
A monster change to add support for filled paths. This requires us to assemble Beziers into outer and inner loops, and find those loops made up of entities with filled styles. The open paths are maintained in a separate list, and we assemble as many closed paths as possible even when open paths exist. This changes many things. The coplanar check is now performed on the Beziers, not the resulting polygon. The way that the polygon is used to determine loop directions is also modified. Also fix the mouse behavior when dragging a point: drop it when the mouse is released, even if it is released outside the window, but don't drop it if the pointer is dragged out of and then back into our window. Also special-case SSurface::ClosestPointTo() for planes, for speed. [git-p4: depot-paths = "//depot/solvespace/": change = 2058]
2009-10-29 07:16:28 +00:00
}
Add marquee selection, a view-aligned rectangle such that everything even partially within that rectangle gets selected when I release. Also make deselecting a point deselect all coincident points too; otherwise there now exist ways to select both coincident points, which meant that it was impossible to deselect the lower one. And fix text window to show selection info even if just constraints are selected, seems more consistent. [git-p4: depot-paths = "//depot/solvespace/": change = 2066]
2009-11-04 07:52:58 +00:00
Point2d mp = Point2d::From(x, y);
When curves to be split intersect at multiple points, don't just choose arbitrarily. Instead, split at the point closest to the mouse pointer. [git-p4: depot-paths = "//depot/solvespace/": change = 2170]
2010-07-12 06:47:14 +00:00
currentMousePosition = mp;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
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
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);
Add a screen to edit the view parameters; scale, translation, rotation. Also clean up the handling of units, by putting the conversion factors in only one place, and clean up the expression-parsing but removing all the copies of the same error message. [git-p4: depot-paths = "//depot/solvespace/": change = 2093]
2010-01-04 00:35:28 +00:00
SS.extraLine.draw = true;
SS.extraLine.ptA = UnProjectPoint(Point2d::From(0, 0));
SS.extraLine.ptB = UnProjectPoint(mp);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
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;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(SS.TW.shown.screen == TextWindow::Screen::EDIT_VIEW) {
Add a screen to edit the view parameters; scale, translation, rotation. Also clean up the handling of units, by putting the conversion factors in only one place, and clean up the expression-parsing but removing all the copies of the same error message. [git-p4: depot-paths = "//depot/solvespace/": change = 2093]
2010-01-04 00:35:28 +00:00
if(havePainted) {
Add a GTK2/3 port. In principle, GTK3 is the way forward, and GTK2 is officially deprecated, though still maintained. In practice however, GTK3 is often unbearably buggy; e.g. on my system, combo boxes don't ever roll up in GTK3 windows. So I have added support for both. This required a few minor changes to the core, namely: * GTK wants to know beforehand whether a menu item is a check menu item or a regular one. * GTK doesn't give us an easy way to execute something after any event is processed, so an explicit idle timer is added. This is a no-op on Win32. * A few function signatures were const'ed, since GTK expects immutable strings when converting to Glib::ustring.
2015-03-18 17:02:11 +00:00
SS.ScheduleShowTW();
Add a screen to edit the view parameters; scale, translation, rotation. Also clean up the handling of units, by putting the conversion factors in only one place, and clean up the expression-parsing but removing all the copies of the same error message. [git-p4: depot-paths = "//depot/solvespace/": change = 2093]
2010-01-04 00:35:28 +00:00
}
}
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
InvalidateGraphics();
Add a screen to edit the view parameters; scale, translation, rotation. Also clean up the handling of units, by putting the conversion factors in only one place, and clean up the expression-parsing but removing all the copies of the same error message. [git-p4: depot-paths = "//depot/solvespace/": change = 2093]
2010-01-04 00:35:28 +00:00
havePainted = false;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
return;
}
Trim trailing whitespace.
2015-03-29 00:30:52 +00:00
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
if(pending.operation == Pending::NONE) {
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
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) {
Add marquee selection, a view-aligned rectangle such that everything even partially within that rectangle gets selected when I release. Also make deselecting a point deselect all coincident points too; otherwise there now exist ways to select both coincident points, which meant that it was impossible to deselect the lower one. And fix text window to show selection info even if just constraints are selected, seems more consistent. [git-p4: depot-paths = "//depot/solvespace/": change = 2066]
2009-11-04 07:52:58 +00:00
Entity *e = NULL;
if(hover.entity.v) e = SK.GetEntity(hover.entity);
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(e && e->type != Entity::Type::WORKPLANE) {
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Entity *e = SK.GetEntity(hover.entity);
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(e->type == Entity::Type::CIRCLE && selection.n <= 1) {
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
// Drag the radius.
ClearSelection();
pending.circle = hover.entity;
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
pending.operation = Pending::DRAGGING_RADIUS;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
} else if(e->IsNormal()) {
ClearSelection();
pending.normal = hover.entity;
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
pending.operation = Pending::DRAGGING_NORMAL;
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
} else {
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
if(!hoverWasSelectedOnMousedown) {
// The user clicked an unselected entity, which
Tweak drag and selection behavior: selection is kept after dragging selected entities, but cleared after dragging an unselected entity. Marquee selection is select-only (not toggle), and "Select All" replaces "Invert Selection". Left-click on nothing will clear the selection. Also add context menu entries for cut, copy, and paste. [git-p4: depot-paths = "//depot/solvespace/": change = 2089]
2009-12-21 16:44:00 +00:00
// means they're dragging just the hovered thing,
// not the full selection. So clear all the selection
// except that entity.
ClearSelection();
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
MakeSelected(e->h);
Tweak drag and selection behavior: selection is kept after dragging selected entities, but cleared after dragging an unselected entity. Marquee selection is select-only (not toggle), and "Select All" replaces "Invert Selection". Left-click on nothing will clear the selection. Also add context menu entries for cut, copy, and paste. [git-p4: depot-paths = "//depot/solvespace/": change = 2089]
2009-12-21 16:44:00 +00:00
}
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
StartDraggingBySelection();
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
if(!hoverWasSelectedOnMousedown) {
// And then clear the selection again, since they
// probably didn't want that selected if they just
// were dragging it.
ClearSelection();
}
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
hover.Clear();
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
pending.operation = Pending::DRAGGING_POINTS;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
}
Trim trailing whitespace.
2015-03-29 00:30:52 +00:00
} else if(hover.constraint.v &&
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
SK.GetConstraint(hover.constraint)->HasLabel())
{
ClearSelection();
pending.constraint = hover.constraint;
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
pending.operation = Pending::DRAGGING_CONSTRAINT;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
}
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
if(pending.operation != Pending::NONE) {
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
// We just started a drag, so remember for the undo before
// the drag changes anything.
SS.UndoRemember();
Add marquee selection, a view-aligned rectangle such that everything even partially within that rectangle gets selected when I release. Also make deselecting a point deselect all coincident points too; otherwise there now exist ways to select both coincident points, which meant that it was impossible to deselect the lower one. And fix text window to show selection info even if just constraints are selected, seems more consistent. [git-p4: depot-paths = "//depot/solvespace/": change = 2066]
2009-11-04 07:52:58 +00:00
} 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.
Annotate constants passed as boolean function arguments. This is to ensure that: * it is clear, when looking at the point of usage, what is the purpose of "true" or "false"; * when refactoring, a simple search will bring up any places that need to be changed. Also, argument names were synchronized between declaration and implementation. As an exception, these are not annotated: * Printf(/*halfLine=*/), to avoid pointless churn.
2016-05-25 12:08:19 +00:00
MakeUnselected(hover.entity, /*coincidentPointTrick=*/false);
Add marquee selection, a view-aligned rectangle such that everything even partially within that rectangle gets selected when I release. Also make deselecting a point deselect all coincident points too; otherwise there now exist ways to select both coincident points, which meant that it was impossible to deselect the lower one. And fix text window to show selection info even if just constraints are selected, seems more consistent. [git-p4: depot-paths = "//depot/solvespace/": change = 2066]
2009-11-04 07:52:58 +00:00
hover.Clear();
}
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
pending.operation = Pending::DRAGGING_MARQUEE;
Add marquee selection, a view-aligned rectangle such that everything even partially within that rectangle gets selected when I release. Also make deselecting a point deselect all coincident points too; otherwise there now exist ways to select both coincident points, which meant that it was impossible to deselect the lower one. And fix text window to show selection info even if just constraints are selected, seems more consistent. [git-p4: depot-paths = "//depot/solvespace/": change = 2066]
2009-11-04 07:52:58 +00:00
orig.marqueePoint =
UnProjectPoint(orig.mouseOnButtonDown);
}
}
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
}
} 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.
Don't perform hit testing if we haven't painted the graphics window. This change is quite subtle. The goal is to improve responsiveness of highlighting even further. To understand this change you need to keep in mind that Windows and Gtk have dramatically different behavior for paint (WM_PAINT in Windows, expose in Gtk) and mouse move events. In Windows, WM_PAINT and WM_MOUSEMOVE, unless sent explicitly, are synthesized: WM_MOUSEMOVE is delivered when there are no other messages and the current cursor position doesn't match the remembered one, and WM_PAINT is delivered when there are no other messages, even WM_MOUSEMOVE. This is pretty clever because it doesn't swamp programs that are slow to process either of those events with even more of them, ensuring they remain responsive. In Gtk, expose events are delivered at the end of the frame whenever there is an invalid view, and every single mouse move that happened will result in a separate event. If mouse move events are handled quickly, then the behavior is identical in either case: * process mouse move event * perform hit testing * invalidate view * no more events to process! * there are invalid views * repaint If, however, mouse move events are handled slower, then the behavior diverges. With Gtk: * process mouse move event * perform hit testing (slow) * while this happens, ten more mouse move events are added * invalidate view * end of frame! * there are invalid views * repaint * process mouse move event... As a result, the Gtk-hosted UI hopelessly lags behind user input. This is very irritating. With Windows: * process mouse move event * perform hit testing (slow) * while this happens, mouse was moved * invalidate view * process mouse move event... As a result, the Windows-hosted UI never repaints while the mouse is moved. This is also very irritating. Commit HEAD^ has fixed the problems with Gtk-based UI by making hit testing so fast that mouse move events never quite overflow the queue. There's still a barely noticeable lag but it's better. However, the problems with Windows remained because while the queue doesn't *overflow* with the faster hit testing code, it doesn't go *empty* either! Thus we still don't repaint. This commit builds on top of HEAD^ and makes it so that we don't actually hit test anything if we haven't painted the result of the previous hit test already. This fixes the problem on Windows but also helps Gtk a little bit. Curiously, the Cocoa-based UI never suffered from any of these problems. To my understanding (it's somewhat underdocumented), it processes mouse moves like Windows, but paints like Gtk.
2016-03-06 10:55:02 +00:00
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);
}
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
}
return;
}
// If the user has started an operation from the menu, but not
// completed it, then just do the selection.
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
if(pending.operation == Pending::COMMAND) {
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
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.
Split cubic splines and periodic splines too; which is a pain, because it can't be C2 continuous after splitting (since I'm doing uniform splines only, and the parametrization changes). So just knock everything down to cubic Beziers. Also draw lines to indicate angle and origin when Ctrl+dragging to rotate in plane of screen. [git-p4: depot-paths = "//depot/solvespace/": change = 2075]
2009-11-10 03:57:24 +00:00
if(!havePainted) {
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
if(pending.operation == Pending::DRAGGING_POINTS && ctrlDown) {
Add a screen to edit the view parameters; scale, translation, rotation. Also clean up the handling of units, by putting the conversion factors in only one place, and clean up the expression-parsing but removing all the copies of the same error message. [git-p4: depot-paths = "//depot/solvespace/": change = 2093]
2010-01-04 00:35:28 +00:00
SS.extraLine.ptA = UnProjectPoint(orig.mouseOnButtonDown);
SS.extraLine.ptB = UnProjectPoint(mp);
SS.extraLine.draw = true;
Split cubic splines and periodic splines too; which is a pain, because it can't be C2 continuous after splitting (since I'm doing uniform splines only, and the parametrization changes). So just knock everything down to cubic Beziers. Also draw lines to indicate angle and origin when Ctrl+dragging to rotate in plane of screen. [git-p4: depot-paths = "//depot/solvespace/": change = 2075]
2009-11-10 03:57:24 +00:00
}
return;
}
Don't perform hit testing if we haven't painted the graphics window. This change is quite subtle. The goal is to improve responsiveness of highlighting even further. To understand this change you need to keep in mind that Windows and Gtk have dramatically different behavior for paint (WM_PAINT in Windows, expose in Gtk) and mouse move events. In Windows, WM_PAINT and WM_MOUSEMOVE, unless sent explicitly, are synthesized: WM_MOUSEMOVE is delivered when there are no other messages and the current cursor position doesn't match the remembered one, and WM_PAINT is delivered when there are no other messages, even WM_MOUSEMOVE. This is pretty clever because it doesn't swamp programs that are slow to process either of those events with even more of them, ensuring they remain responsive. In Gtk, expose events are delivered at the end of the frame whenever there is an invalid view, and every single mouse move that happened will result in a separate event. If mouse move events are handled quickly, then the behavior is identical in either case: * process mouse move event * perform hit testing * invalidate view * no more events to process! * there are invalid views * repaint If, however, mouse move events are handled slower, then the behavior diverges. With Gtk: * process mouse move event * perform hit testing (slow) * while this happens, ten more mouse move events are added * invalidate view * end of frame! * there are invalid views * repaint * process mouse move event... As a result, the Gtk-hosted UI hopelessly lags behind user input. This is very irritating. With Windows: * process mouse move event * perform hit testing (slow) * while this happens, mouse was moved * invalidate view * process mouse move event... As a result, the Windows-hosted UI never repaints while the mouse is moved. This is also very irritating. Commit HEAD^ has fixed the problems with Gtk-based UI by making hit testing so fast that mouse move events never quite overflow the queue. There's still a barely noticeable lag but it's better. However, the problems with Windows remained because while the queue doesn't *overflow* with the faster hit testing code, it doesn't go *empty* either! Thus we still don't repaint. This commit builds on top of HEAD^ and makes it so that we don't actually hit test anything if we haven't painted the result of the previous hit test already. This fixes the problem on Windows but also helps Gtk a little bit. Curiously, the Cocoa-based UI never suffered from any of these problems. To my understanding (it's somewhat underdocumented), it processes mouse moves like Windows, but paints like Gtk.
2016-03-06 10:55:02 +00:00
havePainted = false;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
switch(pending.operation) {
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Pending::DRAGGING_CONSTRAINT: {
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Constraint *c = SK.constraint.FindById(pending.constraint);
UpdateDraggedNum(&(c->disp.offset), x, y);
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
orig.mouse = mp;
InvalidateGraphics();
Enable exhaustive switch coverage warnings as an error, and use them. Specifically, this enables -Wswitch=error on GCC/Clang and its MSVC equivalent; the exact way it is handled varies slightly, but what they all have in common is that in a switch statement over an enumeration, any enumerand that is not explicitly (via case:) or implicitly (via default:) handled in the switch triggers an error. Moreover, we also change the switch statements in three ways: * Switch statements that ought to be extended every time a new enumerand is added (e.g. Entity::DrawOrGetDistance(), are changed to explicitly list every single enumerand, and not have a default: branch. Note that the assertions are kept because it is legal for a enumeration to have a value unlike any of its defined enumerands, and we can e.g. read garbage from a file, or an uninitialized variable. This requires some rearranging if a default: branch is undesired. * Switch statements that ought to only ever see a few select enumerands, are changed to always assert in the default: branch. * Switch statements that do something meaningful for a few enumerands, and ignore everything else, are changed to do nothing in a default: branch, under the assumption that changing them every time an enumerand is added or removed would just result in noise and catch no bugs. This commit also removes the {Request,Entity,Constraint}::UNKNOWN and Entity::DATUM_POINT enumerands, as those were just fancy names for zeroes. They mess up switch exhaustiveness checks and most of the time were not the best way to implement what they did anyway.
2016-05-25 06:55:50 +00:00
return;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
}
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Pending::DRAGGING_NEW_LINE_POINT:
Disable autoconstrainer while Ctrl is held.
2016-04-02 08:29:32 +00:00
if(!ctrlDown) {
Enable exhaustive switch coverage warnings as an error, and use them. Specifically, this enables -Wswitch=error on GCC/Clang and its MSVC equivalent; the exact way it is handled varies slightly, but what they all have in common is that in a switch statement over an enumeration, any enumerand that is not explicitly (via case:) or implicitly (via default:) handled in the switch triggers an error. Moreover, we also change the switch statements in three ways: * Switch statements that ought to be extended every time a new enumerand is added (e.g. Entity::DrawOrGetDistance(), are changed to explicitly list every single enumerand, and not have a default: branch. Note that the assertions are kept because it is legal for a enumeration to have a value unlike any of its defined enumerands, and we can e.g. read garbage from a file, or an uninitialized variable. This requires some rearranging if a default: branch is undesired. * Switch statements that ought to only ever see a few select enumerands, are changed to always assert in the default: branch. * Switch statements that do something meaningful for a few enumerands, and ignore everything else, are changed to do nothing in a default: branch, under the assumption that changing them every time an enumerand is added or removed would just result in noise and catch no bugs. This commit also removes the {Request,Entity,Constraint}::UNKNOWN and Entity::DATUM_POINT enumerands, as those were just fancy names for zeroes. They mess up switch exhaustiveness checks and most of the time were not the best way to implement what they did anyway.
2016-05-25 06:55:50 +00:00
SS.GW.pending.hasSuggestion =
SS.GW.SuggestLineConstraint(SS.GW.pending.request, &SS.GW.pending.suggestion);
Disable autoconstrainer while Ctrl is held.
2016-04-02 08:29:32 +00:00
} else {
Enable exhaustive switch coverage warnings as an error, and use them. Specifically, this enables -Wswitch=error on GCC/Clang and its MSVC equivalent; the exact way it is handled varies slightly, but what they all have in common is that in a switch statement over an enumeration, any enumerand that is not explicitly (via case:) or implicitly (via default:) handled in the switch triggers an error. Moreover, we also change the switch statements in three ways: * Switch statements that ought to be extended every time a new enumerand is added (e.g. Entity::DrawOrGetDistance(), are changed to explicitly list every single enumerand, and not have a default: branch. Note that the assertions are kept because it is legal for a enumeration to have a value unlike any of its defined enumerands, and we can e.g. read garbage from a file, or an uninitialized variable. This requires some rearranging if a default: branch is undesired. * Switch statements that ought to only ever see a few select enumerands, are changed to always assert in the default: branch. * Switch statements that do something meaningful for a few enumerands, and ignore everything else, are changed to do nothing in a default: branch, under the assumption that changing them every time an enumerand is added or removed would just result in noise and catch no bugs. This commit also removes the {Request,Entity,Constraint}::UNKNOWN and Entity::DATUM_POINT enumerands, as those were just fancy names for zeroes. They mess up switch exhaustiveness checks and most of the time were not the best way to implement what they did anyway.
2016-05-25 06:55:50 +00:00
SS.GW.pending.hasSuggestion = false;
Disable autoconstrainer while Ctrl is held.
2016-04-02 08:29:32 +00:00
}
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Pending::DRAGGING_NEW_POINT:
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
UpdateDraggedPoint(pending.point, x, y);
HitTestMakeSelection(mp);
SS.MarkGroupDirtyByEntity(pending.point);
orig.mouse = mp;
InvalidateGraphics();
break;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Pending::DRAGGING_POINTS:
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
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;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
if(ctrlDown) {
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
double d = mp.DistanceTo(orig.mouseOnButtonDown);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
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;
}
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
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);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Vector gn = projRight.Cross(projUp);
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
qt = Quaternion::From(gn, -theta);
Split cubic splines and periodic splines too; which is a pain, because it can't be C2 continuous after splitting (since I'm doing uniform splines only, and the parametrization changes). So just knock everything down to cubic Beziers. Also draw lines to indicate angle and origin when Ctrl+dragging to rotate in plane of screen. [git-p4: depot-paths = "//depot/solvespace/": change = 2075]
2009-11-10 03:57:24 +00:00
Add a screen to edit the view parameters; scale, translation, rotation. Also clean up the handling of units, by putting the conversion factors in only one place, and clean up the expression-parsing but removing all the copies of the same error message. [git-p4: depot-paths = "//depot/solvespace/": change = 2093]
2010-01-04 00:35:28 +00:00
SS.extraLine.draw = true;
SS.extraLine.ptA = UnProjectPoint(orig.mouseOnButtonDown);
SS.extraLine.ptB = UnProjectPoint(mp);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
} else {
double dx = -(x - orig.mouse.x);
double dy = -(y - orig.mouse.y);
double s = 0.3*(PI/180); // degrees per pixel
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
qt = Quaternion::From(projUp, -s*dx).Times(
Quaternion::From(projRight, s*dy));
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
}
orig.mouse = mp;
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
// 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);
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(e->type != Entity::Type::POINT_N_ROT_TRANS) {
Split cubic splines and periodic splines too; which is a pain, because it can't be C2 continuous after splitting (since I'm doing uniform splines only, and the parametrization changes). So just knock everything down to cubic Beziers. Also draw lines to indicate angle and origin when Ctrl+dragging to rotate in plane of screen. [git-p4: depot-paths = "//depot/solvespace/": change = 2075]
2009-11-10 03:57:24 +00:00
if(ctrlDown) {
Vector p = e->PointGetNum();
Add a screen to edit the view parameters; scale, translation, rotation. Also clean up the handling of units, by putting the conversion factors in only one place, and clean up the expression-parsing but removing all the copies of the same error message. [git-p4: depot-paths = "//depot/solvespace/": change = 2093]
2010-01-04 00:35:28 +00:00
p = p.Minus(SS.extraLine.ptA);
Split cubic splines and periodic splines too; which is a pain, because it can't be C2 continuous after splitting (since I'm doing uniform splines only, and the parametrization changes). So just knock everything down to cubic Beziers. Also draw lines to indicate angle and origin when Ctrl+dragging to rotate in plane of screen. [git-p4: depot-paths = "//depot/solvespace/": change = 2075]
2009-11-10 03:57:24 +00:00
p = qt.Rotate(p);
Add a screen to edit the view parameters; scale, translation, rotation. Also clean up the handling of units, by putting the conversion factors in only one place, and clean up the expression-parsing but removing all the copies of the same error message. [git-p4: depot-paths = "//depot/solvespace/": change = 2093]
2010-01-04 00:35:28 +00:00
p = p.Plus(SS.extraLine.ptA);
Split cubic splines and periodic splines too; which is a pain, because it can't be C2 continuous after splitting (since I'm doing uniform splines only, and the parametrization changes). So just knock everything down to cubic Beziers. Also draw lines to indicate angle and origin when Ctrl+dragging to rotate in plane of screen. [git-p4: depot-paths = "//depot/solvespace/": change = 2075]
2009-11-10 03:57:24 +00:00
e->PointForceTo(p);
SS.MarkGroupDirtyByEntity(e->h);
}
continue;
}
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
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);
}
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
} else {
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
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;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
}
break;
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Pending::DRAGGING_NEW_CUBIC_POINT: {
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
UpdateDraggedPoint(pending.point, x, y);
HitTestMakeSelection(mp);
hRequest hr = pending.point.request();
Add interpolating splines: both periodic splines (that form a loop), and open-ended splines, with their tangents specified at their endpoints. Also change constraint solver matrix size to 1024, on the theory that a power of two will generate better array indexing, and replace fabs() with my own function that for some reason is faster. [git-p4: depot-paths = "//depot/solvespace/": change = 2055]
2009-10-21 04:46:01 +00:00
if(pending.point.v == hr.entity(4).v) {
// 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);
}
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
orig.mouse = mp;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
SS.MarkGroupDirtyByEntity(pending.point);
break;
}
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Pending::DRAGGING_NEW_ARC_POINT: {
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
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);
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
orig.mouse = mp;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
SS.MarkGroupDirtyByEntity(pending.point);
break;
}
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Pending::DRAGGING_NEW_RADIUS:
case Pending::DRAGGING_RADIUS: {
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
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;
}
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Pending::DRAGGING_NORMAL: {
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
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;
}
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Pending::DRAGGING_MARQUEE:
Add marquee selection, a view-aligned rectangle such that everything even partially within that rectangle gets selected when I release. Also make deselecting a point deselect all coincident points too; otherwise there now exist ways to select both coincident points, which meant that it was impossible to deselect the lower one. And fix text window to show selection info even if just constraints are selected, seems more consistent. [git-p4: depot-paths = "//depot/solvespace/": change = 2066]
2009-11-04 07:52:58 +00:00
orig.mouse = mp;
InvalidateGraphics();
Enable exhaustive switch coverage warnings as an error, and use them. Specifically, this enables -Wswitch=error on GCC/Clang and its MSVC equivalent; the exact way it is handled varies slightly, but what they all have in common is that in a switch statement over an enumeration, any enumerand that is not explicitly (via case:) or implicitly (via default:) handled in the switch triggers an error. Moreover, we also change the switch statements in three ways: * Switch statements that ought to be extended every time a new enumerand is added (e.g. Entity::DrawOrGetDistance(), are changed to explicitly list every single enumerand, and not have a default: branch. Note that the assertions are kept because it is legal for a enumeration to have a value unlike any of its defined enumerands, and we can e.g. read garbage from a file, or an uninitialized variable. This requires some rearranging if a default: branch is undesired. * Switch statements that ought to only ever see a few select enumerands, are changed to always assert in the default: branch. * Switch statements that do something meaningful for a few enumerands, and ignore everything else, are changed to do nothing in a default: branch, under the assumption that changing them every time an enumerand is added or removed would just result in noise and catch no bugs. This commit also removes the {Request,Entity,Constraint}::UNKNOWN and Entity::DATUM_POINT enumerands, as those were just fancy names for zeroes. They mess up switch exhaustiveness checks and most of the time were not the best way to implement what they did anyway.
2016-05-25 06:55:50 +00:00
return;
Add marquee selection, a view-aligned rectangle such that everything even partially within that rectangle gets selected when I release. Also make deselecting a point deselect all coincident points too; otherwise there now exist ways to select both coincident points, which meant that it was impossible to deselect the lower one. And fix text window to show selection info even if just constraints are selected, seems more consistent. [git-p4: depot-paths = "//depot/solvespace/": change = 2066]
2009-11-04 07:52:58 +00:00
Enable exhaustive switch coverage warnings as an error, and use them. Specifically, this enables -Wswitch=error on GCC/Clang and its MSVC equivalent; the exact way it is handled varies slightly, but what they all have in common is that in a switch statement over an enumeration, any enumerand that is not explicitly (via case:) or implicitly (via default:) handled in the switch triggers an error. Moreover, we also change the switch statements in three ways: * Switch statements that ought to be extended every time a new enumerand is added (e.g. Entity::DrawOrGetDistance(), are changed to explicitly list every single enumerand, and not have a default: branch. Note that the assertions are kept because it is legal for a enumeration to have a value unlike any of its defined enumerands, and we can e.g. read garbage from a file, or an uninitialized variable. This requires some rearranging if a default: branch is undesired. * Switch statements that ought to only ever see a few select enumerands, are changed to always assert in the default: branch. * Switch statements that do something meaningful for a few enumerands, and ignore everything else, are changed to do nothing in a default: branch, under the assumption that changing them every time an enumerand is added or removed would just result in noise and catch no bugs. This commit also removes the {Request,Entity,Constraint}::UNKNOWN and Entity::DATUM_POINT enumerands, as those were just fancy names for zeroes. They mess up switch exhaustiveness checks and most of the time were not the best way to implement what they did anyway.
2016-05-25 06:55:50 +00:00
case Pending::NONE:
case Pending::COMMAND:
ssassert(false, "Unexpected pending operation");
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
}
}
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void GraphicsWindow::ClearPending() {
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
pending.points.Clear();
Do not hover or select entities from any pending request.
2017-01-09 16:54:24 +00:00
pending.requests.Clear();
Replace all ZERO and memset with C++11 brace-initialization. This will allow us to use non-POD classes inside these objects in future and is otherwise functionally equivalent, as well as more concise. Note that there are some subtleties with handling of brace-initialization. Specifically: On aggregates (e.g. simple C-style structures) using an empty brace-initializer zero-initializes the aggregate, i.e. it makes all members zero. On non-aggregates an empty brace-initializer calls the default constructor. And if the constructor doesn't explicitly initialize the members (which the auto-generated constructor doesn't) then the members will be constructed but otherwise uninitialized. So, what is an aggregate class? To quote the C++ standard (C++03 8.5.1 §1): An aggregate is an array or a class (clause 9) with no user-declared constructors (12.1), no private or protected non-static data members (clause 11), no base classes (clause 10), and no virtual functions (10.3). In SolveSpace, we only have to handle the case of base classes; Constraint and Entity have those. Thus, they had to gain a default constructor that does nothing but initializes the members to zero.
2015-03-27 15:31:23 +00:00
pending = {};
Add a GTK2/3 port. In principle, GTK3 is the way forward, and GTK2 is officially deprecated, though still maintained. In practice however, GTK3 is often unbearably buggy; e.g. on my system, combo boxes don't ever roll up in GTK3 windows. So I have added support for both. This required a few minor changes to the core, namely: * GTK wants to know beforehand whether a menu item is a check menu item or a regular one. * GTK doesn't give us an easy way to execute something after any event is processed, so an explicit idle timer is added. This is a no-op on Win32. * A few function signatures were const'ed, since GTK expects immutable strings when converting to Glib::ustring.
2015-03-18 17:02:11 +00:00
SS.ScheduleShowTW();
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
}
Do not hover or select entities from any pending request.
2017-01-09 16:54:24 +00:00
bool GraphicsWindow::IsFromPending(hRequest r) {
for(auto &req : pending.requests) {
if(req.v == r.v) return true;
}
return false;
}
void GraphicsWindow::AddToPending(hRequest r) {
pending.requests.Add(&r);
}
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
void GraphicsWindow::MouseMiddleOrRightDown(double x, double y) {
if(GraphicsEditControlIsVisible()) return;
orig.offset = offset;
orig.projUp = projUp;
orig.projRight = projRight;
orig.mouse.x = x;
orig.mouse.y = y;
orig.startedMoving = false;
}
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void GraphicsWindow::ContextMenuListStyles() {
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
CreateContextSubmenu();
Style *s;
bool empty = true;
for(s = SK.style.First(); s; s = SK.style.NextAfter(s)) {
if(s->h.v < Style::FIRST_CUSTOM) continue;
Internationalize the context menu.
2017-01-05 12:35:50 +00:00
AddContextMenuItem(s->DescriptionString().c_str(),
(ContextCommand)((uint32_t)ContextCommand::FIRST_STYLE + s->h.v));
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
empty = false;
}
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(!empty) AddContextMenuItem(NULL, ContextCommand::SEPARATOR);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Internationalize the context menu.
2017-01-05 12:35:50 +00:00
AddContextMenuItem(_("No Style"), ContextCommand::NO_STYLE);
AddContextMenuItem(_("Newly Created Custom Style..."), ContextCommand::NEW_CUSTOM_STYLE);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
}
void GraphicsWindow::MouseRightUp(double x, double y) {
Add a screen to edit the view parameters; scale, translation, rotation. Also clean up the handling of units, by putting the conversion factors in only one place, and clean up the expression-parsing but removing all the copies of the same error message. [git-p4: depot-paths = "//depot/solvespace/": change = 2093]
2010-01-04 00:35:28 +00:00
SS.extraLine.draw = false;
Split cubic splines and periodic splines too; which is a pain, because it can't be C2 continuous after splitting (since I'm doing uniform splines only, and the parametrization changes). So just knock everything down to cubic Beziers. Also draw lines to indicate angle and origin when Ctrl+dragging to rotate in plane of screen. [git-p4: depot-paths = "//depot/solvespace/": change = 2075]
2009-11-10 03:57:24 +00:00
InvalidateGraphics();
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
// 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;
Enable exhaustive switch coverage warnings as an error, and use them. Specifically, this enables -Wswitch=error on GCC/Clang and its MSVC equivalent; the exact way it is handled varies slightly, but what they all have in common is that in a switch statement over an enumeration, any enumerand that is not explicitly (via case:) or implicitly (via default:) handled in the switch triggers an error. Moreover, we also change the switch statements in three ways: * Switch statements that ought to be extended every time a new enumerand is added (e.g. Entity::DrawOrGetDistance(), are changed to explicitly list every single enumerand, and not have a default: branch. Note that the assertions are kept because it is legal for a enumeration to have a value unlike any of its defined enumerands, and we can e.g. read garbage from a file, or an uninitialized variable. This requires some rearranging if a default: branch is undesired. * Switch statements that ought to only ever see a few select enumerands, are changed to always assert in the default: branch. * Switch statements that do something meaningful for a few enumerands, and ignore everything else, are changed to do nothing in a default: branch, under the assumption that changing them every time an enumerand is added or removed would just result in noise and catch no bugs. This commit also removes the {Request,Entity,Constraint}::UNKNOWN and Entity::DATUM_POINT enumerands, as those were just fancy names for zeroes. They mess up switch exhaustiveness checks and most of the time were not the best way to implement what they did anyway.
2016-05-25 06:55:50 +00:00
if(pending.operation == Pending::DRAGGING_NEW_LINE_POINT && pending.hasSuggestion) {
Constraint::Constrain(SS.GW.pending.suggestion,
Entity::NO_ENTITY, Entity::NO_ENTITY, pending.request.entity(0));
Automatically add horz/vert constraints to lines if close enough.
2015-03-29 22:26:07 +00:00
}
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
if(pending.operation == Pending::DRAGGING_NEW_LINE_POINT ||
pending.operation == Pending::DRAGGING_NEW_CUBIC_POINT)
Add interpolating splines: both periodic splines (that form a loop), and open-ended splines, with their tangents specified at their endpoints. Also change constraint solver matrix size to 1024, on the theory that a power of two will generate better array indexing, and replace fabs() with my own function that for some reason is faster. [git-p4: depot-paths = "//depot/solvespace/": change = 2055]
2009-10-21 04:46:01 +00:00
{
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
// Special case; use a right click to stop drawing lines, since
// a left click would draw another one. This is quicker and more
Add interpolating splines: both periodic splines (that form a loop), and open-ended splines, with their tangents specified at their endpoints. Also change constraint solver matrix size to 1024, on the theory that a power of two will generate better array indexing, and replace fabs() with my own function that for some reason is faster. [git-p4: depot-paths = "//depot/solvespace/": change = 2055]
2009-10-21 04:46:01 +00:00
// intuitive than hitting escape. Likewise for new cubic segments.
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
ClearPending();
Add interpolating splines: both periodic splines (that form a loop), and open-ended splines, with their tangents specified at their endpoints. Also change constraint solver matrix size to 1024, on the theory that a power of two will generate better array indexing, and replace fabs() with my own function that for some reason is faster. [git-p4: depot-paths = "//depot/solvespace/": change = 2055]
2009-10-21 04:46:01 +00:00
return;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
}
Allow adding spline points.
2016-04-08 08:20:42 +00:00
// The current mouse location
Vector v = offset.ScaledBy(-1);
v = v.Plus(projRight.ScaledBy(x/scale));
v = v.Plus(projUp.ScaledBy(y/scale));
Add interpolating splines: both periodic splines (that form a loop), and open-ended splines, with their tangents specified at their endpoints. Also change constraint solver matrix size to 1024, on the theory that a power of two will generate better array indexing, and replace fabs() with my own function that for some reason is faster. [git-p4: depot-paths = "//depot/solvespace/": change = 2055]
2009-10-21 04:46:01 +00:00
context.active = true;
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
if(!hover.IsEmpty()) {
MakeSelected(&hover);
Add a GTK2/3 port. In principle, GTK3 is the way forward, and GTK2 is officially deprecated, though still maintained. In practice however, GTK3 is often unbearably buggy; e.g. on my system, combo boxes don't ever roll up in GTK3 windows. So I have added support for both. This required a few minor changes to the core, namely: * GTK wants to know beforehand whether a menu item is a check menu item or a regular one. * GTK doesn't give us an easy way to execute something after any event is processed, so an explicit idle timer is added. This is a no-op on Win32. * A few function signatures were const'ed, since GTK expects immutable strings when converting to Glib::ustring.
2015-03-18 17:02:11 +00:00
SS.ScheduleShowTW();
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
}
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
GroupSelection();
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
bool itemsSelected = (gs.n > 0 || gs.constraints > 0);
Allow adding spline points.
2016-04-08 08:20:42 +00:00
int addAfterPoint = -1;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
if(itemsSelected) {
if(gs.stylables > 0) {
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
ContextMenuListStyles();
Internationalize the context menu.
2017-01-05 12:35:50 +00:00
AddContextMenuItem(_("Assign to Style"), ContextCommand::SUBMENU);
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
}
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
if(gs.n + gs.constraints == 1) {
Internationalize the context menu.
2017-01-05 12:35:50 +00:00
AddContextMenuItem(_("Group Info"), ContextCommand::GROUP_INFO);
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
}
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
if(gs.n + gs.constraints == 1 && gs.stylables == 1) {
Internationalize the context menu.
2017-01-05 12:35:50 +00:00
AddContextMenuItem(_("Style Info"), ContextCommand::STYLE_INFO);
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
}
if(gs.withEndpoints > 0) {
Internationalize the context menu.
2017-01-05 12:35:50 +00:00
AddContextMenuItem(_("Select Edge Chain"), ContextCommand::SELECT_CHAIN);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
}
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
if(gs.constraints == 1 && gs.n == 0) {
Constraint *c = SK.GetConstraint(gs.constraint[0]);
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(c->HasLabel() && c->type != Constraint::Type::COMMENT) {
Internationalize the context menu.
2017-01-05 12:35:50 +00:00
AddContextMenuItem(_("Toggle Reference Dimension"),
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
ContextCommand::REFERENCE_DIM);
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
}
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(c->type == Constraint::Type::ANGLE ||
c->type == Constraint::Type::EQUAL_ANGLE)
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
{
Internationalize the context menu.
2017-01-05 12:35:50 +00:00
AddContextMenuItem(_("Other Supplementary Angle"),
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
ContextCommand::OTHER_ANGLE);
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
}
}
Allow snapping constraint labels to grid. This is pretty much the only way to get a sketch with tidily placed dimensions.
2016-04-18 06:40:42 +00:00
if(gs.constraintLabels > 0 || gs.points > 0) {
Internationalize the context menu.
2017-01-05 12:35:50 +00:00
AddContextMenuItem(_("Snap to Grid"), ContextCommand::SNAP_TO_GRID);
Don't crash after right-clicking on derived entities.
2016-04-17 01:16:47 +00:00
}
Allow removing spline points.
2016-04-07 14:44:56 +00:00
Don't crash after right-clicking on derived entities.
2016-04-17 01:16:47 +00:00
if(gs.points == 1 && gs.point[0].isFromRequest()) {
Request *r = SK.GetRequest(gs.point[0].request());
int index = r->IndexOfPoint(gs.point[0]);
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if((r->type == Request::Type::CUBIC && (index > 1 && index < r->extraPoints + 2)) ||
r->type == Request::Type::CUBIC_PERIODIC) {
Internationalize the context menu.
2017-01-05 12:35:50 +00:00
AddContextMenuItem(_("Remove Spline Point"), ContextCommand::REMOVE_SPLINE_PT);
Allow removing spline points.
2016-04-07 14:44:56 +00:00
}
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
}
Don't crash after right-clicking on derived entities.
2016-04-17 01:16:47 +00:00
if(gs.entities == 1 && gs.entity[0].isFromRequest()) {
Request *r = SK.GetRequest(gs.entity[0].request());
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(r->type == Request::Type::CUBIC || r->type == Request::Type::CUBIC_PERIODIC) {
Don't crash after right-clicking on derived entities.
2016-04-17 01:16:47 +00:00
Entity *e = SK.GetEntity(gs.entity[0]);
Abstract all (ex-OpenGL) drawing operations into a Canvas interface. This has several desirable consequences: * It is now possible to port SolveSpace to a later version of OpenGL, such as OpenGLES 2, so that it runs on platforms that only have that OpenGL version; * The majority of geometry is now rendered without references to the camera in C++ code, so a renderer can now submit it to the video card once and re-rasterize with a different projection matrix every time the projection is changed, avoiding expensive reuploads; * The DOGD (draw or get distance) interface is now a straightforward Canvas implementation; * There are no more direct references to SS.GW.(projection) in sketch rendering code, which allows rendering to multiple viewports; * There are no more unnecessary framebuffer flips on CPU on Cocoa and GTK; * The platform-dependent GL code is now confined to rendergl1.cpp. * The Microsoft and Apple headers required by it that are prone to identifier conflicts are no longer included globally; * The rendergl1.cpp implementation can now be omitted from compilation to run SolveSpace headless or with a different OpenGL version. Note these implementation details of Canvas: * GetCamera currently always returns a reference to the field `Camera camera;`. This is so that a future renderer that caches geometry in the video memory can define it as asserting, which would provide assurance against code that could accidentally put something projection-dependent in the cache; * Line and triangle rendering is specified through a level of indirection, hStroke and hFill. This is so that a future renderer that batches geometry could cheaply group identical styles. * DrawPixmap and DrawVectorText accept a (o,u,v) and not a matrix. This is so that a future renderer into an output format that uses 2d transforms (e.g. SVG) could easily derive those. Some additional internal changes were required to enable this: * Pixmap is now always passed as std::shared_ptr<{const ,}Pixmap>. This is so that the renderer could cache uploaded textures between API calls, which requires it to capture a (weak) reference. * The PlatformPathEqual function was properly extracted into platform-specific code. This is so that the <windows.h> header could be included only where needed (in platform/w32* as well as rendergl1.cpp). * The SBsp{2,3}::DebugDraw functions were removed. They can be rewritten using the Canvas API if they are ever needed. While no visual changes were originally intended, some minor fixes happened anyway: * The "emphasis" yellow line from top-left corner is now correctly rendered much wider. * The marquee rectangle is now pixel grid aligned. * The hidden entities now do not clobber the depth buffer, removing some minor artifacts. * The workplane "tab" now scales with the font used to render the workplane name. * The workplane name font is now taken from the normals style. * Workplane and constraint line stipple is insignificantly different. This is so that it can reuse the existing stipple codepaths; rendering of workplanes and constraints predates those. Some debug functionality was added: * In graphics window, an fps counter that becomes red when rendering under 60fps is drawn.
2016-05-31 00:55:13 +00:00
addAfterPoint = e->GetPositionOfPoint(GetCamera(), Point2d::From(x, y));
Replace all oops() checks with ssassert()s. This includes explanation and context for non-obvious cases and shortens debug cycles when just-in-time debugging is not available (like on Linux) by immediately printing description of the assert as well as symbolized backtrace.
2016-05-18 22:51:36 +00:00
ssassert(addAfterPoint != -1, "Expected a nearest bezier point to be located");
Don't crash after right-clicking on derived entities.
2016-04-17 01:16:47 +00:00
// Skip derivative point.
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(r->type == Request::Type::CUBIC) addAfterPoint++;
Internationalize the context menu.
2017-01-05 12:35:50 +00:00
AddContextMenuItem(_("Add Spline Point"), ContextCommand::ADD_SPLINE_PT);
Allow adding spline points.
2016-04-08 08:20:42 +00:00
}
}
Add "Toggle Construction" to context menu.
2016-10-09 22:13:01 +00:00
if(gs.entities == gs.n) {
Internationalize the context menu.
2017-01-05 12:35:50 +00:00
AddContextMenuItem(_("Toggle Construction"), ContextCommand::CONSTRUCTION);
Add "Toggle Construction" to context menu.
2016-10-09 22:13:01 +00:00
}
Allow adding spline points.
2016-04-08 08:20:42 +00:00
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
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)) {
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(c->type != Constraint::Type::POINTS_COINCIDENT) continue;
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
if(c->ptA.v == p->h.v || c->ptB.v == p->h.v) {
break;
Add context menu item to delete a point-coincident constraint, which can't be selected with the mouse and would otherwise have to get deleted by selecting it in the text window. [git-p4: depot-paths = "//depot/solvespace/": change = 2065]
2009-11-04 03:46:06 +00:00
}
}
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
if(c) {
Internationalize the context menu.
2017-01-05 12:35:50 +00:00
AddContextMenuItem(_("Delete Point-Coincident Constraint"),
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
ContextCommand::DEL_COINCIDENT);
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
}
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
}
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
AddContextMenuItem(NULL, ContextCommand::SEPARATOR);
Tweak drag and selection behavior: selection is kept after dragging selected entities, but cleared after dragging an unselected entity. Marquee selection is select-only (not toggle), and "Select All" replaces "Invert Selection". Left-click on nothing will clear the selection. Also add context menu entries for cut, copy, and paste. [git-p4: depot-paths = "//depot/solvespace/": change = 2089]
2009-12-21 16:44:00 +00:00
if(LockedInWorkplane()) {
Internationalize the context menu.
2017-01-05 12:35:50 +00:00
AddContextMenuItem(_("Cut"), ContextCommand::CUT_SEL);
AddContextMenuItem(_("Copy"), ContextCommand::COPY_SEL);
Tweak drag and selection behavior: selection is kept after dragging selected entities, but cleared after dragging an unselected entity. Marquee selection is select-only (not toggle), and "Select All" replaces "Invert Selection". Left-click on nothing will clear the selection. Also add context menu entries for cut, copy, and paste. [git-p4: depot-paths = "//depot/solvespace/": change = 2089]
2009-12-21 16:44:00 +00:00
}
Add "Select All" to context menu for no selection.
2016-10-09 22:26:25 +00:00
} else {
Internationalize the context menu.
2017-01-05 12:35:50 +00:00
AddContextMenuItem(_("Select All"), ContextCommand::SELECT_ALL);
Tweak drag and selection behavior: selection is kept after dragging selected entities, but cleared after dragging an unselected entity. Marquee selection is select-only (not toggle), and "Select All" replaces "Invert Selection". Left-click on nothing will clear the selection. Also add context menu entries for cut, copy, and paste. [git-p4: depot-paths = "//depot/solvespace/": change = 2089]
2009-12-21 16:44:00 +00:00
}
Show "Paste" context menu item even when only constraints are copied.
2016-06-20 13:47:14 +00:00
if((SS.clipboard.r.n > 0 || SS.clipboard.c.n > 0) && LockedInWorkplane()) {
Internationalize the context menu.
2017-01-05 12:35:50 +00:00
AddContextMenuItem(_("Paste"), ContextCommand::PASTE);
AddContextMenuItem(_("Paste Transformed..."), ContextCommand::PASTE_XFRM);
Tweak drag and selection behavior: selection is kept after dragging selected entities, but cleared after dragging an unselected entity. Marquee selection is select-only (not toggle), and "Select All" replaces "Invert Selection". Left-click on nothing will clear the selection. Also add context menu entries for cut, copy, and paste. [git-p4: depot-paths = "//depot/solvespace/": change = 2089]
2009-12-21 16:44:00 +00:00
}
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
if(itemsSelected) {
Internationalize the context menu.
2017-01-05 12:35:50 +00:00
AddContextMenuItem(_("Delete"), ContextCommand::DELETE_SEL);
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
AddContextMenuItem(NULL, ContextCommand::SEPARATOR);
Internationalize the context menu.
2017-01-05 12:35:50 +00:00
AddContextMenuItem(_("Unselect All"), ContextCommand::UNSELECT_ALL);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
}
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
// 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) {
Internationalize the context menu.
2017-01-05 12:35:50 +00:00
AddContextMenuItem(_("Unselect Hovered"), ContextCommand::UNSELECT_HOVERED);
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
}
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Add "Zoom to Fit" to context menu.
2016-10-09 22:26:36 +00:00
if(itemsSelected) {
AddContextMenuItem(NULL, ContextCommand::SEPARATOR);
Internationalize the context menu.
2017-01-05 12:35:50 +00:00
AddContextMenuItem(_("Zoom to Fit"), ContextCommand::ZOOM_TO_FIT);
Add "Zoom to Fit" to context menu.
2016-10-09 22:26:36 +00:00
}
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
ContextCommand ret = ShowContextMenu();
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
switch(ret) {
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case ContextCommand::CANCELLED:
// otherwise it was cancelled, so do nothing
contextMenuCancelTime = GetMilliseconds();
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
break;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case ContextCommand::UNSELECT_ALL:
MenuEdit(Command::UNSELECT_ALL);
break;
case ContextCommand::UNSELECT_HOVERED:
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
if(!hover.IsEmpty()) {
Annotate constants passed as boolean function arguments. This is to ensure that: * it is clear, when looking at the point of usage, what is the purpose of "true" or "false"; * when refactoring, a simple search will bring up any places that need to be changed. Also, argument names were synchronized between declaration and implementation. As an exception, these are not annotated: * Printf(/*halfLine=*/), to avoid pointless churn.
2016-05-25 12:08:19 +00:00
MakeUnselected(&hover, /*coincidentPointTrick=*/true);
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
}
break;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case ContextCommand::SELECT_CHAIN:
MenuEdit(Command::SELECT_CHAIN);
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
break;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case ContextCommand::CUT_SEL:
MenuClipboard(Command::CUT);
Tweak drag and selection behavior: selection is kept after dragging selected entities, but cleared after dragging an unselected entity. Marquee selection is select-only (not toggle), and "Select All" replaces "Invert Selection". Left-click on nothing will clear the selection. Also add context menu entries for cut, copy, and paste. [git-p4: depot-paths = "//depot/solvespace/": change = 2089]
2009-12-21 16:44:00 +00:00
break;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case ContextCommand::COPY_SEL:
MenuClipboard(Command::COPY);
Tweak drag and selection behavior: selection is kept after dragging selected entities, but cleared after dragging an unselected entity. Marquee selection is select-only (not toggle), and "Select All" replaces "Invert Selection". Left-click on nothing will clear the selection. Also add context menu entries for cut, copy, and paste. [git-p4: depot-paths = "//depot/solvespace/": change = 2089]
2009-12-21 16:44:00 +00:00
break;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case ContextCommand::PASTE:
MenuClipboard(Command::PASTE);
Tweak drag and selection behavior: selection is kept after dragging selected entities, but cleared after dragging an unselected entity. Marquee selection is select-only (not toggle), and "Select All" replaces "Invert Selection". Left-click on nothing will clear the selection. Also add context menu entries for cut, copy, and paste. [git-p4: depot-paths = "//depot/solvespace/": change = 2089]
2009-12-21 16:44:00 +00:00
break;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case ContextCommand::PASTE_XFRM:
MenuClipboard(Command::PASTE_TRANSFORM);
Add "Paste Transformed..." to context menu, when applicable.
2016-03-15 12:11:00 +00:00
break;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case ContextCommand::DELETE_SEL:
MenuClipboard(Command::DELETE);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
break;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case ContextCommand::REFERENCE_DIM:
Constraint::MenuConstrain(Command::REFERENCE);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
break;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case ContextCommand::OTHER_ANGLE:
Constraint::MenuConstrain(Command::OTHER_ANGLE);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
break;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case ContextCommand::DEL_COINCIDENT: {
Add context menu item to delete a point-coincident constraint, which can't be selected with the mouse and would otherwise have to get deleted by selecting it in the text window. [git-p4: depot-paths = "//depot/solvespace/": change = 2065]
2009-11-04 03:46:06 +00:00
SS.UndoRemember();
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
if(!gs.point[0].v) break;
Entity *p = SK.GetEntity(gs.point[0]);
Add context menu item to delete a point-coincident constraint, which can't be selected with the mouse and would otherwise have to get deleted by selecting it in the text window. [git-p4: depot-paths = "//depot/solvespace/": change = 2065]
2009-11-04 03:46:06 +00:00
if(!p->IsPoint()) break;
SK.constraint.ClearTags();
Constraint *c;
for(c = SK.constraint.First(); c; c = SK.constraint.NextAfter(c)) {
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(c->type != Constraint::Type::POINTS_COINCIDENT) continue;
Add context menu item to delete a point-coincident constraint, which can't be selected with the mouse and would otherwise have to get deleted by selecting it in the text window. [git-p4: depot-paths = "//depot/solvespace/": change = 2065]
2009-11-04 03:46:06 +00:00
if(c->ptA.v == p->h.v || c->ptB.v == p->h.v) {
c->tag = 1;
}
}
SK.constraint.RemoveTagged();
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
ClearSelection();
Add context menu item to delete a point-coincident constraint, which can't be selected with the mouse and would otherwise have to get deleted by selecting it in the text window. [git-p4: depot-paths = "//depot/solvespace/": change = 2065]
2009-11-04 03:46:06 +00:00
break;
}
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case ContextCommand::SNAP_TO_GRID:
MenuEdit(Command::SNAP_TO_GRID);
Increment the version number, and add a context menu item to snap what's hovered to the grid. [git-p4: depot-paths = "//depot/solvespace/": change = 2042]
2009-09-30 08:54:01 +00:00
break;
Add "Toggle Construction" to context menu.
2016-10-09 22:13:01 +00:00
case ContextCommand::CONSTRUCTION:
MenuRequest(Command::CONSTRUCTION);
break;
Add "Zoom to Fit" to context menu.
2016-10-09 22:26:36 +00:00
case ContextCommand::ZOOM_TO_FIT:
MenuView(Command::ZOOM_TO_FIT);
break;
Add "Select All" to context menu for no selection.
2016-10-09 22:26:25 +00:00
case ContextCommand::SELECT_ALL:
MenuEdit(Command::SELECT_ALL);
break;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case ContextCommand::REMOVE_SPLINE_PT: {
Allow removing spline points.
2016-04-07 14:44:56 +00:00
hRequest hr = gs.point[0].request();
Request *r = SK.GetRequest(hr);
int index = r->IndexOfPoint(gs.point[0]);
Replace all oops() checks with ssassert()s. This includes explanation and context for non-obvious cases and shortens debug cycles when just-in-time debugging is not available (like on Linux) by immediately printing description of the assert as well as symbolized backtrace.
2016-05-18 22:51:36 +00:00
ssassert(r->extraPoints != 0, "Expected a bezier with interior control points");
Allow removing spline points.
2016-04-07 14:44:56 +00:00
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();
break;
}
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case ContextCommand::ADD_SPLINE_PT: {
Allow adding spline points.
2016-04-08 08:20:42 +00:00
hRequest hr = gs.entity[0].request();
Request *r = SK.GetRequest(hr);
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
int pointCount = r->extraPoints + ((r->type == Request::Type::CUBIC_PERIODIC) ? 3 : 4);
Allow adding spline points.
2016-04-08 08:20:42 +00:00
if(pointCount < MAX_POINTS_IN_ENTITY) {
SS.UndoRemember();
r->extraPoints++;
SS.MarkGroupDirtyByEntity(gs.entity[0]);
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
SS.GenerateAll(SolveSpaceUI::Generate::REGEN);
Allow adding spline points.
2016-04-08 08:20:42 +00:00
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();
} else {
Internationalize all messages without substitutions.
2017-01-07 06:41:13 +00:00
Error(_("Cannot add spline point: maximum number of points reached."));
Allow adding spline points.
2016-04-08 08:20:42 +00:00
}
break;
}
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case ContextCommand::GROUP_INFO: {
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
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 {
break;
}
ClearSelection();
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
SS.TW.GoToScreen(TextWindow::Screen::GROUP_INFO);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
SS.TW.shown.group = hg;
Add a GTK2/3 port. In principle, GTK3 is the way forward, and GTK2 is officially deprecated, though still maintained. In practice however, GTK3 is often unbearably buggy; e.g. on my system, combo boxes don't ever roll up in GTK3 windows. So I have added support for both. This required a few minor changes to the core, namely: * GTK wants to know beforehand whether a menu item is a check menu item or a regular one. * GTK doesn't give us an easy way to execute something after any event is processed, so an explicit idle timer is added. This is a no-op on Win32. * A few function signatures were const'ed, since GTK expects immutable strings when converting to Glib::ustring.
2015-03-18 17:02:11 +00:00
SS.ScheduleShowTW();
Forcibly show text window on some context menu actions. Specifically: * Group Info * Style Info * Assign to Style → Newly Created Custom Style... These context actions are meaningless without viewing or manipulating text window.
2016-04-17 14:51:53 +00:00
ForceTextWindowShown();
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
break;
}
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case ContextCommand::STYLE_INFO: {
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
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) {
DXF: export color as indexed, not RGB. The version of AutoCAD we advertise is unable to read RGB color, so software attempting to be compatible with it ignores color attributes.
2016-05-07 10:54:44 +00:00
hs = SK.GetConstraint(gs.constraint[0])->GetStyle();
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
} else {
break;
}
ClearSelection();
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
SS.TW.GoToScreen(TextWindow::Screen::STYLE_INFO);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
SS.TW.shown.style = hs;
Add a GTK2/3 port. In principle, GTK3 is the way forward, and GTK2 is officially deprecated, though still maintained. In practice however, GTK3 is often unbearably buggy; e.g. on my system, combo boxes don't ever roll up in GTK3 windows. So I have added support for both. This required a few minor changes to the core, namely: * GTK wants to know beforehand whether a menu item is a check menu item or a regular one. * GTK doesn't give us an easy way to execute something after any event is processed, so an explicit idle timer is added. This is a no-op on Win32. * A few function signatures were const'ed, since GTK expects immutable strings when converting to Glib::ustring.
2015-03-18 17:02:11 +00:00
SS.ScheduleShowTW();
Forcibly show text window on some context menu actions. Specifically: * Group Info * Style Info * Assign to Style → Newly Created Custom Style... These context actions are meaningless without viewing or manipulating text window.
2016-04-17 14:51:53 +00:00
ForceTextWindowShown();
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
break;
}
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case ContextCommand::NEW_CUSTOM_STYLE: {
Use C99 integer types and C++ boolean types/values This change comprehensively replaces the use of Microsoft-standard integer and boolean types with their C99/C++ standard equivalents, as the latter is more appropriate for a cross-platform application. With matter-of-course exceptions in the Win32-specific code, the types/values have been converted as follows: QWORD --> uint64_t SQWORD --> int64_t DWORD --> uint32_t SDWORD --> int32_t WORD --> uint16_t SWORD --> int16_t BYTE --> uint8_t BOOL --> bool TRUE --> true FALSE --> false The following related changes are also included: * Added C99 integer type definitions for Windows, as stdint.h is not available prior to Visual Studio 2010 * Changed types of some variables in the SolveSpace class from 'int' to 'bool', as they actually represent boolean settings * Implemented new Cnf{Freeze,Thaw}Bool() functions to support boolean variables in the Registry * Cnf{Freeze,Thaw}DWORD() are now Cnf{Freeze,Thaw}Int() * TtfFont::Get{WORD,DWORD}() are now TtfFont::Get{USHORT,ULONG}() (names inspired by the OpenType spec) * RGB colors are packed into an integer of type uint32_t (nee DWORD), but in a few places, these were represented by an int; these have been corrected to uint32_t
2013-10-02 05:45:13 +00:00
uint32_t v = Style::CreateCustomStyle();
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Style::AssignSelectionToStyle(v);
Forcibly show text window on some context menu actions. Specifically: * Group Info * Style Info * Assign to Style → Newly Created Custom Style... These context actions are meaningless without viewing or manipulating text window.
2016-04-17 14:51:53 +00:00
ForceTextWindowShown();
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
break;
}
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case ContextCommand::NO_STYLE:
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Style::AssignSelectionToStyle(0);
break;
default:
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
ssassert(ret >= ContextCommand::FIRST_STYLE, "Expected a style to be chosen");
Style::AssignSelectionToStyle((uint32_t)ret - (uint32_t)ContextCommand::FIRST_STYLE);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
break;
}
context.active = false;
Add a GTK2/3 port. In principle, GTK3 is the way forward, and GTK2 is officially deprecated, though still maintained. In practice however, GTK3 is often unbearably buggy; e.g. on my system, combo boxes don't ever roll up in GTK3 windows. So I have added support for both. This required a few minor changes to the core, namely: * GTK wants to know beforehand whether a menu item is a check menu item or a regular one. * GTK doesn't give us an easy way to execute something after any event is processed, so an explicit idle timer is added. This is a no-op on Win32. * A few function signatures were const'ed, since GTK expects immutable strings when converting to Glib::ustring.
2015-03-18 17:02:11 +00:00
SS.ScheduleShowTW();
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
}
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
hRequest GraphicsWindow::AddRequest(Request::Type type) {
Annotate constants passed as boolean function arguments. This is to ensure that: * it is clear, when looking at the point of usage, what is the purpose of "true" or "false"; * when refactoring, a simple search will bring up any places that need to be changed. Also, argument names were synchronized between declaration and implementation. As an exception, these are not annotated: * Printf(/*halfLine=*/), to avoid pointless churn.
2016-05-25 12:08:19 +00:00
return AddRequest(type, /*rememberForUndo=*/true);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
}
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
hRequest GraphicsWindow::AddRequest(Request::Type type, bool rememberForUndo) {
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
if(rememberForUndo) SS.UndoRemember();
Replace all ZERO and memset with C++11 brace-initialization. This will allow us to use non-POD classes inside these objects in future and is otherwise functionally equivalent, as well as more concise. Note that there are some subtleties with handling of brace-initialization. Specifically: On aggregates (e.g. simple C-style structures) using an empty brace-initializer zero-initializes the aggregate, i.e. it makes all members zero. On non-aggregates an empty brace-initializer calls the default constructor. And if the constructor doesn't explicitly initialize the members (which the auto-generated constructor doesn't) then the members will be constructed but otherwise uninitialized. So, what is an aggregate class? To quote the C++ standard (C++03 8.5.1 §1): An aggregate is an array or a class (clause 9) with no user-declared constructors (12.1), no private or protected non-static data members (clause 11), no base classes (clause 10), and no virtual functions (10.3). In SolveSpace, we only have to handle the case of base classes; Constraint and Entity have those. Thus, they had to gain a default constructor that does nothing but initializes the members to zero.
2015-03-27 15:31:23 +00:00
Request r = {};
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
r.group = activeGroup;
Group *g = SK.GetGroup(activeGroup);
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(g->type == Group::Type::DRAWING_3D || g->type == Group::Type::DRAWING_WORKPLANE) {
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
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.
Don't regenerate the entire sketch in AddRequest(). This is unnecessary and leads to huge slowdowns on large sketches. E.g. this speeds up import of a certain large DXF from ~60s to ~3s.
2016-10-10 20:33:02 +00:00
r.Generate(&SK.entity, &SK.param);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
SS.MarkGroupDirty(r.group);
return r.h;
}
bool GraphicsWindow::ConstrainPointByHovered(hEntity pt) {
if(!hover.entity.v) return false;
Entity *e = SK.GetEntity(hover.entity);
if(e->IsPoint()) {
Constraint::ConstrainCoincident(e->h, pt);
return true;
}
if(e->IsCircle()) {
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
Constraint::Constrain(Constraint::Type::PT_ON_CIRCLE,
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
pt, Entity::NO_ENTITY, e->h);
return true;
}
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(e->type == Entity::Type::LINE_SEGMENT) {
Constraint::Constrain(Constraint::Type::PT_ON_LINE,
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
pt, Entity::NO_ENTITY, e->h);
return true;
}
return false;
}
void GraphicsWindow::MouseLeftDown(double mx, double my) {
Add ability to set a background image. I import a png with libpng, load it as a texture, and show it instead of a flat-color background. Includes user interface to specify scale and translation of image, but the rotation is always aligned to the view. [git-p4: depot-paths = "//depot/solvespace/": change = 2071]
2009-11-08 01:11:38 +00:00
orig.mouseDown = true;
Hide the text or graphics edit control when the user left-clicks somewhere in the text or graphics window. Previously, those left-clicks just did nothing. [git-p4: depot-paths = "//depot/solvespace/": change = 2100]
2010-01-08 09:55:22 +00:00
if(GraphicsEditControlIsVisible()) {
orig.mouse = Point2d::From(mx, my);
orig.mouseOnButtonDown = orig.mouse;
HideGraphicsEditControl();
return;
}
Put wrappers around the functions to show and hide the edit control in the text window. This means that I can move the conversion from half-row and column to (x, y) into the platform-independent code, and that I'll be ready to add my color picker. [git-p4: depot-paths = "//depot/solvespace/": change = 2171]
2010-07-12 07:51:12 +00:00
SS.TW.HideEditControl();
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
if(SS.showToolbar) {
if(ToolbarMouseDown((int)mx, (int)my)) return;
}
Fix disabling of autoconstrainter via Ctrl.
2016-06-11 22:26:36 +00:00
// This will be clobbered by MouseMoved below.
bool hasConstraintSuggestion = SS.GW.pending.hasSuggestion;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
// Make sure the hover is up to date.
Show "Paste" context menu item even when only constraints are copied.
2016-06-20 13:47:14 +00:00
MouseMoved(mx, my, /*leftDown=*/false, /*middleDown=*/false, /*rightDown=*/false,
Annotate constants passed as boolean function arguments. This is to ensure that: * it is clear, when looking at the point of usage, what is the purpose of "true" or "false"; * when refactoring, a simple search will bring up any places that need to be changed. Also, argument names were synchronized between declaration and implementation. As an exception, these are not annotated: * Printf(/*halfLine=*/), to avoid pointless churn.
2016-05-25 12:08:19 +00:00
/*shiftDown=*/false, /*ctrlDown=*/false);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
orig.mouse.x = mx;
orig.mouse.y = my;
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
orig.mouseOnButtonDown = orig.mouse;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
// The current mouse location
Vector v = offset.ScaledBy(-1);
v = v.Plus(projRight.ScaledBy(mx/scale));
v = v.Plus(projUp.ScaledBy(my/scale));
Forcibly show the current group once we start a drawing operation.
2016-08-07 12:59:51 +00:00
hRequest hr = {};
hConstraint hc = {};
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
switch(pending.operation) {
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
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));
ClearSuper();
break;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Command::LINE_SEGMENT:
case Command::CONSTR_SEGMENT:
hr = AddRequest(Request::Type::LINE_SEGMENT);
Do not hover or select entities from any pending request.
2017-01-09 16:54:24 +00:00
AddToPending(hr);
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
SK.GetRequest(hr)->construction = (pending.command == Command::CONSTR_SEGMENT);
SK.GetEntity(hr.entity(1))->PointForceTo(v);
ConstrainPointByHovered(hr.entity(1));
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
ClearSuper();
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
pending.operation = Pending::DRAGGING_NEW_LINE_POINT;
pending.request = hr;
pending.point = hr.entity(2);
Internationalize all messages without substitutions.
2017-01-07 06:41:13 +00:00
pending.description = _("click next point of line, or press Esc");
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
SK.GetEntity(pending.point)->PointForceTo(v);
break;
Put information about which requests generate which entities, and how many points are associated with each, into a single table. [git-p4: depot-paths = "//depot/solvespace/": change = 2056]
2009-10-22 14:02:08 +00:00
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Command::RECTANGLE: {
if(!SS.GW.LockedInWorkplane()) {
Internationalize all messages without substitutions.
2017-01-07 06:41:13 +00:00
Error(_("Can't draw rectangle in 3d; first, activate a workplane "
"with Sketch -> In Workplane."));
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
ClearSuper();
break;
}
hRequest lns[4];
int i;
SS.UndoRemember();
for(i = 0; i < 4; i++) {
Annotate constants passed as boolean function arguments. This is to ensure that: * it is clear, when looking at the point of usage, what is the purpose of "true" or "false"; * when refactoring, a simple search will bring up any places that need to be changed. Also, argument names were synchronized between declaration and implementation. As an exception, these are not annotated: * Printf(/*halfLine=*/), to avoid pointless churn.
2016-05-25 12:08:19 +00:00
lns[i] = AddRequest(Request::Type::LINE_SEGMENT, /*rememberForUndo=*/false);
Do not hover or select entities from any pending request.
2017-01-09 16:54:24 +00:00
AddToPending(lns[i]);
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
}
for(i = 0; i < 4; i++) {
Constraint::ConstrainCoincident(
lns[i].entity(1), lns[(i+1)%4].entity(2));
SK.GetEntity(lns[i].entity(1))->PointForceTo(v);
SK.GetEntity(lns[i].entity(2))->PointForceTo(v);
}
for(i = 0; i < 4; i++) {
Constraint::Constrain(
(i % 2) ? Constraint::Type::HORIZONTAL : Constraint::Type::VERTICAL,
Entity::NO_ENTITY, Entity::NO_ENTITY,
lns[i].entity(0));
}
ConstrainPointByHovered(lns[2].entity(1));
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
pending.operation = Pending::DRAGGING_NEW_POINT;
pending.point = lns[1].entity(2);
Internationalize all messages without substitutions.
2017-01-07 06:41:13 +00:00
pending.description = _("click to place other corner of rectangle");
Forcibly show the current group once we start a drawing operation.
2016-08-07 12:59:51 +00:00
hr = lns[0];
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
break;
}
case Command::CIRCLE:
hr = AddRequest(Request::Type::CIRCLE);
// Centered where we clicked
SK.GetEntity(hr.entity(1))->PointForceTo(v);
// Normal to the screen
SK.GetEntity(hr.entity(32))->NormalForceTo(
Quaternion::From(SS.GW.projRight, SS.GW.projUp));
// Initial radius zero
SK.GetEntity(hr.entity(64))->DistanceForceTo(0);
ConstrainPointByHovered(hr.entity(1));
ClearSuper();
pending.operation = Pending::DRAGGING_NEW_RADIUS;
pending.circle = hr.entity(0);
Internationalize all messages without substitutions.
2017-01-07 06:41:13 +00:00
pending.description = _("click to set radius");
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
break;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Command::ARC: {
if(!SS.GW.LockedInWorkplane()) {
Internationalize all messages without substitutions.
2017-01-07 06:41:13 +00:00
Error(_("Can't draw arc in 3d; first, activate a workplane "
"with Sketch -> In Workplane."));
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
ClearPending();
break;
}
hr = AddRequest(Request::Type::ARC_OF_CIRCLE);
Do not hover or select entities from any pending request.
2017-01-09 16:54:24 +00:00
AddToPending(hr);
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
// This fudge factor stops us from immediately failing to solve
// because of the arc's implicit (equal radius) tangent.
Vector adj = SS.GW.projRight.WithMagnitude(2/SS.GW.scale);
SK.GetEntity(hr.entity(1))->PointForceTo(v.Minus(adj));
SK.GetEntity(hr.entity(2))->PointForceTo(v);
SK.GetEntity(hr.entity(3))->PointForceTo(v);
ConstrainPointByHovered(hr.entity(2));
ClearSuper();
pending.operation = Pending::DRAGGING_NEW_ARC_POINT;
pending.point = hr.entity(3);
Internationalize all messages without substitutions.
2017-01-07 06:41:13 +00:00
pending.description = _("click to place point");
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
break;
}
case Command::CUBIC:
hr = AddRequest(Request::Type::CUBIC);
Do not hover or select entities from any pending request.
2017-01-09 16:54:24 +00:00
AddToPending(hr);
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
SK.GetEntity(hr.entity(1))->PointForceTo(v);
SK.GetEntity(hr.entity(2))->PointForceTo(v);
SK.GetEntity(hr.entity(3))->PointForceTo(v);
SK.GetEntity(hr.entity(4))->PointForceTo(v);
ConstrainPointByHovered(hr.entity(1));
ClearSuper();
pending.operation = Pending::DRAGGING_NEW_CUBIC_POINT;
pending.point = hr.entity(4);
Internationalize all messages without substitutions.
2017-01-07 06:41:13 +00:00
pending.description = _("click next point of cubic, or press Esc");
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
break;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Command::WORKPLANE:
if(LockedInWorkplane()) {
Internationalize all messages without substitutions.
2017-01-07 06:41:13 +00:00
Error(_("Sketching in a workplane already; sketch in 3d before "
"creating new workplane."));
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
ClearSuper();
break;
}
hr = AddRequest(Request::Type::WORKPLANE);
SK.GetEntity(hr.entity(1))->PointForceTo(v);
SK.GetEntity(hr.entity(32))->NormalForceTo(
Quaternion::From(SS.GW.projRight, SS.GW.projUp));
ConstrainPointByHovered(hr.entity(1));
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
ClearSuper();
break;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Command::TTF_TEXT: {
if(!SS.GW.LockedInWorkplane()) {
Internationalize all messages without substitutions.
2017-01-07 06:41:13 +00:00
Error(_("Can't draw text in 3d; first, activate a workplane "
"with Sketch -> In Workplane."));
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
ClearSuper();
break;
}
hr = AddRequest(Request::Type::TTF_TEXT);
Request *r = SK.GetRequest(hr);
r->str = "Abc";
r->font = "arial.ttf";
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
SK.GetEntity(hr.entity(1))->PointForceTo(v);
SK.GetEntity(hr.entity(2))->PointForceTo(v);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
pending.operation = Pending::DRAGGING_NEW_POINT;
pending.point = hr.entity(2);
Internationalize all messages without substitutions.
2017-01-07 06:41:13 +00:00
pending.description = _("click to place bottom left of text");
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
break;
}
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Command::COMMENT: {
ClearSuper();
Constraint c = {};
c.group = SS.GW.activeGroup;
c.workplane = SS.GW.ActiveWorkplane();
c.type = Constraint::Type::COMMENT;
c.disp.offset = v;
Internationalize all messages without substitutions.
2017-01-07 06:41:13 +00:00
c.comment = _("NEW COMMENT -- DOUBLE-CLICK TO EDIT");
Forcibly show the current group once we start a drawing operation.
2016-08-07 12:59:51 +00:00
hc = Constraint::AddConstraint(&c);
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
break;
}
default: ssassert(false, "Unexpected pending menu id");
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
}
break;
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Pending::DRAGGING_RADIUS:
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
ClearPending();
break;
Automatically constrain arc or rectangle points.
2017-01-11 04:16:48 +00:00
case Pending::DRAGGING_NEW_POINT:
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Pending::DRAGGING_NEW_ARC_POINT:
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
ConstrainPointByHovered(pending.point);
ClearPending();
break;
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Pending::DRAGGING_NEW_CUBIC_POINT: {
Add interpolating splines: both periodic splines (that form a loop), and open-ended splines, with their tangents specified at their endpoints. Also change constraint solver matrix size to 1024, on the theory that a power of two will generate better array indexing, and replace fabs() with my own function that for some reason is faster. [git-p4: depot-paths = "//depot/solvespace/": change = 2055]
2009-10-21 04:46:01 +00:00
hRequest hr = pending.point.request();
Request *r = SK.GetRequest(hr);
if(hover.entity.v == hr.entity(1).v && r->extraPoints >= 2) {
// They want the endpoints coincident, which means a periodic
// spline instead.
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
r->type = Request::Type::CUBIC_PERIODIC;
Add interpolating splines: both periodic splines (that form a loop), and open-ended splines, with their tangents specified at their endpoints. Also change constraint solver matrix size to 1024, on the theory that a power of two will generate better array indexing, and replace fabs() with my own function that for some reason is faster. [git-p4: depot-paths = "//depot/solvespace/": change = 2055]
2009-10-21 04:46:01 +00:00
// Remove the off-curve control points, which are no longer
// needed here; so move [2,ep+1] down, skipping first pt.
int i;
for(i = 2; i <= r->extraPoints+1; i++) {
SK.GetEntity(hr.entity((i-1)+1))->PointForceTo(
SK.GetEntity(hr.entity(i+1))->PointGetNum());
}
// and move ep+3 down by two, skipping both
SK.GetEntity(hr.entity((r->extraPoints+1)+1))->PointForceTo(
SK.GetEntity(hr.entity((r->extraPoints+3)+1))->PointGetNum());
r->extraPoints -= 2;
// And we're done.
SS.MarkGroupDirty(r->group);
ClearPending();
break;
}
if(ConstrainPointByHovered(pending.point)) {
ClearPending();
break;
}
Entity e;
Use casts to bridge mismatches in integer-type sizes and signedness The compiler gets nervous when we (for example) pass in a size_t as an int parameter, or assign an int to a char, or assign -1 to an unsigned type. By adding appropriate casts, we inform the compiler that, yes, we know what we're doing. This change also upgrades a va_arg() type from char to int, as char is always promoted to int when passed through '...'.
2013-08-26 20:09:15 +00:00
if(r->extraPoints >= (int)arraylen(e.point) - 4) {
Add interpolating splines: both periodic splines (that form a loop), and open-ended splines, with their tangents specified at their endpoints. Also change constraint solver matrix size to 1024, on the theory that a power of two will generate better array indexing, and replace fabs() with my own function that for some reason is faster. [git-p4: depot-paths = "//depot/solvespace/": change = 2055]
2009-10-21 04:46:01 +00:00
ClearPending();
break;
}
(SK.GetRequest(hr)->extraPoints)++;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
SS.GenerateAll(SolveSpaceUI::Generate::REGEN);
Add interpolating splines: both periodic splines (that form a loop), and open-ended splines, with their tangents specified at their endpoints. Also change constraint solver matrix size to 1024, on the theory that a power of two will generate better array indexing, and replace fabs() with my own function that for some reason is faster. [git-p4: depot-paths = "//depot/solvespace/": change = 2055]
2009-10-21 04:46:01 +00:00
int ep = r->extraPoints;
Vector last = SK.GetEntity(hr.entity(3+ep))->PointGetNum();
SK.GetEntity(hr.entity(2+ep))->PointForceTo(last);
SK.GetEntity(hr.entity(3+ep))->PointForceTo(v);
SK.GetEntity(hr.entity(4+ep))->PointForceTo(v);
pending.point = hr.entity(4+ep);
break;
}
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Pending::DRAGGING_NEW_LINE_POINT: {
Automatically add horz/vert constraints to lines if close enough.
2015-03-29 22:26:07 +00:00
// Constrain the line segment horizontal or vertical if close enough
Fix disabling of autoconstrainter via Ctrl.
2016-06-11 22:26:36 +00:00
if(hasConstraintSuggestion) {
Disable autoconstrainer while Ctrl is held.
2016-04-02 08:29:32 +00:00
Constraint::Constrain(SS.GW.pending.suggestion,
Automatically add horz/vert constraints to lines if close enough.
2015-03-29 22:26:07 +00:00
Entity::NO_ENTITY, Entity::NO_ENTITY, pending.request.entity(0));
}
A big nasty change, originally just to add paste transformed. So it does that, and adds a scale factor to that transformation (instead of just mirroring, as before), but also: * Replace the "import mirrored" mechanism with a scale factor, which if negative corresponds to a reflection as well. * Fix self-intersection checker to report a meaningful point when edges are collinear. * Don't blow an assertion on some types of invalid file; instead provide a nice error message to the user. * Clear the naked edges before each regen. * Don't create zero-length line segments by snapping a line segment's end to its beginning. [git-p4: depot-paths = "//depot/solvespace/": change = 2086]
2009-12-15 12:26:22 +00:00
if(hover.entity.v) {
Entity *e = SK.GetEntity(hover.entity);
if(e->IsPoint()) {
hRequest hrl = pending.point.request();
Entity *sp = SK.GetEntity(hrl.entity(1));
if(( e->PointGetNum()).Equals(
(sp->PointGetNum())))
{
// If we constrained by the hovered point, then we
// would create a zero-length line segment. That's
// not good, so just stop drawing.
ClearPending();
break;
}
}
}
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
if(ConstrainPointByHovered(pending.point)) {
ClearPending();
break;
}
A big nasty change, originally just to add paste transformed. So it does that, and adds a scale factor to that transformation (instead of just mirroring, as before), but also: * Replace the "import mirrored" mechanism with a scale factor, which if negative corresponds to a reflection as well. * Fix self-intersection checker to report a meaningful point when edges are collinear. * Don't blow an assertion on some types of invalid file; instead provide a nice error message to the user. * Clear the naked edges before each regen. * Don't create zero-length line segments by snapping a line segment's end to its beginning. [git-p4: depot-paths = "//depot/solvespace/": change = 2086]
2009-12-15 12:26:22 +00:00
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
// Create a new line segment, so that we continue drawing.
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
hRequest hr = AddRequest(Request::Type::LINE_SEGMENT);
Add a shortcut for drawing construction line segments. Almost all construction requests are lines, and allowing to draw them as construction obviates the need to select them one by one afterwards to convert them. Also, it removes the "not closed contour" error message, which is a nice usability improvement.
2015-07-06 02:45:28 +00:00
SK.GetRequest(hr)->construction = SK.GetRequest(pending.request)->construction;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
SK.GetEntity(hr.entity(1))->PointForceTo(v);
Don't create new line segments as zero-length when left-clicking to draw more line segments, to avoid annoying warnings. [git-p4: depot-paths = "//depot/solvespace/": change = 2083]
2009-12-03 19:47:44 +00:00
// Displace the second point of the new line segment slightly,
// to avoid creating zero-length edge warnings.
SK.GetEntity(hr.entity(2))->PointForceTo(
v.Plus(projRight.ScaledBy(0.5/scale)));
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
// Constrain the line segments to share an endpoint
Constraint::ConstrainCoincident(pending.point, hr.entity(1));
// And drag an endpoint of the new line segment
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
pending.operation = Pending::DRAGGING_NEW_LINE_POINT;
Automatically add horz/vert constraints to lines if close enough.
2015-03-29 22:26:07 +00:00
pending.request = hr;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
pending.point = hr.entity(2);
Internationalize all messages without substitutions.
2017-01-07 06:41:13 +00:00
pending.description = _("click next point of line, or press Esc");
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
break;
}
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Pending::NONE:
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
default:
ClearPending();
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
if(!hover.IsEmpty()) {
hoverWasSelectedOnMousedown = IsSelected(&hover);
MakeSelected(&hover);
Tweak drag and selection behavior: selection is kept after dragging selected entities, but cleared after dragging an unselected entity. Marquee selection is select-only (not toggle), and "Select All" replaces "Invert Selection". Left-click on nothing will clear the selection. Also add context menu entries for cut, copy, and paste. [git-p4: depot-paths = "//depot/solvespace/": change = 2089]
2009-12-21 16:44:00 +00:00
}
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
break;
}
Forcibly show the current group once we start a drawing operation.
2016-08-07 12:59:51 +00:00
// Activate group with newly created request/constraint
Group *g = NULL;
if(hr.v != 0) {
g = SK.GetGroup(SK.GetRequest(hr)->group);
}
if(hc.v != 0) {
g = SK.GetGroup(SK.GetConstraint(hc)->group);
}
if(g != NULL) {
g->visible = true;
}
Add a GTK2/3 port. In principle, GTK3 is the way forward, and GTK2 is officially deprecated, though still maintained. In practice however, GTK3 is often unbearably buggy; e.g. on my system, combo boxes don't ever roll up in GTK3 windows. So I have added support for both. This required a few minor changes to the core, namely: * GTK wants to know beforehand whether a menu item is a check menu item or a regular one. * GTK doesn't give us an easy way to execute something after any event is processed, so an explicit idle timer is added. This is a no-op on Win32. * A few function signatures were const'ed, since GTK expects immutable strings when converting to Glib::ustring.
2015-03-18 17:02:11 +00:00
SS.ScheduleShowTW();
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
InvalidateGraphics();
}
void GraphicsWindow::MouseLeftUp(double mx, double my) {
Add ability to set a background image. I import a png with libpng, load it as a texture, and show it instead of a flat-color background. Includes user interface to specify scale and translation of image, but the rotation is always aligned to the view. [git-p4: depot-paths = "//depot/solvespace/": change = 2071]
2009-11-08 01:11:38 +00:00
orig.mouseDown = false;
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
hoverWasSelectedOnMousedown = false;
Add ability to set a background image. I import a png with libpng, load it as a texture, and show it instead of a flat-color background. Includes user interface to specify scale and translation of image, but the rotation is always aligned to the view. [git-p4: depot-paths = "//depot/solvespace/": change = 2071]
2009-11-08 01:11:38 +00:00
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
switch(pending.operation) {
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Pending::DRAGGING_POINTS:
Fix some cases where the green line (that indicates the center of an in-plane rotation of the view, or of a set of entities) would remain on screen after the action was over. [git-p4: depot-paths = "//depot/solvespace/": change = 2142]
2010-05-12 04:47:58 +00:00
SS.extraLine.draw = false;
// fall through
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Pending::DRAGGING_CONSTRAINT:
case Pending::DRAGGING_NORMAL:
case Pending::DRAGGING_RADIUS:
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
ClearPending();
Add marquee selection, a view-aligned rectangle such that everything even partially within that rectangle gets selected when I release. Also make deselecting a point deselect all coincident points too; otherwise there now exist ways to select both coincident points, which meant that it was impossible to deselect the lower one. And fix text window to show selection info even if just constraints are selected, seems more consistent. [git-p4: depot-paths = "//depot/solvespace/": change = 2066]
2009-11-04 07:52:58 +00:00
InvalidateGraphics();
break;
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Pending::DRAGGING_MARQUEE:
Add marquee selection, a view-aligned rectangle such that everything even partially within that rectangle gets selected when I release. Also make deselecting a point deselect all coincident points too; otherwise there now exist ways to select both coincident points, which meant that it was impossible to deselect the lower one. And fix text window to show selection info even if just constraints are selected, seems more consistent. [git-p4: depot-paths = "//depot/solvespace/": change = 2066]
2009-11-04 07:52:58 +00:00
SelectByMarquee();
ClearPending();
InvalidateGraphics();
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
break;
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
case Pending::NONE:
Tweak drag and selection behavior: selection is kept after dragging selected entities, but cleared after dragging an unselected entity. Marquee selection is select-only (not toggle), and "Select All" replaces "Invert Selection". Left-click on nothing will clear the selection. Also add context menu entries for cut, copy, and paste. [git-p4: depot-paths = "//depot/solvespace/": change = 2089]
2009-12-21 16:44:00 +00:00
// We need to clear the selection here, and not in the mouse down
// event, since a mouse down without anything hovered could also
// be the start of marquee selection. But don't do that on the
// left click to cancel a context menu. The time delay is an ugly
// hack.
Trim trailing whitespace.
2015-03-29 00:30:52 +00:00
if(hover.IsEmpty() &&
Tweak drag and selection behavior: selection is kept after dragging selected entities, but cleared after dragging an unselected entity. Marquee selection is select-only (not toggle), and "Select All" replaces "Invert Selection". Left-click on nothing will clear the selection. Also add context menu entries for cut, copy, and paste. [git-p4: depot-paths = "//depot/solvespace/": change = 2089]
2009-12-21 16:44:00 +00:00
(contextMenuCancelTime == 0 ||
(GetMilliseconds() - contextMenuCancelTime) > 200))
{
ClearSelection();
}
break;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
default:
break; // do nothing
}
}
void GraphicsWindow::MouseLeftDoubleClick(double mx, double my) {
if(GraphicsEditControlIsVisible()) return;
Put wrappers around the functions to show and hide the edit control in the text window. This means that I can move the conversion from half-row and column to (x, y) into the platform-independent code, and that I'll be ready to add my color picker. [git-p4: depot-paths = "//depot/solvespace/": change = 2171]
2010-07-12 07:51:12 +00:00
SS.TW.HideEditControl();
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
if(hover.constraint.v) {
constraintBeingEdited = hover.constraint;
ClearSuper();
Constraint *c = SK.GetConstraint(constraintBeingEdited);
Oops, it was possible to edit the dimension for any constraint, not just those that actually have associated dimensions. Amazing how long that bug's been sitting there. [git-p4: depot-paths = "//depot/solvespace/": change = 2099]
2010-01-08 09:40:47 +00:00
if(!c->HasLabel()) {
// Not meaningful to edit a constraint without a dimension
return;
}
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
if(c->reference) {
// Not meaningful to edit a reference dimension
return;
}
Abstract all (ex-OpenGL) drawing operations into a Canvas interface. This has several desirable consequences: * It is now possible to port SolveSpace to a later version of OpenGL, such as OpenGLES 2, so that it runs on platforms that only have that OpenGL version; * The majority of geometry is now rendered without references to the camera in C++ code, so a renderer can now submit it to the video card once and re-rasterize with a different projection matrix every time the projection is changed, avoiding expensive reuploads; * The DOGD (draw or get distance) interface is now a straightforward Canvas implementation; * There are no more direct references to SS.GW.(projection) in sketch rendering code, which allows rendering to multiple viewports; * There are no more unnecessary framebuffer flips on CPU on Cocoa and GTK; * The platform-dependent GL code is now confined to rendergl1.cpp. * The Microsoft and Apple headers required by it that are prone to identifier conflicts are no longer included globally; * The rendergl1.cpp implementation can now be omitted from compilation to run SolveSpace headless or with a different OpenGL version. Note these implementation details of Canvas: * GetCamera currently always returns a reference to the field `Camera camera;`. This is so that a future renderer that caches geometry in the video memory can define it as asserting, which would provide assurance against code that could accidentally put something projection-dependent in the cache; * Line and triangle rendering is specified through a level of indirection, hStroke and hFill. This is so that a future renderer that batches geometry could cheaply group identical styles. * DrawPixmap and DrawVectorText accept a (o,u,v) and not a matrix. This is so that a future renderer into an output format that uses 2d transforms (e.g. SVG) could easily derive those. Some additional internal changes were required to enable this: * Pixmap is now always passed as std::shared_ptr<{const ,}Pixmap>. This is so that the renderer could cache uploaded textures between API calls, which requires it to capture a (weak) reference. * The PlatformPathEqual function was properly extracted into platform-specific code. This is so that the <windows.h> header could be included only where needed (in platform/w32* as well as rendergl1.cpp). * The SBsp{2,3}::DebugDraw functions were removed. They can be rewritten using the Canvas API if they are ever needed. While no visual changes were originally intended, some minor fixes happened anyway: * The "emphasis" yellow line from top-left corner is now correctly rendered much wider. * The marquee rectangle is now pixel grid aligned. * The hidden entities now do not clobber the depth buffer, removing some minor artifacts. * The workplane "tab" now scales with the font used to render the workplane name. * The workplane name font is now taken from the normals style. * Workplane and constraint line stipple is insignificantly different. This is so that it can reuse the existing stipple codepaths; rendering of workplanes and constraints predates those. Some debug functionality was added: * In graphics window, an fps counter that becomes red when rendering under 60fps is drawn.
2016-05-31 00:55:13 +00:00
Vector p3 = c->GetLabelPos(GetCamera());
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Point2d p2 = ProjectPoint(p3);
Make graphics window edit control width fit the content. Before this commit, the graphics window edit control always had a width of 30 average character widths. After this commit, the edit control has a width of 5 average character widths (for numeric constraints) or 30 average character widths (for comment constraints), or just enough to display the entire value being edited, whichever is greater. This makes the edit control overlap the sketch less in case of editing numeric constraints (since in most cases, the numbers being edited are short), and removes annoying scrolling in case of editing long comments.
2016-04-16 00:10:32 +00:00
std::string editValue;
int editMinWidthChar;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
switch(c->type) {
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case Constraint::Type::COMMENT:
Make graphics window edit control width fit the content. Before this commit, the graphics window edit control always had a width of 30 average character widths. After this commit, the edit control has a width of 5 average character widths (for numeric constraints) or 30 average character widths (for comment constraints), or just enough to display the entire value being edited, whichever is greater. This makes the edit control overlap the sketch less in case of editing numeric constraints (since in most cases, the numbers being edited are short), and removes annoying scrolling in case of editing long comments.
2016-04-16 00:10:32 +00:00
editValue = c->comment;
editMinWidthChar = 30;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
break;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case Constraint::Type::ANGLE:
case Constraint::Type::LENGTH_RATIO:
Make graphics window edit control width fit the content. Before this commit, the graphics window edit control always had a width of 30 average character widths. After this commit, the edit control has a width of 5 average character widths (for numeric constraints) or 30 average character widths (for comment constraints), or just enough to display the entire value being edited, whichever is greater. This makes the edit control overlap the sketch less in case of editing numeric constraints (since in most cases, the numbers being edited are short), and removes annoying scrolling in case of editing long comments.
2016-04-16 00:10:32 +00:00
editValue = ssprintf("%.3f", c->valA);
editMinWidthChar = 5;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
break;
Make default text in dimension box the exact (up to ten digits after decimal) current value of the dimension, not the value truncated to the same number of digits that are usually displayed. And make the paste transformed screen accept expressions, not just integers, for the count, angle, and scale. [git-p4: depot-paths = "//depot/solvespace/": change = 2181]
2010-10-12 03:13:41 +00:00
default: {
double v = fabs(c->valA);
Allow displaying and editing diameter constraints as radius. The savefile format is not changed; the display option is stored in Constraint::other.
2015-03-22 13:07:49 +00:00
// If displayed as radius, also edit as radius.
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(c->type == Constraint::Type::DIAMETER && c->other)
Allow displaying and editing diameter constraints as radius. The savefile format is not changed; the display option is stored in Constraint::other.
2015-03-22 13:07:49 +00:00
v /= 2;
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
std::string def = SS.MmToString(v);
Make default text in dimension box the exact (up to ten digits after decimal) current value of the dimension, not the value truncated to the same number of digits that are usually displayed. And make the paste transformed screen accept expressions, not just integers, for the count, angle, and scale. [git-p4: depot-paths = "//depot/solvespace/": change = 2181]
2010-10-12 03:13:41 +00:00
double eps = 1e-12;
if(fabs(SS.StringToMm(def) - v) < eps) {
// Show value with default number of digits after decimal,
// which is at least enough to represent it exactly.
Make graphics window edit control width fit the content. Before this commit, the graphics window edit control always had a width of 30 average character widths. After this commit, the edit control has a width of 5 average character widths (for numeric constraints) or 30 average character widths (for comment constraints), or just enough to display the entire value being edited, whichever is greater. This makes the edit control overlap the sketch less in case of editing numeric constraints (since in most cases, the numbers being edited are short), and removes annoying scrolling in case of editing long comments.
2016-04-16 00:10:32 +00:00
editValue = def;
Make default text in dimension box the exact (up to ten digits after decimal) current value of the dimension, not the value truncated to the same number of digits that are usually displayed. And make the paste transformed screen accept expressions, not just integers, for the count, angle, and scale. [git-p4: depot-paths = "//depot/solvespace/": change = 2181]
2010-10-12 03:13:41 +00:00
} else {
// Show value with as many digits after decimal as
// required to represent it exactly, up to 10.
v /= SS.MmPerUnit();
int i;
for(i = 0; i <= 10; i++) {
Make graphics window edit control width fit the content. Before this commit, the graphics window edit control always had a width of 30 average character widths. After this commit, the edit control has a width of 5 average character widths (for numeric constraints) or 30 average character widths (for comment constraints), or just enough to display the entire value being edited, whichever is greater. This makes the edit control overlap the sketch less in case of editing numeric constraints (since in most cases, the numbers being edited are short), and removes annoying scrolling in case of editing long comments.
2016-04-16 00:10:32 +00:00
editValue = ssprintf("%.*f", i, v);
if(fabs(std::stod(editValue) - v) < eps) break;
Make default text in dimension box the exact (up to ten digits after decimal) current value of the dimension, not the value truncated to the same number of digits that are usually displayed. And make the paste transformed screen accept expressions, not just integers, for the count, angle, and scale. [git-p4: depot-paths = "//depot/solvespace/": change = 2181]
2010-10-12 03:13:41 +00:00
}
}
Make graphics window edit control width fit the content. Before this commit, the graphics window edit control always had a width of 30 average character widths. After this commit, the edit control has a width of 5 average character widths (for numeric constraints) or 30 average character widths (for comment constraints), or just enough to display the entire value being edited, whichever is greater. This makes the edit control overlap the sketch less in case of editing numeric constraints (since in most cases, the numbers being edited are short), and removes annoying scrolling in case of editing long comments.
2016-04-16 00:10:32 +00:00
editMinWidthChar = 5;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
break;
Make default text in dimension box the exact (up to ten digits after decimal) current value of the dimension, not the value truncated to the same number of digits that are usually displayed. And make the paste transformed screen accept expressions, not just integers, for the count, angle, and scale. [git-p4: depot-paths = "//depot/solvespace/": change = 2181]
2010-10-12 03:13:41 +00:00
}
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
}
Ensure edit control font size matches font size of text being edited. Before this commit, the position of the edit box was adjusted by trial and error, as far as I can tell. This commit changes the positioning machinery for edit controls as follows: The coordinates passed to ShowTextEditControl/ShowGraphicsEditControl now denote: X the left bound, and Y the baseline. The font height passed to ShowGraphicsEditControl denotes the absolute font height in pixels, i.e. ascent plus descent. Platform-dependent code uses these coordinates, the font metrics for the font appropriate for the platform, and the knowledge of the decorations drawn around the text by the native edit control to position the edit control in a way that overlays the text inside the edit control with the rendered text. On OS X, GNU Unifont (of height 16) has metrics identical to Monaco (of height 15) and so as an exception, the edit control is nudged slightly for a pixel-perfect fit. Also, since the built-in vector font is proportional, this commit also switches the edit control font to proportional when editing constraints.
2016-04-12 14:24:09 +00:00
hStyle hs = c->disp.style;
if(hs.v == 0) hs.v = Style::CONSTRAINT;
ShowGraphicsEditControl((int)p2.x, (int)p2.y,
Abstract all (ex-OpenGL) drawing operations into a Canvas interface. This has several desirable consequences: * It is now possible to port SolveSpace to a later version of OpenGL, such as OpenGLES 2, so that it runs on platforms that only have that OpenGL version; * The majority of geometry is now rendered without references to the camera in C++ code, so a renderer can now submit it to the video card once and re-rasterize with a different projection matrix every time the projection is changed, avoiding expensive reuploads; * The DOGD (draw or get distance) interface is now a straightforward Canvas implementation; * There are no more direct references to SS.GW.(projection) in sketch rendering code, which allows rendering to multiple viewports; * There are no more unnecessary framebuffer flips on CPU on Cocoa and GTK; * The platform-dependent GL code is now confined to rendergl1.cpp. * The Microsoft and Apple headers required by it that are prone to identifier conflicts are no longer included globally; * The rendergl1.cpp implementation can now be omitted from compilation to run SolveSpace headless or with a different OpenGL version. Note these implementation details of Canvas: * GetCamera currently always returns a reference to the field `Camera camera;`. This is so that a future renderer that caches geometry in the video memory can define it as asserting, which would provide assurance against code that could accidentally put something projection-dependent in the cache; * Line and triangle rendering is specified through a level of indirection, hStroke and hFill. This is so that a future renderer that batches geometry could cheaply group identical styles. * DrawPixmap and DrawVectorText accept a (o,u,v) and not a matrix. This is so that a future renderer into an output format that uses 2d transforms (e.g. SVG) could easily derive those. Some additional internal changes were required to enable this: * Pixmap is now always passed as std::shared_ptr<{const ,}Pixmap>. This is so that the renderer could cache uploaded textures between API calls, which requires it to capture a (weak) reference. * The PlatformPathEqual function was properly extracted into platform-specific code. This is so that the <windows.h> header could be included only where needed (in platform/w32* as well as rendergl1.cpp). * The SBsp{2,3}::DebugDraw functions were removed. They can be rewritten using the Canvas API if they are ever needed. While no visual changes were originally intended, some minor fixes happened anyway: * The "emphasis" yellow line from top-left corner is now correctly rendered much wider. * The marquee rectangle is now pixel grid aligned. * The hidden entities now do not clobber the depth buffer, removing some minor artifacts. * The workplane "tab" now scales with the font used to render the workplane name. * The workplane name font is now taken from the normals style. * Workplane and constraint line stipple is insignificantly different. This is so that it can reuse the existing stipple codepaths; rendering of workplanes and constraints predates those. Some debug functionality was added: * In graphics window, an fps counter that becomes red when rendering under 60fps is drawn.
2016-05-31 00:55:13 +00:00
(int)(VectorFont::Builtin()->GetHeight(Style::TextHeight(hs))),
Make graphics window edit control width fit the content. Before this commit, the graphics window edit control always had a width of 30 average character widths. After this commit, the edit control has a width of 5 average character widths (for numeric constraints) or 30 average character widths (for comment constraints), or just enough to display the entire value being edited, whichever is greater. This makes the edit control overlap the sketch less in case of editing numeric constraints (since in most cases, the numbers being edited are short), and removes annoying scrolling in case of editing long comments.
2016-04-16 00:10:32 +00:00
editMinWidthChar, editValue);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
}
}
Added const qualifiers to edit-control string handling FLTK's Fl_Input widget, instantiated as {Graphics,Text}EditControl, returns a 'const char *' string. In order to handle this properly, several of SolveSpace's internal routines needed to gain a "const" qualifier on the edit-control string argument.
2013-09-16 19:51:20 +00:00
void GraphicsWindow::EditControlDone(const char *s) {
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
HideGraphicsEditControl();
Constraint *c = SK.GetConstraint(constraintBeingEdited);
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(c->type == Constraint::Type::COMMENT) {
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
SS.UndoRemember();
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
c->comment = s;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
return;
}
Add a screen to edit the view parameters; scale, translation, rotation. Also clean up the handling of units, by putting the conversion factors in only one place, and clean up the expression-parsing but removing all the copies of the same error message. [git-p4: depot-paths = "//depot/solvespace/": change = 2093]
2010-01-04 00:35:28 +00:00
Expr *e = Expr::From(s, true);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
if(e) {
SS.UndoRemember();
switch(c->type) {
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case Constraint::Type::PROJ_PT_DISTANCE:
case Constraint::Type::PT_LINE_DISTANCE:
case Constraint::Type::PT_FACE_DISTANCE:
case Constraint::Type::PT_PLANE_DISTANCE:
case Constraint::Type::LENGTH_DIFFERENCE: {
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
// The sign is not displayed to the user, but this is a signed
// distance internally. To flip the sign, the user enters a
// negative distance.
bool wasNeg = (c->valA < 0);
if(wasNeg) {
c->valA = -SS.ExprToMm(e);
} else {
c->valA = SS.ExprToMm(e);
}
break;
}
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case Constraint::Type::ANGLE:
case Constraint::Type::LENGTH_RATIO:
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
// These don't get the units conversion for distance, and
// they're always positive
c->valA = fabs(e->Eval());
break;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case Constraint::Type::DIAMETER:
Allow displaying and editing diameter constraints as radius. The savefile format is not changed; the display option is stored in Constraint::other.
2015-03-22 13:07:49 +00:00
c->valA = fabs(SS.ExprToMm(e));
// If displayed and edited as radius, convert back
// to diameter
if(c->other)
c->valA *= 2;
break;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
default:
// These are always positive, and they get the units conversion.
c->valA = fabs(SS.ExprToMm(e));
break;
}
SS.MarkGroupDirty(c->group);
}
}
bool GraphicsWindow::KeyDown(int c) {
Use '\b' instead of ('h' - 'a' + 1)
2013-09-18 20:41:23 +00:00
if(c == '\b') {
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
// Treat backspace identically to escape.
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
MenuEdit(Command::UNSELECT_ALL);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
return true;
Alias the "=" key to "+" key.
2016-10-09 10:57:25 +00:00
} else if(c == '=') {
// 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;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
}
return false;
}
void GraphicsWindow::MouseScroll(double x, double y, int delta) {
double offsetRight = offset.Dot(projRight);
double offsetUp = offset.Dot(projUp);
double righti = x/scale - offsetRight;
double upi = y/scale - offsetUp;
if(delta > 0) {
scale *= 1.2;
Add a GTK2/3 port. In principle, GTK3 is the way forward, and GTK2 is officially deprecated, though still maintained. In practice however, GTK3 is often unbearably buggy; e.g. on my system, combo boxes don't ever roll up in GTK3 windows. So I have added support for both. This required a few minor changes to the core, namely: * GTK wants to know beforehand whether a menu item is a check menu item or a regular one. * GTK doesn't give us an easy way to execute something after any event is processed, so an explicit idle timer is added. This is a no-op on Win32. * A few function signatures were const'ed, since GTK expects immutable strings when converting to Glib::ustring.
2015-03-18 17:02:11 +00:00
} else if(delta < 0) {
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
scale /= 1.2;
Add a GTK2/3 port. In principle, GTK3 is the way forward, and GTK2 is officially deprecated, though still maintained. In practice however, GTK3 is often unbearably buggy; e.g. on my system, combo boxes don't ever roll up in GTK3 windows. So I have added support for both. This required a few minor changes to the core, namely: * GTK wants to know beforehand whether a menu item is a check menu item or a regular one. * GTK doesn't give us an easy way to execute something after any event is processed, so an explicit idle timer is added. This is a no-op on Win32. * A few function signatures were const'ed, since GTK expects immutable strings when converting to Glib::ustring.
2015-03-18 17:02:11 +00:00
} else return;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
double rightf = x/scale - offsetRight;
double upf = y/scale - offsetUp;
offset = offset.Plus(projRight.ScaledBy(rightf - righti));
offset = offset.Plus(projUp.ScaledBy(upf - upi));
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(SS.TW.shown.screen == TextWindow::Screen::EDIT_VIEW) {
Add a screen to edit the view parameters; scale, translation, rotation. Also clean up the handling of units, by putting the conversion factors in only one place, and clean up the expression-parsing but removing all the copies of the same error message. [git-p4: depot-paths = "//depot/solvespace/": change = 2093]
2010-01-04 00:35:28 +00:00
if(havePainted) {
Add a GTK2/3 port. In principle, GTK3 is the way forward, and GTK2 is officially deprecated, though still maintained. In practice however, GTK3 is often unbearably buggy; e.g. on my system, combo boxes don't ever roll up in GTK3 windows. So I have added support for both. This required a few minor changes to the core, namely: * GTK wants to know beforehand whether a menu item is a check menu item or a regular one. * GTK doesn't give us an easy way to execute something after any event is processed, so an explicit idle timer is added. This is a no-op on Win32. * A few function signatures were const'ed, since GTK expects immutable strings when converting to Glib::ustring.
2015-03-18 17:02:11 +00:00
SS.ScheduleShowTW();
Add a screen to edit the view parameters; scale, translation, rotation. Also clean up the handling of units, by putting the conversion factors in only one place, and clean up the expression-parsing but removing all the copies of the same error message. [git-p4: depot-paths = "//depot/solvespace/": change = 2093]
2010-01-04 00:35:28 +00:00
}
}
havePainted = false;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
InvalidateGraphics();
}
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void GraphicsWindow::MouseLeave() {
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
// Un-hover everything when the mouse leaves our window, unless there's
// currently a context menu shown.
if(!context.active) {
hover.Clear();
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
toolbarTooltipped = Command::NONE;
toolbarHovered = Command::NONE;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
PaintGraphics();
}
Fix some cases where the green line (that indicates the center of an in-plane rotation of the view, or of a set of entities) would remain on screen after the action was over. [git-p4: depot-paths = "//depot/solvespace/": change = 2142]
2010-05-12 04:47:58 +00:00
SS.extraLine.draw = false;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
}
void GraphicsWindow::SpaceNavigatorMoved(double tx, double ty, double tz,
double rx, double ry, double rz,
bool shiftDown)
{
if(!havePainted) return;
Vector out = projRight.Cross(projUp);
// rotation vector is axis of rotation, and its magnitude is angle
Vector aa = Vector::From(rx, ry, rz);
// but it's given with respect to screen projection frame
aa = aa.ScaleOutOfCsys(projRight, projUp, out);
double aam = aa.Magnitude();
Warning fixes
2013-12-02 06:22:35 +00:00
if(aam > 0.0) aa = aa.WithMagnitude(1);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Rename the old "Import / Assemble" feature to "Link / Assemble". This better reflects what it does and avoids clashes with the new DXF import feature.
2016-05-07 05:27:54 +00:00
// This can either transform our view, or transform a linked part.
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
GroupSelection();
Entity *e = NULL;
Group *g = NULL;
if(gs.points == 1 && gs.n == 1) e = SK.GetEntity(gs.point [0]);
if(gs.entities == 1 && gs.n == 1) e = SK.GetEntity(gs.entity[0]);
if(e) g = SK.GetGroup(e->group);
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(g && g->type == Group::Type::LINKED && !shiftDown) {
Rename the old "Import / Assemble" feature to "Link / Assemble". This better reflects what it does and avoids clashes with the new DXF import feature.
2016-05-07 05:27:54 +00:00
// Apply the transformation to a linked part. Gain down the Z
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
// axis, since it's hard to see what you're doing on that one since
// it's normal to the screen.
Vector t = projRight.ScaledBy(tx/scale).Plus(
projUp .ScaledBy(ty/scale).Plus(
out .ScaledBy(0.1*tz/scale)));
Quaternion q = Quaternion::From(aa, aam);
// If we go five seconds without SpaceNavigator input, or if we've
// switched groups, then consider that a new action and save an undo
// point.
Changed GetMilliseconds() to return a 64-bit value This function previously returned an int32_t. Presuming that it measures the length of time since the application was started, the 32-bit type would cause the returned value to wrap from 2^31-1 to -2^31 after a little less than twenty-five days.
2013-10-28 04:28:39 +00:00
int64_t now = GetMilliseconds();
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
if(now - lastSpaceNavigatorTime > 5000 ||
lastSpaceNavigatorGroup.v != g->h.v)
{
SS.UndoRemember();
}
g->TransformImportedBy(t, q);
lastSpaceNavigatorTime = now;
lastSpaceNavigatorGroup = g->h;
SS.MarkGroupDirty(g->h);
} else {
// Apply the transformation to the view of the everything. The
// x and y components are translation; but z component is scale,
// not translation, or else it would do nothing in a parallel
// projection
offset = offset.Plus(projRight.ScaledBy(tx/scale));
offset = offset.Plus(projUp.ScaledBy(ty/scale));
Trim trailing whitespace.
2015-03-29 00:30:52 +00:00
scale *= exp(0.001*tz);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
Warning fixes
2013-12-02 06:22:35 +00:00
if(aam > 0.0) {
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
projRight = projRight.RotatedAbout(aa, -aam);
projUp = projUp. RotatedAbout(aa, -aam);
NormalizeProjectionVectors();
}
}
havePainted = false;
InvalidateGraphics();
}
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void GraphicsWindow::SpaceNavigatorButtonUp() {
Only consider selected entities, when any, when doing Zoom to Fit. Scoped "Zoom to Fit" is convenient for working on large models. I (whitequark) have considered a separate shortcut, but its usefulness is unclear and in any case it can be easily added if desired.
2016-01-30 10:38:38 +00:00
ZoomToFit(/*includingInvisibles=*/false, /*useSelection=*/true);
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
InvalidateGraphics();
}