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

821 lines
30 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
//-----------------------------------------------------------------------------
// The text-based browser window, used to view the structure of the model by
// groups and for other similar purposes.
//
// Copyright 2008-2013 Jonathan Westhues.
//-----------------------------------------------------------------------------
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
#include "solvespace.h"
//-----------------------------------------------------------------------------
Remove the back button from the text window, since I never used it. And fix a bug; wasn't asking the user whether to save before abandoning file when a new file was opened recent. [git-p4: depot-paths = "//depot/solvespace/": change = 1830]
2008-07-10 06:11:56 +00:00
// A navigation bar that always appears at the top of the window, with a
// link to bring us back home.
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
//-----------------------------------------------------------------------------
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
void TextWindow::ScreenHome(int link, uint32_t 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
SS.TW.GoToScreen(Screen::LIST_OF_GROUPS);
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
}
void TextWindow::ShowHeader(bool withNav) {
ClearScreen();
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
const char *header;
std::string desc;
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(SS.GW.LockedInWorkplane()) {
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
header = "in plane: ";
desc = SK.GetEntity(SS.GW.ActiveWorkplane())->DescriptionString();
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
} else {
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
header = "drawing / constraining in 3d";
desc = "";
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
}
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
// Navigation buttons
if(withNav) {
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
Printf(false, " %Fl%Lh%fhome%E %Ft%s%E%s",
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
(&TextWindow::ScreenHome), header, desc.c_str());
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
} else {
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
Printf(false, " %Ft%s%E%s", header, desc.c_str());
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
}
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
// Leave space for the icons that are painted here.
Printf(false, "");
Printf(false, "");
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
}
//-----------------------------------------------------------------------------
// The screen that shows a list of every group in the sketch, with options
// to hide or show them, and to view them in detail. This is our home page.
//-----------------------------------------------------------------------------
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
void TextWindow::ScreenSelectGroup(int link, uint32_t 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
SS.TW.GoToScreen(Screen::GROUP_INFO);
Remove the back button from the text window, since I never used it. And fix a bug; wasn't asking the user whether to save before abandoning file when a new file was opened recent. [git-p4: depot-paths = "//depot/solvespace/": change = 1830]
2008-07-10 06:11:56 +00:00
SS.TW.shown.group.v = v;
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
}
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
void TextWindow::ScreenToggleGroupShown(int link, uint32_t v) {
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
hGroup hg = { v };
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(hg);
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
g->visible = !(g->visible);
// If a group was just shown, then it might not have been generated
// previously, so regenerate.
SS.GenerateAll();
}
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
void TextWindow::ScreenShowGroupsSpecial(int link, uint32_t v) {
Allow generating groups in arbitrary order.
2016-02-17 10:03:07 +00:00
bool state = link == 's';
for(int i = 0; i < SK.groupOrder.n; i++) {
Group *g = SK.GetGroup(SK.groupOrder.elem[i]);
g->visible = state;
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
}
Add an interface for view-independent rendering. To actually achieve improved performance with the OpenGL 2 renderer, we have to cache geometry that doesn't change when the viewport does (note that the rendered pixels can change quite dramatically because we can reconfigure shaders; e.g. stippling can be drawn in screen coordinates). This commit adds a BatchCanvas interface that can be implemented by renderers, and uses it for drawing entities such as lines and points.
2016-06-30 15:54:35 +00:00
SS.GW.persistentDirty = true;
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
}
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
void TextWindow::ScreenActivateGroup(int link, uint32_t v) {
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
SS.GW.activeGroup.v = v;
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(SS.GW.activeGroup)->Activate();
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
SS.GW.ClearSuper();
}
void TextWindow::ReportHowGroupSolved(hGroup hg) {
SS.GW.ClearSuper();
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(Screen::GROUP_SOLVE_INFO);
Remove the back button from the text window, since I never used it. And fix a bug; wasn't asking the user whether to save before abandoning file when a new file was opened recent. [git-p4: depot-paths = "//depot/solvespace/": change = 1830]
2008-07-10 06:11:56 +00:00
SS.TW.shown.group.v = hg.v;
Add a GTK2/3 port. In principle, GTK3 is the way forward, and GTK2 is officially deprecated, though still maintained. In practice however, GTK3 is often unbearably buggy; e.g. on my system, combo boxes don't ever roll up in GTK3 windows. So I have added support for both. This required a few minor changes to the core, namely: * GTK wants to know beforehand whether a menu item is a check menu item or a regular one. * GTK doesn't give us an easy way to execute something after any event is processed, so an explicit idle timer is added. This is a no-op on Win32. * A few function signatures were const'ed, since GTK expects immutable strings when converting to Glib::ustring.
2015-03-18 17:02:11 +00:00
SS.ScheduleShowTW();
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
}
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
void TextWindow::ScreenHowGroupSolved(int link, uint32_t v) {
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
if(SS.GW.activeGroup.v != v) {
ScreenActivateGroup(link, 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
SS.TW.GoToScreen(Screen::GROUP_SOLVE_INFO);
Remove the back button from the text window, since I never used it. And fix a bug; wasn't asking the user whether to save before abandoning file when a new file was opened recent. [git-p4: depot-paths = "//depot/solvespace/": change = 1830]
2008-07-10 06:11:56 +00:00
SS.TW.shown.group.v = v;
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
}
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
void TextWindow::ScreenShowConfiguration(int link, uint32_t 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
SS.TW.GoToScreen(Screen::CONFIGURATION);
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
}
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
void TextWindow::ScreenShowEditView(int link, uint32_t 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
SS.TW.GoToScreen(Screen::EDIT_VIEW);
Add a screen to edit the view parameters; scale, translation, rotation. Also clean up the handling of units, by putting the conversion factors in only one place, and clean up the expression-parsing but removing all the copies of the same error message. [git-p4: depot-paths = "//depot/solvespace/": change = 2093]
2010-01-04 00:35:28 +00:00
}
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
void TextWindow::ScreenGoToWebsite(int link, uint32_t v) {
Finish refactoring of platform code. This commit finally unifies all main() functions and moves the few remaining application-wide functions where they belong.
2018-07-18 02:20:25 +00:00
Platform::OpenInBrowser("http://solvespace.com/txtlink");
Add a simple license key: I take the CRC of the license info, plus some magic numbers. This would be trivial to break, but still more difficult than patching the binary to skip the check... [git-p4: depot-paths = "//depot/solvespace/": change = 1853]
2008-02-09 13:52:01 +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 TextWindow::ShowListOfGroups() {
Rasterize non-ASCII glyphs in the UI. Now it is possible to give non-ASCII names to groups as well as see non-ASCII filenames of imported files. In the future this makes localization possible. This works for LTR languages, such as European and CJK, but not RTL such as Arabic. Does Arabic even exist in monospaced form? I have no idea.
2015-11-05 19:39:27 +00:00
const char *radioTrue = " " RADIO_TRUE " ",
*radioFalse = " " RADIO_FALSE " ",
*checkTrue = " " CHECK_TRUE " ",
*checkFalse = " " CHECK_FALSE " ";
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
Printf(true, "%Ft active");
Show degrees of freedom in property browser.
2017-09-13 09:39:27 +00:00
Printf(false, "%Ft shown dof group-name%E");
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
int i;
bool afterActive = false;
Allow generating groups in arbitrary order.
2016-02-17 10:03:07 +00:00
for(i = 0; i < SK.groupOrder.n; i++) {
Group *g = SK.GetGroup(SK.groupOrder.elem[i]);
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
std::string s = g->DescriptionString();
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
bool active = (g->h.v == SS.GW.activeGroup.v);
bool shown = g->visible;
Add a setting that permits a group to include redundant constraints. This setting is generally useful, but it especially shines when assembling, since the "same orientation" and "parallel" constraints remove three and two rotational degrees of freedom, which makes them impossible to use with 3d "point on line" constraint that removes two spatial and two rotational degrees of freedom. The setting is not enabled for all imported groups by default because it exhibits some edge case failures. For example: * draw two line segments sharing a point, * constrain lengths of line segments, * constrain line segments perpendicular, * constrain line segments to a 90° angle. This is a truly degenerate case and so it is not considered very important. However, we can fix this later by using Eigen::SparseQR.
2016-01-21 15:01:43 +00:00
bool ok = g->IsSolvedOkay();
Show degrees of freedom in property browser.
2017-09-13 09:39:27 +00:00
int dof = g->solved.dof;
char sdof[16] = "ok ";
if(ok && dof > 0) {
if(dof > 999) {
strcpy(sdof, "###");
} else {
sprintf(sdof, "%-3d", dof);
}
}
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
bool ref = (g->h.v == Group::HGROUP_REFERENCES.v);
Printf(false, "%Bp%Fd "
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
"%Ft%s%Fb%D%f%Ll%s%E "
"%Fb%s%D%f%Ll%s%E "
Show degrees of freedom in property browser.
2017-09-13 09:39:27 +00:00
"%Fp%D%f%s%Ll%s%E "
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
"%Fl%Ll%D%f%s",
// Alternate between light and dark backgrounds, for readability
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
(i & 1) ? 'd' : 'a',
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
// Link that activates the group
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
ref ? " " : "",
g->h.v, (&TextWindow::ScreenActivateGroup),
ref ? "" : (active ? radioTrue : radioFalse),
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
// Link that hides or shows the group
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
afterActive ? " - " : "",
g->h.v, (&TextWindow::ScreenToggleGroupShown),
afterActive ? "" : (shown ? checkTrue : checkFalse),
Fix various comment and UI string typos.
2018-07-12 05:05:43 +00:00
// Link to the errors, if a problem occurred while solving
Show degrees of freedom in property browser.
2017-09-13 09:39:27 +00:00
ok ? (dof > 0 ? 'i' : 's') : 'x', g->h.v, (&TextWindow::ScreenHowGroupSolved),
ok ? sdof : "",
ok ? "" : "ERR",
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
// Link to a screen that gives more details on the group
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
g->h.v, (&TextWindow::ScreenSelectGroup), s.c_str());
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
if(active) afterActive = true;
}
Printf(true, " %Fl%Ls%fshow all%E / %Fl%Lh%fhide all%E",
&(TextWindow::ScreenShowGroupsSpecial),
&(TextWindow::ScreenShowGroupsSpecial));
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
Printf(true, " %Fl%Ls%fline styles%E /"
" %Fl%Ls%fview%E /"
" %Fl%Ls%fconfiguration%E",
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
&(TextWindow::ScreenShowListOfStyles),
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
&(TextWindow::ScreenShowEditView),
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
&(TextWindow::ScreenShowConfiguration));
}
//-----------------------------------------------------------------------------
// The screen that shows information about a specific group, and allows the
// user to edit various things about it.
//-----------------------------------------------------------------------------
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
void TextWindow::ScreenHoverConstraint(int link, uint32_t v) {
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
if(!SS.GW.showConstraints) return;
hConstraint hc = { v };
SS.GW.hover.Clear();
SS.GW.hover.constraint = hc;
SS.GW.hover.emphasized = 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
void TextWindow::ScreenHoverRequest(int link, uint32_t v) {
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
SS.GW.hover.Clear();
hRequest hr = { v };
SS.GW.hover.entity = hr.entity(0);
SS.GW.hover.emphasized = 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
void TextWindow::ScreenSelectConstraint(int link, uint32_t v) {
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
SS.GW.ClearSelection();
Replace all ZERO and memset with C++11 brace-initialization. This will allow us to use non-POD classes inside these objects in future and is otherwise functionally equivalent, as well as more concise. Note that there are some subtleties with handling of brace-initialization. Specifically: On aggregates (e.g. simple C-style structures) using an empty brace-initializer zero-initializes the aggregate, i.e. it makes all members zero. On non-aggregates an empty brace-initializer calls the default constructor. And if the constructor doesn't explicitly initialize the members (which the auto-generated constructor doesn't) then the members will be constructed but otherwise uninitialized. So, what is an aggregate class? To quote the C++ standard (C++03 8.5.1 §1): An aggregate is an array or a class (clause 9) with no user-declared constructors (12.1), no private or protected non-static data members (clause 11), no base classes (clause 10), and no virtual functions (10.3). In SolveSpace, we only have to handle the case of base classes; Constraint and Entity have those. Thus, they had to gain a default constructor that does nothing but initializes the members to zero.
2015-03-27 15:31:23 +00:00
GraphicsWindow::Selection sel = {};
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
sel.constraint.v = v;
SS.GW.selection.Add(&sel);
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
}
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
void TextWindow::ScreenSelectRequest(int link, uint32_t v) {
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
SS.GW.ClearSelection();
Replace all ZERO and memset with C++11 brace-initialization. This will allow us to use non-POD classes inside these objects in future and is otherwise functionally equivalent, as well as more concise. Note that there are some subtleties with handling of brace-initialization. Specifically: On aggregates (e.g. simple C-style structures) using an empty brace-initializer zero-initializes the aggregate, i.e. it makes all members zero. On non-aggregates an empty brace-initializer calls the default constructor. And if the constructor doesn't explicitly initialize the members (which the auto-generated constructor doesn't) then the members will be constructed but otherwise uninitialized. So, what is an aggregate class? To quote the C++ standard (C++03 8.5.1 §1): An aggregate is an array or a class (clause 9) with no user-declared constructors (12.1), no private or protected non-static data members (clause 11), no base classes (clause 10), and no virtual functions (10.3). In SolveSpace, we only have to handle the case of base classes; Constraint and Entity have those. Thus, they had to gain a default constructor that does nothing but initializes the members to zero.
2015-03-27 15:31:23 +00:00
GraphicsWindow::Selection sel = {};
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
hRequest hr = { v };
sel.entity = hr.entity(0);
SS.GW.selection.Add(&sel);
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
}
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
void TextWindow::ScreenChangeGroupOption(int link, uint32_t v) {
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
SS.UndoRemember();
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.TW.shown.group);
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
Add option to mirror imported geometry, including the shell, mesh, and parametric entities. Also consolidate the text screen functions to change group options into a single function for everything. [git-p4: depot-paths = "//depot/solvespace/": change = 2051]
2009-10-09 12:57:10 +00:00
switch(link) {
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 's': g->subtype = Group::Subtype::ONE_SIDED; break;
case 'S': g->subtype = Group::Subtype::TWO_SIDED; break;
Add beginnings of stuff to represent surfaces as either meshes or exact surface shells. And add interference checking; I'll be lazy and just do that on the meshes, by modifying the self-intersection tester to ignore coplanar triangles (since that can happen in an assembly). [git-p4: depot-paths = "//depot/solvespace/": change = 1958]
2009-05-22 10:02:02 +00:00
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
case 'k': g->skipFirst = true; break;
case 'K': g->skipFirst = false; break;
Add option to mirror imported geometry, including the shell, mesh, and parametric entities. Also consolidate the text screen functions to change group options into a single function for everything. [git-p4: depot-paths = "//depot/solvespace/": change = 2051]
2009-10-09 12:57:10 +00:00
Flip extrusion normal when switching between union and difference. This is done because a meaningful union extrusion is almost never a meaningful difference extrusion, and saves a bunch of common manual work. To avoid creating invalid sketches this isn't done when there are any constraints.
2016-05-04 10:18:13 +00:00
case 'c':
Fix a crash changing g->meshCombine when g->type!=EXTRUDE.
2017-04-16 02:12:31 +00:00
if(g->type == Group::Type::EXTRUDE) {
// When an extrude group is first created, it's positioned for a union
// extrusion. If no constraints were added, flip it when we switch between
Fix various comment and UI string typos.
2018-07-12 05:05:43 +00:00
// union and difference modes to avoid manual work doing the same.
Fix a crash changing g->meshCombine when g->type!=EXTRUDE.
2017-04-16 02:12:31 +00:00
if(g->meshCombine != (Group::CombineAs)v && g->GetNumConstraints() == 0 &&
((Group::CombineAs)v == Group::CombineAs::DIFFERENCE ||
g->meshCombine == Group::CombineAs::DIFFERENCE)) {
g->ExtrusionForceVectorTo(g->ExtrusionGetVector().Negated());
}
Flip extrusion normal when switching between union and difference. This is done because a meaningful union extrusion is almost never a meaningful difference extrusion, and saves a bunch of common manual work. To avoid creating invalid sketches this isn't done when there are any constraints.
2016-05-04 10:18:13 +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
g->meshCombine = (Group::CombineAs)v;
Flip extrusion normal when switching between union and difference. This is done because a meaningful union extrusion is almost never a meaningful difference extrusion, and saves a bunch of common manual work. To avoid creating invalid sketches this isn't done when there are any constraints.
2016-05-04 10:18:13 +00:00
break;
Add option to mirror imported geometry, including the shell, mesh, and parametric entities. Also consolidate the text screen functions to change group options into a single function for everything. [git-p4: depot-paths = "//depot/solvespace/": change = 2051]
2009-10-09 12:57:10 +00:00
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
case 'P': g->suppress = !(g->suppress); break;
Add option to mirror imported geometry, including the shell, mesh, and parametric entities. Also consolidate the text screen functions to change group options into a single function for everything. [git-p4: depot-paths = "//depot/solvespace/": change = 2051]
2009-10-09 12:57:10 +00:00
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
case 'r': g->relaxConstraints = !(g->relaxConstraints); break;
Add option to mirror imported geometry, including the shell, mesh, and parametric entities. Also consolidate the text screen functions to change group options into a single function for everything. [git-p4: depot-paths = "//depot/solvespace/": change = 2051]
2009-10-09 12:57:10 +00:00
Add a setting that permits a group to include redundant constraints. This setting is generally useful, but it especially shines when assembling, since the "same orientation" and "parallel" constraints remove three and two rotational degrees of freedom, which makes them impossible to use with 3d "point on line" constraint that removes two spatial and two rotational degrees of freedom. The setting is not enabled for all imported groups by default because it exhibits some edge case failures. For example: * draw two line segments sharing a point, * constrain lengths of line segments, * constrain line segments perpendicular, * constrain line segments to a 90° angle. This is a truly degenerate case and so it is not considered very important. However, we can fix this later by using Eigen::SparseQR.
2016-01-21 15:01:43 +00:00
case 'e': g->allowRedundant = !(g->allowRedundant); break;
Add a checkbox to group screens to toggle visibility; seemed silly to have that available from the list of groups, but not there. [git-p4: depot-paths = "//depot/solvespace/": change = 2143]
2010-05-12 04:57:41 +00:00
case 'v': g->visible = !(g->visible); break;
Add option to treat all dimensions as reference dimensions. This is useful because it makes it possible to add cosmetic dimensions to an existing model, without REF appended. [git-p4: depot-paths = "//depot/solvespace/": change = 2140]
2010-05-10 01:06:09 +00:00
case 'd': g->allDimsReference = !(g->allDimsReference); break;
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
case 'f': g->forceToMesh = !(g->forceToMesh); break;
Add option to mirror imported geometry, including the shell, mesh, and parametric entities. Also consolidate the text screen functions to change group options into a single function for everything. [git-p4: depot-paths = "//depot/solvespace/": change = 2051]
2009-10-09 12:57:10 +00:00
}
Now I can suppress an imported part; so the entities still show up, but the mesh doesn't get combined. That effectively hides it, good for looking inside and such. [git-p4: depot-paths = "//depot/solvespace/": change = 1860]
2008-02-15 11:35:15 +00:00
SS.MarkGroupDirty(g->h);
SS.GW.ClearSuper();
}
Add ability to relax the constraints, applying only point-coincident constraints and the entity- or group-generated constraints. Also fix a bug where a dragged point was not released when the mouse pointer left the window. [git-p4: depot-paths = "//depot/solvespace/": change = 2045]
2009-10-01 11:22:56 +00:00
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
void TextWindow::ScreenColor(int link, uint32_t v) {
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
SS.UndoRemember();
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.TW.shown.group);
Don't calculate halfRow for ShowEditControl manually. Instead, grab it from hoveredRow, since almost always (with only one exception) this is where the edit control has to be shown. This makes it much easier to adjust views, e.g. add a new editable field in the middle of configuration view, because it's not necessary to manually change and test all the indexes below the row being changed. Additionally, it removes a lot of awkward and opaque row calculations.
2016-01-26 11:19:52 +00:00
SS.TW.ShowEditControlWithColorPicker(3, g->color);
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.edit.meaning = Edit::GROUP_COLOR;
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
}
Add support for transparent solids. Some extra code is necessary to determine that the back faces should not be drawn in red for transparent solids. It is expected that the user will first ensure that the shell is watertight and then set the opacity; back faces are still drawn if the opacity is exactly 1. The savefile format is changed backwards-compatibly by stashing the alpha value in uppermost byte of 4-byte hex color value in Surface and Triangle clauses. The existing files have 00 in the high byte, so RgbColor::FromPackedInt treats that as "opaque".
2015-03-26 10:30:12 +00:00
void TextWindow::ScreenOpacity(int link, uint32_t v) {
Group *g = SK.GetGroup(SS.TW.shown.group);
Don't calculate halfRow for ShowEditControl manually. Instead, grab it from hoveredRow, since almost always (with only one exception) this is where the edit control has to be shown. This makes it much easier to adjust views, e.g. add a new editable field in the middle of configuration view, because it's not necessary to manually change and test all the indexes below the row being changed. Additionally, it removes a lot of awkward and opaque row calculations.
2016-01-26 11:19:52 +00:00
SS.TW.ShowEditControl(11, ssprintf("%.2f", g->color.alphaF()));
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.edit.meaning = Edit::GROUP_OPACITY;
Add support for transparent solids. Some extra code is necessary to determine that the back faces should not be drawn in red for transparent solids. It is expected that the user will first ensure that the shell is watertight and then set the opacity; back faces are still drawn if the opacity is exactly 1. The savefile format is changed backwards-compatibly by stashing the alpha value in uppermost byte of 4-byte hex color value in Surface and Triangle clauses. The existing files have 00 in the high byte, so RgbColor::FromPackedInt treats that as "opaque".
2015-03-26 10:30:12 +00:00
SS.TW.edit.group.v = g->h.v;
}
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
void TextWindow::ScreenChangeExprA(int link, uint32_t v) {
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.TW.shown.group);
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
Don't calculate halfRow for ShowEditControl manually. Instead, grab it from hoveredRow, since almost always (with only one exception) this is where the edit control has to be shown. This makes it much easier to adjust views, e.g. add a new editable field in the middle of configuration view, because it's not necessary to manually change and test all the indexes below the row being changed. Additionally, it removes a lot of awkward and opaque row calculations.
2016-01-26 11:19:52 +00:00
SS.TW.ShowEditControl(10, ssprintf("%d", (int)g->valA));
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.edit.meaning = Edit::TIMES_REPEATED;
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
SS.TW.edit.group.v = v;
}
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
void TextWindow::ScreenChangeGroupName(int link, uint32_t v) {
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.TW.shown.group);
Don't calculate halfRow for ShowEditControl manually. Instead, grab it from hoveredRow, since almost always (with only one exception) this is where the edit control has to be shown. This makes it much easier to adjust views, e.g. add a new editable field in the middle of configuration view, because it's not necessary to manually change and test all the indexes below the row being changed. Additionally, it removes a lot of awkward and opaque row calculations.
2016-01-26 11:19:52 +00:00
SS.TW.ShowEditControl(12, g->DescriptionString().substr(5));
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.edit.meaning = Edit::GROUP_NAME;
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
SS.TW.edit.group.v = v;
}
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
void TextWindow::ScreenChangeGroupScale(int link, uint32_t v) {
A big nasty change, originally just to add paste transformed. So it does that, and adds a scale factor to that transformation (instead of just mirroring, as before), but also: * Replace the "import mirrored" mechanism with a scale factor, which if negative corresponds to a reflection as well. * Fix self-intersection checker to report a meaningful point when edges are collinear. * Don't blow an assertion on some types of invalid file; instead provide a nice error message to the user. * Clear the naked edges before each regen. * Don't create zero-length line segments by snapping a line segment's end to its beginning. [git-p4: depot-paths = "//depot/solvespace/": change = 2086]
2009-12-15 12:26:22 +00:00
Group *g = SK.GetGroup(SS.TW.shown.group);
Don't calculate halfRow for ShowEditControl manually. Instead, grab it from hoveredRow, since almost always (with only one exception) this is where the edit control has to be shown. This makes it much easier to adjust views, e.g. add a new editable field in the middle of configuration view, because it's not necessary to manually change and test all the indexes below the row being changed. Additionally, it removes a lot of awkward and opaque row calculations.
2016-01-26 11:19:52 +00:00
SS.TW.ShowEditControl(13, ssprintf("%.3f", g->scale));
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.edit.meaning = Edit::GROUP_SCALE;
A big nasty change, originally just to add paste transformed. So it does that, and adds a scale factor to that transformation (instead of just mirroring, as before), but also: * Replace the "import mirrored" mechanism with a scale factor, which if negative corresponds to a reflection as well. * Fix self-intersection checker to report a meaningful point when edges are collinear. * Don't blow an assertion on some types of invalid file; instead provide a nice error message to the user. * Clear the naked edges before each regen. * Don't create zero-length line segments by snapping a line segment's end to its beginning. [git-p4: depot-paths = "//depot/solvespace/": change = 2086]
2009-12-15 12:26:22 +00:00
SS.TW.edit.group.v = v;
}
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
void TextWindow::ScreenDeleteGroup(int link, uint32_t v) {
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
SS.UndoRemember();
Remove the back button from the text window, since I never used it. And fix a bug; wasn't asking the user whether to save before abandoning file when a new file was opened recent. [git-p4: depot-paths = "//depot/solvespace/": change = 1830]
2008-07-10 06:11:56 +00:00
hGroup hg = SS.TW.shown.group;
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
if(hg.v == SS.GW.activeGroup.v) {
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
SS.GW.activeGroup = SK.GetGroup(SS.GW.activeGroup)->PreviousGroup()->h;
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
}
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
// Reset the text window, since we're displaying information about
// the group that's about to get deleted.
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
SS.TW.ClearSuper();
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
// This is a major change, so let's re-solve everything.
SK.group.RemoveById(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
SS.GenerateAll(SolveSpaceUI::Generate::ALL);
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
// Reset the graphics window. This will also recreate the default
// group if it was removed.
SS.GW.ClearSuper();
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +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 TextWindow::ShowGroupInfo() {
Allow generating groups in arbitrary order.
2016-02-17 10:03:07 +00:00
Group *g = SK.GetGroup(shown.group);
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 = "???";
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
Remove the back button from the text window, since I never used it. And fix a bug; wasn't asking the user whether to save before abandoning file when a new file was opened recent. [git-p4: depot-paths = "//depot/solvespace/": change = 1830]
2008-07-10 06:11:56 +00:00
if(shown.group.v == Group::HGROUP_REFERENCES.v) {
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
Printf(true, "%FtGROUP %E%s", g->DescriptionString().c_str());
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
goto list_items;
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
} else {
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
Printf(true, "%FtGROUP %E%s [%Fl%Ll%D%frename%E/%Fl%Ll%D%fdel%E]",
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
g->DescriptionString().c_str(),
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
g->h.v, &TextWindow::ScreenChangeGroupName,
g->h.v, &TextWindow::ScreenDeleteGroup);
}
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::LATHE) {
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
Printf(true, " %Ftlathe plane sketch");
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::EXTRUDE || g->type == Group::Type::ROTATE ||
g->type == Group::Type::TRANSLATE)
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
{
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(g->type == Group::Type::EXTRUDE) {
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
s = "extrude plane sketch";
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::TRANSLATE) {
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
s = "translate original sketch";
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::ROTATE) {
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
s = "rotate original sketch";
}
Printf(true, " %Ft%s%E", s);
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
bool one = (g->subtype == Group::Subtype::ONE_SIDED);
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
Printf(false,
Rasterize non-ASCII glyphs in the UI. Now it is possible to give non-ASCII names to groups as well as see non-ASCII filenames of imported files. In the future this makes localization possible. This works for LTR languages, such as European and CJK, but not RTL such as Arabic. Does Arabic even exist in monospaced form? I have no idea.
2015-11-05 19:39:27 +00:00
"%Ba %f%Ls%Fd%s one-sided%E "
"%f%LS%Fd%s two-sided%E",
Add option to mirror imported geometry, including the shell, mesh, and parametric entities. Also consolidate the text screen functions to change group options into a single function for everything. [git-p4: depot-paths = "//depot/solvespace/": change = 2051]
2009-10-09 12:57:10 +00:00
&TextWindow::ScreenChangeGroupOption,
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
one ? RADIO_TRUE : RADIO_FALSE,
Add option to mirror imported geometry, including the shell, mesh, and parametric entities. Also consolidate the text screen functions to change group options into a single function for everything. [git-p4: depot-paths = "//depot/solvespace/": change = 2051]
2009-10-09 12:57:10 +00:00
&TextWindow::ScreenChangeGroupOption,
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
!one ? RADIO_TRUE : RADIO_FALSE);
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(g->type == Group::Type::ROTATE || g->type == Group::Type::TRANSLATE) {
if(g->subtype == Group::Subtype::ONE_SIDED) {
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
bool skip = g->skipFirst;
Trim trailing whitespace.
2015-03-29 00:30:52 +00:00
Printf(false,
Rasterize non-ASCII glyphs in the UI. Now it is possible to give non-ASCII names to groups as well as see non-ASCII filenames of imported files. In the future this makes localization possible. This works for LTR languages, such as European and CJK, but not RTL such as Arabic. Does Arabic even exist in monospaced form? I have no idea.
2015-11-05 19:39:27 +00:00
"%Bd %Ftstart %f%LK%Fd%s with original%E "
"%f%Lk%Fd%s with copy #1%E",
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
&ScreenChangeGroupOption,
!skip ? RADIO_TRUE : RADIO_FALSE,
&ScreenChangeGroupOption,
skip ? RADIO_TRUE : RADIO_FALSE);
}
int times = (int)(g->valA);
Printf(false, "%Bp %Ftrepeat%E %d time%s %Fl%Ll%D%f[change]%E",
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
(g->subtype == Group::Subtype::ONE_SIDED) ? 'a' : 'd',
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
times, times == 1 ? "" : "s",
g->h.v, &TextWindow::ScreenChangeExprA);
}
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::LINKED) {
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
Printf(true, " %Ftlink geometry from file%E");
Implement an image request.
2016-11-29 16:49:20 +00:00
Platform::Path relativePath = g->linkFile.RelativeTo(SS.saveFile.Parent());
Rework path and file operations to be more robust. This commit updates a *lot* of rather questionable path handling logic to be robust. Specifically: * All path operations go through Platform::Path. * All ad-hoc path handling functions are removed, together with PATH_SEP. This removes code that was in platform-independent parts, but had platform-dependent behavior. * Group::linkFileRel is removed; only an absolute path is stored in Group::linkFile. However, only Group::linkFileRel is saved, with the relative path calculated on the fly, from the filename passed into SaveToFile. This eliminates dependence on global state, and makes it unnecessary to have separare code paths for saved and not yet saved files. * In a departure from previous practice, functions with platform-independent code but platform-dependent behavior are all grouped under platform/. This makes it easy to grep for functions with platform-dependent behavior. * Similarly, new (GUI-independent) code for all platforms is added in the same platform.cpp file, guarded with #ifs. It turns out that implementations for different platforms had a lot of shared code that tended to go out of sync.
2017-03-11 14:43:21 +00:00
if(relativePath.IsEmpty()) {
Printf(false, "%Ba '%s'", g->linkFile.raw.c_str());
} else {
Printf(false, "%Ba '%s'", relativePath.raw.c_str());
}
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
Printf(false, "%Bd %Ftscaled by%E %# %Fl%Ll%f%D[change]%E",
g->scale,
&TextWindow::ScreenChangeGroupScale, g->h.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
} else if(g->type == Group::Type::DRAWING_3D) {
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
Printf(true, " %Ftsketch in 3d%E");
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) {
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
Printf(true, " %Ftsketch in new workplane%E");
} else {
Printf(true, "???");
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
}
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
Printf(false, "");
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(g->type == Group::Type::EXTRUDE ||
g->type == Group::Type::LATHE ||
g->type == Group::Type::LINKED)
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +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
bool un = (g->meshCombine == Group::CombineAs::UNION);
bool diff = (g->meshCombine == Group::CombineAs::DIFFERENCE);
bool asy = (g->meshCombine == Group::CombineAs::ASSEMBLE);
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
Printf(false, " %Ftsolid model as");
Rasterize non-ASCII glyphs in the UI. Now it is possible to give non-ASCII names to groups as well as see non-ASCII filenames of imported files. In the future this makes localization possible. This works for LTR languages, such as European and CJK, but not RTL such as Arabic. Does Arabic even exist in monospaced form? I have no idea.
2015-11-05 19:39:27 +00:00
Printf(false, "%Ba %f%D%Lc%Fd%s union%E "
"%f%D%Lc%Fd%s difference%E "
Allow combining extrude, lathe, translate and rotate group as assemblies. This significantly improves performance e.g. in case of a sketch containing a multitude of wooden panels, as the meshes can be merely transformed instead of being joined.
2016-05-03 07:44:10 +00:00
"%f%D%Lc%Fd%s assemble%E ",
Add option to mirror imported geometry, including the shell, mesh, and parametric entities. Also consolidate the text screen functions to change group options into a single function for everything. [git-p4: depot-paths = "//depot/solvespace/": change = 2051]
2009-10-09 12:57:10 +00:00
&TextWindow::ScreenChangeGroupOption,
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
Group::CombineAs::UNION,
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
un ? RADIO_TRUE : RADIO_FALSE,
Add option to mirror imported geometry, including the shell, mesh, and parametric entities. Also consolidate the text screen functions to change group options into a single function for everything. [git-p4: depot-paths = "//depot/solvespace/": change = 2051]
2009-10-09 12:57:10 +00:00
&TextWindow::ScreenChangeGroupOption,
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
Group::CombineAs::DIFFERENCE,
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
diff ? RADIO_TRUE : RADIO_FALSE,
Add option to mirror imported geometry, including the shell, mesh, and parametric entities. Also consolidate the text screen functions to change group options into a single function for everything. [git-p4: depot-paths = "//depot/solvespace/": change = 2051]
2009-10-09 12:57:10 +00:00
&TextWindow::ScreenChangeGroupOption,
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
Group::CombineAs::ASSEMBLE,
Allow combining extrude, lathe, translate and rotate group as assemblies. This significantly improves performance e.g. in case of a sketch containing a multitude of wooden panels, as the meshes can be merely transformed instead of being joined.
2016-05-03 07:44:10 +00:00
(asy ? RADIO_TRUE : RADIO_FALSE));
Add ability to relax the constraints, applying only point-coincident constraints and the entity- or group-generated constraints. Also fix a bug where a dragged point was not released when the mouse pointer left the window. [git-p4: depot-paths = "//depot/solvespace/": change = 2045]
2009-10-01 11:22:56 +00:00
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(g->type == Group::Type::EXTRUDE ||
g->type == Group::Type::LATHE)
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
{
Update selection of extrusion/lathe solid model color to use new color picker. And apply same rule to rewrite nearly-white colors (when exporting with a file format typically viewed on a white background) for fill color as for stroke color. [git-p4: depot-paths = "//depot/solvespace/": change = 2176]
2010-08-14 19:00:25 +00:00
Printf(false,
Add support for transparent solids. Some extra code is necessary to determine that the back faces should not be drawn in red for transparent solids. It is expected that the user will first ensure that the shell is watertight and then set the opacity; back faces are still drawn if the opacity is exactly 1. The savefile format is changed backwards-compatibly by stashing the alpha value in uppermost byte of 4-byte hex color value in Surface and Triangle clauses. The existing files have 00 in the high byte, so RgbColor::FromPackedInt treats that as "opaque".
2015-03-26 10:30:12 +00:00
"%Bd %Ftcolor %E%Bz %Bd (%@, %@, %@) %f%D%Lf%Fl[change]%E",
Replaced RGB-color integers with dedicated data structure RGB colors were represented using a uint32_t with the red, green and blue values stuffed into the lower three octets (i.e. 0x00BBGGRR), like Microsoft's COLORREF. This approach did not lend itself to type safety, however, so this change replaces it with an RgbColor class that provides the same infomation plus a handful of useful methods to work with it. (Note that sizeof(RgbColor) == sizeof(uint32_t), so this change should not lead to memory bloat.) Some of the new methods/fields replace what were previously macro calls; e.g. RED(c) is now c.red, REDf(c) is now c.redF(). The .Equals() method is now used instead of == to compare colors. RGB colors still need to be represented as packed integers in file I/O and preferences, so the methods .FromPackedInt() and .ToPackedInt() are provided. Also implemented are Cnf{Freeze,Thaw}Color(), type-safe wrappers around Cnf{Freeze,Thaw}Int() that facilitate I/O with preferences. (Cnf{Freeze,Thaw}Color() are defined outside of the system-dependent code to minimize the footprint of the latter; because the same can be done with Cnf{Freeze,Thaw}Bool(), those are also moved out of the system code with this commit.) Color integers were being OR'ed with 0x80000000 in some places for two distinct purposes: One, to indicate use of a default color in glxFillMesh(); this has been replaced by use of the .UseDefault() method. Two, to indicate to TextWindow::Printf() that the format argument of a "%Bp"/"%Fp" specifier is an RGB color rather than a color "code" from TextWindow::bgColors[] or TextWindow::fgColors[] (as the specifier can accept either); instead, we define a new flag "z" (as in "%Bz" or "%Fz") to indicate an RGBcolor pointer, leaving "%Bp"/"%Fp" to indicate a color code exclusively. (This also allows TextWindow::meta[][].bg to be a char instead of an int, partly compensating for the new .bgRgb field added immediately after.) In array declarations, RGB colors could previously be specified as 0 (often in a terminating element). As that no longer works, we define NULL_COLOR, which serves much the same purpose for RgbColor variables as NULL serves for pointers.
2013-10-16 20:00:58 +00:00
&g->color,
g->color.redF(), g->color.greenF(), g->color.blueF(),
Update selection of extrusion/lathe solid model color to use new color picker. And apply same rule to rewrite nearly-white colors (when exporting with a file format typically viewed on a white background) for fill color as for stroke color. [git-p4: depot-paths = "//depot/solvespace/": change = 2176]
2010-08-14 19:00:25 +00:00
ScreenColor, top[rows-1] + 2);
Add support for transparent solids. Some extra code is necessary to determine that the back faces should not be drawn in red for transparent solids. It is expected that the user will first ensure that the shell is watertight and then set the opacity; back faces are still drawn if the opacity is exactly 1. The savefile format is changed backwards-compatibly by stashing the alpha value in uppermost byte of 4-byte hex color value in Surface and Triangle clauses. The existing files have 00 in the high byte, so RgbColor::FromPackedInt treats that as "opaque".
2015-03-26 10:30:12 +00:00
Printf(false, "%Bd %Ftopacity%E %@ %f%Lf%Fl[change]%E",
g->color.alphaF(),
&TextWindow::ScreenOpacity);
Allow suppressing solid model of extrude and lathe groups.
2017-04-05 18:49:18 +00:00
}
if(g->type == Group::Type::EXTRUDE ||
g->type == Group::Type::LATHE ||
g->type == Group::Type::LINKED) {
Rasterize non-ASCII glyphs in the UI. Now it is possible to give non-ASCII names to groups as well as see non-ASCII filenames of imported files. In the future this makes localization possible. This works for LTR languages, such as European and CJK, but not RTL such as Arabic. Does Arabic even exist in monospaced form? I have no idea.
2015-11-05 19:39:27 +00:00
Printf(false, " %Fd%f%LP%s suppress this group's solid model",
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
&TextWindow::ScreenChangeGroupOption,
g->suppress ? CHECK_TRUE : CHECK_FALSE);
Add beginnings of stuff to represent surfaces as either meshes or exact surface shells. And add interference checking; I'll be lazy and just do that on the meshes, by modifying the self-intersection tester to ignore coplanar triangles (since that can happen in an assembly). [git-p4: depot-paths = "//depot/solvespace/": change = 1958]
2009-05-22 10:02:02 +00:00
}
If a Boolean fails, then make a note of it in the group's text window screen, and remind the user that they could 'fix' the problem by working with meshes instead. [git-p4: depot-paths = "//depot/solvespace/": change = 1962]
2009-05-30 08:49:09 +00:00
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
Printf(false, "");
Add beginnings of stuff to represent surfaces as either meshes or exact surface shells. And add interference checking; I'll be lazy and just do that on the meshes, by modifying the self-intersection tester to ignore coplanar triangles (since that can happen in an assembly). [git-p4: depot-paths = "//depot/solvespace/": change = 1958]
2009-05-22 10:02:02 +00:00
}
Rasterize non-ASCII glyphs in the UI. Now it is possible to give non-ASCII names to groups as well as see non-ASCII filenames of imported files. In the future this makes localization possible. This works for LTR languages, such as European and CJK, but not RTL such as Arabic. Does Arabic even exist in monospaced form? I have no idea.
2015-11-05 19:39:27 +00:00
Printf(false, " %f%Lv%Fd%s show entities from this group",
Add a checkbox to group screens to toggle visibility; seemed silly to have that available from the list of groups, but not there. [git-p4: depot-paths = "//depot/solvespace/": change = 2143]
2010-05-12 04:57:41 +00:00
&TextWindow::ScreenChangeGroupOption,
g->visible ? CHECK_TRUE : CHECK_FALSE);
Fix forcing NURBS to mesh in a step group when the flag is inherited. Before this commit, if the source group of a step rotate/translate group is forced to triangle mesh, the UI would show that the step rotate/translate group is also forced to triangle mesh, but the group would in fact contain NURBS surfaces.
2017-03-21 15:47:59 +00:00
if(!g->IsForcedToMeshBySource()) {
Rasterize non-ASCII glyphs in the UI. Now it is possible to give non-ASCII names to groups as well as see non-ASCII filenames of imported files. In the future this makes localization possible. This works for LTR languages, such as European and CJK, but not RTL such as Arabic. Does Arabic even exist in monospaced form? I have no idea.
2015-11-05 19:39:27 +00:00
Printf(false, " %f%Lf%Fd%s force NURBS surfaces to triangle mesh",
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
&TextWindow::ScreenChangeGroupOption,
g->forceToMesh ? CHECK_TRUE : CHECK_FALSE);
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
} else {
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
Printf(false, " (model already forced to triangle mesh)");
}
Rasterize non-ASCII glyphs in the UI. Now it is possible to give non-ASCII names to groups as well as see non-ASCII filenames of imported files. In the future this makes localization possible. This works for LTR languages, such as European and CJK, but not RTL such as Arabic. Does Arabic even exist in monospaced form? I have no idea.
2015-11-05 19:39:27 +00:00
Printf(true, " %f%Lr%Fd%s relax constraints and dimensions",
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
&TextWindow::ScreenChangeGroupOption,
g->relaxConstraints ? CHECK_TRUE : CHECK_FALSE);
Add a setting that permits a group to include redundant constraints. This setting is generally useful, but it especially shines when assembling, since the "same orientation" and "parallel" constraints remove three and two rotational degrees of freedom, which makes them impossible to use with 3d "point on line" constraint that removes two spatial and two rotational degrees of freedom. The setting is not enabled for all imported groups by default because it exhibits some edge case failures. For example: * draw two line segments sharing a point, * constrain lengths of line segments, * constrain line segments perpendicular, * constrain line segments to a 90° angle. This is a truly degenerate case and so it is not considered very important. However, we can fix this later by using Eigen::SparseQR.
2016-01-21 15:01:43 +00:00
Printf(false, " %f%Le%Fd%s allow redundant constraints",
&TextWindow::ScreenChangeGroupOption,
g->allowRedundant ? CHECK_TRUE : CHECK_FALSE);
Rasterize non-ASCII glyphs in the UI. Now it is possible to give non-ASCII names to groups as well as see non-ASCII filenames of imported files. In the future this makes localization possible. This works for LTR languages, such as European and CJK, but not RTL such as Arabic. Does Arabic even exist in monospaced form? I have no idea.
2015-11-05 19:39:27 +00:00
Printf(false, " %f%Ld%Fd%s treat all dimensions as reference",
Add option to treat all dimensions as reference dimensions. This is useful because it makes it possible to add cosmetic dimensions to an existing model, without REF appended. [git-p4: depot-paths = "//depot/solvespace/": change = 2140]
2010-05-10 01:06:09 +00:00
&TextWindow::ScreenChangeGroupOption,
g->allDimsReference ? CHECK_TRUE : CHECK_FALSE);
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
if(g->booleanFailed) {
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
Printf(false, "");
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
Printf(false, "The Boolean operation failed. It may be ");
Printf(false, "possible to fix the problem by choosing ");
Printf(false, "'force NURBS surfaces to triangle mesh'.");
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
}
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
list_items:
Printf(false, "");
Printf(false, "%Ft requests in group");
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
int i, a = 0;
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
for(i = 0; i < SK.request.n; i++) {
Request *r = &(SK.request.elem[i]);
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
Remove the back button from the text window, since I never used it. And fix a bug; wasn't asking the user whether to save before abandoning file when a new file was opened recent. [git-p4: depot-paths = "//depot/solvespace/": change = 1830]
2008-07-10 06:11:56 +00:00
if(r->group.v == shown.group.v) {
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
std::string s = r->DescriptionString();
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
Printf(false, "%Bp %Fl%Ll%D%f%h%s%E",
(a & 1) ? 'd' : 'a',
r->h.v, (&TextWindow::ScreenSelectRequest),
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
&(TextWindow::ScreenHoverRequest), s.c_str());
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
a++;
}
}
if(a == 0) Printf(false, "%Ba (none)");
a = 0;
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
Printf(false, "");
Printf(false, "%Ft constraints in group (%d DOF)", g->solved.dof);
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
for(i = 0; i < SK.constraint.n; i++) {
Constraint *c = &(SK.constraint.elem[i]);
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
Remove the back button from the text window, since I never used it. And fix a bug; wasn't asking the user whether to save before abandoning file when a new file was opened recent. [git-p4: depot-paths = "//depot/solvespace/": change = 1830]
2008-07-10 06:11:56 +00:00
if(c->group.v == shown.group.v) {
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
std::string s = c->DescriptionString();
Add symmetric about line constraint. This applies only when locked in a workplane, since it would otherwise be ambiguous. [git-p4: depot-paths = "//depot/solvespace/": change = 1817]
2008-07-02 06:59:49 +00:00
Printf(false, "%Bp %Fl%Ll%D%f%h%s%E %s",
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
(a & 1) ? 'd' : 'a',
c->h.v, (&TextWindow::ScreenSelectConstraint),
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
(&TextWindow::ScreenHoverConstraint), s.c_str(),
Add symmetric about line constraint. This applies only when locked in a workplane, since it would otherwise be ambiguous. [git-p4: depot-paths = "//depot/solvespace/": change = 1817]
2008-07-02 06:59:49 +00:00
c->reference ? "(ref)" : "");
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
a++;
}
}
if(a == 0) Printf(false, "%Ba (none)");
}
//-----------------------------------------------------------------------------
// The screen that's displayed when the sketch fails to solve. A report of
// what failed, and (if the problem is a singular Jacobian) a list of
// constraints that could be removed to fix it.
//-----------------------------------------------------------------------------
Add a setting that permits a group to include redundant constraints. This setting is generally useful, but it especially shines when assembling, since the "same orientation" and "parallel" constraints remove three and two rotational degrees of freedom, which makes them impossible to use with 3d "point on line" constraint that removes two spatial and two rotational degrees of freedom. The setting is not enabled for all imported groups by default because it exhibits some edge case failures. For example: * draw two line segments sharing a point, * constrain lengths of line segments, * constrain line segments perpendicular, * constrain line segments to a 90° angle. This is a truly degenerate case and so it is not considered very important. However, we can fix this later by using Eigen::SparseQR.
2016-01-21 15:01:43 +00:00
void TextWindow::ScreenAllowRedundant(int link, uint32_t v) {
SS.UndoRemember();
Group *g = SK.GetGroup(SS.TW.shown.group);
g->allowRedundant = true;
Do ScheduleGenerateAll in MarkGroupDirty. This generally simplifies code, and also fixes a bug where adding a datum point would not regenerate the sketch.
2016-12-26 02:09:45 +00:00
SS.MarkGroupDirty(SS.TW.shown.group);
Add a setting that permits a group to include redundant constraints. This setting is generally useful, but it especially shines when assembling, since the "same orientation" and "parallel" constraints remove three and two rotational degrees of freedom, which makes them impossible to use with 3d "point on line" constraint that removes two spatial and two rotational degrees of freedom. The setting is not enabled for all imported groups by default because it exhibits some edge case failures. For example: * draw two line segments sharing a point, * constrain lengths of line segments, * constrain line segments perpendicular, * constrain line segments to a 90° angle. This is a truly degenerate case and so it is not considered very important. However, we can fix this later by using Eigen::SparseQR.
2016-01-21 15:01:43 +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
SS.TW.shown.screen = Screen::GROUP_INFO;
Add a setting that permits a group to include redundant constraints. This setting is generally useful, but it especially shines when assembling, since the "same orientation" and "parallel" constraints remove three and two rotational degrees of freedom, which makes them impossible to use with 3d "point on line" constraint that removes two spatial and two rotational degrees of freedom. The setting is not enabled for all imported groups by default because it exhibits some edge case failures. For example: * draw two line segments sharing a point, * constrain lengths of line segments, * constrain line segments perpendicular, * constrain line segments to a 90° angle. This is a truly degenerate case and so it is not considered very important. However, we can fix this later by using Eigen::SparseQR.
2016-01-21 15:01:43 +00:00
SS.TW.Show();
}
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 TextWindow::ShowGroupSolveInfo() {
Allow generating groups in arbitrary order.
2016-02-17 10:03:07 +00:00
Group *g = SK.GetGroup(shown.group);
Add a setting that permits a group to include redundant constraints. This setting is generally useful, but it especially shines when assembling, since the "same orientation" and "parallel" constraints remove three and two rotational degrees of freedom, which makes them impossible to use with 3d "point on line" constraint that removes two spatial and two rotational degrees of freedom. The setting is not enabled for all imported groups by default because it exhibits some edge case failures. For example: * draw two line segments sharing a point, * constrain lengths of line segments, * constrain line segments perpendicular, * constrain line segments to a 90° angle. This is a truly degenerate case and so it is not considered very important. However, we can fix this later by using Eigen::SparseQR.
2016-01-21 15:01:43 +00:00
if(g->IsSolvedOkay()) {
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
// Go back to the default group info screen
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
shown.screen = Screen::GROUP_INFO;
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
Show();
return;
}
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
Printf(true, "%FtGROUP %E%s", g->DescriptionString().c_str());
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
switch(g->solved.how) {
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 SolveResult::DIDNT_CONVERGE:
Distinguish overconstrained and redundantly constrained sketches. When a solver error arises after a change to the sketch, it should be easy to understand exactly why it happened. Before this change, two functionally distinct modes of failure were lumped into one: the same "redundant constraints" message was displayed when all degrees of freedom were exhausted and the had a solution, but also when it had not. To understand why this is problematic, let's examine several ways in which we can end up with linearly dependent equations in our system: 0) create a triangle, then constrain two different pairs of edges to be perpendicular 1) add two distinct distance constraints on the same segment 2) add two identical distance constraints on the same segment 3) create a triangle, then constrain edges to lengths a, b, and c so that a+b=c The case (0) is our baseline case: the constraints in it make the system unsolvable yet they do not remove more degrees of freedom than the amount we started with. So the displayed error is "unsolvable constraints". The constraints in case (1) remove one too many degrees of freedom, but otherwise are quite like the case (0): the cause of failure that is useful to the user is that the constraints are mutually incompatible. The constraints in cases (2) and (3) however are not like the others: there is a set of parameters that satisfies all of the constraints, but the constraints still remove one degree of freedom too many. It makes sense to display a different error message for cases (2) and (3) because in practice, cases like this are likely to arise from adjustment of constraint values on sketches corresponding to systems that have a small amount of degenerate solutions, and this is very different from systems arising in cases like (0) where no adjustment of constraint values will ever result in a successful solution. So the error message displayed is "redundant constraints". At last, this commit makes cases (0) and (1) display a message with only a minor difference in wording. This is deliberate. The reason is that the facts "the system is unsolvable" and "the system is unsolvable and also has linearly dependent equations" present no meaningful, actionable difference to the user, and placing emphasis on it would only cause confusion. However, they are still distinguished, because in case (0) we list all relevant constraints (and thus we say they are "mutually incompatible") but in case (1) we only list the ones that constrain the sketch further than some valid solution (and we say they are "unsatisfied").
2016-01-21 09:28:05 +00:00
Printf(true, "%FxSOLVE FAILED!%Fd unsolvable constraints");
Printf(true, "the following constraints are incompatible");
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 SolveResult::REDUNDANT_DIDNT_CONVERGE:
Reword error messages that are displayed when a group fails to solve. The current messages accurately reflect what happens to the system of equations that represents the sketch, but can be quite confusing to users that only think in terms of the constraints. We use "unsolvable" and not "impossible" because while most of the cases that result in this error message will indeed stem from mutually exclusive sets of constraints, it is still possible that there is some solution that our solver is unable to find using numeric methods.
2016-01-21 08:05:21 +00:00
Printf(true, "%FxSOLVE FAILED!%Fd unsolvable constraints");
Speed up the inconsistent constraint detection; there's no reason not to solve by substitution before rank testing. And report the unsatisfied constraints when we don't converge. [git-p4: depot-paths = "//depot/solvespace/": change = 1874]
2008-09-05 11:25:53 +00:00
Printf(true, "the following constraints are unsatisfied");
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37: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 SolveResult::REDUNDANT_OKAY:
Reword error messages that are displayed when a group fails to solve. The current messages accurately reflect what happens to the system of equations that represents the sketch, but can be quite confusing to users that only think in terms of the constraints. We use "unsolvable" and not "impossible" because while most of the cases that result in this error message will indeed stem from mutually exclusive sets of constraints, it is still possible that there is some solution that our solver is unable to find using numeric methods.
2016-01-21 08:05:21 +00:00
Printf(true, "%FxSOLVE FAILED!%Fd redundant constraints");
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
Printf(true, "remove any one of these to fix it");
break;
Oops, don't just crash when the MAX_UNKNOWNS limit is exceeded. [git-p4: depot-paths = "//depot/solvespace/": change = 1943]
2009-04-19 20:37:51 +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 SolveResult::TOO_MANY_UNKNOWNS:
Oops, don't just crash when the MAX_UNKNOWNS limit is exceeded. [git-p4: depot-paths = "//depot/solvespace/": change = 1943]
2009-04-19 20:37:51 +00:00
Printf(true, "Too many unknowns in a single group!");
return;
Enable exhaustive switch coverage warnings as an error, and use them. Specifically, this enables -Wswitch=error on GCC/Clang and its MSVC equivalent; the exact way it is handled varies slightly, but what they all have in common is that in a switch statement over an enumeration, any enumerand that is not explicitly (via case:) or implicitly (via default:) handled in the switch triggers an error. Moreover, we also change the switch statements in three ways: * Switch statements that ought to be extended every time a new enumerand is added (e.g. Entity::DrawOrGetDistance(), are changed to explicitly list every single enumerand, and not have a default: branch. Note that the assertions are kept because it is legal for a enumeration to have a value unlike any of its defined enumerands, and we can e.g. read garbage from a file, or an uninitialized variable. This requires some rearranging if a default: branch is undesired. * Switch statements that ought to only ever see a few select enumerands, are changed to always assert in the default: branch. * Switch statements that do something meaningful for a few enumerands, and ignore everything else, are changed to do nothing in a default: branch, under the assumption that changing them every time an enumerand is added or removed would just result in noise and catch no bugs. This commit also removes the {Request,Entity,Constraint}::UNKNOWN and Entity::DATUM_POINT enumerands, as those were just fancy names for zeroes. They mess up switch exhaustiveness checks and most of the time were not the best way to implement what they did anyway.
2016-05-25 06:55:50 +00:00
default: ssassert(false, "Unexpected solve result");
Speed up the inconsistent constraint detection; there's no reason not to solve by substitution before rank testing. And report the unsatisfied constraints when we don't converge. [git-p4: depot-paths = "//depot/solvespace/": change = 1874]
2008-09-05 11:25:53 +00:00
}
for(int i = 0; i < g->solved.remove.n; i++) {
hConstraint hc = g->solved.remove.elem[i];
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
Constraint *c = SK.constraint.FindByIdNoOops(hc);
Speed up the inconsistent constraint detection; there's no reason not to solve by substitution before rank testing. And report the unsatisfied constraints when we don't converge. [git-p4: depot-paths = "//depot/solvespace/": change = 1874]
2008-09-05 11:25:53 +00:00
if(!c) continue;
Printf(false, "%Bp %Fl%Ll%D%f%h%s%E",
(i & 1) ? 'd' : 'a',
c->h.v, (&TextWindow::ScreenSelectConstraint),
(&TextWindow::ScreenHoverConstraint),
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
c->DescriptionString().c_str());
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
}
A suggestion when we fail to converge or go singular. [git-p4: depot-paths = "//depot/solvespace/": change = 1832]
2008-07-10 07:17:35 +00:00
Printf(true, "It may be possible to fix the problem ");
Printf(false, "by selecting Edit -> Undo.");
Add a setting that permits a group to include redundant constraints. This setting is generally useful, but it especially shines when assembling, since the "same orientation" and "parallel" constraints remove three and two rotational degrees of freedom, which makes them impossible to use with 3d "point on line" constraint that removes two spatial and two rotational degrees of freedom. The setting is not enabled for all imported groups by default because it exhibits some edge case failures. For example: * draw two line segments sharing a point, * constrain lengths of line segments, * constrain line segments perpendicular, * constrain line segments to a 90° angle. This is a truly degenerate case and so it is not considered very important. However, we can fix this later by using Eigen::SparseQR.
2016-01-21 15:01:43 +00:00
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(g->solved.how == SolveResult::REDUNDANT_OKAY) {
Add a setting that permits a group to include redundant constraints. This setting is generally useful, but it especially shines when assembling, since the "same orientation" and "parallel" constraints remove three and two rotational degrees of freedom, which makes them impossible to use with 3d "point on line" constraint that removes two spatial and two rotational degrees of freedom. The setting is not enabled for all imported groups by default because it exhibits some edge case failures. For example: * draw two line segments sharing a point, * constrain lengths of line segments, * constrain line segments perpendicular, * constrain line segments to a 90° angle. This is a truly degenerate case and so it is not considered very important. However, we can fix this later by using Eigen::SparseQR.
2016-01-21 15:01:43 +00:00
Printf(true, "It is possible to suppress this error ");
Printf(false, "by %Fl%f%Llallowing redundant constraints%E in ",
&TextWindow::ScreenAllowRedundant);
Printf(false, "this group.");
}
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
}
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
//-----------------------------------------------------------------------------
// When we're stepping a dimension. User specifies the finish value, and
// how many steps to take in between current and finish, re-solving each
// time.
//-----------------------------------------------------------------------------
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
void TextWindow::ScreenStepDimFinish(int link, uint32_t 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
SS.TW.edit.meaning = Edit::STEP_DIM_FINISH;
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
std::string edit_value;
Eliminate imperative redraws. This commit removes Platform::Window::Redraw function, and rewrites its uses to run on timer events. Most UI toolkits have obscure issues with recursive event handling loops, and Emscripten is purely event- driven and cannot handle imperative redraws at all. As a part of this change, the Platform::Timer::WindUp function is split into three to make the interpretation of its argument less magical. The new functions are RunAfter (a regular timeout, setTimeout in browser terms), RunAfterNextFrame (an animation request, requestAnimationFrame in browser terms), and RunAfterProcessingEvents (a request to run something after all events for the current frame are processed, used for coalescing expensive operations in face of input event queues). This commit changes two uses of Redraw(): the AnimateOnto() and ScreenStepDimGo() functions. The latter was actually broken in that on small sketches, it would run very quickly and not animate the dimension change at all; this has been fixed. While we're at it, get rid of unused Platform::Window::NativePtr function as well.
2018-07-18 23:11:49 +00:00
if(SS.TW.stepDim.isDistance) {
edit_value = SS.MmToString(SS.TW.stepDim.finish);
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
} else {
Eliminate imperative redraws. This commit removes Platform::Window::Redraw function, and rewrites its uses to run on timer events. Most UI toolkits have obscure issues with recursive event handling loops, and Emscripten is purely event- driven and cannot handle imperative redraws at all. As a part of this change, the Platform::Timer::WindUp function is split into three to make the interpretation of its argument less magical. The new functions are RunAfter (a regular timeout, setTimeout in browser terms), RunAfterNextFrame (an animation request, requestAnimationFrame in browser terms), and RunAfterProcessingEvents (a request to run something after all events for the current frame are processed, used for coalescing expensive operations in face of input event queues). This commit changes two uses of Redraw(): the AnimateOnto() and ScreenStepDimGo() functions. The latter was actually broken in that on small sketches, it would run very quickly and not animate the dimension change at all; this has been fixed. While we're at it, get rid of unused Platform::Window::NativePtr function as well.
2018-07-18 23:11:49 +00:00
edit_value = ssprintf("%.3f", SS.TW.stepDim.finish);
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
}
Don't calculate halfRow for ShowEditControl manually. Instead, grab it from hoveredRow, since almost always (with only one exception) this is where the edit control has to be shown. This makes it much easier to adjust views, e.g. add a new editable field in the middle of configuration view, because it's not necessary to manually change and test all the indexes below the row being changed. Additionally, it removes a lot of awkward and opaque row calculations.
2016-01-26 11:19:52 +00:00
SS.TW.ShowEditControl(12, edit_value);
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
}
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
void TextWindow::ScreenStepDimSteps(int link, uint32_t 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
SS.TW.edit.meaning = Edit::STEP_DIM_STEPS;
Eliminate imperative redraws. This commit removes Platform::Window::Redraw function, and rewrites its uses to run on timer events. Most UI toolkits have obscure issues with recursive event handling loops, and Emscripten is purely event- driven and cannot handle imperative redraws at all. As a part of this change, the Platform::Timer::WindUp function is split into three to make the interpretation of its argument less magical. The new functions are RunAfter (a regular timeout, setTimeout in browser terms), RunAfterNextFrame (an animation request, requestAnimationFrame in browser terms), and RunAfterProcessingEvents (a request to run something after all events for the current frame are processed, used for coalescing expensive operations in face of input event queues). This commit changes two uses of Redraw(): the AnimateOnto() and ScreenStepDimGo() functions. The latter was actually broken in that on small sketches, it would run very quickly and not animate the dimension change at all; this has been fixed. While we're at it, get rid of unused Platform::Window::NativePtr function as well.
2018-07-18 23:11:49 +00:00
SS.TW.ShowEditControl(12, ssprintf("%d", SS.TW.stepDim.steps));
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
}
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
void TextWindow::ScreenStepDimGo(int link, uint32_t v) {
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
hConstraint hc = SS.TW.shown.constraint;
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
Constraint *c = SK.constraint.FindByIdNoOops(hc);
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
if(c) {
SS.UndoRemember();
Eliminate imperative redraws. This commit removes Platform::Window::Redraw function, and rewrites its uses to run on timer events. Most UI toolkits have obscure issues with recursive event handling loops, and Emscripten is purely event- driven and cannot handle imperative redraws at all. As a part of this change, the Platform::Timer::WindUp function is split into three to make the interpretation of its argument less magical. The new functions are RunAfter (a regular timeout, setTimeout in browser terms), RunAfterNextFrame (an animation request, requestAnimationFrame in browser terms), and RunAfterProcessingEvents (a request to run something after all events for the current frame are processed, used for coalescing expensive operations in face of input event queues). This commit changes two uses of Redraw(): the AnimateOnto() and ScreenStepDimGo() functions. The latter was actually broken in that on small sketches, it would run very quickly and not animate the dimension change at all; this has been fixed. While we're at it, get rid of unused Platform::Window::NativePtr function as well.
2018-07-18 23:11:49 +00:00
double start = c->valA, finish = SS.TW.stepDim.finish;
SS.TW.stepDim.time = GetMilliseconds();
SS.TW.stepDim.step = 1;
if(!SS.TW.stepDim.timer) {
SS.TW.stepDim.timer = Platform::CreateTimer();
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
}
Eliminate imperative redraws. This commit removes Platform::Window::Redraw function, and rewrites its uses to run on timer events. Most UI toolkits have obscure issues with recursive event handling loops, and Emscripten is purely event- driven and cannot handle imperative redraws at all. As a part of this change, the Platform::Timer::WindUp function is split into three to make the interpretation of its argument less magical. The new functions are RunAfter (a regular timeout, setTimeout in browser terms), RunAfterNextFrame (an animation request, requestAnimationFrame in browser terms), and RunAfterProcessingEvents (a request to run something after all events for the current frame are processed, used for coalescing expensive operations in face of input event queues). This commit changes two uses of Redraw(): the AnimateOnto() and ScreenStepDimGo() functions. The latter was actually broken in that on small sketches, it would run very quickly and not animate the dimension change at all; this has been fixed. While we're at it, get rid of unused Platform::Window::NativePtr function as well.
2018-07-18 23:11:49 +00:00
SS.TW.stepDim.timer->onTimeout = [=] {
if(SS.TW.stepDim.step <= SS.TW.stepDim.steps) {
c->valA = start + ((finish - start)*SS.TW.stepDim.step)/SS.TW.stepDim.steps;
SS.MarkGroupDirty(c->group);
SS.GenerateAll();
if(!SS.ActiveGroupsOkay()) {
// Failed to solve, so quit
return;
}
SS.TW.stepDim.step++;
const int64_t STEP_MILLIS = 50;
int64_t time = GetMilliseconds();
if(time - SS.TW.stepDim.time < STEP_MILLIS) {
SS.TW.stepDim.timer->RunAfterNextFrame();
} else {
SS.TW.stepDim.timer->RunAfter(time - SS.TW.stepDim.time - STEP_MILLIS);
}
SS.TW.stepDim.time = time;
} else {
SS.TW.GoToScreen(Screen::LIST_OF_GROUPS);
SS.ScheduleShowTW();
}
SS.GW.Invalidate();
};
SS.TW.stepDim.timer->RunAfterNextFrame();
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +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 TextWindow::ShowStepDimension() {
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
Constraint *c = SK.constraint.FindByIdNoOops(shown.constraint);
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
if(!c) {
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
shown.screen = Screen::LIST_OF_GROUPS;
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
Show();
return;
}
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
Printf(true, "%FtSTEP DIMENSION%E %s", c->DescriptionString().c_str());
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
Eliminate imperative redraws. This commit removes Platform::Window::Redraw function, and rewrites its uses to run on timer events. Most UI toolkits have obscure issues with recursive event handling loops, and Emscripten is purely event- driven and cannot handle imperative redraws at all. As a part of this change, the Platform::Timer::WindUp function is split into three to make the interpretation of its argument less magical. The new functions are RunAfter (a regular timeout, setTimeout in browser terms), RunAfterNextFrame (an animation request, requestAnimationFrame in browser terms), and RunAfterProcessingEvents (a request to run something after all events for the current frame are processed, used for coalescing expensive operations in face of input event queues). This commit changes two uses of Redraw(): the AnimateOnto() and ScreenStepDimGo() functions. The latter was actually broken in that on small sketches, it would run very quickly and not animate the dimension change at all; this has been fixed. While we're at it, get rid of unused Platform::Window::NativePtr function as well.
2018-07-18 23:11:49 +00:00
if(stepDim.isDistance) {
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
Printf(true, "%Ba %Ftstart%E %s", SS.MmToString(c->valA).c_str());
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
Printf(false, "%Bd %Ftfinish%E %s %Fl%Ll%f[change]%E",
Eliminate imperative redraws. This commit removes Platform::Window::Redraw function, and rewrites its uses to run on timer events. Most UI toolkits have obscure issues with recursive event handling loops, and Emscripten is purely event- driven and cannot handle imperative redraws at all. As a part of this change, the Platform::Timer::WindUp function is split into three to make the interpretation of its argument less magical. The new functions are RunAfter (a regular timeout, setTimeout in browser terms), RunAfterNextFrame (an animation request, requestAnimationFrame in browser terms), and RunAfterProcessingEvents (a request to run something after all events for the current frame are processed, used for coalescing expensive operations in face of input event queues). This commit changes two uses of Redraw(): the AnimateOnto() and ScreenStepDimGo() functions. The latter was actually broken in that on small sketches, it would run very quickly and not animate the dimension change at all; this has been fixed. While we're at it, get rid of unused Platform::Window::NativePtr function as well.
2018-07-18 23:11:49 +00:00
SS.MmToString(stepDim.finish).c_str(), &ScreenStepDimFinish);
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
} else {
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
Printf(true, "%Ba %Ftstart%E %@", c->valA);
Printf(false, "%Bd %Ftfinish%E %@ %Fl%Ll%f[change]%E",
Eliminate imperative redraws. This commit removes Platform::Window::Redraw function, and rewrites its uses to run on timer events. Most UI toolkits have obscure issues with recursive event handling loops, and Emscripten is purely event- driven and cannot handle imperative redraws at all. As a part of this change, the Platform::Timer::WindUp function is split into three to make the interpretation of its argument less magical. The new functions are RunAfter (a regular timeout, setTimeout in browser terms), RunAfterNextFrame (an animation request, requestAnimationFrame in browser terms), and RunAfterProcessingEvents (a request to run something after all events for the current frame are processed, used for coalescing expensive operations in face of input event queues). This commit changes two uses of Redraw(): the AnimateOnto() and ScreenStepDimGo() functions. The latter was actually broken in that on small sketches, it would run very quickly and not animate the dimension change at all; this has been fixed. While we're at it, get rid of unused Platform::Window::NativePtr function as well.
2018-07-18 23:11:49 +00:00
stepDim.finish, &ScreenStepDimFinish);
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
}
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
Printf(false, "%Ba %Ftsteps%E %d %Fl%Ll%f%D[change]%E",
Eliminate imperative redraws. This commit removes Platform::Window::Redraw function, and rewrites its uses to run on timer events. Most UI toolkits have obscure issues with recursive event handling loops, and Emscripten is purely event- driven and cannot handle imperative redraws at all. As a part of this change, the Platform::Timer::WindUp function is split into three to make the interpretation of its argument less magical. The new functions are RunAfter (a regular timeout, setTimeout in browser terms), RunAfterNextFrame (an animation request, requestAnimationFrame in browser terms), and RunAfterProcessingEvents (a request to run something after all events for the current frame are processed, used for coalescing expensive operations in face of input event queues). This commit changes two uses of Redraw(): the AnimateOnto() and ScreenStepDimGo() functions. The latter was actually broken in that on small sketches, it would run very quickly and not animate the dimension change at all; this has been fixed. While we're at it, get rid of unused Platform::Window::NativePtr function as well.
2018-07-18 23:11:49 +00:00
stepDim.steps, &ScreenStepDimSteps);
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
Printf(true, " %Fl%Ll%fstep dimension now%E", &ScreenStepDimGo);
Printf(true, "(or %Fl%Ll%fcancel operation%E)", &ScreenHome);
}
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
//-----------------------------------------------------------------------------
// When we're creating tangent arcs (as requests, not as some parametric
// thing). User gets to specify the radius, and whether the old untrimmed
// curves are kept or deleted.
//-----------------------------------------------------------------------------
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
void TextWindow::ScreenChangeTangentArc(int link, uint32_t v) {
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
switch(link) {
case 'r': {
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.edit.meaning = Edit::TANGENT_ARC_RADIUS;
Don't calculate halfRow for ShowEditControl manually. Instead, grab it from hoveredRow, since almost always (with only one exception) this is where the edit control has to be shown. This makes it much easier to adjust views, e.g. add a new editable field in the middle of configuration view, because it's not necessary to manually change and test all the indexes below the row being changed. Additionally, it removes a lot of awkward and opaque row calculations.
2016-01-26 11:19:52 +00:00
SS.TW.ShowEditControl(3, SS.MmToString(SS.tangentArcRadius));
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
break;
}
case 'a': SS.tangentArcManual = !SS.tangentArcManual; break;
Let tangent arc modify the original entities. Modifying the original entities instead of deleting them, retains the original associated constraints. This makes creating rounded rectangles a lot easier.
2018-07-22 18:56:28 +00:00
case 'm': SS.tangentArcModify = !SS.tangentArcModify; 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
}
}
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 TextWindow::ShowTangentArc() {
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
Printf(true, "%FtTANGENT ARC PARAMETERS%E");
Printf(true, "%Ft radius of created arc%E");
if(SS.tangentArcManual) {
Printf(false, "%Ba %s %Fl%Lr%f[change]%E",
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
SS.MmToString(SS.tangentArcRadius).c_str(),
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
&(TextWindow::ScreenChangeTangentArc));
} else {
Printf(false, "%Ba automatic");
}
Printf(false, "");
Rasterize non-ASCII glyphs in the UI. Now it is possible to give non-ASCII names to groups as well as see non-ASCII filenames of imported files. In the future this makes localization possible. This works for LTR languages, such as European and CJK, but not RTL such as Arabic. Does Arabic even exist in monospaced form? I have no idea.
2015-11-05 19:39:27 +00:00
Printf(false, " %Fd%f%La%s choose radius automatically%E",
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
&ScreenChangeTangentArc,
!SS.tangentArcManual ? CHECK_TRUE : CHECK_FALSE);
Let tangent arc modify the original entities. Modifying the original entities instead of deleting them, retains the original associated constraints. This makes creating rounded rectangles a lot easier.
2018-07-22 18:56:28 +00:00
Printf(false, " %Fd%f%Lm%s modify original entities%E",
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
&ScreenChangeTangentArc,
Let tangent arc modify the original entities. Modifying the original entities instead of deleting them, retains the original associated constraints. This makes creating rounded rectangles a lot easier.
2018-07-22 18:56:28 +00:00
SS.tangentArcModify ? CHECK_TRUE : CHECK_FALSE);
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
Printf(false, "");
Printf(false, "To create a tangent arc at a point,");
Printf(false, "select that point and then choose");
Printf(false, "Sketch -> Tangent Arc at Point.");
Put a link the rounding screen to return home, just in case the one at the top left isn't obvious enough. [git-p4: depot-paths = "//depot/solvespace/": change = 2155]
2010-05-17 01:54:19 +00:00
Printf(true, "(or %Fl%Ll%fback to home screen%E)", &ScreenHome);
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
}
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
//-----------------------------------------------------------------------------
// The edit control is visible, and the user just pressed enter.
//-----------------------------------------------------------------------------
Implement a platform abstraction for windows. This commit removes a large amount of code partially duplicated between the text and the graphics windows, and opens the path to having more than one model window on screen at any given time, as well as simplifies platform work. This commit also adds complete support for High-DPI device pixel ratio. It adds support for font scale factor (a fractional factor on top of integral device pixel ratio) on the platform side, but not on the application side. This commit also adds error checking to all Windows API calls (within the abstracted code) and fixes a significant number of misuses and non-future-proof uses of Windows API. This commit also makes uses of Windows API idiomatic, e.g. using the built-in vertical scroll bar, native tooltips, control subclassing instead of hooks in the global dispatch loop, and so on. It reinstates tooltip support and removes menu-related hacks.
2018-07-12 19:29:44 +00:00
void TextWindow::EditControlDone(std::string s) {
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
edit.showAgain = false;
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
switch(edit.meaning) {
Implement a platform abstraction for windows. This commit removes a large amount of code partially duplicated between the text and the graphics windows, and opens the path to having more than one model window on screen at any given time, as well as simplifies platform work. This commit also adds complete support for High-DPI device pixel ratio. It adds support for font scale factor (a fractional factor on top of integral device pixel ratio) on the platform side, but not on the application side. This commit also adds error checking to all Windows API calls (within the abstracted code) and fixes a significant number of misuses and non-future-proof uses of Windows API. This commit also makes uses of Windows API idiomatic, e.g. using the built-in vertical scroll bar, native tooltips, control subclassing instead of hooks in the global dispatch loop, and so on. It reinstates tooltip support and removes menu-related hacks.
2018-07-12 19:29:44 +00:00
case Edit::TIMES_REPEATED:
if(Expr *e = Expr::From(s, /*popUpError=*/true)) {
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
SS.UndoRemember();
Make rotations default to 360/n degrees (uniform about a circle) if no constraints set the rotation. [git-p4: depot-paths = "//depot/solvespace/": change = 1827]
2008-07-09 06:13:49 +00:00
double ev = e->Eval();
if((int)ev < 1) {
Internationalize all messages without substitutions.
2017-01-07 06:41:13 +00:00
Error(_("Can't repeat fewer than 1 time."));
Make rotations default to 360/n degrees (uniform about a circle) if no constraints set the rotation. [git-p4: depot-paths = "//depot/solvespace/": change = 1827]
2008-07-09 06:13:49 +00:00
break;
}
Due to questionable decision to use copy-number values of 1000 and up for special things, the number of times that a group may be stepped is limited to 999. So avoid a crash by not letting the user specify more than that. [git-p4: depot-paths = "//depot/solvespace/": change = 2178]
2010-09-18 02:20:08 +00:00
if((int)ev > 999) {
Internationalize all messages without substitutions.
2017-01-07 06:41:13 +00:00
Error(_("Can't repeat more than 999 times."));
Due to questionable decision to use copy-number values of 1000 and up for special things, the number of times that a group may be stepped is limited to 999. So avoid a crash by not letting the user specify more than that. [git-p4: depot-paths = "//depot/solvespace/": change = 2178]
2010-09-18 02:20:08 +00:00
break;
}
Make rotations default to 360/n degrees (uniform about a circle) if no constraints set the rotation. [git-p4: depot-paths = "//depot/solvespace/": change = 1827]
2008-07-09 06:13:49 +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(edit.group);
Make rotations default to 360/n degrees (uniform about a circle) if no constraints set the rotation. [git-p4: depot-paths = "//depot/solvespace/": change = 1827]
2008-07-09 06:13:49 +00:00
g->valA = ev;
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::ROTATE) {
Make rotations default to 360/n degrees (uniform about a circle) if no constraints set the rotation. [git-p4: depot-paths = "//depot/solvespace/": change = 1827]
2008-07-09 06:13:49 +00:00
// If the group does not contain any constraints, then
// set the numerical guess to space the copies uniformly
// over one rotation. Don't touch the guess if we're
// already constrained, because that would break
// convergence.
Add CountIf method to IdList to simplify some call sites. NFC. This also changes GetNumConstraints to return size_t.
2018-01-04 01:56:04 +00:00
if(g->GetNumConstraints() == 0) {
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
double copies = (g->skipFirst) ? (ev + 1) : ev;
SK.GetParam(g->h.param(3))->val = PI/(2*copies);
Make rotations default to 360/n degrees (uniform about a circle) if no constraints set the rotation. [git-p4: depot-paths = "//depot/solvespace/": change = 1827]
2008-07-09 06:13:49 +00:00
}
}
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
SS.MarkGroupDirty(g->h);
}
break;
Implement a platform abstraction for windows. This commit removes a large amount of code partially duplicated between the text and the graphics windows, and opens the path to having more than one model window on screen at any given time, as well as simplifies platform work. This commit also adds complete support for High-DPI device pixel ratio. It adds support for font scale factor (a fractional factor on top of integral device pixel ratio) on the platform side, but not on the application side. This commit also adds error checking to all Windows API calls (within the abstracted code) and fixes a significant number of misuses and non-future-proof uses of Windows API. This commit also makes uses of Windows API idiomatic, e.g. using the built-in vertical scroll bar, native tooltips, control subclassing instead of hooks in the global dispatch loop, and so on. It reinstates tooltip support and removes menu-related hacks.
2018-07-12 19:29:44 +00:00
case Edit::GROUP_NAME:
if(s.empty()) {
Internationalize all messages without substitutions.
2017-01-07 06:41:13 +00:00
Error(_("Group name cannot be empty"));
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
} else {
SS.UndoRemember();
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(edit.group);
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
g->name = s;
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
}
break;
Implement a platform abstraction for windows. This commit removes a large amount of code partially duplicated between the text and the graphics windows, and opens the path to having more than one model window on screen at any given time, as well as simplifies platform work. This commit also adds complete support for High-DPI device pixel ratio. It adds support for font scale factor (a fractional factor on top of integral device pixel ratio) on the platform side, but not on the application side. This commit also adds error checking to all Windows API calls (within the abstracted code) and fixes a significant number of misuses and non-future-proof uses of Windows API. This commit also makes uses of Windows API idiomatic, e.g. using the built-in vertical scroll bar, native tooltips, control subclassing instead of hooks in the global dispatch loop, and so on. It reinstates tooltip support and removes menu-related hacks.
2018-07-12 19:29:44 +00:00
case Edit::GROUP_SCALE:
if(Expr *e = Expr::From(s, /*popUpError=*/true)) {
A big nasty change, originally just to add paste transformed. So it does that, and adds a scale factor to that transformation (instead of just mirroring, as before), but also: * Replace the "import mirrored" mechanism with a scale factor, which if negative corresponds to a reflection as well. * Fix self-intersection checker to report a meaningful point when edges are collinear. * Don't blow an assertion on some types of invalid file; instead provide a nice error message to the user. * Clear the naked edges before each regen. * Don't create zero-length line segments by snapping a line segment's end to its beginning. [git-p4: depot-paths = "//depot/solvespace/": change = 2086]
2009-12-15 12:26:22 +00:00
double ev = e->Eval();
if(fabs(ev) < 1e-6) {
Internationalize all messages without substitutions.
2017-01-07 06:41:13 +00:00
Error(_("Scale cannot be zero."));
A big nasty change, originally just to add paste transformed. So it does that, and adds a scale factor to that transformation (instead of just mirroring, as before), but also: * Replace the "import mirrored" mechanism with a scale factor, which if negative corresponds to a reflection as well. * Fix self-intersection checker to report a meaningful point when edges are collinear. * Don't blow an assertion on some types of invalid file; instead provide a nice error message to the user. * Clear the naked edges before each regen. * Don't create zero-length line segments by snapping a line segment's end to its beginning. [git-p4: depot-paths = "//depot/solvespace/": change = 2086]
2009-12-15 12:26:22 +00:00
} else {
Group *g = SK.GetGroup(edit.group);
g->scale = ev;
SS.MarkGroupDirty(g->h);
}
}
break;
Implement a platform abstraction for windows. This commit removes a large amount of code partially duplicated between the text and the graphics windows, and opens the path to having more than one model window on screen at any given time, as well as simplifies platform work. This commit also adds complete support for High-DPI device pixel ratio. It adds support for font scale factor (a fractional factor on top of integral device pixel ratio) on the platform side, but not on the application side. This commit also adds error checking to all Windows API calls (within the abstracted code) and fixes a significant number of misuses and non-future-proof uses of Windows API. This commit also makes uses of Windows API idiomatic, e.g. using the built-in vertical scroll bar, native tooltips, control subclassing instead of hooks in the global dispatch loop, and so on. It reinstates tooltip support and removes menu-related hacks.
2018-07-12 19:29:44 +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 Edit::GROUP_COLOR: {
Update selection of extrusion/lathe solid model color to use new color picker. And apply same rule to rewrite nearly-white colors (when exporting with a file format typically viewed on a white background) for fill color as for stroke color. [git-p4: depot-paths = "//depot/solvespace/": change = 2176]
2010-08-14 19:00:25 +00:00
Vector rgb;
Implement a platform abstraction for windows. This commit removes a large amount of code partially duplicated between the text and the graphics windows, and opens the path to having more than one model window on screen at any given time, as well as simplifies platform work. This commit also adds complete support for High-DPI device pixel ratio. It adds support for font scale factor (a fractional factor on top of integral device pixel ratio) on the platform side, but not on the application side. This commit also adds error checking to all Windows API calls (within the abstracted code) and fixes a significant number of misuses and non-future-proof uses of Windows API. This commit also makes uses of Windows API idiomatic, e.g. using the built-in vertical scroll bar, native tooltips, control subclassing instead of hooks in the global dispatch loop, and so on. It reinstates tooltip support and removes menu-related hacks.
2018-07-12 19:29:44 +00:00
if(sscanf(s.c_str(), "%lf, %lf, %lf", &rgb.x, &rgb.y, &rgb.z)==3) {
Update selection of extrusion/lathe solid model color to use new color picker. And apply same rule to rewrite nearly-white colors (when exporting with a file format typically viewed on a white background) for fill color as for stroke color. [git-p4: depot-paths = "//depot/solvespace/": change = 2176]
2010-08-14 19:00:25 +00:00
rgb = rgb.ClampWithin(0, 1);
Group *g = SK.group.FindByIdNoOops(SS.TW.shown.group);
if(!g) break;
g->color = RGBf(rgb.x, rgb.y, rgb.z);
SS.MarkGroupDirty(g->h);
SS.GW.ClearSuper();
} else {
Internationalize all messages without substitutions.
2017-01-07 06:41:13 +00:00
Error(_("Bad format: specify color as r, g, b"));
Update selection of extrusion/lathe solid model color to use new color picker. And apply same rule to rewrite nearly-white colors (when exporting with a file format typically viewed on a white background) for fill color as for stroke color. [git-p4: depot-paths = "//depot/solvespace/": change = 2176]
2010-08-14 19:00:25 +00:00
}
break;
}
Implement a platform abstraction for windows. This commit removes a large amount of code partially duplicated between the text and the graphics windows, and opens the path to having more than one model window on screen at any given time, as well as simplifies platform work. This commit also adds complete support for High-DPI device pixel ratio. It adds support for font scale factor (a fractional factor on top of integral device pixel ratio) on the platform side, but not on the application side. This commit also adds error checking to all Windows API calls (within the abstracted code) and fixes a significant number of misuses and non-future-proof uses of Windows API. This commit also makes uses of Windows API idiomatic, e.g. using the built-in vertical scroll bar, native tooltips, control subclassing instead of hooks in the global dispatch loop, and so on. It reinstates tooltip support and removes menu-related hacks.
2018-07-12 19:29:44 +00:00
case Edit::GROUP_OPACITY:
if(Expr *e = Expr::From(s, /*popUpError=*/true)) {
Add support for transparent solids. Some extra code is necessary to determine that the back faces should not be drawn in red for transparent solids. It is expected that the user will first ensure that the shell is watertight and then set the opacity; back faces are still drawn if the opacity is exactly 1. The savefile format is changed backwards-compatibly by stashing the alpha value in uppermost byte of 4-byte hex color value in Surface and Triangle clauses. The existing files have 00 in the high byte, so RgbColor::FromPackedInt treats that as "opaque".
2015-03-26 10:30:12 +00:00
double alpha = e->Eval();
if(alpha < 0 || alpha > 1) {
Internationalize all messages without substitutions.
2017-01-07 06:41:13 +00:00
Error(_("Opacity must be between zero and one."));
Add support for transparent solids. Some extra code is necessary to determine that the back faces should not be drawn in red for transparent solids. It is expected that the user will first ensure that the shell is watertight and then set the opacity; back faces are still drawn if the opacity is exactly 1. The savefile format is changed backwards-compatibly by stashing the alpha value in uppermost byte of 4-byte hex color value in Surface and Triangle clauses. The existing files have 00 in the high byte, so RgbColor::FromPackedInt treats that as "opaque".
2015-03-26 10:30:12 +00:00
} else {
Group *g = SK.GetGroup(edit.group);
g->color.alpha = (int)(255.1f * alpha);
SS.MarkGroupDirty(g->h);
SS.GW.ClearSuper();
}
}
break;
Implement a platform abstraction for windows. This commit removes a large amount of code partially duplicated between the text and the graphics windows, and opens the path to having more than one model window on screen at any given time, as well as simplifies platform work. This commit also adds complete support for High-DPI device pixel ratio. It adds support for font scale factor (a fractional factor on top of integral device pixel ratio) on the platform side, but not on the application side. This commit also adds error checking to all Windows API calls (within the abstracted code) and fixes a significant number of misuses and non-future-proof uses of Windows API. This commit also makes uses of Windows API idiomatic, e.g. using the built-in vertical scroll bar, native tooltips, control subclassing instead of hooks in the global dispatch loop, and so on. It reinstates tooltip support and removes menu-related hacks.
2018-07-12 19:29:44 +00:00
case Edit::TTF_TEXT:
Add TrueType font support to SolveSpace. This uses a modified version of the code from SketchFlat, with all arbitrary limits removed. The TTF text is its own entity, and that entity includes the font file basename and the text. That's an extra 128 bytes in the entity, which is around a 50% increase, kind of a shame. It was simple, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1814]
2008-06-30 09:09:17 +00:00
SS.UndoRemember();
Implement a platform abstraction for windows. This commit removes a large amount of code partially duplicated between the text and the graphics windows, and opens the path to having more than one model window on screen at any given time, as well as simplifies platform work. This commit also adds complete support for High-DPI device pixel ratio. It adds support for font scale factor (a fractional factor on top of integral device pixel ratio) on the platform side, but not on the application side. This commit also adds error checking to all Windows API calls (within the abstracted code) and fixes a significant number of misuses and non-future-proof uses of Windows API. This commit also makes uses of Windows API idiomatic, e.g. using the built-in vertical scroll bar, native tooltips, control subclassing instead of hooks in the global dispatch loop, and so on. It reinstates tooltip support and removes menu-related hacks.
2018-07-12 19:29:44 +00:00
if(Request *r = SK.request.FindByIdNoOops(edit.request)) {
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
r->str = s;
Add TrueType font support to SolveSpace. This uses a modified version of the code from SketchFlat, with all arbitrary limits removed. The TTF text is its own entity, and that entity includes the font file basename and the text. That's an extra 128 bytes in the entity, which is around a 50% increase, kind of a shame. It was simple, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1814]
2008-06-30 09:09:17 +00:00
SS.MarkGroupDirty(r->group);
}
break;
Implement a platform abstraction for windows. This commit removes a large amount of code partially duplicated between the text and the graphics windows, and opens the path to having more than one model window on screen at any given time, as well as simplifies platform work. This commit also adds complete support for High-DPI device pixel ratio. It adds support for font scale factor (a fractional factor on top of integral device pixel ratio) on the platform side, but not on the application side. This commit also adds error checking to all Windows API calls (within the abstracted code) and fixes a significant number of misuses and non-future-proof uses of Windows API. This commit also makes uses of Windows API idiomatic, e.g. using the built-in vertical scroll bar, native tooltips, control subclassing instead of hooks in the global dispatch loop, and so on. It reinstates tooltip support and removes menu-related hacks.
2018-07-12 19:29:44 +00:00
case Edit::STEP_DIM_FINISH:
if(Expr *e = Expr::From(s, /*popUpError=*/true)) {
Eliminate imperative redraws. This commit removes Platform::Window::Redraw function, and rewrites its uses to run on timer events. Most UI toolkits have obscure issues with recursive event handling loops, and Emscripten is purely event- driven and cannot handle imperative redraws at all. As a part of this change, the Platform::Timer::WindUp function is split into three to make the interpretation of its argument less magical. The new functions are RunAfter (a regular timeout, setTimeout in browser terms), RunAfterNextFrame (an animation request, requestAnimationFrame in browser terms), and RunAfterProcessingEvents (a request to run something after all events for the current frame are processed, used for coalescing expensive operations in face of input event queues). This commit changes two uses of Redraw(): the AnimateOnto() and ScreenStepDimGo() functions. The latter was actually broken in that on small sketches, it would run very quickly and not animate the dimension change at all; this has been fixed. While we're at it, get rid of unused Platform::Window::NativePtr function as well.
2018-07-18 23:11:49 +00:00
if(stepDim.isDistance) {
stepDim.finish = SS.ExprToMm(e);
Implement a platform abstraction for windows. This commit removes a large amount of code partially duplicated between the text and the graphics windows, and opens the path to having more than one model window on screen at any given time, as well as simplifies platform work. This commit also adds complete support for High-DPI device pixel ratio. It adds support for font scale factor (a fractional factor on top of integral device pixel ratio) on the platform side, but not on the application side. This commit also adds error checking to all Windows API calls (within the abstracted code) and fixes a significant number of misuses and non-future-proof uses of Windows API. This commit also makes uses of Windows API idiomatic, e.g. using the built-in vertical scroll bar, native tooltips, control subclassing instead of hooks in the global dispatch loop, and so on. It reinstates tooltip support and removes menu-related hacks.
2018-07-12 19:29:44 +00:00
} else {
Eliminate imperative redraws. This commit removes Platform::Window::Redraw function, and rewrites its uses to run on timer events. Most UI toolkits have obscure issues with recursive event handling loops, and Emscripten is purely event- driven and cannot handle imperative redraws at all. As a part of this change, the Platform::Timer::WindUp function is split into three to make the interpretation of its argument less magical. The new functions are RunAfter (a regular timeout, setTimeout in browser terms), RunAfterNextFrame (an animation request, requestAnimationFrame in browser terms), and RunAfterProcessingEvents (a request to run something after all events for the current frame are processed, used for coalescing expensive operations in face of input event queues). This commit changes two uses of Redraw(): the AnimateOnto() and ScreenStepDimGo() functions. The latter was actually broken in that on small sketches, it would run very quickly and not animate the dimension change at all; this has been fixed. While we're at it, get rid of unused Platform::Window::NativePtr function as well.
2018-07-18 23:11:49 +00:00
stepDim.finish = e->Eval();
Implement a platform abstraction for windows. This commit removes a large amount of code partially duplicated between the text and the graphics windows, and opens the path to having more than one model window on screen at any given time, as well as simplifies platform work. This commit also adds complete support for High-DPI device pixel ratio. It adds support for font scale factor (a fractional factor on top of integral device pixel ratio) on the platform side, but not on the application side. This commit also adds error checking to all Windows API calls (within the abstracted code) and fixes a significant number of misuses and non-future-proof uses of Windows API. This commit also makes uses of Windows API idiomatic, e.g. using the built-in vertical scroll bar, native tooltips, control subclassing instead of hooks in the global dispatch loop, and so on. It reinstates tooltip support and removes menu-related hacks.
2018-07-12 19:29:44 +00:00
}
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
}
break;
Implement a platform abstraction for windows. This commit removes a large amount of code partially duplicated between the text and the graphics windows, and opens the path to having more than one model window on screen at any given time, as well as simplifies platform work. This commit also adds complete support for High-DPI device pixel ratio. It adds support for font scale factor (a fractional factor on top of integral device pixel ratio) on the platform side, but not on the application side. This commit also adds error checking to all Windows API calls (within the abstracted code) and fixes a significant number of misuses and non-future-proof uses of Windows API. This commit also makes uses of Windows API idiomatic, e.g. using the built-in vertical scroll bar, native tooltips, control subclassing instead of hooks in the global dispatch loop, and so on. It reinstates tooltip support and removes menu-related hacks.
2018-07-12 19:29:44 +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 Edit::STEP_DIM_STEPS:
Eliminate imperative redraws. This commit removes Platform::Window::Redraw function, and rewrites its uses to run on timer events. Most UI toolkits have obscure issues with recursive event handling loops, and Emscripten is purely event- driven and cannot handle imperative redraws at all. As a part of this change, the Platform::Timer::WindUp function is split into three to make the interpretation of its argument less magical. The new functions are RunAfter (a regular timeout, setTimeout in browser terms), RunAfterNextFrame (an animation request, requestAnimationFrame in browser terms), and RunAfterProcessingEvents (a request to run something after all events for the current frame are processed, used for coalescing expensive operations in face of input event queues). This commit changes two uses of Redraw(): the AnimateOnto() and ScreenStepDimGo() functions. The latter was actually broken in that on small sketches, it would run very quickly and not animate the dimension change at all; this has been fixed. While we're at it, get rid of unused Platform::Window::NativePtr function as well.
2018-07-18 23:11:49 +00:00
stepDim.steps = min(300, max(1, atoi(s.c_str())));
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
break;
Add ability to set export canvas size (paper size for PDF, bbox size for EPS, etc.). This can either be fixed, with a given width and height and offset, or automatic, by the left right bottom top margins. And draw nicer dimensions for length, with arrows and more extension lines. Add code to trim those lines against the (rectangular, axis-aligned) box that contains the actual number, and use that (instead of the elliptical interpolation, which was only approximately right) for diameter dimensions too. [git-p4: depot-paths = "//depot/solvespace/": change = 2027]
2009-09-03 08:13:09 +00:00
Implement a platform abstraction for windows. This commit removes a large amount of code partially duplicated between the text and the graphics windows, and opens the path to having more than one model window on screen at any given time, as well as simplifies platform work. This commit also adds complete support for High-DPI device pixel ratio. It adds support for font scale factor (a fractional factor on top of integral device pixel ratio) on the platform side, but not on the application side. This commit also adds error checking to all Windows API calls (within the abstracted code) and fixes a significant number of misuses and non-future-proof uses of Windows API. This commit also makes uses of Windows API idiomatic, e.g. using the built-in vertical scroll bar, native tooltips, control subclassing instead of hooks in the global dispatch loop, and so on. It reinstates tooltip support and removes menu-related hacks.
2018-07-12 19:29:44 +00:00
case Edit::TANGENT_ARC_RADIUS:
if(Expr *e = Expr::From(s, /*popUpError=*/true)) {
if(e->Eval() < LENGTH_EPS) {
Error(_("Radius cannot be zero or negative."));
break;
}
SS.tangentArcRadius = SS.ExprToMm(e);
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
}
break;
Split draw.cpp and textscreens.cpp, and move a few things around. This creates mouse.cpp and confscreen.cpp. [git-p4: depot-paths = "//depot/solvespace/": change = 2040]
2009-09-29 13:14:47 +00:00
default: {
A big nasty change, originally just to add paste transformed. So it does that, and adds a scale factor to that transformation (instead of just mirroring, as before), but also: * Replace the "import mirrored" mechanism with a scale factor, which if negative corresponds to a reflection as well. * Fix self-intersection checker to report a meaningful point when edges are collinear. * Don't blow an assertion on some types of invalid file; instead provide a nice error message to the user. * Clear the naked edges before each regen. * Don't create zero-length line segments by snapping a line segment's end to its beginning. [git-p4: depot-paths = "//depot/solvespace/": change = 2086]
2009-12-15 12:26:22 +00:00
int cnt = 0;
if(EditControlDoneForStyles(s)) cnt++;
if(EditControlDoneForConfiguration(s)) cnt++;
if(EditControlDoneForPaste(s)) cnt++;
Add a screen to edit the view parameters; scale, translation, rotation. Also clean up the handling of units, by putting the conversion factors in only one place, and clean up the expression-parsing but removing all the copies of the same error message. [git-p4: depot-paths = "//depot/solvespace/": change = 2093]
2010-01-04 00:35:28 +00:00
if(EditControlDoneForView(s)) cnt++;
Replace all oops() checks with ssassert()s. This includes explanation and context for non-obvious cases and shortens debug cycles when just-in-time debugging is not available (like on Linux) by immediately printing description of the assert as well as symbolized backtrace.
2016-05-18 22:51:36 +00:00
ssassert(cnt == 1, "Expected exactly one parameter to be edited");
Add ability to set export canvas size (paper size for PDF, bbox size for EPS, etc.). This can either be fixed, with a given width and height and offset, or automatic, by the left right bottom top margins. And draw nicer dimensions for length, with arrows and more extension lines. Add code to trim those lines against the (rectangular, axis-aligned) box that contains the actual number, and use that (instead of the elliptical interpolation, which was only approximately right) for diameter dimensions too. [git-p4: depot-paths = "//depot/solvespace/": change = 2027]
2009-09-03 08:13:09 +00:00
break;
}
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
}
Implement a platform abstraction for windows. This commit removes a large amount of code partially duplicated between the text and the graphics windows, and opens the path to having more than one model window on screen at any given time, as well as simplifies platform work. This commit also adds complete support for High-DPI device pixel ratio. It adds support for font scale factor (a fractional factor on top of integral device pixel ratio) on the platform side, but not on the application side. This commit also adds error checking to all Windows API calls (within the abstracted code) and fixes a significant number of misuses and non-future-proof uses of Windows API. This commit also makes uses of Windows API idiomatic, e.g. using the built-in vertical scroll bar, native tooltips, control subclassing instead of hooks in the global dispatch loop, and so on. It reinstates tooltip support and removes menu-related hacks.
2018-07-12 19:29:44 +00:00
SS.GW.Invalidate();
Add a GTK2/3 port. In principle, GTK3 is the way forward, and GTK2 is officially deprecated, though still maintained. In practice however, GTK3 is often unbearably buggy; e.g. on my system, combo boxes don't ever roll up in GTK3 windows. So I have added support for both. This required a few minor changes to the core, namely: * GTK wants to know beforehand whether a menu item is a check menu item or a regular one. * GTK doesn't give us an easy way to execute something after any event is processed, so an explicit idle timer is added. This is a no-op on Win32. * A few function signatures were const'ed, since GTK expects immutable strings when converting to Glib::ustring.
2015-03-18 17:02:11 +00:00
SS.ScheduleShowTW();
Add a screen to edit the view parameters; scale, translation, rotation. Also clean up the handling of units, by putting the conversion factors in only one place, and clean up the expression-parsing but removing all the copies of the same error message. [git-p4: depot-paths = "//depot/solvespace/": change = 2093]
2010-01-04 00:35:28 +00:00
if(!edit.showAgain) {
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
HideEditControl();
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
edit.meaning = Edit::NOTHING;
Add a screen to edit the view parameters; scale, translation, rotation. Also clean up the handling of units, by putting the conversion factors in only one place, and clean up the expression-parsing but removing all the copies of the same error message. [git-p4: depot-paths = "//depot/solvespace/": change = 2093]
2010-01-04 00:35:28 +00:00
}
Split the BSP stuff off the mesh stuff, and the text screens themselves of the text window utility functions. [git-p4: depot-paths = "//depot/solvespace/": change = 1806]
2008-06-23 08:37:12 +00:00
}