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

432 lines
15 KiB
C++
Raw Normal View History

Changes in preparation for the release of SolveSpace under the GPL, to add that license, and change all copyright notices to me, not Useful Subset, LLC. [git-p4: depot-paths = "//depot/solvespace/": change = 2211]
2013-07-28 22:08:34 +00:00
//-----------------------------------------------------------------------------
// The clipboard that gets manipulated when the user selects Edit -> Cut,
// Copy, Paste, etc.; may contain entities only, not constraints.
//
// Copyright 2008-2013 Jonathan Westhues.
//-----------------------------------------------------------------------------
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
#include "solvespace.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::Clipboard::Clear() {
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
c.Clear();
r.Clear();
}
Copy any constraints that only refer to entities in the clipboard.
2015-12-30 12:36:31 +00:00
bool SolveSpaceUI::Clipboard::ContainsEntity(hEntity he) {
if(he.v == Entity::NO_ENTITY.v)
return true;
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
ClipboardRequest *cr;
for(cr = r.First(); cr; cr = r.NextAfter(cr)) {
Copy any constraints that only refer to entities in the clipboard.
2015-12-30 12:36:31 +00:00
if(cr->oldEnt.v == he.v)
return true;
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
for(int i = 0; i < MAX_POINTS_IN_ENTITY; i++) {
Copy any constraints that only refer to entities in the clipboard.
2015-12-30 12:36:31 +00:00
if(cr->oldPointEnt[i].v == he.v)
return true;
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
}
}
Copy any constraints that only refer to entities in the clipboard.
2015-12-30 12:36:31 +00:00
return false;
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
}
Copy any constraints that only refer to entities in the clipboard.
2015-12-30 12:36:31 +00:00
hEntity SolveSpaceUI::Clipboard::NewEntityFor(hEntity he) {
if(he.v == Entity::NO_ENTITY.v)
return Entity::NO_ENTITY;
ClipboardRequest *cr;
for(cr = r.First(); cr; cr = r.NextAfter(cr)) {
if(cr->oldEnt.v == he.v)
return cr->newReq.entity(0);
for(int i = 0; i < MAX_POINTS_IN_ENTITY; i++) {
if(cr->oldPointEnt[i].v == he.v)
return cr->newReq.entity(1+i);
}
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
}
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, "Expected to find entity in some clipboard request");
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
}
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void GraphicsWindow::DeleteSelection() {
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
SK.request.ClearTags();
SK.constraint.ClearTags();
List<Selection> *ls = &(selection);
for(Selection *s = ls->First(); s; s = ls->NextAfter(s)) {
hRequest r = { 0 };
if(s->entity.v && s->entity.isFromRequest()) {
r = s->entity.request();
}
if(r.v && !r.IsFromReferences()) {
SK.request.Tag(r, 1);
}
if(s->constraint.v) {
SK.constraint.Tag(s->constraint, 1);
}
}
SK.constraint.RemoveTagged();
// Note that this regenerates and clears the selection, to avoid
// lingering references to the just-deleted items.
DeleteTaggedRequests();
}
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void GraphicsWindow::CopySelection() {
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
SS.clipboard.Clear();
Entity *wrkpl = SK.GetEntity(ActiveWorkplane());
Entity *wrkpln = SK.GetEntity(wrkpl->normal);
Vector u = wrkpln->NormalU(),
v = wrkpln->NormalV(),
n = wrkpln->NormalN(),
p = SK.GetEntity(wrkpl->point[0])->PointGetNum();
List<Selection> *ls = &(selection);
for(Selection *s = ls->First(); s; s = ls->NextAfter(s)) {
if(!s->entity.v) continue;
// Work only on entities that have requests that will generate them.
Entity *e = SK.GetEntity(s->entity);
bool hasDistance;
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
Request::Type req;
int pts;
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
if(!EntReqTable::GetEntityInfo(e->type, e->extraPoints,
&req, &pts, NULL, &hasDistance))
{
continue;
}
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(req == Request::Type::WORKPLANE) continue;
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
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
ClipboardRequest cr = {};
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
cr.type = req;
cr.extraPoints = e->extraPoints;
cr.style = 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
cr.str = e->str;
cr.font = e->font;
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
cr.construction = e->construction;
Various fixes for warnings and minutia This commit consists of numerous small changes, none significant enough to merit a commit on their own: * Added extra braces to quash for-loop variable scoping issues for older compilers (or "g++ -fno-for-scope") * Appeased "unreachable code" warnings, spurious or otherwise * Added casts to fix integer-variable signedness warnings * Added a dummy virtual method to the VectorFileWriter class to silence the -Wweak-vtables warning from Clang++ * Renamed some parameters in the Expr and GraphicsWindow classes to eliminate "parameter shadows a field" warnings * Removed an inert "0 ||" from a conditional, and changed a "&& 0" into an "#if 0" * Added missing elements to array/struct/class initializers to zap further warnings * Indented some cpp conditionals where appropriate * Qualified some variables and functions as static to quiet "no previous declaration" warnings * toolbar.cpp needed to #include<icons-proto.h> to fix those same "no previous declaration" warnings from icons.h * Added some casts and const qualifiers to the Win32 code to address warnings produced by g++ when compiling under MinGW * Rewrote Cnf{Freeze,Thaw}Float() to use a union rather than pointer aliasing; this makes g++ a lot happier * Removed redundant #includes from win32/w32util.cpp * With Jonathan's blessing, shortened the last line of the About dialog text to better match the preceding lines
2013-10-19 05:36:45 +00:00
{for(int i = 0; i < pts; i++) {
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
Vector pt = SK.GetEntity(e->point[i])->PointGetNum();
pt = pt.Minus(p);
pt = pt.DotInToCsys(u, v, n);
cr.point[i] = pt;
Various fixes for warnings and minutia This commit consists of numerous small changes, none significant enough to merit a commit on their own: * Added extra braces to quash for-loop variable scoping issues for older compilers (or "g++ -fno-for-scope") * Appeased "unreachable code" warnings, spurious or otherwise * Added casts to fix integer-variable signedness warnings * Added a dummy virtual method to the VectorFileWriter class to silence the -Wweak-vtables warning from Clang++ * Renamed some parameters in the Expr and GraphicsWindow classes to eliminate "parameter shadows a field" warnings * Removed an inert "0 ||" from a conditional, and changed a "&& 0" into an "#if 0" * Added missing elements to array/struct/class initializers to zap further warnings * Indented some cpp conditionals where appropriate * Qualified some variables and functions as static to quiet "no previous declaration" warnings * toolbar.cpp needed to #include<icons-proto.h> to fix those same "no previous declaration" warnings from icons.h * Added some casts and const qualifiers to the Win32 code to address warnings produced by g++ when compiling under MinGW * Rewrote Cnf{Freeze,Thaw}Float() to use a union rather than pointer aliasing; this makes g++ a lot happier * Removed redundant #includes from win32/w32util.cpp * With Jonathan's blessing, shortened the last line of the About dialog text to better match the preceding lines
2013-10-19 05:36:45 +00:00
}}
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
if(hasDistance) {
cr.distance = SK.GetEntity(e->distance)->DistanceGetNum();
}
cr.oldEnt = e->h;
for(int i = 0; i < pts; i++) {
cr.oldPointEnt[i] = e->point[i];
}
SS.clipboard.r.Add(&cr);
}
Allow copying and pasting constraints.
2016-05-20 14:19:50 +00:00
for(Selection *s = ls->First(); s; s = ls->NextAfter(s)) {
if(!s->constraint.v) continue;
Constraint *c = SK.GetConstraint(s->constraint);
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(c->type == Constraint::Type::COMMENT) {
Allow copying and pasting constraints.
2016-05-20 14:19:50 +00:00
SS.clipboard.c.Add(c);
}
}
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
Constraint *c;
for(c = SK.constraint.First(); c; c = SK.constraint.NextAfter(c)) {
Copy any constraints that only refer to entities in the clipboard.
2015-12-30 12:36:31 +00:00
if(!SS.clipboard.ContainsEntity(c->ptA) ||
!SS.clipboard.ContainsEntity(c->ptB) ||
!SS.clipboard.ContainsEntity(c->entityA) ||
!SS.clipboard.ContainsEntity(c->entityB) ||
!SS.clipboard.ContainsEntity(c->entityC) ||
Allow copying and pasting constraints.
2016-05-20 14:19:50 +00:00
!SS.clipboard.ContainsEntity(c->entityD) ||
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
c->type == Constraint::Type::COMMENT) {
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
continue;
}
SS.clipboard.c.Add(c);
}
}
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
void GraphicsWindow::PasteClipboard(Vector trans, double theta, double scale) {
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
Entity *wrkpl = SK.GetEntity(ActiveWorkplane());
Entity *wrkpln = SK.GetEntity(wrkpl->normal);
Vector u = wrkpln->NormalU(),
v = wrkpln->NormalV(),
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
n = wrkpln->NormalN(),
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
p = SK.GetEntity(wrkpl->point[0])->PointGetNum();
ClipboardRequest *cr;
for(cr = SS.clipboard.r.First(); cr; cr = SS.clipboard.r.NextAfter(cr)) {
hRequest hr = AddRequest(cr->type, false);
Request *r = SK.GetRequest(hr);
r->extraPoints = cr->extraPoints;
r->style = cr->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->str = cr->str;
r->font = cr->font;
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
r->construction = cr->construction;
// Need to regen to get the right number of points, if extraPoints
// changed.
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
SS.GenerateAll(SolveSpaceUI::Generate::REGEN);
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
SS.MarkGroupDirty(r->group);
bool hasDistance;
Tweak drag and selection behavior: selection is kept after dragging selected entities, but cleared after dragging an unselected entity. Marquee selection is select-only (not toggle), and "Select All" replaces "Invert Selection". Left-click on nothing will clear the selection. Also add context menu entries for cut, copy, and paste. [git-p4: depot-paths = "//depot/solvespace/": change = 2089]
2009-12-21 16:44:00 +00:00
int i, pts;
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
EntReqTable::GetRequestInfo(r->type, r->extraPoints,
NULL, &pts, NULL, &hasDistance);
Tweak drag and selection behavior: selection is kept after dragging selected entities, but cleared after dragging an unselected entity. Marquee selection is select-only (not toggle), and "Select All" replaces "Invert Selection". Left-click on nothing will clear the selection. Also add context menu entries for cut, copy, and paste. [git-p4: depot-paths = "//depot/solvespace/": change = 2089]
2009-12-21 16:44:00 +00:00
for(i = 0; i < pts; i++) {
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
Vector pt = cr->point[i];
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
// We need the reflection to occur within the workplane; it may
// otherwise correspond to just a rotation as projected.
if(scale < 0) {
pt.x *= -1;
}
// Likewise the scale, which could otherwise take us out of the
// workplane.
pt = pt.ScaledBy(fabs(scale));
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
pt = pt.ScaleOutOfCsys(u, v, Vector::From(0, 0, 0));
pt = pt.Plus(p);
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
pt = pt.RotatedAbout(n, theta);
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
pt = pt.Plus(trans);
SK.GetEntity(hr.entity(i+1))->PointForceTo(pt);
}
if(hasDistance) {
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
SK.GetEntity(hr.entity(64))->DistanceForceTo(
cr->distance*fabs(scale));
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
}
cr->newReq = hr;
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
MakeSelected(hr.entity(0));
Tweak drag and selection behavior: selection is kept after dragging selected entities, but cleared after dragging an unselected entity. Marquee selection is select-only (not toggle), and "Select All" replaces "Invert Selection". Left-click on nothing will clear the selection. Also add context menu entries for cut, copy, and paste. [git-p4: depot-paths = "//depot/solvespace/": change = 2089]
2009-12-21 16:44:00 +00:00
for(i = 0; i < pts; i++) {
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
MakeSelected(hr.entity(i+1));
Tweak drag and selection behavior: selection is kept after dragging selected entities, but cleared after dragging an unselected entity. Marquee selection is select-only (not toggle), and "Select All" replaces "Invert Selection". Left-click on nothing will clear the selection. Also add context menu entries for cut, copy, and paste. [git-p4: depot-paths = "//depot/solvespace/": change = 2089]
2009-12-21 16:44:00 +00:00
}
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
}
Trim trailing whitespace.
2015-03-29 00:30:52 +00:00
Copy any constraints that only refer to entities in the clipboard.
2015-12-30 12:36:31 +00:00
Constraint *cc;
for(cc = SS.clipboard.c.First(); cc; cc = SS.clipboard.c.NextAfter(cc)) {
Constraint c = {};
c.group = SS.GW.activeGroup;
c.workplane = SS.GW.ActiveWorkplane();
c.type = cc->type;
c.valA = cc->valA;
c.ptA = SS.clipboard.NewEntityFor(cc->ptA);
c.ptB = SS.clipboard.NewEntityFor(cc->ptB);
c.entityA = SS.clipboard.NewEntityFor(cc->entityA);
c.entityB = SS.clipboard.NewEntityFor(cc->entityB);
c.entityC = SS.clipboard.NewEntityFor(cc->entityC);
c.entityD = SS.clipboard.NewEntityFor(cc->entityD);
c.other = cc->other;
c.other2 = cc->other2;
c.reference = cc->reference;
c.disp = cc->disp;
Allow copying and pasting constraints.
2016-05-20 14:19:50 +00:00
c.comment = cc->comment;
hConstraint hc = Constraint::AddConstraint(&c, /*rememberForUndo=*/false);
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
if(c.type == Constraint::Type::COMMENT) {
Allow copying and pasting constraints.
2016-05-20 14:19:50 +00:00
SK.GetConstraint(hc)->disp.offset = SK.GetConstraint(hc)->disp.offset.Plus(trans);
MakeSelected(hc);
}
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
}
Add 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.ScheduleGenerateAll();
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
}
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
void GraphicsWindow::MenuClipboard(Command id) {
if(id != Command::DELETE && !SS.GW.LockedInWorkplane()) {
Edit Message() and Error() strings to use just \n, not \r\n, since my own dialog boxes don't require the carriage returns. [git-p4: depot-paths = "//depot/solvespace/": change = 2109]
2010-01-16 18:15:40 +00:00
Error("Cut, paste, and copy work only in a workplane.\n\n"
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
"Select one with Sketch -> In Workplane.");
return;
}
switch(id) {
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case Command::PASTE: {
A big nasty change, originally just to add paste transformed. So it does that, and adds a scale factor to that transformation (instead of just mirroring, as before), but also: * Replace the "import mirrored" mechanism with a scale factor, which if negative corresponds to a reflection as well. * Fix self-intersection checker to report a meaningful point when edges are collinear. * Don't blow an assertion on some types of invalid file; instead provide a nice error message to the user. * Clear the naked edges before each regen. * Don't create zero-length line segments by snapping a line segment's end to its beginning. [git-p4: depot-paths = "//depot/solvespace/": change = 2086]
2009-12-15 12:26:22 +00:00
SS.UndoRemember();
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
Vector trans = SS.GW.projRight.ScaledBy(80/SS.GW.scale).Plus(
SS.GW.projUp .ScaledBy(40/SS.GW.scale));
Leave the just-pasted entities selected after a Paste Transformed. [git-p4: depot-paths = "//depot/solvespace/": change = 2095]
2010-01-04 03:17:09 +00:00
SS.GW.ClearSelection();
A big nasty change, originally just to add paste transformed. So it does that, and adds a scale factor to that transformation (instead of just mirroring, as before), but also: * Replace the "import mirrored" mechanism with a scale factor, which if negative corresponds to a reflection as well. * Fix self-intersection checker to report a meaningful point when edges are collinear. * Don't blow an assertion on some types of invalid file; instead provide a nice error message to the user. * Clear the naked edges before each regen. * Don't create zero-length line segments by snapping a line segment's end to its beginning. [git-p4: depot-paths = "//depot/solvespace/": change = 2086]
2009-12-15 12:26:22 +00:00
SS.GW.PasteClipboard(trans, 0, 1);
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
break;
}
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case Command::PASTE_TRANSFORM: {
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(SS.clipboard.r.n == 0) {
Error("Clipboard is empty; nothing to paste.");
break;
}
Trim trailing whitespace.
2015-03-29 00:30:52 +00:00
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
Entity *wrkpl = SK.GetEntity(SS.GW.ActiveWorkplane());
Vector p = SK.GetEntity(wrkpl->point[0])->PointGetNum();
SS.TW.shown.paste.times = 1;
SS.TW.shown.paste.trans = Vector::From(0, 0, 0);
SS.TW.shown.paste.theta = 0;
SS.TW.shown.paste.origin = p;
SS.TW.shown.paste.scale = 1;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
SS.TW.GoToScreen(TextWindow::Screen::PASTE_TRANSFORMED);
A big nasty change, originally just to add paste transformed. So it does that, and adds a scale factor to that transformation (instead of just mirroring, as before), but also: * Replace the "import mirrored" mechanism with a scale factor, which if negative corresponds to a reflection as well. * Fix self-intersection checker to report a meaningful point when edges are collinear. * Don't blow an assertion on some types of invalid file; instead provide a nice error message to the user. * Clear the naked edges before each regen. * Don't create zero-length line segments by snapping a line segment's end to its beginning. [git-p4: depot-paths = "//depot/solvespace/": change = 2086]
2009-12-15 12:26:22 +00:00
SS.GW.ForceTextWindowShown();
Add a GTK2/3 port. In principle, GTK3 is the way forward, and GTK2 is officially deprecated, though still maintained. In practice however, GTK3 is often unbearably buggy; e.g. on my system, combo boxes don't ever roll up in GTK3 windows. So I have added support for both. This required a few minor changes to the core, namely: * GTK wants to know beforehand whether a menu item is a check menu item or a regular one. * GTK doesn't give us an easy way to execute something after any event is processed, so an explicit idle timer is added. This is a no-op on Win32. * A few function signatures were const'ed, since GTK expects immutable strings when converting to Glib::ustring.
2015-03-18 17:02:11 +00:00
SS.ScheduleShowTW();
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
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
}
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case Command::COPY:
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
SS.GW.CopySelection();
SS.GW.ClearSelection();
break;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case Command::CUT:
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
SS.UndoRemember();
SS.GW.CopySelection();
SS.GW.DeleteSelection();
break;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case Command::DELETE:
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
SS.UndoRemember();
SS.GW.DeleteSelection();
break;
Replace all oops() checks with ssassert()s. This includes explanation and context for non-obvious cases and shortens debug cycles when just-in-time debugging is not available (like on Linux) by immediately printing description of the assert as well as symbolized backtrace.
2016-05-18 22:51:36 +00:00
default: ssassert(false, "Unexpected menu ID");
Add support for a clipboard, with cut, copy, and paste. This works only in a workplane; but this means that plane sketches are conveniently transformed from one plane to another. Also tweak snap to grid to ignore unsnappable entities instead of triggering an error, and to remove arbitrary limit on the number of entities / comments that will be snapped. [git-p4: depot-paths = "//depot/solvespace/": change = 2084]
2009-12-04 08:08:41 +00:00
}
}
Added const qualifiers to edit-control string handling FLTK's Fl_Input widget, instantiated as {Graphics,Text}EditControl, returns a 'const char *' string. In order to handle this properly, several of SolveSpace's internal routines needed to gain a "const" qualifier on the edit-control string argument.
2013-09-16 19:51:20 +00:00
bool TextWindow::EditControlDoneForPaste(const char *s) {
Make default text in dimension box the exact (up to ten digits after decimal) current value of the dimension, not the value truncated to the same number of digits that are usually displayed. And make the paste transformed screen accept expressions, not just integers, for the count, angle, and scale. [git-p4: depot-paths = "//depot/solvespace/": change = 2181]
2010-10-12 03:13:41 +00:00
Expr *e;
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
switch(edit.meaning) {
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case Edit::PASTE_TIMES_REPEATED: {
Make default text in dimension box the exact (up to ten digits after decimal) current value of the dimension, not the value truncated to the same number of digits that are usually displayed. And make the paste transformed screen accept expressions, not just integers, for the count, angle, and scale. [git-p4: depot-paths = "//depot/solvespace/": change = 2181]
2010-10-12 03:13:41 +00:00
e = Expr::From(s, true);
if(!e) break;
int v = (int)e->Eval();
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(v > 0) {
shown.paste.times = v;
} else {
Error("Number of copies to paste must be at least one.");
}
break;
}
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case Edit::PASTE_ANGLE:
Make default text in dimension box the exact (up to ten digits after decimal) current value of the dimension, not the value truncated to the same number of digits that are usually displayed. And make the paste transformed screen accept expressions, not just integers, for the count, angle, and scale. [git-p4: depot-paths = "//depot/solvespace/": change = 2181]
2010-10-12 03:13:41 +00:00
e = Expr::From(s, true);
if(!e) break;
shown.paste.theta = WRAP_SYMMETRIC((e->Eval())*PI/180, 2*PI);
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
break;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
case Edit::PASTE_SCALE: {
Make default text in dimension box the exact (up to ten digits after decimal) current value of the dimension, not the value truncated to the same number of digits that are usually displayed. And make the paste transformed screen accept expressions, not just integers, for the count, angle, and scale. [git-p4: depot-paths = "//depot/solvespace/": change = 2181]
2010-10-12 03:13:41 +00:00
e = Expr::From(s, true);
double v = e->Eval();
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(fabs(v) > 1e-6) {
shown.paste.scale = v;
} else {
Error("Scale cannot be zero.");
}
break;
}
default:
return false;
}
return true;
}
Use C99 integer types and C++ boolean types/values This change comprehensively replaces the use of Microsoft-standard integer and boolean types with their C99/C++ standard equivalents, as the latter is more appropriate for a cross-platform application. With matter-of-course exceptions in the Win32-specific code, the types/values have been converted as follows: QWORD --> uint64_t SQWORD --> int64_t DWORD --> uint32_t SDWORD --> int32_t WORD --> uint16_t SWORD --> int16_t BYTE --> uint8_t BOOL --> bool TRUE --> true FALSE --> false The following related changes are also included: * Added C99 integer type definitions for Windows, as stdint.h is not available prior to Visual Studio 2010 * Changed types of some variables in the SolveSpace class from 'int' to 'bool', as they actually represent boolean settings * Implemented new Cnf{Freeze,Thaw}Bool() functions to support boolean variables in the Registry * Cnf{Freeze,Thaw}DWORD() are now Cnf{Freeze,Thaw}Int() * TtfFont::Get{WORD,DWORD}() are now TtfFont::Get{USHORT,ULONG}() (names inspired by the OpenType spec) * RGB colors are packed into an integer of type uint32_t (nee DWORD), but in a few places, these were represented by an int; these have been corrected to uint32_t
2013-10-02 05:45:13 +00:00
void TextWindow::ScreenChangePasteTransformed(int link, uint32_t v) {
A big nasty change, originally just to add paste transformed. So it does that, and adds a scale factor to that transformation (instead of just mirroring, as before), but also: * Replace the "import mirrored" mechanism with a scale factor, which if negative corresponds to a reflection as well. * Fix self-intersection checker to report a meaningful point when edges are collinear. * Don't blow an assertion on some types of invalid file; instead provide a nice error message to the user. * Clear the naked edges before each regen. * Don't create zero-length line segments by snapping a line segment's end to its beginning. [git-p4: depot-paths = "//depot/solvespace/": change = 2086]
2009-12-15 12:26:22 +00:00
switch(link) {
case 't':
Don't calculate halfRow for ShowEditControl manually. Instead, grab it from hoveredRow, since almost always (with only one exception) this is where the edit control has to be shown. This makes it much easier to adjust views, e.g. add a new editable field in the middle of configuration view, because it's not necessary to manually change and test all the indexes below the row being changed. Additionally, it removes a lot of awkward and opaque row calculations.
2016-01-26 11:19:52 +00:00
SS.TW.ShowEditControl(13, ssprintf("%d", SS.TW.shown.paste.times));
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
SS.TW.edit.meaning = Edit::PASTE_TIMES_REPEATED;
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
break;
case 'r':
Don't calculate halfRow for ShowEditControl manually. Instead, grab it from hoveredRow, since almost always (with only one exception) this is where the edit control has to be shown. This makes it much easier to adjust views, e.g. add a new editable field in the middle of configuration view, because it's not necessary to manually change and test all the indexes below the row being changed. Additionally, it removes a lot of awkward and opaque row calculations.
2016-01-26 11:19:52 +00:00
SS.TW.ShowEditControl(13, ssprintf("%.3f", SS.TW.shown.paste.theta*180/PI));
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
SS.TW.edit.meaning = Edit::PASTE_ANGLE;
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
break;
case 's':
Don't calculate halfRow for ShowEditControl manually. Instead, grab it from hoveredRow, since almost always (with only one exception) this is where the edit control has to be shown. This makes it much easier to adjust views, e.g. add a new editable field in the middle of configuration view, because it's not necessary to manually change and test all the indexes below the row being changed. Additionally, it removes a lot of awkward and opaque row calculations.
2016-01-26 11:19:52 +00:00
SS.TW.ShowEditControl(13, ssprintf("%.3f", SS.TW.shown.paste.scale));
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
SS.TW.edit.meaning = Edit::PASTE_SCALE;
A big nasty change, originally just to add paste transformed. So it does that, and adds a scale factor to that transformation (instead of just mirroring, as before), but also: * Replace the "import mirrored" mechanism with a scale factor, which if negative corresponds to a reflection as well. * Fix self-intersection checker to report a meaningful point when edges are collinear. * Don't blow an assertion on some types of invalid file; instead provide a nice error message to the user. * Clear the naked edges before each regen. * Don't create zero-length line segments by snapping a line segment's end to its beginning. [git-p4: depot-paths = "//depot/solvespace/": change = 2086]
2009-12-15 12:26:22 +00:00
break;
}
}
Use C99 integer types and C++ boolean types/values This change comprehensively replaces the use of Microsoft-standard integer and boolean types with their C99/C++ standard equivalents, as the latter is more appropriate for a cross-platform application. With matter-of-course exceptions in the Win32-specific code, the types/values have been converted as follows: QWORD --> uint64_t SQWORD --> int64_t DWORD --> uint32_t SDWORD --> int32_t WORD --> uint16_t SWORD --> int16_t BYTE --> uint8_t BOOL --> bool TRUE --> true FALSE --> false The following related changes are also included: * Added C99 integer type definitions for Windows, as stdint.h is not available prior to Visual Studio 2010 * Changed types of some variables in the SolveSpace class from 'int' to 'bool', as they actually represent boolean settings * Implemented new Cnf{Freeze,Thaw}Bool() functions to support boolean variables in the Registry * Cnf{Freeze,Thaw}DWORD() are now Cnf{Freeze,Thaw}Int() * TtfFont::Get{WORD,DWORD}() are now TtfFont::Get{USHORT,ULONG}() (names inspired by the OpenType spec) * RGB colors are packed into an integer of type uint32_t (nee DWORD), but in a few places, these were represented by an int; these have been corrected to uint32_t
2013-10-02 05:45:13 +00:00
void TextWindow::ScreenPasteTransformed(int link, uint32_t v) {
A big nasty change, originally just to add paste transformed. So it does that, and adds a scale factor to that transformation (instead of just mirroring, as before), but also: * Replace the "import mirrored" mechanism with a scale factor, which if negative corresponds to a reflection as well. * Fix self-intersection checker to report a meaningful point when edges are collinear. * Don't blow an assertion on some types of invalid file; instead provide a nice error message to the user. * Clear the naked edges before each regen. * Don't create zero-length line segments by snapping a line segment's end to its beginning. [git-p4: depot-paths = "//depot/solvespace/": change = 2086]
2009-12-15 12:26:22 +00:00
SS.GW.GroupSelection();
switch(link) {
case 'o':
if(SS.GW.gs.points == 1 && SS.GW.gs.n == 1) {
Entity *e = SK.GetEntity(SS.GW.gs.point[0]);
SS.TW.shown.paste.origin = e->PointGetNum();
} else {
Error("Select one point to define origin of rotation.");
}
Leave the just-pasted entities selected after a Paste Transformed. [git-p4: depot-paths = "//depot/solvespace/": change = 2095]
2010-01-04 03:17:09 +00:00
SS.GW.ClearSelection();
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
break;
case 't':
if(SS.GW.gs.points == 2 && SS.GW.gs.n == 2) {
Entity *pa = SK.GetEntity(SS.GW.gs.point[0]),
*pb = SK.GetEntity(SS.GW.gs.point[1]);
SS.TW.shown.paste.trans =
(pb->PointGetNum()).Minus(pa->PointGetNum());
} else {
Error("Select two points to define translation vector.");
}
Leave the just-pasted entities selected after a Paste Transformed. [git-p4: depot-paths = "//depot/solvespace/": change = 2095]
2010-01-04 03:17:09 +00:00
SS.GW.ClearSelection();
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
break;
case 'g': {
if(fabs(SS.TW.shown.paste.theta) < LENGTH_EPS &&
SS.TW.shown.paste.trans.Magnitude() < LENGTH_EPS &&
SS.TW.shown.paste.times != 1)
{
Message("Transformation is identity. So all copies will be "
"exactly on top of each other.");
}
if(SS.TW.shown.paste.times*SS.clipboard.r.n > 100) {
Error("Too many items to paste; split this into smaller "
"pastes.");
break;
}
if(!SS.GW.LockedInWorkplane()) {
Error("No workplane active.");
break;
}
Entity *wrkpl = SK.GetEntity(SS.GW.ActiveWorkplane());
Entity *wrkpln = SK.GetEntity(wrkpl->normal);
Vector wn = wrkpln->NormalN();
SS.UndoRemember();
Leave the just-pasted entities selected after a Paste Transformed. [git-p4: depot-paths = "//depot/solvespace/": change = 2095]
2010-01-04 03:17:09 +00:00
SS.GW.ClearSelection();
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
for(int i = 0; i < SS.TW.shown.paste.times; i++) {
Vector trans = SS.TW.shown.paste.trans.ScaledBy(i+1),
origin = SS.TW.shown.paste.origin;
double theta = SS.TW.shown.paste.theta*(i+1);
// desired transformation is Q*(p - o) + o + t =
// Q*p - Q*o + o + t = Q*p + (t + o - Q*o)
Vector t = trans.Plus(
origin).Minus(
origin.RotatedAbout(wn, theta));
SS.GW.PasteClipboard(t, theta, SS.TW.shown.paste.scale);
}
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
SS.TW.GoToScreen(Screen::LIST_OF_GROUPS);
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();
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
break;
}
}
}
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void TextWindow::ShowPasteTransformed() {
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
Printf(true, "%FtPASTE TRANSFORMED%E");
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
Printf(true, "%Ba %Ftrepeat%E %d time%s %Fl%Lt%f[change]%E",
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
shown.paste.times, (shown.paste.times == 1) ? "" : "s",
&ScreenChangePasteTransformed);
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
Printf(false, "%Bd %Ftrotate%E %@ degrees %Fl%Lr%f[change]%E",
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
shown.paste.theta*180/PI,
&ScreenChangePasteTransformed);
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
Printf(false, "%Ba %Ftabout pt%E (%s, %s, %s) %Fl%Lo%f[use selected]%E",
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
SS.MmToString(shown.paste.origin.x).c_str(),
SS.MmToString(shown.paste.origin.y).c_str(),
SS.MmToString(shown.paste.origin.z).c_str(),
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
&ScreenPasteTransformed);
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
Printf(false, "%Bd %Fttranslate%E (%s, %s, %s) %Fl%Lt%f[use selected]%E",
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
SS.MmToString(shown.paste.trans.x).c_str(),
SS.MmToString(shown.paste.trans.y).c_str(),
SS.MmToString(shown.paste.trans.z).c_str(),
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
&ScreenPasteTransformed);
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-09 18:25:23 +00:00
Printf(false, "%Ba %Ftscale%E %@ %Fl%Ls%f[change]%E",
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
shown.paste.scale,
&ScreenChangePasteTransformed);
Printf(true, " %Fl%Lg%fpaste transformed now%E", &ScreenPasteTransformed);
Printf(true, "(or %Fl%Ll%fcancel operation%E)", &ScreenHome);
}