caiyu/solvespace
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
11a8a0abd5
solvespace/src/file.cpp

1008 lines
40 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-29 06:08:34 +08:00
//-----------------------------------------------------------------------------
// Routines to write and read our .slvs file format.
//
// Copyright 2008-2013 Jonathan Westhues.
//-----------------------------------------------------------------------------
Rename some stuff in the IdList again. Rough in the file save stuff, though no file load stuff, and perhaps this can all be made to work from a table somehow. Move the quaternion stuff into its own class, and add a fancy animated view when you orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1672]
2008-04-18 19:11:48 +08:00
#include "solvespace.h"
Miscellaneous adjustments for warnings and code quality This commit contains a grab bag of minor changes not worth committing individually: * Replaced raw Latin-1 characters with octal escapes to avoid source-file encoding issues * Undefined some convenience macros after they've served their purpose * Rewrote SEdge::From() to avoid confusing less-capable C++ compilers * Have oops() print a newline at the end of its message * Removed "static" keyword from the Bernstein() function definition, as it has a non-static prototype in srf/surface.h * Added casts (and changed a variable type) to quell warnings about integer size and signedness * Simplified an expression with our handy arraylen() macro
2013-09-19 14:35:56 +08:00
#define VERSION_STRING "\261\262\263" "SolveSpaceREVa"
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
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-27 02:58:35 +08:00
static int StrStartsWith(const char *str, const char *start) {
Save the exact surfaces in the exported file, and import and transform them for assembly. [git-p4: depot-paths = "//depot/solvespace/": change = 1954]
2009-05-19 15:26:38 +08:00
return memcmp(str, start, strlen(start)) == 0;
}
Fix a gross memory leak: when switching to a new file, either after File -> New or File -> Open, I freed the Group structures themselves, but none of their children. [git-p4: depot-paths = "//depot/solvespace/": change = 2120]
2010-03-01 03:23:01 +08:00
//-----------------------------------------------------------------------------
// Clear and free all the dynamic memory associated with our currently-loaded
// sketch. This does not leave the program in an acceptable state (with the
// references created, and so on), so anyone calling this must fix that later.
//-----------------------------------------------------------------------------
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 13:54:05 +08:00
void SolveSpaceUI::ClearExisting() {
Fix a gross memory leak: when switching to a new file, either after File -> New or File -> Open, I freed the Group structures themselves, but none of their children. [git-p4: depot-paths = "//depot/solvespace/": change = 2120]
2010-03-01 03:23:01 +08:00
UndoClearStack(&redo);
UndoClearStack(&undo);
Convert many loops to range-for or std algorithms. NFC. Also add comments about indexing and when we don't use range-for.
2018-01-04 09:42:38 +08:00
for(hGroup hg : SK.groupOrder) {
Group *g = SK.GetGroup(hg);
Fix a gross memory leak: when switching to a new file, either after File -> New or File -> Open, I freed the Group structures themselves, but none of their children. [git-p4: depot-paths = "//depot/solvespace/": change = 2120]
2010-03-01 03:23:01 +08:00
g->Clear();
}
SK.constraint.Clear();
SK.request.Clear();
SK.group.Clear();
Allow generating groups in arbitrary order.
2016-02-17 18:03:07 +08:00
SK.groupOrder.Clear();
Fix a gross memory leak: when switching to a new file, either after File -> New or File -> Open, I freed the Group structures themselves, but none of their children. [git-p4: depot-paths = "//depot/solvespace/": change = 2120]
2010-03-01 03:23:01 +08:00
SK.style.Clear();
SK.entity.Clear();
SK.param.Clear();
Implement an image request.
2016-11-30 00:49:20 +08:00
images.clear();
Fix a gross memory leak: when switching to a new file, either after File -> New or File -> Open, I freed the Group structures themselves, but none of their children. [git-p4: depot-paths = "//depot/solvespace/": change = 2120]
2010-03-01 03:23:01 +08: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 13:54:05 +08:00
hGroup SolveSpaceUI::CreateDefaultDrawingGroup() {
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 23:31:23 +08:00
Group g = {};
We now have selective solve; a group (and all the groups afterward) becomes dirty when the user makes a change, and only the dirty groups get solved. That's a huge effective speedup. Also add delete function for groups. That has an interesting issue; it actually ends up recursing on GenerateAll(), since GenerateAll() calls ClearSuper(), ClearSuper() might need to recreate a group (if all the groups were deleted), and that would activate the group, which calls GenerateAll. The right solution is probably a deferred execution mechanism, where you can schedule something to happen before we go idle, but not do it right now. [git-p4: depot-paths = "//depot/solvespace/": change = 1771]
2008-06-02 19:43:27 +08:00
// And an empty group, for the first stuff the user draws.
g.visible = true;
Internationalize all messages without substitutions.
2017-01-07 14:41:13 +08:00
g.name = C_("group-name", "sketch-in-plane");
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 16:31:20 +08:00
g.type = Group::Type::DRAWING_WORKPLANE;
g.subtype = Group::Subtype::WORKPLANE_BY_POINT_ORTHO;
Allow generating groups in arbitrary order.
2016-02-17 18:03:07 +08:00
g.order = 1;
We now have selective solve; a group (and all the groups afterward) becomes dirty when the user makes a change, and only the dirty groups get solved. That's a huge effective speedup. Also add delete function for groups. That has an interesting issue; it actually ends up recursing on GenerateAll(), since GenerateAll() calls ClearSuper(), ClearSuper() might need to recreate a group (if all the groups were deleted), and that would activate the group, which calls GenerateAll. The right solution is probably a deferred execution mechanism, where you can schedule something to happen before we go idle, but not do it right now. [git-p4: depot-paths = "//depot/solvespace/": change = 1771]
2008-06-02 19:43:27 +08:00
g.predef.q = Quaternion::From(1, 0, 0, 0);
hRequest hr = Request::HREQUEST_REFERENCE_XY;
g.predef.origin = hr.entity(1);
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 13:53:16 +08:00
SK.group.AddAndAssignId(&g);
SK.GetGroup(g.h)->activeWorkplane = g.h.entity(0);
We now have selective solve; a group (and all the groups afterward) becomes dirty when the user makes a change, and only the dirty groups get solved. That's a huge effective speedup. Also add delete function for groups. That has an interesting issue; it actually ends up recursing on GenerateAll(), since GenerateAll() calls ClearSuper(), ClearSuper() might need to recreate a group (if all the groups were deleted), and that would activate the group, which calls GenerateAll. The right solution is probably a deferred execution mechanism, where you can schedule something to happen before we go idle, but not do it right now. [git-p4: depot-paths = "//depot/solvespace/": change = 1771]
2008-06-02 19:43:27 +08:00
return g.h;
}
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 13:54:05 +08:00
void SolveSpaceUI::NewFile() {
Fix a gross memory leak: when switching to a new file, either after File -> New or File -> Open, I freed the Group structures themselves, but none of their children. [git-p4: depot-paths = "//depot/solvespace/": change = 2120]
2010-03-01 03:23:01 +08:00
ClearExisting();
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 14:22:16 +08:00
// Our initial group, that contains the references.
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 23:31:23 +08:00
Group g = {};
A ~10x speedup in the solver. Simplify equations before evaluating or taking partials (constant folding). Also keep a little hash table to mark with params are used in each equation, in order to quickly discard trivial partial derivatives. This is solving a 64x64 system in <20 ms. I suspect this is now much faster than Sketchflat. Slightly fake situation, though, since substitution solver has not yet been written, and no partitioning. I'll do those next. [git-p4: depot-paths = "//depot/solvespace/": change = 1698]
2008-04-30 12:52:34 +08:00
g.visible = true;
Internationalize all messages without substitutions.
2017-01-07 14:41:13 +08:00
g.name = C_("group-name", "#references");
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 16:31:20 +08:00
g.type = Group::Type::DRAWING_3D;
Allow generating groups in arbitrary order.
2016-02-17 18:03:07 +08:00
g.order = 0;
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 14:22:16 +08:00
g.h = Group::HGROUP_REFERENCES;
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 13:53:16 +08:00
SK.group.Add(&g);
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 14:22:16 +08:00
// Let's create three two-d coordinate systems, for the coordinate
// planes; these are our references, present in every sketch.
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 23:31:23 +08:00
Request 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 16:31:20 +08:00
r.type = Request::Type::WORKPLANE;
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 14:22:16 +08:00
r.group = Group::HGROUP_REFERENCES;
A great renaming. 2d coordinate systems are now called workplanes, and the associated entities are now just points. [git-p4: depot-paths = "//depot/solvespace/": change = 1690]
2008-04-27 11:26:27 +08:00
r.workplane = Entity::FREE_IN_3D;
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 14:22:16 +08:00
r.h = Request::HREQUEST_REFERENCE_XY;
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 13:53:16 +08:00
SK.request.Add(&r);
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 14:22:16 +08:00
r.h = Request::HREQUEST_REFERENCE_YZ;
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 13:53:16 +08:00
SK.request.Add(&r);
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 14:22:16 +08:00
r.h = Request::HREQUEST_REFERENCE_ZX;
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 13:53:16 +08:00
SK.request.Add(&r);
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 14:22:16 +08:00
We now have selective solve; a group (and all the groups afterward) becomes dirty when the user makes a change, and only the dirty groups get solved. That's a huge effective speedup. Also add delete function for groups. That has an interesting issue; it actually ends up recursing on GenerateAll(), since GenerateAll() calls ClearSuper(), ClearSuper() might need to recreate a group (if all the groups were deleted), and that would activate the group, which calls GenerateAll. The right solution is probably a deferred execution mechanism, where you can schedule something to happen before we go idle, but not do it right now. [git-p4: depot-paths = "//depot/solvespace/": change = 1771]
2008-06-02 19:43:27 +08:00
CreateDefaultDrawingGroup();
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 10:22:20 +08:00
}
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 14:22:16 +08:00
Pack everything into `namespace SolveSpace`. This is required to avoid name conflicts with the Cocoa libraries on OS X. I renamed the `class SolveSpace` to `class SolveSpaceUI`, because that's what it does, and because otherwise the namespace would have to be called something else than `namespace SolveSpace`.
2015-03-24 01:49:04 +08:00
const SolveSpaceUI::SaveTable SolveSpaceUI::SAVED[] = {
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 10:22:20 +08:00
{ 'g', "Group.h.v", 'x', &(SS.sv.g.h.v) },
{ 'g', "Group.type", 'd', &(SS.sv.g.type) },
Add code to evaluate the volume of a mesh, thanks to the divergence theorem; it's evaluated as a surface integral over each triangle. And don't regenerate the emphasized edges unless we have to; specifically, don't do it when the only dirty group is the drawing group. [git-p4: depot-paths = "//depot/solvespace/": change = 1849]
2008-02-07 17:53:52 +08:00
{ 'g', "Group.order", 'd', &(SS.sv.g.order) },
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 16:40:12 +08:00
{ 'g', "Group.name", 'S', &(SS.sv.g.name) },
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 10:22:20 +08:00
{ 'g', "Group.activeWorkplane.v", 'x', &(SS.sv.g.activeWorkplane.v) },
{ 'g', "Group.opA.v", 'x', &(SS.sv.g.opA.v) },
Add sweeps. The user specifies a trajectory and a section, in two separate groups. The section is swept normal to the trajectory, producing a mesh. I'm doing the triangles only now, not copying over any entities. Also fix a bug in the PNG export; rows are 4-aligned, so that was breaking when the width of the image wasn't divisible by four. Also fix a bug in lathes, where it generated overlapping triangles for one segment. And change the groups to record both "this mesh", the contribution due to the extrude/lathe/whatever, and the "running mesh", that we get after applying the requested Boolean op between "this mesh" and the previous group's "running mesh". I'll use that to make step and repeats step the mesh too. [git-p4: depot-paths = "//depot/solvespace/": change = 1801]
2008-06-21 18:18:20 +08:00
{ 'g', "Group.opB.v", 'x', &(SS.sv.g.opB.v) },
Don't keep a dimension or group's user-entered numerical value as an Expr *, since that complicates multiple units and also memory management. Now it's just a double. [git-p4: depot-paths = "//depot/solvespace/": change = 1791]
2008-06-14 16:43:38 +08:00
{ 'g', "Group.valA", 'f', &(SS.sv.g.valA) },
Add helical sweeps. These aren't as parametric as I would have liked, but my more parametric attempts were very difficult to use. The pitch (both axial and radial) gets specified by typing a distance in a textbox. [git-p4: depot-paths = "//depot/solvespace/": change = 1804]
2008-06-23 16:25:17 +08:00
{ 'g', "Group.valB", 'f', &(SS.sv.g.valB) },
{ 'g', "Group.valC", 'f', &(SS.sv.g.valB) },
Fix broken colors in file import/export. The move to RgbColor() missed the code that reads and writes Style.color and Group.color. Also clarify redefinition of RGB() in w32main.cpp.
2013-11-04 07:09:17 +08:00
{ 'g', "Group.color", 'c', &(SS.sv.g.color) },
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 10:22:20 +08:00
{ 'g', "Group.subtype", 'd', &(SS.sv.g.subtype) },
Bits and pieces; option to not include original in step translates and rotates, auto-constrain translates in active workplane, speed up remap list search with a hash table, other stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 1786]
2008-06-12 12:36:33 +08:00
{ 'g', "Group.skipFirst", 'b', &(SS.sv.g.skipFirst) },
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 10:22:20 +08:00
{ 'g', "Group.meshCombine", 'd', &(SS.sv.g.meshCombine) },
Add a separate display mesh and edge list; so if we're working with a mesh than that's a copy, and if we're working with a shell then it's the shell's triangulation. [git-p4: depot-paths = "//depot/solvespace/": change = 1957]
2009-05-21 17:06:26 +08:00
{ 'g', "Group.forceToMesh", 'd', &(SS.sv.g.forceToMesh) },
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 16:29:59 +08:00
{ 'g', "Group.predef.q.w", 'f', &(SS.sv.g.predef.q.w) },
{ 'g', "Group.predef.q.vx", 'f', &(SS.sv.g.predef.q.vx) },
{ 'g', "Group.predef.q.vy", 'f', &(SS.sv.g.predef.q.vy) },
{ 'g', "Group.predef.q.vz", 'f', &(SS.sv.g.predef.q.vz) },
{ 'g', "Group.predef.origin.v", 'x', &(SS.sv.g.predef.origin.v) },
{ 'g', "Group.predef.entityB.v", 'x', &(SS.sv.g.predef.entityB.v) },
{ 'g', "Group.predef.entityC.v", 'x', &(SS.sv.g.predef.entityC.v) },
{ 'g', "Group.predef.swapUV", 'b', &(SS.sv.g.predef.swapUV) },
{ 'g', "Group.predef.negateU", 'b', &(SS.sv.g.predef.negateU) },
{ 'g', "Group.predef.negateV", 'b', &(SS.sv.g.predef.negateV) },
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 10:22:20 +08:00
{ 'g', "Group.visible", 'b', &(SS.sv.g.visible) },
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 19:35:15 +08:00
{ 'g', "Group.suppress", 'b', &(SS.sv.g.suppress) },
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 19:22:56 +08:00
{ 'g', "Group.relaxConstraints", 'b', &(SS.sv.g.relaxConstraints) },
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 23:01:43 +08:00
{ 'g', "Group.allowRedundant", 'b', &(SS.sv.g.allowRedundant) },
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 09:06:09 +08:00
{ 'g', "Group.allDimsReference", 'b', &(SS.sv.g.allDimsReference) },
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 20:26:22 +08:00
{ 'g', "Group.scale", 'f', &(SS.sv.g.scale) },
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 10:22:20 +08:00
{ 'g', "Group.remap", 'M', &(SS.sv.g.remap) },
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 22:43:21 +08:00
{ 'g', "Group.impFile", 'i', NULL },
{ 'g', "Group.impFileRel", 'P', &(SS.sv.g.linkFile) },
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 10:22:20 +08:00
{ 'p', "Param.h.v.", 'x', &(SS.sv.p.h.v) },
{ 'p', "Param.val", 'f', &(SS.sv.p.val) },
{ 'r', "Request.h.v", 'x', &(SS.sv.r.h.v) },
{ 'r', "Request.type", 'd', &(SS.sv.r.type) },
Add interpolating splines: both periodic splines (that form a loop), and open-ended splines, with their tangents specified at their endpoints. Also change constraint solver matrix size to 1024, on the theory that a power of two will generate better array indexing, and replace fabs() with my own function that for some reason is faster. [git-p4: depot-paths = "//depot/solvespace/": change = 2055]
2009-10-21 12:46:01 +08:00
{ 'r', "Request.extraPoints", 'd', &(SS.sv.r.extraPoints) },
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 10:22:20 +08:00
{ 'r', "Request.workplane.v", 'x', &(SS.sv.r.workplane.v) },
{ 'r', "Request.group.v", 'x', &(SS.sv.r.group.v) },
{ 'r', "Request.construction", 'b', &(SS.sv.r.construction) },
Change how step and repeat works: now I build the union of all the steps in thisShell or thisMesh, and then let the Boolean proceed as usual. If everything works, then this is equivalent. And it's less code, and it makes stuff like stepping the step and repeat work. Also begin to work on line/entity/constraint styles, but no real work yet. [git-p4: depot-paths = "//depot/solvespace/": change = 2018]
2009-07-20 09:47:59 +08:00
{ 'r', "Request.style", 'x', &(SS.sv.r.style) },
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 16:40:12 +08:00
{ 'r', "Request.str", 'S', &(SS.sv.r.str) },
{ 'r', "Request.font", 'S', &(SS.sv.r.font) },
Implement an image request.
2016-11-30 00:49:20 +08:00
{ 'r', "Request.file", 'P', &(SS.sv.r.file) },
Add two more points to the TTF text request. These points can be used for constraining the width of the text (or to the width of the text). The main parts of the commit are: * TtfFont is restructured to be able to return the aspect ratio for a given string. * This aspect ratio is written to the savefile, such that even if the font is missing, the sketch would still be solved correctly. * The two additional points are constrained via perpendicularly to the two main points (which form a v vector). The compatibility features are as follows: * When the font is missing in old files, 1:1 aspect ratio is used, which works for the replacement symbol anyhow. * When the two additional points are missing in old files, their would-be positions are calculated and they are moved there, avoiding 'jumping' of underconstrained sketches.
2016-10-11 09:58:04 +08:00
{ 'r', "Request.aspectRatio", 'f', &(SS.sv.r.aspectRatio) },
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 10:22:20 +08:00
{ 'e', "Entity.h.v", 'x', &(SS.sv.e.h.v) },
{ 'e', "Entity.type", 'd', &(SS.sv.e.type) },
{ 'e', "Entity.construction", 'b', &(SS.sv.e.construction) },
Change how step and repeat works: now I build the union of all the steps in thisShell or thisMesh, and then let the Boolean proceed as usual. If everything works, then this is equivalent. And it's less code, and it makes stuff like stepping the step and repeat work. Also begin to work on line/entity/constraint styles, but no real work yet. [git-p4: depot-paths = "//depot/solvespace/": change = 2018]
2009-07-20 09:47:59 +08:00
{ 'e', "Entity.style", 'x', &(SS.sv.e.style) },
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 16:40:12 +08:00
{ 'e', "Entity.str", 'S', &(SS.sv.e.str) },
{ 'e', "Entity.font", 'S', &(SS.sv.e.font) },
Implement an image request.
2016-11-30 00:49:20 +08:00
{ 'e', "Entity.file", 'P', &(SS.sv.e.file) },
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 10:22:20 +08:00
{ 'e', "Entity.point[0].v", 'x', &(SS.sv.e.point[0].v) },
{ 'e', "Entity.point[1].v", 'x', &(SS.sv.e.point[1].v) },
{ 'e', "Entity.point[2].v", 'x', &(SS.sv.e.point[2].v) },
{ 'e', "Entity.point[3].v", 'x', &(SS.sv.e.point[3].v) },
Add interpolating splines: both periodic splines (that form a loop), and open-ended splines, with their tangents specified at their endpoints. Also change constraint solver matrix size to 1024, on the theory that a power of two will generate better array indexing, and replace fabs() with my own function that for some reason is faster. [git-p4: depot-paths = "//depot/solvespace/": change = 2055]
2009-10-21 12:46:01 +08:00
{ 'e', "Entity.point[4].v", 'x', &(SS.sv.e.point[4].v) },
{ 'e', "Entity.point[5].v", 'x', &(SS.sv.e.point[5].v) },
{ 'e', "Entity.point[6].v", 'x', &(SS.sv.e.point[6].v) },
{ 'e', "Entity.point[7].v", 'x', &(SS.sv.e.point[7].v) },
{ 'e', "Entity.point[8].v", 'x', &(SS.sv.e.point[8].v) },
{ 'e', "Entity.point[9].v", 'x', &(SS.sv.e.point[9].v) },
{ 'e', "Entity.point[10].v", 'x', &(SS.sv.e.point[10].v) },
{ 'e', "Entity.point[11].v", 'x', &(SS.sv.e.point[11].v) },
{ 'e', "Entity.extraPoints", 'd', &(SS.sv.e.extraPoints) },
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 10:22:20 +08:00
{ 'e', "Entity.normal.v", 'x', &(SS.sv.e.normal.v) },
{ 'e', "Entity.distance.v", 'x', &(SS.sv.e.distance.v) },
{ 'e', "Entity.workplane.v", 'x', &(SS.sv.e.workplane.v) },
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
{ 'e', "Entity.actPoint.x", 'f', &(SS.sv.e.actPoint.x) },
{ 'e', "Entity.actPoint.y", 'f', &(SS.sv.e.actPoint.y) },
{ 'e', "Entity.actPoint.z", 'f', &(SS.sv.e.actPoint.z) },
{ 'e', "Entity.actNormal.w", 'f', &(SS.sv.e.actNormal.w) },
{ 'e', "Entity.actNormal.vx", 'f', &(SS.sv.e.actNormal.vx) },
{ 'e', "Entity.actNormal.vy", 'f', &(SS.sv.e.actNormal.vy) },
{ 'e', "Entity.actNormal.vz", 'f', &(SS.sv.e.actNormal.vz) },
{ 'e', "Entity.actDistance", 'f', &(SS.sv.e.actDistance) },
Bits and pieces; option to not include original in step translates and rotates, auto-constrain translates in active workplane, speed up remap list search with a hash table, other stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 1786]
2008-06-12 12:36:33 +08:00
{ 'e', "Entity.actVisible", 'b', &(SS.sv.e.actVisible), },
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 10:22:20 +08:00
{ 'c', "Constraint.h.v", 'x', &(SS.sv.c.h.v) },
{ 'c', "Constraint.type", 'd', &(SS.sv.c.type) },
{ 'c', "Constraint.group.v", 'x', &(SS.sv.c.group.v) },
{ 'c', "Constraint.workplane.v", 'x', &(SS.sv.c.workplane.v) },
Don't keep a dimension or group's user-entered numerical value as an Expr *, since that complicates multiple units and also memory management. Now it's just a double. [git-p4: depot-paths = "//depot/solvespace/": change = 1791]
2008-06-14 16:43:38 +08:00
{ 'c', "Constraint.valA", 'f', &(SS.sv.c.valA) },
Explicitly represent the parameter used in constraints. Commit f5485cb and its ancestors add a parameter to some constraints. This parameter must be materialized and assigned a non-zero value via ModifyToSatisfy for the solver library to not make unnecessary changes to the sketch during the initial generation. For this, we represent it explicitly instead of using hc.param(0), such that the materialized constraint does not conflict with any user-defined ones.
2017-01-26 00:39:26 +08:00
{ 'c', "Constraint.valP.v", 'x', &(SS.sv.c.valP.v) },
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 10:22:20 +08:00
{ 'c', "Constraint.ptA.v", 'x', &(SS.sv.c.ptA.v) },
{ 'c', "Constraint.ptB.v", 'x', &(SS.sv.c.ptB.v) },
{ 'c', "Constraint.entityA.v", 'x', &(SS.sv.c.entityA.v) },
{ 'c', "Constraint.entityB.v", 'x', &(SS.sv.c.entityB.v) },
Add equal-angle constraints. These are implemented by brute force, as the difference between the cosines of the two angles. All of the angle stuff generates huge expressions (Expr *), but doesn't seem noticeably slow. [git-p4: depot-paths = "//depot/solvespace/": change = 1847]
2008-07-20 20:24:43 +08:00
{ 'c', "Constraint.entityC.v", 'x', &(SS.sv.c.entityC.v) },
{ 'c', "Constraint.entityD.v", 'x', &(SS.sv.c.entityD.v) },
Add tangency constraints, for line segments against arcs or cubics. These are just a convenience, since it would be possible to get the same result by drawing a construction line. [git-p4: depot-paths = "//depot/solvespace/": change = 1836]
2008-07-13 20:44:05 +08:00
{ 'c', "Constraint.other", 'b', &(SS.sv.c.other) },
Add a constraint for tangency between any combination of arcs and cubics. Also add that to the library interface. It might have been better to use a single constraint for that, plus all the line-curve or line-line cases, but it would break backwards compatibility if I did that now, and perhaps be confusing with the 'other' member (which is meaningless for lines) anyways. [git-p4: depot-paths = "//depot/solvespace/": change = 2141]
2010-05-10 12:14:06 +08:00
{ 'c', "Constraint.other2", 'b', &(SS.sv.c.other2) },
Add reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 12:22:52 +08:00
{ 'c', "Constraint.reference", 'b', &(SS.sv.c.reference) },
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 16:40:12 +08:00
{ 'c', "Constraint.comment", 'S', &(SS.sv.c.comment) },
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 10:22:20 +08:00
{ 'c', "Constraint.disp.offset.x", 'f', &(SS.sv.c.disp.offset.x) },
{ 'c', "Constraint.disp.offset.y", 'f', &(SS.sv.c.disp.offset.y) },
{ 'c', "Constraint.disp.offset.z", 'f', &(SS.sv.c.disp.offset.z) },
Change how step and repeat works: now I build the union of all the steps in thisShell or thisMesh, and then let the Boolean proceed as usual. If everything works, then this is equivalent. And it's less code, and it makes stuff like stepping the step and repeat work. Also begin to work on line/entity/constraint styles, but no real work yet. [git-p4: depot-paths = "//depot/solvespace/": change = 2018]
2009-07-20 09:47:59 +08:00
{ 'c', "Constraint.disp.style", 'x', &(SS.sv.c.disp.style) },
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 10:22:20 +08:00
Move colors and line widths for almost everything to the styles mechanism. This gets filled in from some defaults, and stored in the registry. The default styles do not get saved in the file, but user-created styles (which aren't supported yet) do. [git-p4: depot-paths = "//depot/solvespace/": change = 2028]
2009-09-17 15:32:36 +08:00
{ 's', "Style.h.v", 'x', &(SS.sv.s.h.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 16:40:12 +08:00
{ 's', "Style.name", 'S', &(SS.sv.s.name) },
Move colors and line widths for almost everything to the styles mechanism. This gets filled in from some defaults, and stored in the registry. The default styles do not get saved in the file, but user-created styles (which aren't supported yet) do. [git-p4: depot-paths = "//depot/solvespace/": change = 2028]
2009-09-17 15:32:36 +08:00
{ 's', "Style.width", 'f', &(SS.sv.s.width) },
Add ability to assign styles to cosmetic text (in the form of Constraint::COMMENTs), including line width and color, and text height and origin location. [git-p4: depot-paths = "//depot/solvespace/": change = 2033]
2009-09-24 23:52:48 +08:00
{ 's', "Style.widthAs", 'd', &(SS.sv.s.widthAs) },
{ 's', "Style.textHeight", 'f', &(SS.sv.s.textHeight) },
{ 's', "Style.textHeightAs", 'd', &(SS.sv.s.textHeightAs) },
Add text angle for styles. Add ability to quickly change between perspective and parallel projections. Add a snap grid, for points and for text comments. Draw text comments in the plane of their workplane if they have one, otherwise always facing forward. And fix a few nasty bugs: the possibility of an extremely long animation onto a workplane, accidental use of the wrong style line width for constraints, misplaced text box in style screen for default styles, other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 2037]
2009-09-29 19:35:19 +08:00
{ 's', "Style.textAngle", 'f', &(SS.sv.s.textAngle) },
Add ability to assign styles to cosmetic text (in the form of Constraint::COMMENTs), including line width and color, and text height and origin location. [git-p4: depot-paths = "//depot/solvespace/": change = 2033]
2009-09-24 23:52:48 +08:00
{ 's', "Style.textOrigin", 'x', &(SS.sv.s.textOrigin) },
Fix broken colors in file import/export. The move to RgbColor() missed the code that reads and writes Style.color and Group.color. Also clarify redefinition of RGB() in w32main.cpp.
2013-11-04 07:09:17 +08:00
{ 's', "Style.color", 'c', &(SS.sv.s.color) },
Oops, fix Style.fillColor export/import too.
2013-11-04 07:41:11 +08:00
{ 's', "Style.fillColor", 'c', &(SS.sv.s.fillColor) },
Move code to find outer and inner contours (and which inner contours go with which outer contour) out of exportstep.cpp, since I'll need that to do filled contour export for the 2d file formats. Also add user interface to specify fill color. [git-p4: depot-paths = "//depot/solvespace/": change = 2057]
2009-10-23 01:16:20 +08:00
{ 's', "Style.filled", 'b', &(SS.sv.s.filled) },
Move colors and line widths for almost everything to the styles mechanism. This gets filled in from some defaults, and stored in the registry. The default styles do not get saved in the file, but user-created styles (which aren't supported yet) do. [git-p4: depot-paths = "//depot/solvespace/": change = 2028]
2009-09-17 15:32:36 +08:00
{ 's', "Style.visible", 'b', &(SS.sv.s.visible) },
{ 's', "Style.exportable", 'b', &(SS.sv.s.exportable) },
Implement stippled line styles from ISO 128. Now it's possible to use a styled line to indicate e.g. a centerline.
2016-02-24 02:00:39 +08:00
{ 's', "Style.stippleType", 'd', &(SS.sv.s.stippleType) },
{ 's', "Style.stippleScale", 'f', &(SS.sv.s.stippleScale) },
Move colors and line widths for almost everything to the styles mechanism. This gets filled in from some defaults, and stored in the registry. The default styles do not get saved in the file, but user-created styles (which aren't supported yet) do. [git-p4: depot-paths = "//depot/solvespace/": change = 2028]
2009-09-17 15:32:36 +08:00
General compiler warning/error fixes This addresses a grab bag of compiler grievances relating to C++ syntax, type, and scope, as observed on Linux with g++ and Solaris with Sun WorkShop 6.
2013-08-27 04:54:04 +08:00
{ 0, NULL, 0, NULL }
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 14:22:16 +08:00
};
Rework SAVEDptr to be a struct with accessors instead of an union. It's not possible to put non-POD elements in a union, and a struct with accessors is a more elegant solution than a union with POD elements and explicit casts for the rest.
2016-01-15 20:30:53 +08:00
struct SAVEDptr {
Replace entity map implementation with std::unordered_map. On a single load benchmark this provides about 25% speedup.
2019-05-25 01:54:02 +08:00
EntityMap &M() { return *((EntityMap *)this); }
std::string &S() { return *((std::string *)this); }
Platform::Path &P() { return *((Platform::Path *)this); }
Rework SAVEDptr to be a struct with accessors instead of an union. It's not possible to put non-POD elements in a union, and a struct with accessors is a more elegant solution than a union with POD elements and explicit casts for the rest.
2016-01-15 20:30:53 +08:00
bool &b() { return *((bool *)this); }
RgbaColor &c() { return *((RgbaColor *)this); }
int &d() { return *((int *)this); }
double &f() { return *((double *)this); }
uint32_t &x() { return *((uint32_t *)this); }
Use a union for pointer polymorphism in the .slvs file I/O routines The .slvs file I/O code was using "*((type *)pointer) = value" type-punning dereferences, which are syntactically unwieldy and prone to annoying modern compilers. A union pointer is more elegant, and better expresses the polymorphism at issue.
2013-11-13 13:46:40 +08:00
};
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 22:43:21 +08:00
void SolveSpaceUI::SaveUsingTable(const Platform::Path &filename, int type) {
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 14:22:16 +08:00
int i;
for(i = 0; SAVED[i].type != 0; i++) {
if(SAVED[i].type != type) continue;
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
int fmt = SAVED[i].fmt;
Rework SAVEDptr to be a struct with accessors instead of an union. It's not possible to put non-POD elements in a union, and a struct with accessors is a more elegant solution than a union with POD elements and explicit casts for the rest.
2016-01-15 20:30:53 +08:00
SAVEDptr *p = (SAVEDptr *)SAVED[i].ptr;
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
// Any items that aren't specified are assumed to be zero
Rework SAVEDptr to be a struct with accessors instead of an union. It's not possible to put non-POD elements in a union, and a struct with accessors is a more elegant solution than a union with POD elements and explicit casts for the rest.
2016-01-15 20:30:53 +08:00
if(fmt == 'S' && p->S().empty()) continue;
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 22:43:21 +08:00
if(fmt == 'P' && p->P().IsEmpty()) continue;
Rework SAVEDptr to be a struct with accessors instead of an union. It's not possible to put non-POD elements in a union, and a struct with accessors is a more elegant solution than a union with POD elements and explicit casts for the rest.
2016-01-15 20:30:53 +08:00
if(fmt == 'd' && p->d() == 0) continue;
if(fmt == 'f' && EXACT(p->f() == 0.0)) continue;
if(fmt == 'x' && p->x() == 0) continue;
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 22:43:21 +08:00
if(fmt == 'i') continue;
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
fprintf(fh, "%s=", SAVED[i].desc);
switch(fmt) {
Rework SAVEDptr to be a struct with accessors instead of an union. It's not possible to put non-POD elements in a union, and a struct with accessors is a more elegant solution than a union with POD elements and explicit casts for the rest.
2016-01-15 20:30:53 +08:00
case 'S': fprintf(fh, "%s", p->S().c_str()); break;
case 'b': fprintf(fh, "%d", p->b() ? 1 : 0); break;
case 'c': fprintf(fh, "%08x", p->c().ToPackedInt()); break;
case 'd': fprintf(fh, "%d", p->d()); break;
case 'f': fprintf(fh, "%.20f", p->f()); break;
case 'x': fprintf(fh, "%08x", p->x()); break;
Include the remap lists (when we copy entities, that we used to assign the new ids) in the saved file, and split the file load from table stuff into its own function. [git-p4: depot-paths = "//depot/solvespace/": change = 1694]
2008-04-27 18:01:23 +08:00
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 22:43:21 +08:00
case 'P': {
if(!p->P().IsEmpty()) {
Platform::Path relativePath = p->P().RelativeTo(filename.Parent());
ssassert(!relativePath.IsEmpty(), "Cannot relativize path");
fprintf(fh, "%s", relativePath.ToPortable().c_str());
}
break;
}
Include the remap lists (when we copy entities, that we used to assign the new ids) in the saved file, and split the file load from table stuff into its own function. [git-p4: depot-paths = "//depot/solvespace/": change = 1694]
2008-04-27 18:01:23 +08:00
case 'M': {
fprintf(fh, "{\n");
Replace entity map implementation with std::unordered_map. On a single load benchmark this provides about 25% speedup.
2019-05-25 01:54:02 +08:00
// Sort the mapping, since EntityMap is not deterministic.
std::vector<std::pair<EntityKey, EntityId>> sorted(p->M().begin(), p->M().end());
std::sort(sorted.begin(), sorted.end(),
[](std::pair<EntityKey, EntityId> &a, std::pair<EntityKey, EntityId> &b) {
return a.second.v < b.second.v;
});
for(auto it : sorted) {
Trim trailing whitespace.
2015-03-29 08:30:52 +08:00
fprintf(fh, " %d %08x %d\n",
Replace entity map implementation with std::unordered_map. On a single load benchmark this provides about 25% speedup.
2019-05-25 01:54:02 +08:00
it.second.v, it.first.input.v, it.first.copyNumber);
Include the remap lists (when we copy entities, that we used to assign the new ids) in the saved file, and split the file load from table stuff into its own function. [git-p4: depot-paths = "//depot/solvespace/": change = 1694]
2008-04-27 18:01:23 +08:00
}
fprintf(fh, "}");
break;
}
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 22:43:21 +08:00
case 'i': break;
Replace all oops() checks with ssassert()s. This includes explanation and context for non-obvious cases and shortens debug cycles when just-in-time debugging is not available (like on Linux) by immediately printing description of the assert as well as symbolized backtrace.
2016-05-19 06:51:36 +08:00
default: ssassert(false, "Unexpected value format");
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 14:22:16 +08:00
}
fprintf(fh, "\n");
}
}
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 22:43:21 +08:00
bool SolveSpaceUI::SaveToFile(const Platform::Path &filename) {
// Make sure all the entities are regenerated up to date, since they will be exported.
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-19 01:02:11 +08:00
SS.ScheduleShowTW();
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 16:31:20 +08:00
SS.GenerateAll(SolveSpaceUI::Generate::ALL);
Treatment of numerical faces was screwy, exporting stuff in numXXX. So fix that, and now I can simplify what's exported for an entity. And add an extra measurement (face-face distance/angle), and some other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 1789]
2008-06-13 12:41:27 +08:00
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 22:43:21 +08:00
for(Group &g : SK.group) {
if(g.type != Group::Type::LINKED) continue;
if(g.linkFile.RelativeTo(filename).IsEmpty()) {
Error("This sketch links the sketch '%s'; it can only be saved "
"on the same volume.", g.linkFile.raw.c_str());
return false;
}
}
fh = OpenFile(filename, "wb");
Trim trailing whitespace.
2015-03-29 08:30:52 +08:00
if(!fh) {
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 22:43:21 +08:00
Error("Couldn't write to file '%s'", filename.raw.c_str());
Rename some stuff in the IdList again. Rough in the file save stuff, though no file load stuff, and perhaps this can all be made to work from a table somehow. Move the quaternion stuff into its own class, and add a fancy animated view when you orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1672]
2008-04-18 19:11:48 +08:00
return false;
}
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
fprintf(fh, "%s\n\n\n", VERSION_STRING);
Rename some stuff in the IdList again. Rough in the file save stuff, though no file load stuff, and perhaps this can all be made to work from a table somehow. Move the quaternion stuff into its own class, and add a fancy animated view when you orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1672]
2008-04-18 19:11:48 +08:00
Save the exact surfaces in the exported file, and import and transform them for assembly. [git-p4: depot-paths = "//depot/solvespace/": change = 1954]
2009-05-19 15:26:38 +08:00
int i, j;
Convert many loops to range-for or std algorithms. NFC. Also add comments about indexing and when we don't use range-for.
2018-01-04 09:42:38 +08:00
for(auto &g : SK.group) {
sv.g = g;
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 22:43:21 +08:00
SaveUsingTable(filename, 'g');
Rename some stuff in the IdList again. Rough in the file save stuff, though no file load stuff, and perhaps this can all be made to work from a table somehow. Move the quaternion stuff into its own class, and add a fancy animated view when you orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1672]
2008-04-18 19:11:48 +08:00
fprintf(fh, "AddGroup\n\n");
}
Convert many loops to range-for or std algorithms. NFC. Also add comments about indexing and when we don't use range-for.
2018-01-04 09:42:38 +08:00
for(auto &p : SK.param) {
sv.p = p;
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 22:43:21 +08:00
SaveUsingTable(filename, 'p');
Rename some stuff in the IdList again. Rough in the file save stuff, though no file load stuff, and perhaps this can all be made to work from a table somehow. Move the quaternion stuff into its own class, and add a fancy animated view when you orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1672]
2008-04-18 19:11:48 +08:00
fprintf(fh, "AddParam\n\n");
}
Convert many loops to range-for or std algorithms. NFC. Also add comments about indexing and when we don't use range-for.
2018-01-04 09:42:38 +08:00
for(auto &r : SK.request) {
sv.r = r;
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 22:43:21 +08:00
SaveUsingTable(filename, 'r');
Rename some stuff in the IdList again. Rough in the file save stuff, though no file load stuff, and perhaps this can all be made to work from a table somehow. Move the quaternion stuff into its own class, and add a fancy animated view when you orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1672]
2008-04-18 19:11:48 +08:00
fprintf(fh, "AddRequest\n\n");
}
Convert many loops to range-for or std algorithms. NFC. Also add comments about indexing and when we don't use range-for.
2018-01-04 09:42:38 +08:00
for(auto &e : SK.entity) {
e.CalculateNumerical(/*forExport=*/true);
sv.e = e;
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 22:43:21 +08:00
SaveUsingTable(filename, 'e');
Rename some stuff in the IdList again. Rough in the file save stuff, though no file load stuff, and perhaps this can all be made to work from a table somehow. Move the quaternion stuff into its own class, and add a fancy animated view when you orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1672]
2008-04-18 19:11:48 +08:00
fprintf(fh, "AddEntity\n\n");
}
Convert many loops to range-for or std algorithms. NFC. Also add comments about indexing and when we don't use range-for.
2018-01-04 09:42:38 +08:00
for(auto &c : SK.constraint) {
sv.c = c;
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 22:43:21 +08:00
SaveUsingTable(filename, 'c');
Rename some stuff in the IdList again. Rough in the file save stuff, though no file load stuff, and perhaps this can all be made to work from a table somehow. Move the quaternion stuff into its own class, and add a fancy animated view when you orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1672]
2008-04-18 19:11:48 +08:00
fprintf(fh, "AddConstraint\n\n");
}
Convert many loops to range-for or std algorithms. NFC. Also add comments about indexing and when we don't use range-for.
2018-01-04 09:42:38 +08:00
for(auto &s : SK.style) {
sv.s = s;
Move colors and line widths for almost everything to the styles mechanism. This gets filled in from some defaults, and stored in the registry. The default styles do not get saved in the file, but user-created styles (which aren't supported yet) do. [git-p4: depot-paths = "//depot/solvespace/": change = 2028]
2009-09-17 15:32:36 +08:00
if(sv.s.h.v >= Style::FIRST_CUSTOM) {
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 22:43:21 +08:00
SaveUsingTable(filename, 's');
Move colors and line widths for almost everything to the styles mechanism. This gets filled in from some defaults, and stored in the registry. The default styles do not get saved in the file, but user-created styles (which aren't supported yet) do. [git-p4: depot-paths = "//depot/solvespace/": change = 2028]
2009-09-17 15:32:36 +08:00
fprintf(fh, "AddStyle\n\n");
}
}
Add a separate display mesh and edge list; so if we're working with a mesh than that's a copy, and if we're working with a shell then it's the shell's triangulation. [git-p4: depot-paths = "//depot/solvespace/": change = 1957]
2009-05-21 17:06:26 +08:00
// A group will have either a mesh or a shell, but not both; but the code
// to print either of those just does nothing if the mesh/shell is empty.
Add and use List::Last(). NFC.
2019-08-20 23:43:39 +08:00
Group *g = SK.GetGroup(*SK.groupOrder.Last());
Allow generating groups in arbitrary order.
2016-02-17 18:03:07 +08:00
SMesh *m = &g->runningMesh;
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
for(i = 0; i < m->l.n; i++) {
Improve implementation hiding in IdList/List. NFC. Allows distancing users from the internal "elem" member. Add Get() and operator[]. Replace direct references to elem. Make elem and elemsAllocated private in IdList/List.
2019-05-24 01:09:47 +08:00
STriangle *tr = &(m->l[i]);
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 18:30:12 +08:00
fprintf(fh, "Triangle %08x %08x "
Add an interference check for assembled parts. That's easy once the BSP stuff works. The failures are reported with red stripes and no depth buffering, and in a message in the text window. Also improve convergence of point-on-line constraints, and don't write triangles to export files with limited precision, because that was making the coplanar tests fail. [git-p4: depot-paths = "//depot/solvespace/": change = 1774]
2008-06-04 14:39:32 +08:00
"%.20f %.20f %.20f %.20f %.20f %.20f %.20f %.20f %.20f\n",
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-17 04:00:58 +08:00
tr->meta.face, tr->meta.color.ToPackedInt(),
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
CO(tr->a), CO(tr->b), CO(tr->c));
}
Allow generating groups in arbitrary order.
2016-02-17 18:03:07 +08:00
SShell *s = &g->runningShell;
Save the exact surfaces in the exported file, and import and transform them for assembly. [git-p4: depot-paths = "//depot/solvespace/": change = 1954]
2009-05-19 15:26:38 +08:00
SSurface *srf;
for(srf = s->surface.First(); srf; srf = s->surface.NextAfter(srf)) {
fprintf(fh, "Surface %08x %08x %08x %d %d\n",
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-17 04:00:58 +08:00
srf->h.v, srf->color.ToPackedInt(), srf->face, srf->degm, srf->degn);
Save the exact surfaces in the exported file, and import and transform them for assembly. [git-p4: depot-paths = "//depot/solvespace/": change = 1954]
2009-05-19 15:26:38 +08:00
for(i = 0; i <= srf->degm; i++) {
for(j = 0; j <= srf->degn; j++) {
fprintf(fh, "SCtrl %d %d %.20f %.20f %.20f Weight %20.20f\n",
i, j, CO(srf->ctrl[i][j]), srf->weight[i][j]);
}
}
Trim trailing whitespace.
2015-03-29 08:30:52 +08:00
Save the exact surfaces in the exported file, and import and transform them for assembly. [git-p4: depot-paths = "//depot/solvespace/": change = 1954]
2009-05-19 15:26:38 +08:00
STrimBy *stb;
for(stb = srf->trim.First(); stb; stb = srf->trim.NextAfter(stb)) {
fprintf(fh, "TrimBy %08x %d %.20f %.20f %.20f %.20f %.20f %.20f\n",
stb->curve.v, stb->backwards ? 1 : 0,
CO(stb->start), CO(stb->finish));
}
fprintf(fh, "AddSurface\n");
}
SCurve *sc;
for(sc = s->curve.First(); sc; sc = s->curve.NextAfter(sc)) {
fprintf(fh, "Curve %08x %d %d %08x %08x\n",
sc->h.v,
sc->isExact ? 1 : 0, sc->exact.deg,
sc->surfA.v, sc->surfB.v);
if(sc->isExact) {
for(i = 0; i <= sc->exact.deg; i++) {
fprintf(fh, "CCtrl %d %.20f %.20f %.20f Weight %.20f\n",
i, CO(sc->exact.ctrl[i]), sc->exact.weight[i]);
}
}
SCurvePt *scpt;
for(scpt = sc->pts.First(); scpt; scpt = sc->pts.NextAfter(scpt)) {
fprintf(fh, "CurvePt %d %.20f %.20f %.20f\n",
scpt->vertex ? 1 : 0, CO(scpt->p));
}
fprintf(fh, "AddCurve\n");
}
Rename some stuff in the IdList again. Rough in the file save stuff, though no file load stuff, and perhaps this can all be made to work from a table somehow. Move the quaternion stuff into its own class, and add a fancy animated view when you orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1672]
2008-04-18 19:11:48 +08:00
fclose(fh);
return true;
}
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 22:43:21 +08:00
void SolveSpaceUI::LoadUsingTable(const Platform::Path &filename, char *key, char *val) {
Include the remap lists (when we copy entities, that we used to assign the new ids) in the saved file, and split the file load from table stuff into its own function. [git-p4: depot-paths = "//depot/solvespace/": change = 1694]
2008-04-27 18:01:23 +08:00
int i;
for(i = 0; SAVED[i].type != 0; i++) {
if(strcmp(SAVED[i].desc, key)==0) {
Rework SAVEDptr to be a struct with accessors instead of an union. It's not possible to put non-POD elements in a union, and a struct with accessors is a more elegant solution than a union with POD elements and explicit casts for the rest.
2016-01-15 20:30:53 +08:00
SAVEDptr *p = (SAVEDptr *)SAVED[i].ptr;
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 13:45:13 +08:00
unsigned int u = 0;
Include the remap lists (when we copy entities, that we used to assign the new ids) in the saved file, and split the file load from table stuff into its own function. [git-p4: depot-paths = "//depot/solvespace/": change = 1694]
2008-04-27 18:01:23 +08:00
switch(SAVED[i].fmt) {
Rework SAVEDptr to be a struct with accessors instead of an union. It's not possible to put non-POD elements in a union, and a struct with accessors is a more elegant solution than a union with POD elements and explicit casts for the rest.
2016-01-15 20:30:53 +08:00
case 'S': p->S() = val; break;
case 'b': p->b() = (atoi(val) != 0); break;
case 'd': p->d() = atoi(val); break;
case 'f': p->f() = atof(val); break;
case 'x': sscanf(val, "%x", &u); p->x()= u; break;
Include the remap lists (when we copy entities, that we used to assign the new ids) in the saved file, and split the file load from table stuff into its own function. [git-p4: depot-paths = "//depot/solvespace/": change = 1694]
2008-04-27 18:01:23 +08:00
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 22:43:21 +08:00
case 'P': {
Implement an image request.
2016-11-30 00:49:20 +08:00
Platform::Path path = Platform::Path::FromPortable(val);
if(!path.IsEmpty()) {
p->P() = filename.Parent().Join(path).Expand();
}
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 22:43:21 +08:00
break;
}
Fix broken colors in file import/export. The move to RgbColor() missed the code that reads and writes Style.color and Group.color. Also clarify redefinition of RGB() in w32main.cpp.
2013-11-04 07:09:17 +08:00
case 'c':
sscanf(val, "%x", &u);
Rework SAVEDptr to be a struct with accessors instead of an union. It's not possible to put non-POD elements in a union, and a struct with accessors is a more elegant solution than a union with POD elements and explicit casts for the rest.
2016-01-15 20:30:53 +08:00
p->c() = RgbaColor::FromPackedInt(u);
Fix broken colors in file import/export. The move to RgbColor() missed the code that reads and writes Style.color and Group.color. Also clarify redefinition of RGB() in w32main.cpp.
2013-11-04 07:09:17 +08:00
break;
Include the remap lists (when we copy entities, that we used to assign the new ids) in the saved file, and split the file load from table stuff into its own function. [git-p4: depot-paths = "//depot/solvespace/": change = 1694]
2008-04-27 18:01:23 +08:00
case 'M': {
Replace entity map implementation with std::unordered_map. On a single load benchmark this provides about 25% speedup.
2019-05-25 01:54:02 +08:00
p->M().clear();
Include the remap lists (when we copy entities, that we used to assign the new ids) in the saved file, and split the file load from table stuff into its own function. [git-p4: depot-paths = "//depot/solvespace/": change = 1694]
2008-04-27 18:01:23 +08:00
for(;;) {
Replace entity map implementation with std::unordered_map. On a single load benchmark this provides about 25% speedup.
2019-05-25 01:54:02 +08:00
EntityKey ek;
EntityId ei;
Include the remap lists (when we copy entities, that we used to assign the new ids) in the saved file, and split the file load from table stuff into its own function. [git-p4: depot-paths = "//depot/solvespace/": change = 1694]
2008-04-27 18:01:23 +08:00
char line2[1024];
Don't ignore the return value of fgets() and fread()
2013-08-27 04:48:41 +08:00
if (fgets(line2, (int)sizeof(line2), fh) == NULL)
break;
Replace entity map implementation with std::unordered_map. On a single load benchmark this provides about 25% speedup.
2019-05-25 01:54:02 +08:00
if(sscanf(line2, "%d %x %d", &(ei.v), &(ek.input.v),
Auto-recover files corrupted by the bug in commit bd84bc1a.
2019-06-25 08:48:57 +08:00
&(ek.copyNumber)) == 3) {
if(ei.v == Entity::NO_ENTITY.v) {
// Commit bd84bc1a mistakenly introduced code that would remap
// some entities to NO_ENTITY. This was fixed in commit bd84bc1a,
// but files created meanwhile are corrupt, and can cause crashes.
//
// To fix this, we skip any such remaps when loading; they will be
// recreated on the next regeneration. Any resulting orphans will
// be pruned in the usual way, recovering to a well-defined state.
continue;
}
Replace entity map implementation with std::unordered_map. On a single load benchmark this provides about 25% speedup.
2019-05-25 01:54:02 +08:00
p->M().insert({ ek, ei });
Include the remap lists (when we copy entities, that we used to assign the new ids) in the saved file, and split the file load from table stuff into its own function. [git-p4: depot-paths = "//depot/solvespace/": change = 1694]
2008-04-27 18:01:23 +08:00
} else {
break;
}
}
break;
}
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 22:43:21 +08:00
case 'i': break;
Replace all oops() checks with ssassert()s. This includes explanation and context for non-obvious cases and shortens debug cycles when just-in-time debugging is not available (like on Linux) by immediately printing description of the assert as well as symbolized backtrace.
2016-05-19 06:51:36 +08:00
default: ssassert(false, "Unexpected value format");
Include the remap lists (when we copy entities, that we used to assign the new ids) in the saved file, and split the file load from table stuff into its own function. [git-p4: depot-paths = "//depot/solvespace/": change = 1694]
2008-04-27 18:01:23 +08:00
}
break;
}
}
A big nasty change, originally just to add paste transformed. So it does that, and adds a scale factor to that transformation (instead of just mirroring, as before), but also: * Replace the "import mirrored" mechanism with a scale factor, which if negative corresponds to a reflection as well. * Fix self-intersection checker to report a meaningful point when edges are collinear. * Don't blow an assertion on some types of invalid file; instead provide a nice error message to the user. * Clear the naked edges before each regen. * Don't create zero-length line segments by snapping a line segment's end to its beginning. [git-p4: depot-paths = "//depot/solvespace/": change = 2086]
2009-12-15 20:26:22 +08:00
if(SAVED[i].type == 0) {
fileLoadError = true;
}
Include the remap lists (when we copy entities, that we used to assign the new ids) in the saved file, and split the file load from table stuff into its own function. [git-p4: depot-paths = "//depot/solvespace/": change = 1694]
2008-04-27 18:01:23 +08:00
}
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 22:43:21 +08:00
bool SolveSpaceUI::LoadFromFile(const Platform::Path &filename, bool canCancel) {
Add logic to remember imported files' relative filenames, and use that to try to find them if we can't find them by absolute path. This is intended to make everything still work if you copy an entire directory tree of files that import each other. Also add a mechanism to not paint the scene if we're not sure it's consistent; otherwise got some crashes on startup. And disable both text and graphic window when displaying a modal dialog, wasn't doing that always. [git-p4: depot-paths = "//depot/solvespace/": change = 1808]
2008-06-25 13:14:49 +08:00
allConsistent = false;
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 20:26:22 +08:00
fileLoadError = false;
Add logic to remember imported files' relative filenames, and use that to try to find them if we can't find them by absolute path. This is intended to make everything still work if you copy an entire directory tree of files that import each other. Also add a mechanism to not paint the scene if we're not sure it's consistent; otherwise got some crashes on startup. And disable both text and graphic window when displaying a modal dialog, wasn't doing that always. [git-p4: depot-paths = "//depot/solvespace/": change = 1808]
2008-06-25 13:14:49 +08:00
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 22:43:21 +08:00
fh = OpenFile(filename, "rb");
Trim trailing whitespace.
2015-03-29 08:30:52 +08:00
if(!fh) {
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 22:43:21 +08:00
Error("Couldn't read from file '%s'", filename.raw.c_str());
Rename some stuff in the IdList again. Rough in the file save stuff, though no file load stuff, and perhaps this can all be made to work from a table somehow. Move the quaternion stuff into its own class, and add a fancy animated view when you orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1672]
2008-04-18 19:11:48 +08:00
return false;
}
Fix a gross memory leak: when switching to a new file, either after File -> New or File -> Open, I freed the Group structures themselves, but none of their children. [git-p4: depot-paths = "//depot/solvespace/": change = 2120]
2010-03-01 03:23:01 +08:00
ClearExisting();
Add more measurement information about the selection. And remove menu items for some features that I suppose I won't add, and fix some bugs. [git-p4: depot-paths = "//depot/solvespace/": change = 1787]
2008-06-12 15:31:41 +08:00
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 23:31:23 +08:00
sv = {};
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 20:26:22 +08:00
sv.g.scale = 1; // default is 1, not 0; so legacy files need this
Extract Style::FillDefaultStyle.
2016-02-27 14:15:15 +08:00
Style::FillDefaultStyle(&sv.s);
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 14:22:16 +08:00
char line[1024];
Use casts to bridge mismatches in integer-type sizes and signedness The compiler gets nervous when we (for example) pass in a size_t as an int parameter, or assign an int to a char, or assign -1 to an unsigned type. By adding appropriate casts, we inform the compiler that, yes, we know what we're doing. This change also upgrades a va_arg() type from char to int, as char is always promoted to int when passed through '...'.
2013-08-27 04:09:15 +08:00
while(fgets(line, (int)sizeof(line), fh)) {
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 14:22:16 +08:00
char *s = strchr(line, '\n');
if(s) *s = '\0';
Tolerate files with \r characters in them; we would never write such a file, but mailers might mangle them. [git-p4: depot-paths = "//depot/solvespace/": change = 1891]
2009-01-10 16:18:54 +08:00
// We should never get files with \r characters in them, but mailers
// will sometimes mangle attachments.
s = strchr(line, '\r');
if(s) *s = '\0';
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 14:22:16 +08:00
if(*line == '\0') continue;
Trim trailing whitespace.
2015-03-29 08:30:52 +08:00
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 14:22:16 +08:00
char *e = strchr(line, '=');
if(e) {
*e = '\0';
char *key = line, *val = e+1;
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 22:43:21 +08:00
LoadUsingTable(filename, key, val);
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 14:22:16 +08:00
} else if(strcmp(line, "AddGroup")==0) {
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 13:27:54 +08:00
// legacy files have a spurious dependency between linked groups
Break the dependency between an imported group and its parent. Per correspondence with Jonathan the dependency serves no useful purpose. It also prevents safely deleting groups preceding imported groups.
2016-02-02 13:43:41 +08:00
// and their parent groups, remove
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 16:31:20 +08:00
if(sv.g.type == Group::Type::LINKED)
Break the dependency between an imported group and its parent. Per correspondence with Jonathan the dependency serves no useful purpose. It also prevents safely deleting groups preceding imported groups.
2016-02-02 13:43:41 +08:00
sv.g.opA.v = 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 13:53:16 +08:00
SK.group.Add(&(sv.g));
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 23:31:23 +08:00
sv.g = {};
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 20:26:22 +08:00
sv.g.scale = 1; // default is 1, not 0; so legacy files need this
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 14:22:16 +08:00
} else if(strcmp(line, "AddParam")==0) {
// params are regenerated, but we want to preload the values
// for initial guesses
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 13:53:16 +08:00
SK.param.Add(&(sv.p));
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 23:31:23 +08:00
sv.p = {};
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 14:22:16 +08:00
} else if(strcmp(line, "AddEntity")==0) {
// entities are regenerated
} else if(strcmp(line, "AddRequest")==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 13:53:16 +08:00
SK.request.Add(&(sv.r));
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 23:31:23 +08:00
sv.r = {};
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 14:22:16 +08:00
} else if(strcmp(line, "AddConstraint")==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 13:53:16 +08:00
SK.constraint.Add(&(sv.c));
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 23:31:23 +08:00
sv.c = {};
Move colors and line widths for almost everything to the styles mechanism. This gets filled in from some defaults, and stored in the registry. The default styles do not get saved in the file, but user-created styles (which aren't supported yet) do. [git-p4: depot-paths = "//depot/solvespace/": change = 2028]
2009-09-17 15:32:36 +08:00
} else if(strcmp(line, "AddStyle")==0) {
SK.style.Add(&(sv.s));
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 23:31:23 +08:00
sv.s = {};
Extract Style::FillDefaultStyle.
2016-02-27 14:15:15 +08:00
Style::FillDefaultStyle(&sv.s);
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
} else if(strcmp(line, VERSION_STRING)==0) {
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 14:22:16 +08:00
// do nothing, version string
Save the exact surfaces in the exported file, and import and transform them for assembly. [git-p4: depot-paths = "//depot/solvespace/": change = 1954]
2009-05-19 15:26:38 +08:00
} else if(StrStartsWith(line, "Triangle ") ||
StrStartsWith(line, "Surface ") ||
StrStartsWith(line, "SCtrl ") ||
StrStartsWith(line, "TrimBy ") ||
StrStartsWith(line, "Curve ") ||
StrStartsWith(line, "CCtrl ") ||
StrStartsWith(line, "CurvePt ") ||
strcmp(line, "AddSurface")==0 ||
strcmp(line, "AddCurve")==0)
{
// ignore the mesh or shell, since we regenerate that
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 14:22:16 +08:00
} else {
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 20:26:22 +08:00
fileLoadError = true;
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 14:22:16 +08:00
}
}
fclose(fh);
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 20:26:22 +08:00
if(fileLoadError) {
Internationalize all messages without substitutions.
2017-01-07 14:41:13 +08:00
Error(_("Unrecognized data in file. This file may be corrupt, or "
"from a newer version of the program."));
Oops, feeding garbage to the SolveSpace file load routines would make it return with the program in a bad state and blow up later; so fix at least one easy case of that. [git-p4: depot-paths = "//depot/solvespace/": change = 2114]
2010-01-25 09:32:36 +08:00
// At least leave the program in a non-crashing state.
Add and use IdList::IsEmpty. NFC. Removes consuming code from the implementation details, easing swap of the underlying container, etc.
2018-01-04 05:10:18 +08:00
if(SK.group.IsEmpty()) {
Oops, feeding garbage to the SolveSpace file load routines would make it return with the program in a bad state and blow up later; so fix at least one easy case of that. [git-p4: depot-paths = "//depot/solvespace/": change = 2114]
2010-01-25 09:32:36 +08:00
NewFile();
}
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 20:26:22 +08:00
}
Implement an image request.
2016-11-30 00:49:20 +08:00
if(!ReloadAllLinked(filename, canCancel)) {
Reload linked files before upgrading legacy data. Before this commit, if constraints with newly introduced params were loaded from a file that linked other files, the upgrade code would attempt to look up a non-existent entity.
2016-11-29 00:20:59 +08:00
return false;
}
Add two more points to the TTF text request. These points can be used for constraining the width of the text (or to the width of the text). The main parts of the commit are: * TtfFont is restructured to be able to return the aspect ratio for a given string. * This aspect ratio is written to the savefile, such that even if the font is missing, the sketch would still be solved correctly. * The two additional points are constrained via perpendicularly to the two main points (which form a v vector). The compatibility features are as follows: * When the font is missing in old files, 1:1 aspect ratio is used, which works for the replacement symbol anyhow. * When the two additional points are missing in old files, their would-be positions are calculated and they are moved there, avoiding 'jumping' of underconstrained sketches.
2016-10-11 09:58:04 +08:00
UpgradeLegacyData();
Rename some stuff in the IdList again. Rough in the file save stuff, though no file load stuff, and perhaps this can all be made to work from a table somehow. Move the quaternion stuff into its own class, and add a fancy animated view when you orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1672]
2008-04-18 19:11:48 +08:00
return true;
}
Add two more points to the TTF text request. These points can be used for constraining the width of the text (or to the width of the text). The main parts of the commit are: * TtfFont is restructured to be able to return the aspect ratio for a given string. * This aspect ratio is written to the savefile, such that even if the font is missing, the sketch would still be solved correctly. * The two additional points are constrained via perpendicularly to the two main points (which form a v vector). The compatibility features are as follows: * When the font is missing in old files, 1:1 aspect ratio is used, which works for the replacement symbol anyhow. * When the two additional points are missing in old files, their would-be positions are calculated and they are moved there, avoiding 'jumping' of underconstrained sketches.
2016-10-11 09:58:04 +08:00
void SolveSpaceUI::UpgradeLegacyData() {
for(Request &r : SK.request) {
switch(r.type) {
// TTF text requests saved in versions prior to 3.0 only have two
// reference points (origin and origin plus v); version 3.0 adds two
// more points, and if we don't do anything, then they will appear
// at workplane origin, and the solver will mess up the sketch if
// it is not fully constrained.
case Request::Type::TTF_TEXT: {
IdList<Entity,hEntity> entity = {};
IdList<Param,hParam> param = {};
r.Generate(&entity, &param);
// If we didn't load all of the entities and params that this
// request would generate, then add them now, so that we can
// force them to their appropriate positions.
for(Param &p : param) {
if(SK.param.FindByIdNoOops(p.h) != NULL) continue;
SK.param.Add(&p);
}
bool allPointsExist = true;
for(Entity &e : entity) {
if(SK.entity.FindByIdNoOops(e.h) != NULL) continue;
SK.entity.Add(&e);
allPointsExist = false;
}
if(!allPointsExist) {
Entity *text = entity.FindById(r.h.entity(0));
Entity *b = entity.FindById(text->point[2]);
Entity *c = entity.FindById(text->point[3]);
ExprVector bex, cex;
Implement an image request.
2016-11-30 00:49:20 +08:00
text->RectGetPointsExprs(&bex, &cex);
Add two more points to the TTF text request. These points can be used for constraining the width of the text (or to the width of the text). The main parts of the commit are: * TtfFont is restructured to be able to return the aspect ratio for a given string. * This aspect ratio is written to the savefile, such that even if the font is missing, the sketch would still be solved correctly. * The two additional points are constrained via perpendicularly to the two main points (which form a v vector). The compatibility features are as follows: * When the font is missing in old files, 1:1 aspect ratio is used, which works for the replacement symbol anyhow. * When the two additional points are missing in old files, their would-be positions are calculated and they are moved there, avoiding 'jumping' of underconstrained sketches.
2016-10-11 09:58:04 +08:00
b->PointForceParamTo(bex.Eval());
c->PointForceParamTo(cex.Eval());
}
entity.Clear();
param.Clear();
Rewrite equations generated for pt-on-line constraints. Before this commit, pt-on-line constraints are buggy. To reproduce, extrude a circle, then add a datum point and constrain it to the axis of the circle, then move it. The cylinder will collapse. To quote Jonathan: > On investigation, I (a) confirm that the problem is > the unconstrained extrusion depth going to zero, and (b) retract > my earlier statement blaming extrude and other similar non-entity > parameter treatment for this problem; you can easily reproduce it > with a point in 3d constrained to lie on any line whose length > is free. > > PT_ON_LINE is written using VectorsParallel, for no obvious reason. > Rewriting that constraint to work on two projected distances (using > any two basis vectors perpendicular to the line) should fix that > problem, since replacing the "point on line in 3d" constraint with > two "point on line in 2d" constraints works. That still has > the hairy ball problem of choosing the basis vectors, which you > can't do with a continuous function; you'd need Vector::Normal() > or equivalent. > > You could write three equations and make the constraint itself > introduce one new parameter for t. I don't know how well that > would work numerically, but it would avoid the hairy ball problem, > perhaps elegant at the cost of speed. Indeed, this commit implements the latter solution: it introduces an additional free parameter. The point being coincident with the start of the line corresponds to the parameter being zero, and point being coincident with the end corresponds to one). In effect, instead of constraining two of three degrees of freedom (for which the equations do not exist because of the hairy ball theorem), it constrains three and adds one more.
2016-11-02 00:06:57 +08:00
break;
Add two more points to the TTF text request. These points can be used for constraining the width of the text (or to the width of the text). The main parts of the commit are: * TtfFont is restructured to be able to return the aspect ratio for a given string. * This aspect ratio is written to the savefile, such that even if the font is missing, the sketch would still be solved correctly. * The two additional points are constrained via perpendicularly to the two main points (which form a v vector). The compatibility features are as follows: * When the font is missing in old files, 1:1 aspect ratio is used, which works for the replacement symbol anyhow. * When the two additional points are missing in old files, their would-be positions are calculated and they are moved there, avoiding 'jumping' of underconstrained sketches.
2016-10-11 09:58:04 +08:00
}
default:
break;
}
}
Rewrite equations generated for pt-on-line constraints. Before this commit, pt-on-line constraints are buggy. To reproduce, extrude a circle, then add a datum point and constrain it to the axis of the circle, then move it. The cylinder will collapse. To quote Jonathan: > On investigation, I (a) confirm that the problem is > the unconstrained extrusion depth going to zero, and (b) retract > my earlier statement blaming extrude and other similar non-entity > parameter treatment for this problem; you can easily reproduce it > with a point in 3d constrained to lie on any line whose length > is free. > > PT_ON_LINE is written using VectorsParallel, for no obvious reason. > Rewriting that constraint to work on two projected distances (using > any two basis vectors perpendicular to the line) should fix that > problem, since replacing the "point on line in 3d" constraint with > two "point on line in 2d" constraints works. That still has > the hairy ball problem of choosing the basis vectors, which you > can't do with a continuous function; you'd need Vector::Normal() > or equivalent. > > You could write three equations and make the constraint itself > introduce one new parameter for t. I don't know how well that > would work numerically, but it would avoid the hairy ball problem, > perhaps elegant at the cost of speed. Indeed, this commit implements the latter solution: it introduces an additional free parameter. The point being coincident with the start of the line corresponds to the parameter being zero, and point being coincident with the end corresponds to one). In effect, instead of constraining two of three degrees of freedom (for which the equations do not exist because of the hairy ball theorem), it constrains three and adds one more.
2016-11-02 00:06:57 +08:00
Rewrite equations generated for curve-line tangent constraints (in 3d). This has the same motivations and implementation as in 3d6d873.
2016-11-27 15:59:47 +08:00
// Constraints saved in versions prior to 3.0 never had any params;
// version 3.0 introduced params to constraints to avoid the hairy ball problem,
// so force them where they belong.
Rewrite equations generated for pt-on-line constraints. Before this commit, pt-on-line constraints are buggy. To reproduce, extrude a circle, then add a datum point and constrain it to the axis of the circle, then move it. The cylinder will collapse. To quote Jonathan: > On investigation, I (a) confirm that the problem is > the unconstrained extrusion depth going to zero, and (b) retract > my earlier statement blaming extrude and other similar non-entity > parameter treatment for this problem; you can easily reproduce it > with a point in 3d constrained to lie on any line whose length > is free. > > PT_ON_LINE is written using VectorsParallel, for no obvious reason. > Rewriting that constraint to work on two projected distances (using > any two basis vectors perpendicular to the line) should fix that > problem, since replacing the "point on line in 3d" constraint with > two "point on line in 2d" constraints works. That still has > the hairy ball problem of choosing the basis vectors, which you > can't do with a continuous function; you'd need Vector::Normal() > or equivalent. > > You could write three equations and make the constraint itself > introduce one new parameter for t. I don't know how well that > would work numerically, but it would avoid the hairy ball problem, > perhaps elegant at the cost of speed. Indeed, this commit implements the latter solution: it introduces an additional free parameter. The point being coincident with the start of the line corresponds to the parameter being zero, and point being coincident with the end corresponds to one). In effect, instead of constraining two of three degrees of freedom (for which the equations do not exist because of the hairy ball theorem), it constrains three and adds one more.
2016-11-02 00:06:57 +08:00
IdList<Param,hParam> oldParam = {};
SK.param.DeepCopyInto(&oldParam);
SS.GenerateAll(SolveSpaceUI::Generate::REGEN);
Rewrite equations generated for curve-line tangent constraints (in 3d). This has the same motivations and implementation as in 3d6d873.
2016-11-27 15:59:47 +08:00
Explicitly represent the parameter used in constraints. Commit f5485cb and its ancestors add a parameter to some constraints. This parameter must be materialized and assigned a non-zero value via ModifyToSatisfy for the solver library to not make unnecessary changes to the sketch during the initial generation. For this, we represent it explicitly instead of using hc.param(0), such that the materialized constraint does not conflict with any user-defined ones.
2017-01-26 00:39:26 +08:00
auto AllParamsExistFor = [&](Constraint &c) {
Rewrite equations generated for curve-line tangent constraints (in 3d). This has the same motivations and implementation as in 3d6d873.
2016-11-27 15:59:47 +08:00
IdList<Param,hParam> param = {};
c.Generate(&param);
bool allParamsExist = true;
for(Param &p : param) {
if(oldParam.FindByIdNoOops(p.h) != NULL) continue;
allParamsExist = false;
break;
}
param.Clear();
return allParamsExist;
};
Rewrite equations generated for pt-on-line constraints. Before this commit, pt-on-line constraints are buggy. To reproduce, extrude a circle, then add a datum point and constrain it to the axis of the circle, then move it. The cylinder will collapse. To quote Jonathan: > On investigation, I (a) confirm that the problem is > the unconstrained extrusion depth going to zero, and (b) retract > my earlier statement blaming extrude and other similar non-entity > parameter treatment for this problem; you can easily reproduce it > with a point in 3d constrained to lie on any line whose length > is free. > > PT_ON_LINE is written using VectorsParallel, for no obvious reason. > Rewriting that constraint to work on two projected distances (using > any two basis vectors perpendicular to the line) should fix that > problem, since replacing the "point on line in 3d" constraint with > two "point on line in 2d" constraints works. That still has > the hairy ball problem of choosing the basis vectors, which you > can't do with a continuous function; you'd need Vector::Normal() > or equivalent. > > You could write three equations and make the constraint itself > introduce one new parameter for t. I don't know how well that > would work numerically, but it would avoid the hairy ball problem, > perhaps elegant at the cost of speed. Indeed, this commit implements the latter solution: it introduces an additional free parameter. The point being coincident with the start of the line corresponds to the parameter being zero, and point being coincident with the end corresponds to one). In effect, instead of constraining two of three degrees of freedom (for which the equations do not exist because of the hairy ball theorem), it constrains three and adds one more.
2016-11-02 00:06:57 +08:00
for(Constraint &c : SK.constraint) {
switch(c.type) {
case Constraint::Type::PT_ON_LINE: {
Rewrite equations generated for curve-line tangent constraints (in 3d). This has the same motivations and implementation as in 3d6d873.
2016-11-27 15:59:47 +08:00
if(AllParamsExistFor(c)) continue;
EntityBase *eln = SK.GetEntity(c.entityA);
EntityBase *ea = SK.GetEntity(eln->point[0]);
EntityBase *eb = SK.GetEntity(eln->point[1]);
EntityBase *ep = SK.GetEntity(c.ptA);
ExprVector exp = ep->PointGetExprsInWorkplane(c.workplane);
ExprVector exa = ea->PointGetExprsInWorkplane(c.workplane);
ExprVector exb = eb->PointGetExprsInWorkplane(c.workplane);
ExprVector exba = exb.Minus(exa);
Param *p = SK.GetParam(c.h.param(0));
p->val = exba.Dot(exp.Minus(exa))->Eval() / exba.Dot(exba)->Eval();
break;
}
Rewrite equations generated for pt-on-line constraints. Before this commit, pt-on-line constraints are buggy. To reproduce, extrude a circle, then add a datum point and constrain it to the axis of the circle, then move it. The cylinder will collapse. To quote Jonathan: > On investigation, I (a) confirm that the problem is > the unconstrained extrusion depth going to zero, and (b) retract > my earlier statement blaming extrude and other similar non-entity > parameter treatment for this problem; you can easily reproduce it > with a point in 3d constrained to lie on any line whose length > is free. > > PT_ON_LINE is written using VectorsParallel, for no obvious reason. > Rewriting that constraint to work on two projected distances (using > any two basis vectors perpendicular to the line) should fix that > problem, since replacing the "point on line in 3d" constraint with > two "point on line in 2d" constraints works. That still has > the hairy ball problem of choosing the basis vectors, which you > can't do with a continuous function; you'd need Vector::Normal() > or equivalent. > > You could write three equations and make the constraint itself > introduce one new parameter for t. I don't know how well that > would work numerically, but it would avoid the hairy ball problem, > perhaps elegant at the cost of speed. Indeed, this commit implements the latter solution: it introduces an additional free parameter. The point being coincident with the start of the line corresponds to the parameter being zero, and point being coincident with the end corresponds to one). In effect, instead of constraining two of three degrees of freedom (for which the equations do not exist because of the hairy ball theorem), it constrains three and adds one more.
2016-11-02 00:06:57 +08:00
Rewrite equations generated for curve-line tangent constraints (in 3d). This has the same motivations and implementation as in 3d6d873.
2016-11-27 15:59:47 +08:00
case Constraint::Type::CUBIC_LINE_TANGENT: {
if(AllParamsExistFor(c)) continue;
EntityBase *cubic = SK.GetEntity(c.entityA);
EntityBase *line = SK.GetEntity(c.entityB);
ExprVector a;
if(c.other) {
a = cubic->CubicGetFinishTangentExprs();
} else {
a = cubic->CubicGetStartTangentExprs();
Rewrite equations generated for pt-on-line constraints. Before this commit, pt-on-line constraints are buggy. To reproduce, extrude a circle, then add a datum point and constrain it to the axis of the circle, then move it. The cylinder will collapse. To quote Jonathan: > On investigation, I (a) confirm that the problem is > the unconstrained extrusion depth going to zero, and (b) retract > my earlier statement blaming extrude and other similar non-entity > parameter treatment for this problem; you can easily reproduce it > with a point in 3d constrained to lie on any line whose length > is free. > > PT_ON_LINE is written using VectorsParallel, for no obvious reason. > Rewriting that constraint to work on two projected distances (using > any two basis vectors perpendicular to the line) should fix that > problem, since replacing the "point on line in 3d" constraint with > two "point on line in 2d" constraints works. That still has > the hairy ball problem of choosing the basis vectors, which you > can't do with a continuous function; you'd need Vector::Normal() > or equivalent. > > You could write three equations and make the constraint itself > introduce one new parameter for t. I don't know how well that > would work numerically, but it would avoid the hairy ball problem, > perhaps elegant at the cost of speed. Indeed, this commit implements the latter solution: it introduces an additional free parameter. The point being coincident with the start of the line corresponds to the parameter being zero, and point being coincident with the end corresponds to one). In effect, instead of constraining two of three degrees of freedom (for which the equations do not exist because of the hairy ball theorem), it constrains three and adds one more.
2016-11-02 00:06:57 +08:00
}
Rewrite equations generated for curve-line tangent constraints (in 3d). This has the same motivations and implementation as in 3d6d873.
2016-11-27 15:59:47 +08:00
ExprVector b = line->VectorGetExprs();
Param *param = SK.GetParam(c.h.param(0));
param->val = a.Dot(b)->Eval() / b.Dot(b)->Eval();
Rewrite equations generated for same-orientation constraints. This has the same motivations and implementation as in 3d6d873.
2016-11-27 16:43:21 +08:00
break;
}
case Constraint::Type::SAME_ORIENTATION: {
if(AllParamsExistFor(c)) continue;
EntityBase *an = SK.GetEntity(c.entityA);
EntityBase *bn = SK.GetEntity(c.entityB);
ExprVector a = an->NormalExprsN();
ExprVector b = bn->NormalExprsN();
Param *param = SK.GetParam(c.h.param(0));
param->val = a.Dot(b)->Eval() / b.Dot(b)->Eval();
Rewrite equations generated for pt-on-line constraints. Before this commit, pt-on-line constraints are buggy. To reproduce, extrude a circle, then add a datum point and constrain it to the axis of the circle, then move it. The cylinder will collapse. To quote Jonathan: > On investigation, I (a) confirm that the problem is > the unconstrained extrusion depth going to zero, and (b) retract > my earlier statement blaming extrude and other similar non-entity > parameter treatment for this problem; you can easily reproduce it > with a point in 3d constrained to lie on any line whose length > is free. > > PT_ON_LINE is written using VectorsParallel, for no obvious reason. > Rewriting that constraint to work on two projected distances (using > any two basis vectors perpendicular to the line) should fix that > problem, since replacing the "point on line in 3d" constraint with > two "point on line in 2d" constraints works. That still has > the hairy ball problem of choosing the basis vectors, which you > can't do with a continuous function; you'd need Vector::Normal() > or equivalent. > > You could write three equations and make the constraint itself > introduce one new parameter for t. I don't know how well that > would work numerically, but it would avoid the hairy ball problem, > perhaps elegant at the cost of speed. Indeed, this commit implements the latter solution: it introduces an additional free parameter. The point being coincident with the start of the line corresponds to the parameter being zero, and point being coincident with the end corresponds to one). In effect, instead of constraining two of three degrees of freedom (for which the equations do not exist because of the hairy ball theorem), it constrains three and adds one more.
2016-11-02 00:06:57 +08:00
break;
}
Rewrite equations generated for parallel constraints (in 3d). Before this commit, parallel constraints in 3d are fragile: constraints that are geometrically fine can end up singular anyway because VectorsParallel() pivots wrong but converges anyway. After this commit, much like in cc07058, the constraints are written in a different form: instead of trying to remove two degrees of freedom out of three, all three are removed, and one added; namely, the constraint introduces a free parameter, signed length ratio.
2016-11-02 01:15:15 +08:00
case Constraint::Type::PARALLEL: {
Rewrite equations generated for curve-line tangent constraints (in 3d). This has the same motivations and implementation as in 3d6d873.
2016-11-27 15:59:47 +08:00
if(AllParamsExistFor(c)) continue;
Rewrite equations generated for parallel constraints (in 3d). Before this commit, parallel constraints in 3d are fragile: constraints that are geometrically fine can end up singular anyway because VectorsParallel() pivots wrong but converges anyway. After this commit, much like in cc07058, the constraints are written in a different form: instead of trying to remove two degrees of freedom out of three, all three are removed, and one added; namely, the constraint introduces a free parameter, signed length ratio.
2016-11-02 01:15:15 +08:00
Rewrite equations generated for curve-line tangent constraints (in 3d). This has the same motivations and implementation as in 3d6d873.
2016-11-27 15:59:47 +08:00
EntityBase *ea = SK.GetEntity(c.entityA),
*eb = SK.GetEntity(c.entityB);
ExprVector a = ea->VectorGetExprsInWorkplane(c.workplane);
ExprVector b = eb->VectorGetExprsInWorkplane(c.workplane);
Rewrite equations generated for parallel constraints (in 3d). Before this commit, parallel constraints in 3d are fragile: constraints that are geometrically fine can end up singular anyway because VectorsParallel() pivots wrong but converges anyway. After this commit, much like in cc07058, the constraints are written in a different form: instead of trying to remove two degrees of freedom out of three, all three are removed, and one added; namely, the constraint introduces a free parameter, signed length ratio.
2016-11-02 01:15:15 +08:00
Rewrite equations generated for curve-line tangent constraints (in 3d). This has the same motivations and implementation as in 3d6d873.
2016-11-27 15:59:47 +08:00
Param *param = SK.GetParam(c.h.param(0));
param->val = a.Dot(b)->Eval() / b.Dot(b)->Eval();
Rewrite equations generated for parallel constraints (in 3d). Before this commit, parallel constraints in 3d are fragile: constraints that are geometrically fine can end up singular anyway because VectorsParallel() pivots wrong but converges anyway. After this commit, much like in cc07058, the constraints are written in a different form: instead of trying to remove two degrees of freedom out of three, all three are removed, and one added; namely, the constraint introduces a free parameter, signed length ratio.
2016-11-02 01:15:15 +08:00
break;
}
Rewrite equations generated for pt-on-line constraints. Before this commit, pt-on-line constraints are buggy. To reproduce, extrude a circle, then add a datum point and constrain it to the axis of the circle, then move it. The cylinder will collapse. To quote Jonathan: > On investigation, I (a) confirm that the problem is > the unconstrained extrusion depth going to zero, and (b) retract > my earlier statement blaming extrude and other similar non-entity > parameter treatment for this problem; you can easily reproduce it > with a point in 3d constrained to lie on any line whose length > is free. > > PT_ON_LINE is written using VectorsParallel, for no obvious reason. > Rewriting that constraint to work on two projected distances (using > any two basis vectors perpendicular to the line) should fix that > problem, since replacing the "point on line in 3d" constraint with > two "point on line in 2d" constraints works. That still has > the hairy ball problem of choosing the basis vectors, which you > can't do with a continuous function; you'd need Vector::Normal() > or equivalent. > > You could write three equations and make the constraint itself > introduce one new parameter for t. I don't know how well that > would work numerically, but it would avoid the hairy ball problem, > perhaps elegant at the cost of speed. Indeed, this commit implements the latter solution: it introduces an additional free parameter. The point being coincident with the start of the line corresponds to the parameter being zero, and point being coincident with the end corresponds to one). In effect, instead of constraining two of three degrees of freedom (for which the equations do not exist because of the hairy ball theorem), it constrains three and adds one more.
2016-11-02 00:06:57 +08:00
default:
break;
}
}
oldParam.Clear();
Add two more points to the TTF text request. These points can be used for constraining the width of the text (or to the width of the text). The main parts of the commit are: * TtfFont is restructured to be able to return the aspect ratio for a given string. * This aspect ratio is written to the savefile, such that even if the font is missing, the sketch would still be solved correctly. * The two additional points are constrained via perpendicularly to the two main points (which form a v vector). The compatibility features are as follows: * When the font is missing in old files, 1:1 aspect ratio is used, which works for the replacement symbol anyhow. * When the two additional points are missing in old files, their would-be positions are calculated and they are moved there, avoiding 'jumping' of underconstrained sketches.
2016-10-11 09:58:04 +08:00
}
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 22:43:21 +08:00
bool SolveSpaceUI::LoadEntitiesFromFile(const Platform::Path &filename, EntityList *le,
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 23:31:23 +08:00
SMesh *m, SShell *sh)
IDF file Linking. Can read PCB outlines and cutouts, as well as Pin and Mounting holes. A simple PPCB model sans components is added to the assembly.
2020-09-25 00:30:06 +08:00
{
if(strcmp(filename.Extension().c_str(), "emn")==0) {
return LinkIDF(filename, le, m, sh);
} else {
return LoadEntitiesFromSlvs(filename, le, m, sh);
}
}
bool SolveSpaceUI::LoadEntitiesFromSlvs(const Platform::Path &filename, EntityList *le,
SMesh *m, SShell *sh)
Save the exact surfaces in the exported file, and import and transform them for assembly. [git-p4: depot-paths = "//depot/solvespace/": change = 1954]
2009-05-19 15:26:38 +08:00
{
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 23:31:23 +08:00
SSurface srf = {};
SCurve crv = {};
Save the exact surfaces in the exported file, and import and transform them for assembly. [git-p4: depot-paths = "//depot/solvespace/": change = 1954]
2009-05-19 15:26:38 +08:00
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 22:43:21 +08:00
fh = OpenFile(filename, "rb");
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
if(!fh) return false;
le->Clear();
Replace all ZERO and memset with C++11 brace-initialization. This will allow us to use non-POD classes inside these objects in future and is otherwise functionally equivalent, as well as more concise. Note that there are some subtleties with handling of brace-initialization. Specifically: On aggregates (e.g. simple C-style structures) using an empty brace-initializer zero-initializes the aggregate, i.e. it makes all members zero. On non-aggregates an empty brace-initializer calls the default constructor. And if the constructor doesn't explicitly initialize the members (which the auto-generated constructor doesn't) then the members will be constructed but otherwise uninitialized. So, what is an aggregate class? To quote the C++ standard (C++03 8.5.1 §1): An aggregate is an array or a class (clause 9) with no user-declared constructors (12.1), no private or protected non-static data members (clause 11), no base classes (clause 10), and no virtual functions (10.3). In SolveSpace, we only have to handle the case of base classes; Constraint and Entity have those. Thus, they had to gain a default constructor that does nothing but initializes the members to zero.
2015-03-27 23:31:23 +08:00
sv = {};
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
char line[1024];
Use casts to bridge mismatches in integer-type sizes and signedness The compiler gets nervous when we (for example) pass in a size_t as an int parameter, or assign an int to a char, or assign -1 to an unsigned type. By adding appropriate casts, we inform the compiler that, yes, we know what we're doing. This change also upgrades a va_arg() type from char to int, as char is always promoted to int when passed through '...'.
2013-08-27 04:09:15 +08:00
while(fgets(line, (int)sizeof(line), fh)) {
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
char *s = strchr(line, '\n');
if(s) *s = '\0';
Tolerate files with \r characters in them; we would never write such a file, but mailers might mangle them. [git-p4: depot-paths = "//depot/solvespace/": change = 1891]
2009-01-10 16:18:54 +08:00
// We should never get files with \r characters in them, but mailers
// will sometimes mangle attachments.
s = strchr(line, '\r');
if(s) *s = '\0';
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
if(*line == '\0') continue;
Trim trailing whitespace.
2015-03-29 08:30:52 +08:00
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
char *e = strchr(line, '=');
if(e) {
*e = '\0';
char *key = line, *val = e+1;
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 22:43:21 +08:00
LoadUsingTable(filename, key, val);
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
} else if(strcmp(line, "AddGroup")==0) {
Replace entity map implementation with std::unordered_map. On a single load benchmark this provides about 25% speedup.
2019-05-25 01:54:02 +08:00
// These get allocated whether we want them or not.
sv.g.remap.clear();
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
} else if(strcmp(line, "AddParam")==0) {
} else if(strcmp(line, "AddEntity")==0) {
le->Add(&(sv.e));
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 23:31:23 +08:00
sv.e = {};
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
} else if(strcmp(line, "AddRequest")==0) {
} else if(strcmp(line, "AddConstraint")==0) {
Don't keep a dimension or group's user-entered numerical value as an Expr *, since that complicates multiple units and also memory management. Now it's just a double. [git-p4: depot-paths = "//depot/solvespace/": change = 1791]
2008-06-14 16:43:38 +08:00
Add ability to assign styles to cosmetic text (in the form of Constraint::COMMENTs), including line width and color, and text height and origin location. [git-p4: depot-paths = "//depot/solvespace/": change = 2033]
2009-09-24 23:52:48 +08:00
} else if(strcmp(line, "AddStyle")==0) {
Import missing styles from linked files.
2019-02-19 18:42:14 +08:00
// Linked file contains a style that we don't have yet,
// so import it.
if (SK.style.FindByIdNoOops(sv.s.h) == nullptr) {
SK.style.Add(&(sv.s));
}
sv.s = {};
Style::FillDefaultStyle(&sv.s);
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
} else if(strcmp(line, VERSION_STRING)==0) {
Save the exact surfaces in the exported file, and import and transform them for assembly. [git-p4: depot-paths = "//depot/solvespace/": change = 1954]
2009-05-19 15:26:38 +08:00
} else if(StrStartsWith(line, "Triangle ")) {
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 23:31:23 +08:00
STriangle tr = {};
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 18:30:12 +08:00
unsigned int rgba = 0;
Add color. Now each triangle has metadata, which are preserved in csg ops; so the union of a red part and a blue part has both red and blue faces. And some user interface to pick the color in the text window. The metadata also include a face, which will be an entity; I can use that to constrain against. But none of that is yet implemented. [git-p4: depot-paths = "//depot/solvespace/": change = 1757]
2008-05-30 14:09:41 +08:00
if(sscanf(line, "Triangle %x %x "
"%lf %lf %lf %lf %lf %lf %lf %lf %lf",
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 18:30:12 +08:00
&(tr.meta.face), &rgba,
Trim trailing whitespace.
2015-03-29 08:30:52 +08:00
&(tr.a.x), &(tr.a.y), &(tr.a.z),
&(tr.b.x), &(tr.b.y), &(tr.b.z),
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 18:30:12 +08:00
&(tr.c.x), &(tr.c.y), &(tr.c.z)) != 11) {
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-19 06:51:36 +08:00
ssassert(false, "Unexpected Triangle format");
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
}
Rename RgbColor to RgbaColor.
2015-07-10 19:54:39 +08:00
tr.meta.color = RgbaColor::FromPackedInt((uint32_t)rgba);
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
m->AddTriangle(&tr);
Save the exact surfaces in the exported file, and import and transform them for assembly. [git-p4: depot-paths = "//depot/solvespace/": change = 1954]
2009-05-19 15:26:38 +08:00
} else if(StrStartsWith(line, "Surface ")) {
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 18:30:12 +08:00
unsigned int rgba = 0;
Save the exact surfaces in the exported file, and import and transform them for assembly. [git-p4: depot-paths = "//depot/solvespace/": change = 1954]
2009-05-19 15:26:38 +08:00
if(sscanf(line, "Surface %x %x %x %d %d",
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 18:30:12 +08:00
&(srf.h.v), &rgba, &(srf.face),
&(srf.degm), &(srf.degn)) != 5) {
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-19 06:51:36 +08:00
ssassert(false, "Unexpected Surface format");
Save the exact surfaces in the exported file, and import and transform them for assembly. [git-p4: depot-paths = "//depot/solvespace/": change = 1954]
2009-05-19 15:26:38 +08:00
}
Rename RgbColor to RgbaColor.
2015-07-10 19:54:39 +08:00
srf.color = RgbaColor::FromPackedInt((uint32_t)rgba);
Save the exact surfaces in the exported file, and import and transform them for assembly. [git-p4: depot-paths = "//depot/solvespace/": change = 1954]
2009-05-19 15:26:38 +08:00
} else if(StrStartsWith(line, "SCtrl ")) {
int i, j;
Vector c;
double w;
if(sscanf(line, "SCtrl %d %d %lf %lf %lf Weight %lf",
&i, &j, &(c.x), &(c.y), &(c.z), &w) != 6)
{
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-19 06:51:36 +08:00
ssassert(false, "Unexpected SCtrl format");
Save the exact surfaces in the exported file, and import and transform them for assembly. [git-p4: depot-paths = "//depot/solvespace/": change = 1954]
2009-05-19 15:26:38 +08:00
}
srf.ctrl[i][j] = c;
srf.weight[i][j] = w;
} else if(StrStartsWith(line, "TrimBy ")) {
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 23:31:23 +08:00
STrimBy stb = {};
Save the exact surfaces in the exported file, and import and transform them for assembly. [git-p4: depot-paths = "//depot/solvespace/": change = 1954]
2009-05-19 15:26:38 +08:00
int backwards;
if(sscanf(line, "TrimBy %x %d %lf %lf %lf %lf %lf %lf",
&(stb.curve.v), &backwards,
&(stb.start.x), &(stb.start.y), &(stb.start.z),
&(stb.finish.x), &(stb.finish.y), &(stb.finish.z)) != 8)
{
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-19 06:51:36 +08:00
ssassert(false, "Unexpected TrimBy format");
Save the exact surfaces in the exported file, and import and transform them for assembly. [git-p4: depot-paths = "//depot/solvespace/": change = 1954]
2009-05-19 15:26:38 +08:00
}
stb.backwards = (backwards != 0);
srf.trim.Add(&stb);
} else if(strcmp(line, "AddSurface")==0) {
sh->surface.Add(&srf);
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 23:31:23 +08:00
srf = {};
Save the exact surfaces in the exported file, and import and transform them for assembly. [git-p4: depot-paths = "//depot/solvespace/": change = 1954]
2009-05-19 15:26:38 +08:00
} else if(StrStartsWith(line, "Curve ")) {
int isExact;
if(sscanf(line, "Curve %x %d %d %x %x",
&(crv.h.v),
&(isExact),
&(crv.exact.deg),
&(crv.surfA.v), &(crv.surfB.v)) != 5)
{
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-19 06:51:36 +08:00
ssassert(false, "Unexpected Curve format");
Save the exact surfaces in the exported file, and import and transform them for assembly. [git-p4: depot-paths = "//depot/solvespace/": change = 1954]
2009-05-19 15:26:38 +08:00
}
crv.isExact = (isExact != 0);
} else if(StrStartsWith(line, "CCtrl ")) {
int i;
Vector c;
double w;
if(sscanf(line, "CCtrl %d %lf %lf %lf Weight %lf",
&i, &(c.x), &(c.y), &(c.z), &w) != 5)
{
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-19 06:51:36 +08:00
ssassert(false, "Unexpected CCtrl format");
Save the exact surfaces in the exported file, and import and transform them for assembly. [git-p4: depot-paths = "//depot/solvespace/": change = 1954]
2009-05-19 15:26:38 +08:00
}
crv.exact.ctrl[i] = c;
crv.exact.weight[i] = w;
} else if(StrStartsWith(line, "CurvePt ")) {
SCurvePt scpt;
int vertex;
if(sscanf(line, "CurvePt %d %lf %lf %lf",
&vertex,
&(scpt.p.x), &(scpt.p.y), &(scpt.p.z)) != 4)
{
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-19 06:51:36 +08:00
ssassert(false, "Unexpected CurvePt format");
Save the exact surfaces in the exported file, and import and transform them for assembly. [git-p4: depot-paths = "//depot/solvespace/": change = 1954]
2009-05-19 15:26:38 +08:00
}
scpt.vertex = (vertex != 0);
crv.pts.Add(&scpt);
} else if(strcmp(line, "AddCurve")==0) {
sh->curve.Add(&crv);
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 23:31:23 +08:00
crv = {};
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-19 06:51:36 +08:00
} else ssassert(false, "Unexpected operation");
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
}
fclose(fh);
return true;
}
Add a platform abstraction for message dialogs. This commit changes the awfully specific code for dialogs with messages duplicated three times to go through a generic interface. It also fixes some issues with the way translated messages were parameterized. This commit removes the custom message dialog box used on Windows, for several reasons. First, it was the last element not respecting HiDPI displays. Second, other OSes do not easily provide this much control over rendering default message boxes, and both Gnome and macOS frown upon non-standard renderings such as those; so the custom rendering was already not used on the other OSes.
2018-07-17 23:00:46 +08:00
static Platform::MessageDialog::Response LocateImportedFile(const Platform::Path &filename,
bool canCancel) {
Platform::MessageDialogRef dialog = CreateMessageDialog(SS.GW.window);
using Platform::MessageDialog;
dialog->SetType(MessageDialog::Type::QUESTION);
dialog->SetTitle(C_("title", "Missing File"));
dialog->SetMessage(ssprintf(C_("dialog", "The linked file “%s” is not present."),
filename.raw.c_str()));
dialog->SetDescription(C_("dialog", "Do you want to locate it manually?\n\n"
"If you decline, any geometry that depends on "
"the missing file will be permanently removed."));
dialog->AddButton(C_("button", "&Yes"), MessageDialog::Response::YES,
/*isDefault=*/true);
dialog->AddButton(C_("button", "&No"), MessageDialog::Response::NO);
if(canCancel) {
dialog->AddButton(C_("button", "&Cancel"), MessageDialog::Response::CANCEL);
}
Eliminate blocking in Error() and Message() calls. This serves two purposes. First, we want to (some day) convert these messages into a less obtrustive form, something like toaster notifications, such that they don't interrupt workflow as harshly. That would, of course, be nonblocking. Second, some platforms, like Emscripten, do not support nested event loops, and it's not possible to display a modal dialog on them synchronously. When making this commit, I've reviewed all Error() and Message() calls to ensure that only some of the following is true for all of them: * The call is followed a break or return statement that exits an UI entry point (e.g. an MenuX function); * The call is followed by cleanup (in fact, in this case the new behavior is better, since even with a synchronous modal dialog we have to be reentrant); * The message is an informational message only and nothing unexpected will happen if the operation proceeds in background. In general, all Error() calls already satisfied the above conditions, although in some cases I changed control flow aroudn them to more clearly show that. The Message() calls that didn't satisfy these conditions were reworked into an asynchronous form. There are three explicit RunModal() calls left that need to be reworked into an async form.
2018-07-20 05:54:05 +08:00
// FIXME(async): asyncify this call
Add a platform abstraction for message dialogs. This commit changes the awfully specific code for dialogs with messages duplicated three times to go through a generic interface. It also fixes some issues with the way translated messages were parameterized. This commit removes the custom message dialog box used on Windows, for several reasons. First, it was the last element not respecting HiDPI displays. Second, other OSes do not easily provide this much control over rendering default message boxes, and both Gnome and macOS frown upon non-standard renderings such as those; so the custom rendering was already not used on the other OSes.
2018-07-17 23:00:46 +08:00
return dialog->RunModal();
}
Implement an image request.
2016-11-30 00:49:20 +08:00
bool SolveSpaceUI::ReloadAllLinked(const Platform::Path &saveFile, bool canCancel) {
Add a platform abstraction for file dialogs. This commit merges all ad-hoc file dialog code, such as the feature where dialogs remember last location and format, and exposes it through a common interface. This commit also significantly improves Gtk dialog handling code.
2018-07-18 02:51:00 +08:00
Platform::SettingsRef settings = Platform::GetSettings();
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 22:43:21 +08:00
std::map<Platform::Path, Platform::Path, Platform::PathLess> linkMap;
Rigorously treat paths on every platform. After this commit, SolveSpace deals with paths as follows: * Paths are generally treated as opaque platform-specific strings. This helps on Linux, because paths on Linux don't have any specific encoding and it helps to avoid any operations on them. * The UI in some places wants to get a basename. In this case, the newly introduced PATH_SEP is used. This allows to treat backslash as a regular character, which it is on Linux and OS X. * The only place where any nontrivial operations on paths are performed is the g->impFile/impFileRel logic. Specifically, when saved, g->impFile always contains an absolute path with separators of the current platform, and g->impFileRel always contains a relative path with UNIX separators. This allows to treat backslash as a regular character. Old files will contain g->impFileRel with Windows separators; these are detected by looking for a drive letter in g->impFile and in that case mapping Windows separators to UNIX ones. There is no need to treat UNIX separators (forward slashes) in any special way on Windows because there is no way on Windows, not even via UNC paths, to create or address a directory entry with a forward slash in its name.
2015-12-27 14:35:46 +08:00
Add logic to remember imported files' relative filenames, and use that to try to find them if we can't find them by absolute path. This is intended to make everything still work if you copy an entire directory tree of files that import each other. Also add a mechanism to not paint the scene if we're not sure it's consistent; otherwise got some crashes on startup. And disable both text and graphic window when displaying a modal dialog, wasn't doing that always. [git-p4: depot-paths = "//depot/solvespace/": change = 1808]
2008-06-25 13:14:49 +08:00
allConsistent = false;
Implement an image request.
2016-11-30 00:49:20 +08:00
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 22:43:21 +08:00
for(Group &g : SK.group) {
if(g.type != Group::Type::LINKED) continue;
Add logic to remember imported files' relative filenames, and use that to try to find them if we can't find them by absolute path. This is intended to make everything still work if you copy an entire directory tree of files that import each other. Also add a mechanism to not paint the scene if we're not sure it's consistent; otherwise got some crashes on startup. And disable both text and graphic window when displaying a modal dialog, wasn't doing that always. [git-p4: depot-paths = "//depot/solvespace/": change = 1808]
2008-06-25 13:14:49 +08:00
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 22:43:21 +08:00
g.impEntity.Clear();
g.impMesh.Clear();
g.impShell.Clear();
Add logic to remember imported files' relative filenames, and use that to try to find them if we can't find them by absolute path. This is intended to make everything still work if you copy an entire directory tree of files that import each other. Also add a mechanism to not paint the scene if we're not sure it's consistent; otherwise got some crashes on startup. And disable both text and graphic window when displaying a modal dialog, wasn't doing that always. [git-p4: depot-paths = "//depot/solvespace/": change = 1808]
2008-06-25 13:14:49 +08:00
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 22:43:21 +08:00
// If we prompted for this specific file before, don't ask again.
if(linkMap.count(g.linkFile)) {
g.linkFile = linkMap[g.linkFile];
Ask the user to locate imported files if they cannot be loaded.
2016-01-11 20:18:18 +08:00
}
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 22:43:21 +08:00
try_again:
if(LoadEntitiesFromFile(g.linkFile, &g.impEntity, &g.impMesh, &g.impShell)) {
Implement an image request.
2016-11-30 00:49:20 +08:00
// We loaded the data, good. Now import its dependencies as well.
for(Entity &e : g.impEntity) {
if(e.type != Entity::Type::IMAGE) continue;
if(!ReloadLinkedImage(g.linkFile, &e.file, canCancel)) {
return false;
}
}
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 22:43:21 +08:00
} else if(linkMap.count(g.linkFile) == 0) {
add debug message showing the name of a group whose linked file can't be found.
2020-09-23 02:53:51 +08:00
dbp("Missing file for group: %s", g.name.c_str());
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 22:43:21 +08:00
// The file was moved; prompt the user for its new location.
Suggest sensible defaults in file dialogs Went through first the diff of the referenced commit, then all instances of "Create(Open|Save)FileDialog"; added SuggestFilename() calls where a default exists This has been previously removed in 6b5db5897155ca9bdc5daa3e791c07723a6b7d9c Closes #538
2020-03-22 02:37:14 +08:00
const auto linkFileRelative = g.linkFile.RelativeTo(saveFile);
switch(LocateImportedFile(linkFileRelative, canCancel)) {
Add a platform abstraction for message dialogs. This commit changes the awfully specific code for dialogs with messages duplicated three times to go through a generic interface. It also fixes some issues with the way translated messages were parameterized. This commit removes the custom message dialog box used on Windows, for several reasons. First, it was the last element not respecting HiDPI displays. Second, other OSes do not easily provide this much control over rendering default message boxes, and both Gnome and macOS frown upon non-standard renderings such as those; so the custom rendering was already not used on the other OSes.
2018-07-17 23:00:46 +08:00
case Platform::MessageDialog::Response::YES: {
Add a platform abstraction for file dialogs. This commit merges all ad-hoc file dialog code, such as the feature where dialogs remember last location and format, and exposes it through a common interface. This commit also significantly improves Gtk dialog handling code.
2018-07-18 02:51:00 +08:00
Platform::FileDialogRef dialog = Platform::CreateOpenFileDialog(SS.GW.window);
dialog->AddFilters(Platform::SolveSpaceModelFileFilters);
dialog->ThawChoices(settings, "LinkSketch");
Suggest sensible defaults in file dialogs Went through first the diff of the referenced commit, then all instances of "Create(Open|Save)FileDialog"; added SuggestFilename() calls where a default exists This has been previously removed in 6b5db5897155ca9bdc5daa3e791c07723a6b7d9c Closes #538
2020-03-22 02:37:14 +08:00
dialog->SuggestFilename(linkFileRelative);
Add a platform abstraction for file dialogs. This commit merges all ad-hoc file dialog code, such as the feature where dialogs remember last location and format, and exposes it through a common interface. This commit also significantly improves Gtk dialog handling code.
2018-07-18 02:51:00 +08:00
if(dialog->RunModal()) {
dialog->FreezeChoices(settings, "LinkSketch");
linkMap[g.linkFile] = dialog->GetFilename();
g.linkFile = dialog->GetFilename();
Add a platform abstraction for message dialogs. This commit changes the awfully specific code for dialogs with messages duplicated three times to go through a generic interface. It also fixes some issues with the way translated messages were parameterized. This commit removes the custom message dialog box used on Windows, for several reasons. First, it was the last element not respecting HiDPI displays. Second, other OSes do not easily provide this much control over rendering default message boxes, and both Gnome and macOS frown upon non-standard renderings such as those; so the custom rendering was already not used on the other OSes.
2018-07-17 23:00:46 +08:00
goto try_again;
} else {
if(canCancel) return false;
break;
}
Ask the user to locate imported files if they cannot be loaded.
2016-01-11 20:18:18 +08:00
}
Add a platform abstraction for message dialogs. This commit changes the awfully specific code for dialogs with messages duplicated three times to go through a generic interface. It also fixes some issues with the way translated messages were parameterized. This commit removes the custom message dialog box used on Windows, for several reasons. First, it was the last element not respecting HiDPI displays. Second, other OSes do not easily provide this much control over rendering default message boxes, and both Gnome and macOS frown upon non-standard renderings such as those; so the custom rendering was already not used on the other OSes.
2018-07-17 23:00:46 +08:00
case Platform::MessageDialog::Response::NO:
linkMap[g.linkFile].Clear();
// Geometry will be pruned by GenerateAll().
break;
Ask the user to locate imported files if they cannot be loaded.
2016-01-11 20:18:18 +08:00
Add a platform abstraction for message dialogs. This commit changes the awfully specific code for dialogs with messages duplicated three times to go through a generic interface. It also fixes some issues with the way translated messages were parameterized. This commit removes the custom message dialog box used on Windows, for several reasons. First, it was the last element not respecting HiDPI displays. Second, other OSes do not easily provide this much control over rendering default message boxes, and both Gnome and macOS frown upon non-standard renderings such as those; so the custom rendering was already not used on the other OSes.
2018-07-17 23:00:46 +08:00
case Platform::MessageDialog::Response::CANCEL:
return false;
default:
ssassert(false, "Unexpected dialog response");
Ask the user to locate imported files if they cannot be loaded.
2016-01-11 20:18:18 +08:00
}
Add logic to remember imported files' relative filenames, and use that to try to find them if we can't find them by absolute path. This is intended to make everything still work if you copy an entire directory tree of files that import each other. Also add a mechanism to not paint the scene if we're not sure it's consistent; otherwise got some crashes on startup. And disable both text and graphic window when displaying a modal dialog, wasn't doing that always. [git-p4: depot-paths = "//depot/solvespace/": change = 1808]
2008-06-25 13:14:49 +08:00
} else {
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 22:43:21 +08:00
// User was already asked to and refused to locate a missing linked file.
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
}
}
Ask the user to locate imported files if they cannot be loaded.
2016-01-11 20:18:18 +08:00
Implement an image request.
2016-11-30 00:49:20 +08:00
for(Request &r : SK.request) {
if(r.type != Request::Type::IMAGE) continue;
if(!ReloadLinkedImage(saveFile, &r.file, canCancel)) {
return false;
}
}
Ask the user to locate imported files if they cannot be loaded.
2016-01-11 20:18:18 +08:00
return true;
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 18:10:12 +08:00
}
Implement an image request.
2016-11-30 00:49:20 +08:00
bool SolveSpaceUI::ReloadLinkedImage(const Platform::Path &saveFile,
Platform::Path *filename, bool canCancel) {
Add a platform abstraction for file dialogs. This commit merges all ad-hoc file dialog code, such as the feature where dialogs remember last location and format, and exposes it through a common interface. This commit also significantly improves Gtk dialog handling code.
2018-07-18 02:51:00 +08:00
Platform::SettingsRef settings = Platform::GetSettings();
Implement an image request.
2016-11-30 00:49:20 +08:00
std::shared_ptr<Pixmap> pixmap;
bool promptOpenFile = false;
if(filename->IsEmpty()) {
// We're prompting the user for a new image.
promptOpenFile = true;
} else {
auto image = SS.images.find(*filename);
if(image != SS.images.end()) return true;
pixmap = Pixmap::ReadPng(*filename);
if(pixmap == NULL) {
// The file was moved; prompt the user for its new location.
Add a platform abstraction for message dialogs. This commit changes the awfully specific code for dialogs with messages duplicated three times to go through a generic interface. It also fixes some issues with the way translated messages were parameterized. This commit removes the custom message dialog box used on Windows, for several reasons. First, it was the last element not respecting HiDPI displays. Second, other OSes do not easily provide this much control over rendering default message boxes, and both Gnome and macOS frown upon non-standard renderings such as those; so the custom rendering was already not used on the other OSes.
2018-07-17 23:00:46 +08:00
switch(LocateImportedFile(filename->RelativeTo(saveFile), canCancel)) {
case Platform::MessageDialog::Response::YES:
Implement an image request.
2016-11-30 00:49:20 +08:00
promptOpenFile = true;
break;
Add a platform abstraction for message dialogs. This commit changes the awfully specific code for dialogs with messages duplicated three times to go through a generic interface. It also fixes some issues with the way translated messages were parameterized. This commit removes the custom message dialog box used on Windows, for several reasons. First, it was the last element not respecting HiDPI displays. Second, other OSes do not easily provide this much control over rendering default message boxes, and both Gnome and macOS frown upon non-standard renderings such as those; so the custom rendering was already not used on the other OSes.
2018-07-17 23:00:46 +08:00
case Platform::MessageDialog::Response::NO:
Implement an image request.
2016-11-30 00:49:20 +08:00
// We don't know where the file is, record it as absent.
break;
Add a platform abstraction for message dialogs. This commit changes the awfully specific code for dialogs with messages duplicated three times to go through a generic interface. It also fixes some issues with the way translated messages were parameterized. This commit removes the custom message dialog box used on Windows, for several reasons. First, it was the last element not respecting HiDPI displays. Second, other OSes do not easily provide this much control over rendering default message boxes, and both Gnome and macOS frown upon non-standard renderings such as those; so the custom rendering was already not used on the other OSes.
2018-07-17 23:00:46 +08:00
case Platform::MessageDialog::Response::CANCEL:
Implement an image request.
2016-11-30 00:49:20 +08:00
return false;
Add a platform abstraction for message dialogs. This commit changes the awfully specific code for dialogs with messages duplicated three times to go through a generic interface. It also fixes some issues with the way translated messages were parameterized. This commit removes the custom message dialog box used on Windows, for several reasons. First, it was the last element not respecting HiDPI displays. Second, other OSes do not easily provide this much control over rendering default message boxes, and both Gnome and macOS frown upon non-standard renderings such as those; so the custom rendering was already not used on the other OSes.
2018-07-17 23:00:46 +08:00
default:
ssassert(false, "Unexpected dialog response");
Implement an image request.
2016-11-30 00:49:20 +08:00
}
}
}
if(promptOpenFile) {
Add a platform abstraction for file dialogs. This commit merges all ad-hoc file dialog code, such as the feature where dialogs remember last location and format, and exposes it through a common interface. This commit also significantly improves Gtk dialog handling code.
2018-07-18 02:51:00 +08:00
Platform::FileDialogRef dialog = Platform::CreateOpenFileDialog(SS.GW.window);
dialog->AddFilters(Platform::RasterFileFilters);
dialog->ThawChoices(settings, "LinkImage");
Suggest sensible defaults in file dialogs Went through first the diff of the referenced commit, then all instances of "Create(Open|Save)FileDialog"; added SuggestFilename() calls where a default exists This has been previously removed in 6b5db5897155ca9bdc5daa3e791c07723a6b7d9c Closes #538
2020-03-22 02:37:14 +08:00
dialog->SuggestFilename(filename->RelativeTo(saveFile));
Add a platform abstraction for file dialogs. This commit merges all ad-hoc file dialog code, such as the feature where dialogs remember last location and format, and exposes it through a common interface. This commit also significantly improves Gtk dialog handling code.
2018-07-18 02:51:00 +08:00
if(dialog->RunModal()) {
dialog->FreezeChoices(settings, "LinkImage");
*filename = dialog->GetFilename();
Implement an image request.
2016-11-30 00:49:20 +08:00
pixmap = Pixmap::ReadPng(*filename);
if(pixmap == NULL) {
Error("The image '%s' is corrupted.", filename->raw.c_str());
}
// We know where the file is now, good.
} else if(canCancel) {
return false;
}
}
// We loaded the data, good.
SS.images[*filename] = pixmap;
return true;
}
Reference in New Issue Copy Permalink