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

853 lines
33 KiB
C++
Raw Normal View History

Changes in preparation for the release of SolveSpace under the GPL, to add that license, and change all copyright notices to me, not Useful Subset, LLC. [git-p4: depot-paths = "//depot/solvespace/": change = 2211]
2013-07-28 22:08:34 +00:00
//-----------------------------------------------------------------------------
// 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 11:11:48 +00: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 06:35:56 +00: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 10:10:12 +00: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-26 18:58:35 +00: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 07:26:38 +00: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-02-28 19:23:01 +00: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 05:54:05 +00: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-02-28 19:23:01 +00:00
UndoClearStack(&redo);
UndoClearStack(&undo);
Allow generating groups in arbitrary order.
2016-02-17 10:03:07 +00:00
for(int i = 0; i < SK.groupOrder.n; i++) {
Group *g = SK.GetGroup(SK.groupOrder.elem[i]);
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-02-28 19:23:01 +00:00
g->Clear();
}
SK.constraint.Clear();
SK.request.Clear();
SK.group.Clear();
Allow generating groups in arbitrary order.
2016-02-17 10:03:07 +00: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-02-28 19:23:01 +00:00
SK.style.Clear();
SK.entity.Clear();
SK.param.Clear();
}
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
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 15:31:23 +00: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 11:43:27 +00:00
// And an empty group, for the first stuff the user draws.
g.visible = true;
Allow generating groups in arbitrary order.
2016-02-17 10:03:07 +00:00
g.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 08:31:20 +00:00
g.type = Group::Type::DRAWING_WORKPLANE;
g.subtype = Group::Subtype::WORKPLANE_BY_POINT_ORTHO;
Allow generating groups in arbitrary order.
2016-02-17 10:03:07 +00: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 11:43:27 +00: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 05:53:16 +00: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 11:43:27 +00: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 05:54:05 +00: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-02-28 19:23:01 +00: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 06:22:16 +00: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 15:31:23 +00: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 04:52:34 +00:00
g.visible = true;
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
g.name = "#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 08:31:20 +00:00
g.type = Group::Type::DRAWING_3D;
Allow generating groups in arbitrary order.
2016-02-17 10:03:07 +00: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 06:22:16 +00: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 05:53:16 +00: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 06:22:16 +00: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 15:31:23 +00: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 08:31:20 +00: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 06:22:16 +00: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 03:26:27 +00: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 06:22:16 +00: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 05:53:16 +00: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 06:22:16 +00: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 05:53:16 +00: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 06:22:16 +00: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 05:53:16 +00: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 06:22:16 +00: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 11:43:27 +00: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 02:22:20 +00: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 06:22:16 +00: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-23 17:49:04 +00: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 02:22:20 +00: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 09:53:52 +00: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 08:40:12 +00: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 02:22:20 +00: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 10:18:20 +00: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 08:43:38 +00: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 08:25:17 +00: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-03 23:09:17 +00: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 02:22:20 +00: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 04:36:33 +00: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 02:22:20 +00: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 09:06:26 +00: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 08:29:59 +00: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 02:22:20 +00: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 11:35:15 +00: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 11:22:56 +00: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 15:01:43 +00: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 01:06:09 +00: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 12:26:22 +00: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 02:22:20 +00:00
{ 'g', "Group.remap", 'M', &(SS.sv.g.remap) },
Rename the old "Import / Assemble" feature to "Link / Assemble". This better reflects what it does and avoids clashes with the new DXF import feature.
2016-05-07 05:27:54 +00:00
{ 'g', "Group.impFile", 'S', &(SS.sv.g.linkFile) },
{ 'g', "Group.impFileRel", 'S', &(SS.sv.g.linkFileRel) },
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 02:22:20 +00:00
{ '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 04:46:01 +00: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 02:22:20 +00: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 01:47:59 +00: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 08:40:12 +00:00
{ 'r', "Request.str", 'S', &(SS.sv.r.str) },
{ 'r', "Request.font", 'S', &(SS.sv.r.font) },
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 02:22:20 +00:00
{ '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 01:47:59 +00: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 08:40:12 +00:00
{ 'e', "Entity.str", 'S', &(SS.sv.e.str) },
{ 'e', "Entity.font", 'S', &(SS.sv.e.font) },
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 02:22:20 +00:00
{ '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 04:46:01 +00: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 02:22:20 +00: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 10:10:12 +00: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 04:36:33 +00: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 10:10:12 +00:00
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 02:22:20 +00:00
{ '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 08:43:38 +00:00
{ 'c', "Constraint.valA", 'f', &(SS.sv.c.valA) },
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 02:22:20 +00:00
{ '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 12:24:43 +00: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 12:44:05 +00: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 04:14:06 +00: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 04:22:52 +00: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 08:40:12 +00: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 02:22:20 +00: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 01:47:59 +00: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 02:22:20 +00: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 07:32:36 +00: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 08:40:12 +00: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 07:32:36 +00: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 15:52:48 +00: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 11:35:19 +00: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 15:52:48 +00: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-03 23:09:17 +00:00
{ 's', "Style.color", 'c', &(SS.sv.s.color) },
Oops, fix Style.fillColor export/import too.
2013-11-03 23:41:11 +00: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-22 17:16:20 +00: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 07:32:36 +00: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-23 18:00:39 +00: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 07:32:36 +00: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-26 20:54:04 +00: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 06:22:16 +00: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 12:30:53 +00:00
struct SAVEDptr {
IdList<EntityMap,EntityId> &M() { return *((IdList<EntityMap,EntityId> *)this); }
std::string &S() { return *((std::string *)this); }
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 05:46:40 +00: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-23 17:49:04 +00:00
void SolveSpaceUI::SaveUsingTable(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 06:22:16 +00: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 10:10:12 +00: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 12:30:53 +00: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 10:10:12 +00: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 12:30:53 +00:00
if(fmt == 'S' && p->S().empty()) continue;
if(fmt == 'd' && p->d() == 0) continue;
if(fmt == 'f' && EXACT(p->f() == 0.0)) continue;
if(fmt == 'x' && p->x() == 0) 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 10:10:12 +00: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 12:30:53 +00: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 10:01:23 +00:00
case 'M': {
int j;
fprintf(fh, "{\n");
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 12:30:53 +00:00
for(j = 0; j < p->M().n; j++) {
EntityMap *em = &(p->M().elem[j]);
Trim trailing whitespace.
2015-03-29 00:30:52 +00:00
fprintf(fh, " %d %08x %d\n",
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 10:01:23 +00:00
em->h.v, em->input.v, em->copyNumber);
}
fprintf(fh, "}");
break;
}
Replace all oops() checks with ssassert()s. This includes explanation and context for non-obvious cases and shortens debug cycles when just-in-time debugging is not available (like on Linux) by immediately printing description of the assert as well as symbolized backtrace.
2016-05-18 22:51:36 +00:00
default: ssassert(false, "Unexpected 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 06:22:16 +00:00
}
fprintf(fh, "\n");
}
}
Rewrite all path handling with std::string. What do we gain from this? Several things. * First, usage of PATH_MAX (the POSIX constant) is eliminated. PATH_MAX is actually a lie; Linux and OS X (and probably other BSDs too) do not have an actual path length limit. Linux claims 4096, OS X claims 1024, but it is trivial to construct paths that are longer. * Second, while Windows does enforce a limit of MAX_PATH (the Win32 constant) for its ASCII functions, the Unicode variants, when used with UNC paths, do not have this restriction. The capability to use UNC paths is useful by itself, as it allows to access files on network shares directly. * Third, representing paths as std::string will make it easier to interoperate with *W WinAPI functions later.
2015-12-27 01:03:24 +00:00
bool SolveSpaceUI::SaveToFile(const std::string &filename) {
Treatment of numerical faces was screwy, exporting stuff in numXXX. So fix that, and now I can simplify what's exported for an entity. And add an extra measurement (face-face distance/angle), and some other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 1789]
2008-06-13 04:41:27 +00:00
// Make sure all the entities are regenerated up to date, since they
Rename the old "Import / Assemble" feature to "Link / Assemble". This better reflects what it does and avoids clashes with the new DXF import feature.
2016-05-07 05:27:54 +00:00
// will be exported. We reload the linked files because that rewrites
// the linkFileRel for our possibly-new filename.
Add a GTK2/3 port. In principle, GTK3 is the way forward, and GTK2 is officially deprecated, though still maintained. In practice however, GTK3 is often unbearably buggy; e.g. on my system, combo boxes don't ever roll up in GTK3 windows. So I have added support for both. This required a few minor changes to the core, namely: * GTK wants to know beforehand whether a menu item is a check menu item or a regular one. * GTK doesn't give us an easy way to execute something after any event is processed, so an explicit idle timer is added. This is a no-op on Win32. * A few function signatures were const'ed, since GTK expects immutable strings when converting to Glib::ustring.
2015-03-18 17:02:11 +00:00
SS.ScheduleShowTW();
Improve relative paths for file import. Don't break on case-sensitive filesystems, and don't require an explicit regen after initial save of the assembly.
2015-05-21 12:26:29 +00:00
SS.ReloadAllImported();
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
SS.GenerateAll(SolveSpaceUI::Generate::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 04:41:27 +00:00
Use Unicode-aware fopen and remove on Windows. After this commit, SolveSpace can robustly handle non-ASCII filenames on every OS. Additionally, on Windows, filenames longer than 260 characeters can be used, and files on network shares can be opened directly, without mounting them as a network drive.
2015-12-27 08:09:00 +00:00
fh = ssfopen(filename, "wb");
Trim trailing whitespace.
2015-03-29 00:30:52 +00:00
if(!fh) {
Rewrite all path handling with std::string. What do we gain from this? Several things. * First, usage of PATH_MAX (the POSIX constant) is eliminated. PATH_MAX is actually a lie; Linux and OS X (and probably other BSDs too) do not have an actual path length limit. Linux claims 4096, OS X claims 1024, but it is trivial to construct paths that are longer. * Second, while Windows does enforce a limit of MAX_PATH (the Win32 constant) for its ASCII functions, the Unicode variants, when used with UNC paths, do not have this restriction. The capability to use UNC paths is useful by itself, as it allows to access files on network shares directly. * Third, representing paths as std::string will make it easier to interoperate with *W WinAPI functions later.
2015-12-27 01:03:24 +00:00
Error("Couldn't write to file '%s'", filename.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 11:11:48 +00: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 10:10:12 +00: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 11:11:48 +00: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 07:26:38 +00:00
int i, j;
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
for(i = 0; i < SK.group.n; i++) {
sv.g = SK.group.elem[i];
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 06:22:16 +00:00
SaveUsingTable('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 11:11:48 +00:00
fprintf(fh, "AddGroup\n\n");
}
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
for(i = 0; i < SK.param.n; i++) {
sv.p = SK.param.elem[i];
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 06:22:16 +00:00
SaveUsingTable('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 11:11:48 +00:00
fprintf(fh, "AddParam\n\n");
}
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
for(i = 0; i < SK.request.n; i++) {
sv.r = SK.request.elem[i];
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 06:22:16 +00:00
SaveUsingTable('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 11:11:48 +00:00
fprintf(fh, "AddRequest\n\n");
}
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
for(i = 0; i < SK.entity.n; i++) {
Annotate constants passed as boolean function arguments. This is to ensure that: * it is clear, when looking at the point of usage, what is the purpose of "true" or "false"; * when refactoring, a simple search will bring up any places that need to be changed. Also, argument names were synchronized between declaration and implementation. As an exception, these are not annotated: * Printf(/*halfLine=*/), to avoid pointless churn.
2016-05-25 12:08:19 +00:00
(SK.entity.elem[i]).CalculateNumerical(/*forExport=*/true);
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
sv.e = SK.entity.elem[i];
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 06:22:16 +00:00
SaveUsingTable('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 11:11:48 +00:00
fprintf(fh, "AddEntity\n\n");
}
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
for(i = 0; i < SK.constraint.n; i++) {
sv.c = SK.constraint.elem[i];
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 06:22:16 +00:00
SaveUsingTable('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 11:11:48 +00:00
fprintf(fh, "AddConstraint\n\n");
}
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 07:32:36 +00:00
for(i = 0; i < SK.style.n; i++) {
sv.s = SK.style.elem[i];
if(sv.s.h.v >= Style::FIRST_CUSTOM) {
SaveUsingTable('s');
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 09:06:26 +00: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.
Allow generating groups in arbitrary order.
2016-02-17 10:03:07 +00:00
Group *g = SK.GetGroup(SK.groupOrder.elem[SK.groupOrder.n - 1]);
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 10:10:12 +00:00
for(i = 0; i < m->l.n; i++) {
STriangle *tr = &(m->l.elem[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 10:30:12 +00: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 06:39:32 +00: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-16 20:00:58 +00: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 10:10:12 +00:00
CO(tr->a), CO(tr->b), CO(tr->c));
}
Allow generating groups in arbitrary order.
2016-02-17 10:03:07 +00: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 07:26:38 +00: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-16 20:00:58 +00: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 07:26:38 +00: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 00:30:52 +00: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 07:26:38 +00: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 11:11:48 +00:00
fclose(fh);
return true;
}
Pack everything into `namespace SolveSpace`. This is required to avoid name conflicts with the Cocoa libraries on OS X. I renamed the `class SolveSpace` to `class SolveSpaceUI`, because that's what it does, and because otherwise the namespace would have to be called something else than `namespace SolveSpace`.
2015-03-23 17:49:04 +00:00
void SolveSpaceUI::LoadUsingTable(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 10:01:23 +00: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 12:30:53 +00: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 05:45:13 +00: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 10:01:23 +00: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 12:30:53 +00: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 10:01:23 +00:00
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-03 23:09:17 +00: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 12:30:53 +00: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-03 23:09:17 +00:00
break;
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 10:10:12 +00:00
case 'P':
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 12:30:53 +00:00
p->S() = 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 10:10:12 +00: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 10:01:23 +00:00
case 'M': {
Add transformed points and normals with a rotation (as well as a translation; or equivalently, rotation about an arbitrary axis). Those will be important for step and repeats, and for imported parts. Also fix a terrible memory corruption bug: I was freeing the remap list after I loaded it from the file, but the code that put that into the SS.group list made only a shallow copy. [git-p4: depot-paths = "//depot/solvespace/": change = 1715]
2008-05-11 06:09:46 +00:00
// Don't clear this list! When the group gets added, it
// makes a shallow copy, so that would result in us
// freeing memory that we want to keep around. Just
// zero it out so that new memory is allocated.
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 12:30:53 +00:00
p->M() = {};
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 10:01:23 +00:00
for(;;) {
EntityMap em;
char line2[1024];
Don't ignore the return value of fgets() and fread()
2013-08-26 20:48:41 +00:00
if (fgets(line2, (int)sizeof(line2), fh) == NULL)
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 10:01:23 +00:00
if(sscanf(line2, "%d %x %d", &(em.h.v), &(em.input.v),
&(em.copyNumber)) == 3)
{
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 12:30:53 +00:00
p->M().Add(&em);
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 10:01:23 +00:00
} else {
break;
}
}
break;
}
Replace all oops() checks with ssassert()s. This includes explanation and context for non-obvious cases and shortens debug cycles when just-in-time debugging is not available (like on Linux) by immediately printing description of the assert as well as symbolized backtrace.
2016-05-18 22:51:36 +00:00
default: ssassert(false, "Unexpected 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 10:01:23 +00: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 12:26:22 +00: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 10:01:23 +00:00
}
Rewrite all path handling with std::string. What do we gain from this? Several things. * First, usage of PATH_MAX (the POSIX constant) is eliminated. PATH_MAX is actually a lie; Linux and OS X (and probably other BSDs too) do not have an actual path length limit. Linux claims 4096, OS X claims 1024, but it is trivial to construct paths that are longer. * Second, while Windows does enforce a limit of MAX_PATH (the Win32 constant) for its ASCII functions, the Unicode variants, when used with UNC paths, do not have this restriction. The capability to use UNC paths is useful by itself, as it allows to access files on network shares directly. * Third, representing paths as std::string will make it easier to interoperate with *W WinAPI functions later.
2015-12-27 01:03:24 +00:00
bool SolveSpaceUI::LoadFromFile(const std::string &filename) {
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 05:14:49 +00: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 12:26:22 +00: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 05:14:49 +00:00
Use Unicode-aware fopen and remove on Windows. After this commit, SolveSpace can robustly handle non-ASCII filenames on every OS. Additionally, on Windows, filenames longer than 260 characeters can be used, and files on network shares can be opened directly, without mounting them as a network drive.
2015-12-27 08:09:00 +00:00
fh = ssfopen(filename, "rb");
Trim trailing whitespace.
2015-03-29 00:30:52 +00:00
if(!fh) {
Rewrite all path handling with std::string. What do we gain from this? Several things. * First, usage of PATH_MAX (the POSIX constant) is eliminated. PATH_MAX is actually a lie; Linux and OS X (and probably other BSDs too) do not have an actual path length limit. Linux claims 4096, OS X claims 1024, but it is trivial to construct paths that are longer. * Second, while Windows does enforce a limit of MAX_PATH (the Win32 constant) for its ASCII functions, the Unicode variants, when used with UNC paths, do not have this restriction. The capability to use UNC paths is useful by itself, as it allows to access files on network shares directly. * Third, representing paths as std::string will make it easier to interoperate with *W WinAPI functions later.
2015-12-27 01:03:24 +00:00
Error("Couldn't read from file '%s'", filename.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 11:11:48 +00: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-02-28 19:23:01 +00: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 07:31:41 +00: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 15:31:23 +00: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 12:26:22 +00:00
sv.g.scale = 1; // default is 1, not 0; so legacy files need this
Extract Style::FillDefaultStyle.
2016-02-27 06:15:15 +00: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 06:22:16 +00: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-26 20:09:15 +00: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 06:22:16 +00: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 08:18:54 +00: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 06:22:16 +00:00
if(*line == '\0') continue;
Trim trailing whitespace.
2015-03-29 00:30:52 +00: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 06:22:16 +00:00
char *e = strchr(line, '=');
if(e) {
*e = '\0';
char *key = line, *val = e+1;
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 10:01:23 +00:00
LoadUsingTable(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 06:22:16 +00: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 05:27:54 +00: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 05:43:41 +00: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 08:31:20 +00: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 05:43:41 +00: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 05:53:16 +00: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 15:31:23 +00: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 12:26:22 +00: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 06:22:16 +00: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 05:53:16 +00: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 15:31:23 +00: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 06:22:16 +00: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 05:53:16 +00: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 15:31:23 +00: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 06:22:16 +00: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 05:53:16 +00: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 15:31:23 +00: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 07:32:36 +00: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 15:31:23 +00:00
sv.s = {};
Extract Style::FillDefaultStyle.
2016-02-27 06:15:15 +00: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 10:10:12 +00: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 06:22:16 +00: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 07:26:38 +00: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 06:22:16 +00: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 12:26:22 +00: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 06:22:16 +00: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 12:26:22 +00:00
if(fileLoadError) {
Error("Unrecognized data in file. This file may be corrupt, or "
"from a new 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 01:32:36 +00:00
// At least leave the program in a non-crashing state.
if(SK.group.n == 0) {
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 12:26:22 +00:00
}
Rename some stuff in the IdList again. Rough in the file save stuff, though no file load stuff, and perhaps this can all be made to work from a table somehow. Move the quaternion stuff into its own class, and add a fancy animated view when you orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1672]
2008-04-18 11:11:48 +00:00
return true;
}
Rewrite all path handling with std::string. What do we gain from this? Several things. * First, usage of PATH_MAX (the POSIX constant) is eliminated. PATH_MAX is actually a lie; Linux and OS X (and probably other BSDs too) do not have an actual path length limit. Linux claims 4096, OS X claims 1024, but it is trivial to construct paths that are longer. * Second, while Windows does enforce a limit of MAX_PATH (the Win32 constant) for its ASCII functions, the Unicode variants, when used with UNC paths, do not have this restriction. The capability to use UNC paths is useful by itself, as it allows to access files on network shares directly. * Third, representing paths as std::string will make it easier to interoperate with *W WinAPI functions later.
2015-12-27 01:03:24 +00:00
bool SolveSpaceUI::LoadEntitiesFromFile(const std::string &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 15:31:23 +00:00
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 07:26:38 +00: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 15:31:23 +00: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 07:26:38 +00:00
Use Unicode-aware fopen and remove on Windows. After this commit, SolveSpace can robustly handle non-ASCII filenames on every OS. Additionally, on Windows, filenames longer than 260 characeters can be used, and files on network shares can be opened directly, without mounting them as a network drive.
2015-12-27 08:09:00 +00:00
fh = ssfopen(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 10:10:12 +00: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 15:31:23 +00: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 10:10:12 +00: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-26 20:09:15 +00: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 10:10:12 +00: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 08:18:54 +00: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 10:10:12 +00:00
if(*line == '\0') continue;
Trim trailing whitespace.
2015-03-29 00:30:52 +00: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 10:10:12 +00:00
char *e = strchr(line, '=');
if(e) {
*e = '\0';
char *key = line, *val = e+1;
LoadUsingTable(key, val);
} else if(strcmp(line, "AddGroup")==0) {
Add undo/redo. This saves the param guesses, constraints, groups, and requests to a separate list. It's messy, because I have to make a deep copy (e.g. of the remap list for the groups, or Expr * stuff) of some things. Others (e.g. the polygon or mesh) will be regenerated, so they should be discarded, but they must not get double-freed. In any case, works superficially. And fix a few memory leaks unrelated to this, and remove some dead code. [git-p4: depot-paths = "//depot/solvespace/": change = 1775]
2008-06-04 10:22:30 +00:00
// Don't leak memory; 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 10:10:12 +00: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 15:31:23 +00: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 10:10:12 +00: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 08:43:38 +00:00
Add ability to assign styles to cosmetic text (in the form of Constraint::COMMENTs), including line width and color, and text height and origin location. [git-p4: depot-paths = "//depot/solvespace/": change = 2033]
2009-09-24 15:52:48 +00:00
} else if(strcmp(line, "AddStyle")==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 10:10:12 +00: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 07:26:38 +00: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 15:31:23 +00: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 10:30:12 +00: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 06:09:41 +00: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 10:30:12 +00:00
&(tr.meta.face), &rgba,
Trim trailing whitespace.
2015-03-29 00:30:52 +00: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 10:30:12 +00: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-18 22:51:36 +00: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 10:10:12 +00:00
}
Rename RgbColor to RgbaColor.
2015-07-10 11:54:39 +00: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 10:10:12 +00: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 07:26:38 +00: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 10:30:12 +00: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 07:26:38 +00: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 10:30:12 +00: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-18 22:51:36 +00: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 07:26:38 +00:00
}
Rename RgbColor to RgbaColor.
2015-07-10 11:54:39 +00: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 07:26:38 +00: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-18 22:51:36 +00: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 07:26:38 +00: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 15:31:23 +00: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 07:26:38 +00: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-18 22:51:36 +00: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 07:26:38 +00: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 15:31:23 +00: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 07:26:38 +00: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-18 22:51:36 +00: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 07:26:38 +00: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-18 22:51:36 +00: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 07:26:38 +00: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-18 22:51:36 +00: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 07:26:38 +00: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 15:31:23 +00: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-18 22:51:36 +00: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 10:10:12 +00:00
}
fclose(fh);
return true;
}
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 06:35:46 +00:00
//-----------------------------------------------------------------------------
Rename the old "Import / Assemble" feature to "Link / Assemble". This better reflects what it does and avoids clashes with the new DXF import feature.
2016-05-07 05:27:54 +00:00
// Handling of the relative-absolute path transformations for links
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 06:35:46 +00:00
//-----------------------------------------------------------------------------
static std::vector<std::string> Split(const std::string &haystack, const std::string &needle)
{
std::vector<std::string> result;
size_t oldpos = 0, pos = 0;
while(true) {
oldpos = pos;
pos = haystack.find(needle, pos);
if(pos == std::string::npos) break;
result.push_back(haystack.substr(oldpos, pos - oldpos));
pos += needle.length();
}
if(oldpos != haystack.length() - 1)
result.push_back(haystack.substr(oldpos));
return result;
}
static std::string Join(const std::vector<std::string> &parts, const std::string &separator)
{
bool first = true;
std::string result;
for(auto &part : parts) {
if(!first) result += separator;
result += part;
first = false;
}
return result;
}
static std::string MakePathRelative(const std::string &base, const std::string &path)
{
std::vector<std::string> baseParts = Split(base, PATH_SEP),
pathParts = Split(path, PATH_SEP),
resultParts;
baseParts.pop_back();
Use size_t for indexing where appropriate. MSVC (rightly) complains about this.
2016-02-12 05:25:19 +00:00
size_t common;
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 06:35:46 +00:00
for(common = 0; common < baseParts.size() && common < pathParts.size(); common++) {
Abstract all (ex-OpenGL) drawing operations into a Canvas interface. This has several desirable consequences: * It is now possible to port SolveSpace to a later version of OpenGL, such as OpenGLES 2, so that it runs on platforms that only have that OpenGL version; * The majority of geometry is now rendered without references to the camera in C++ code, so a renderer can now submit it to the video card once and re-rasterize with a different projection matrix every time the projection is changed, avoiding expensive reuploads; * The DOGD (draw or get distance) interface is now a straightforward Canvas implementation; * There are no more direct references to SS.GW.(projection) in sketch rendering code, which allows rendering to multiple viewports; * There are no more unnecessary framebuffer flips on CPU on Cocoa and GTK; * The platform-dependent GL code is now confined to rendergl1.cpp. * The Microsoft and Apple headers required by it that are prone to identifier conflicts are no longer included globally; * The rendergl1.cpp implementation can now be omitted from compilation to run SolveSpace headless or with a different OpenGL version. Note these implementation details of Canvas: * GetCamera currently always returns a reference to the field `Camera camera;`. This is so that a future renderer that caches geometry in the video memory can define it as asserting, which would provide assurance against code that could accidentally put something projection-dependent in the cache; * Line and triangle rendering is specified through a level of indirection, hStroke and hFill. This is so that a future renderer that batches geometry could cheaply group identical styles. * DrawPixmap and DrawVectorText accept a (o,u,v) and not a matrix. This is so that a future renderer into an output format that uses 2d transforms (e.g. SVG) could easily derive those. Some additional internal changes were required to enable this: * Pixmap is now always passed as std::shared_ptr<{const ,}Pixmap>. This is so that the renderer could cache uploaded textures between API calls, which requires it to capture a (weak) reference. * The PlatformPathEqual function was properly extracted into platform-specific code. This is so that the <windows.h> header could be included only where needed (in platform/w32* as well as rendergl1.cpp). * The SBsp{2,3}::DebugDraw functions were removed. They can be rewritten using the Canvas API if they are ever needed. While no visual changes were originally intended, some minor fixes happened anyway: * The "emphasis" yellow line from top-left corner is now correctly rendered much wider. * The marquee rectangle is now pixel grid aligned. * The hidden entities now do not clobber the depth buffer, removing some minor artifacts. * The workplane "tab" now scales with the font used to render the workplane name. * The workplane name font is now taken from the normals style. * Workplane and constraint line stipple is insignificantly different. This is so that it can reuse the existing stipple codepaths; rendering of workplanes and constraints predates those. Some debug functionality was added: * In graphics window, an fps counter that becomes red when rendering under 60fps is drawn.
2016-05-31 00:55:13 +00:00
if(!PathEqual(baseParts[common], pathParts[common]))
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 06:35:46 +00:00
break;
}
Use size_t for indexing where appropriate. MSVC (rightly) complains about this.
2016-02-12 05:25:19 +00:00
for(size_t i = common; i < baseParts.size(); i++)
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 06:35:46 +00:00
resultParts.push_back("..");
resultParts.insert(resultParts.end(),
pathParts.begin() + common, pathParts.end());
return Join(resultParts, PATH_SEP);
}
static std::string MakePathAbsolute(const std::string &base, const std::string &path)
{
std::vector<std::string> resultParts = Split(base, PATH_SEP),
pathParts = Split(path, PATH_SEP);
resultParts.pop_back();
for(auto &part : pathParts) {
if(part == ".") {
/* do nothing */
} else if(part == "..") {
Replace all oops() checks with ssassert()s. This includes explanation and context for non-obvious cases and shortens debug cycles when just-in-time debugging is not available (like on Linux) by immediately printing description of the assert as well as symbolized backtrace.
2016-05-18 22:51:36 +00:00
ssassert(!resultParts.empty(), "Relative path pointing outside of root directory");
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 06:35:46 +00:00
resultParts.pop_back();
} else {
resultParts.push_back(part);
}
}
return Join(resultParts, PATH_SEP);
}
static void PathSepNormalize(std::string &filename)
{
Use size_t for indexing where appropriate. MSVC (rightly) complains about this.
2016-02-12 05:25:19 +00:00
for(size_t i = 0; i < filename.length(); i++) {
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 06:35:46 +00:00
if(filename[i] == '\\')
filename[i] = '/';
}
}
static std::string PathSepPlatformToUNIX(const std::string &filename)
{
#if defined(WIN32)
std::string result = filename;
Use size_t for indexing where appropriate. MSVC (rightly) complains about this.
2016-02-12 05:25:19 +00:00
for(size_t i = 0; i < result.length(); i++) {
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 06:35:46 +00:00
if(result[i] == '\\')
result[i] = '/';
}
return result;
#else
return filename;
#endif
}
static std::string PathSepUNIXToPlatform(const std::string &filename)
{
#if defined(WIN32)
std::string result = filename;
Use size_t for indexing where appropriate. MSVC (rightly) complains about this.
2016-02-12 05:25:19 +00:00
for(size_t i = 0; i < result.length(); i++) {
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 06:35:46 +00:00
if(result[i] == '/')
result[i] = '\\';
}
return result;
#else
return filename;
#endif
}
Ask the user to locate imported files if they cannot be loaded.
2016-01-11 12:18:18 +00:00
bool SolveSpaceUI::ReloadAllImported(bool canCancel)
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 06:35:46 +00:00
{
Rename the old "Import / Assemble" feature to "Link / Assemble". This better reflects what it does and avoids clashes with the new DXF import feature.
2016-05-07 05:27:54 +00:00
std::map<std::string, std::string> linkMap;
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 05:14:49 +00:00
allConsistent = 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 10:10:12 +00:00
int i;
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
for(i = 0; i < SK.group.n; i++) {
Group *g = &(SK.group.elem[i]);
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(g->type != Group::Type::LINKED) 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 10:10:12 +00:00
Rename the old "Import / Assemble" feature to "Link / Assemble". This better reflects what it does and avoids clashes with the new DXF import feature.
2016-05-07 05:27:54 +00:00
if(isalpha(g->linkFile[0]) && g->linkFile[1] == ':') {
// Make sure that g->linkFileRel always contains a relative path
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 06:35:46 +00:00
// in an UNIX format, even after we load an old file which had
// the path in Windows format
Rename the old "Import / Assemble" feature to "Link / Assemble". This better reflects what it does and avoids clashes with the new DXF import feature.
2016-05-07 05:27:54 +00:00
PathSepNormalize(g->linkFileRel);
Replace \ with / slashes in assembly relative paths on *nix. This is done specifically targeting the case where an assembly initially made on Windows is transported to an *nix machine. On *nix, the paths will be already saved with /, and correctly read on Windows. On Windows however / is not a first-class separator, in particular it cannot be used in UNC-style paths \\?\ (which are the only paths that work with Unicode). See also: http://msdn.microsoft.com/en-us/library/aa365247.aspx
2015-03-30 00:09:28 +00: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 10:10:12 +00:00
g->impEntity.Clear();
g->impMesh.Clear();
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 07:26:38 +00:00
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 05:14:49 +00:00
Rename the old "Import / Assemble" feature to "Link / Assemble". This better reflects what it does and avoids clashes with the new DXF import feature.
2016-05-07 05:27:54 +00:00
if(linkMap.count(g->linkFile)) {
std::string newPath = linkMap[g->linkFile];
Ask the user to locate imported files if they cannot be loaded.
2016-01-11 12:18:18 +00:00
if(!newPath.empty())
Rename the old "Import / Assemble" feature to "Link / Assemble". This better reflects what it does and avoids clashes with the new DXF import feature.
2016-05-07 05:27:54 +00:00
g->linkFile = newPath;
Ask the user to locate imported files if they cannot be loaded.
2016-01-11 12:18:18 +00:00
}
Unbreak importing files in the same directory as current file. This commit fixes a bug introduced in commit 0d7aa0a1.
2016-06-06 16:05:37 +00:00
// In a newly created group we only have an absolute path.
if(!g->linkFileRel.empty()) {
std::string rel = PathSepUNIXToPlatform(g->linkFileRel);
std::string fromRel = MakePathAbsolute(SS.saveFile, rel);
FILE *test = ssfopen(fromRel, "rb");
if(test) {
fclose(test);
// Okay, exists; update the absolute path.
g->linkFile = fromRel;
} else {
// It doesn't exist. Perhaps the file was moved but the tree wasn't, and we
// can use the absolute filename to get us back. The relative path will be
// updated below.
}
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 05:14:49 +00:00
}
Ask the user to locate imported files if they cannot be loaded.
2016-01-11 12:18:18 +00:00
try_load_file:
Rename the old "Import / Assemble" feature to "Link / Assemble". This better reflects what it does and avoids clashes with the new DXF import feature.
2016-05-07 05:27:54 +00:00
if(LoadEntitiesFromFile(g->linkFile, &(g->impEntity), &(g->impMesh), &(g->impShell)))
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 07:26:38 +00:00
{
Rewrite all path handling with std::string. What do we gain from this? Several things. * First, usage of PATH_MAX (the POSIX constant) is eliminated. PATH_MAX is actually a lie; Linux and OS X (and probably other BSDs too) do not have an actual path length limit. Linux claims 4096, OS X claims 1024, but it is trivial to construct paths that are longer. * Second, while Windows does enforce a limit of MAX_PATH (the Win32 constant) for its ASCII functions, the Unicode variants, when used with UNC paths, do not have this restriction. The capability to use UNC paths is useful by itself, as it allows to access files on network shares directly. * Third, representing paths as std::string will make it easier to interoperate with *W WinAPI functions later.
2015-12-27 01:03:24 +00:00
if(!SS.saveFile.empty()) {
Rename the old "Import / Assemble" feature to "Link / Assemble". This better reflects what it does and avoids clashes with the new DXF import feature.
2016-05-07 05:27:54 +00:00
// Record the linked file's name relative to our filename;
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 05:14:49 +00:00
// if the entire tree moves, then everything will still work
Rename the old "Import / Assemble" feature to "Link / Assemble". This better reflects what it does and avoids clashes with the new DXF import feature.
2016-05-07 05:27:54 +00:00
std::string rel = MakePathRelative(SS.saveFile, g->linkFile);
g->linkFileRel = PathSepPlatformToUNIX(rel);
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 05:14:49 +00:00
} else {
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 06:35:46 +00:00
// We're not yet saved, so can't make it absolute.
// This will only be used for display purposes, as SS.saveFile
// is always nonempty when we are actually writing anything.
Rename the old "Import / Assemble" feature to "Link / Assemble". This better reflects what it does and avoids clashes with the new DXF import feature.
2016-05-07 05:27:54 +00:00
g->linkFileRel = g->linkFile;
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 05:14:49 +00:00
}
Rename the old "Import / Assemble" feature to "Link / Assemble". This better reflects what it does and avoids clashes with the new DXF import feature.
2016-05-07 05:27:54 +00:00
} else if(!linkMap.count(g->linkFile)) {
switch(LocateImportedFileYesNoCancel(g->linkFileRel, canCancel)) {
Ask the user to locate imported files if they cannot be loaded.
2016-01-11 12:18:18 +00:00
case DIALOG_YES: {
Rename the old "Import / Assemble" feature to "Link / Assemble". This better reflects what it does and avoids clashes with the new DXF import feature.
2016-05-07 05:27:54 +00:00
std::string oldImpFile = g->linkFile;
if(!GetOpenFile(&g->linkFile, "", SlvsFileFilter)) {
Ask the user to locate imported files if they cannot be loaded.
2016-01-11 12:18:18 +00:00
if(canCancel)
return false;
break;
} else {
Rename the old "Import / Assemble" feature to "Link / Assemble". This better reflects what it does and avoids clashes with the new DXF import feature.
2016-05-07 05:27:54 +00:00
linkMap[oldImpFile] = g->linkFile;
Ask the user to locate imported files if they cannot be loaded.
2016-01-11 12:18:18 +00:00
goto try_load_file;
}
}
case DIALOG_NO:
Rename the old "Import / Assemble" feature to "Link / Assemble". This better reflects what it does and avoids clashes with the new DXF import feature.
2016-05-07 05:27:54 +00:00
linkMap[g->linkFile] = "";
Ask the user to locate imported files if they cannot be loaded.
2016-01-11 12:18:18 +00:00
/* Geometry will be pruned by GenerateAll(). */
break;
case DIALOG_CANCEL:
return 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 05:14:49 +00:00
} else {
Ask the user to locate imported files if they cannot be loaded.
2016-01-11 12:18:18 +00:00
// User was already asked to and refused to locate a missing
Rename the old "Import / Assemble" feature to "Link / Assemble". This better reflects what it does and avoids clashes with the new DXF import feature.
2016-05-07 05:27:54 +00:00
// 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 10:10:12 +00:00
}
}
Ask the user to locate imported files if they cannot be loaded.
2016-01-11 12:18:18 +00: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 10:10:12 +00:00
}