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

762 lines
26 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
//-----------------------------------------------------------------------------
// Entry point in to the program, our registry-stored settings and top-level
// housekeeping when we open, save, and create new files.
//
// Copyright 2008-2013 Jonathan Westhues.
//-----------------------------------------------------------------------------
This is my initial checkin for solvespace, a second attempt at constraint solver drawing. I've started work on the user inteface, which will be based around two windows: one with the graphical sketch, and one command line. I've started to implement the command line, no other work. [git-p4: depot-paths = "//depot/solvespace/": change = 1652]
2008-03-25 10:02:13 +00:00
#include "solvespace.h"
SolveSpace SS;
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Sketch SK;
This is my initial checkin for solvespace, a second attempt at constraint solver drawing. I've started work on the user inteface, which will be based around two windows: one with the graphical sketch, and one command line. I've started to implement the command line, no other work. [git-p4: depot-paths = "//depot/solvespace/": change = 1652]
2008-03-25 10:02:13 +00:00
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 06:22:16 +00:00
void SolveSpace::Init(char *cmdLine) {
Improve the non-parametric rounding. It now works on both lines and circles, using a numerical method. And the user can specify a radius, instead of letting us choose automatically, and specify whether the original lines should be kept and made construction, or deleted. [git-p4: depot-paths = "//depot/solvespace/": change = 2146]
2010-05-16 16:36:23 +00:00
SS.tangentArcRadius = 10.0;
Add a simple license key: I take the CRC of the license info, plus some magic numbers. This would be trivial to break, but still more difficult than patching the binary to skip the check... [git-p4: depot-paths = "//depot/solvespace/": change = 1853]
2008-02-09 13:52:01 +00:00
// Then, load the registry settings.
Add reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 04:22:52 +00:00
int i;
// Default list of colors for the model material
Replaced RGB-color integers with dedicated data structure RGB colors were represented using a uint32_t with the red, green and blue values stuffed into the lower three octets (i.e. 0x00BBGGRR), like Microsoft's COLORREF. This approach did not lend itself to type safety, however, so this change replaces it with an RgbColor class that provides the same infomation plus a handful of useful methods to work with it. (Note that sizeof(RgbColor) == sizeof(uint32_t), so this change should not lead to memory bloat.) Some of the new methods/fields replace what were previously macro calls; e.g. RED(c) is now c.red, REDf(c) is now c.redF(). The .Equals() method is now used instead of == to compare colors. RGB colors still need to be represented as packed integers in file I/O and preferences, so the methods .FromPackedInt() and .ToPackedInt() are provided. Also implemented are Cnf{Freeze,Thaw}Color(), type-safe wrappers around Cnf{Freeze,Thaw}Int() that facilitate I/O with preferences. (Cnf{Freeze,Thaw}Color() are defined outside of the system-dependent code to minimize the footprint of the latter; because the same can be done with Cnf{Freeze,Thaw}Bool(), those are also moved out of the system code with this commit.) Color integers were being OR'ed with 0x80000000 in some places for two distinct purposes: One, to indicate use of a default color in glxFillMesh(); this has been replaced by use of the .UseDefault() method. Two, to indicate to TextWindow::Printf() that the format argument of a "%Bp"/"%Fp" specifier is an RGB color rather than a color "code" from TextWindow::bgColors[] or TextWindow::fgColors[] (as the specifier can accept either); instead, we define a new flag "z" (as in "%Bz" or "%Fz") to indicate an RGBcolor pointer, leaving "%Bp"/"%Fp" to indicate a color code exclusively. (This also allows TextWindow::meta[][].bg to be a char instead of an int, partly compensating for the new .bgRgb field added immediately after.) In array declarations, RGB colors could previously be specified as 0 (often in a terminating element). As that no longer works, we define NULL_COLOR, which serves much the same purpose for RgbColor variables as NULL serves for pointers.
2013-10-16 20:00:58 +00:00
modelColor[0] = CnfThawColor(RGB(150, 150, 150), "ModelColor_0");
modelColor[1] = CnfThawColor(RGB(100, 100, 100), "ModelColor_1");
modelColor[2] = CnfThawColor(RGB( 30, 30, 30), "ModelColor_2");
modelColor[3] = CnfThawColor(RGB(150, 0, 0), "ModelColor_3");
modelColor[4] = CnfThawColor(RGB( 0, 100, 0), "ModelColor_4");
modelColor[5] = CnfThawColor(RGB( 0, 80, 80), "ModelColor_5");
modelColor[6] = CnfThawColor(RGB( 0, 0, 130), "ModelColor_6");
modelColor[7] = CnfThawColor(RGB( 80, 0, 80), "ModelColor_7");
Add reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 04:22:52 +00:00
// Light intensities
Add a scale factor when exporting; the user specifies a number, and all coordinates are divided by that number as we export. And add functions to store a float in the registry. I'm using those for the scale factor, and also to replace the crazy scaled integers that I was using for light positions etc. before. [git-p4: depot-paths = "//depot/solvespace/": change = 1824]
2008-07-08 07:41:29 +00:00
lightIntensity[0] = CnfThawFloat(1.0f, "LightIntensity_0");
lightIntensity[1] = CnfThawFloat(0.5f, "LightIntensity_1");
Add hidden line and surface removal, and vector shaded surface export. So I calculate lighting for each triangle in the mesh, make a BSP, and then traverse it in-order and output those as SVG or EPS. And I test edges against the mesh, removing those portions of the edge that overlap a triangle in front of them (using the kd-tree to accelerate). [git-p4: depot-paths = "//depot/solvespace/": change = 1931]
2009-03-17 16:33:46 +00:00
ambientIntensity = 0.3; // no setting for that yet
Add reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 04:22:52 +00:00
// Light positions
Add a scale factor when exporting; the user specifies a number, and all coordinates are divided by that number as we export. And add functions to store a float in the registry. I'm using those for the scale factor, and also to replace the crazy scaled integers that I was using for light positions etc. before. [git-p4: depot-paths = "//depot/solvespace/": change = 1824]
2008-07-08 07:41:29 +00:00
lightDir[0].x = CnfThawFloat(-1.0f, "LightDir_0_Right" );
lightDir[0].y = CnfThawFloat( 1.0f, "LightDir_0_Up" );
lightDir[0].z = CnfThawFloat( 0.0f, "LightDir_0_Forward" );
lightDir[1].x = CnfThawFloat( 1.0f, "LightDir_1_Right" );
lightDir[1].y = CnfThawFloat( 0.0f, "LightDir_1_Up" );
lightDir[1].z = CnfThawFloat( 0.0f, "LightDir_1_Forward" );
Make the piecewise linear stuff for cubics and quadratics adaptive, based on a chord tolerance. And rewrite the pwl circles to work against a chord tolerance too (which they really were doing before, but in funny units). Also make "assemble" combine type do a union after interference checking; was previously just copying, which meant that coplanar faces could break subsequent operations. And make right-clicking effectively toggle shift key, instead of forcing it on; so you can pan or rotate with either right or middle button. [git-p4: depot-paths = "//depot/solvespace/": change = 1829]
2008-07-10 05:26:08 +00:00
// Chord tolerance
Oops, was computing numerical by perturbing a point in uv; but the xyz point that I subtracted off had been refined to lie exactly on our edge's curve, and the uv point that I started with had not. So normals got randomly screwed up. [git-p4: depot-paths = "//depot/solvespace/": change = 1978]
2009-06-10 08:04:35 +00:00
chordTol = CnfThawFloat(2.0f, "ChordTolerance");
Add a configuration item to specify the maximum number of piecewise linear segments to generate, irrespective of the chord tolerance. That used to be hard-coded, and it needs to be small enough to avoid lags while working interactively, but I also need to export fine geometry. [git-p4: depot-paths = "//depot/solvespace/": change = 1857]
2008-02-12 13:00:26 +00:00
// Max pwl segments to generate
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
maxSegments = CnfThawInt(10, "MaxSegments");
Now display dimensions (and stuff in the text window) in the user-selected units, and enter them the same way. [git-p4: depot-paths = "//depot/solvespace/": change = 1792]
2008-06-14 09:51:25 +00:00
// View units
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
viewUnits = (Unit)CnfThawInt((uint32_t)UNIT_MM, "ViewUnits");
Make the number of digits after the decimal point (for dimensions, as they are displayed on the drawing, and for many other places) a user-configurable parameter. Also reshuffle some options in the configuration screen, to put all the stuff relating to exports together. [git-p4: depot-paths = "//depot/solvespace/": change = 2179]
2010-09-24 02:58:34 +00:00
// Number of digits after the decimal point
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
afterDecimalMm = CnfThawInt(2, "AfterDecimalMm");
afterDecimalInch = CnfThawInt(3, "AfterDecimalInch");
Add perspective, by a user-specified factor. So I have to apply that perspective in the gl matrices, and also everywhere that I check mouse pointer positions against the model, and for the zoom to fit. [git-p4: depot-paths = "//depot/solvespace/": change = 1796]
2008-06-17 19:12:25 +00:00
// Camera tangent (determines perspective)
Oops, camera tangent was defaulting to 300, not 0.3, very bad. [git-p4: depot-paths = "//depot/solvespace/": change = 2149]
2010-05-16 18:46:10 +00:00
cameraTangent = CnfThawFloat(0.3f/1e3f, "CameraTangent");
Add text angle for styles. Add ability to quickly change between perspective and parallel projections. Add a snap grid, for points and for text comments. Draw text comments in the plane of their workplane if they have one, otherwise always facing forward. And fix a few nasty bugs: the possibility of an extremely long animation onto a workplane, accidental use of the wrong style line width for constraints, misplaced text box in style screen for default styles, other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 2037]
2009-09-29 11:35:19 +00:00
// Grid spacing
gridSpacing = CnfThawFloat(5.0f, "GridSpacing");
Add a scale factor when exporting; the user specifies a number, and all coordinates are divided by that number as we export. And add functions to store a float in the registry. I'm using those for the scale factor, and also to replace the crazy scaled integers that I was using for light positions etc. before. [git-p4: depot-paths = "//depot/solvespace/": change = 1824]
2008-07-08 07:41:29 +00:00
// Export scale factor
exportScale = CnfThawFloat(1.0f, "ExportScale");
Add cutter radius compensation. That's a bolt on thing at the end; just applies an offset to the DXF before exporting. Useful enough to be worth the ugliness, though. This is the stupid routines from SketchFlat, slightly reworked. [git-p4: depot-paths = "//depot/solvespace/": change = 1866]
2008-08-14 08:28:25 +00:00
// Export offset (cutter radius comp)
exportOffset = CnfThawFloat(0.0f, "ExportOffset");
Now actually export the line styles, for PDF, EPS, and SVG file formats, with the proper color and width. This may need a bit of cleanup for stuff like the hidden line removal, which currently loses the style. Also fix a bug in the test for arcs of a circle. A second-order Bezier with collinear control points really is an arc, but it's an arc with infinite radius so stuff tends to blow up. So return false for that one. [git-p4: depot-paths = "//depot/solvespace/": change = 2030]
2009-09-22 05:46:30 +00:00
// Rewrite exported colors close to white into black (assuming white bg)
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
fixExportColors = CnfThawBool(true, "FixExportColors");
Add a configuration option to hide the back faces; that gets rid of stray red pixels sometimes, if the mesh is leaky or the graphics card isn't perfect. [git-p4: depot-paths = "//depot/solvespace/": change = 1864]
2008-08-11 10:56:08 +00:00
// Draw back faces of triangles (when mesh is leaky/self-intersecting)
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
drawBackFaces = CnfThawBool(true, "DrawBackFaces");
Add option to disable the "not closed contour" warnings and such, instead of tying that to whether the shaded model is shown. And rewrite all URLs to solvespace.com, not www.solvespace.com, and get rid of the nag screen that I just added because opening the website with ShellExecute seems to freeze a bit on startup. [git-p4: depot-paths = "//depot/solvespace/": change = 2044]
2009-10-01 10:35:11 +00:00
// Check that contours are closed and not self-intersecting
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
checkClosedContour = CnfThawBool(true, "CheckClosedContour");
Generate additional edges wherever a front- and back-facing triangle join. And add controls to show and hide the solid model edges (independently of the shaded mesh), and to suppress the shaded triangles from SVG/EPS output. [git-p4: depot-paths = "//depot/solvespace/": change = 1932]
2009-03-18 04:26:04 +00:00
// Export shaded triangles in a 2d view
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
exportShadedTriangles = CnfThawBool(true, "ExportShadedTriangles");
Add beginnings of exact curve export. We take the trim curves in our specified section plane; we then split them according to the start and endpoints of each STrimBy, using de Castejau's algorithm. These sections get projected (possibly in perspective, which I do correctly) into 2d and exported. Except, for now they just get pwl'd in the export files. That's the fallback, since it works for any file format. But that's the place to add special cases for circles etc., or to export them exactly. DXF supports the latter, but very painfully since I would need to write a later-versioned file, which requires thousands of lines of baggage. I'll probably stick with arcs. [git-p4: depot-paths = "//depot/solvespace/": change = 1936]
2009-04-14 04:19:23 +00:00
// Export pwl curves (instead of exact) always
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
exportPwlCurves = CnfThawBool(false, "ExportPwlCurves");
Add user interface to modify styles: change the color, line width, line width units, on-screen and export visibility. So now we can use that to modify the default styles, or to create custom styles. Also add code to draw fat lines, with round endcaps, since gl doesn't do that. Next we need some user interface to assign styles to entities, and to make all the export file formats support the style attributes. [git-p4: depot-paths = "//depot/solvespace/": change = 2029]
2009-09-18 08:14:15 +00:00
// Background color on-screen
Replaced RGB-color integers with dedicated data structure RGB colors were represented using a uint32_t with the red, green and blue values stuffed into the lower three octets (i.e. 0x00BBGGRR), like Microsoft's COLORREF. This approach did not lend itself to type safety, however, so this change replaces it with an RgbColor class that provides the same infomation plus a handful of useful methods to work with it. (Note that sizeof(RgbColor) == sizeof(uint32_t), so this change should not lead to memory bloat.) Some of the new methods/fields replace what were previously macro calls; e.g. RED(c) is now c.red, REDf(c) is now c.redF(). The .Equals() method is now used instead of == to compare colors. RGB colors still need to be represented as packed integers in file I/O and preferences, so the methods .FromPackedInt() and .ToPackedInt() are provided. Also implemented are Cnf{Freeze,Thaw}Color(), type-safe wrappers around Cnf{Freeze,Thaw}Int() that facilitate I/O with preferences. (Cnf{Freeze,Thaw}Color() are defined outside of the system-dependent code to minimize the footprint of the latter; because the same can be done with Cnf{Freeze,Thaw}Bool(), those are also moved out of the system code with this commit.) Color integers were being OR'ed with 0x80000000 in some places for two distinct purposes: One, to indicate use of a default color in glxFillMesh(); this has been replaced by use of the .UseDefault() method. Two, to indicate to TextWindow::Printf() that the format argument of a "%Bp"/"%Fp" specifier is an RGB color rather than a color "code" from TextWindow::bgColors[] or TextWindow::fgColors[] (as the specifier can accept either); instead, we define a new flag "z" (as in "%Bz" or "%Fz") to indicate an RGBcolor pointer, leaving "%Bp"/"%Fp" to indicate a color code exclusively. (This also allows TextWindow::meta[][].bg to be a char instead of an int, partly compensating for the new .bgRgb field added immediately after.) In array declarations, RGB colors could previously be specified as 0 (often in a terminating element). As that no longer works, we define NULL_COLOR, which serves much the same purpose for RgbColor variables as NULL serves for pointers.
2013-10-16 20:00:58 +00:00
backgroundColor = CnfThawColor(RGB(0, 0, 0), "BackgroundColor");
Add ability to set export canvas size (paper size for PDF, bbox size for EPS, etc.). This can either be fixed, with a given width and height and offset, or automatic, by the left right bottom top margins. And draw nicer dimensions for length, with arrows and more extension lines. Add code to trim those lines against the (rectangular, axis-aligned) box that contains the actual number, and use that (instead of the elliptical interpolation, which was only approximately right) for diameter dimensions too. [git-p4: depot-paths = "//depot/solvespace/": change = 2027]
2009-09-03 08:13:09 +00:00
// Whether export canvas size is fixed or derived from bbox
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
exportCanvasSizeAuto = CnfThawBool(true, "ExportCanvasSizeAuto");
Add ability to set export canvas size (paper size for PDF, bbox size for EPS, etc.). This can either be fixed, with a given width and height and offset, or automatic, by the left right bottom top margins. And draw nicer dimensions for length, with arrows and more extension lines. Add code to trim those lines against the (rectangular, axis-aligned) box that contains the actual number, and use that (instead of the elliptical interpolation, which was only approximately right) for diameter dimensions too. [git-p4: depot-paths = "//depot/solvespace/": change = 2027]
2009-09-03 08:13:09 +00:00
// Margins for automatic canvas size
exportMargin.left = CnfThawFloat(5.0f, "ExportMargin_Left");
exportMargin.right = CnfThawFloat(5.0f, "ExportMargin_Right");
exportMargin.bottom = CnfThawFloat(5.0f, "ExportMargin_Bottom");
exportMargin.top = CnfThawFloat(5.0f, "ExportMargin_Top");
// Dimensions for fixed canvas size
exportCanvas.width = CnfThawFloat(100.0f, "ExportCanvas_Width");
exportCanvas.height = CnfThawFloat(100.0f, "ExportCanvas_Height");
exportCanvas.dx = CnfThawFloat( 5.0f, "ExportCanvas_Dx");
exportCanvas.dy = CnfThawFloat( 5.0f, "ExportCanvas_Dy");
Add G Code export to SolveSpace, similar to SketchFlat. This requires user interface to specify the depth, number of passes, feed, and plunge feed, unfortunately. [git-p4: depot-paths = "//depot/solvespace/": change = 2106]
2010-01-14 04:47:17 +00:00
// Extra parameters when exporting G code
gCode.depth = CnfThawFloat(10.0f, "GCode_Depth");
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
gCode.passes = CnfThawInt(1, "GCode_Passes");
Add G Code export to SolveSpace, similar to SketchFlat. This requires user interface to specify the depth, number of passes, feed, and plunge feed, unfortunately. [git-p4: depot-paths = "//depot/solvespace/": change = 2106]
2010-01-14 04:47:17 +00:00
gCode.feed = CnfThawFloat(10.0f, "GCode_Feed");
gCode.plungeFeed = CnfThawFloat(10.0f, "GCode_PlungeFeed");
Add a toolbar. This requires a tool to convert my PNG icons to tables in the code, which I have written in perl and am checking in. Also get WM_MOUSELEAVE events from win32, so that I can de-hover everything when the mouse leaves the graphics window. And fix one of the icons, which was 23x24 instead of 24x24. [git-p4: depot-paths = "//depot/solvespace/": change = 1883]
2009-01-02 10:38:36 +00:00
// Show toolbar in the graphics window
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
showToolbar = CnfThawBool(true, "ShowToolbar");
Add reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 04:22:52 +00:00
// Recent files menus
for(i = 0; i < MAX_RECENT; i++) {
char name[100];
sprintf(name, "RecentFile_%d", i);
strcpy(RecentFile[i], "");
CnfThawString(RecentFile[i], MAX_PATH, name);
}
RefreshRecentMenus();
Move colors and line widths for almost everything to the styles mechanism. This gets filled in from some defaults, and stored in the registry. The default styles do not get saved in the file, but user-created styles (which aren't supported yet) do. [git-p4: depot-paths = "//depot/solvespace/": change = 2028]
2009-09-17 07:32:36 +00:00
// The default styles (colors, line widths, etc.) are also stored in the
// configuration file, but we will automatically load those as we need
// them.
Add reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 04:22:52 +00:00
// Start with either an empty file, or the file specified on the
// command line.
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 10:10:12 +00:00
NewFile();
AfterNewFile();
if(strlen(cmdLine) != 0) {
Add the file open/save user interface. This includes a list of recently opened files, that is saved in the registry and displayed in a separate popup menu. [git-p4: depot-paths = "//depot/solvespace/": change = 1752]
2008-05-28 10:10:31 +00:00
if(LoadFromFile(cmdLine)) {
strcpy(saveFile, cmdLine);
} else {
NewFile();
}
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 06:22:16 +00:00
}
Add the file open/save user interface. This includes a list of recently opened files, that is saved in the registry and displayed in a separate popup menu. [git-p4: depot-paths = "//depot/solvespace/": change = 1752]
2008-05-28 10:10:31 +00:00
AfterNewFile();
}
Add reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 04:22:52 +00:00
void SolveSpace::Exit(void) {
int i;
char name[100];
// Recent files
for(i = 0; i < MAX_RECENT; i++) {
sprintf(name, "RecentFile_%d", i);
CnfFreezeString(RecentFile[i], name);
}
// Model colors
for(i = 0; i < MODEL_COLORS; i++) {
sprintf(name, "ModelColor_%d", i);
Replaced RGB-color integers with dedicated data structure RGB colors were represented using a uint32_t with the red, green and blue values stuffed into the lower three octets (i.e. 0x00BBGGRR), like Microsoft's COLORREF. This approach did not lend itself to type safety, however, so this change replaces it with an RgbColor class that provides the same infomation plus a handful of useful methods to work with it. (Note that sizeof(RgbColor) == sizeof(uint32_t), so this change should not lead to memory bloat.) Some of the new methods/fields replace what were previously macro calls; e.g. RED(c) is now c.red, REDf(c) is now c.redF(). The .Equals() method is now used instead of == to compare colors. RGB colors still need to be represented as packed integers in file I/O and preferences, so the methods .FromPackedInt() and .ToPackedInt() are provided. Also implemented are Cnf{Freeze,Thaw}Color(), type-safe wrappers around Cnf{Freeze,Thaw}Int() that facilitate I/O with preferences. (Cnf{Freeze,Thaw}Color() are defined outside of the system-dependent code to minimize the footprint of the latter; because the same can be done with Cnf{Freeze,Thaw}Bool(), those are also moved out of the system code with this commit.) Color integers were being OR'ed with 0x80000000 in some places for two distinct purposes: One, to indicate use of a default color in glxFillMesh(); this has been replaced by use of the .UseDefault() method. Two, to indicate to TextWindow::Printf() that the format argument of a "%Bp"/"%Fp" specifier is an RGB color rather than a color "code" from TextWindow::bgColors[] or TextWindow::fgColors[] (as the specifier can accept either); instead, we define a new flag "z" (as in "%Bz" or "%Fz") to indicate an RGBcolor pointer, leaving "%Bp"/"%Fp" to indicate a color code exclusively. (This also allows TextWindow::meta[][].bg to be a char instead of an int, partly compensating for the new .bgRgb field added immediately after.) In array declarations, RGB colors could previously be specified as 0 (often in a terminating element). As that no longer works, we define NULL_COLOR, which serves much the same purpose for RgbColor variables as NULL serves for pointers.
2013-10-16 20:00:58 +00:00
CnfFreezeColor(modelColor[i], name);
Add reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 04:22:52 +00:00
}
// Light intensities
Add a scale factor when exporting; the user specifies a number, and all coordinates are divided by that number as we export. And add functions to store a float in the registry. I'm using those for the scale factor, and also to replace the crazy scaled integers that I was using for light positions etc. before. [git-p4: depot-paths = "//depot/solvespace/": change = 1824]
2008-07-08 07:41:29 +00:00
CnfFreezeFloat((float)lightIntensity[0], "LightIntensity_0");
CnfFreezeFloat((float)lightIntensity[1], "LightIntensity_1");
The lights are directional, so call those triples directions, not positions. [git-p4: depot-paths = "//depot/solvespace/": change = 1784]
2008-06-11 04:30:18 +00:00
// Light directions
Add a scale factor when exporting; the user specifies a number, and all coordinates are divided by that number as we export. And add functions to store a float in the registry. I'm using those for the scale factor, and also to replace the crazy scaled integers that I was using for light positions etc. before. [git-p4: depot-paths = "//depot/solvespace/": change = 1824]
2008-07-08 07:41:29 +00:00
CnfFreezeFloat((float)lightDir[0].x, "LightDir_0_Right");
CnfFreezeFloat((float)lightDir[0].y, "LightDir_0_Up");
CnfFreezeFloat((float)lightDir[0].z, "LightDir_0_Forward");
CnfFreezeFloat((float)lightDir[1].x, "LightDir_1_Right");
CnfFreezeFloat((float)lightDir[1].y, "LightDir_1_Up");
CnfFreezeFloat((float)lightDir[1].z, "LightDir_1_Forward");
Make the piecewise linear stuff for cubics and quadratics adaptive, based on a chord tolerance. And rewrite the pwl circles to work against a chord tolerance too (which they really were doing before, but in funny units). Also make "assemble" combine type do a union after interference checking; was previously just copying, which meant that coplanar faces could break subsequent operations. And make right-clicking effectively toggle shift key, instead of forcing it on; so you can pan or rotate with either right or middle button. [git-p4: depot-paths = "//depot/solvespace/": change = 1829]
2008-07-10 05:26:08 +00:00
// Chord tolerance
CnfFreezeFloat((float)chordTol, "ChordTolerance");
Add a configuration item to specify the maximum number of piecewise linear segments to generate, irrespective of the chord tolerance. That used to be hard-coded, and it needs to be small enough to avoid lags while working interactively, but I also need to export fine geometry. [git-p4: depot-paths = "//depot/solvespace/": change = 1857]
2008-02-12 13:00:26 +00:00
// Max pwl segments to generate
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
CnfFreezeInt((uint32_t)maxSegments, "MaxSegments");
Make the number of digits after the decimal point (for dimensions, as they are displayed on the drawing, and for many other places) a user-configurable parameter. Also reshuffle some options in the configuration screen, to put all the stuff relating to exports together. [git-p4: depot-paths = "//depot/solvespace/": change = 2179]
2010-09-24 02:58:34 +00:00
// View units
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
CnfFreezeInt((uint32_t)viewUnits, "ViewUnits");
Make the number of digits after the decimal point (for dimensions, as they are displayed on the drawing, and for many other places) a user-configurable parameter. Also reshuffle some options in the configuration screen, to put all the stuff relating to exports together. [git-p4: depot-paths = "//depot/solvespace/": change = 2179]
2010-09-24 02:58:34 +00:00
// Number of digits after the decimal point
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
CnfFreezeInt((uint32_t)afterDecimalMm, "AfterDecimalMm");
CnfFreezeInt((uint32_t)afterDecimalInch, "AfterDecimalInch");
Add perspective, by a user-specified factor. So I have to apply that perspective in the gl matrices, and also everywhere that I check mouse pointer positions against the model, and for the zoom to fit. [git-p4: depot-paths = "//depot/solvespace/": change = 1796]
2008-06-17 19:12:25 +00:00
// Camera tangent (determines perspective)
Add a scale factor when exporting; the user specifies a number, and all coordinates are divided by that number as we export. And add functions to store a float in the registry. I'm using those for the scale factor, and also to replace the crazy scaled integers that I was using for light positions etc. before. [git-p4: depot-paths = "//depot/solvespace/": change = 1824]
2008-07-08 07:41:29 +00:00
CnfFreezeFloat((float)cameraTangent, "CameraTangent");
Add text angle for styles. Add ability to quickly change between perspective and parallel projections. Add a snap grid, for points and for text comments. Draw text comments in the plane of their workplane if they have one, otherwise always facing forward. And fix a few nasty bugs: the possibility of an extremely long animation onto a workplane, accidental use of the wrong style line width for constraints, misplaced text box in style screen for default styles, other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 2037]
2009-09-29 11:35:19 +00:00
// Grid spacing
CnfFreezeFloat(gridSpacing, "GridSpacing");
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
// Export scale
Add a scale factor when exporting; the user specifies a number, and all coordinates are divided by that number as we export. And add functions to store a float in the registry. I'm using those for the scale factor, and also to replace the crazy scaled integers that I was using for light positions etc. before. [git-p4: depot-paths = "//depot/solvespace/": change = 1824]
2008-07-08 07:41:29 +00:00
CnfFreezeFloat(exportScale, "ExportScale");
Add cutter radius compensation. That's a bolt on thing at the end; just applies an offset to the DXF before exporting. Useful enough to be worth the ugliness, though. This is the stupid routines from SketchFlat, slightly reworked. [git-p4: depot-paths = "//depot/solvespace/": change = 1866]
2008-08-14 08:28:25 +00:00
// Export offset (cutter radius comp)
CnfFreezeFloat(exportOffset, "ExportOffset");
Now actually export the line styles, for PDF, EPS, and SVG file formats, with the proper color and width. This may need a bit of cleanup for stuff like the hidden line removal, which currently loses the style. Also fix a bug in the test for arcs of a circle. A second-order Bezier with collinear control points really is an arc, but it's an arc with infinite radius so stuff tends to blow up. So return false for that one. [git-p4: depot-paths = "//depot/solvespace/": change = 2030]
2009-09-22 05:46:30 +00:00
// Rewrite exported colors close to white into black (assuming white bg)
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
CnfFreezeBool(fixExportColors, "FixExportColors");
Add a configuration option to hide the back faces; that gets rid of stray red pixels sometimes, if the mesh is leaky or the graphics card isn't perfect. [git-p4: depot-paths = "//depot/solvespace/": change = 1864]
2008-08-11 10:56:08 +00:00
// Draw back faces of triangles (when mesh is leaky/self-intersecting)
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
CnfFreezeBool(drawBackFaces, "DrawBackFaces");
Add option to disable the "not closed contour" warnings and such, instead of tying that to whether the shaded model is shown. And rewrite all URLs to solvespace.com, not www.solvespace.com, and get rid of the nag screen that I just added because opening the website with ShellExecute seems to freeze a bit on startup. [git-p4: depot-paths = "//depot/solvespace/": change = 2044]
2009-10-01 10:35:11 +00:00
// Check that contours are closed and not self-intersecting
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
CnfFreezeBool(checkClosedContour, "CheckClosedContour");
Generate additional edges wherever a front- and back-facing triangle join. And add controls to show and hide the solid model edges (independently of the shaded mesh), and to suppress the shaded triangles from SVG/EPS output. [git-p4: depot-paths = "//depot/solvespace/": change = 1932]
2009-03-18 04:26:04 +00:00
// Export shaded triangles in a 2d view
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
CnfFreezeBool(exportShadedTriangles, "ExportShadedTriangles");
Add beginnings of exact curve export. We take the trim curves in our specified section plane; we then split them according to the start and endpoints of each STrimBy, using de Castejau's algorithm. These sections get projected (possibly in perspective, which I do correctly) into 2d and exported. Except, for now they just get pwl'd in the export files. That's the fallback, since it works for any file format. But that's the place to add special cases for circles etc., or to export them exactly. DXF supports the latter, but very painfully since I would need to write a later-versioned file, which requires thousands of lines of baggage. I'll probably stick with arcs. [git-p4: depot-paths = "//depot/solvespace/": change = 1936]
2009-04-14 04:19:23 +00:00
// Export pwl curves (instead of exact) always
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
CnfFreezeBool(exportPwlCurves, "ExportPwlCurves");
Add user interface to modify styles: change the color, line width, line width units, on-screen and export visibility. So now we can use that to modify the default styles, or to create custom styles. Also add code to draw fat lines, with round endcaps, since gl doesn't do that. Next we need some user interface to assign styles to entities, and to make all the export file formats support the style attributes. [git-p4: depot-paths = "//depot/solvespace/": change = 2029]
2009-09-18 08:14:15 +00:00
// Background color on-screen
Replaced RGB-color integers with dedicated data structure RGB colors were represented using a uint32_t with the red, green and blue values stuffed into the lower three octets (i.e. 0x00BBGGRR), like Microsoft's COLORREF. This approach did not lend itself to type safety, however, so this change replaces it with an RgbColor class that provides the same infomation plus a handful of useful methods to work with it. (Note that sizeof(RgbColor) == sizeof(uint32_t), so this change should not lead to memory bloat.) Some of the new methods/fields replace what were previously macro calls; e.g. RED(c) is now c.red, REDf(c) is now c.redF(). The .Equals() method is now used instead of == to compare colors. RGB colors still need to be represented as packed integers in file I/O and preferences, so the methods .FromPackedInt() and .ToPackedInt() are provided. Also implemented are Cnf{Freeze,Thaw}Color(), type-safe wrappers around Cnf{Freeze,Thaw}Int() that facilitate I/O with preferences. (Cnf{Freeze,Thaw}Color() are defined outside of the system-dependent code to minimize the footprint of the latter; because the same can be done with Cnf{Freeze,Thaw}Bool(), those are also moved out of the system code with this commit.) Color integers were being OR'ed with 0x80000000 in some places for two distinct purposes: One, to indicate use of a default color in glxFillMesh(); this has been replaced by use of the .UseDefault() method. Two, to indicate to TextWindow::Printf() that the format argument of a "%Bp"/"%Fp" specifier is an RGB color rather than a color "code" from TextWindow::bgColors[] or TextWindow::fgColors[] (as the specifier can accept either); instead, we define a new flag "z" (as in "%Bz" or "%Fz") to indicate an RGBcolor pointer, leaving "%Bp"/"%Fp" to indicate a color code exclusively. (This also allows TextWindow::meta[][].bg to be a char instead of an int, partly compensating for the new .bgRgb field added immediately after.) In array declarations, RGB colors could previously be specified as 0 (often in a terminating element). As that no longer works, we define NULL_COLOR, which serves much the same purpose for RgbColor variables as NULL serves for pointers.
2013-10-16 20:00:58 +00:00
CnfFreezeColor(backgroundColor, "BackgroundColor");
Add ability to set export canvas size (paper size for PDF, bbox size for EPS, etc.). This can either be fixed, with a given width and height and offset, or automatic, by the left right bottom top margins. And draw nicer dimensions for length, with arrows and more extension lines. Add code to trim those lines against the (rectangular, axis-aligned) box that contains the actual number, and use that (instead of the elliptical interpolation, which was only approximately right) for diameter dimensions too. [git-p4: depot-paths = "//depot/solvespace/": change = 2027]
2009-09-03 08:13:09 +00:00
// Whether export canvas size is fixed or derived from bbox
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
CnfFreezeBool(exportCanvasSizeAuto, "ExportCanvasSizeAuto");
Add ability to set export canvas size (paper size for PDF, bbox size for EPS, etc.). This can either be fixed, with a given width and height and offset, or automatic, by the left right bottom top margins. And draw nicer dimensions for length, with arrows and more extension lines. Add code to trim those lines against the (rectangular, axis-aligned) box that contains the actual number, and use that (instead of the elliptical interpolation, which was only approximately right) for diameter dimensions too. [git-p4: depot-paths = "//depot/solvespace/": change = 2027]
2009-09-03 08:13:09 +00:00
// Margins for automatic canvas size
CnfFreezeFloat(exportMargin.left, "ExportMargin_Left");
CnfFreezeFloat(exportMargin.right, "ExportMargin_Right");
CnfFreezeFloat(exportMargin.bottom, "ExportMargin_Bottom");
CnfFreezeFloat(exportMargin.top, "ExportMargin_Top");
// Dimensions for fixed canvas size
CnfFreezeFloat(exportCanvas.width, "ExportCanvas_Width");
CnfFreezeFloat(exportCanvas.height, "ExportCanvas_Height");
CnfFreezeFloat(exportCanvas.dx, "ExportCanvas_Dx");
CnfFreezeFloat(exportCanvas.dy, "ExportCanvas_Dy");
Add G Code export to SolveSpace, similar to SketchFlat. This requires user interface to specify the depth, number of passes, feed, and plunge feed, unfortunately. [git-p4: depot-paths = "//depot/solvespace/": change = 2106]
2010-01-14 04:47:17 +00:00
// Extra parameters when exporting G code
CnfFreezeFloat(gCode.depth, "GCode_Depth");
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
CnfFreezeInt(gCode.passes, "GCode_Passes");
Add G Code export to SolveSpace, similar to SketchFlat. This requires user interface to specify the depth, number of passes, feed, and plunge feed, unfortunately. [git-p4: depot-paths = "//depot/solvespace/": change = 2106]
2010-01-14 04:47:17 +00:00
CnfFreezeFloat(gCode.feed, "GCode_Feed");
CnfFreezeFloat(gCode.plungeFeed, "GCode_PlungeFeed");
Add a toolbar. This requires a tool to convert my PNG icons to tables in the code, which I have written in perl and am checking in. Also get WM_MOUSELEAVE events from win32, so that I can de-hover everything when the mouse leaves the graphics window. And fix one of the icons, which was 23x24 instead of 24x24. [git-p4: depot-paths = "//depot/solvespace/": change = 1883]
2009-01-02 10:38:36 +00:00
// Show toolbar in the graphics window
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
CnfFreezeBool(showToolbar, "ShowToolbar");
Add a scale factor when exporting; the user specifies a number, and all coordinates are divided by that number as we export. And add functions to store a float in the registry. I'm using those for the scale factor, and also to replace the crazy scaled integers that I was using for light positions etc. before. [git-p4: depot-paths = "//depot/solvespace/": change = 1824]
2008-07-08 07:41:29 +00:00
Move colors and line widths for almost everything to the styles mechanism. This gets filled in from some defaults, and stored in the registry. The default styles do not get saved in the file, but user-created styles (which aren't supported yet) do. [git-p4: depot-paths = "//depot/solvespace/": change = 2028]
2009-09-17 07:32:36 +00:00
// And the default styles, colors and line widths and such.
Style::FreezeDefaultStyles();
Add reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 04:22:52 +00:00
ExitNow();
}
Improve convergence of constraints involving parallel vectors, by using the initial numerical guess of whichever vector is already known to choose our projection planes. And add a mechanism to defer showing the text window or regenerating, in order to simplify dependencies on valid actives. Also yes/no/cancel when about to abandon an unsaved file, and a bugfix when rotating a rot/trans point. [git-p4: depot-paths = "//depot/solvespace/": change = 1772]
2008-06-03 18:28:41 +00:00
void SolveSpace::DoLater(void) {
if(later.generateAll) GenerateAll();
if(later.showTW) TW.Show();
ZERO(&later);
}
Add a screen to edit the view parameters; scale, translation, rotation. Also clean up the handling of units, by putting the conversion factors in only one place, and clean up the expression-parsing but removing all the copies of the same error message. [git-p4: depot-paths = "//depot/solvespace/": change = 2093]
2010-01-04 00:35:28 +00:00
double SolveSpace::MmPerUnit(void) {
if(viewUnits == UNIT_INCHES) {
return 25.4;
} else {
return 1.0;
}
}
Added const qualifiers String literals in C++ are implicitly typed as 'const char *', and with this change, their const-ness is maintained when assigning them to variables or passing them as arguments. This significantly cuts down the number of warnings generated by the compiler.
2013-08-26 18:58:35 +00:00
const char *SolveSpace::UnitName(void) {
Add a screen to edit the view parameters; scale, translation, rotation. Also clean up the handling of units, by putting the conversion factors in only one place, and clean up the expression-parsing but removing all the copies of the same error message. [git-p4: depot-paths = "//depot/solvespace/": change = 2093]
2010-01-04 00:35:28 +00:00
if(viewUnits == UNIT_INCHES) {
return "inch";
} else {
return "mm";
}
}
Now display dimensions (and stuff in the text window) in the user-selected units, and enter them the same way. [git-p4: depot-paths = "//depot/solvespace/": change = 1792]
2008-06-14 09:51:25 +00:00
char *SolveSpace::MmToString(double v) {
static int WhichBuf;
static char Bufs[8][128];
WhichBuf++;
if(WhichBuf >= 8 || WhichBuf < 0) WhichBuf = 0;
char *s = Bufs[WhichBuf];
if(viewUnits == UNIT_INCHES) {
Use a '*' printf() field width rather than an intermediate format string
2013-09-19 04:50:11 +00:00
sprintf(s, "%.*f", afterDecimalInch, v/25.4);
Now display dimensions (and stuff in the text window) in the user-selected units, and enter them the same way. [git-p4: depot-paths = "//depot/solvespace/": change = 1792]
2008-06-14 09:51:25 +00:00
} else {
Use a '*' printf() field width rather than an intermediate format string
2013-09-19 04:50:11 +00:00
sprintf(s, "%.*f", afterDecimalMm, v);
Now display dimensions (and stuff in the text window) in the user-selected units, and enter them the same way. [git-p4: depot-paths = "//depot/solvespace/": change = 1792]
2008-06-14 09:51:25 +00:00
}
return s;
}
double SolveSpace::ExprToMm(Expr *e) {
Add a screen to edit the view parameters; scale, translation, rotation. Also clean up the handling of units, by putting the conversion factors in only one place, and clean up the expression-parsing but removing all the copies of the same error message. [git-p4: depot-paths = "//depot/solvespace/": change = 2093]
2010-01-04 00:35:28 +00:00
return (e->Eval()) * MmPerUnit();
Now display dimensions (and stuff in the text window) in the user-selected units, and enter them the same way. [git-p4: depot-paths = "//depot/solvespace/": change = 1792]
2008-06-14 09:51:25 +00:00
}
Added const qualifiers String literals in C++ are implicitly typed as 'const char *', and with this change, their const-ness is maintained when assigning them to variables or passing them as arguments. This significantly cuts down the number of warnings generated by the compiler.
2013-08-26 18:58:35 +00:00
double SolveSpace::StringToMm(const char *str) {
Add a screen to edit the view parameters; scale, translation, rotation. Also clean up the handling of units, by putting the conversion factors in only one place, and clean up the expression-parsing but removing all the copies of the same error message. [git-p4: depot-paths = "//depot/solvespace/": change = 2093]
2010-01-04 00:35:28 +00:00
return atof(str) * MmPerUnit();
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
}
Add code to subdivide (with de Castljau's algorithm) a surface, and use that for surface-line intersections. That has major problems with the heuristic on when to stop and do Newton polishing. There's also an issue with all the Newton stuff when surfaces join tangent. And update the wishlist to reflect current needs. [git-p4: depot-paths = "//depot/solvespace/": change = 1925]
2009-03-08 10:59:57 +00:00
double SolveSpace::ChordTolMm(void) {
return SS.chordTol / SS.GW.scale;
}
Make the number of digits after the decimal point (for dimensions, as they are displayed on the drawing, and for many other places) a user-configurable parameter. Also reshuffle some options in the configuration screen, to put all the stuff relating to exports together. [git-p4: depot-paths = "//depot/solvespace/": change = 2179]
2010-09-24 02:58:34 +00:00
int SolveSpace::UnitDigitsAfterDecimal(void) {
return (viewUnits == UNIT_INCHES) ? afterDecimalInch : afterDecimalMm;
}
void SolveSpace::SetUnitDigitsAfterDecimal(int v) {
if(viewUnits == UNIT_INCHES) {
afterDecimalInch = v;
} else {
afterDecimalMm = v;
}
}
Now display dimensions (and stuff in the text window) in the user-selected units, and enter them the same way. [git-p4: depot-paths = "//depot/solvespace/": change = 1792]
2008-06-14 09:51:25 +00:00
Add text angle for styles. Add ability to quickly change between perspective and parallel projections. Add a snap grid, for points and for text comments. Draw text comments in the plane of their workplane if they have one, otherwise always facing forward. And fix a few nasty bugs: the possibility of an extremely long animation onto a workplane, accidental use of the wrong style line width for constraints, misplaced text box in style screen for default styles, other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 2037]
2009-09-29 11:35:19 +00:00
double SolveSpace::CameraTangent(void) {
Instead of a "force parallel projection" menu item that's on by default, let's do a "use perspective projection" item that's off by default. Same meaning, but less confusion. [git-p4: depot-paths = "//depot/solvespace/": change = 2132]
2010-05-03 05:15:28 +00:00
if(!usePerspectiveProj) {
Add text angle for styles. Add ability to quickly change between perspective and parallel projections. Add a snap grid, for points and for text comments. Draw text comments in the plane of their workplane if they have one, otherwise always facing forward. And fix a few nasty bugs: the possibility of an extremely long animation onto a workplane, accidental use of the wrong style line width for constraints, misplaced text box in style screen for default styles, other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 2037]
2009-09-29 11:35:19 +00:00
return 0;
} else {
return cameraTangent;
}
}
Now display dimensions (and stuff in the text window) in the user-selected units, and enter them the same way. [git-p4: depot-paths = "//depot/solvespace/": change = 1792]
2008-06-14 09:51:25 +00:00
Add the file open/save user interface. This includes a list of recently opened files, that is saved in the registry and displayed in a separate popup menu. [git-p4: depot-paths = "//depot/solvespace/": change = 1752]
2008-05-28 10:10:31 +00:00
void SolveSpace::AfterNewFile(void) {
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
// Clear out the traced point, which is no longer valid
traced.point = Entity::NO_ENTITY;
traced.path.l.Clear();
Add sin and cos to the expression entry (for dimensions etc.), with the same precedence as sqrt. Add the code to find naked edges, and draw them highlighted on the model. And make the direction of trim curves consistent, always ccw with normal toward viewer; so there's no need to fix the directions before triangulating. [git-p4: depot-paths = "//depot/solvespace/": change = 1903]
2009-01-25 09:19:59 +00:00
// and the naked edges
nakedEdges.Clear();
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
Revamp the edge classification for Booleans. I no longer make a separate polygon of coincident (with same or opposite normal) faces; I instead test all the edges against the other shell, and have extended the classify-against-shell stuff to handle those cases. And the normals are now perturbed a bit numerically, to either side of the edge, to distinguish tangency from a coincident surface. This seems to work fairly well, although things still tend to fail when the piecewise linear tolerance is too coarse. [git-p4: depot-paths = "//depot/solvespace/": change = 1964]
2009-06-04 03:59:40 +00:00
// GenerateAll() expects the view to be valid, because it uses that to
// fill in default values for extrusion depths etc. (which won't matter
// here, but just don't let it work on garbage)
SS.GW.offset = Vector::From(0, 0, 0);
SS.GW.projRight = Vector::From(1, 0, 0);
SS.GW.projUp = Vector::From(0, 1, 0);
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 10:10:12 +00:00
ReloadAllImported();
Consolidate the code that determines whether an entity is visible in one place. And remove the ability to disable the solver, since that's unlikely to be anything but confusing (and in any case, was badly implemented). This is in preparation for selective solving, of only the dirty groups. [git-p4: depot-paths = "//depot/solvespace/": change = 1769]
2008-06-02 09:31:26 +00:00
GenerateAll(-1, -1);
Add user interface to specify union/difference for extrudes, and implement that. Also make solver work only between the first and last visible group; earlier can just work from previous solve result, and later don't matter. There's some issues with the csg code; it will eventually produce an open mesh, which is very bad. Not sure whether that's a logic bug, or a numerical issue; still generating absurd triangles pretty routinely. [git-p4: depot-paths = "//depot/solvespace/": change = 1741]
2008-05-25 13:11:44 +00:00
Tweak the handles to make more space in the request ID, so that I can use the high bits as an "import ID" for imported parts, for hierarchy (that retains parametric capabilities). Implement enought that I can draw a datum point or a line segment, and drag points around in three-space. Still so much to do. [git-p4: depot-paths = "//depot/solvespace/": change = 1665]
2008-04-13 10:57:41 +00:00
TW.Init();
GW.Init();
Improve convergence of constraints involving parallel vectors, by using the initial numerical guess of whichever vector is already known to choose our projection planes. And add a mechanism to defer showing the text window or regenerating, in order to simplify dependencies on valid actives. Also yes/no/cancel when about to abandon an unsaved file, and a bugfix when rotating a rot/trans point. [git-p4: depot-paths = "//depot/solvespace/": change = 1772]
2008-06-03 18:28:41 +00:00
unsaved = false;
Add more measurement information about the selection. And remove menu items for some features that I suppose I won't add, and fix some bugs. [git-p4: depot-paths = "//depot/solvespace/": change = 1787]
2008-06-12 07:31:41 +00:00
int w, h;
GetGraphicsWindowSize(&w, &h);
GW.width = w;
GW.height = h;
Add sweeps. The user specifies a trajectory and a section, in two separate groups. The section is swept normal to the trajectory, producing a mesh. I'm doing the triangles only now, not copying over any entities. Also fix a bug in the PNG export; rows are 4-aligned, so that was breaking when the width of the image wasn't divisible by four. Also fix a bug in lathes, where it generated overlapping triangles for one segment. And change the groups to record both "this mesh", the contribution due to the extrude/lathe/whatever, and the "running mesh", that we get after applying the requested Boolean op between "this mesh" and the previous group's "running mesh". I'll use that to make step and repeats step the mesh too. [git-p4: depot-paths = "//depot/solvespace/": change = 1801]
2008-06-21 10:18:20 +00:00
// The triangles haven't been generated yet, but zoom to fit the entities
Put back code to generate emphasized edges from a mesh; so now we can show edges for both meshes and shells, and export them and hidden line remove and all the usual stuff. And fix the zoom to fit on startup, so that it considers hidden entities too. That avoids the problem where things get generated at stupid chord tolerance because no entities were visible and the mesh of course did not yet exist. [git-p4: depot-paths = "//depot/solvespace/": change = 1961]
2009-05-29 05:40:17 +00:00
// roughly in the window, since that sets the mesh tolerance. Consider
// invisible entities, so we still get something reasonable if the only
// thing visible is the not-yet-generated surfaces.
GW.ZoomToFit(true);
Add a special constraint type for comments; no equations, just user-visible text. And make points hoverable/selectable even when GW.showPoints is false, and zoom to fit before regenerating on file open, because then we're at the right zoom level (and will use the right pwl tolerance). [git-p4: depot-paths = "//depot/solvespace/": change = 1788]
2008-06-12 08:58:58 +00:00
GenerateAll(0, INT_MAX);
later.showTW = true;
Add sweeps. The user specifies a trajectory and a section, in two separate groups. The section is swept normal to the trajectory, producing a mesh. I'm doing the triangles only now, not copying over any entities. Also fix a bug in the PNG export; rows are 4-aligned, so that was breaking when the width of the image wasn't divisible by four. Also fix a bug in lathes, where it generated overlapping triangles for one segment. And change the groups to record both "this mesh", the contribution due to the extrude/lathe/whatever, and the "running mesh", that we get after applying the requested Boolean op between "this mesh" and the previous group's "running mesh". I'll use that to make step and repeats step the mesh too. [git-p4: depot-paths = "//depot/solvespace/": change = 1801]
2008-06-21 10:18:20 +00:00
// Then zoom to fit again, to fit the triangles
Put back code to generate emphasized edges from a mesh; so now we can show edges for both meshes and shells, and export them and hidden line remove and all the usual stuff. And fix the zoom to fit on startup, so that it considers hidden entities too. That avoids the problem where things get generated at stupid chord tolerance because no entities were visible and the mesh of course did not yet exist. [git-p4: depot-paths = "//depot/solvespace/": change = 1961]
2009-05-29 05:40:17 +00:00
GW.ZoomToFit(false);
Show the open filename in the title bar of the graphics window. [git-p4: depot-paths = "//depot/solvespace/": change = 1826]
2008-07-08 08:02:22 +00:00
Add user interface to modify styles: change the color, line width, line width units, on-screen and export visibility. So now we can use that to modify the default styles, or to create custom styles. Also add code to draw fat lines, with round endcaps, since gl doesn't do that. Next we need some user interface to assign styles to entities, and to make all the export file formats support the style attributes. [git-p4: depot-paths = "//depot/solvespace/": change = 2029]
2009-09-18 08:14:15 +00:00
// Create all the default styles; they'll get created on the fly anyways,
// but can't hurt to do it now.
Style::CreateAllDefaultStyles();
Show the open filename in the title bar of the graphics window. [git-p4: depot-paths = "//depot/solvespace/": change = 1826]
2008-07-08 08:02:22 +00:00
UpdateWindowTitle();
Check in some SolveSpace stuff, even though I didn't make much progress. I want to change the sketch.h stuff fairly significantly, I think, before proceeding. [git-p4: depot-paths = "//depot/solvespace/": change = 1657]
2008-04-08 12:54:53 +00:00
}
Add the file open/save user interface. This includes a list of recently opened files, that is saved in the registry and displayed in a separate popup menu. [git-p4: depot-paths = "//depot/solvespace/": change = 1752]
2008-05-28 10:10:31 +00:00
void SolveSpace::RemoveFromRecentList(char *file) {
int src, dest;
dest = 0;
for(src = 0; src < MAX_RECENT; src++) {
if(strcmp(file, RecentFile[src]) != 0) {
if(src != dest) strcpy(RecentFile[dest], RecentFile[src]);
dest++;
}
}
while(dest < MAX_RECENT) strcpy(RecentFile[dest++], "");
RefreshRecentMenus();
}
void SolveSpace::AddToRecentList(char *file) {
RemoveFromRecentList(file);
int src;
for(src = MAX_RECENT - 2; src >= 0; src--) {
strcpy(RecentFile[src+1], RecentFile[src]);
}
strcpy(RecentFile[0], file);
RefreshRecentMenus();
}
Improve convergence of constraints involving parallel vectors, by using the initial numerical guess of whichever vector is already known to choose our projection planes. And add a mechanism to defer showing the text window or regenerating, in order to simplify dependencies on valid actives. Also yes/no/cancel when about to abandon an unsaved file, and a bugfix when rotating a rot/trans point. [git-p4: depot-paths = "//depot/solvespace/": change = 1772]
2008-06-03 18:28:41 +00:00
bool SolveSpace::GetFilenameAndSave(bool saveAs) {
Change the licensing so that we run unrestricted for ninety days after first execution, but limit the number of constraints to 30 after 90 days. [git-p4: depot-paths = "//depot/solvespace/": change = 1977]
2009-06-10 06:57:27 +00:00
Improve convergence of constraints involving parallel vectors, by using the initial numerical guess of whichever vector is already known to choose our projection planes. And add a mechanism to defer showing the text window or regenerating, in order to simplify dependencies on valid actives. Also yes/no/cancel when about to abandon an unsaved file, and a bugfix when rotating a rot/trans point. [git-p4: depot-paths = "//depot/solvespace/": change = 1772]
2008-06-03 18:28:41 +00:00
char newFile[MAX_PATH];
strcpy(newFile, saveFile);
if(saveAs || strlen(newFile)==0) {
if(!GetSaveFile(newFile, SLVS_EXT, SLVS_PATTERN)) return false;
}
if(SaveToFile(newFile)) {
AddToRecentList(newFile);
strcpy(saveFile, newFile);
unsaved = false;
return true;
} else {
return false;
}
}
bool SolveSpace::OkayToStartNewFile(void) {
if(!unsaved) return true;
switch(SaveFileYesNoCancel()) {
Use system-agnostic return values for SaveFileYesNoCancel() This function was returning ID{YES,NO,CANCEL}, which are specific to Windows as return values for MessageBox(). These have been replaced with SAVE_{YES,NO,CANCEL}, which we define ourselves.
2013-09-18 20:49:32 +00:00
case SAVE_YES:
Improve convergence of constraints involving parallel vectors, by using the initial numerical guess of whichever vector is already known to choose our projection planes. And add a mechanism to defer showing the text window or regenerating, in order to simplify dependencies on valid actives. Also yes/no/cancel when about to abandon an unsaved file, and a bugfix when rotating a rot/trans point. [git-p4: depot-paths = "//depot/solvespace/": change = 1772]
2008-06-03 18:28:41 +00:00
return GetFilenameAndSave(false);
Use system-agnostic return values for SaveFileYesNoCancel() This function was returning ID{YES,NO,CANCEL}, which are specific to Windows as return values for MessageBox(). These have been replaced with SAVE_{YES,NO,CANCEL}, which we define ourselves.
2013-09-18 20:49:32 +00:00
case SAVE_NO:
Improve convergence of constraints involving parallel vectors, by using the initial numerical guess of whichever vector is already known to choose our projection planes. And add a mechanism to defer showing the text window or regenerating, in order to simplify dependencies on valid actives. Also yes/no/cancel when about to abandon an unsaved file, and a bugfix when rotating a rot/trans point. [git-p4: depot-paths = "//depot/solvespace/": change = 1772]
2008-06-03 18:28:41 +00:00
return true;
Use system-agnostic return values for SaveFileYesNoCancel() This function was returning ID{YES,NO,CANCEL}, which are specific to Windows as return values for MessageBox(). These have been replaced with SAVE_{YES,NO,CANCEL}, which we define ourselves.
2013-09-18 20:49:32 +00:00
case SAVE_CANCEL:
Improve convergence of constraints involving parallel vectors, by using the initial numerical guess of whichever vector is already known to choose our projection planes. And add a mechanism to defer showing the text window or regenerating, in order to simplify dependencies on valid actives. Also yes/no/cancel when about to abandon an unsaved file, and a bugfix when rotating a rot/trans point. [git-p4: depot-paths = "//depot/solvespace/": change = 1772]
2008-06-03 18:28:41 +00:00
return false;
Use system-agnostic return values for SaveFileYesNoCancel() This function was returning ID{YES,NO,CANCEL}, which are specific to Windows as return values for MessageBox(). These have been replaced with SAVE_{YES,NO,CANCEL}, which we define ourselves.
2013-09-18 20:49:32 +00:00
default: oops(); break;
Improve convergence of constraints involving parallel vectors, by using the initial numerical guess of whichever vector is already known to choose our projection planes. And add a mechanism to defer showing the text window or regenerating, in order to simplify dependencies on valid actives. Also yes/no/cancel when about to abandon an unsaved file, and a bugfix when rotating a rot/trans point. [git-p4: depot-paths = "//depot/solvespace/": change = 1772]
2008-06-03 18:28:41 +00:00
}
}
Show the open filename in the title bar of the graphics window. [git-p4: depot-paths = "//depot/solvespace/": change = 1826]
2008-07-08 08:02:22 +00:00
void SolveSpace::UpdateWindowTitle(void) {
if(strlen(saveFile) == 0) {
SetWindowTitle("SolveSpace - (not yet saved)");
} else {
char buf[MAX_PATH+100];
sprintf(buf, "SolveSpace - %s", saveFile);
SetWindowTitle(buf);
}
}
Rename some stuff in the IdList again. Rough in the file save stuff, though no file load stuff, and perhaps this can all be made to work from a table somehow. Move the quaternion stuff into its own class, and add a fancy animated view when you orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1672]
2008-04-18 11:11:48 +00:00
void SolveSpace::MenuFile(int id) {
Add the file open/save user interface. This includes a list of recently opened files, that is saved in the registry and displayed in a separate popup menu. [git-p4: depot-paths = "//depot/solvespace/": change = 1752]
2008-05-28 10:10:31 +00:00
if(id >= RECENT_OPEN && id < (RECENT_OPEN+MAX_RECENT)) {
Remove the back button from the text window, since I never used it. And fix a bug; wasn't asking the user whether to save before abandoning file when a new file was opened recent. [git-p4: depot-paths = "//depot/solvespace/": change = 1830]
2008-07-10 06:11:56 +00:00
if(!SS.OkayToStartNewFile()) return;
Add the file open/save user interface. This includes a list of recently opened files, that is saved in the registry and displayed in a separate popup menu. [git-p4: depot-paths = "//depot/solvespace/": change = 1752]
2008-05-28 10:10:31 +00:00
char newFile[MAX_PATH];
strcpy(newFile, RecentFile[id-RECENT_OPEN]);
RemoveFromRecentList(newFile);
if(SS.LoadFromFile(newFile)) {
strcpy(SS.saveFile, newFile);
AddToRecentList(newFile);
} else {
strcpy(SS.saveFile, "");
SS.NewFile();
}
SS.AfterNewFile();
return;
}
Rename some stuff in the IdList again. Rough in the file save stuff, though no file load stuff, and perhaps this can all be made to work from a table somehow. Move the quaternion stuff into its own class, and add a fancy animated view when you orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1672]
2008-04-18 11:11:48 +00:00
switch(id) {
case GraphicsWindow::MNU_NEW:
Improve convergence of constraints involving parallel vectors, by using the initial numerical guess of whichever vector is already known to choose our projection planes. And add a mechanism to defer showing the text window or regenerating, in order to simplify dependencies on valid actives. Also yes/no/cancel when about to abandon an unsaved file, and a bugfix when rotating a rot/trans point. [git-p4: depot-paths = "//depot/solvespace/": change = 1772]
2008-06-03 18:28:41 +00:00
if(!SS.OkayToStartNewFile()) break;
Add the file open/save user interface. This includes a list of recently opened files, that is saved in the registry and displayed in a separate popup menu. [git-p4: depot-paths = "//depot/solvespace/": change = 1752]
2008-05-28 10:10:31 +00:00
strcpy(SS.saveFile, "");
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 06:22:16 +00:00
SS.NewFile();
Add the file open/save user interface. This includes a list of recently opened files, that is saved in the registry and displayed in a separate popup menu. [git-p4: depot-paths = "//depot/solvespace/": change = 1752]
2008-05-28 10:10:31 +00:00
SS.AfterNewFile();
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 06:22:16 +00:00
break;
Add the file open/save user interface. This includes a list of recently opened files, that is saved in the registry and displayed in a separate popup menu. [git-p4: depot-paths = "//depot/solvespace/": change = 1752]
2008-05-28 10:10:31 +00:00
case GraphicsWindow::MNU_OPEN: {
Improve convergence of constraints involving parallel vectors, by using the initial numerical guess of whichever vector is already known to choose our projection planes. And add a mechanism to defer showing the text window or regenerating, in order to simplify dependencies on valid actives. Also yes/no/cancel when about to abandon an unsaved file, and a bugfix when rotating a rot/trans point. [git-p4: depot-paths = "//depot/solvespace/": change = 1772]
2008-06-03 18:28:41 +00:00
if(!SS.OkayToStartNewFile()) break;
Add the file open/save user interface. This includes a list of recently opened files, that is saved in the registry and displayed in a separate popup menu. [git-p4: depot-paths = "//depot/solvespace/": change = 1752]
2008-05-28 10:10:31 +00:00
char newFile[MAX_PATH] = "";
Initial work on the assembly (`import') feature. I can import a part, including all of its entities and the triangle mesh. These are transformed by a rotation and translation, and appear in the sketch; the transformation may be set with constraints. [git-p4: depot-paths = "//depot/solvespace/": change = 1756]
2008-05-29 10:10:12 +00:00
if(GetOpenFile(newFile, SLVS_EXT, SLVS_PATTERN)) {
Add the file open/save user interface. This includes a list of recently opened files, that is saved in the registry and displayed in a separate popup menu. [git-p4: depot-paths = "//depot/solvespace/": change = 1752]
2008-05-28 10:10:31 +00:00
if(SS.LoadFromFile(newFile)) {
strcpy(SS.saveFile, newFile);
AddToRecentList(newFile);
} else {
strcpy(SS.saveFile, "");
SS.NewFile();
}
SS.AfterNewFile();
}
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 06:22:16 +00:00
break;
Add the file open/save user interface. This includes a list of recently opened files, that is saved in the registry and displayed in a separate popup menu. [git-p4: depot-paths = "//depot/solvespace/": change = 1752]
2008-05-28 10:10:31 +00:00
}
Rename some stuff in the IdList again. Rough in the file save stuff, though no file load stuff, and perhaps this can all be made to work from a table somehow. Move the quaternion stuff into its own class, and add a fancy animated view when you orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1672]
2008-04-18 11:11:48 +00:00
case GraphicsWindow::MNU_SAVE:
Improve convergence of constraints involving parallel vectors, by using the initial numerical guess of whichever vector is already known to choose our projection planes. And add a mechanism to defer showing the text window or regenerating, in order to simplify dependencies on valid actives. Also yes/no/cancel when about to abandon an unsaved file, and a bugfix when rotating a rot/trans point. [git-p4: depot-paths = "//depot/solvespace/": change = 1772]
2008-06-03 18:28:41 +00:00
SS.GetFilenameAndSave(false);
break;
Rename some stuff in the IdList again. Rough in the file save stuff, though no file load stuff, and perhaps this can all be made to work from a table somehow. Move the quaternion stuff into its own class, and add a fancy animated view when you orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1672]
2008-04-18 11:11:48 +00:00
Improve convergence of constraints involving parallel vectors, by using the initial numerical guess of whichever vector is already known to choose our projection planes. And add a mechanism to defer showing the text window or regenerating, in order to simplify dependencies on valid actives. Also yes/no/cancel when about to abandon an unsaved file, and a bugfix when rotating a rot/trans point. [git-p4: depot-paths = "//depot/solvespace/": change = 1772]
2008-06-03 18:28:41 +00:00
case GraphicsWindow::MNU_SAVE_AS:
SS.GetFilenameAndSave(true);
Rename some stuff in the IdList again. Rough in the file save stuff, though no file load stuff, and perhaps this can all be made to work from a table somehow. Move the quaternion stuff into its own class, and add a fancy animated view when you orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1672]
2008-04-18 11:11:48 +00:00
break;
Link against libpng and zlib, and use that to export graphics; basically just a screenshot, get the image from the framebuffer. [git-p4: depot-paths = "//depot/solvespace/": change = 1797]
2008-06-18 08:35:14 +00:00
case GraphicsWindow::MNU_EXPORT_PNG: {
char exportFile[MAX_PATH] = "";
if(!GetSaveFile(exportFile, PNG_EXT, PNG_PATTERN)) break;
SS.ExportAsPngTo(exportFile);
break;
}
Split export DXF command into export section and export view, and add framework for additional vector output formats (ps, pdf). [git-p4: depot-paths = "//depot/solvespace/": change = 1893]
2009-01-14 05:10:42 +00:00
case GraphicsWindow::MNU_EXPORT_VIEW: {
Add DXF export. The complexity comes from all the different ways to specify the plane from which we want to grab the triangles. Shared edges are then removed with the same code used to check for watertight meshes, and the remaining edges are assembled into polygons. [git-p4: depot-paths = "//depot/solvespace/": change = 1823]
2008-07-08 06:30:13 +00:00
char exportFile[MAX_PATH] = "";
Add eps, hpgl, and svg output (simple, all just for polylines). And fix convergence tolerance so that points projected into a rational polynomial surface end up much closer than LENGTH_EPS. [git-p4: depot-paths = "//depot/solvespace/": change = 1906]
2009-01-27 05:48:40 +00:00
if(!GetSaveFile(exportFile, VEC_EXT, VEC_PATTERN)) break;
Add G Code export to SolveSpace, similar to SketchFlat. This requires user interface to specify the depth, number of passes, feed, and plunge feed, unfortunately. [git-p4: depot-paths = "//depot/solvespace/": change = 2106]
2010-01-14 04:47:17 +00:00
// If the user is exporting something where it would be
// inappropriate to include the constraints, then warn.
if(SS.GW.showConstraints &&
(StringEndsIn(exportFile, ".txt") ||
fabs(SS.exportOffset) > LENGTH_EPS))
{
Message("Constraints are currently shown, and will be exported "
"in the toolpath. This is probably not what you want; "
"hide them by clicking the link at the top of the "
"text window.");
}
Add 3d wireframe export, in DXF or STEP format. This uses most of the same plumbing as the 2d vector output. Also fix piecewise linear tolerance when the export scale factor is not equal to one; have to scale the chord tol along with that. [git-p4: depot-paths = "//depot/solvespace/": change = 2053]
2009-10-12 10:40:48 +00:00
SS.ExportViewOrWireframeTo(exportFile, false);
break;
}
case GraphicsWindow::MNU_EXPORT_WIREFRAME: {
char exportFile[MAX_PATH] = "";
if(!GetSaveFile(exportFile, V3D_EXT, V3D_PATTERN)) break;
SS.ExportViewOrWireframeTo(exportFile, true);
Split export DXF command into export section and export view, and add framework for additional vector output formats (ps, pdf). [git-p4: depot-paths = "//depot/solvespace/": change = 1893]
2009-01-14 05:10:42 +00:00
break;
}
case GraphicsWindow::MNU_EXPORT_SECTION: {
char exportFile[MAX_PATH] = "";
Add eps, hpgl, and svg output (simple, all just for polylines). And fix convergence tolerance so that points projected into a rational polynomial surface end up much closer than LENGTH_EPS. [git-p4: depot-paths = "//depot/solvespace/": change = 1906]
2009-01-27 05:48:40 +00:00
if(!GetSaveFile(exportFile, VEC_EXT, VEC_PATTERN)) break;
Split export DXF command into export section and export view, and add framework for additional vector output formats (ps, pdf). [git-p4: depot-paths = "//depot/solvespace/": change = 1893]
2009-01-14 05:10:42 +00:00
SS.ExportSectionTo(exportFile);
Add DXF export. The complexity comes from all the different ways to specify the plane from which we want to grab the triangles. Shared edges are then removed with the same code used to check for watertight meshes, and the remaining edges are assembled into polygons. [git-p4: depot-paths = "//depot/solvespace/": change = 1823]
2008-07-08 06:30:13 +00:00
break;
}
Add export of the mesh as an STL file. That's trivial. [git-p4: depot-paths = "//depot/solvespace/": change = 1822]
2008-07-06 09:24:31 +00:00
case GraphicsWindow::MNU_EXPORT_MESH: {
char exportFile[MAX_PATH] = "";
Add Wavefront OBJ support, to supplement the existing STL mesh export. That doesn't seem very useful, but it's only a few dozen lines of code. [git-p4: depot-paths = "//depot/solvespace/": change = 2054]
2009-10-12 11:34:43 +00:00
if(!GetSaveFile(exportFile, MESH_EXT, MESH_PATTERN)) break;
Add export of the mesh as an STL file. That's trivial. [git-p4: depot-paths = "//depot/solvespace/": change = 1822]
2008-07-06 09:24:31 +00:00
SS.ExportMeshTo(exportFile);
break;
}
Add beginnings of STEP export, which weren't as horrible as I had feared. Though I don't have rational surfaces or curves going yet, and I don't have the stuff to handle holes or multiple outer contours in a single surface. [git-p4: depot-paths = "//depot/solvespace/": change = 1974]
2009-06-08 06:50:16 +00:00
case GraphicsWindow::MNU_EXPORT_SURFACES: {
char exportFile[MAX_PATH] = "";
if(!GetSaveFile(exportFile, SRF_EXT, SRF_PATTERN)) break;
StepFileWriter sfw;
ZERO(&sfw);
Add STEP file export for 2d curves too, and disable extrusion not normal to the sketch. [git-p4: depot-paths = "//depot/solvespace/": change = 1981]
2009-06-11 05:57:23 +00:00
sfw.ExportSurfacesTo(exportFile);
Add beginnings of STEP export, which weren't as horrible as I had feared. Though I don't have rational surfaces or curves going yet, and I don't have the stuff to handle holes or multiple outer contours in a single surface. [git-p4: depot-paths = "//depot/solvespace/": change = 1974]
2009-06-08 06:50:16 +00:00
break;
}
Rename some stuff in the IdList again. Rough in the file save stuff, though no file load stuff, and perhaps this can all be made to work from a table somehow. Move the quaternion stuff into its own class, and add a fancy animated view when you orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1672]
2008-04-18 11:11:48 +00:00
case GraphicsWindow::MNU_EXIT:
Improve convergence of constraints involving parallel vectors, by using the initial numerical guess of whichever vector is already known to choose our projection planes. And add a mechanism to defer showing the text window or regenerating, in order to simplify dependencies on valid actives. Also yes/no/cancel when about to abandon an unsaved file, and a bugfix when rotating a rot/trans point. [git-p4: depot-paths = "//depot/solvespace/": change = 1772]
2008-06-03 18:28:41 +00:00
if(!SS.OkayToStartNewFile()) break;
Add reference dimensions, add user-programmable lighting, and add a configuration screen where all this can be specified. [git-p4: depot-paths = "//depot/solvespace/": change = 1783]
2008-06-11 04:22:52 +00:00
SS.Exit();
Rename some stuff in the IdList again. Rough in the file save stuff, though no file load stuff, and perhaps this can all be made to work from a table somehow. Move the quaternion stuff into its own class, and add a fancy animated view when you orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1672]
2008-04-18 11:11:48 +00:00
break;
default: oops();
}
Show the open filename in the title bar of the graphics window. [git-p4: depot-paths = "//depot/solvespace/": change = 1826]
2008-07-08 08:02:22 +00:00
SS.UpdateWindowTitle();
Rename some stuff in the IdList again. Rough in the file save stuff, though no file load stuff, and perhaps this can all be made to work from a table somehow. Move the quaternion stuff into its own class, and add a fancy animated view when you orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1672]
2008-04-18 11:11:48 +00:00
}
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
void SolveSpace::MenuAnalyze(int id) {
SS.GW.GroupSelection();
#define gs (SS.GW.gs)
switch(id) {
case GraphicsWindow::MNU_STEP_DIM:
if(gs.constraints == 1 && gs.n == 0) {
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Constraint *c = SK.GetConstraint(gs.constraint[0]);
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
if(c->HasLabel() && !c->reference) {
SS.TW.shown.dimFinish = c->valA;
SS.TW.shown.dimSteps = 10;
SS.TW.shown.dimIsDistance =
(c->type != Constraint::ANGLE) &&
(c->type != Constraint::LENGTH_RATIO);
SS.TW.shown.constraint = c->h;
SS.TW.shown.screen = TextWindow::SCREEN_STEP_DIMENSION;
Auto-show the text window when stepping a dimension, in addition to auto-showing when a solve fails. And accept expressions, not just numbers, for that new dimension value. [git-p4: depot-paths = "//depot/solvespace/": change = 1877]
2008-09-17 10:13:37 +00:00
// The step params are specified in the text window,
// so force that to be shown.
SS.GW.ForceTextWindowShown();
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
SS.later.showTW = true;
SS.GW.ClearSelection();
} else {
Error("Constraint must have a label, and must not be "
"a reference dimension.");
}
} else {
Error("Bad selection for step dimension; select a constraint.");
}
break;
Early attempts at rational polynomial surfaces. I can create one from an extrusion, with piecewise linear trim curves for everything (that are shared, so that they appear only once for the two surfaces that each trims). No Boolean operations on them, and the triangulation is bad, because gl seems to merge collinear edges. So before going further, I seem to need my own triangulation code. I have not had great luck in the past, but I can't live without it now. [git-p4: depot-paths = "//depot/solvespace/": change = 1899]
2009-01-19 10:37:10 +00:00
case GraphicsWindow::MNU_NAKED_EDGES: {
Add sin and cos to the expression entry (for dimensions etc.), with the same precedence as sqrt. Add the code to find naked edges, and draw them highlighted on the model. And make the direction of trim curves consistent, always ccw with normal toward viewer; so there's no need to fix the directions before triangulating. [git-p4: depot-paths = "//depot/solvespace/": change = 1903]
2009-01-25 09:19:59 +00:00
SS.nakedEdges.Clear();
Report the number of triangles and surfaces in the naked edges check, hide the coordinate axes at the origin when normals are hidden (but still show the coordinate axes at the bottom left of the screen), and report point-line distance when a point and a line are selected. [git-p4: depot-paths = "//depot/solvespace/": change = 1973]
2009-06-07 23:00:57 +00:00
Group *g = SK.GetGroup(SS.GW.activeGroup);
SMesh *m = &(g->displayMesh);
Add sin and cos to the expression entry (for dimensions etc.), with the same precedence as sqrt. Add the code to find naked edges, and draw them highlighted on the model. And make the direction of trim curves consistent, always ccw with normal toward viewer; so there's no need to fix the directions before triangulating. [git-p4: depot-paths = "//depot/solvespace/": change = 1903]
2009-01-25 09:19:59 +00:00
SKdNode *root = SKdNode::From(m);
Test for self-intersecting mesh too when we test for naked edges. [git-p4: depot-paths = "//depot/solvespace/": change = 1909]
2009-01-28 07:09:01 +00:00
bool inters, leaks;
Put back code to generate emphasized edges from a mesh; so now we can show edges for both meshes and shells, and export them and hidden line remove and all the usual stuff. And fix the zoom to fit on startup, so that it considers hidden entities too. That avoids the problem where things get generated at stupid chord tolerance because no entities were visible and the mesh of course did not yet exist. [git-p4: depot-paths = "//depot/solvespace/": change = 1961]
2009-05-29 05:40:17 +00:00
root->MakeCertainEdgesInto(&(SS.nakedEdges),
SKdNode::NAKED_OR_SELF_INTER_EDGES, true, &inters, &leaks);
Add sin and cos to the expression entry (for dimensions etc.), with the same precedence as sqrt. Add the code to find naked edges, and draw them highlighted on the model. And make the direction of trim curves consistent, always ccw with normal toward viewer; so there's no need to fix the directions before triangulating. [git-p4: depot-paths = "//depot/solvespace/": change = 1903]
2009-01-25 09:19:59 +00:00
InvalidateGraphics();
Added const qualifiers String literals in C++ are implicitly typed as 'const char *', and with this change, their const-ness is maintained when assigning them to variables or passing them as arguments. This significantly cuts down the number of warnings generated by the compiler.
2013-08-26 18:58:35 +00:00
const char *intersMsg = inters ?
Test for self-intersecting mesh too when we test for naked edges. [git-p4: depot-paths = "//depot/solvespace/": change = 1909]
2009-01-28 07:09:01 +00:00
"The mesh is self-intersecting (NOT okay, invalid)." :
"The mesh is not self-intersecting (okay, valid).";
Added const qualifiers String literals in C++ are implicitly typed as 'const char *', and with this change, their const-ness is maintained when assigning them to variables or passing them as arguments. This significantly cuts down the number of warnings generated by the compiler.
2013-08-26 18:58:35 +00:00
const char *leaksMsg = leaks ?
Test for self-intersecting mesh too when we test for naked edges. [git-p4: depot-paths = "//depot/solvespace/": change = 1909]
2009-01-28 07:09:01 +00:00
"The mesh has naked edges (NOT okay, invalid)." :
"The mesh is watertight (okay, valid).";
Report the number of triangles and surfaces in the naked edges check, hide the coordinate axes at the origin when normals are hidden (but still show the coordinate axes at the bottom left of the screen), and report point-line distance when a point and a line are selected. [git-p4: depot-paths = "//depot/solvespace/": change = 1973]
2009-06-07 23:00:57 +00:00
char cntMsg[1024];
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
sprintf(cntMsg, "\n\nThe model contains %d triangles, from "
Report the number of triangles and surfaces in the naked edges check, hide the coordinate axes at the origin when normals are hidden (but still show the coordinate axes at the bottom left of the screen), and report point-line distance when a point and a line are selected. [git-p4: depot-paths = "//depot/solvespace/": change = 1973]
2009-06-07 23:00:57 +00:00
"%d surfaces.",
g->displayMesh.l.n, g->runningShell.surface.n);
Add sin and cos to the expression entry (for dimensions etc.), with the same precedence as sqrt. Add the code to find naked edges, and draw them highlighted on the model. And make the direction of trim curves consistent, always ccw with normal toward viewer; so there's no need to fix the directions before triangulating. [git-p4: depot-paths = "//depot/solvespace/": change = 1903]
2009-01-25 09:19:59 +00:00
if(SS.nakedEdges.l.n == 0) {
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
Message("%s\n\n%s\n\nZero problematic edges, good.%s",
Report the number of triangles and surfaces in the naked edges check, hide the coordinate axes at the origin when normals are hidden (but still show the coordinate axes at the bottom left of the screen), and report point-line distance when a point and a line are selected. [git-p4: depot-paths = "//depot/solvespace/": change = 1973]
2009-06-07 23:00:57 +00:00
intersMsg, leaksMsg, cntMsg);
Add sin and cos to the expression entry (for dimensions etc.), with the same precedence as sqrt. Add the code to find naked edges, and draw them highlighted on the model. And make the direction of trim curves consistent, always ccw with normal toward viewer; so there's no need to fix the directions before triangulating. [git-p4: depot-paths = "//depot/solvespace/": change = 1903]
2009-01-25 09:19:59 +00:00
} else {
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("%s\n\n%s\n\n%d problematic edges, bad.%s",
Report the number of triangles and surfaces in the naked edges check, hide the coordinate axes at the origin when normals are hidden (but still show the coordinate axes at the bottom left of the screen), and report point-line distance when a point and a line are selected. [git-p4: depot-paths = "//depot/solvespace/": change = 1973]
2009-06-07 23:00:57 +00:00
intersMsg, leaksMsg, SS.nakedEdges.l.n, cntMsg);
Add sin and cos to the expression entry (for dimensions etc.), with the same precedence as sqrt. Add the code to find naked edges, and draw them highlighted on the model. And make the direction of trim curves consistent, always ccw with normal toward viewer; so there's no need to fix the directions before triangulating. [git-p4: depot-paths = "//depot/solvespace/": change = 1903]
2009-01-25 09:19:59 +00:00
}
Early attempts at rational polynomial surfaces. I can create one from an extrusion, with piecewise linear trim curves for everything (that are shared, so that they appear only once for the two surfaces that each trims). No Boolean operations on them, and the triangulation is bad, because gl seems to merge collinear edges. So before going further, I seem to need my own triangulation code. I have not had great luck in the past, but I can't live without it now. [git-p4: depot-paths = "//depot/solvespace/": change = 1899]
2009-01-19 10:37:10 +00:00
break;
}
Add beginnings of stuff to represent surfaces as either meshes or exact surface shells. And add interference checking; I'll be lazy and just do that on the meshes, by modifying the self-intersection tester to ignore coplanar triangles (since that can happen in an assembly). [git-p4: depot-paths = "//depot/solvespace/": change = 1958]
2009-05-22 10:02:02 +00:00
case GraphicsWindow::MNU_INTERFERENCE: {
SS.nakedEdges.Clear();
SMesh *m = &(SK.GetGroup(SS.GW.activeGroup)->displayMesh);
SKdNode *root = SKdNode::From(m);
bool inters, leaks;
Put back code to generate emphasized edges from a mesh; so now we can show edges for both meshes and shells, and export them and hidden line remove and all the usual stuff. And fix the zoom to fit on startup, so that it considers hidden entities too. That avoids the problem where things get generated at stupid chord tolerance because no entities were visible and the mesh of course did not yet exist. [git-p4: depot-paths = "//depot/solvespace/": change = 1961]
2009-05-29 05:40:17 +00:00
root->MakeCertainEdgesInto(&(SS.nakedEdges),
Fix interference check to not report not-2-manifold edges; those can occur in assemblies with coincident faces. And turn on smooth shading, finally. [git-p4: depot-paths = "//depot/solvespace/": change = 1971]
2009-06-06 09:44:58 +00:00
SKdNode::SELF_INTER_EDGES, false, &inters, &leaks);
Put back code to generate emphasized edges from a mesh; so now we can show edges for both meshes and shells, and export them and hidden line remove and all the usual stuff. And fix the zoom to fit on startup, so that it considers hidden entities too. That avoids the problem where things get generated at stupid chord tolerance because no entities were visible and the mesh of course did not yet exist. [git-p4: depot-paths = "//depot/solvespace/": change = 1961]
2009-05-29 05:40:17 +00:00
Add beginnings of stuff to represent surfaces as either meshes or exact surface shells. And add interference checking; I'll be lazy and just do that on the meshes, by modifying the self-intersection tester to ignore coplanar triangles (since that can happen in an assembly). [git-p4: depot-paths = "//depot/solvespace/": change = 1958]
2009-05-22 10:02:02 +00:00
InvalidateGraphics();
if(inters) {
Error("%d edges interfere with other triangles, bad.",
SS.nakedEdges.l.n);
} else {
Message("The assembly does not interfere, good.");
}
break;
}
Add code to evaluate the volume of a mesh, thanks to the divergence theorem; it's evaluated as a surface integral over each triangle. And don't regenerate the emphasized edges unless we have to; specifically, don't do it when the only dirty group is the drawing group. [git-p4: depot-paths = "//depot/solvespace/": change = 1849]
2008-02-07 09:53:52 +00:00
case GraphicsWindow::MNU_VOLUME: {
Add a separate display mesh and edge list; so if we're working with a mesh than that's a copy, and if we're working with a shell then it's the shell's triangulation. [git-p4: depot-paths = "//depot/solvespace/": change = 1957]
2009-05-21 09:06:26 +00:00
SMesh *m = &(SK.GetGroup(SS.GW.activeGroup)->displayMesh);
Add code to evaluate the volume of a mesh, thanks to the divergence theorem; it's evaluated as a surface integral over each triangle. And don't regenerate the emphasized edges unless we have to; specifically, don't do it when the only dirty group is the drawing group. [git-p4: depot-paths = "//depot/solvespace/": change = 1849]
2008-02-07 09:53:52 +00:00
double vol = 0;
int i;
for(i = 0; i < m->l.n; i++) {
STriangle tr = m->l.elem[i];
// Translate to place vertex A at (x, y, 0)
Vector trans = Vector::From(tr.a.x, tr.a.y, 0);
tr.a = (tr.a).Minus(trans);
tr.b = (tr.b).Minus(trans);
tr.c = (tr.c).Minus(trans);
// Rotate to place vertex B on the y-axis. Depending on
// whether the triangle is CW or CCW, C is either to the
// right or to the left of the y-axis. This handles the
// sign of our normal.
Vector u = Vector::From(-tr.b.y, tr.b.x, 0);
u = u.WithMagnitude(1);
Vector v = Vector::From(tr.b.x, tr.b.y, 0);
v = v.WithMagnitude(1);
Vector n = Vector::From(0, 0, 1);
tr.a = (tr.a).DotInToCsys(u, v, n);
tr.b = (tr.b).DotInToCsys(u, v, n);
tr.c = (tr.c).DotInToCsys(u, v, n);
n = tr.Normal().WithMagnitude(1);
// Triangles on edge don't contribute
if(fabs(n.z) < LENGTH_EPS) continue;
// The plane has equation p dot n = a dot n
double d = (tr.a).Dot(n);
// nx*x + ny*y + nz*z = d
// nz*z = d - nx*x - ny*y
double A = -n.x/n.z, B = -n.y/n.z, C = d/n.z;
double mac = tr.c.y/tr.c.x, mbc = (tr.c.y - tr.b.y)/tr.c.x;
double xc = tr.c.x, yb = tr.b.y;
// I asked Maple for
// int(int(A*x + B*y +C, y=mac*x..(mbc*x + yb)), x=0..xc);
double integral =
(1.0/3)*(
A*(mbc-mac)+
(1.0/2)*B*(mbc*mbc-mac*mac)
)*(xc*xc*xc)+
(1.0/2)*(A*yb+B*yb*mbc+C*(mbc-mac))*xc*xc+
C*yb*xc+
(1.0/2)*B*yb*yb*xc;
vol += integral;
}
Add ability to measure the area of a plane sketch, since that's easy and useful. Also make the volume measurement use Message(), and not a separate text window screen. And make Edit -> Unselect All (Esc) clear the marks drawn to indicate free parameters, since it clears all the other temporary stuff drawn in the graphics window. [git-p4: depot-paths = "//depot/solvespace/": change = 2121]
2010-03-01 17:23:57 +00:00
char msg[1024];
sprintf(msg, "The volume of the solid model is:\n\n"
" %.3f %s^3",
vol / pow(SS.MmPerUnit(), 3),
SS.UnitName());
if(SS.viewUnits == SolveSpace::UNIT_MM) {
sprintf(msg+strlen(msg), "\n %.2f mL", vol/(10*10*10));
}
strcpy(msg+strlen(msg),
"\n\nCurved surfaces have been approximated as triangles.\n"
"This introduces error, typically of around 1%.");
Message("%s", msg);
break;
}
case GraphicsWindow::MNU_AREA: {
Group *g = SK.GetGroup(SS.GW.activeGroup);
if(g->polyError.how != Group::POLY_GOOD) {
Error("This group does not contain a correctly-formed "
"2d closed area. It is open, not coplanar, or self-"
"intersecting.");
break;
}
SEdgeList sel;
ZERO(&sel);
g->polyLoops.MakeEdgesInto(&sel);
SPolygon sp;
ZERO(&sp);
sel.AssemblePolygon(&sp, NULL, true);
sp.normal = sp.ComputeNormal();
sp.FixContourDirections();
double area = sp.SignedArea();
double scale = SS.MmPerUnit();
Message("The area of the region sketched in this group is:\n\n"
" %.3f %s^2\n\n"
"Curves have been approximated as piecewise linear.\n"
"This introduces error, typically of around 1%%.",
area / (scale*scale),
SS.UnitName());
sel.Clear();
sp.Clear();
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
break;
Add code to evaluate the volume of a mesh, thanks to the divergence theorem; it's evaluated as a surface integral over each triangle. And don't regenerate the emphasized edges unless we have to; specifically, don't do it when the only dirty group is the drawing group. [git-p4: depot-paths = "//depot/solvespace/": change = 1849]
2008-02-07 09:53:52 +00:00
}
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
Add feature to find the degrees of freedom; strike the corresponding to each param from the Jacobian, and see if it loses rank. If it does then that one was important, so it's bound. Then display a big blue square around its point until the next normal solve. [git-p4: depot-paths = "//depot/solvespace/": change = 1887]
2009-01-04 12:01:46 +00:00
case GraphicsWindow::MNU_SHOW_DOF:
// This works like a normal solve, except that it calculates
// which variables are free/bound at the same time.
SS.GenerateAll(0, INT_MAX, true);
break;
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
case GraphicsWindow::MNU_TRACE_PT:
if(gs.points == 1 && gs.n == 1) {
SS.traced.point = gs.point[0];
SS.GW.ClearSelection();
} else {
Error("Bad selection for trace; select a single point.");
}
break;
case GraphicsWindow::MNU_STOP_TRACING: {
char exportFile[MAX_PATH] = "";
if(GetSaveFile(exportFile, CSV_EXT, CSV_PATTERN)) {
Add a simple license key: I take the CRC of the license info, plus some magic numbers. This would be trivial to break, but still more difficult than patching the binary to skip the check... [git-p4: depot-paths = "//depot/solvespace/": change = 1853]
2008-02-09 13:52:01 +00:00
FILE *f = fopen(exportFile, "wb");
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
if(f) {
int i;
SContour *sc = &(SS.traced.path);
for(i = 0; i < sc->l.n; i++) {
Vector p = sc->l.elem[i].p;
double s = SS.exportScale;
Add a simple license key: I take the CRC of the license info, plus some magic numbers. This would be trivial to break, but still more difficult than patching the binary to skip the check... [git-p4: depot-paths = "//depot/solvespace/": change = 1853]
2008-02-09 13:52:01 +00:00
fprintf(f, "%.10f, %.10f, %.10f\r\n",
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
p.x/s, p.y/s, p.z/s);
}
fclose(f);
} else {
Error("Couldn't write to '%s'", exportFile);
}
}
// Clear the trace, and stop tracing
SS.traced.point = Entity::NO_ENTITY;
SS.traced.path.l.Clear();
InvalidateGraphics();
break;
}
default: oops();
}
}
Add a simple license key: I take the CRC of the license info, plus some magic numbers. This would be trivial to break, but still more difficult than patching the binary to skip the check... [git-p4: depot-paths = "//depot/solvespace/": change = 1853]
2008-02-09 13:52:01 +00:00
void SolveSpace::MenuHelp(int id) {
switch(id) {
case GraphicsWindow::MNU_WEBSITE:
Add option to disable the "not closed contour" warnings and such, instead of tying that to whether the shaded model is shown. And rewrite all URLs to solvespace.com, not www.solvespace.com, and get rid of the nag screen that I just added because opening the website with ShellExecute seems to freeze a bit on startup. [git-p4: depot-paths = "//depot/solvespace/": change = 2044]
2009-10-01 10:35:11 +00:00
OpenWebsite("http://solvespace.com/helpmenu");
Add a simple license key: I take the CRC of the license info, plus some magic numbers. This would be trivial to break, but still more difficult than patching the binary to skip the check... [git-p4: depot-paths = "//depot/solvespace/": change = 1853]
2008-02-09 13:52:01 +00:00
break;
case GraphicsWindow::MNU_ABOUT:
Update Help -> About to note that license is GPLv3.
2013-09-22 10:50:59 +00:00
Message(
Initial Autotools and FLTK support With this commit, SolveSpace gains an Autotools build system and a new platform-dependent backend implemented using the FLTK GUI toolkit. These will allow the application to be built and run on Linux and other Unix-like operating systems, and prospectively, MacOS X. A number of new files have been added: * Makefile.am: Automake makefile template; this contains some experimental support for MinGW and MSVC++ builds that needs further development * ac-aux/ax_fltk.m4: Autoconf M4 macro to locate and query the system's installation of FLTK; this will eventually be contributed to the GNU Autoconf Archive * autogen.sh: Script to bootstrap the Autotools build system, usually for a tree just checked out from source control * configure.ac: Source for the Autoconf configure script; note that this file specifies a version of 2.1, near the top * fltk/fltkmain.cpp: Main FLTK backend implementation * fltk/fltkutil.cpp: Utility functions for the FLTK backend * fltk/xFl_Gl_Window_Group.{H,cxx}: Implementation of a new Fl_Gl_Window_Group widget for FLTK, needed to facilitate drawing FLTK widgets on top of OpenGL graphics as SolveSpace does. This has been submitted to the FLTK project for (hopefully) eventual upstream inclusion: http://www.fltk.org/str.php?L2992 The following minor changes are also a part of this commit: * Makefile.msvc: Define PACKAGE_VERSION=2.1 for the benefit of solvespace.cpp in MSVC++ builds * solvespace.cpp: In the About dialog text, use PACKAGE_VERSION rather than hard-coding the version of the program * solvespace.h: Don't define the C99 integer types if HAVE_C99_INTEGER_TYPES is defined, to facilitate MinGW builds
2013-10-28 05:28:42 +00:00
"This is SolveSpace version " PACKAGE_VERSION ".\n"
Update Help -> About to note that license is GPLv3.
2013-09-22 10:50:59 +00:00
"\n"
"Built " __TIME__ " " __DATE__ ".\n"
"\n"
"For more information, see http://solvespace.com/\n"
"\n"
"SolveSpace is free software: you are free to modify\n"
"and/or redistribute it under the terms of the GNU\n"
"General Public License (GPL) version 3 or later.\n"
"\n"
"There is NO WARRANTY, to the extent permitted by\n"
"law. For details, visit http://gnu.org/licenses/\n"
"\n"
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
"\xa9 2008-2013 Jonathan Westhues and other authors.\n"
Update Help -> About to note that license is GPLv3.
2013-09-22 10:50:59 +00:00
);
Add a simple license key: I take the CRC of the license info, plus some magic numbers. This would be trivial to break, but still more difficult than patching the binary to skip the check... [git-p4: depot-paths = "//depot/solvespace/": change = 1853]
2008-02-09 13:52:01 +00:00
break;
default: oops();
}
}
Enabled freeing of (most) allocated memory on program exit The Valgrind tool can give a full accounting of what memory allocations have yet to be free()d when the program exits. It is easier to find actual memory leaks in the code if all non-leaked allocations are elided from that accounting, which is most easily accomplished by free()ing them. The "most" qualifier is there because some allocations are difficult/ impossible to free, as they are internal to libraries like OpenGL and Xft. The best we can hope for is to cover all allocations made by SolveSpace directly.
2013-09-19 04:33:12 +00:00
void SolveSpace::Clear(void) {
sys.Clear();
for(int i = 0; i < MAX_UNDO; i++) {
if(i < undo.cnt) undo.d[i].Clear();
if(i < redo.cnt) redo.d[i].Clear();
}
}
void Sketch::Clear(void) {
group.Clear();
constraint.Clear();
request.Clear();
style.Clear();
entity.Clear();
param.Clear();
}