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

1115 lines
45 KiB
C++
Raw Normal View History

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
//-----------------------------------------------------------------------------
// Top-level implementation of the program's main window, in which a graphical
// representation of the model is drawn and edited by the user.
//
// Copyright 2008-2013 Jonathan Westhues.
//-----------------------------------------------------------------------------
Start to add OpenGL support to SolveSpace, for the graphical view. I've got the user interface to pan and rotate an object, more or less works. [git-p4: depot-paths = "//depot/solvespace/": change = 1654]
2008-03-27 09:53:51 +00:00
#include "solvespace.h"
Only #include "config.h" when we need something from it. config.h now includes the git hash and so, as long as it's included in solvespace.h, any change of git HEAD will trigger a complete recompilation, which makes bisecting especially annoying. While we're at it, remove HAVE_STDINT_H from it, since we require C++11 and all MSVC versions that include C++11 also include stdint.h.
2016-04-23 23:00:16 +00:00
#include "config.h"
More fragments of SolveSpace work. Improve the command line window, and add some (non-functional) menus to the graphics window. Start to rough in some data structures to hold the sketch. No real work yet, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1653]
2008-03-26 09:18:12 +00:00
Add the keyboard accelerator mechanism for menu items. Use that to implement zoom in/out, and orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1663]
2008-04-12 15:17:58 +00:00
#define mView (&GraphicsWindow::MenuView)
#define mEdit (&GraphicsWindow::MenuEdit)
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
#define mClip (&GraphicsWindow::MenuClipboard)
Tweak the handles to make more space in the request ID, so that I can use the high bits as an "import ID" for imported parts, for hierarchy (that retains parametric capabilities). Implement enought that I can draw a datum point or a line segment, and drag points around in three-space. Still so much to do. [git-p4: depot-paths = "//depot/solvespace/": change = 1665]
2008-04-13 10:57:41 +00:00
#define mReq (&GraphicsWindow::MenuRequest)
Now I can add a constraint (a length), and it's displayed on-screen, and I can drag the label. That's progress. Also implement a bunch of untested expression stuff, since I'll need that for the values of the dimensions, for example. [git-p4: depot-paths = "//depot/solvespace/": change = 1668]
2008-04-14 10:28:32 +00:00
#define mCon (&Constraint::MenuConstrain)
Pack everything into `namespace SolveSpace`. This is required to avoid name conflicts with the Cocoa libraries on OS X. I renamed the `class SolveSpace` to `class SolveSpaceUI`, because that's what it does, and because otherwise the namespace would have to be called something else than `namespace SolveSpace`.
2015-03-23 17:49:04 +00:00
#define mFile (&SolveSpaceUI::MenuFile)
Add the first `derived' group, that generates entities based on other entities. This requires a new point type, for a point that's defined as a transformation of some other point. All works nicely, I think. There's ugliness because entities are no longer guaranteed to have a parent request. Also speed up display of the text window, by caching brushes instead of recreating for each character (!), and add a bit more user interface in the text window. [git-p4: depot-paths = "//depot/solvespace/": change = 1692]
2008-04-27 09:03:01 +00:00
#define mGrp (&Group::MenuGroup)
Pack everything into `namespace SolveSpace`. This is required to avoid name conflicts with the Cocoa libraries on OS X. I renamed the `class SolveSpace` to `class SolveSpaceUI`, because that's what it does, and because otherwise the namespace would have to be called something else than `namespace SolveSpace`.
2015-03-23 17:49:04 +00:00
#define mAna (&SolveSpaceUI::MenuAnalyze)
#define mHelp (&SolveSpaceUI::MenuHelp)
Use symbolic names for special keys and modifiers Easier to remember e.g. DELETE_KEY instead of 127 or CTRL_MASK instead of 0x200, and better to have a single definition of each.
2013-09-20 17:54:57 +00:00
#define DEL DELETE_KEY
#define ESC ESCAPE_KEY
#define S SHIFT_MASK
#define C CTRL_MASK
#define F(k) (FUNCTION_KEY_BASE+(k))
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
#define TN MenuKind::NORMAL
#define TC MenuKind::CHECK
#define TR MenuKind::RADIO
More fragments of SolveSpace work. Improve the command line window, and add some (non-functional) menus to the graphics window. Start to rough in some data structures to hold the sketch. No real work yet, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1653]
2008-03-26 09:18:12 +00:00
const GraphicsWindow::MenuEntry GraphicsWindow::menu[] = {
Minor changes to GraphicsWindow::menu[] * Added a comment header identifying the columns * Added Ctrl-Q accelerator for "Exit", as this is standard * Replaced a Latin-1 "degree" character with an octal escape, to avoid source-file encoding issues * Undefine (some of) the convenience macros used to define the table (the method aliases are numerous and unlikely to collide with anything)
2013-09-20 18:16:38 +00:00
//level
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
// label id accel ty fn
{ 0, "&File", Command::NONE, 0, TN, NULL },
{ 1, "&New", Command::NEW, C|'N', TN, mFile },
{ 1, "&Open...", Command::OPEN, C|'O', TN, mFile },
{ 1, "Open &Recent", Command::OPEN_RECENT, 0, TN, mFile },
{ 1, "&Save", Command::SAVE, C|'S', TN, mFile },
{ 1, "Save &As...", Command::SAVE_AS, 0, TN, mFile },
{ 1, NULL, Command::NONE, 0, TN, NULL },
{ 1, "Export &Image...", Command::EXPORT_PNG, 0, TN, mFile },
{ 1, "Export 2d &View...", Command::EXPORT_VIEW, 0, TN, mFile },
{ 1, "Export 2d &Section...", Command::EXPORT_SECTION, 0, TN, mFile },
{ 1, "Export 3d &Wireframe...", Command::EXPORT_WIREFRAME, 0, TN, mFile },
{ 1, "Export Triangle &Mesh...", Command::EXPORT_MESH, 0, TN, mFile },
{ 1, "Export &Surfaces...", Command::EXPORT_SURFACES, 0, TN, mFile },
{ 1, "Im&port...", Command::IMPORT, 0, TN, mFile },
Implement OS X port.
2015-03-24 06:45:53 +00:00
#ifndef __APPLE__
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
{ 1, NULL, Command::NONE, 0, TN, NULL },
{ 1, "E&xit", Command::EXIT, C|'Q', TN, mFile },
Implement OS X port.
2015-03-24 06:45:53 +00:00
#endif
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
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
{ 0, "&Edit", Command::NONE, 0, TN, NULL },
{ 1, "&Undo", Command::UNDO, C|'Z', TN, mEdit },
{ 1, "&Redo", Command::REDO, C|'Y', TN, mEdit },
{ 1, "Re&generate All", Command::REGEN_ALL, ' ', TN, mEdit },
{ 1, NULL, Command::NONE, 0, TN, NULL },
{ 1, "Snap Selection to &Grid", Command::SNAP_TO_GRID, '.', TN, mEdit },
{ 1, "Rotate Imported &90°", Command::ROTATE_90, '9', TN, mEdit },
{ 1, NULL, Command::NONE, 0, TN, NULL },
{ 1, "Cu&t", Command::CUT, C|'X', TN, mClip },
{ 1, "&Copy", Command::COPY, C|'C', TN, mClip },
{ 1, "&Paste", Command::PASTE, C|'V', TN, mClip },
{ 1, "Paste &Transformed...", Command::PASTE_TRANSFORM, C|'T', TN, mClip },
{ 1, "&Delete", Command::DELETE, DEL, TN, mClip },
{ 1, NULL, Command::NONE, 0, TN, NULL },
{ 1, "Select &Edge Chain", Command::SELECT_CHAIN, C|'E', TN, mEdit },
{ 1, "Select &All", Command::SELECT_ALL, C|'A', TN, mEdit },
{ 1, "&Unselect All", Command::UNSELECT_ALL, ESC, TN, mEdit },
{ 0, "&View", Command::NONE, 0, TN, NULL },
{ 1, "Zoom &In", Command::ZOOM_IN, '+', TN, mView },
{ 1, "Zoom &Out", Command::ZOOM_OUT, '-', TN, mView },
{ 1, "Zoom To &Fit", Command::ZOOM_TO_FIT, 'F', TN, mView },
{ 1, NULL, Command::NONE, 0, TN, NULL },
{ 1, "Align View to &Workplane", Command::ONTO_WORKPLANE, 'W', TN, mView },
{ 1, "Nearest &Ortho View", Command::NEAREST_ORTHO, F(2), TN, mView },
{ 1, "Nearest &Isometric View", Command::NEAREST_ISO, F(3), TN, mView },
{ 1, "&Center View At Point", Command::CENTER_VIEW, F(4), TN, mView },
{ 1, NULL, Command::NONE, 0, TN, NULL },
{ 1, "Show Snap &Grid", Command::SHOW_GRID, '>', TC, mView },
{ 1, "Use &Perspective Projection", Command::PERSPECTIVE_PROJ, '`', TC, mView },
{ 1, NULL, Command::NONE, 0, TN, NULL },
Remove FLTK port. It provides no value over the native GTK and Cocoa ports.
2015-03-24 23:38:06 +00:00
#if defined(__APPLE__)
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
{ 1, "Show Menu &Bar", Command::SHOW_MENU_BAR, C|F(12), TC, mView },
Preliminary changes for FLTK support * Added "Show Menu Bar" and "Full Screen" menu items, which will be implemented in the FLTK interface. These are currently prevented from appearing in the Win32 interface by the HAVE_FLTK and HAVE_FLTK_FULLSCREEN macros. * Moved the "Show Text Window" down below the "Show Toolbar" item, so that "Show Menu Bar", "Show Toolbar" and "Show Text Window" are in the same vertical order as their corresponding UI elements typically take on * Added new platform-dependent routines to back the new menu items: void ToggleMenuBar(void); bool MenuBarIsVisible(void); void ToggleFullScreen(void); bool FullScreenIsActive(void); These are stubs in the Win32 code. * Fleshed out the system header #includes in solvespace.h, and moved them to the top of the file per convention * Rewrote the file dialog selection patterns in terms of macros that allow them to expand to either the FLTK or Windows formats * Don't use __stdcall in SSGL_CALLBACK, and make SSGL_CALLBACK 'extern "C"' as OpenGL usually expects function pointers to point to C functions
2013-10-25 05:04:16 +00:00
#endif
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
{ 1, "Show &Toolbar", Command::SHOW_TOOLBAR, 0, TC, mView },
{ 1, "Show Property Bro&wser", Command::SHOW_TEXT_WND, '\t', TC, mView },
{ 1, NULL, Command::NONE, 0, TN, NULL },
{ 1, "Dimensions in &Inches", Command::UNITS_INCHES, 0, TR, mView },
{ 1, "Dimensions in &Millimeters", Command::UNITS_MM, 0, TR, mView },
Remove FLTK port. It provides no value over the native GTK and Cocoa ports.
2015-03-24 23:38:06 +00:00
#if defined(HAVE_GTK) || defined(__APPLE__)
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
{ 1, NULL, Command::NONE, 0, TN, NULL },
{ 1, "&Full Screen", Command::FULL_SCREEN, C|F(11), TC, mView },
Preliminary changes for FLTK support * Added "Show Menu Bar" and "Full Screen" menu items, which will be implemented in the FLTK interface. These are currently prevented from appearing in the Win32 interface by the HAVE_FLTK and HAVE_FLTK_FULLSCREEN macros. * Moved the "Show Text Window" down below the "Show Toolbar" item, so that "Show Menu Bar", "Show Toolbar" and "Show Text Window" are in the same vertical order as their corresponding UI elements typically take on * Added new platform-dependent routines to back the new menu items: void ToggleMenuBar(void); bool MenuBarIsVisible(void); void ToggleFullScreen(void); bool FullScreenIsActive(void); These are stubs in the Win32 code. * Fleshed out the system header #includes in solvespace.h, and moved them to the top of the file per convention * Rewrote the file dialog selection patterns in terms of macros that allow them to expand to either the FLTK or Windows formats * Don't use __stdcall in SSGL_CALLBACK, and make SSGL_CALLBACK 'extern "C"' as OpenGL usually expects function pointers to point to C functions
2013-10-25 05:04:16 +00:00
#endif
Synthesize accelerator labels (e.g. "Ctrl+S") instead of hard-coding them GraphicsWindow::menu[] previously recorded both item names (e.g. "Open...") and accelerator labels ("Ctrl+O") in .label, and accelerator key/mask values in .accel. Not only were the accelerator labels redundant given the latter, they are not needed by GUI toolkits like FLTK, which generate them from key/mask values. So we remove the accelerator portion from each menu-item label, and define a new MakeAcceleratorLabel() routine which takes a key/mask value and returns the appropriate label. We make use of this new routine in CreateGraphicsWindowMenus() and GraphicsWindow::ToolbarDrawOrHitTest().
2013-09-20 19:01:00 +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
{ 0, "&New Group", Command::NONE, 0, TN, NULL },
{ 1, "Sketch In &3d", Command::GROUP_3D, S|'3', TN, mGrp },
{ 1, "Sketch In New &Workplane", Command::GROUP_WRKPL, S|'W', TN, mGrp },
{ 1, NULL, Command::NONE, 0, TN, NULL },
{ 1, "Step &Translating", Command::GROUP_TRANS, S|'T', TN, mGrp },
{ 1, "Step &Rotating", Command::GROUP_ROT, S|'R', TN, mGrp },
{ 1, NULL, Command::NONE, 0, TN, NULL },
{ 1, "E&xtrude", Command::GROUP_EXTRUDE, S|'X', TN, mGrp },
{ 1, "&Lathe", Command::GROUP_LATHE, S|'L', TN, mGrp },
{ 1, NULL, Command::NONE, 0, TN, NULL },
{ 1, "Link / Assemble...", Command::GROUP_LINK, S|'I', TN, mGrp },
{ 1, "Link Recent", Command::GROUP_RECENT, 0, TN, mGrp },
{ 0, "&Sketch", Command::NONE, 0, TN, NULL },
{ 1, "In &Workplane", Command::SEL_WORKPLANE, '2', TR, mReq },
{ 1, "Anywhere In &3d", Command::FREE_IN_3D, '3', TR, mReq },
{ 1, NULL, Command::NONE, 0, TN, NULL },
{ 1, "Datum &Point", Command::DATUM_POINT, 'P', TN, mReq },
{ 1, "&Workplane", Command::WORKPLANE, 0, TN, mReq },
{ 1, NULL, Command::NONE, 0, TN, NULL },
{ 1, "Line &Segment", Command::LINE_SEGMENT, 'S', TN, mReq },
{ 1, "C&onstruction Line Segment", Command::CONSTR_SEGMENT, S|'S', TN, mReq },
{ 1, "&Rectangle", Command::RECTANGLE, 'R', TN, mReq },
{ 1, "&Circle", Command::CIRCLE, 'C', TN, mReq },
{ 1, "&Arc of a Circle", Command::ARC, 'A', TN, mReq },
{ 1, "&Bezier Cubic Spline", Command::CUBIC, 'B', TN, mReq },
{ 1, NULL, Command::NONE, 0, TN, NULL },
{ 1, "&Text in TrueType Font", Command::TTF_TEXT, 'T', TN, mReq },
{ 1, NULL, Command::NONE, 0, TN, NULL },
{ 1, "To&ggle Construction", Command::CONSTRUCTION, 'G', TN, mReq },
{ 1, "Tangent &Arc at Point", Command::TANGENT_ARC, S|'A', TN, mReq },
{ 1, "Split Curves at &Intersection", Command::SPLIT_CURVES, 'I', TN, mReq },
{ 0, "&Constrain", Command::NONE, 0, TN, NULL },
{ 1, "&Distance / Diameter", Command::DISTANCE_DIA, 'D', TN, mCon },
{ 1, "Re&ference Dimension", Command::REF_DISTANCE, S|'D', TN, mCon },
{ 1, "A&ngle", Command::ANGLE, 'N', TN, mCon },
{ 1, "Reference An&gle", Command::REF_ANGLE, S|'N', TN, mCon },
{ 1, "Other S&upplementary Angle", Command::OTHER_ANGLE, 'U', TN, mCon },
{ 1, "Toggle R&eference Dim", Command::REFERENCE, 'E', TN, mCon },
{ 1, NULL, Command::NONE, 0, TN, NULL },
{ 1, "&Horizontal", Command::HORIZONTAL, 'H', TN, mCon },
{ 1, "&Vertical", Command::VERTICAL, 'V', TN, mCon },
{ 1, NULL, Command::NONE, 0, TN, NULL },
{ 1, "&On Point / Curve / Plane", Command::ON_ENTITY, 'O', TN, mCon },
{ 1, "E&qual Length / Radius / Angle", Command::EQUAL, 'Q', TN, mCon },
{ 1, "Length Ra&tio", Command::RATIO, 'Z', TN, mCon },
{ 1, "Length Diff&erence", Command::DIFFERENCE, 'J', TN, mCon },
{ 1, "At &Midpoint", Command::AT_MIDPOINT, 'M', TN, mCon },
{ 1, "S&ymmetric", Command::SYMMETRIC, 'Y', TN, mCon },
{ 1, "Para&llel / Tangent", Command::PARALLEL, 'L', TN, mCon },
{ 1, "&Perpendicular", Command::PERPENDICULAR, '[', TN, mCon },
{ 1, "Same Orient&ation", Command::ORIENTED_SAME, 'X', TN, mCon },
{ 1, "Lock Point Where &Dragged", Command::WHERE_DRAGGED, ']', TN, mCon },
{ 1, NULL, Command::NONE, 0, TN, NULL },
{ 1, "Comment", Command::COMMENT, ';', TN, mCon },
{ 0, "&Analyze", Command::NONE, 0, TN, NULL },
{ 1, "Measure &Volume", Command::VOLUME, C|S|'V', TN, mAna },
Implement Analyze → Measure Perimeter.
2016-08-01 13:18:58 +00:00
{ 1, "Measure A&rea", Command::AREA, C|S|'A', TN, mAna },
{ 1, "Measure &Perimeter", Command::PERIMETER, C|S|'P', TN, mAna },
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
{ 1, "Show &Interfering Parts", Command::INTERFERENCE, C|S|'I', TN, mAna },
{ 1, "Show &Naked Edges", Command::NAKED_EDGES, C|S|'N', TN, mAna },
{ 1, NULL, Command::NONE, 0, TN, NULL },
{ 1, "Show Degrees of &Freedom", Command::SHOW_DOF, C|S|'F', TN, mAna },
{ 1, NULL, Command::NONE, 0, TN, NULL },
{ 1, "&Trace Point", Command::TRACE_PT, C|S|'T', TN, mAna },
{ 1, "&Stop Tracing...", Command::STOP_TRACING, C|S|'S', TN, mAna },
{ 1, "Step &Dimension...", Command::STEP_DIM, C|S|'D', TN, mAna },
{ 0, "&Help", Command::NONE, 0, TN, NULL },
{ 1, "&Website / Manual", Command::WEBSITE, 0, TN, mHelp },
Implement OS X port.
2015-03-24 06:45:53 +00:00
#ifndef __APPLE__
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
{ 1, "&About", Command::ABOUT, 0, TN, mHelp },
Implement OS X port.
2015-03-24 06:45:53 +00:00
#endif
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
{ -1, 0, Command::NONE, 0, TN, 0 }
More fragments of SolveSpace work. Improve the command line window, and add some (non-functional) menus to the graphics window. Start to rough in some data structures to hold the sketch. No real work yet, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1653]
2008-03-26 09:18:12 +00:00
};
Minor changes to GraphicsWindow::menu[] * Added a comment header identifying the columns * Added Ctrl-Q accelerator for "Exit", as this is standard * Replaced a Latin-1 "degree" character with an octal escape, to avoid source-file encoding issues * Undefine (some of) the convenience macros used to define the table (the method aliases are numerous and unlikely to collide with anything)
2013-09-20 18:16:38 +00:00
#undef DEL
#undef ESC
#undef S
#undef C
#undef F
Fix a macro redefinition warning. Including windows.h defines "IN".
2016-04-10 12:30:25 +00:00
#undef TN
#undef TC
#undef TR
Minor changes to GraphicsWindow::menu[] * Added a comment header identifying the columns * Added Ctrl-Q accelerator for "Exit", as this is standard * Replaced a Latin-1 "degree" character with an octal escape, to avoid source-file encoding issues * Undefine (some of) the convenience macros used to define the table (the method aliases are numerous and unlikely to collide with anything)
2013-09-20 18:16:38 +00:00
Fix empty space at the end of the tooltips. Also, bring MakeAcceleratorLabel to modernity.
2016-04-17 10:01:44 +00:00
std::string SolveSpace::MakeAcceleratorLabel(int accel) {
if(!accel) return "";
Synthesize accelerator labels (e.g. "Ctrl+S") instead of hard-coding them GraphicsWindow::menu[] previously recorded both item names (e.g. "Open...") and accelerator labels ("Ctrl+O") in .label, and accelerator key/mask values in .accel. Not only were the accelerator labels redundant given the latter, they are not needed by GUI toolkits like FLTK, which generate them from key/mask values. So we remove the accelerator portion from each menu-item label, and define a new MakeAcceleratorLabel() routine which takes a key/mask value and returns the appropriate label. We make use of this new routine in CreateGraphicsWindowMenus() and GraphicsWindow::ToolbarDrawOrHitTest().
2013-09-20 19:01:00 +00:00
Fix empty space at the end of the tooltips. Also, bring MakeAcceleratorLabel to modernity.
2016-04-17 10:01:44 +00:00
std::string label;
if(accel & GraphicsWindow::CTRL_MASK) {
label += "Ctrl+";
}
if(accel & GraphicsWindow::SHIFT_MASK) {
label += "Shift+";
}
Synthesize accelerator labels (e.g. "Ctrl+S") instead of hard-coding them GraphicsWindow::menu[] previously recorded both item names (e.g. "Open...") and accelerator labels ("Ctrl+O") in .label, and accelerator key/mask values in .accel. Not only were the accelerator labels redundant given the latter, they are not needed by GUI toolkits like FLTK, which generate them from key/mask values. So we remove the accelerator portion from each menu-item label, and define a new MakeAcceleratorLabel() routine which takes a key/mask value and returns the appropriate label. We make use of this new routine in CreateGraphicsWindowMenus() and GraphicsWindow::ToolbarDrawOrHitTest().
2013-09-20 19:01:00 +00:00
if(accel >= GraphicsWindow::FUNCTION_KEY_BASE + 1 &&
accel <= GraphicsWindow::FUNCTION_KEY_BASE + 12) {
Fix empty space at the end of the tooltips. Also, bring MakeAcceleratorLabel to modernity.
2016-04-17 10:01:44 +00:00
label += ssprintf("F%d", accel - GraphicsWindow::FUNCTION_KEY_BASE);
} else if(accel == '\t') {
label += "Tab";
} else if(accel == ' ') {
label += "Space";
} else if(accel == GraphicsWindow::ESCAPE_KEY) {
label += "Esc";
} else if(accel == GraphicsWindow::DELETE_KEY) {
label += "Del";
} else {
label += (char)(accel & 0xff);
Synthesize accelerator labels (e.g. "Ctrl+S") instead of hard-coding them GraphicsWindow::menu[] previously recorded both item names (e.g. "Open...") and accelerator labels ("Ctrl+O") in .label, and accelerator key/mask values in .accel. Not only were the accelerator labels redundant given the latter, they are not needed by GUI toolkits like FLTK, which generate them from key/mask values. So we remove the accelerator portion from each menu-item label, and define a new MakeAcceleratorLabel() routine which takes a key/mask value and returns the appropriate label. We make use of this new routine in CreateGraphicsWindowMenus() and GraphicsWindow::ToolbarDrawOrHitTest().
2013-09-20 19:01:00 +00:00
}
Fix empty space at the end of the tooltips. Also, bring MakeAcceleratorLabel to modernity.
2016-04-17 10:01:44 +00:00
return label;
Synthesize accelerator labels (e.g. "Ctrl+S") instead of hard-coding them GraphicsWindow::menu[] previously recorded both item names (e.g. "Open...") and accelerator labels ("Ctrl+O") in .label, and accelerator key/mask values in .accel. Not only were the accelerator labels redundant given the latter, they are not needed by GUI toolkits like FLTK, which generate them from key/mask values. So we remove the accelerator portion from each menu-item label, and define a new MakeAcceleratorLabel() routine which takes a key/mask value and returns the appropriate label. We make use of this new routine in CreateGraphicsWindowMenus() and GraphicsWindow::ToolbarDrawOrHitTest().
2013-09-20 19:01:00 +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::Init() {
Hide OpenGL implementation details. Abstract the exact details of the OpenGL renderer in the render.h header; this allows us to use GL-specific types in the renderer class and functions without including OpenGL (and Windows, where applicable) headers in every source file.
2016-06-28 08:48:06 +00:00
canvas = CreateRenderer();
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
scale = 5;
Add more measurement information about the selection. And remove menu items for some features that I suppose I won't add, and fix some bugs. [git-p4: depot-paths = "//depot/solvespace/": change = 1787]
2008-06-12 07:31:41 +00:00
offset = Vector::From(0, 0, 0);
projRight = Vector::From(1, 0, 0);
projUp = Vector::From(0, 1, 0);
Start to add OpenGL support to SolveSpace, for the graphical view. I've got the user interface to pan and rotate an object, more or less works. [git-p4: depot-paths = "//depot/solvespace/": change = 1654]
2008-03-27 09:53:51 +00:00
Fix the mystery bug where the display disappears. That would happen when I get a mouse moved event with the middle button down before I got a middle button down event; orig.proj{Right,Up} were invalid. [git-p4: depot-paths = "//depot/solvespace/": change = 1873]
2008-08-24 01:32:25 +00:00
// Make sure those are valid; could get a mouse move without a mouse
// down if someone depresses the button, then drags into our window.
orig.projRight = projRight;
orig.projUp = projUp;
Little fixes for units display, and change file format to binary (even though it's still a text file), to avoid CRLF issue. [git-p4: depot-paths = "//depot/solvespace/": change = 1794]
2008-06-14 23:31:36 +00:00
// And with the last group active
Allow generating groups in arbitrary order.
2016-02-17 10:03:07 +00:00
activeGroup = SK.groupOrder.elem[SK.groupOrder.n - 1];
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
SK.GetGroup(activeGroup)->Activate();
Add user interface to specify union/difference for extrudes, and implement that. Also make solver work only between the first and last visible group; earlier can just work from previous solve result, and later don't matter. There's some issues with the csg code; it will eventually produce an open mesh, which is very bad. Not sure whether that's a logic bug, or a numerical issue; still generating absurd triangles pretty routinely. [git-p4: depot-paths = "//depot/solvespace/": change = 1741]
2008-05-25 13:11:44 +00:00
Now display dimensions (and stuff in the text window) in the user-selected units, and enter them the same way. [git-p4: depot-paths = "//depot/solvespace/": change = 1792]
2008-06-14 09:51:25 +00:00
showWorkplanes = false;
A big change, to add a concept of normals. These are "oriented vectors", represented by unit quaternions. This permits me to add circles, where the normal defines the plane of the circle. Still many things painful. The interface for editing normals is not so intuitive, and it's not yet clear how I would e.g. export a circle entity and recreate it properly, since that entity has a param not associated with a normal or point. And the transformed points/normals do not yet support rotations. That will be necessary soon. [git-p4: depot-paths = "//depot/solvespace/": change = 1705]
2008-05-05 06:18:01 +00:00
showNormals = true;
Start to use that text window a bit; user interface to show and hide things. [git-p4: depot-paths = "//depot/solvespace/": change = 1661]
2008-04-11 12:47:14 +00:00
showPoints = true;
showConstraints = true;
Remove stupid "show any datum" link, and replace with a link to show/hide the mesh (drawn as wireframe triangles). [git-p4: depot-paths = "//depot/solvespace/": change = 1754]
2008-05-28 10:34:55 +00:00
showShaded = true;
Generate additional edges wherever a front- and back-facing triangle join. And add controls to show and hide the solid model edges (independently of the shaded mesh), and to suppress the shaded triangles from SVG/EPS output. [git-p4: depot-paths = "//depot/solvespace/": change = 1932]
2009-03-18 04:26:04 +00:00
showEdges = true;
Little tweaks: wider lines drawn, fix editing dimensions. [git-p4: depot-paths = "//depot/solvespace/": change = 1761]
2008-06-01 04:31:28 +00:00
showMesh = false;
Allow rendering solid outlines using a distinct style. A new button is added, "Show/hide outline of solid model". When the outline is hidden, it is rendered using the "solid edge" style. When the outline is shown, it is rendered using the "outline" style. In SolveSpace's true WYSIWYG tradition, the 2d view export follows the rendered view exactly. Moreover, shell edges are not rendered anymore, since there is not much need in them anymore and not drawing them lessens the overlap between various kinds of lines, which already includes entities, solid edges and outlines.
2016-03-14 16:14:24 +00:00
showOutlines = false;
Make "Show/hide hidden lines" a tri-state button instead. The states are: * Draw all lines (on top of shaded mesh). * Draw occluded (by shaded mesh) lines as stippled. * Do not draw occluded (by shaded mesh) lines. As usual, the export output follows the screen output.
2016-08-13 09:02:12 +00:00
drawOccludedAs = DrawOccludedAs::INVISIBLE;
Standardize the behaviour of constraints, by assigning them a workplane: a free constraint works in three-space (e.g. true distance), and a constraint in a workplane works in that plane (e.g. projected distance). And make the solver go automatically, though solver itself has lots of pieces missing. [git-p4: depot-paths = "//depot/solvespace/": change = 1691]
2008-04-27 05:00:12 +00:00
showTextWindow = true;
ShowTextWindow(showTextWindow);
Treatment of numerical faces was screwy, exporting stuff in numXXX. So fix that, and now I can simplify what's exported for an entity. And add an extra measurement (face-face distance/angle), and some other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 1789]
2008-06-13 04:41:27 +00:00
Add text angle for styles. Add ability to quickly change between perspective and parallel projections. Add a snap grid, for points and for text comments. Draw text comments in the plane of their workplane if they have one, otherwise always facing forward. And fix a few nasty bugs: the possibility of an extremely long animation onto a workplane, accidental use of the wrong style line width for constraints, misplaced text box in style screen for default styles, other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 2037]
2009-09-29 11:35:19 +00:00
showSnapGrid = false;
Add a context menu, with a grab bag of options. That will need some refinement later, but it does not affect file formats so it's not very critical. [git-p4: depot-paths = "//depot/solvespace/": change = 2032]
2009-09-23 10:59:59 +00:00
context.active = false;
Treatment of numerical faces was screwy, exporting stuff in numXXX. So fix that, and now I can simplify what's exported for an entity. And add an extra measurement (face-face distance/angle), and some other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 1789]
2008-06-13 04:41:27 +00:00
// Do this last, so that all the menus get updated correctly.
Fully reinitialize graphics window in AfterNewFile(). Before this commit it was possible to cause a crash by e.g. selecting a face and pressing Ctrl+N, or numerous other glitches.
2016-04-16 02:16:47 +00:00
ClearSuper();
Start to add OpenGL support to SolveSpace, for the graphical view. I've got the user interface to pan and rotate an object, more or less works. [git-p4: depot-paths = "//depot/solvespace/": change = 1654]
2008-03-27 09:53:51 +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::AnimateOntoWorkplane() {
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 02:22:20 +00:00
if(!LockedInWorkplane()) return;
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Entity *w = SK.GetEntity(ActiveWorkplane());
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 02:22:20 +00:00
Quaternion quatf = w->Normal()->NormalGetNum();
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Vector offsetf = (SK.GetEntity(w->point[0])->PointGetNum()).ScaledBy(-1);
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 02:22:20 +00:00
Add menu items to snap view to nearest orthogonal or iso view. [git-p4: depot-paths = "//depot/solvespace/": change = 1882]
2009-01-02 04:06:47 +00:00
AnimateOnto(quatf, offsetf);
}
void GraphicsWindow::AnimateOnto(Quaternion quatf, Vector offsetf) {
Simplify the way that the active csys is handled, and default to locked on to the XY plane. And simplify the handling of colors in the text window: identify them by a character, not an integer ID, since the character is easier to remember. [git-p4: depot-paths = "//depot/solvespace/": change = 1687]
2008-04-25 08:26:15 +00:00
// Get our initial orientation and translation.
Standardize naming of FromXxx (and XxxFrom) static methods to create a `new' stack-allocated instance of an object; just From, possibly different versions with different arg types. [git-p4: depot-paths = "//depot/solvespace/": change = 1763]
2008-06-01 08:45:11 +00:00
Quaternion quat0 = Quaternion::From(projRight, projUp);
Now we can add new workplanes. So fix all the mistakes that I hadn't previously noticed, because I didn't use to have workplanes with non-zero offsets. And clean up the interface to normals a bit. [git-p4: depot-paths = "//depot/solvespace/": change = 1707]
2008-05-05 11:17:00 +00:00
Vector offset0 = offset;
Simplify the way that the active csys is handled, and default to locked on to the XY plane. And simplify the handling of colors in the text window: identify them by a character, not an integer ID, since the character is easier to remember. [git-p4: depot-paths = "//depot/solvespace/": change = 1687]
2008-04-25 08:26:15 +00:00
// Make sure we take the shorter of the two possible paths.
double mp = (quatf.Minus(quat0)).Magnitude();
double mm = (quatf.Plus(quat0)).Magnitude();
if(mp > mm) {
quatf = quatf.ScaledBy(-1);
mp = mm;
}
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
double mo = (offset0.Minus(offsetf)).Magnitude()*scale;
Simplify the way that the active csys is handled, and default to locked on to the XY plane. And simplify the handling of colors in the text window: identify them by a character, not an integer ID, since the character is easier to remember. [git-p4: depot-paths = "//depot/solvespace/": change = 1687]
2008-04-25 08:26:15 +00:00
// Animate transition, unless it's a tiny move.
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
int32_t dt = (mp < 0.01 && mo < 10) ? (-20) :
(int32_t)(100 + 1000*mp + 0.4*mo);
Add text angle for styles. Add ability to quickly change between perspective and parallel projections. Add a snap grid, for points and for text comments. Draw text comments in the plane of their workplane if they have one, otherwise always facing forward. And fix a few nasty bugs: the possibility of an extremely long animation onto a workplane, accidental use of the wrong style line width for constraints, misplaced text box in style screen for default styles, other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 2037]
2009-09-29 11:35:19 +00:00
// Don't ever animate for longer than 2000 ms; we can get absurdly
// long translations (as measured in pixels) if the user zooms out, moves,
// and then zooms in again.
if(dt > 2000) dt = 2000;
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 tn, t0 = GetMilliseconds();
Simplify the way that the active csys is handled, and default to locked on to the XY plane. And simplify the handling of colors in the text window: identify them by a character, not an integer ID, since the character is easier to remember. [git-p4: depot-paths = "//depot/solvespace/": change = 1687]
2008-04-25 08:26:15 +00:00
double s = 0;
Do spherical linear interpolation when we animate onto a workplane. [git-p4: depot-paths = "//depot/solvespace/": change = 1722]
2008-05-14 14:23:58 +00:00
Quaternion dq = quatf.Times(quat0.Inverse());
Simplify the way that the active csys is handled, and default to locked on to the XY plane. And simplify the handling of colors in the text window: identify them by a character, not an integer ID, since the character is easier to remember. [git-p4: depot-paths = "//depot/solvespace/": change = 1687]
2008-04-25 08:26:15 +00:00
do {
offset = (offset0.ScaledBy(1 - s)).Plus(offsetf.ScaledBy(s));
Do spherical linear interpolation when we animate onto a workplane. [git-p4: depot-paths = "//depot/solvespace/": change = 1722]
2008-05-14 14:23:58 +00:00
Quaternion quat = (dq.ToThe(s)).Times(quat0);
Simplify the way that the active csys is handled, and default to locked on to the XY plane. And simplify the handling of colors in the text window: identify them by a character, not an integer ID, since the character is easier to remember. [git-p4: depot-paths = "//depot/solvespace/": change = 1687]
2008-04-25 08:26:15 +00:00
quat = quat.WithMagnitude(1);
projRight = quat.RotationU();
projUp = quat.RotationV();
PaintGraphics();
tn = GetMilliseconds();
s = (tn - t0)/((double)dt);
} while((tn - t0) < dt);
projRight = quatf.RotationU();
projUp = quatf.RotationV();
offset = offsetf;
InvalidateGraphics();
Fix bug where on-screen display of view parameters wasn't updated after View -> Nearest Ortho/Iso. [git-p4: depot-paths = "//depot/solvespace/": change = 2119]
2010-02-28 18:55:49 +00:00
// If the view screen is open, then we need to refresh it.
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();
Simplify the way that the active csys is handled, and default to locked on to the XY plane. And simplify the handling of colors in the text window: identify them by a character, not an integer ID, since the character is easier to remember. [git-p4: depot-paths = "//depot/solvespace/": change = 1687]
2008-04-25 08:26:15 +00:00
}
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
void GraphicsWindow::HandlePointForZoomToFit(Vector p, Point2d *pmax, Point2d *pmin,
double *wmin, bool usePerspective)
Add reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 04:22:52 +00:00
{
Add perspective, by a user-specified factor. So I have to apply that perspective in the gl matrices, and also everywhere that I check mouse pointer positions against the model, and for the zoom to fit. [git-p4: depot-paths = "//depot/solvespace/": change = 1796]
2008-06-17 19:12:25 +00:00
double w;
Vector pp = ProjectPoint4(p, &w);
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
// If usePerspective is true, then we calculate a perspective projection of the point.
Put back code to generate emphasized edges from a mesh; so now we can show edges for both meshes and shells, and export them and hidden line remove and all the usual stuff. And fix the zoom to fit on startup, so that it considers hidden entities too. That avoids the problem where things get generated at stupid chord tolerance because no entities were visible and the mesh of course did not yet exist. [git-p4: depot-paths = "//depot/solvespace/": change = 1961]
2009-05-29 05:40:17 +00:00
// If not, then we do a parallel projection regardless of the current
// scale factor.
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
if(usePerspective) {
Add perspective, by a user-specified factor. So I have to apply that perspective in the gl matrices, and also everywhere that I check mouse pointer positions against the model, and for the zoom to fit. [git-p4: depot-paths = "//depot/solvespace/": change = 1796]
2008-06-17 19:12:25 +00:00
pp = pp.ScaledBy(1.0/w);
}
Add reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 04:22:52 +00:00
Add perspective, by a user-specified factor. So I have to apply that perspective in the gl matrices, and also everywhere that I check mouse pointer positions against the model, and for the zoom to fit. [git-p4: depot-paths = "//depot/solvespace/": change = 1796]
2008-06-17 19:12:25 +00:00
pmax->x = max(pmax->x, pp.x);
pmax->y = max(pmax->y, pp.y);
pmin->x = min(pmin->x, pp.x);
pmin->y = min(pmin->y, pp.y);
*wmin = min(*wmin, w);
}
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
void GraphicsWindow::LoopOverPoints(const std::vector<Entity *> &entities,
Also consider constraints when zooming to fit. Before this commit, when working on convex sketches, zooming to fit was guaranteed to clip most or even all constraints, making it quite useless.
2016-08-01 14:00:00 +00:00
const std::vector<Constraint *> &constraints,
Consider plane faces when zooming to fit.
2016-03-25 07:32:11 +00:00
const std::vector<hEntity> &faces,
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
Point2d *pmax, Point2d *pmin, double *wmin,
bool usePerspective, bool includeMesh) {
Add reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 04:22:52 +00:00
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
for(Entity *e : entities) {
Add beginnings of exact curve export. We take the trim curves in our specified section plane; we then split them according to the start and endpoints of each STrimBy, using de Castejau's algorithm. These sections get projected (possibly in perspective, which I do correctly) into 2d and exported. Except, for now they just get pwl'd in the export files. That's the fallback, since it works for any file format. But that's the place to add special cases for circles etc., or to export them exactly. DXF supports the latter, but very painfully since I would need to write a later-versioned file, which requires thousands of lines of baggage. I'll probably stick with arcs. [git-p4: depot-paths = "//depot/solvespace/": change = 1936]
2009-04-14 04:19:23 +00:00
if(e->IsPoint()) {
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
HandlePointForZoomToFit(e->PointGetNum(), pmax, pmin, wmin, usePerspective);
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::CIRCLE) {
Add beginnings of exact curve export. We take the trim curves in our specified section plane; we then split them according to the start and endpoints of each STrimBy, using de Castejau's algorithm. These sections get projected (possibly in perspective, which I do correctly) into 2d and exported. Except, for now they just get pwl'd in the export files. That's the fallback, since it works for any file format. But that's the place to add special cases for circles etc., or to export them exactly. DXF supports the latter, but very painfully since I would need to write a later-versioned file, which requires thousands of lines of baggage. I'll probably stick with arcs. [git-p4: depot-paths = "//depot/solvespace/": change = 1936]
2009-04-14 04:19:23 +00:00
// Lots of entities can extend outside the bbox of their points,
// but circles are particularly bad. We want to get things halfway
// reasonable without the mesh, because a zoom to fit is used to
// set the zoom level to set the chord tol.
double r = e->CircleGetRadiusNum();
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Vector c = SK.GetEntity(e->point[0])->PointGetNum();
Quaternion q = SK.GetEntity(e->normal)->NormalGetNum();
Also consider constraints when zooming to fit. Before this commit, when working on convex sketches, zooming to fit was guaranteed to clip most or even all constraints, making it quite useless.
2016-08-01 14:00:00 +00:00
for(int j = 0; j < 4; j++) {
Add beginnings of exact curve export. We take the trim curves in our specified section plane; we then split them according to the start and endpoints of each STrimBy, using de Castejau's algorithm. These sections get projected (possibly in perspective, which I do correctly) into 2d and exported. Except, for now they just get pwl'd in the export files. That's the fallback, since it works for any file format. But that's the place to add special cases for circles etc., or to export them exactly. DXF supports the latter, but very painfully since I would need to write a later-versioned file, which requires thousands of lines of baggage. I'll probably stick with arcs. [git-p4: depot-paths = "//depot/solvespace/": change = 1936]
2009-04-14 04:19:23 +00:00
Vector p = (j == 0) ? (c.Plus(q.RotationU().ScaledBy( r))) :
(j == 1) ? (c.Plus(q.RotationU().ScaledBy(-r))) :
(j == 2) ? (c.Plus(q.RotationV().ScaledBy( r))) :
(c.Plus(q.RotationV().ScaledBy(-r)));
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
HandlePointForZoomToFit(p, pmax, pmin, wmin, usePerspective);
}
} else {
// We have to iterate children points, because we can select entites without points
for(int i = 0; i < MAX_POINTS_IN_ENTITY; i++) {
if(e->point[i].v == 0) break;
Vector p = SK.GetEntity(e->point[i])->PointGetNum();
HandlePointForZoomToFit(p, pmax, pmin, wmin, usePerspective);
Add beginnings of exact curve export. We take the trim curves in our specified section plane; we then split them according to the start and endpoints of each STrimBy, using de Castejau's algorithm. These sections get projected (possibly in perspective, which I do correctly) into 2d and exported. Except, for now they just get pwl'd in the export files. That's the fallback, since it works for any file format. But that's the place to add special cases for circles etc., or to export them exactly. DXF supports the latter, but very painfully since I would need to write a later-versioned file, which requires thousands of lines of baggage. I'll probably stick with arcs. [git-p4: depot-paths = "//depot/solvespace/": change = 1936]
2009-04-14 04:19:23 +00:00
}
}
Add reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 04:22:52 +00:00
}
Add a separate display mesh and edge list; so if we're working with a mesh than that's a copy, and if we're working with a shell then it's the shell's triangulation. [git-p4: depot-paths = "//depot/solvespace/": change = 1957]
2009-05-21 09:06:26 +00:00
Also consider constraints when zooming to fit. Before this commit, when working on convex sketches, zooming to fit was guaranteed to clip most or even all constraints, making it quite useless.
2016-08-01 14:00:00 +00:00
for(Constraint *c : constraints) {
std::vector<Vector> refs;
c->GetReferencePoints(GetCamera(), &refs);
for(Vector p : refs) {
HandlePointForZoomToFit(p, pmax, pmin, wmin, usePerspective);
}
}
Consider plane faces when zooming to fit.
2016-03-25 07:32:11 +00:00
if(!includeMesh && faces.empty()) return;
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
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Group *g = SK.GetGroup(activeGroup);
Add a separate display mesh and edge list; so if we're working with a mesh than that's a copy, and if we're working with a shell then it's the shell's triangulation. [git-p4: depot-paths = "//depot/solvespace/": change = 1957]
2009-05-21 09:06:26 +00:00
g->GenerateDisplayItems();
Also consider constraints when zooming to fit. Before this commit, when working on convex sketches, zooming to fit was guaranteed to clip most or even all constraints, making it quite useless.
2016-08-01 14:00:00 +00:00
for(int i = 0; i < g->displayMesh.l.n; i++) {
Add a separate display mesh and edge list; so if we're working with a mesh than that's a copy, and if we're working with a shell then it's the shell's triangulation. [git-p4: depot-paths = "//depot/solvespace/": change = 1957]
2009-05-21 09:06:26 +00:00
STriangle *tr = &(g->displayMesh.l.elem[i]);
Consider plane faces when zooming to fit.
2016-03-25 07:32:11 +00:00
if(!includeMesh) {
bool found = false;
for(const hEntity &face : faces) {
if(face.v != tr->meta.face) continue;
found = true;
break;
}
if(!found) continue;
}
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
HandlePointForZoomToFit(tr->a, pmax, pmin, wmin, usePerspective);
HandlePointForZoomToFit(tr->b, pmax, pmin, wmin, usePerspective);
HandlePointForZoomToFit(tr->c, pmax, pmin, wmin, usePerspective);
Add reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 04:22:52 +00:00
}
Consider plane faces when zooming to fit.
2016-03-25 07:32:11 +00:00
if(!includeMesh) return;
Also consider constraints when zooming to fit. Before this commit, when working on convex sketches, zooming to fit was guaranteed to clip most or even all constraints, making it quite useless.
2016-08-01 14:00:00 +00:00
for(int i = 0; i < g->polyLoops.l.n; i++) {
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
SContour *sc = &(g->polyLoops.l.elem[i]);
Also consider constraints when zooming to fit. Before this commit, when working on convex sketches, zooming to fit was guaranteed to clip most or even all constraints, making it quite useless.
2016-08-01 14:00:00 +00:00
for(int j = 0; j < sc->l.n; j++) {
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
HandlePointForZoomToFit(sc->l.elem[j].p, pmax, pmin, wmin, usePerspective);
Add reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 04:22:52 +00:00
}
}
Add perspective, by a user-specified factor. So I have to apply that perspective in the gl matrices, and also everywhere that I check mouse pointer positions against the model, and for the zoom to fit. [git-p4: depot-paths = "//depot/solvespace/": change = 1796]
2008-06-17 19:12:25 +00:00
}
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
void GraphicsWindow::ZoomToFit(bool includingInvisibles, bool useSelection) {
std::vector<Entity *> entities;
Also consider constraints when zooming to fit. Before this commit, when working on convex sketches, zooming to fit was guaranteed to clip most or even all constraints, making it quite useless.
2016-08-01 14:00:00 +00:00
std::vector<Constraint *> constraints;
Consider plane faces when zooming to fit.
2016-03-25 07:32:11 +00:00
std::vector<hEntity> faces;
if(useSelection) {
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
for(int i = 0; i < selection.n; i++) {
Selection *s = &selection.elem[i];
Also consider constraints when zooming to fit. Before this commit, when working on convex sketches, zooming to fit was guaranteed to clip most or even all constraints, making it quite useless.
2016-08-01 14:00:00 +00:00
if(s->entity.v != 0) {
Entity *e = SK.entity.FindById(s->entity);
if(e->IsFace()) {
faces.push_back(e->h);
continue;
}
entities.push_back(e);
}
if(s->constraint.v != 0) {
Constraint *c = SK.constraint.FindById(s->constraint);
constraints.push_back(c);
Consider plane faces when zooming to fit.
2016-03-25 07:32:11 +00:00
}
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
}
Consider plane faces when zooming to fit.
2016-03-25 07:32:11 +00:00
}
Also consider constraints when zooming to fit. Before this commit, when working on convex sketches, zooming to fit was guaranteed to clip most or even all constraints, making it quite useless.
2016-08-01 14:00:00 +00:00
bool selectionUsed = !entities.empty() || !constraints.empty() || !faces.empty();
Consider plane faces when zooming to fit.
2016-03-25 07:32:11 +00:00
if(!selectionUsed) {
Also consider constraints when zooming to fit. Before this commit, when working on convex sketches, zooming to fit was guaranteed to clip most or even all constraints, making it quite useless.
2016-08-01 14:00:00 +00:00
for(Entity &e : SK.entity) {
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
// we don't want to handle separate points, because we will iterate them inside entities.
Also consider constraints when zooming to fit. Before this commit, when working on convex sketches, zooming to fit was guaranteed to clip most or even all constraints, making it quite useless.
2016-08-01 14:00:00 +00:00
if(e.IsPoint()) continue;
if(!includingInvisibles && !e.IsVisible()) continue;
entities.push_back(&e);
}
for(Constraint &c : SK.constraint) {
if(!c.IsVisible()) continue;
constraints.push_back(&c);
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
}
}
Add perspective, by a user-specified factor. So I have to apply that perspective in the gl matrices, and also everywhere that I check mouse pointer positions against the model, and for the zoom to fit. [git-p4: depot-paths = "//depot/solvespace/": change = 1796]
2008-06-17 19:12:25 +00:00
// On the first run, ignore perspective.
Point2d pmax = { -1e12, -1e12 }, pmin = { 1e12, 1e12 };
double wmin = 1;
Also consider constraints when zooming to fit. Before this commit, when working on convex sketches, zooming to fit was guaranteed to clip most or even all constraints, making it quite useless.
2016-08-01 14:00:00 +00:00
LoopOverPoints(entities, constraints, faces, &pmax, &pmin, &wmin,
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
/*usePerspective=*/false, /*includeMesh=*/!selectionUsed);
Add reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 04:22:52 +00:00
double xm = (pmax.x + pmin.x)/2, ym = (pmax.y + pmin.y)/2;
double dx = pmax.x - pmin.x, dy = pmax.y - pmin.y;
offset = offset.Plus(projRight.ScaledBy(-xm)).Plus(
projUp. ScaledBy(-ym));
Trim trailing whitespace.
2015-03-29 00:30:52 +00:00
Add perspective, by a user-specified factor. So I have to apply that perspective in the gl matrices, and also everywhere that I check mouse pointer positions against the model, and for the zoom to fit. [git-p4: depot-paths = "//depot/solvespace/": change = 1796]
2008-06-17 19:12:25 +00:00
// And based on this, we calculate the scale and offset
Quash warnings for floating-point equality comparisons GCC and Clang's -Wfloat-equal warning notes that comparing floating-point values with == or != may be questionable. But the few instances of these in SolveSpace are defensibly correct (as discussed with Jonathan), so to keep folks from getting nervous that a CAD application isn't handling its floats correctly, we define an EXACT() macro inside which the -Wfloat-equal warning is disabled. This macro will also serve as a source-code annotation, like a comment but better. (The warning is only disabled for Clang, alas, because GCC is particular about where _Pragma() can be used. This isn't so bad, however, because the warning is much easier to enable on Clang [thanks to -Weverything], whereas with GCC it has to be requested explicitly.)
2013-10-21 21:29:25 +00:00
if(EXACT(dx == 0 && dy == 0)) {
Add reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 04:22:52 +00:00
scale = 5;
} else {
double scalex = 1e12, scaley = 1e12;
Quash warnings for floating-point equality comparisons GCC and Clang's -Wfloat-equal warning notes that comparing floating-point values with == or != may be questionable. But the few instances of these in SolveSpace are defensibly correct (as discussed with Jonathan), so to keep folks from getting nervous that a CAD application isn't handling its floats correctly, we define an EXACT() macro inside which the -Wfloat-equal warning is disabled. This macro will also serve as a source-code annotation, like a comment but better. (The warning is only disabled for Clang, alas, because GCC is particular about where _Pragma() can be used. This isn't so bad, however, because the warning is much easier to enable on Clang [thanks to -Weverything], whereas with GCC it has to be requested explicitly.)
2013-10-21 21:29:25 +00:00
if(EXACT(dx != 0)) scalex = 0.9*width /dx;
if(EXACT(dy != 0)) scaley = 0.9*height/dy;
Add perspective, by a user-specified factor. So I have to apply that perspective in the gl matrices, and also everywhere that I check mouse pointer positions against the model, and for the zoom to fit. [git-p4: depot-paths = "//depot/solvespace/": change = 1796]
2008-06-17 19:12:25 +00:00
scale = min(scalex, scaley);
Use C++ std::{min,max,swap} instead of custom ones. The main benefit is that std::swap will ensure that the type of arguments is copy-constructible and move-constructible. It is more concise as well. When min and max are defined as macros, they will conflict with STL header files included by other C++ libraries; in this case STL will #undef any other definition.
2015-03-27 15:43:28 +00:00
scale = min(300.0, scale);
Many changes: * Rewrite surface handles in curves, so that Booleans beyond the first don't screw up. * If an intersection curve is identical to an existing curve (as happens when faces are coincident), take the piecewise linearization of the existing curve; this stops us from screwing up when different shells are pwl'd at different chord tols. * Hook up the plane faces again. * Remove coincident (parallel or anti-parallel) edges from the coincident-face edge lists when doing Booleans; those may happen if two faces are coincident with ours. * Miscellaneous bugfixes. It doesn't seem to screw up very much now, although tangent edges (and insufficient pwl resolution) may still cause problems. [git-p4: depot-paths = "//depot/solvespace/": change = 1929]
2009-03-15 23:04:45 +00:00
scale = max(0.003, scale);
Add perspective, by a user-specified factor. So I have to apply that perspective in the gl matrices, and also everywhere that I check mouse pointer positions against the model, and for the zoom to fit. [git-p4: depot-paths = "//depot/solvespace/": change = 1796]
2008-06-17 19:12:25 +00:00
}
// Then do another run, considering the perspective.
pmax.x = -1e12; pmax.y = -1e12;
pmin.x = 1e12; pmin.y = 1e12;
wmin = 1;
Also consider constraints when zooming to fit. Before this commit, when working on convex sketches, zooming to fit was guaranteed to clip most or even all constraints, making it quite useless.
2016-08-01 14:00:00 +00:00
LoopOverPoints(entities, constraints, faces, &pmax, &pmin, &wmin,
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
/*usePerspective=*/true, /*includeMesh=*/!selectionUsed);
Add perspective, by a user-specified factor. So I have to apply that perspective in the gl matrices, and also everywhere that I check mouse pointer positions against the model, and for the zoom to fit. [git-p4: depot-paths = "//depot/solvespace/": change = 1796]
2008-06-17 19:12:25 +00:00
// Adjust the scale so that no points are behind the camera
if(wmin < 0.1) {
Add text angle for styles. Add ability to quickly change between perspective and parallel projections. Add a snap grid, for points and for text comments. Draw text comments in the plane of their workplane if they have one, otherwise always facing forward. And fix a few nasty bugs: the possibility of an extremely long animation onto a workplane, accidental use of the wrong style line width for constraints, misplaced text box in style screen for default styles, other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 2037]
2009-09-29 11:35:19 +00:00
double k = SS.CameraTangent();
Add perspective, by a user-specified factor. So I have to apply that perspective in the gl matrices, and also everywhere that I check mouse pointer positions against the model, and for the zoom to fit. [git-p4: depot-paths = "//depot/solvespace/": change = 1796]
2008-06-17 19:12:25 +00:00
// w = 1+k*scale*z
double zmin = (wmin - 1)/(k*scale);
// 0.1 = 1 + k*scale*zmin
// (0.1 - 1)/(k*zmin) = scale
scale = min(scale, (0.1 - 1)/(k*zmin));
Add reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 04:22:52 +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
void GraphicsWindow::MenuView(Command id) {
Add the keyboard accelerator mechanism for menu items. Use that to implement zoom in/out, and orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1663]
2008-04-12 15:17:58 +00:00
switch(id) {
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 Command::ZOOM_IN:
Add the keyboard accelerator mechanism for menu items. Use that to implement zoom in/out, and orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1663]
2008-04-12 15:17:58 +00:00
SS.GW.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
SS.ScheduleShowTW();
Add the keyboard accelerator mechanism for menu items. Use that to implement zoom in/out, and orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1663]
2008-04-12 15:17:58 +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 Command::ZOOM_OUT:
Add the keyboard accelerator mechanism for menu items. Use that to implement zoom in/out, and orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1663]
2008-04-12 15:17:58 +00:00
SS.GW.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
SS.ScheduleShowTW();
Add the keyboard accelerator mechanism for menu items. Use that to implement zoom in/out, and orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1663]
2008-04-12 15:17:58 +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 Command::ZOOM_TO_FIT:
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
SS.GW.ZoomToFit(/*includingInvisibles=*/false, /*useSelection=*/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();
Add the keyboard accelerator mechanism for menu items. Use that to implement zoom in/out, and orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1663]
2008-04-12 15:17:58 +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 Command::SHOW_GRID:
Add text angle for styles. Add ability to quickly change between perspective and parallel projections. Add a snap grid, for points and for text comments. Draw text comments in the plane of their workplane if they have one, otherwise always facing forward. And fix a few nasty bugs: the possibility of an extremely long animation onto a workplane, accidental use of the wrong style line width for constraints, misplaced text box in style screen for default styles, other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 2037]
2009-09-29 11:35:19 +00:00
SS.GW.showSnapGrid = !SS.GW.showSnapGrid;
if(SS.GW.showSnapGrid && !SS.GW.LockedInWorkplane()) {
Message("No workplane is active, so the grid will not "
"appear.");
}
SS.GW.EnsureValidActives();
InvalidateGraphics();
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 Command::PERSPECTIVE_PROJ:
Instead of a "force parallel projection" menu item that's on by default, let's do a "use perspective projection" item that's off by default. Same meaning, but less confusion. [git-p4: depot-paths = "//depot/solvespace/": change = 2132]
2010-05-03 05:15:28 +00:00
SS.usePerspectiveProj = !SS.usePerspectiveProj;
Add text angle for styles. Add ability to quickly change between perspective and parallel projections. Add a snap grid, for points and for text comments. Draw text comments in the plane of their workplane if they have one, otherwise always facing forward. And fix a few nasty bugs: the possibility of an extremely long animation onto a workplane, accidental use of the wrong style line width for constraints, misplaced text box in style screen for default styles, other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 2037]
2009-09-29 11:35:19 +00:00
if(SS.cameraTangent < 1e-6) {
Error("The perspective factor is set to zero, so the view will "
Edit Message() and Error() strings to use just \n, not \r\n, since my own dialog boxes don't require the carriage returns. [git-p4: depot-paths = "//depot/solvespace/": change = 2109]
2010-01-16 18:15:40 +00:00
"always be a parallel projection.\n\n"
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
"For a perspective projection, modify the perspective "
"factor in the configuration screen. A value around 0.3 "
"is typical.");
Add text angle for styles. Add ability to quickly change between perspective and parallel projections. Add a snap grid, for points and for text comments. Draw text comments in the plane of their workplane if they have one, otherwise always facing forward. And fix a few nasty bugs: the possibility of an extremely long animation onto a workplane, accidental use of the wrong style line width for constraints, misplaced text box in style screen for default styles, other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 2037]
2009-09-29 11:35:19 +00:00
}
SS.GW.EnsureValidActives();
InvalidateGraphics();
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 Command::ONTO_WORKPLANE:
Make "Align view onto workplane" switch to locked workplane, if any. Original patch by yugami (http://solvespace.com/forum.pl?action=viewthread&parent=508).
2015-03-22 13:23:40 +00:00
if(SS.GW.LockedInWorkplane()) {
SS.GW.AnimateOntoWorkplane();
SS.ScheduleShowTW();
Replace ugly text links to hide/show things with icons. So add code to draw those, and hit test with the mouse, and display tool tips when the user hovers with the mouse. Also, underline links only when they're hovered, and not otherwise. And add a separate menu option to align the view to the active workplane, vs. activating the active group's workplane, and remap the bottom two graphics window toolbar icons to that and "nearest iso view" instead of draw in 2d/3d, since people tended to click on those without understanding and cause trouble. And by default, we force a parallel projection; so the factory default camera tangent is now 0.3, not 0. [git-p4: depot-paths = "//depot/solvespace/": change = 2131]
2010-05-03 05:04:42 +00:00
break;
Make "Align view onto workplane" switch to locked workplane, if any. Original patch by yugami (http://solvespace.com/forum.pl?action=viewthread&parent=508).
2015-03-22 13:23:40 +00:00
} // if not in 2d mode fall through and use ORTHO logic
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 Command::NEAREST_ORTHO:
case Command::NEAREST_ISO: {
Add menu items to snap view to nearest orthogonal or iso view. [git-p4: depot-paths = "//depot/solvespace/": change = 1882]
2009-01-02 04:06:47 +00:00
static const Vector ortho[3] = {
Vector::From(1, 0, 0),
Vector::From(0, 1, 0),
Vector::From(0, 0, 1)
};
double sqrt2 = sqrt(2.0), sqrt6 = sqrt(6.0);
Quaternion quat0 = Quaternion::From(SS.GW.projRight, SS.GW.projUp);
Quaternion quatf = quat0;
double dmin = 1e10;
// There are 24 possible views; 3*2*2*2
int i, j, negi, negj;
for(i = 0; i < 3; i++) {
for(j = 0; j < 3; j++) {
if(i == j) continue;
for(negi = 0; negi < 2; negi++) {
for(negj = 0; negj < 2; negj++) {
Vector ou = ortho[i], ov = ortho[j];
if(negi) ou = ou.ScaledBy(-1);
if(negj) ov = ov.ScaledBy(-1);
Vector on = ou.Cross(ov);
Vector u, v;
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(id == Command::NEAREST_ORTHO || id == Command::ONTO_WORKPLANE) {
Add menu items to snap view to nearest orthogonal or iso view. [git-p4: depot-paths = "//depot/solvespace/": change = 1882]
2009-01-02 04:06:47 +00:00
u = ou;
v = ov;
} else {
u =
ou.ScaledBy(1/sqrt2).Plus(
on.ScaledBy(-1/sqrt2));
v =
ou.ScaledBy(-1/sqrt6).Plus(
ov.ScaledBy(2/sqrt6).Plus(
on.ScaledBy(-1/sqrt6)));
}
Quaternion quatt = Quaternion::From(u, v);
double d = min(
(quatt.Minus(quat0)).Magnitude(),
(quatt.Plus(quat0)).Magnitude());
if(d < dmin) {
dmin = d;
quatf = quatt;
}
}
}
}
}
SS.GW.AnimateOnto(quatf, SS.GW.offset);
break;
}
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 Command::CENTER_VIEW:
Add menu item to center view at a point; and move non-ID list data structure from polygon.h into dsc.h, since it is used outside the polygon/mesh code. [git-p4: depot-paths = "//depot/solvespace/": change = 1892]
2009-01-13 06:56:05 +00:00
SS.GW.GroupSelection();
if(SS.GW.gs.n == 1 && SS.GW.gs.points == 1) {
Quaternion quat0;
// Offset is the selected point, quaternion is same as before
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Vector pt = SK.GetEntity(SS.GW.gs.point[0])->PointGetNum();
Add menu item to center view at a point; and move non-ID list data structure from polygon.h into dsc.h, since it is used outside the polygon/mesh code. [git-p4: depot-paths = "//depot/solvespace/": change = 1892]
2009-01-13 06:56:05 +00:00
quat0 = Quaternion::From(SS.GW.projRight, SS.GW.projUp);
SS.GW.AnimateOnto(quat0, pt.ScaledBy(-1));
SS.GW.ClearSelection();
} else {
Error("Select a point; this point will become the center "
"of the view on screen.");
}
break;
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 Command::SHOW_MENU_BAR:
Preliminary changes for FLTK support * Added "Show Menu Bar" and "Full Screen" menu items, which will be implemented in the FLTK interface. These are currently prevented from appearing in the Win32 interface by the HAVE_FLTK and HAVE_FLTK_FULLSCREEN macros. * Moved the "Show Text Window" down below the "Show Toolbar" item, so that "Show Menu Bar", "Show Toolbar" and "Show Text Window" are in the same vertical order as their corresponding UI elements typically take on * Added new platform-dependent routines to back the new menu items: void ToggleMenuBar(void); bool MenuBarIsVisible(void); void ToggleFullScreen(void); bool FullScreenIsActive(void); These are stubs in the Win32 code. * Fleshed out the system header #includes in solvespace.h, and moved them to the top of the file per convention * Rewrote the file dialog selection patterns in terms of macros that allow them to expand to either the FLTK or Windows formats * Don't use __stdcall in SSGL_CALLBACK, and make SSGL_CALLBACK 'extern "C"' as OpenGL usually expects function pointers to point to C functions
2013-10-25 05:04:16 +00:00
ToggleMenuBar();
Standardize the behaviour of constraints, by assigning them a workplane: a free constraint works in three-space (e.g. true distance), and a constraint in a workplane works in that plane (e.g. projected distance). And make the solver go automatically, though solver itself has lots of pieces missing. [git-p4: depot-paths = "//depot/solvespace/": change = 1691]
2008-04-27 05:00:12 +00:00
SS.GW.EnsureValidActives();
Preliminary changes for FLTK support * Added "Show Menu Bar" and "Full Screen" menu items, which will be implemented in the FLTK interface. These are currently prevented from appearing in the Win32 interface by the HAVE_FLTK and HAVE_FLTK_FULLSCREEN macros. * Moved the "Show Text Window" down below the "Show Toolbar" item, so that "Show Menu Bar", "Show Toolbar" and "Show Text Window" are in the same vertical order as their corresponding UI elements typically take on * Added new platform-dependent routines to back the new menu items: void ToggleMenuBar(void); bool MenuBarIsVisible(void); void ToggleFullScreen(void); bool FullScreenIsActive(void); These are stubs in the Win32 code. * Fleshed out the system header #includes in solvespace.h, and moved them to the top of the file per convention * Rewrote the file dialog selection patterns in terms of macros that allow them to expand to either the FLTK or Windows formats * Don't use __stdcall in SSGL_CALLBACK, and make SSGL_CALLBACK 'extern "C"' as OpenGL usually expects function pointers to point to C functions
2013-10-25 05:04:16 +00:00
InvalidateGraphics();
Standardize the behaviour of constraints, by assigning them a workplane: a free constraint works in three-space (e.g. true distance), and a constraint in a workplane works in that plane (e.g. projected distance). And make the solver go automatically, though solver itself has lots of pieces missing. [git-p4: depot-paths = "//depot/solvespace/": change = 1691]
2008-04-27 05:00:12 +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 Command::SHOW_TOOLBAR:
Add a toolbar. This requires a tool to convert my PNG icons to tables in the code, which I have written in perl and am checking in. Also get WM_MOUSELEAVE events from win32, so that I can de-hover everything when the mouse leaves the graphics window. And fix one of the icons, which was 23x24 instead of 24x24. [git-p4: depot-paths = "//depot/solvespace/": change = 1883]
2009-01-02 10:38:36 +00:00
SS.showToolbar = !SS.showToolbar;
SS.GW.EnsureValidActives();
Add text angle for styles. Add ability to quickly change between perspective and parallel projections. Add a snap grid, for points and for text comments. Draw text comments in the plane of their workplane if they have one, otherwise always facing forward. And fix a few nasty bugs: the possibility of an extremely long animation onto a workplane, accidental use of the wrong style line width for constraints, misplaced text box in style screen for default styles, other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 2037]
2009-09-29 11:35:19 +00:00
InvalidateGraphics();
Add a toolbar. This requires a tool to convert my PNG icons to tables in the code, which I have written in perl and am checking in. Also get WM_MOUSELEAVE events from win32, so that I can de-hover everything when the mouse leaves the graphics window. And fix one of the icons, which was 23x24 instead of 24x24. [git-p4: depot-paths = "//depot/solvespace/": change = 1883]
2009-01-02 10:38:36 +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 Command::SHOW_TEXT_WND:
Preliminary changes for FLTK support * Added "Show Menu Bar" and "Full Screen" menu items, which will be implemented in the FLTK interface. These are currently prevented from appearing in the Win32 interface by the HAVE_FLTK and HAVE_FLTK_FULLSCREEN macros. * Moved the "Show Text Window" down below the "Show Toolbar" item, so that "Show Menu Bar", "Show Toolbar" and "Show Text Window" are in the same vertical order as their corresponding UI elements typically take on * Added new platform-dependent routines to back the new menu items: void ToggleMenuBar(void); bool MenuBarIsVisible(void); void ToggleFullScreen(void); bool FullScreenIsActive(void); These are stubs in the Win32 code. * Fleshed out the system header #includes in solvespace.h, and moved them to the top of the file per convention * Rewrote the file dialog selection patterns in terms of macros that allow them to expand to either the FLTK or Windows formats * Don't use __stdcall in SSGL_CALLBACK, and make SSGL_CALLBACK 'extern "C"' as OpenGL usually expects function pointers to point to C functions
2013-10-25 05:04:16 +00:00
SS.GW.showTextWindow = !SS.GW.showTextWindow;
Add an ExprVector class, for a 3-vector whose members are expressions. That simplifies a few things considerably. And some little UI tweaks. [git-p4: depot-paths = "//depot/solvespace/": change = 1682]
2008-04-22 13:14:15 +00:00
SS.GW.EnsureValidActives();
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 Command::UNITS_INCHES:
SS.viewUnits = Unit::INCHES;
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 an ExprVector class, for a 3-vector whose members are expressions. That simplifies a few things considerably. And some little UI tweaks. [git-p4: depot-paths = "//depot/solvespace/": change = 1682]
2008-04-22 13:14:15 +00:00
SS.GW.EnsureValidActives();
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 Command::UNITS_MM:
SS.viewUnits = Unit::MM;
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();
Preliminary changes for FLTK support * Added "Show Menu Bar" and "Full Screen" menu items, which will be implemented in the FLTK interface. These are currently prevented from appearing in the Win32 interface by the HAVE_FLTK and HAVE_FLTK_FULLSCREEN macros. * Moved the "Show Text Window" down below the "Show Toolbar" item, so that "Show Menu Bar", "Show Toolbar" and "Show Text Window" are in the same vertical order as their corresponding UI elements typically take on * Added new platform-dependent routines to back the new menu items: void ToggleMenuBar(void); bool MenuBarIsVisible(void); void ToggleFullScreen(void); bool FullScreenIsActive(void); These are stubs in the Win32 code. * Fleshed out the system header #includes in solvespace.h, and moved them to the top of the file per convention * Rewrote the file dialog selection patterns in terms of macros that allow them to expand to either the FLTK or Windows formats * Don't use __stdcall in SSGL_CALLBACK, and make SSGL_CALLBACK 'extern "C"' as OpenGL usually expects function pointers to point to C functions
2013-10-25 05:04:16 +00:00
SS.GW.EnsureValidActives();
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 Command::FULL_SCREEN:
Preliminary changes for FLTK support * Added "Show Menu Bar" and "Full Screen" menu items, which will be implemented in the FLTK interface. These are currently prevented from appearing in the Win32 interface by the HAVE_FLTK and HAVE_FLTK_FULLSCREEN macros. * Moved the "Show Text Window" down below the "Show Toolbar" item, so that "Show Menu Bar", "Show Toolbar" and "Show Text Window" are in the same vertical order as their corresponding UI elements typically take on * Added new platform-dependent routines to back the new menu items: void ToggleMenuBar(void); bool MenuBarIsVisible(void); void ToggleFullScreen(void); bool FullScreenIsActive(void); These are stubs in the Win32 code. * Fleshed out the system header #includes in solvespace.h, and moved them to the top of the file per convention * Rewrote the file dialog selection patterns in terms of macros that allow them to expand to either the FLTK or Windows formats * Don't use __stdcall in SSGL_CALLBACK, and make SSGL_CALLBACK 'extern "C"' as OpenGL usually expects function pointers to point to C functions
2013-10-25 05:04:16 +00:00
ToggleFullScreen();
SS.GW.EnsureValidActives();
break;
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
default: ssassert(false, "Unexpected menu ID");
Add the keyboard accelerator mechanism for menu items. Use that to implement zoom in/out, and orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1663]
2008-04-12 15:17:58 +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::EnsureValidActives() {
Add functions to deep-copy Exprs, for those generated from user expressions that we wish to keep around. And make the 2d coordinate system (that causes points to generate 2 unknowns, not 3) an attribute of the request, not the group, and add user interface to change that. [git-p4: depot-paths = "//depot/solvespace/": change = 1670]
2008-04-18 07:06:37 +00:00
bool change = false;
// The active group must exist, and not be the references.
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Group *g = SK.group.FindByIdNoOops(activeGroup);
Add functions to deep-copy Exprs, for those generated from user expressions that we wish to keep around. And make the 2d coordinate system (that causes points to generate 2 unknowns, not 3) an attribute of the request, not the group, and add user interface to change that. [git-p4: depot-paths = "//depot/solvespace/": change = 1670]
2008-04-18 07:06:37 +00:00
if((!g) || (g->h.v == Group::HGROUP_REFERENCES.v)) {
int i;
Allow generating groups in arbitrary order.
2016-02-17 10:03:07 +00:00
for(i = 0; i < SK.groupOrder.n; i++) {
if(SK.groupOrder.elem[i].v != Group::HGROUP_REFERENCES.v) {
Add functions to deep-copy Exprs, for those generated from user expressions that we wish to keep around. And make the 2d coordinate system (that causes points to generate 2 unknowns, not 3) an attribute of the request, not the group, and add user interface to change that. [git-p4: depot-paths = "//depot/solvespace/": change = 1670]
2008-04-18 07:06:37 +00:00
break;
}
}
Allow generating groups in arbitrary order.
2016-02-17 10:03:07 +00:00
if(i >= SK.groupOrder.n) {
We now have selective solve; a group (and all the groups afterward) becomes dirty when the user makes a change, and only the dirty groups get solved. That's a huge effective speedup. Also add delete function for groups. That has an interesting issue; it actually ends up recursing on GenerateAll(), since GenerateAll() calls ClearSuper(), ClearSuper() might need to recreate a group (if all the groups were deleted), and that would activate the group, which calls GenerateAll. The right solution is probably a deferred execution mechanism, where you can schedule something to happen before we go idle, but not do it right now. [git-p4: depot-paths = "//depot/solvespace/": change = 1771]
2008-06-02 11:43:27 +00:00
// This can happen if the user deletes all the groups in the
// sketch. It's difficult to prevent that, because the last
// group might have been deleted automatically, because it failed
// a dependency. There needs to be something, so create a plane
// drawing group and activate that. They should never be able
// to delete the references, though.
activeGroup = SS.CreateDefaultDrawingGroup();
Allow removing active group. This is an artificial restriction that serves no useful purpose. Just switch to the previous group if asked to delete the current one. The ClearSuper() calls are reshuffled, since TW.ClearSuper() calls TW.Show() and so has to be called while the sketch is still valid, whereas GW.ClearSuper() also recreates the default group and thus it should be called after the first RemoveById+GenerateAll pair, or it'll recreate the default group before the entities on it have a chance to be pruned.
2016-02-18 11:11:59 +00:00
// We've created the default group, but not the workplane entity;
// do it now so that drawing mode isn't switched to "Free in 3d".
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::ALL);
We now have selective solve; a group (and all the groups afterward) becomes dirty when the user makes a change, and only the dirty groups get solved. That's a huge effective speedup. Also add delete function for groups. That has an interesting issue; it actually ends up recursing on GenerateAll(), since GenerateAll() calls ClearSuper(), ClearSuper() might need to recreate a group (if all the groups were deleted), and that would activate the group, which calls GenerateAll. The right solution is probably a deferred execution mechanism, where you can schedule something to happen before we go idle, but not do it right now. [git-p4: depot-paths = "//depot/solvespace/": change = 1771]
2008-06-02 11:43:27 +00:00
} else {
Allow generating groups in arbitrary order.
2016-02-17 10:03:07 +00:00
activeGroup = SK.groupOrder.elem[i];
We now have selective solve; a group (and all the groups afterward) becomes dirty when the user makes a change, and only the dirty groups get solved. That's a huge effective speedup. Also add delete function for groups. That has an interesting issue; it actually ends up recursing on GenerateAll(), since GenerateAll() calls ClearSuper(), ClearSuper() might need to recreate a group (if all the groups were deleted), and that would activate the group, which calls GenerateAll. The right solution is probably a deferred execution mechanism, where you can schedule something to happen before we go idle, but not do it right now. [git-p4: depot-paths = "//depot/solvespace/": change = 1771]
2008-06-02 11:43:27 +00:00
}
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
SK.GetGroup(activeGroup)->Activate();
Add functions to deep-copy Exprs, for those generated from user expressions that we wish to keep around. And make the 2d coordinate system (that causes points to generate 2 unknowns, not 3) an attribute of the request, not the group, and add user interface to change that. [git-p4: depot-paths = "//depot/solvespace/": change = 1670]
2008-04-18 07:06:37 +00:00
change = true;
Tweak the handles to make more space in the request ID, so that I can use the high bits as an "import ID" for imported parts, for hierarchy (that retains parametric capabilities). Implement enought that I can draw a datum point or a line segment, and drag points around in three-space. Still so much to do. [git-p4: depot-paths = "//depot/solvespace/": change = 1665]
2008-04-13 10:57:41 +00:00
}
Add functions to deep-copy Exprs, for those generated from user expressions that we wish to keep around. And make the 2d coordinate system (that causes points to generate 2 unknowns, not 3) an attribute of the request, not the group, and add user interface to change that. [git-p4: depot-paths = "//depot/solvespace/": change = 1670]
2008-04-18 07:06:37 +00:00
// The active coordinate system must also exist.
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 02:22:20 +00:00
if(LockedInWorkplane()) {
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Entity *e = SK.entity.FindByIdNoOops(ActiveWorkplane());
Fix a crash; it was possible to attempt to draw in a workplane that's in a group that solves after the current group. This means that the constraint/request gets deleted instantly, and stuff like auto-constraints on the just-created entities blow up. I now check that the active workplane comes from the active group or one solved before it. [git-p4: depot-paths = "//depot/solvespace/": change = 1729]
2008-05-17 23:48:58 +00:00
if(e) {
hGroup hgw = e->group;
if(hgw.v != activeGroup.v && SS.GroupsInOrder(activeGroup, hgw)) {
// The active workplane is in a group that comes after the
// active group; so any request or constraint will fail.
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 02:22:20 +00:00
SetWorkplaneFreeIn3d();
Fix a crash; it was possible to attempt to draw in a workplane that's in a group that solves after the current group. This means that the constraint/request gets deleted instantly, and stuff like auto-constraints on the just-created entities blow up. I now check that the active workplane comes from the active group or one solved before it. [git-p4: depot-paths = "//depot/solvespace/": change = 1729]
2008-05-17 23:48:58 +00:00
change = true;
}
} else {
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 02:22:20 +00:00
SetWorkplaneFreeIn3d();
Fix a crash; it was possible to attempt to draw in a workplane that's in a group that solves after the current group. This means that the constraint/request gets deleted instantly, and stuff like auto-constraints on the just-created entities blow up. I now check that the active workplane comes from the active group or one solved before it. [git-p4: depot-paths = "//depot/solvespace/": change = 1729]
2008-05-17 23:48:58 +00:00
change = true;
}
Tweak the handles to make more space in the request ID, so that I can use the high bits as an "import ID" for imported parts, for hierarchy (that retains parametric capabilities). Implement enought that I can draw a datum point or a line segment, and drag points around in three-space. Still so much to do. [git-p4: depot-paths = "//depot/solvespace/": change = 1665]
2008-04-13 10:57:41 +00:00
}
Rename some stuff in the IdList again. Rough in the file save stuff, though no file load stuff, and perhaps this can all be made to work from a table somehow. Move the quaternion stuff into its own class, and add a fancy animated view when you orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1672]
2008-04-18 11:11:48 +00:00
Add undo/redo. This saves the param guesses, constraints, groups, and requests to a separate list. It's messy, because I have to make a deep copy (e.g. of the remap list for the groups, or Expr * stuff) of some things. Others (e.g. the polygon or mesh) will be regenerated, so they should be discarded, but they must not get double-freed. In any case, works superficially. And fix a few memory leaks unrelated to this, and remove some dead code. [git-p4: depot-paths = "//depot/solvespace/": change = 1775]
2008-06-04 10:22:30 +00:00
// And update the checked state for various menus
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 02:22:20 +00:00
bool locked = LockedInWorkplane();
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
RadioMenuByCmd(Command::FREE_IN_3D, !locked);
RadioMenuByCmd(Command::SEL_WORKPLANE, locked);
Add an ExprVector class, for a 3-vector whose members are expressions. That simplifies a few things considerably. And some little UI tweaks. [git-p4: depot-paths = "//depot/solvespace/": change = 1682]
2008-04-22 13:14:15 +00:00
Add undo/redo. This saves the param guesses, constraints, groups, and requests to a separate list. It's messy, because I have to make a deep copy (e.g. of the remap list for the groups, or Expr * stuff) of some things. Others (e.g. the polygon or mesh) will be regenerated, so they should be discarded, but they must not get double-freed. In any case, works superficially. And fix a few memory leaks unrelated to this, and remove some dead code. [git-p4: depot-paths = "//depot/solvespace/": change = 1775]
2008-06-04 10:22:30 +00:00
SS.UndoEnableMenus();
Now display dimensions (and stuff in the text window) in the user-selected units, and enter them the same way. [git-p4: depot-paths = "//depot/solvespace/": change = 1792]
2008-06-14 09:51:25 +00:00
switch(SS.viewUnits) {
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 Unit::MM:
case Unit::INCHES:
Add an ExprVector class, for a 3-vector whose members are expressions. That simplifies a few things considerably. And some little UI tweaks. [git-p4: depot-paths = "//depot/solvespace/": change = 1682]
2008-04-22 13:14:15 +00:00
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
SS.viewUnits = Unit::MM;
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
break;
Add an ExprVector class, for a 3-vector whose members are expressions. That simplifies a few things considerably. And some little UI tweaks. [git-p4: depot-paths = "//depot/solvespace/": change = 1682]
2008-04-22 13:14:15 +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
RadioMenuByCmd(Command::UNITS_MM, SS.viewUnits == Unit::MM);
RadioMenuByCmd(Command::UNITS_INCHES, SS.viewUnits == Unit::INCHES);
Standardize the behaviour of constraints, by assigning them a workplane: a free constraint works in three-space (e.g. true distance), and a constraint in a workplane works in that plane (e.g. projected distance). And make the solver go automatically, though solver itself has lots of pieces missing. [git-p4: depot-paths = "//depot/solvespace/": change = 1691]
2008-04-27 05:00:12 +00:00
ShowTextWindow(SS.GW.showTextWindow);
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
CheckMenuByCmd(Command::SHOW_TEXT_WND, /*checked=*/SS.GW.showTextWindow);
Standardize the behaviour of constraints, by assigning them a workplane: a free constraint works in three-space (e.g. true distance), and a constraint in a workplane works in that plane (e.g. projected distance). And make the solver go automatically, though solver itself has lots of pieces missing. [git-p4: depot-paths = "//depot/solvespace/": change = 1691]
2008-04-27 05:00:12 +00:00
Remove FLTK port. It provides no value over the native GTK and Cocoa ports.
2015-03-24 23:38:06 +00:00
#if defined(__APPLE__)
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
CheckMenuByCmd(Command::SHOW_MENU_BAR, /*checked=*/MenuBarIsVisible());
Preliminary changes for FLTK support * Added "Show Menu Bar" and "Full Screen" menu items, which will be implemented in the FLTK interface. These are currently prevented from appearing in the Win32 interface by the HAVE_FLTK and HAVE_FLTK_FULLSCREEN macros. * Moved the "Show Text Window" down below the "Show Toolbar" item, so that "Show Menu Bar", "Show Toolbar" and "Show Text Window" are in the same vertical order as their corresponding UI elements typically take on * Added new platform-dependent routines to back the new menu items: void ToggleMenuBar(void); bool MenuBarIsVisible(void); void ToggleFullScreen(void); bool FullScreenIsActive(void); These are stubs in the Win32 code. * Fleshed out the system header #includes in solvespace.h, and moved them to the top of the file per convention * Rewrote the file dialog selection patterns in terms of macros that allow them to expand to either the FLTK or Windows formats * Don't use __stdcall in SSGL_CALLBACK, and make SSGL_CALLBACK 'extern "C"' as OpenGL usually expects function pointers to point to C functions
2013-10-25 05:04:16 +00:00
#endif
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
CheckMenuByCmd(Command::SHOW_TOOLBAR, /*checked=*/SS.showToolbar);
CheckMenuByCmd(Command::PERSPECTIVE_PROJ, /*checked=*/SS.usePerspectiveProj);
CheckMenuByCmd(Command::SHOW_GRID,/*checked=*/SS.GW.showSnapGrid);
Remove FLTK port. It provides no value over the native GTK and Cocoa ports.
2015-03-24 23:38:06 +00:00
#if defined(HAVE_GTK) || defined(__APPLE__)
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
CheckMenuByCmd(Command::FULL_SCREEN, /*checked=*/FullScreenIsActive());
Preliminary changes for FLTK support * Added "Show Menu Bar" and "Full Screen" menu items, which will be implemented in the FLTK interface. These are currently prevented from appearing in the Win32 interface by the HAVE_FLTK and HAVE_FLTK_FULLSCREEN macros. * Moved the "Show Text Window" down below the "Show Toolbar" item, so that "Show Menu Bar", "Show Toolbar" and "Show Text Window" are in the same vertical order as their corresponding UI elements typically take on * Added new platform-dependent routines to back the new menu items: void ToggleMenuBar(void); bool MenuBarIsVisible(void); void ToggleFullScreen(void); bool FullScreenIsActive(void); These are stubs in the Win32 code. * Fleshed out the system header #includes in solvespace.h, and moved them to the top of the file per convention * Rewrote the file dialog selection patterns in terms of macros that allow them to expand to either the FLTK or Windows formats * Don't use __stdcall in SSGL_CALLBACK, and make SSGL_CALLBACK 'extern "C"' as OpenGL usually expects function pointers to point to C functions
2013-10-25 05:04:16 +00:00
#endif
Add a toolbar. This requires a tool to convert my PNG icons to tables in the code, which I have written in perl and am checking in. Also get WM_MOUSELEAVE events from win32, so that I can de-hover everything when the mouse leaves the graphics window. And fix one of the icons, which was 23x24 instead of 24x24. [git-p4: depot-paths = "//depot/solvespace/": change = 1883]
2009-01-02 10:38:36 +00:00
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
if(change) SS.ScheduleShowTW();
Tweak the handles to make more space in the request ID, so that I can use the high bits as an "import ID" for imported parts, for hierarchy (that retains parametric capabilities). Implement enought that I can draw a datum point or a line segment, and drag points around in three-space. Still so much to do. [git-p4: depot-paths = "//depot/solvespace/": change = 1665]
2008-04-13 10:57:41 +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::SetWorkplaneFreeIn3d() {
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
SK.GetGroup(activeGroup)->activeWorkplane = Entity::FREE_IN_3D;
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 02:22:20 +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
hEntity GraphicsWindow::ActiveWorkplane() {
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Group *g = SK.group.FindByIdNoOops(activeGroup);
Start to describe the selected entities in the text window. Also more starting work on the selectable faces, and fiddling in an attempt to remove dependencies when stuff gets deleted. [git-p4: depot-paths = "//depot/solvespace/": change = 1760]
2008-06-01 00:26:41 +00:00
if(g) {
return g->activeWorkplane;
} else {
return Entity::FREE_IN_3D;
}
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 02:22:20 +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
bool GraphicsWindow::LockedInWorkplane() {
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 02:22:20 +00:00
return (SS.GW.ActiveWorkplane().v != Entity::FREE_IN_3D.v);
}
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::ForceTextWindowShown() {
Auto-show the text window when stepping a dimension, in addition to auto-showing when a solve fails. And accept expressions, not just numbers, for that new dimension value. [git-p4: depot-paths = "//depot/solvespace/": change = 1877]
2008-09-17 10:13:37 +00:00
if(!showTextWindow) {
showTextWindow = true;
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
CheckMenuByCmd(Command::SHOW_TEXT_WND, /*checked=*/true);
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
ShowTextWindow(true);
Auto-show the text window when stepping a dimension, in addition to auto-showing when a solve fails. And accept expressions, not just numbers, for that new dimension value. [git-p4: depot-paths = "//depot/solvespace/": change = 1877]
2008-09-17 10:13:37 +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::DeleteTaggedRequests() {
When deleting a request, rewrite the constraints on its points in such a way as to keep all the points that used to be coincident, still coincident. [git-p4: depot-paths = "//depot/solvespace/": change = 2013]
2009-07-08 09:36:18 +00:00
// Rewrite any point-coincident constraints that were affected by this
// deletion.
Request *r;
for(r = SK.request.First(); r; r = SK.request.NextAfter(r)) {
if(!r->tag) continue;
FixConstraintsForRequestBeingDeleted(r->h);
}
// and then delete the tagged requests.
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
SK.request.RemoveTagged();
Add a trim command. I can now do circles (or arcs) against lines, or lines against lines. The constraints get rather screwed up afterwards, of course. So make arcs with the endpoints coincident into circles, instead of nothings; since the first split of a circle produces that. And don't warn after deleting just point-coincident or horiz/vert constraints as a dependency; that's just a nuisance, because it happens too often. [git-p4: depot-paths = "//depot/solvespace/": change = 1884]
2009-01-03 12:27:33 +00:00
// An edit might be in progress for the just-deleted item. So
// now it's not.
HideGraphicsEditControl();
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();
Add a trim command. I can now do circles (or arcs) against lines, or lines against lines. The constraints get rather screwed up afterwards, of course. So make arcs with the endpoints coincident into circles, instead of nothings; since the first split of a circle produces that. And don't warn after deleting just point-coincident or horiz/vert constraints as a dependency; that's just a nuisance, because it happens too often. [git-p4: depot-paths = "//depot/solvespace/": change = 1884]
2009-01-03 12:27:33 +00:00
// And clear out the selection, which could contain that item.
ClearSuper();
// And regenerate to get rid of what it generates, plus anything
// that references it (since the regen code checks for that).
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::ALL);
Add a trim command. I can now do circles (or arcs) against lines, or lines against lines. The constraints get rather screwed up afterwards, of course. So make arcs with the endpoints coincident into circles, instead of nothings; since the first split of a circle produces that. And don't warn after deleting just point-coincident or horiz/vert constraints as a dependency; that's just a nuisance, because it happens too often. [git-p4: depot-paths = "//depot/solvespace/": change = 1884]
2009-01-03 12:27:33 +00:00
EnsureValidActives();
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 trim command. I can now do circles (or arcs) against lines, or lines against lines. The constraints get rather screwed up afterwards, of course. So make arcs with the endpoints coincident into circles, instead of nothings; since the first split of a circle produces that. And don't warn after deleting just point-coincident or horiz/vert constraints as a dependency; that's just a nuisance, because it happens too often. [git-p4: depot-paths = "//depot/solvespace/": change = 1884]
2009-01-03 12:27:33 +00:00
}
Add text angle for styles. Add ability to quickly change between perspective and parallel projections. Add a snap grid, for points and for text comments. Draw text comments in the plane of their workplane if they have one, otherwise always facing forward. And fix a few nasty bugs: the possibility of an extremely long animation onto a workplane, accidental use of the wrong style line width for constraints, misplaced text box in style screen for default styles, other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 2037]
2009-09-29 11:35:19 +00:00
Vector GraphicsWindow::SnapToGrid(Vector p) {
if(!LockedInWorkplane()) return p;
EntityBase *wrkpl = SK.GetEntity(ActiveWorkplane()),
*norm = wrkpl->Normal();
Vector wo = SK.GetEntity(wrkpl->point[0])->PointGetNum(),
wu = norm->NormalU(),
wv = norm->NormalV(),
wn = norm->NormalN();
Vector pp = (p.Minus(wo)).DotInToCsys(wu, wv, wn);
pp.x = floor((pp.x / SS.gridSpacing) + 0.5)*SS.gridSpacing;
pp.y = floor((pp.y / SS.gridSpacing) + 0.5)*SS.gridSpacing;
pp.z = 0;
Trim trailing whitespace.
2015-03-29 00:30:52 +00:00
Add text angle for styles. Add ability to quickly change between perspective and parallel projections. Add a snap grid, for points and for text comments. Draw text comments in the plane of their workplane if they have one, otherwise always facing forward. And fix a few nasty bugs: the possibility of an extremely long animation onto a workplane, accidental use of the wrong style line width for constraints, misplaced text box in style screen for default styles, other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 2037]
2009-09-29 11:35:19 +00:00
return pp.ScaleOutOfCsys(wu, wv, wn).Plus(wo);
}
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
void GraphicsWindow::MenuEdit(Command id) {
Add the keyboard accelerator mechanism for menu items. Use that to implement zoom in/out, and orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1663]
2008-04-12 15:17:58 +00:00
switch(id) {
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 Command::UNSELECT_ALL:
Little tweaks: wider lines drawn, fix editing dimensions. [git-p4: depot-paths = "//depot/solvespace/": change = 1761]
2008-06-01 04:31:28 +00:00
SS.GW.GroupSelection();
Add user interface to modify styles: change the color, line width, line width units, on-screen and export visibility. So now we can use that to modify the default styles, or to create custom styles. Also add code to draw fat lines, with round endcaps, since gl doesn't do that. Next we need some user interface to assign styles to entities, and to make all the export file formats support the style attributes. [git-p4: depot-paths = "//depot/solvespace/": change = 2029]
2009-09-18 08:14:15 +00:00
// If there's nothing selected to de-select, and no operation
// to cancel, then perhaps they want to return to the home
// screen in the text window.
Add text angle for styles. Add ability to quickly change between perspective and parallel projections. Add a snap grid, for points and for text comments. Draw text comments in the plane of their workplane if they have one, otherwise always facing forward. And fix a few nasty bugs: the possibility of an extremely long animation onto a workplane, accidental use of the wrong style line width for constraints, misplaced text box in style screen for default styles, other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 2037]
2009-09-29 11:35:19 +00:00
if(SS.GW.gs.n == 0 &&
SS.GW.gs.constraints == 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
SS.GW.pending.operation == Pending::NONE)
Add text angle for styles. Add ability to quickly change between perspective and parallel projections. Add a snap grid, for points and for text comments. Draw text comments in the plane of their workplane if they have one, otherwise always facing forward. And fix a few nasty bugs: the possibility of an extremely long animation onto a workplane, accidental use of the wrong style line width for constraints, misplaced text box in style screen for default styles, other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 2037]
2009-09-29 11:35:19 +00:00
{
Add ability to assign styles to cosmetic text (in the form of Constraint::COMMENTs), including line width and color, and text height and origin location. [git-p4: depot-paths = "//depot/solvespace/": change = 2033]
2009-09-24 15:52:48 +00:00
if(!(TextEditControlIsVisible() ||
GraphicsEditControlIsVisible()))
{
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::STYLE_INFO) {
SS.TW.GoToScreen(TextWindow::Screen::LIST_OF_STYLES);
Add user interface to modify styles: change the color, line width, line width units, on-screen and export visibility. So now we can use that to modify the default styles, or to create custom styles. Also add code to draw fat lines, with round endcaps, since gl doesn't do that. Next we need some user interface to assign styles to entities, and to make all the export file formats support the style attributes. [git-p4: depot-paths = "//depot/solvespace/": change = 2029]
2009-09-18 08:14:15 +00:00
} else {
SS.TW.ClearSuper();
}
We now have selective solve; a group (and all the groups afterward) becomes dirty when the user makes a change, and only the dirty groups get solved. That's a huge effective speedup. Also add delete function for groups. That has an interesting issue; it actually ends up recursing on GenerateAll(), since GenerateAll() calls ClearSuper(), ClearSuper() might need to recreate a group (if all the groups were deleted), and that would activate the group, which calls GenerateAll. The right solution is probably a deferred execution mechanism, where you can schedule something to happen before we go idle, but not do it right now. [git-p4: depot-paths = "//depot/solvespace/": change = 1771]
2008-06-02 11:43:27 +00:00
}
Little tweaks: wider lines drawn, fix editing dimensions. [git-p4: depot-paths = "//depot/solvespace/": change = 1761]
2008-06-01 04:31:28 +00:00
}
Start to describe the selected entities in the text window. Also more starting work on the selectable faces, and fiddling in an attempt to remove dependencies when stuff gets deleted. [git-p4: depot-paths = "//depot/solvespace/": change = 1760]
2008-06-01 00:26:41 +00:00
SS.GW.ClearSuper();
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();
Add sin and cos to the expression entry (for dimensions etc.), with the same precedence as sqrt. Add the code to find naked edges, and draw them highlighted on the model. And make the direction of trim curves consistent, always ccw with normal toward viewer; so there's no need to fix the directions before triangulating. [git-p4: depot-paths = "//depot/solvespace/": change = 1903]
2009-01-25 09:19:59 +00:00
SS.nakedEdges.Clear();
Indicate the just-exported origin and basis x and y vectors after exporting our view to any file that doesn't have a canvas size (and therefore doesn't get everything shifted to fit with the requested margins around it in the canvas). [git-p4: depot-paths = "//depot/solvespace/": change = 2107]
2010-01-14 05:24:32 +00:00
SS.justExportedInfo.draw = false;
Add ability to measure the area of a plane sketch, since that's easy and useful. Also make the volume measurement use Message(), and not a separate text window screen. And make Edit -> Unselect All (Esc) clear the marks drawn to indicate free parameters, since it clears all the other temporary stuff drawn in the graphics window. [git-p4: depot-paths = "//depot/solvespace/": change = 2121]
2010-03-01 17:23:57 +00:00
// This clears the marks drawn to indicate which points are
// still free to drag.
Param *p;
for(p = SK.param.First(); p; p = SK.param.NextAfter(p)) {
p->free = false;
}
Use a separate value of chord tolerance for exporting. Before this commit, a single chord tolerance was used for both displaying and exporting geometry. Moreover, this chord tolerance was specified in screen pixels, and as such depended on zoom level. This was inconvenient: exporting geometry with a required level of precision required awkward manipulations of viewport. Moreover, since some operations, e.g. mesh watertightness checking, were done on triangle meshes which are generated differently depending on the zoom level, these operations could report wildly different and quite confusing results depending on zoom level. The chord tolerance for display and export pursue completely distinct goals: display chord tolerance should be set high enough to achieve both fast regeneration and legible rendering, whereas export chord tolerance should be set to match the dimension tolerance of the fabrication process. This commit introduces two distinct chord tolerances: a display and an export one. Both chord tolerances are absolute and expressed in millimeters; this is inappropriate for display purposes but will be fixed in the next commits. After exporting, the geometry is redrawn with the chord tolerance configured for the export and an overlay message is displayed; pressing Esc clears the message and returns the display back to normal.
2016-01-27 04:07:54 +00:00
if(SS.exportMode) {
SS.exportMode = 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
SS.GenerateAll(SolveSpaceUI::Generate::ALL);
Use a separate value of chord tolerance for exporting. Before this commit, a single chord tolerance was used for both displaying and exporting geometry. Moreover, this chord tolerance was specified in screen pixels, and as such depended on zoom level. This was inconvenient: exporting geometry with a required level of precision required awkward manipulations of viewport. Moreover, since some operations, e.g. mesh watertightness checking, were done on triangle meshes which are generated differently depending on the zoom level, these operations could report wildly different and quite confusing results depending on zoom level. The chord tolerance for display and export pursue completely distinct goals: display chord tolerance should be set high enough to achieve both fast regeneration and legible rendering, whereas export chord tolerance should be set to match the dimension tolerance of the fabrication process. This commit introduces two distinct chord tolerances: a display and an export one. Both chord tolerances are absolute and expressed in millimeters; this is inappropriate for display purposes but will be fixed in the next commits. After exporting, the geometry is redrawn with the chord tolerance configured for the export and an overlay message is displayed; pressing Esc clears the message and returns the display back to normal.
2016-01-27 04:07:54 +00:00
}
Tweak the handles to make more space in the request ID, so that I can use the high bits as an "import ID" for imported parts, for hierarchy (that retains parametric capabilities). Implement enought that I can draw a datum point or a line segment, and drag points around in three-space. Still so much to do. [git-p4: depot-paths = "//depot/solvespace/": change = 1665]
2008-04-13 10:57:41 +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 Command::SELECT_ALL: {
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
Entity *e;
for(e = SK.entity.First(); e; e = SK.entity.NextAfter(e)) {
if(e->group.v != SS.GW.activeGroup.v) continue;
if(e->IsFace() || e->IsDistance()) continue;
Don't let invert selection, select edge chain, or marquee selection work on hidden entities. Also fix bug where undo state wasn't saved before toggling construction. [git-p4: depot-paths = "//depot/solvespace/": change = 2067]
2009-11-04 07:59:23 +00:00
if(!e->IsVisible()) 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
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
SS.GW.MakeSelected(e->h);
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
}
InvalidateGraphics();
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();
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 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
Entity *e;
int newlySelected = 0;
bool didSomething;
do {
didSomething = false;
for(e = SK.entity.First(); e; e = SK.entity.NextAfter(e)) {
if(e->group.v != SS.GW.activeGroup.v) continue;
if(!e->HasEndpoints()) continue;
Don't let invert selection, select edge chain, or marquee selection work on hidden entities. Also fix bug where undo state wasn't saved before toggling construction. [git-p4: depot-paths = "//depot/solvespace/": change = 2067]
2009-11-04 07:59:23 +00:00
if(!e->IsVisible()) 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
Vector st = e->EndpointStart(),
fi = e->EndpointFinish();
Trim trailing whitespace.
2015-03-29 00:30:52 +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
bool onChain = false, alreadySelected = false;
List<Selection> *ls = &(SS.GW.selection);
for(Selection *s = ls->First(); s; s = ls->NextAfter(s)) {
if(!s->entity.v) continue;
if(s->entity.v == e->h.v) {
alreadySelected = true;
continue;
}
Entity *se = SK.GetEntity(s->entity);
if(!se->HasEndpoints()) continue;
Vector sst = se->EndpointStart(),
sfi = se->EndpointFinish();
if(sst.Equals(st) || sst.Equals(fi) ||
sfi.Equals(st) || sfi.Equals(fi))
{
onChain = true;
}
}
if(onChain && !alreadySelected) {
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
SS.GW.MakeSelected(e->h);
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
newlySelected++;
didSomething = true;
}
}
} while(didSomething);
if(newlySelected == 0) {
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
Error("No additional entities share endpoints with the "
"selected entities.");
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
}
InvalidateGraphics();
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();
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 Command::ROTATE_90: {
Add a menu item to rotate an imported part by ninety degrees about the coordinate axis closest to the screen normal. [git-p4: depot-paths = "//depot/solvespace/": change = 1994]
2009-06-21 20:39:42 +00:00
SS.GW.GroupSelection();
Entity *e = NULL;
if(SS.GW.gs.n == 1 && SS.GW.gs.points == 1) {
e = SK.GetEntity(SS.GW.gs.point[0]);
} else if(SS.GW.gs.n == 1 && SS.GW.gs.entities == 1) {
e = SK.GetEntity(SS.GW.gs.entity[0]);
}
SS.GW.ClearSelection();
hGroup hg = e ? e->group : SS.GW.activeGroup;
Group *g = SK.GetGroup(hg);
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::LINKED) {
Add a menu item to rotate an imported part by ninety degrees about the coordinate axis closest to the screen normal. [git-p4: depot-paths = "//depot/solvespace/": change = 1994]
2009-06-21 20:39:42 +00:00
Error("To use this command, select a point or other "
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
"entity from an linked part, or make a link "
Add a menu item to rotate an imported part by ninety degrees about the coordinate axis closest to the screen normal. [git-p4: depot-paths = "//depot/solvespace/": change = 1994]
2009-06-21 20:39:42 +00:00
"group the active group.");
break;
}
SS.UndoRemember();
// Rotate by ninety degrees about the coordinate axis closest
// to the screen normal.
Vector norm = SS.GW.projRight.Cross(SS.GW.projUp);
norm = norm.ClosestOrtho();
norm = norm.WithMagnitude(1);
Quaternion qaa = Quaternion::From(norm, PI/2);
Add support for the 3dconnexion six degree of freedom input devices (in my case, a SpaceNavigator). I can transform the view of the part, or transform a part in an assembly. Also fix up mouse wheel input, so that it works even if it comes in chunks of less than 120 units. [git-p4: depot-paths = "//depot/solvespace/": change = 2019]
2009-07-20 19:05:33 +00:00
g->TransformImportedBy(Vector::From(0, 0, 0), qaa);
Add a menu item to rotate an imported part by ninety degrees about the coordinate axis closest to the screen normal. [git-p4: depot-paths = "//depot/solvespace/": change = 1994]
2009-06-21 20:39:42 +00:00
// and regenerate as necessary.
SS.MarkGroupDirty(hg);
SS.GenerateAll();
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 Command::SNAP_TO_GRID: {
Add text angle for styles. Add ability to quickly change between perspective and parallel projections. Add a snap grid, for points and for text comments. Draw text comments in the plane of their workplane if they have one, otherwise always facing forward. And fix a few nasty bugs: the possibility of an extremely long animation onto a workplane, accidental use of the wrong style line width for constraints, misplaced text box in style screen for default styles, other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 2037]
2009-09-29 11:35:19 +00:00
if(!SS.GW.LockedInWorkplane()) {
Rephrase error messages that say "select a workplane". This is confusing, as merely selecting one (and not activating it) is not enough to satisfy any of the conditions leading to these errors.
2016-10-11 13:46:05 +00:00
Error("No workplane is active. Activate a workplane "
"(with Sketch -> In Workplane) to define the plane "
"for the snap grid.");
Add text angle for styles. Add ability to quickly change between perspective and parallel projections. Add a snap grid, for points and for text comments. Draw text comments in the plane of their workplane if they have one, otherwise always facing forward. And fix a few nasty bugs: the possibility of an extremely long animation onto a workplane, accidental use of the wrong style line width for constraints, misplaced text box in style screen for default styles, other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 2037]
2009-09-29 11:35:19 +00:00
break;
}
SS.GW.GroupSelection();
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(SS.GW.gs.points == 0 && SS.GW.gs.constraintLabels == 0) {
Error("Can't snap these items to grid; select points, "
"text comments, or constraints with a label. "
"To snap a line, select its endpoints.");
Add text angle for styles. Add ability to quickly change between perspective and parallel projections. Add a snap grid, for points and for text comments. Draw text comments in the plane of their workplane if they have one, otherwise always facing forward. And fix a few nasty bugs: the possibility of an extremely long animation onto a workplane, accidental use of the wrong style line width for constraints, misplaced text box in style screen for default styles, other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 2037]
2009-09-29 11:35:19 +00:00
break;
}
SS.UndoRemember();
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
List<Selection> *ls = &(SS.GW.selection);
for(Selection *s = ls->First(); s; s = ls->NextAfter(s)) {
if(s->entity.v) {
hEntity hp = s->entity;
Entity *ep = SK.GetEntity(hp);
if(!ep->IsPoint()) continue;
Vector p = ep->PointGetNum();
ep->PointForceTo(SS.GW.SnapToGrid(p));
SS.GW.pending.points.Add(&hp);
SS.MarkGroupDirty(ep->group);
} else if(s->constraint.v) {
Constraint *c = SK.GetConstraint(s->constraint);
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
std::vector<Vector> refs;
c->GetReferencePoints(SS.GW.GetCamera(), &refs);
c->disp.offset = c->disp.offset.Plus(SS.GW.SnapToGrid(refs[0]).Minus(refs[0]));
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
}
Add text angle for styles. Add ability to quickly change between perspective and parallel projections. Add a snap grid, for points and for text comments. Draw text comments in the plane of their workplane if they have one, otherwise always facing forward. And fix a few nasty bugs: the possibility of an extremely long animation onto a workplane, accidental use of the wrong style line width for constraints, misplaced text box in style screen for default styles, other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 2037]
2009-09-29 11:35:19 +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
// Regenerate, with these points marked as dragged so that they
// get placed as close as possible to our snap grid.
SS.GenerateAll();
SS.GW.ClearPending();
Add text angle for styles. Add ability to quickly change between perspective and parallel projections. Add a snap grid, for points and for text comments. Draw text comments in the plane of their workplane if they have one, otherwise always facing forward. And fix a few nasty bugs: the possibility of an extremely long animation onto a workplane, accidental use of the wrong style line width for constraints, misplaced text box in style screen for default styles, other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 2037]
2009-09-29 11:35:19 +00:00
SS.GW.ClearSelection();
InvalidateGraphics();
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 Command::UNDO:
Add undo/redo. This saves the param guesses, constraints, groups, and requests to a separate list. It's messy, because I have to make a deep copy (e.g. of the remap list for the groups, or Expr * stuff) of some things. Others (e.g. the polygon or mesh) will be regenerated, so they should be discarded, but they must not get double-freed. In any case, works superficially. And fix a few memory leaks unrelated to this, and remove some dead code. [git-p4: depot-paths = "//depot/solvespace/": change = 1775]
2008-06-04 10:22:30 +00:00
SS.UndoUndo();
break;
Trim trailing whitespace.
2015-03-29 00:30:52 +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
case Command::REDO:
Add undo/redo. This saves the param guesses, constraints, groups, and requests to a separate list. It's messy, because I have to make a deep copy (e.g. of the remap list for the groups, or Expr * stuff) of some things. Others (e.g. the polygon or mesh) will be regenerated, so they should be discarded, but they must not get double-freed. In any case, works superficially. And fix a few memory leaks unrelated to this, and remove some dead code. [git-p4: depot-paths = "//depot/solvespace/": change = 1775]
2008-06-04 10:22:30 +00:00
SS.UndoRedo();
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 Command::REGEN_ALL:
Move `Solve Once Now' to the Edit menu, and call it `Regenerate'; and fix some other problems with the menu labels. [git-p4: depot-paths = "//depot/solvespace/": change = 1815]
2008-06-30 09:34:03 +00:00
SS.ReloadAllImported();
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::UNTIL_ACTIVE);
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();
Move `Solve Once Now' to the Edit menu, and call it `Regenerate'; and fix some other problems with the menu labels. [git-p4: depot-paths = "//depot/solvespace/": change = 1815]
2008-06-30 09:34:03 +00:00
break;
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
default: ssassert(false, "Unexpected menu ID");
Tweak the handles to make more space in the request ID, so that I can use the high bits as an "import ID" for imported parts, for hierarchy (that retains parametric capabilities). Implement enought that I can draw a datum point or a line segment, and drag points around in three-space. Still so much to do. [git-p4: depot-paths = "//depot/solvespace/": change = 1665]
2008-04-13 10:57:41 +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
void GraphicsWindow::MenuRequest(Command id) {
Added const qualifiers String literals in C++ are implicitly typed as 'const char *', and with this change, their const-ness is maintained when assigning them to variables or passing them as arguments. This significantly cuts down the number of warnings generated by the compiler.
2013-08-26 18:58:35 +00:00
const char *s;
Tweak the handles to make more space in the request ID, so that I can use the high bits as an "import ID" for imported parts, for hierarchy (that retains parametric capabilities). Implement enought that I can draw a datum point or a line segment, and drag points around in three-space. Still so much to do. [git-p4: depot-paths = "//depot/solvespace/": change = 1665]
2008-04-13 10:57:41 +00:00
switch(id) {
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 Command::SEL_WORKPLANE: {
Add functions to deep-copy Exprs, for those generated from user expressions that we wish to keep around. And make the 2d coordinate system (that causes points to generate 2 unknowns, not 3) an attribute of the request, not the group, and add user interface to change that. [git-p4: depot-paths = "//depot/solvespace/": change = 1670]
2008-04-18 07:06:37 +00:00
SS.GW.GroupSelection();
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Group *g = SK.GetGroup(SS.GW.activeGroup);
Add preliminary lathe (solid of revolution) support. I'm generating just the mesh, no derived entities (but I suppose that I could turn all points into circles). And fix some bugs where equations didn't get unique IDs, and make it possible to lock on to the group's workplane automatically, if you press W while free in 3d with no workplane selected. [git-p4: depot-paths = "//depot/solvespace/": change = 1780]
2008-06-06 11:35:28 +00:00
A great renaming. 2d coordinate systems are now called workplanes, and the associated entities are now just points. [git-p4: depot-paths = "//depot/solvespace/": change = 1690]
2008-04-27 03:26:27 +00:00
if(SS.GW.gs.n == 1 && SS.GW.gs.workplanes == 1) {
Add preliminary lathe (solid of revolution) support. I'm generating just the mesh, no derived entities (but I suppose that I could turn all points into circles). And fix some bugs where equations didn't get unique IDs, and make it possible to lock on to the group's workplane automatically, if you press W while free in 3d with no workplane selected. [git-p4: depot-paths = "//depot/solvespace/": change = 1780]
2008-06-06 11:35:28 +00:00
// A user-selected workplane
g->activeWorkplane = SS.GW.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
} else if(g->type == Group::Type::DRAWING_WORKPLANE) {
Add preliminary lathe (solid of revolution) support. I'm generating just the mesh, no derived entities (but I suppose that I could turn all points into circles). And fix some bugs where equations didn't get unique IDs, and make it possible to lock on to the group's workplane automatically, if you press W while free in 3d with no workplane selected. [git-p4: depot-paths = "//depot/solvespace/": change = 1780]
2008-06-06 11:35:28 +00:00
// The group's default workplane
g->activeWorkplane = g->h.entity(0);
Replace ugly text links to hide/show things with icons. So add code to draw those, and hit test with the mouse, and display tool tips when the user hovers with the mouse. Also, underline links only when they're hovered, and not otherwise. And add a separate menu option to align the view to the active workplane, vs. activating the active group's workplane, and remap the bottom two graphics window toolbar icons to that and "nearest iso view" instead of draw in 2d/3d, since people tended to click on those without understanding and cause trouble. And by default, we force a parallel projection; so the factory default camera tangent is now 0.3, not 0. [git-p4: depot-paths = "//depot/solvespace/": change = 2131]
2010-05-03 05:04:42 +00:00
Message("No workplane selected. Activating default workplane "
"for this group.");
Simplify the way that the active csys is handled, and default to locked on to the XY plane. And simplify the handling of colors in the text window: identify them by a character, not an integer ID, since the character is easier to remember. [git-p4: depot-paths = "//depot/solvespace/": change = 1687]
2008-04-25 08:26:15 +00:00
}
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 02:22:20 +00:00
if(!SS.GW.LockedInWorkplane()) {
Replace ugly text links to hide/show things with icons. So add code to draw those, and hit test with the mouse, and display tool tips when the user hovers with the mouse. Also, underline links only when they're hovered, and not otherwise. And add a separate menu option to align the view to the active workplane, vs. activating the active group's workplane, and remap the bottom two graphics window toolbar icons to that and "nearest iso view" instead of draw in 2d/3d, since people tended to click on those without understanding and cause trouble. And by default, we force a parallel projection; so the factory default camera tangent is now 0.3, not 0. [git-p4: depot-paths = "//depot/solvespace/": change = 2131]
2010-05-03 05:04:42 +00:00
Error("No workplane is selected, and the active group does "
"not have a default workplane. Try selecting a "
"workplane, or activating a sketch-in-new-workplane "
"group.");
Simplify the way that the active csys is handled, and default to locked on to the XY plane. And simplify the handling of colors in the text window: identify them by a character, not an integer ID, since the character is easier to remember. [git-p4: depot-paths = "//depot/solvespace/": change = 1687]
2008-04-25 08:26:15 +00:00
break;
Add functions to deep-copy Exprs, for those generated from user expressions that we wish to keep around. And make the 2d coordinate system (that causes points to generate 2 unknowns, not 3) an attribute of the request, not the group, and add user interface to change that. [git-p4: depot-paths = "//depot/solvespace/": change = 1670]
2008-04-18 07:06:37 +00:00
}
A great renaming. 2d coordinate systems are now called workplanes, and the associated entities are now just points. [git-p4: depot-paths = "//depot/solvespace/": change = 1690]
2008-04-27 03:26:27 +00:00
// Align the view with the selected workplane
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 02:22:20 +00:00
SS.GW.AnimateOntoWorkplane();
Fix a crash; it was possible to attempt to draw in a workplane that's in a group that solves after the current group. This means that the constraint/request gets deleted instantly, and stuff like auto-constraints on the just-created entities blow up. I now check that the active workplane comes from the active group or one solved before it. [git-p4: depot-paths = "//depot/solvespace/": change = 1729]
2008-05-17 23:48:58 +00:00
SS.GW.ClearSuper();
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 functions to deep-copy Exprs, for those generated from user expressions that we wish to keep around. And make the 2d coordinate system (that causes points to generate 2 unknowns, not 3) an attribute of the request, not the group, and add user interface to change that. [git-p4: depot-paths = "//depot/solvespace/": change = 1670]
2008-04-18 07:06:37 +00:00
break;
Simplify the way that the active csys is handled, and default to locked on to the XY plane. And simplify the handling of colors in the text window: identify them by a character, not an integer ID, since the character is easier to remember. [git-p4: depot-paths = "//depot/solvespace/": change = 1687]
2008-04-25 08:26:15 +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
case Command::FREE_IN_3D:
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 02:22:20 +00:00
SS.GW.SetWorkplaneFreeIn3d();
Add functions to deep-copy Exprs, for those generated from user expressions that we wish to keep around. And make the 2d coordinate system (that causes points to generate 2 unknowns, not 3) an attribute of the request, not the group, and add user interface to change that. [git-p4: depot-paths = "//depot/solvespace/": change = 1670]
2008-04-18 07:06:37 +00:00
SS.GW.EnsureValidActives();
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 text angle for styles. Add ability to quickly change between perspective and parallel projections. Add a snap grid, for points and for text comments. Draw text comments in the plane of their workplane if they have one, otherwise always facing forward. And fix a few nasty bugs: the possibility of an extremely long animation onto a workplane, accidental use of the wrong style line width for constraints, misplaced text box in style screen for default styles, other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 2037]
2009-09-29 11:35:19 +00:00
InvalidateGraphics();
Add functions to deep-copy Exprs, for those generated from user expressions that we wish to keep around. And make the 2d coordinate system (that causes points to generate 2 unknowns, not 3) an attribute of the request, not the group, and add user interface to change that. [git-p4: depot-paths = "//depot/solvespace/": change = 1670]
2008-04-18 07:06:37 +00:00
break;
Add a command to create an arc that's tangent to two line segments. This was possible before (by drawing everything explicitly), but now it's easy. [git-p4: depot-paths = "//depot/solvespace/": change = 1838]
2008-07-14 02:45:11 +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
case Command::TANGENT_ARC:
Add a command to create an arc that's tangent to two line segments. This was possible before (by drawing everything explicitly), but now it's easy. [git-p4: depot-paths = "//depot/solvespace/": change = 1838]
2008-07-14 02:45:11 +00:00
SS.GW.GroupSelection();
if(SS.GW.gs.n == 1 && SS.GW.gs.points == 1) {
Add a trim command. I can now do circles (or arcs) against lines, or lines against lines. The constraints get rather screwed up afterwards, of course. So make arcs with the endpoints coincident into circles, instead of nothings; since the first split of a circle produces that. And don't warn after deleting just point-coincident or horiz/vert constraints as a dependency; that's just a nuisance, because it happens too often. [git-p4: depot-paths = "//depot/solvespace/": change = 1884]
2009-01-03 12:27:33 +00:00
SS.GW.MakeTangentArc();
Improve the non-parametric rounding. It now works on both lines and circles, using a numerical method. And the user can specify a radius, instead of letting us choose automatically, and specify whether the original lines should be kept and made construction, or deleted. [git-p4: depot-paths = "//depot/solvespace/": change = 2146]
2010-05-16 16:36:23 +00:00
} else if(SS.GW.gs.n != 0) {
Error("Bad selection for tangent arc at point. Select a "
"single point, or select nothing to set up arc "
"parameters.");
Add a command to create an arc that's tangent to two line segments. This was possible before (by drawing everything explicitly), but now it's easy. [git-p4: depot-paths = "//depot/solvespace/": change = 1838]
2008-07-14 02:45:11 +00:00
} else {
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::TANGENT_ARC);
Improve the non-parametric rounding. It now works on both lines and circles, using a numerical method. And the user can specify a radius, instead of letting us choose automatically, and specify whether the original lines should be kept and made construction, or deleted. [git-p4: depot-paths = "//depot/solvespace/": change = 2146]
2010-05-16 16:36:23 +00:00
SS.GW.ForceTextWindowShown();
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();
Highlight pending operation on toolbar, even if started via keyboard.
2015-03-29 21:37:21 +00:00
InvalidateGraphics(); // repaint toolbar
Add a command to create an arc that's tangent to two line segments. This was possible before (by drawing everything explicitly), but now it's easy. [git-p4: depot-paths = "//depot/solvespace/": change = 1838]
2008-07-14 02:45:11 +00:00
}
break;
Improve the non-parametric rounding. It now works on both lines and circles, using a numerical method. And the user can specify a radius, instead of letting us choose automatically, and specify whether the original lines should be kept and made construction, or deleted. [git-p4: depot-paths = "//depot/solvespace/": change = 2146]
2010-05-16 16:36:23 +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
case Command::ARC: s = "click point on arc (draws anti-clockwise)"; goto c;
case Command::DATUM_POINT: s = "click to place datum point"; goto c;
case Command::LINE_SEGMENT: s = "click first point of line segment"; goto c;
case Command::CONSTR_SEGMENT: s = "click first point of construction line segment"; goto c;
case Command::CUBIC: s = "click first point of cubic segment"; goto c;
case Command::CIRCLE: s = "click center of circle"; goto c;
case Command::WORKPLANE: s = "click origin of workplane"; goto c;
case Command::RECTANGLE: s = "click one corner of rectangle"; goto c;
case Command::TTF_TEXT: s = "click top left of text"; goto c;
Tweak the handles to make more space in the request ID, so that I can use the high bits as an "import ID" for imported parts, for hierarchy (that retains parametric capabilities). Implement enought that I can draw a datum point or a line segment, and drag points around in three-space. Still so much to do. [git-p4: depot-paths = "//depot/solvespace/": change = 1665]
2008-04-13 10:57:41 +00:00
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
SS.GW.pending.operation = GraphicsWindow::Pending::COMMAND;
SS.GW.pending.command = id;
A big change, to add a concept of normals. These are "oriented vectors", represented by unit quaternions. This permits me to add circles, where the normal defines the plane of the circle. Still many things painful. The interface for editing normals is not so intuitive, and it's not yet clear how I would e.g. export a circle entity and recreate it properly, since that entity has a param not associated with a normal or point. And the transformed points/normals do not yet support rotations. That will be necessary soon. [git-p4: depot-paths = "//depot/solvespace/": change = 1705]
2008-05-05 06:18:01 +00:00
SS.GW.pending.description = s;
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();
Highlight pending operation on toolbar, even if started via keyboard.
2015-03-29 21:37:21 +00:00
InvalidateGraphics(); // repaint toolbar
Add the keyboard accelerator mechanism for menu items. Use that to implement zoom in/out, and orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1663]
2008-04-12 15:17:58 +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 Command::CONSTRUCTION: {
Don't let invert selection, select edge chain, or marquee selection work on hidden entities. Also fix bug where undo state wasn't saved before toggling construction. [git-p4: depot-paths = "//depot/solvespace/": change = 2067]
2009-11-04 07:59:23 +00:00
SS.UndoRemember();
Add a convenience command to draw a rectangle (as four line segments), add the toggle construction command, and color the lines differently depending on what group you're in. Also change dynamic memory stuff to use a Win32 heap for everything (no malloc), and validate that often. I think I've seen it crash, though I can't reproduce it. [git-p4: depot-paths = "//depot/solvespace/": change = 1708]
2008-05-07 04:17:29 +00:00
SS.GW.GroupSelection();
Add warning when user tries to toggle construction with nothing selected. [git-p4: depot-paths = "//depot/solvespace/": change = 2097]
2010-01-07 08:02:13 +00:00
if(SS.GW.gs.entities == 0) {
Error("No entities are selected. Select entities before "
"trying to toggle their construction state.");
}
Add a convenience command to draw a rectangle (as four line segments), add the toggle construction command, and color the lines differently depending on what group you're in. Also change dynamic memory stuff to use a Win32 heap for everything (no malloc), and validate that often. I think I've seen it crash, though I can't reproduce it. [git-p4: depot-paths = "//depot/solvespace/": change = 1708]
2008-05-07 04:17:29 +00:00
int i;
for(i = 0; i < SS.GW.gs.entities; i++) {
hEntity he = SS.GW.gs.entity[i];
if(!he.isFromRequest()) continue;
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Request *r = SK.GetRequest(he.request());
Add a convenience command to draw a rectangle (as four line segments), add the toggle construction command, and color the lines differently depending on what group you're in. Also change dynamic memory stuff to use a Win32 heap for everything (no malloc), and validate that often. I think I've seen it crash, though I can't reproduce it. [git-p4: depot-paths = "//depot/solvespace/": change = 1708]
2008-05-07 04:17:29 +00:00
r->construction = !(r->construction);
We now have selective solve; a group (and all the groups afterward) becomes dirty when the user makes a change, and only the dirty groups get solved. That's a huge effective speedup. Also add delete function for groups. That has an interesting issue; it actually ends up recursing on GenerateAll(), since GenerateAll() calls ClearSuper(), ClearSuper() might need to recreate a group (if all the groups were deleted), and that would activate the group, which calls GenerateAll. The right solution is probably a deferred execution mechanism, where you can schedule something to happen before we go idle, but not do it right now. [git-p4: depot-paths = "//depot/solvespace/": change = 1771]
2008-06-02 11:43:27 +00:00
SS.MarkGroupDirty(r->group);
Add a convenience command to draw a rectangle (as four line segments), add the toggle construction command, and color the lines differently depending on what group you're in. Also change dynamic memory stuff to use a Win32 heap for everything (no malloc), and validate that often. I think I've seen it crash, though I can't reproduce it. [git-p4: depot-paths = "//depot/solvespace/": change = 1708]
2008-05-07 04:17:29 +00:00
}
SS.GW.ClearSelection();
Consolidate the code that determines whether an entity is visible in one place. And remove the ability to disable the solver, since that's unlikely to be anything but confusing (and in any case, was badly implemented). This is in preparation for selective solving, of only the dirty groups. [git-p4: depot-paths = "//depot/solvespace/": change = 1769]
2008-06-02 09:31:26 +00:00
SS.GenerateAll();
Add a convenience command to draw a rectangle (as four line segments), add the toggle construction command, and color the lines differently depending on what group you're in. Also change dynamic memory stuff to use a Win32 heap for everything (no malloc), and validate that often. I think I've seen it crash, though I can't reproduce it. [git-p4: depot-paths = "//depot/solvespace/": change = 1708]
2008-05-07 04:17:29 +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 Command::SPLIT_CURVES:
Add a trim command. I can now do circles (or arcs) against lines, or lines against lines. The constraints get rather screwed up afterwards, of course. So make arcs with the endpoints coincident into circles, instead of nothings; since the first split of a circle produces that. And don't warn after deleting just point-coincident or horiz/vert constraints as a dependency; that's just a nuisance, because it happens too often. [git-p4: depot-paths = "//depot/solvespace/": change = 1884]
2009-01-03 12:27:33 +00:00
SS.GW.SplitLinesOrCurves();
break;
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
default: ssassert(false, "Unexpected menu ID");
Add the keyboard accelerator mechanism for menu items. Use that to implement zoom in/out, and orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1663]
2008-04-12 15:17:58 +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::ClearSuper() {
Start to describe the selected entities in the text window. Also more starting work on the selectable faces, and fiddling in an attempt to remove dependencies when stuff gets deleted. [git-p4: depot-paths = "//depot/solvespace/": change = 1760]
2008-06-01 00:26:41 +00:00
HideGraphicsEditControl();
Add angle constraints. I'm doing these differently from SketchFlat, as a constraint on the direction cosine, rather than driving the dot product against a rotated vector to zero. The drawing is the ugly part; to do that for skew lines, I gave up. Also add a function to clear non-existent items on the selection after solving, since that could have caused an oops(). [git-p4: depot-paths = "//depot/solvespace/": change = 1727]
2008-05-17 11:15:14 +00:00
ClearPending();
ClearSelection();
hover.Clear();
EnsureValidActives();
}
Replace ugly text links to hide/show things with icons. So add code to draw those, and hit test with the mouse, and display tool tips when the user hovers with the mouse. Also, underline links only when they're hovered, and not otherwise. And add a separate menu option to align the view to the active workplane, vs. activating the active group's workplane, and remap the bottom two graphics window toolbar icons to that and "nearest iso view" instead of draw in 2d/3d, since people tended to click on those without understanding and cause trouble. And by default, we force a parallel projection; so the factory default camera tangent is now 0.3, not 0. [git-p4: depot-paths = "//depot/solvespace/": change = 2131]
2010-05-03 05:04:42 +00:00
void GraphicsWindow::ToggleBool(bool *v) {
*v = !*v;
Start to use that text window a bit; user interface to show and hide things. [git-p4: depot-paths = "//depot/solvespace/": change = 1661]
2008-04-11 12:47:14 +00:00
Stipple the selected/hovered faces, instead of drawing them in solid red or yellow. And add user interface to `hide' the faces (i.e., to make them unselectable), defaulting to hidden in everything except extrudes or imports. [git-p4: depot-paths = "//depot/solvespace/": change = 1768]
2008-06-02 05:38:12 +00:00
// The faces are shown as special stippling on the shaded triangle mesh,
// so not meaningful to show them and hide the shaded.
Replace ugly text links to hide/show things with icons. So add code to draw those, and hit test with the mouse, and display tool tips when the user hovers with the mouse. Also, underline links only when they're hovered, and not otherwise. And add a separate menu option to align the view to the active workplane, vs. activating the active group's workplane, and remap the bottom two graphics window toolbar icons to that and "nearest iso view" instead of draw in 2d/3d, since people tended to click on those without understanding and cause trouble. And by default, we force a parallel projection; so the factory default camera tangent is now 0.3, not 0. [git-p4: depot-paths = "//depot/solvespace/": change = 2131]
2010-05-03 05:04:42 +00:00
if(!showShaded) showFaces = false;
Stipple the selected/hovered faces, instead of drawing them in solid red or yellow. And add user interface to `hide' the faces (i.e., to make them unselectable), defaulting to hidden in everything except extrudes or imports. [git-p4: depot-paths = "//depot/solvespace/": change = 1768]
2008-06-02 05:38:12 +00:00
Put back code to generate emphasized edges from a mesh; so now we can show edges for both meshes and shells, and export them and hidden line remove and all the usual stuff. And fix the zoom to fit on startup, so that it considers hidden entities too. That avoids the problem where things get generated at stupid chord tolerance because no entities were visible and the mesh of course did not yet exist. [git-p4: depot-paths = "//depot/solvespace/": change = 1961]
2009-05-29 05:40:17 +00:00
// We might need to regenerate the mesh and edge list, since the edges
// wouldn't have been generated if they were previously hidden.
Allow displaying outlines without any other edges. As usual, what's displayed is what's exported.
2016-08-14 00:55:27 +00:00
if(showEdges || showOutlines) {
SK.GetGroup(activeGroup)->displayDirty = true;
}
Put back code to generate emphasized edges from a mesh; so now we can show edges for both meshes and shells, and export them and hidden line remove and all the usual stuff. And fix the zoom to fit on startup, so that it considers hidden entities too. That avoids the problem where things get generated at stupid chord tolerance because no entities were visible and the mesh of course did not yet exist. [git-p4: depot-paths = "//depot/solvespace/": change = 1961]
2009-05-29 05:40:17 +00:00
Consolidate the code that determines whether an entity is visible in one place. And remove the ability to disable the solver, since that's unlikely to be anything but confusing (and in any case, was badly implemented). This is in preparation for selective solving, of only the dirty groups. [git-p4: depot-paths = "//depot/solvespace/": change = 1769]
2008-06-02 09:31:26 +00:00
SS.GenerateAll();
Start to use that text window a bit; user interface to show and hide things. [git-p4: depot-paths = "//depot/solvespace/": change = 1661]
2008-04-11 12:47:14 +00:00
InvalidateGraphics();
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();
Start to use that text window a bit; user interface to show and hide things. [git-p4: depot-paths = "//depot/solvespace/": change = 1661]
2008-04-11 12:47:14 +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
bool GraphicsWindow::SuggestLineConstraint(hRequest request, Constraint::Type *type) {
Automatically add horz/vert constraints to lines if close enough.
2015-03-29 22:26:07 +00:00
if(LockedInWorkplane()) {
Entity *ptA = SK.GetEntity(request.entity(1)),
*ptB = SK.GetEntity(request.entity(2));
Expr *au, *av, *bu, *bv;
ptA->PointGetExprsInWorkplane(ActiveWorkplane(), &au, &av);
ptB->PointGetExprsInWorkplane(ActiveWorkplane(), &bu, &bv);
Use relative tolerance for axis-parallel autoconstrainter. This works better than absolute tolerance in display pixels for small lines.
2015-11-19 05:30:31 +00:00
double du = au->Minus(bu)->Eval();
double dv = av->Minus(bv)->Eval();
Automatically add horz/vert constraints to lines if close enough.
2015-03-29 22:26:07 +00:00
Use relative tolerance for axis-parallel autoconstrainter. This works better than absolute tolerance in display pixels for small lines.
2015-11-19 05:30:31 +00:00
const double TOLERANCE_RATIO = 0.02;
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(fabs(dv) > LENGTH_EPS && fabs(du / dv) < TOLERANCE_RATIO) {
*type = Constraint::Type::VERTICAL;
return true;
} else if(fabs(du) > LENGTH_EPS && fabs(dv / du) < TOLERANCE_RATIO) {
*type = Constraint::Type::HORIZONTAL;
return true;
}
Automatically add horz/vert constraints to lines if close enough.
2015-03-29 22:26:07 +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
return false;
Automatically add horz/vert constraints to lines if close enough.
2015-03-29 22:26:07 +00:00
}