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

898 lines
27 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
//-----------------------------------------------------------------------------
// Declarations relating to our user interface, in both the graphics and
// text browser window.
//
// 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
#ifndef __UI_H
#define __UI_H
Implement a gettext .po file parser.
2017-01-04 15:39:27 +00:00
class Locale {
public:
std::string language;
std::string region;
uint16_t lcid;
std::string displayName;
std::string Culture() const {
return language + "-" + region;
}
};
struct LocaleLess {
Internationalize the main menu.
2017-01-05 10:39:08 +00:00
bool operator()(const Locale &a, const Locale &b) const {
Implement a gettext .po file parser.
2017-01-04 15:39:27 +00:00
return a.language < b.language ||
(a.language == b.language && a.region < b.region);
}
};
const std::set<Locale, LocaleLess> &Locales();
bool SetLocale(const std::string &name);
bool SetLocale(uint16_t lcid);
const std::string &Translate(const char *msgid);
Internationalize all messages without substitutions.
2017-01-07 06:41:13 +00:00
const std::string &Translate(const char *msgctxt, const char *msgid);
Implement a gettext .po file parser.
2017-01-04 15:39:27 +00:00
const std::string &TranslatePlural(const char *msgid, unsigned n);
Internationalize all messages without substitutions.
2017-01-07 06:41:13 +00:00
const std::string &TranslatePlural(const char *msgctxt, const char *msgid, unsigned n);
Implement a gettext .po file parser.
2017-01-04 15:39:27 +00:00
Internationalize all messages without substitutions.
2017-01-07 06:41:13 +00:00
inline const char *N_(const char *msgid) {
return msgid;
}
inline const char *CN_(const char *msgctxt, const char *msgid) {
return msgid;
}
#if defined(LIBRARY)
inline const char *_(const char *msgid) {
return msgid;
}
inline const char *C_(const char *msgctxt, const char *msgid) {
return msgid;
}
#else
inline const char *_(const char *msgid) {
return Translate(msgid).c_str();
}
inline const char *C_(const char *msgctxt, const char *msgid) {
return Translate(msgctxt, msgid).c_str();
}
#endif
Implement a gettext .po file parser.
2017-01-04 15:39:27 +00:00
Internationalize platform-specific code.
2017-01-11 02:44:29 +00:00
// Filters for the file formats that we support.
struct FileFilter {
const char *name;
const char *patterns[3];
};
// SolveSpace native file format
const FileFilter SlvsFileFilter[] = {
{ N_("SolveSpace models"), { "slvs" } },
{ NULL, {} }
};
// PNG format bitmap
Implement an image request.
2016-11-29 16:49:20 +00:00
const FileFilter RasterFileFilter[] = {
Internationalize platform-specific code.
2017-01-11 02:44:29 +00:00
{ N_("PNG file"), { "png" } },
{ NULL, {} }
};
// Triangle mesh
const FileFilter MeshFileFilter[] = {
{ N_("STL mesh"), { "stl" } },
{ N_("Wavefront OBJ mesh"), { "obj" } },
{ N_("Three.js-compatible mesh, with viewer"), { "html" } },
{ N_("Three.js-compatible mesh, mesh only"), { "js" } },
{ NULL, {} }
};
// NURBS surfaces
const FileFilter SurfaceFileFilter[] = {
{ N_("STEP file"), { "step", "stp" } },
{ NULL, {} }
};
// 2d vector (lines and curves) format
const FileFilter VectorFileFilter[] = {
{ N_("PDF file"), { "pdf" } },
{ N_("Encapsulated PostScript"), { "eps", "ps" } },
{ N_("Scalable Vector Graphics"), { "svg" } },
{ N_("STEP file"), { "step", "stp" } },
{ N_("DXF file (AutoCAD 2007)"), { "dxf" } },
{ N_("HPGL file"), { "plt", "hpgl" } },
{ N_("G Code"), { "ngc", "txt" } },
{ NULL, {} }
};
// 3d vector (wireframe lines and curves) format
const FileFilter Vector3dFileFilter[] = {
{ N_("STEP file"), { "step", "stp" } },
{ N_("DXF file (AutoCAD 2007)"), { "dxf" } },
{ NULL, {} }
};
// All Importable formats
const FileFilter ImportableFileFilter[] = {
{ N_("AutoCAD DXF and DWG files"), { "dxf", "dwg" } },
{ NULL, {} }
};
// Comma-separated value, like a spreadsheet would use
const FileFilter CsvFileFilter[] = {
{ N_("Comma-separated values"), { "csv" } },
{ NULL, {} }
};
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
// This table describes the top-level menus in the graphics winodw.
enum class Command : uint32_t {
NONE = 0,
// File
NEW = 100,
OPEN,
OPEN_RECENT,
SAVE,
SAVE_AS,
EXPORT_PNG,
EXPORT_MESH,
EXPORT_SURFACES,
EXPORT_VIEW,
EXPORT_SECTION,
EXPORT_WIREFRAME,
IMPORT,
EXIT,
// View
ZOOM_IN,
ZOOM_OUT,
ZOOM_TO_FIT,
SHOW_GRID,
PERSPECTIVE_PROJ,
ONTO_WORKPLANE,
NEAREST_ORTHO,
NEAREST_ISO,
CENTER_VIEW,
SHOW_TOOLBAR,
SHOW_TEXT_WND,
UNITS_INCHES,
UNITS_MM,
FULL_SCREEN,
// Edit
UNDO,
REDO,
CUT,
COPY,
PASTE,
PASTE_TRANSFORM,
DELETE,
SELECT_CHAIN,
SELECT_ALL,
SNAP_TO_GRID,
ROTATE_90,
UNSELECT_ALL,
REGEN_ALL,
// Request
SEL_WORKPLANE,
FREE_IN_3D,
DATUM_POINT,
WORKPLANE,
LINE_SEGMENT,
CONSTR_SEGMENT,
CIRCLE,
ARC,
RECTANGLE,
CUBIC,
TTF_TEXT,
Implement an image request.
2016-11-29 16:49:20 +00:00
IMAGE,
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
SPLIT_CURVES,
TANGENT_ARC,
CONSTRUCTION,
// Group
GROUP_3D,
GROUP_WRKPL,
GROUP_EXTRUDE,
GROUP_LATHE,
GROUP_ROT,
GROUP_TRANS,
GROUP_LINK,
GROUP_RECENT,
// Constrain
DISTANCE_DIA,
REF_DISTANCE,
ANGLE,
REF_ANGLE,
OTHER_ANGLE,
REFERENCE,
EQUAL,
RATIO,
DIFFERENCE,
ON_ENTITY,
SYMMETRIC,
AT_MIDPOINT,
HORIZONTAL,
VERTICAL,
PARALLEL,
PERPENDICULAR,
ORIENTED_SAME,
WHERE_DRAGGED,
COMMENT,
// Analyze
VOLUME,
AREA,
Implement Analyze → Measure Perimeter.
2016-08-01 13:18:58 +00:00
PERIMETER,
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
INTERFERENCE,
NAKED_EDGES,
SHOW_DOF,
Add a command to show center of mass, assuming uniform density.
2017-01-17 16:57:27 +00:00
CENTER_OF_MASS,
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
TRACE_PT,
STOP_TRACING,
STEP_DIM,
// Help
WEBSITE,
ABOUT,
// Recent
RECENT_OPEN = 0xf000,
RECENT_LINK = 0xf100,
Internationalize the main menu.
2017-01-05 10:39:08 +00:00
// Locale
LOCALE = 0xf200,
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
};
enum class ContextCommand : uint32_t {
Remove exact numeric values from ContextCommand. They carry no meaning, except for FIRST_STYLE.
2016-10-09 22:08:22 +00:00
CANCELLED,
SUBMENU,
SEPARATOR,
UNSELECT_ALL,
UNSELECT_HOVERED,
CUT_SEL,
COPY_SEL,
PASTE,
PASTE_XFRM,
DELETE_SEL,
SELECT_CHAIN,
NEW_CUSTOM_STYLE,
NO_STYLE,
GROUP_INFO,
STYLE_INFO,
REFERENCE_DIM,
OTHER_ANGLE,
DEL_COINCIDENT,
SNAP_TO_GRID,
REMOVE_SPLINE_PT,
ADD_SPLINE_PT,
Add "Toggle Construction" to context menu.
2016-10-09 22:13:01 +00:00
CONSTRUCTION,
Add "Zoom to Fit" to context menu.
2016-10-09 22:26:36 +00:00
ZOOM_TO_FIT,
Add "Select All" to context menu for no selection.
2016-10-09 22:26:25 +00:00
SELECT_ALL,
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
FIRST_STYLE = 0x40000000
};
Refactor text window buttons to allow for more custom behavior.
2016-08-13 06:46:54 +00:00
class Button;
Add hyperlink and colour support to the text window. Don't redraw the text window every time we refresh the graphics window, because that's slow. Use classes instead of structs for everything; I don't understand the template handling for structs. And implement the IdList, which I will try to use in many places. [git-p4: depot-paths = "//depot/solvespace/": change = 1655]
2008-03-28 10:00:37 +00:00
class TextWindow {
public:
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-09 19:50:32 +00:00
enum {
MAX_COLS = 100,
MIN_COLS = 45,
MAX_ROWS = 2000
};
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
Add hyperlink and colour support to the text window. Don't redraw the text window every time we refresh the graphics window, because that's slow. Use classes instead of structs for everything; I don't understand the template handling for structs. And implement the IdList, which I will try to use in many places. [git-p4: depot-paths = "//depot/solvespace/": change = 1655]
2008-03-28 10:00:37 +00:00
typedef struct {
Rename RgbColor to RgbaColor.
2015-07-10 11:54:39 +00:00
char c;
RgbaColor color;
Add hyperlink and colour support to the text window. Don't redraw the text window every time we refresh the graphics window, because that's slow. Use classes instead of structs for everything; I don't understand the template handling for structs. And implement the IdList, which I will try to use in many places. [git-p4: depot-paths = "//depot/solvespace/": change = 1655]
2008-03-28 10:00:37 +00:00
} Color;
Tear apart the text window, mostly to beautify things. The foreground and background colours are now specified separately, and it's possible to insert half-line spaces. So now I have a window that lets me show/hide groups, and select the active one. [git-p4: depot-paths = "//depot/solvespace/": change = 1695]
2008-04-28 07:18:39 +00:00
static const Color fgColors[];
static const Color bgColors[];
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
Initial work to move text window guts into platform-independent code. This is now drawn using gl, and the bitmap font (both there and in the graphics window) is drawn from a texture from a static table, not from the Win32 functions, since that's ~1000x faster. So this adds a tool to generate that table. With luck that will also fix my font issues under WINE, which won't have to render the TTF itself. Still needs some cleanup, and to make all the cosmetic improvements that I want. [git-p4: depot-paths = "//depot/solvespace/": change = 2130]
2010-04-26 07:52:49 +00:00
float bgColorTable[256*3];
float fgColorTable[256*3];
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-09 19:50:32 +00:00
enum {
Rename TextWindow::CHAR_WIDTH to CHAR_WIDTH_. glibc defines a CHAR_WIDTH macro in limits.h since about 6.3.*. This is apparently added as a part of ISO TS 18661-1:2014, which I cannot read because it is not publicly available, and which covers some sort of floating-point extensions. This is one of those changes that should never have been done yet here we are.
2017-04-06 06:54:07 +00:00
CHAR_WIDTH_ = 9,
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-09 19:50:32 +00:00
CHAR_HEIGHT = 16,
LINE_HEIGHT = 20,
LEFT_MARGIN = 6,
};
Add special characters to font, to represent checkboxes and radio buttons. This requires some tools to convert .png images to that, and that I put the characters in a two-dimensional grid in the texture (since one-dimensional strip gets wider than the hardware supports). [git-p4: depot-paths = "//depot/solvespace/": change = 2138]
2010-05-09 01:20:02 +00:00
Rasterize non-ASCII glyphs in the UI. Now it is possible to give non-ASCII names to groups as well as see non-ASCII filenames of imported files. In the future this makes localization possible. This works for LTR languages, such as European and CJK, but not RTL such as Arabic. Does Arabic even exist in monospaced form? I have no idea.
2015-11-05 19:39:27 +00:00
#define CHECK_FALSE "\xEE\x80\x80" // U+E000
#define CHECK_TRUE "\xEE\x80\x81"
#define RADIO_FALSE "\xEE\x80\x82"
#define RADIO_TRUE "\xEE\x80\x83"
Initial work to move text window guts into platform-independent code. This is now drawn using gl, and the bitmap font (both there and in the graphics window) is drawn from a texture from a static table, not from the Win32 functions, since that's ~1000x faster. So this adds a tool to generate that table. With luck that will also fix my font issues under WINE, which won't have to render the TTF itself. Still needs some cleanup, and to make all the cosmetic improvements that I want. [git-p4: depot-paths = "//depot/solvespace/": change = 2130]
2010-04-26 07:52:49 +00:00
int scrollPos; // The scrollbar position, in half-row units
int halfRows; // The height of our window, in half-row units
Rasterize non-ASCII glyphs in the UI. Now it is possible to give non-ASCII names to groups as well as see non-ASCII filenames of imported files. In the future this makes localization possible. This works for LTR languages, such as European and CJK, but not RTL such as Arabic. Does Arabic even exist in monospaced form? I have no idea.
2015-11-05 19:39:27 +00:00
uint32_t text[MAX_ROWS][MAX_COLS];
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
typedef void LinkFunction(int link, uint32_t v);
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-09 19:50:32 +00:00
enum { NOT_A_LINK = 0 };
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
struct {
Tear apart the text window, mostly to beautify things. The foreground and background colours are now specified separately, and it's possible to insert half-line spaces. So now I have a window that lets me show/hide groups, and select the active one. [git-p4: depot-paths = "//depot/solvespace/": change = 1695]
2008-04-28 07:18:39 +00:00
char fg;
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
char bg;
Rename RgbColor to RgbaColor.
2015-07-10 11:54:39 +00:00
RgbaColor bgRgb;
Add hyperlink and colour support to the text window. Don't redraw the text window every time we refresh the graphics window, because that's slow. Use classes instead of structs for everything; I don't understand the template handling for structs. And implement the IdList, which I will try to use in many places. [git-p4: depot-paths = "//depot/solvespace/": change = 1655]
2008-03-28 10:00:37 +00:00
int link;
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
uint32_t data;
Add hyperlink and colour support to the text window. Don't redraw the text window every time we refresh the graphics window, because that's slow. Use classes instead of structs for everything; I don't understand the template handling for structs. And implement the IdList, which I will try to use in many places. [git-p4: depot-paths = "//depot/solvespace/": change = 1655]
2008-03-28 10:00:37 +00:00
LinkFunction *f;
Many user interface additions. Now I report when the solver fails, and in the case of a singular Jacobian, report which constraints can be removed to fix it. Also a mechanism to hover and select entities and constraints from the text window. [git-p4: depot-paths = "//depot/solvespace/": change = 1746]
2008-05-26 09:56:50 +00:00
LinkFunction *h;
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
} meta[MAX_ROWS][MAX_COLS];
Replace ugly text links to hide/show things with icons. So add code to draw those, and hit test with the mouse, and display tool tips when the user hovers with the mouse. Also, underline links only when they're hovered, and not otherwise. And add a separate menu option to align the view to the active workplane, vs. activating the active group's workplane, and remap the bottom two graphics window toolbar icons to that and "nearest iso view" instead of draw in 2d/3d, since people tended to click on those without understanding and cause trouble. And by default, we force a parallel projection; so the factory default camera tangent is now 0.3, not 0. [git-p4: depot-paths = "//depot/solvespace/": change = 2131]
2010-05-03 05:04:42 +00:00
int hoveredRow, hoveredCol;
int top[MAX_ROWS]; // in half-line units, or -1 for unused
Simplify the text window in SolveSpace; better scrolling behaviour, and my concept is more like a web page than like a command line. [git-p4: depot-paths = "//depot/solvespace/": change = 1659]
2008-04-09 09:35:09 +00:00
int rows;
Initial work to move text window guts into platform-independent code. This is now drawn using gl, and the bitmap font (both there and in the graphics window) is drawn from a texture from a static table, not from the Win32 functions, since that's ~1000x faster. So this adds a tool to generate that table. With luck that will also fix my font issues under WINE, which won't have to render the TTF itself. Still needs some cleanup, and to make all the cosmetic improvements that I want. [git-p4: depot-paths = "//depot/solvespace/": change = 2130]
2010-04-26 07:52:49 +00:00
Hide OpenGL implementation details. Abstract the exact details of the OpenGL renderer in the render.h header; this allows us to use GL-specific types in the renderer class and functions without including OpenGL (and Windows, where applicable) headers in every source file.
2016-06-28 08:48:06 +00:00
std::shared_ptr<ViewportCanvas> canvas;
Abstract all (ex-OpenGL) drawing operations into a Canvas interface. This has several desirable consequences: * It is now possible to port SolveSpace to a later version of OpenGL, such as OpenGLES 2, so that it runs on platforms that only have that OpenGL version; * The majority of geometry is now rendered without references to the camera in C++ code, so a renderer can now submit it to the video card once and re-rasterize with a different projection matrix every time the projection is changed, avoiding expensive reuploads; * The DOGD (draw or get distance) interface is now a straightforward Canvas implementation; * There are no more direct references to SS.GW.(projection) in sketch rendering code, which allows rendering to multiple viewports; * There are no more unnecessary framebuffer flips on CPU on Cocoa and GTK; * The platform-dependent GL code is now confined to rendergl1.cpp. * The Microsoft and Apple headers required by it that are prone to identifier conflicts are no longer included globally; * The rendergl1.cpp implementation can now be omitted from compilation to run SolveSpace headless or with a different OpenGL version. Note these implementation details of Canvas: * GetCamera currently always returns a reference to the field `Camera camera;`. This is so that a future renderer that caches geometry in the video memory can define it as asserting, which would provide assurance against code that could accidentally put something projection-dependent in the cache; * Line and triangle rendering is specified through a level of indirection, hStroke and hFill. This is so that a future renderer that batches geometry could cheaply group identical styles. * DrawPixmap and DrawVectorText accept a (o,u,v) and not a matrix. This is so that a future renderer into an output format that uses 2d transforms (e.g. SVG) could easily derive those. Some additional internal changes were required to enable this: * Pixmap is now always passed as std::shared_ptr<{const ,}Pixmap>. This is so that the renderer could cache uploaded textures between API calls, which requires it to capture a (weak) reference. * The PlatformPathEqual function was properly extracted into platform-specific code. This is so that the <windows.h> header could be included only where needed (in platform/w32* as well as rendergl1.cpp). * The SBsp{2,3}::DebugDraw functions were removed. They can be rewritten using the Canvas API if they are ever needed. While no visual changes were originally intended, some minor fixes happened anyway: * The "emphasis" yellow line from top-left corner is now correctly rendered much wider. * The marquee rectangle is now pixel grid aligned. * The hidden entities now do not clobber the depth buffer, removing some minor artifacts. * The workplane "tab" now scales with the font used to render the workplane name. * The workplane name font is now taken from the normals style. * Workplane and constraint line stipple is insignificantly different. This is so that it can reuse the existing stipple codepaths; rendering of workplanes and constraints predates those. Some debug functionality was added: * In graphics window, an fps counter that becomes red when rendering under 60fps is drawn.
2016-05-31 00:55:13 +00:00
void Draw(Canvas *canvas);
Initial work to move text window guts into platform-independent code. This is now drawn using gl, and the bitmap font (both there and in the graphics window) is drawn from a texture from a static table, not from the Win32 functions, since that's ~1000x faster. So this adds a tool to generate that table. With luck that will also fix my font issues under WINE, which won't have to render the TTF itself. Still needs some cleanup, and to make all the cosmetic improvements that I want. [git-p4: depot-paths = "//depot/solvespace/": change = 2130]
2010-04-26 07:52:49 +00:00
// These are called by the platform-specific code.
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void Paint();
Add a color picker, with a fancy HSV (actually, a modified version of that, where you can pick the hue and blackness, and then the whiteness) color picker and some swatches. This is used in three places now: the special colors in the config screen, the background color, and the style colors. [git-p4: depot-paths = "//depot/solvespace/": change = 2174]
2010-07-21 05:04:03 +00:00
void MouseEvent(bool isClick, bool leftDown, double x, double y);
Initial work to move text window guts into platform-independent code. This is now drawn using gl, and the bitmap font (both there and in the graphics window) is drawn from a texture from a static table, not from the Win32 functions, since that's ~1000x faster. So this adds a tool to generate that table. With luck that will also fix my font issues under WINE, which won't have to render the TTF itself. Still needs some cleanup, and to make all the cosmetic improvements that I want. [git-p4: depot-paths = "//depot/solvespace/": change = 2130]
2010-04-26 07:52:49 +00:00
void MouseScroll(double x, double y, int delta);
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void MouseLeave();
Initial work to move text window guts into platform-independent code. This is now drawn using gl, and the bitmap font (both there and in the graphics window) is drawn from a texture from a static table, not from the Win32 functions, since that's ~1000x faster. So this adds a tool to generate that table. With luck that will also fix my font issues under WINE, which won't have to render the TTF itself. Still needs some cleanup, and to make all the cosmetic improvements that I want. [git-p4: depot-paths = "//depot/solvespace/": change = 2130]
2010-04-26 07:52:49 +00:00
void ScrollbarEvent(int newPos);
Replace ugly text links to hide/show things with icons. So add code to draw those, and hit test with the mouse, and display tool tips when the user hovers with the mouse. Also, underline links only when they're hovered, and not otherwise. And add a separate menu option to align the view to the active workplane, vs. activating the active group's workplane, and remap the bottom two graphics window toolbar icons to that and "nearest iso view" instead of draw in 2d/3d, since people tended to click on those without understanding and cause trouble. And by default, we force a parallel projection; so the factory default camera tangent is now 0.3, not 0. [git-p4: depot-paths = "//depot/solvespace/": change = 2131]
2010-05-03 05:04:42 +00:00
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
enum DrawOrHitHow : uint32_t {
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-09 19:50:32 +00:00
PAINT = 0,
HOVER = 1,
CLICK = 2
};
Abstract all (ex-OpenGL) drawing operations into a Canvas interface. This has several desirable consequences: * It is now possible to port SolveSpace to a later version of OpenGL, such as OpenGLES 2, so that it runs on platforms that only have that OpenGL version; * The majority of geometry is now rendered without references to the camera in C++ code, so a renderer can now submit it to the video card once and re-rasterize with a different projection matrix every time the projection is changed, avoiding expensive reuploads; * The DOGD (draw or get distance) interface is now a straightforward Canvas implementation; * There are no more direct references to SS.GW.(projection) in sketch rendering code, which allows rendering to multiple viewports; * There are no more unnecessary framebuffer flips on CPU on Cocoa and GTK; * The platform-dependent GL code is now confined to rendergl1.cpp. * The Microsoft and Apple headers required by it that are prone to identifier conflicts are no longer included globally; * The rendergl1.cpp implementation can now be omitted from compilation to run SolveSpace headless or with a different OpenGL version. Note these implementation details of Canvas: * GetCamera currently always returns a reference to the field `Camera camera;`. This is so that a future renderer that caches geometry in the video memory can define it as asserting, which would provide assurance against code that could accidentally put something projection-dependent in the cache; * Line and triangle rendering is specified through a level of indirection, hStroke and hFill. This is so that a future renderer that batches geometry could cheaply group identical styles. * DrawPixmap and DrawVectorText accept a (o,u,v) and not a matrix. This is so that a future renderer into an output format that uses 2d transforms (e.g. SVG) could easily derive those. Some additional internal changes were required to enable this: * Pixmap is now always passed as std::shared_ptr<{const ,}Pixmap>. This is so that the renderer could cache uploaded textures between API calls, which requires it to capture a (weak) reference. * The PlatformPathEqual function was properly extracted into platform-specific code. This is so that the <windows.h> header could be included only where needed (in platform/w32* as well as rendergl1.cpp). * The SBsp{2,3}::DebugDraw functions were removed. They can be rewritten using the Canvas API if they are ever needed. While no visual changes were originally intended, some minor fixes happened anyway: * The "emphasis" yellow line from top-left corner is now correctly rendered much wider. * The marquee rectangle is now pixel grid aligned. * The hidden entities now do not clobber the depth buffer, removing some minor artifacts. * The workplane "tab" now scales with the font used to render the workplane name. * The workplane name font is now taken from the normals style. * Workplane and constraint line stipple is insignificantly different. This is so that it can reuse the existing stipple codepaths; rendering of workplanes and constraints predates those. Some debug functionality was added: * In graphics window, an fps counter that becomes red when rendering under 60fps is drawn.
2016-05-31 00:55:13 +00:00
void DrawOrHitTestIcons(UiCanvas *canvas, DrawOrHitHow how,
double mx, double my);
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void TimerCallback();
Replace ugly text links to hide/show things with icons. So add code to draw those, and hit test with the mouse, and display tool tips when the user hovers with the mouse. Also, underline links only when they're hovered, and not otherwise. And add a separate menu option to align the view to the active workplane, vs. activating the active group's workplane, and remap the bottom two graphics window toolbar icons to that and "nearest iso view" instead of draw in 2d/3d, since people tended to click on those without understanding and cause trouble. And by default, we force a parallel projection; so the factory default camera tangent is now 0.3, not 0. [git-p4: depot-paths = "//depot/solvespace/": change = 2131]
2010-05-03 05:04:42 +00:00
Point2d oldMousePos;
Refactor text window buttons to allow for more custom behavior.
2016-08-13 06:46:54 +00:00
Button *hoveredButton, *tooltippedButton;
Add a color picker, with a fancy HSV (actually, a modified version of that, where you can pick the hue and blackness, and then the whiteness) color picker and some swatches. This is used in three places now: the special colors in the config screen, the background color, and the style colors. [git-p4: depot-paths = "//depot/solvespace/": change = 2174]
2010-07-21 05:04:03 +00:00
Vector HsvToRgb(Vector hsv);
Abstract all (ex-OpenGL) drawing operations into a Canvas interface. This has several desirable consequences: * It is now possible to port SolveSpace to a later version of OpenGL, such as OpenGLES 2, so that it runs on platforms that only have that OpenGL version; * The majority of geometry is now rendered without references to the camera in C++ code, so a renderer can now submit it to the video card once and re-rasterize with a different projection matrix every time the projection is changed, avoiding expensive reuploads; * The DOGD (draw or get distance) interface is now a straightforward Canvas implementation; * There are no more direct references to SS.GW.(projection) in sketch rendering code, which allows rendering to multiple viewports; * There are no more unnecessary framebuffer flips on CPU on Cocoa and GTK; * The platform-dependent GL code is now confined to rendergl1.cpp. * The Microsoft and Apple headers required by it that are prone to identifier conflicts are no longer included globally; * The rendergl1.cpp implementation can now be omitted from compilation to run SolveSpace headless or with a different OpenGL version. Note these implementation details of Canvas: * GetCamera currently always returns a reference to the field `Camera camera;`. This is so that a future renderer that caches geometry in the video memory can define it as asserting, which would provide assurance against code that could accidentally put something projection-dependent in the cache; * Line and triangle rendering is specified through a level of indirection, hStroke and hFill. This is so that a future renderer that batches geometry could cheaply group identical styles. * DrawPixmap and DrawVectorText accept a (o,u,v) and not a matrix. This is so that a future renderer into an output format that uses 2d transforms (e.g. SVG) could easily derive those. Some additional internal changes were required to enable this: * Pixmap is now always passed as std::shared_ptr<{const ,}Pixmap>. This is so that the renderer could cache uploaded textures between API calls, which requires it to capture a (weak) reference. * The PlatformPathEqual function was properly extracted into platform-specific code. This is so that the <windows.h> header could be included only where needed (in platform/w32* as well as rendergl1.cpp). * The SBsp{2,3}::DebugDraw functions were removed. They can be rewritten using the Canvas API if they are ever needed. While no visual changes were originally intended, some minor fixes happened anyway: * The "emphasis" yellow line from top-left corner is now correctly rendered much wider. * The marquee rectangle is now pixel grid aligned. * The hidden entities now do not clobber the depth buffer, removing some minor artifacts. * The workplane "tab" now scales with the font used to render the workplane name. * The workplane name font is now taken from the normals style. * Workplane and constraint line stipple is insignificantly different. This is so that it can reuse the existing stipple codepaths; rendering of workplanes and constraints predates those. Some debug functionality was added: * In graphics window, an fps counter that becomes red when rendering under 60fps is drawn.
2016-05-31 00:55:13 +00:00
std::shared_ptr<Pixmap> HsvPattern2d(int w, int h);
std::shared_ptr<Pixmap> HsvPattern1d(double hue, double sat, int w, int h);
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void ColorPickerDone();
Abstract all (ex-OpenGL) drawing operations into a Canvas interface. This has several desirable consequences: * It is now possible to port SolveSpace to a later version of OpenGL, such as OpenGLES 2, so that it runs on platforms that only have that OpenGL version; * The majority of geometry is now rendered without references to the camera in C++ code, so a renderer can now submit it to the video card once and re-rasterize with a different projection matrix every time the projection is changed, avoiding expensive reuploads; * The DOGD (draw or get distance) interface is now a straightforward Canvas implementation; * There are no more direct references to SS.GW.(projection) in sketch rendering code, which allows rendering to multiple viewports; * There are no more unnecessary framebuffer flips on CPU on Cocoa and GTK; * The platform-dependent GL code is now confined to rendergl1.cpp. * The Microsoft and Apple headers required by it that are prone to identifier conflicts are no longer included globally; * The rendergl1.cpp implementation can now be omitted from compilation to run SolveSpace headless or with a different OpenGL version. Note these implementation details of Canvas: * GetCamera currently always returns a reference to the field `Camera camera;`. This is so that a future renderer that caches geometry in the video memory can define it as asserting, which would provide assurance against code that could accidentally put something projection-dependent in the cache; * Line and triangle rendering is specified through a level of indirection, hStroke and hFill. This is so that a future renderer that batches geometry could cheaply group identical styles. * DrawPixmap and DrawVectorText accept a (o,u,v) and not a matrix. This is so that a future renderer into an output format that uses 2d transforms (e.g. SVG) could easily derive those. Some additional internal changes were required to enable this: * Pixmap is now always passed as std::shared_ptr<{const ,}Pixmap>. This is so that the renderer could cache uploaded textures between API calls, which requires it to capture a (weak) reference. * The PlatformPathEqual function was properly extracted into platform-specific code. This is so that the <windows.h> header could be included only where needed (in platform/w32* as well as rendergl1.cpp). * The SBsp{2,3}::DebugDraw functions were removed. They can be rewritten using the Canvas API if they are ever needed. While no visual changes were originally intended, some minor fixes happened anyway: * The "emphasis" yellow line from top-left corner is now correctly rendered much wider. * The marquee rectangle is now pixel grid aligned. * The hidden entities now do not clobber the depth buffer, removing some minor artifacts. * The workplane "tab" now scales with the font used to render the workplane name. * The workplane name font is now taken from the normals style. * Workplane and constraint line stipple is insignificantly different. This is so that it can reuse the existing stipple codepaths; rendering of workplanes and constraints predates those. Some debug functionality was added: * In graphics window, an fps counter that becomes red when rendering under 60fps is drawn.
2016-05-31 00:55:13 +00:00
bool DrawOrHitTestColorPicker(UiCanvas *canvas, DrawOrHitHow how,
bool leftDown, double x, double y);
Trim trailing whitespace.
2015-03-29 00:30:52 +00:00
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void Init();
Initial work to move text window guts into platform-independent code. This is now drawn using gl, and the bitmap font (both there and in the graphics window) is drawn from a texture from a static table, not from the Win32 functions, since that's ~1000x faster. So this adds a tool to generate that table. With luck that will also fix my font issues under WINE, which won't have to render the TTF itself. Still needs some cleanup, and to make all the cosmetic improvements that I want. [git-p4: depot-paths = "//depot/solvespace/": change = 2130]
2010-04-26 07:52:49 +00:00
void MakeColorTable(const Color *in, float *out);
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
void Printf(bool half, const char *fmt, ...);
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void ClearScreen();
Trim trailing whitespace.
2015-03-29 00:30:52 +00:00
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void Show();
Start to use that text window a bit; user interface to show and hide things. [git-p4: depot-paths = "//depot/solvespace/": change = 1661]
2008-04-11 12:47:14 +00:00
Get rid of the command line from the text window; we'll say that's just for display, and any text entry will happen via some floating text box, same as entering a dimension on the sketch. Add the hover and selection mechanism, which now seems to work. Still not clear how to do imported parts, for assemblies and hierarchy. The handle formats may still have to change. [git-p4: depot-paths = "//depot/solvespace/": change = 1662]
2008-04-12 14:12:26 +00:00
// State for the screen that we are showing in the text window.
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
enum class Screen : uint32_t {
LIST_OF_GROUPS = 0,
GROUP_INFO = 1,
GROUP_SOLVE_INFO = 2,
CONFIGURATION = 3,
STEP_DIMENSION = 4,
LIST_OF_STYLES = 5,
STYLE_INFO = 6,
PASTE_TRANSFORMED = 7,
EDIT_VIEW = 8,
TANGENT_ARC = 9
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-09 19:50:32 +00:00
};
Get rid of the command line from the text window; we'll say that's just for display, and any text entry will happen via some floating text box, same as entering a dimension on the sketch. Add the hover and selection mechanism, which now seems to work. Still not clear how to do imported parts, for assemblies and hierarchy. The handle formats may still have to change. [git-p4: depot-paths = "//depot/solvespace/": change = 1662]
2008-04-12 14:12:26 +00:00
typedef struct {
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
Screen screen;
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
Simplify the way that the active csys is handled, and default to locked on to the XY plane. And simplify the handling of colors in the text window: identify them by a character, not an integer ID, since the character is easier to remember. [git-p4: depot-paths = "//depot/solvespace/": change = 1687]
2008-04-25 08:26:15 +00:00
hGroup group;
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
hStyle style;
Add feature to trace a point; so I can show the path that a linkage traces out, and export the coordinates. [git-p4: depot-paths = "//depot/solvespace/": change = 1846]
2008-07-20 11:27:22 +00:00
hConstraint constraint;
bool dimIsDistance;
double dimFinish;
int dimSteps;
A big nasty change, originally just to add paste transformed. So it does that, and adds a scale factor to that transformation (instead of just mirroring, as before), but also: * Replace the "import mirrored" mechanism with a scale factor, which if negative corresponds to a reflection as well. * Fix self-intersection checker to report a meaningful point when edges are collinear. * Don't blow an assertion on some types of invalid file; instead provide a nice error message to the user. * Clear the naked edges before each regen. * Don't create zero-length line segments by snapping a line segment's end to its beginning. [git-p4: depot-paths = "//depot/solvespace/": change = 2086]
2009-12-15 12:26:22 +00:00
struct {
int times;
Vector trans;
double theta;
Vector origin;
double scale;
} paste;
Get rid of the command line from the text window; we'll say that's just for display, and any text entry will happen via some floating text box, same as entering a dimension on the sketch. Add the hover and selection mechanism, which now seems to work. Still not clear how to do imported parts, for assemblies and hierarchy. The handle formats may still have to change. [git-p4: depot-paths = "//depot/solvespace/": change = 1662]
2008-04-12 14:12:26 +00:00
} ShownState;
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
ShownState shown;
Get rid of the command line from the text window; we'll say that's just for display, and any text entry will happen via some floating text box, same as entering a dimension on the sketch. Add the hover and selection mechanism, which now seems to work. Still not clear how to do imported parts, for assemblies and hierarchy. The handle formats may still have to change. [git-p4: depot-paths = "//depot/solvespace/": change = 1662]
2008-04-12 14:12:26 +00:00
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
enum class Edit : uint32_t {
NOTHING = 0,
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-09 19:50:32 +00:00
// For multiple groups
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
TIMES_REPEATED = 1,
GROUP_NAME = 2,
GROUP_SCALE = 3,
GROUP_COLOR = 4,
GROUP_OPACITY = 5,
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-09 19:50:32 +00:00
// For the configuraiton screen
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
LIGHT_DIRECTION = 100,
LIGHT_INTENSITY = 101,
COLOR = 102,
CHORD_TOLERANCE = 103,
MAX_SEGMENTS = 104,
CAMERA_TANGENT = 105,
GRID_SPACING = 106,
DIGITS_AFTER_DECIMAL = 107,
EXPORT_SCALE = 108,
EXPORT_OFFSET = 109,
CANVAS_SIZE = 110,
G_CODE_DEPTH = 120,
G_CODE_PASSES = 121,
G_CODE_FEED = 122,
G_CODE_PLUNGE_FEED = 123,
AUTOSAVE_INTERVAL = 124,
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-09 19:50:32 +00:00
// For TTF text
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
TTF_TEXT = 300,
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-09 19:50:32 +00:00
// For the step dimension screen
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
STEP_DIM_FINISH = 400,
STEP_DIM_STEPS = 401,
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-09 19:50:32 +00:00
// For the styles stuff
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
STYLE_WIDTH = 500,
STYLE_TEXT_HEIGHT = 501,
STYLE_TEXT_ANGLE = 502,
STYLE_COLOR = 503,
STYLE_FILL_COLOR = 504,
STYLE_NAME = 505,
BACKGROUND_COLOR = 506,
STYLE_STIPPLE_PERIOD = 508,
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-09 19:50:32 +00:00
// For paste transforming
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
PASTE_TIMES_REPEATED = 600,
PASTE_ANGLE = 601,
PASTE_SCALE = 602,
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-09 19:50:32 +00:00
// For view
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
VIEW_SCALE = 700,
VIEW_ORIGIN = 701,
VIEW_PROJ_RIGHT = 702,
VIEW_PROJ_UP = 703,
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-09 19:50:32 +00:00
// For tangent arc
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
TANGENT_ARC_RADIUS = 800
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-09 19:50:32 +00:00
};
Add step and repeat translate, with multiple copies; that all works nicely. And to do that, I've added the user interface to show an edit control in the text window. [git-p4: depot-paths = "//depot/solvespace/": change = 1749]
2008-05-27 06:36:59 +00:00
struct {
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
bool showAgain;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
Edit meaning;
Add TrueType font support to SolveSpace. This uses a modified version of the code from SketchFlat, with all arbitrary limits removed. The TTF text is its own entity, and that entity includes the font file basename and the text. That's an extra 128 bytes in the entity, which is around a 50% increase, kind of a shame. It was simple, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1814]
2008-06-30 09:09:17 +00:00
int i;
hGroup group;
hRequest request;
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
hStyle style;
Add step and repeat translate, with multiple copies; that all works nicely. And to do that, I've added the user interface to show an edit control in the text window. [git-p4: depot-paths = "//depot/solvespace/": change = 1749]
2008-05-27 06:36:59 +00:00
} edit;
Many user interface additions. Now I report when the solver fails, and in the case of a singular Jacobian, report which constraints can be removed to fix it. Also a mechanism to hover and select entities and constraints from the text window. [git-p4: depot-paths = "//depot/solvespace/": change = 1746]
2008-05-26 09:56:50 +00:00
static void ReportHowGroupSolved(hGroup hg);
Put wrappers around the functions to show and hide the edit control in the text window. This means that I can move the conversion from half-row and column to (x, y) into the platform-independent code, and that I'll be ready to add my color picker. [git-p4: depot-paths = "//depot/solvespace/": change = 2171]
2010-07-12 07:51:12 +00:00
struct {
int halfRow;
int col;
Add a color picker, with a fancy HSV (actually, a modified version of that, where you can pick the hue and blackness, and then the whiteness) color picker and some swatches. This is used in three places now: the special colors in the config screen, the background color, and the style colors. [git-p4: depot-paths = "//depot/solvespace/": change = 2174]
2010-07-21 05:04:03 +00:00
struct {
Rename RgbColor to RgbaColor.
2015-07-10 11:54:39 +00:00
RgbaColor rgb;
double h, s, v;
bool show;
bool picker1dActive;
bool picker2dActive;
Add a color picker, with a fancy HSV (actually, a modified version of that, where you can pick the hue and blackness, and then the whiteness) color picker and some swatches. This is used in three places now: the special colors in the config screen, the background color, and the style colors. [git-p4: depot-paths = "//depot/solvespace/": change = 2174]
2010-07-21 05:04:03 +00:00
} colorPicker;
Put wrappers around the functions to show and hide the edit control in the text window. This means that I can move the conversion from half-row and column to (x, y) into the platform-independent code, and that I'll be ready to add my color picker. [git-p4: depot-paths = "//depot/solvespace/": change = 2171]
2010-07-12 07:51:12 +00:00
} editControl;
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void HideEditControl();
Don't calculate halfRow for ShowEditControl manually. Instead, grab it from hoveredRow, since almost always (with only one exception) this is where the edit control has to be shown. This makes it much easier to adjust views, e.g. add a new editable field in the middle of configuration view, because it's not necessary to manually change and test all the indexes below the row being changed. Additionally, it removes a lot of awkward and opaque row calculations.
2016-01-26 11:19:52 +00:00
void ShowEditControl(int col, const std::string &str, int halfRow = -1);
void ShowEditControlWithColorPicker(int col, RgbaColor rgb);
Put wrappers around the functions to show and hide the edit control in the text window. This means that I can move the conversion from half-row and column to (x, y) into the platform-independent code, and that I'll be ready to add my color picker. [git-p4: depot-paths = "//depot/solvespace/": change = 2171]
2010-07-12 07:51:12 +00:00
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void ClearSuper();
Start to describe the selected entities in the text window. Also more starting work on the selectable faces, and fiddling in an attempt to remove dependencies when stuff gets deleted. [git-p4: depot-paths = "//depot/solvespace/": change = 1760]
2008-06-01 00:26:41 +00:00
void ShowHeader(bool withNav);
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
// These are self-contained screens, that show some information about
// the sketch.
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void ShowListOfGroups();
void ShowGroupInfo();
void ShowGroupSolveInfo();
void ShowConfiguration();
void ShowListOfStyles();
void ShowStyleInfo();
void ShowStepDimension();
void ShowPasteTransformed();
void ShowEditView();
void ShowTangentArc();
Start to describe the selected entities in the text window. Also more starting work on the selectable faces, and fiddling in an attempt to remove dependencies when stuff gets deleted. [git-p4: depot-paths = "//depot/solvespace/": change = 1760]
2008-06-01 00:26:41 +00:00
// Special screen, based on selection
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void DescribeSelection();
Add functions to deep-copy Exprs, for those generated from user expressions that we wish to keep around. And make the 2d coordinate system (that causes points to generate 2 unknowns, not 3) an attribute of the request, not the group, and add user interface to change that. [git-p4: depot-paths = "//depot/solvespace/": change = 1670]
2008-04-18 07:06:37 +00:00
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
void GoToScreen(Screen screen);
Add step and repeat translate, with multiple copies; that all works nicely. And to do that, I've added the user interface to show an edit control in the text window. [git-p4: depot-paths = "//depot/solvespace/": change = 1749]
2008-05-27 06:36:59 +00:00
Add TrueType font support to SolveSpace. This uses a modified version of the code from SketchFlat, with all arbitrary limits removed. The TTF text is its own entity, and that entity includes the font file basename and the text. That's an extra 128 bytes in the entity, which is around a 50% increase, kind of a shame. It was simple, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1814]
2008-06-30 09:09:17 +00:00
// All of these are callbacks from the GUI code; first from when
// we're describing an entity
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
static void ScreenEditTtfText(int link, uint32_t v);
static void ScreenSetTtfFont(int link, uint32_t v);
static void ScreenUnselectAll(int link, uint32_t v);
Add TrueType font support to SolveSpace. This uses a modified version of the code from SketchFlat, with all arbitrary limits removed. The TTF text is its own entity, and that entity includes the font file basename and the text. That's an extra 128 bytes in the entity, which is around a 50% increase, kind of a shame. It was simple, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1814]
2008-06-30 09:09:17 +00:00
Allow displaying and editing diameter constraints as radius. The savefile format is not changed; the display option is stored in Constraint::other.
2015-03-22 13:07:49 +00:00
// when we're describing a constraint
static void ScreenConstraintShowAsRadius(int link, uint32_t v);
Add TrueType font support to SolveSpace. This uses a modified version of the code from SketchFlat, with all arbitrary limits removed. The TTF text is its own entity, and that entity includes the font file basename and the text. That's an extra 128 bytes in the entity, which is around a 50% increase, kind of a shame. It was simple, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1814]
2008-06-30 09:09:17 +00:00
// and the rest from the stuff in textscreens.cpp
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
static void ScreenSelectGroup(int link, uint32_t v);
static void ScreenActivateGroup(int link, uint32_t v);
static void ScreenToggleGroupShown(int link, uint32_t v);
static void ScreenHowGroupSolved(int link, uint32_t v);
static void ScreenShowGroupsSpecial(int link, uint32_t v);
static void ScreenDeleteGroup(int link, uint32_t v);
static void ScreenHoverConstraint(int link, uint32_t v);
static void ScreenHoverRequest(int link, uint32_t v);
static void ScreenSelectRequest(int link, uint32_t v);
static void ScreenSelectConstraint(int link, uint32_t v);
static void ScreenChangeGroupOption(int link, uint32_t v);
static void ScreenColor(int link, uint32_t v);
Add support for transparent solids. Some extra code is necessary to determine that the back faces should not be drawn in red for transparent solids. It is expected that the user will first ensure that the shell is watertight and then set the opacity; back faces are still drawn if the opacity is exactly 1. The savefile format is changed backwards-compatibly by stashing the alpha value in uppermost byte of 4-byte hex color value in Surface and Triangle clauses. The existing files have 00 in the high byte, so RgbColor::FromPackedInt treats that as "opaque".
2015-03-26 10:30:12 +00:00
static void ScreenOpacity(int link, uint32_t v);
Use C99 integer types and C++ boolean types/values This change comprehensively replaces the use of Microsoft-standard integer and boolean types with their C99/C++ standard equivalents, as the latter is more appropriate for a cross-platform application. With matter-of-course exceptions in the Win32-specific code, the types/values have been converted as follows: QWORD --> uint64_t SQWORD --> int64_t DWORD --> uint32_t SDWORD --> int32_t WORD --> uint16_t SWORD --> int16_t BYTE --> uint8_t BOOL --> bool TRUE --> true FALSE --> false The following related changes are also included: * Added C99 integer type definitions for Windows, as stdint.h is not available prior to Visual Studio 2010 * Changed types of some variables in the SolveSpace class from 'int' to 'bool', as they actually represent boolean settings * Implemented new Cnf{Freeze,Thaw}Bool() functions to support boolean variables in the Registry * Cnf{Freeze,Thaw}DWORD() are now Cnf{Freeze,Thaw}Int() * TtfFont::Get{WORD,DWORD}() are now TtfFont::Get{USHORT,ULONG}() (names inspired by the OpenType spec) * RGB colors are packed into an integer of type uint32_t (nee DWORD), but in a few places, these were represented by an int; these have been corrected to uint32_t
2013-10-02 05:45:13 +00:00
static void ScreenShowListOfStyles(int link, uint32_t v);
static void ScreenShowStyleInfo(int link, uint32_t v);
static void ScreenDeleteStyle(int link, uint32_t v);
Implement stippled line styles from ISO 128. Now it's possible to use a styled line to indicate e.g. a centerline.
2016-02-23 18:00:39 +00:00
static void ScreenChangeStylePatternType(int link, uint32_t v);
Use C99 integer types and C++ boolean types/values This change comprehensively replaces the use of Microsoft-standard integer and boolean types with their C99/C++ standard equivalents, as the latter is more appropriate for a cross-platform application. With matter-of-course exceptions in the Win32-specific code, the types/values have been converted as follows: QWORD --> uint64_t SQWORD --> int64_t DWORD --> uint32_t SDWORD --> int32_t WORD --> uint16_t SWORD --> int16_t BYTE --> uint8_t BOOL --> bool TRUE --> true FALSE --> false The following related changes are also included: * Added C99 integer type definitions for Windows, as stdint.h is not available prior to Visual Studio 2010 * Changed types of some variables in the SolveSpace class from 'int' to 'bool', as they actually represent boolean settings * Implemented new Cnf{Freeze,Thaw}Bool() functions to support boolean variables in the Registry * Cnf{Freeze,Thaw}DWORD() are now Cnf{Freeze,Thaw}Int() * TtfFont::Get{WORD,DWORD}() are now TtfFont::Get{USHORT,ULONG}() (names inspired by the OpenType spec) * RGB colors are packed into an integer of type uint32_t (nee DWORD), but in a few places, these were represented by an int; these have been corrected to uint32_t
2013-10-02 05:45:13 +00:00
static void ScreenChangeStyleYesNo(int link, uint32_t v);
static void ScreenCreateCustomStyle(int link, uint32_t v);
static void ScreenLoadFactoryDefaultStyles(int link, uint32_t v);
static void ScreenAssignSelectionToStyle(int link, uint32_t v);
static void ScreenShowConfiguration(int link, uint32_t v);
static void ScreenShowEditView(int link, uint32_t v);
static void ScreenGoToWebsite(int link, uint32_t v);
static void ScreenChangeFixExportColors(int link, uint32_t v);
static void ScreenChangeBackFaces(int link, uint32_t v);
Add an option to display areas of closed contours. This is useful e.g. for architectural work.
2017-03-30 14:39:42 +00:00
static void ScreenChangeShowContourAreas(int link, uint32_t v);
Use C99 integer types and C++ boolean types/values This change comprehensively replaces the use of Microsoft-standard integer and boolean types with their C99/C++ standard equivalents, as the latter is more appropriate for a cross-platform application. With matter-of-course exceptions in the Win32-specific code, the types/values have been converted as follows: QWORD --> uint64_t SQWORD --> int64_t DWORD --> uint32_t SDWORD --> int32_t WORD --> uint16_t SWORD --> int16_t BYTE --> uint8_t BOOL --> bool TRUE --> true FALSE --> false The following related changes are also included: * Added C99 integer type definitions for Windows, as stdint.h is not available prior to Visual Studio 2010 * Changed types of some variables in the SolveSpace class from 'int' to 'bool', as they actually represent boolean settings * Implemented new Cnf{Freeze,Thaw}Bool() functions to support boolean variables in the Registry * Cnf{Freeze,Thaw}DWORD() are now Cnf{Freeze,Thaw}Int() * TtfFont::Get{WORD,DWORD}() are now TtfFont::Get{USHORT,ULONG}() (names inspired by the OpenType spec) * RGB colors are packed into an integer of type uint32_t (nee DWORD), but in a few places, these were represented by an int; these have been corrected to uint32_t
2013-10-02 05:45:13 +00:00
static void ScreenChangeCheckClosedContour(int link, uint32_t v);
static void ScreenChangePwlCurves(int link, uint32_t v);
static void ScreenChangeCanvasSizeAuto(int link, uint32_t v);
static void ScreenChangeCanvasSize(int link, uint32_t v);
static void ScreenChangeShadedTriangles(int link, uint32_t v);
Add a setting that permits a group to include redundant constraints. This setting is generally useful, but it especially shines when assembling, since the "same orientation" and "parallel" constraints remove three and two rotational degrees of freedom, which makes them impossible to use with 3d "point on line" constraint that removes two spatial and two rotational degrees of freedom. The setting is not enabled for all imported groups by default because it exhibits some edge case failures. For example: * draw two line segments sharing a point, * constrain lengths of line segments, * constrain line segments perpendicular, * constrain line segments to a 90° angle. This is a truly degenerate case and so it is not considered very important. However, we can fix this later by using Eigen::SparseQR.
2016-01-21 15:01:43 +00:00
static void ScreenAllowRedundant(int link, uint32_t v);
Use C99 integer types and C++ boolean types/values This change comprehensively replaces the use of Microsoft-standard integer and boolean types with their C99/C++ standard equivalents, as the latter is more appropriate for a cross-platform application. With matter-of-course exceptions in the Win32-specific code, the types/values have been converted as follows: QWORD --> uint64_t SQWORD --> int64_t DWORD --> uint32_t SDWORD --> int32_t WORD --> uint16_t SWORD --> int16_t BYTE --> uint8_t BOOL --> bool TRUE --> true FALSE --> false The following related changes are also included: * Added C99 integer type definitions for Windows, as stdint.h is not available prior to Visual Studio 2010 * Changed types of some variables in the SolveSpace class from 'int' to 'bool', as they actually represent boolean settings * Implemented new Cnf{Freeze,Thaw}Bool() functions to support boolean variables in the Registry * Cnf{Freeze,Thaw}DWORD() are now Cnf{Freeze,Thaw}Int() * TtfFont::Get{WORD,DWORD}() are now TtfFont::Get{USHORT,ULONG}() (names inspired by the OpenType spec) * RGB colors are packed into an integer of type uint32_t (nee DWORD), but in a few places, these were represented by an int; these have been corrected to uint32_t
2013-10-02 05:45:13 +00:00
static void ScreenStepDimSteps(int link, uint32_t v);
static void ScreenStepDimFinish(int link, uint32_t v);
static void ScreenStepDimGo(int link, uint32_t v);
static void ScreenChangeTangentArc(int link, uint32_t v);
static void ScreenPasteTransformed(int link, uint32_t v);
static void ScreenHome(int link, uint32_t v);
Stipple the selected/hovered faces, instead of drawing them in solid red or yellow. And add user interface to `hide' the faces (i.e., to make them unselectable), defaulting to hidden in everything except extrudes or imports. [git-p4: depot-paths = "//depot/solvespace/": change = 1768]
2008-06-02 05:38:12 +00:00
Now I can rename groups, using that same edit control in the text window. [git-p4: depot-paths = "//depot/solvespace/": change = 1750]
2008-05-27 09:52:36 +00:00
// These ones do stuff with the edit control
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
static void ScreenChangeExprA(int link, uint32_t v);
static void ScreenChangeGroupName(int link, uint32_t v);
static void ScreenChangeGroupScale(int link, uint32_t v);
static void ScreenChangeLightDirection(int link, uint32_t v);
static void ScreenChangeLightIntensity(int link, uint32_t v);
static void ScreenChangeColor(int link, uint32_t v);
static void ScreenChangeChordTolerance(int link, uint32_t v);
static void ScreenChangeMaxSegments(int link, uint32_t v);
Use a separate value of chord tolerance for exporting. Before this commit, a single chord tolerance was used for both displaying and exporting geometry. Moreover, this chord tolerance was specified in screen pixels, and as such depended on zoom level. This was inconvenient: exporting geometry with a required level of precision required awkward manipulations of viewport. Moreover, since some operations, e.g. mesh watertightness checking, were done on triangle meshes which are generated differently depending on the zoom level, these operations could report wildly different and quite confusing results depending on zoom level. The chord tolerance for display and export pursue completely distinct goals: display chord tolerance should be set high enough to achieve both fast regeneration and legible rendering, whereas export chord tolerance should be set to match the dimension tolerance of the fabrication process. This commit introduces two distinct chord tolerances: a display and an export one. Both chord tolerances are absolute and expressed in millimeters; this is inappropriate for display purposes but will be fixed in the next commits. After exporting, the geometry is redrawn with the chord tolerance configured for the export and an overlay message is displayed; pressing Esc clears the message and returns the display back to normal.
2016-01-27 04:07:54 +00:00
static void ScreenChangeExportChordTolerance(int link, uint32_t v);
static void ScreenChangeExportMaxSegments(int link, uint32_t v);
Use C99 integer types and C++ boolean types/values This change comprehensively replaces the use of Microsoft-standard integer and boolean types with their C99/C++ standard equivalents, as the latter is more appropriate for a cross-platform application. With matter-of-course exceptions in the Win32-specific code, the types/values have been converted as follows: QWORD --> uint64_t SQWORD --> int64_t DWORD --> uint32_t SDWORD --> int32_t WORD --> uint16_t SWORD --> int16_t BYTE --> uint8_t BOOL --> bool TRUE --> true FALSE --> false The following related changes are also included: * Added C99 integer type definitions for Windows, as stdint.h is not available prior to Visual Studio 2010 * Changed types of some variables in the SolveSpace class from 'int' to 'bool', as they actually represent boolean settings * Implemented new Cnf{Freeze,Thaw}Bool() functions to support boolean variables in the Registry * Cnf{Freeze,Thaw}DWORD() are now Cnf{Freeze,Thaw}Int() * TtfFont::Get{WORD,DWORD}() are now TtfFont::Get{USHORT,ULONG}() (names inspired by the OpenType spec) * RGB colors are packed into an integer of type uint32_t (nee DWORD), but in a few places, these were represented by an int; these have been corrected to uint32_t
2013-10-02 05:45:13 +00:00
static void ScreenChangeCameraTangent(int link, uint32_t v);
static void ScreenChangeGridSpacing(int link, uint32_t v);
static void ScreenChangeDigitsAfterDecimal(int link, uint32_t v);
static void ScreenChangeExportScale(int link, uint32_t v);
static void ScreenChangeExportOffset(int link, uint32_t v);
static void ScreenChangeGCodeParameter(int link, uint32_t v);
Add an autosave timer. Original patch by Marc Britten <marc.britten@gmail.com>.
2015-03-29 04:46:57 +00:00
static void ScreenChangeAutosaveInterval(int link, uint32_t v);
Use C99 integer types and C++ boolean types/values This change comprehensively replaces the use of Microsoft-standard integer and boolean types with their C99/C++ standard equivalents, as the latter is more appropriate for a cross-platform application. With matter-of-course exceptions in the Win32-specific code, the types/values have been converted as follows: QWORD --> uint64_t SQWORD --> int64_t DWORD --> uint32_t SDWORD --> int32_t WORD --> uint16_t SWORD --> int16_t BYTE --> uint8_t BOOL --> bool TRUE --> true FALSE --> false The following related changes are also included: * Added C99 integer type definitions for Windows, as stdint.h is not available prior to Visual Studio 2010 * Changed types of some variables in the SolveSpace class from 'int' to 'bool', as they actually represent boolean settings * Implemented new Cnf{Freeze,Thaw}Bool() functions to support boolean variables in the Registry * Cnf{Freeze,Thaw}DWORD() are now Cnf{Freeze,Thaw}Int() * TtfFont::Get{WORD,DWORD}() are now TtfFont::Get{USHORT,ULONG}() (names inspired by the OpenType spec) * RGB colors are packed into an integer of type uint32_t (nee DWORD), but in a few places, these were represented by an int; these have been corrected to uint32_t
2013-10-02 05:45:13 +00:00
static void ScreenChangeStyleName(int link, uint32_t v);
Implement stippled line styles from ISO 128. Now it's possible to use a styled line to indicate e.g. a centerline.
2016-02-23 18:00:39 +00:00
static void ScreenChangeStyleMetric(int link, uint32_t v);
Use C99 integer types and C++ boolean types/values This change comprehensively replaces the use of Microsoft-standard integer and boolean types with their C99/C++ standard equivalents, as the latter is more appropriate for a cross-platform application. With matter-of-course exceptions in the Win32-specific code, the types/values have been converted as follows: QWORD --> uint64_t SQWORD --> int64_t DWORD --> uint32_t SDWORD --> int32_t WORD --> uint16_t SWORD --> int16_t BYTE --> uint8_t BOOL --> bool TRUE --> true FALSE --> false The following related changes are also included: * Added C99 integer type definitions for Windows, as stdint.h is not available prior to Visual Studio 2010 * Changed types of some variables in the SolveSpace class from 'int' to 'bool', as they actually represent boolean settings * Implemented new Cnf{Freeze,Thaw}Bool() functions to support boolean variables in the Registry * Cnf{Freeze,Thaw}DWORD() are now Cnf{Freeze,Thaw}Int() * TtfFont::Get{WORD,DWORD}() are now TtfFont::Get{USHORT,ULONG}() (names inspired by the OpenType spec) * RGB colors are packed into an integer of type uint32_t (nee DWORD), but in a few places, these were represented by an int; these have been corrected to uint32_t
2013-10-02 05:45:13 +00:00
static void ScreenChangeStyleTextAngle(int link, uint32_t v);
static void ScreenChangeStyleColor(int link, uint32_t v);
static void ScreenChangeBackgroundColor(int link, uint32_t v);
static void ScreenChangePasteTransformed(int link, uint32_t v);
static void ScreenChangeViewScale(int link, uint32_t v);
Implement "view → set to full scale" text window command.
2016-08-01 13:44:38 +00:00
static void ScreenChangeViewToFullScale(int link, uint32_t v);
Use C99 integer types and C++ boolean types/values This change comprehensively replaces the use of Microsoft-standard integer and boolean types with their C99/C++ standard equivalents, as the latter is more appropriate for a cross-platform application. With matter-of-course exceptions in the Win32-specific code, the types/values have been converted as follows: QWORD --> uint64_t SQWORD --> int64_t DWORD --> uint32_t SDWORD --> int32_t WORD --> uint16_t SWORD --> int16_t BYTE --> uint8_t BOOL --> bool TRUE --> true FALSE --> false The following related changes are also included: * Added C99 integer type definitions for Windows, as stdint.h is not available prior to Visual Studio 2010 * Changed types of some variables in the SolveSpace class from 'int' to 'bool', as they actually represent boolean settings * Implemented new Cnf{Freeze,Thaw}Bool() functions to support boolean variables in the Registry * Cnf{Freeze,Thaw}DWORD() are now Cnf{Freeze,Thaw}Int() * TtfFont::Get{WORD,DWORD}() are now TtfFont::Get{USHORT,ULONG}() (names inspired by the OpenType spec) * RGB colors are packed into an integer of type uint32_t (nee DWORD), but in a few places, these were represented by an int; these have been corrected to uint32_t
2013-10-02 05:45:13 +00:00
static void ScreenChangeViewOrigin(int link, uint32_t v);
static void ScreenChangeViewProjection(int link, uint32_t v);
Add double-sided extrudes, and user interface for that. Also put the coordinate system (x, y, z normal vectors) in the bottom left corner of the screen at all times, and hide group-created workplanes except when that group is active, and activate that workplane when the group is activated. [git-p4: depot-paths = "//depot/solvespace/": change = 1726]
2008-05-17 08:02:39 +00:00
Added const qualifiers to edit-control string handling FLTK's Fl_Input widget, instantiated as {Graphics,Text}EditControl, returns a 'const char *' string. In order to handle this properly, several of SolveSpace's internal routines needed to gain a "const" qualifier on the edit-control string argument.
2013-09-16 19:51:20 +00:00
bool EditControlDoneForStyles(const char *s);
bool EditControlDoneForConfiguration(const char *s);
bool EditControlDoneForPaste(const char *s);
bool EditControlDoneForView(const char *s);
void EditControlDone(const char *s);
Add hyperlink and colour support to the text window. Don't redraw the text window every time we refresh the graphics window, because that's slow. Use classes instead of structs for everything; I don't understand the template handling for structs. And implement the IdList, which I will try to use in many places. [git-p4: depot-paths = "//depot/solvespace/": change = 1655]
2008-03-28 10:00:37 +00:00
};
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
Add hyperlink and colour support to the text window. Don't redraw the text window every time we refresh the graphics window, because that's slow. Use classes instead of structs for everything; I don't understand the template handling for structs. And implement the IdList, which I will try to use in many places. [git-p4: depot-paths = "//depot/solvespace/": change = 1655]
2008-03-28 10:00:37 +00:00
class GraphicsWindow {
public:
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void Init();
Add the keyboard accelerator mechanism for menu items. Use that to implement zoom in/out, and orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1663]
2008-04-12 15:17:58 +00:00
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
typedef void MenuHandler(Command id);
Use symbolic names for special keys and modifiers Easier to remember e.g. DELETE_KEY instead of 127 or CTRL_MASK instead of 0x200, and better to have a single definition of each.
2013-09-20 17:54:57 +00:00
enum {
ESCAPE_KEY = 27,
DELETE_KEY = 127,
FUNCTION_KEY_BASE = 0xf0
};
enum {
SHIFT_MASK = 0x100,
CTRL_MASK = 0x200
};
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
enum class MenuKind : uint32_t {
NORMAL = 0,
CHECK,
RADIO
Add a GTK2/3 port. In principle, GTK3 is the way forward, and GTK2 is officially deprecated, though still maintained. In practice however, GTK3 is often unbearably buggy; e.g. on my system, combo boxes don't ever roll up in GTK3 windows. So I have added support for both. This required a few minor changes to the core, namely: * GTK wants to know beforehand whether a menu item is a check menu item or a regular one. * GTK doesn't give us an easy way to execute something after any event is processed, so an explicit idle timer is added. This is a no-op on Win32. * A few function signatures were const'ed, since GTK expects immutable strings when converting to Glib::ustring.
2015-03-18 17:02:11 +00:00
};
More fragments of SolveSpace work. Improve the command line window, and add some (non-functional) menus to the graphics window. Start to rough in some data structures to hold the sketch. No real work yet, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1653]
2008-03-26 09:18:12 +00:00
typedef struct {
Add a GTK2/3 port. In principle, GTK3 is the way forward, and GTK2 is officially deprecated, though still maintained. In practice however, GTK3 is often unbearably buggy; e.g. on my system, combo boxes don't ever roll up in GTK3 windows. So I have added support for both. This required a few minor changes to the core, namely: * GTK wants to know beforehand whether a menu item is a check menu item or a regular one. * GTK doesn't give us an easy way to execute something after any event is processed, so an explicit idle timer is added. This is a no-op on Win32. * A few function signatures were const'ed, since GTK expects immutable strings when converting to Glib::ustring.
2015-03-18 17:02:11 +00:00
int level; // 0 == on menu bar, 1 == one level down
const char *label; // or NULL for a separator
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
Command id; // unique ID
Add a GTK2/3 port. In principle, GTK3 is the way forward, and GTK2 is officially deprecated, though still maintained. In practice however, GTK3 is often unbearably buggy; e.g. on my system, combo boxes don't ever roll up in GTK3 windows. So I have added support for both. This required a few minor changes to the core, namely: * GTK wants to know beforehand whether a menu item is a check menu item or a regular one. * GTK doesn't give us an easy way to execute something after any event is processed, so an explicit idle timer is added. This is a no-op on Win32. * A few function signatures were const'ed, since GTK expects immutable strings when converting to Glib::ustring.
2015-03-18 17:02:11 +00:00
int accel; // keyboard accelerator
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
MenuKind kind;
Add a GTK2/3 port. In principle, GTK3 is the way forward, and GTK2 is officially deprecated, though still maintained. In practice however, GTK3 is often unbearably buggy; e.g. on my system, combo boxes don't ever roll up in GTK3 windows. So I have added support for both. This required a few minor changes to the core, namely: * GTK wants to know beforehand whether a menu item is a check menu item or a regular one. * GTK doesn't give us an easy way to execute something after any event is processed, so an explicit idle timer is added. This is a no-op on Win32. * A few function signatures were const'ed, since GTK expects immutable strings when converting to Glib::ustring.
2015-03-18 17:02:11 +00:00
MenuHandler *fn;
More fragments of SolveSpace work. Improve the command line window, and add some (non-functional) menus to the graphics window. Start to rough in some data structures to hold the sketch. No real work yet, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1653]
2008-03-26 09:18:12 +00:00
} MenuEntry;
static const MenuEntry menu[];
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
static void MenuView(Command id);
static void MenuEdit(Command id);
static void MenuRequest(Command id);
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void DeleteSelection();
void CopySelection();
A big nasty change, originally just to add paste transformed. So it does that, and adds a scale factor to that transformation (instead of just mirroring, as before), but also: * Replace the "import mirrored" mechanism with a scale factor, which if negative corresponds to a reflection as well. * Fix self-intersection checker to report a meaningful point when edges are collinear. * Don't blow an assertion on some types of invalid file; instead provide a nice error message to the user. * Clear the naked edges before each regen. * Don't create zero-length line segments by snapping a line segment's end to its beginning. [git-p4: depot-paths = "//depot/solvespace/": change = 2086]
2009-12-15 12:26:22 +00:00
void PasteClipboard(Vector trans, double theta, double scale);
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
static void MenuClipboard(Command id);
Get rid of the command line from the text window; we'll say that's just for display, and any text entry will happen via some floating text box, same as entering a dimension on the sketch. Add the hover and selection mechanism, which now seems to work. Still not clear how to do imported parts, for assemblies and hierarchy. The handle formats may still have to change. [git-p4: depot-paths = "//depot/solvespace/": change = 1662]
2008-04-12 14:12:26 +00:00
Hide OpenGL implementation details. Abstract the exact details of the OpenGL renderer in the render.h header; this allows us to use GL-specific types in the renderer class and functions without including OpenGL (and Windows, where applicable) headers in every source file.
2016-06-28 08:48:06 +00:00
std::shared_ptr<ViewportCanvas> canvas;
Add an interface for view-independent rendering. To actually achieve improved performance with the OpenGL 2 renderer, we have to cache geometry that doesn't change when the viewport does (note that the rendered pixels can change quite dramatically because we can reconfigure shaders; e.g. stippling can be drawn in screen coordinates). This commit adds a BatchCanvas interface that can be implemented by renderers, and uses it for drawing entities such as lines and points.
2016-06-30 15:54:35 +00:00
std::shared_ptr<BatchCanvas> persistentCanvas;
bool persistentDirty;
Hide OpenGL implementation details. Abstract the exact details of the OpenGL renderer in the render.h header; this allows us to use GL-specific types in the renderer class and functions without including OpenGL (and Windows, where applicable) headers in every source file.
2016-06-28 08:48:06 +00:00
Bits and pieces of SolveSpace; zoom works now, and some stuff to draw planes that I will use to do the datum planes. Still haven't settled upon the request/entity/group structure, and that's the dependency before doing much real. [git-p4: depot-paths = "//depot/solvespace/": change = 1656]
2008-04-01 10:48:44 +00:00
// The width and height (in pixels) of the window.
double width, height;
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
// These parameters define the map from 2d screen coordinates to the
// coordinates of the 3d sketch points. We will use an axonometric
// projection.
Vector offset;
Vector projRight;
Add the keyboard accelerator mechanism for menu items. Use that to implement zoom in/out, and orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1663]
2008-04-12 15:17:58 +00:00
Vector projUp;
Start to add OpenGL support to SolveSpace, for the graphical view. I've got the user interface to pan and rotate an object, more or less works. [git-p4: depot-paths = "//depot/solvespace/": change = 1654]
2008-03-27 09:53:51 +00:00
double scale;
struct {
Add ability to set a background image. I import a png with libpng, load it as a texture, and show it instead of a flat-color background. Includes user interface to specify scale and translation of image, but the rotation is always aligned to the view. [git-p4: depot-paths = "//depot/solvespace/": change = 2071]
2009-11-08 01:11:38 +00:00
bool mouseDown;
Start to add OpenGL support to SolveSpace, for the graphical view. I've got the user interface to pan and rotate an object, more or less works. [git-p4: depot-paths = "//depot/solvespace/": change = 1654]
2008-03-27 09:53:51 +00:00
Vector offset;
Vector projRight;
Add the keyboard accelerator mechanism for menu items. Use that to implement zoom in/out, and orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1663]
2008-04-12 15:17:58 +00:00
Vector projUp;
Start to add OpenGL support to SolveSpace, for the graphical view. I've got the user interface to pan and rotate an object, more or less works. [git-p4: depot-paths = "//depot/solvespace/": change = 1654]
2008-03-27 09:53:51 +00:00
Point2d mouse;
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
Point2d mouseOnButtonDown;
Add marquee selection, a view-aligned rectangle such that everything even partially within that rectangle gets selected when I release. Also make deselecting a point deselect all coincident points too; otherwise there now exist ways to select both coincident points, which meant that it was impossible to deselect the lower one. And fix text window to show selection info even if just constraints are selected, seems more consistent. [git-p4: depot-paths = "//depot/solvespace/": change = 2066]
2009-11-04 07:52:58 +00:00
Vector marqueePoint;
Add a context menu, with a grab bag of options. That will need some refinement later, but it does not affect file formats so it's not very critical. [git-p4: depot-paths = "//depot/solvespace/": change = 2032]
2009-09-23 10:59:59 +00:00
bool startedMoving;
Start to add OpenGL support to SolveSpace, for the graphical view. I've got the user interface to pan and rotate an object, more or less works. [git-p4: depot-paths = "//depot/solvespace/": change = 1654]
2008-03-27 09:53:51 +00:00
} orig;
Cache bounding boxes. This results in massive performance improvements for hit testing. Files with very large amounts of entities (e.g. [1]) inflict a delay of several seconds between moving the pointer and highlighting an entity in commit HEAD^^^, whereas in this commit the delay is barely perceptible. [1]: http://solvespace.com/forum.pl?action=viewthread&parent=872
2016-03-05 15:09:11 +00:00
// We need to detect when the projection is changed to invalidate
// caches for drawn items.
struct {
Vector offset;
Vector projRight;
Vector projUp;
double scale;
} cached;
Start to add OpenGL support to SolveSpace, for the graphical view. I've got the user interface to pan and rotate an object, more or less works. [git-p4: depot-paths = "//depot/solvespace/": change = 1654]
2008-03-27 09:53:51 +00:00
When curves to be split intersect at multiple points, don't just choose arbitrarily. Instead, split at the point closest to the mouse pointer. [git-p4: depot-paths = "//depot/solvespace/": change = 2170]
2010-07-12 06:47:14 +00:00
// Most recent mouse position, updated every time the mouse moves.
Point2d currentMousePosition;
Add point on line constraints, in 2d and 3d. The 3d equations do not have much motivation behind them, but they seem to work. And make sure that we don't solve multiple times without repainting in between, and tweak the text window a bit more. [git-p4: depot-paths = "//depot/solvespace/": change = 1696]
2008-04-28 09:40:02 +00:00
// When the user is dragging a point, don't solve multiple times without
// allowing a paint in between. The extra solves are wasted if they're
// not displayed.
bool havePainted;
Add a context menu, with a grab bag of options. That will need some refinement later, but it does not affect file formats so it's not very critical. [git-p4: depot-paths = "//depot/solvespace/": change = 2032]
2009-09-23 10:59:59 +00:00
// Some state for the context menu.
struct {
bool active;
} context;
Abstract all (ex-OpenGL) drawing operations into a Canvas interface. This has several desirable consequences: * It is now possible to port SolveSpace to a later version of OpenGL, such as OpenGLES 2, so that it runs on platforms that only have that OpenGL version; * The majority of geometry is now rendered without references to the camera in C++ code, so a renderer can now submit it to the video card once and re-rasterize with a different projection matrix every time the projection is changed, avoiding expensive reuploads; * The DOGD (draw or get distance) interface is now a straightforward Canvas implementation; * There are no more direct references to SS.GW.(projection) in sketch rendering code, which allows rendering to multiple viewports; * There are no more unnecessary framebuffer flips on CPU on Cocoa and GTK; * The platform-dependent GL code is now confined to rendergl1.cpp. * The Microsoft and Apple headers required by it that are prone to identifier conflicts are no longer included globally; * The rendergl1.cpp implementation can now be omitted from compilation to run SolveSpace headless or with a different OpenGL version. Note these implementation details of Canvas: * GetCamera currently always returns a reference to the field `Camera camera;`. This is so that a future renderer that caches geometry in the video memory can define it as asserting, which would provide assurance against code that could accidentally put something projection-dependent in the cache; * Line and triangle rendering is specified through a level of indirection, hStroke and hFill. This is so that a future renderer that batches geometry could cheaply group identical styles. * DrawPixmap and DrawVectorText accept a (o,u,v) and not a matrix. This is so that a future renderer into an output format that uses 2d transforms (e.g. SVG) could easily derive those. Some additional internal changes were required to enable this: * Pixmap is now always passed as std::shared_ptr<{const ,}Pixmap>. This is so that the renderer could cache uploaded textures between API calls, which requires it to capture a (weak) reference. * The PlatformPathEqual function was properly extracted into platform-specific code. This is so that the <windows.h> header could be included only where needed (in platform/w32* as well as rendergl1.cpp). * The SBsp{2,3}::DebugDraw functions were removed. They can be rewritten using the Canvas API if they are ever needed. While no visual changes were originally intended, some minor fixes happened anyway: * The "emphasis" yellow line from top-left corner is now correctly rendered much wider. * The marquee rectangle is now pixel grid aligned. * The hidden entities now do not clobber the depth buffer, removing some minor artifacts. * The workplane "tab" now scales with the font used to render the workplane name. * The workplane name font is now taken from the normals style. * Workplane and constraint line stipple is insignificantly different. This is so that it can reuse the existing stipple codepaths; rendering of workplanes and constraints predates those. Some debug functionality was added: * In graphics window, an fps counter that becomes red when rendering under 60fps is drawn.
2016-05-31 00:55:13 +00:00
Camera GetCamera() const;
Lighting GetLighting() const;
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void NormalizeProjectionVectors();
Get rid of the command line from the text window; we'll say that's just for display, and any text entry will happen via some floating text box, same as entering a dimension on the sketch. Add the hover and selection mechanism, which now seems to work. Still not clear how to do imported parts, for assemblies and hierarchy. The handle formats may still have to change. [git-p4: depot-paths = "//depot/solvespace/": change = 1662]
2008-04-12 14:12:26 +00:00
Point2d ProjectPoint(Vector p);
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
Vector ProjectPoint3(Vector p);
Vector ProjectPoint4(Vector p, double *w);
Add marquee selection, a view-aligned rectangle such that everything even partially within that rectangle gets selected when I release. Also make deselecting a point deselect all coincident points too; otherwise there now exist ways to select both coincident points, which meant that it was impossible to deselect the lower one. And fix text window to show selection info even if just constraints are selected, seems more consistent. [git-p4: depot-paths = "//depot/solvespace/": change = 2066]
2009-11-04 07:52:58 +00:00
Vector UnProjectPoint(Point2d p);
Perform grid fitting on the builtin vector font. Grid fitting is performed only on glyph boundaries, since glyphs include curves converted to pwl, which would be mangled by per-point grid fitting. Grid fitting is only performed when the plane in which text is laid out is parallel to the viewing plane. Grid fitting is only performed when rendering for display; there are no devices with dpi low enough for grid fitting to become profitable, and in any case we cannot predict what the dpi would be anyway.
2016-04-05 11:12:14 +00:00
Vector UnProjectPoint3(Vector p);
Add menu items to snap view to nearest orthogonal or iso view. [git-p4: depot-paths = "//depot/solvespace/": change = 1882]
2009-01-02 04:06:47 +00:00
void AnimateOnto(Quaternion quatf, Vector offsetf);
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void AnimateOntoWorkplane();
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
Vector VectorFromProjs(Vector rightUpForward);
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
void HandlePointForZoomToFit(Vector p, Point2d *pmax, Point2d *pmin,
Only consider selected entities, when any, when doing Zoom to Fit. Scoped "Zoom to Fit" is convenient for working on large models. I (whitequark) have considered a separate shortcut, but its usefulness is unclear and in any case it can be easily added if desired.
2016-01-30 10:38:38 +00:00
double *wmin, bool usePerspective);
Also consider constraints when zooming to fit. Before this commit, when working on convex sketches, zooming to fit was guaranteed to clip most or even all constraints, making it quite useless.
2016-08-01 14:00:00 +00:00
void LoopOverPoints(const std::vector<Entity *> &entities,
const std::vector<Constraint *> &constraints,
const std::vector<hEntity> &faces,
Point2d *pmax, Point2d *pmin,
Only consider selected entities, when any, when doing Zoom to Fit. Scoped "Zoom to Fit" is convenient for working on large models. I (whitequark) have considered a separate shortcut, but its usefulness is unclear and in any case it can be easily added if desired.
2016-01-30 10:38:38 +00:00
double *wmin, bool usePerspective, bool includeMesh);
void ZoomToFit(bool includingInvisibles, bool useSelection = false);
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
hGroup activeGroup;
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void EnsureValidActives();
bool LockedInWorkplane();
void SetWorkplaneFreeIn3d();
hEntity ActiveWorkplane();
void ForceTextWindowShown();
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
// Operations that must be completed by doing something with the mouse
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
// are noted here.
enum class Pending : uint32_t {
NONE = 0,
COMMAND = 1,
DRAGGING_POINTS = 2,
DRAGGING_NEW_POINT = 3,
DRAGGING_NEW_LINE_POINT = 4,
DRAGGING_NEW_CUBIC_POINT = 5,
DRAGGING_NEW_ARC_POINT = 6,
DRAGGING_CONSTRAINT = 7,
DRAGGING_RADIUS = 8,
DRAGGING_NORMAL = 9,
DRAGGING_NEW_RADIUS = 10,
DRAGGING_MARQUEE = 11,
Changed "static const int" class members into enums Not only is the enum syntax more compact, it avoids inadvertent link failures resulting from how C++ treats "static const int" members: http://stackoverflow.com/questions/5391973/undefined-reference-to-static-const-int http://stackoverflow.com/questions/5508182/static-const-int-causes-linking-error-undefined-reference (And for what it's worth, MSVC6 gave silly errors for these members wherever a non-zero value was assigned.)
2013-09-09 19:50:32 +00:00
};
Disable autoconstrainer while Ctrl is held.
2016-04-02 08:29:32 +00:00
A big change, to add a concept of normals. These are "oriented vectors", represented by unit quaternions. This permits me to add circles, where the normal defines the plane of the circle. Still many things painful. The interface for editing normals is not so intuitive, and it's not yet clear how I would e.g. export a circle entity and recreate it properly, since that entity has a param not associated with a normal or point. And the transformed points/normals do not yet support rotations. That will be necessary soon. [git-p4: depot-paths = "//depot/solvespace/": change = 1705]
2008-05-05 06:18:01 +00:00
struct {
Convert GraphicsWindow::pending.operation to `enum class`. This follows the previous commit. Unlike it, though, a small change to control flow is made to separate the command and pending operation enumerations.
2016-05-23 10:15:38 +00:00
Pending operation;
Command command;
A big change, to add a concept of normals. These are "oriented vectors", represented by unit quaternions. This permits me to add circles, where the normal defines the plane of the circle. Still many things painful. The interface for editing normals is not so intuitive, and it's not yet clear how I would e.g. export a circle entity and recreate it properly, since that entity has a param not associated with a normal or point. And the transformed points/normals do not yet support rotations. That will be necessary soon. [git-p4: depot-paths = "//depot/solvespace/": change = 1705]
2008-05-05 06:18:01 +00:00
Disable autoconstrainer while Ctrl is held.
2016-04-02 08:29:32 +00:00
hRequest request;
hEntity point;
List<hEntity> points;
Do not hover or select entities from any pending request.
2017-01-09 16:54:24 +00:00
List<hRequest> requests;
Disable autoconstrainer while Ctrl is held.
2016-04-02 08:29:32 +00:00
hEntity circle;
hEntity normal;
hConstraint constraint;
Trim trailing whitespace.
2015-03-29 00:30:52 +00:00
Disable autoconstrainer while Ctrl is held.
2016-04-02 08:29:32 +00:00
const char *description;
Implement an image request.
2016-11-29 16:49:20 +00:00
Platform::Path filename;
Disable autoconstrainer while Ctrl is held.
2016-04-02 08:29:32 +00:00
Enable exhaustive switch coverage warnings as an error, and use them. Specifically, this enables -Wswitch=error on GCC/Clang and its MSVC equivalent; the exact way it is handled varies slightly, but what they all have in common is that in a switch statement over an enumeration, any enumerand that is not explicitly (via case:) or implicitly (via default:) handled in the switch triggers an error. Moreover, we also change the switch statements in three ways: * Switch statements that ought to be extended every time a new enumerand is added (e.g. Entity::DrawOrGetDistance(), are changed to explicitly list every single enumerand, and not have a default: branch. Note that the assertions are kept because it is legal for a enumeration to have a value unlike any of its defined enumerands, and we can e.g. read garbage from a file, or an uninitialized variable. This requires some rearranging if a default: branch is undesired. * Switch statements that ought to only ever see a few select enumerands, are changed to always assert in the default: branch. * Switch statements that do something meaningful for a few enumerands, and ignore everything else, are changed to do nothing in a default: branch, under the assumption that changing them every time an enumerand is added or removed would just result in noise and catch no bugs. This commit also removes the {Request,Entity,Constraint}::UNKNOWN and Entity::DATUM_POINT enumerands, as those were just fancy names for zeroes. They mess up switch exhaustiveness checks and most of the time were not the best way to implement what they did anyway.
2016-05-25 06:55:50 +00:00
bool hasSuggestion;
Constraint::Type suggestion;
A big change, to add a concept of normals. These are "oriented vectors", represented by unit quaternions. This permits me to add circles, where the normal defines the plane of the circle. Still many things painful. The interface for editing normals is not so intuitive, and it's not yet clear how I would e.g. export a circle entity and recreate it properly, since that entity has a param not associated with a normal or point. And the transformed points/normals do not yet support rotations. That will be necessary soon. [git-p4: depot-paths = "//depot/solvespace/": change = 1705]
2008-05-05 06:18:01 +00:00
} pending;
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void ClearPending();
Do not hover or select entities from any pending request.
2017-01-09 16:54:24 +00:00
bool IsFromPending(hRequest r);
void AddToPending(hRequest r);
Fix logic introduced in 55ae10b. Before this commit, the effect of the AddPending() call was immediately reversed by ClearSuper.
2017-01-24 16:54:10 +00:00
void ReplacePending(hRequest before, hRequest after);
Do not hover or select entities from any pending request.
2017-01-09 16:54:24 +00:00
Now I can display the edit control in the graphics window, and edit the label associated with a constraint. And that even works, changes the length of the line. [git-p4: depot-paths = "//depot/solvespace/": change = 1678]
2008-04-21 10:12:04 +00:00
// The constraint that is being edited with the on-screen textbox.
hConstraint constraintBeingEdited;
A big change, to add a concept of normals. These are "oriented vectors", represented by unit quaternions. This permits me to add circles, where the normal defines the plane of the circle. Still many things painful. The interface for editing normals is not so intuitive, and it's not yet clear how I would e.g. export a circle entity and recreate it properly, since that entity has a param not associated with a normal or point. And the transformed points/normals do not yet support rotations. That will be necessary soon. [git-p4: depot-paths = "//depot/solvespace/": change = 1705]
2008-05-05 06:18:01 +00:00
Enable exhaustive switch coverage warnings as an error, and use them. Specifically, this enables -Wswitch=error on GCC/Clang and its MSVC equivalent; the exact way it is handled varies slightly, but what they all have in common is that in a switch statement over an enumeration, any enumerand that is not explicitly (via case:) or implicitly (via default:) handled in the switch triggers an error. Moreover, we also change the switch statements in three ways: * Switch statements that ought to be extended every time a new enumerand is added (e.g. Entity::DrawOrGetDistance(), are changed to explicitly list every single enumerand, and not have a default: branch. Note that the assertions are kept because it is legal for a enumeration to have a value unlike any of its defined enumerands, and we can e.g. read garbage from a file, or an uninitialized variable. This requires some rearranging if a default: branch is undesired. * Switch statements that ought to only ever see a few select enumerands, are changed to always assert in the default: branch. * Switch statements that do something meaningful for a few enumerands, and ignore everything else, are changed to do nothing in a default: branch, under the assumption that changing them every time an enumerand is added or removed would just result in noise and catch no bugs. This commit also removes the {Request,Entity,Constraint}::UNKNOWN and Entity::DATUM_POINT enumerands, as those were just fancy names for zeroes. They mess up switch exhaustiveness checks and most of the time were not the best way to implement what they did anyway.
2016-05-25 06:55:50 +00:00
bool SuggestLineConstraint(hRequest lineSegment, ConstraintBase::Type *type);
Automatically add horz/vert constraints to lines if close enough.
2015-03-29 22:26:07 +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
Vector SnapToGrid(Vector p);
Snap point to entity when constraining to a hovered entity. Before this commit, when a point is constrained to an entity (point, circle, arc of circle or line segment) by clicking on it, the resulting constraint is not necessarily satisfied, and the next regeneration may place the newly constrained point somewhere other than the intended position. After this commit, the parameters are modified to satisfy the constraint.
2017-02-02 03:48:54 +00:00
Vector SnapToEntityByScreenPoint(Point2d pp, hEntity he);
bool ConstrainPointByHovered(hEntity pt, const Point2d *projected = NULL);
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void DeleteTaggedRequests();
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
hRequest AddRequest(Request::Type type, bool rememberForUndo);
hRequest AddRequest(Request::Type type);
Add a trim command. I can now do circles (or arcs) against lines, or lines against lines. The constraints get rather screwed up afterwards, of course. So make arcs with the endpoints coincident into circles, instead of nothings; since the first split of a circle produces that. And don't warn after deleting just point-coincident or horiz/vert constraints as a dependency; that's just a nuisance, because it happens too often. [git-p4: depot-paths = "//depot/solvespace/": change = 1884]
2009-01-03 12:27:33 +00:00
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
class ParametricCurve {
public:
bool isLine; // else circle
Vector p0, p1;
Vector u, v;
double r, theta0, theta1, dtheta;
Trim trailing whitespace.
2015-03-29 00:30:52 +00:00
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
void MakeFromEntity(hEntity he, bool reverse);
Vector PointAt(double t);
Vector TangentAt(double t);
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
double LengthForAuto();
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
hRequest CreateRequestTrimmedTo(double t, bool extraConstraints,
hEntity orig, hEntity arc, bool arcFinish);
void ConstrainPointIfCoincident(hEntity hpt);
};
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void MakeTangentArc();
void SplitLinesOrCurves();
Replace the closed-form solutions for entity-entity splitting with a method that works on the piecewise linear segments, and then refines any intersections that it finds by Newton's method. So now I support cubics too, and circle-circle intersections, and the code is much simpler. [git-p4: depot-paths = "//depot/solvespace/": change = 2012]
2009-07-07 08:21:59 +00:00
hEntity SplitEntity(hEntity he, Vector pinter);
hEntity SplitLine(hEntity he, Vector pinter);
hEntity SplitCircle(hEntity he, Vector pinter);
hEntity SplitCubic(hEntity he, Vector pinter);
Add a trim command. I can now do circles (or arcs) against lines, or lines against lines. The constraints get rather screwed up afterwards, of course. So make arcs with the endpoints coincident into circles, instead of nothings; since the first split of a circle produces that. And don't warn after deleting just point-coincident or horiz/vert constraints as a dependency; that's just a nuisance, because it happens too often. [git-p4: depot-paths = "//depot/solvespace/": change = 1884]
2009-01-03 12:27:33 +00:00
void ReplacePointInConstraints(hEntity oldpt, hEntity newpt);
Allow removing spline points.
2016-04-07 14:44:56 +00:00
void RemoveConstraintsForPointBeingDeleted(hEntity hpt);
When deleting a request, rewrite the constraints on its points in such a way as to keep all the points that used to be coincident, still coincident. [git-p4: depot-paths = "//depot/solvespace/": change = 2013]
2009-07-08 09:36:18 +00:00
void FixConstraintsForRequestBeingDeleted(hRequest hr);
void FixConstraintsForPointBeingDeleted(hEntity hpt);
Trim trailing whitespace.
2015-03-29 00:30:52 +00:00
Choose entities to select in a way appropriate for the operation. Before this commit, when an entity is clicked at or dragged, and it shares a place with other entities, which of them is selected is decided more or less at random. This is particularly annoying when dragging. After this commit, when clicking, an entity from the current group is given preference, and when dragging, an entity from a request is given preference. This allows e.g. dragging points of a sketch even when an extrusion of that sketch is active.
2016-07-21 17:58:18 +00:00
// A selected entity.
Get rid of the command line from the text window; we'll say that's just for display, and any text entry will happen via some floating text box, same as entering a dimension on the sketch. Add the hover and selection mechanism, which now seems to work. Still not clear how to do imported parts, for assemblies and hierarchy. The handle formats may still have to change. [git-p4: depot-paths = "//depot/solvespace/": change = 1662]
2008-04-12 14:12:26 +00:00
class Selection {
public:
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
int tag;
Get rid of the command line from the text window; we'll say that's just for display, and any text entry will happen via some floating text box, same as entering a dimension on the sketch. Add the hover and selection mechanism, which now seems to work. Still not clear how to do imported parts, for assemblies and hierarchy. The handle formats may still have to change. [git-p4: depot-paths = "//depot/solvespace/": change = 1662]
2008-04-12 14:12:26 +00:00
hEntity entity;
Now I can add a constraint (a length), and it's displayed on-screen, and I can drag the label. That's progress. Also implement a bunch of untested expression stuff, since I'll need that for the values of the dimensions, for example. [git-p4: depot-paths = "//depot/solvespace/": change = 1668]
2008-04-14 10:28:32 +00:00
hConstraint constraint;
Many user interface additions. Now I report when the solver fails, and in the case of a singular Jacobian, report which constraints can be removed to fix it. Also a mechanism to hover and select entities and constraints from the text window. [git-p4: depot-paths = "//depot/solvespace/": change = 1746]
2008-05-26 09:56:50 +00:00
bool emphasized;
Get rid of the command line from the text window; we'll say that's just for display, and any text entry will happen via some floating text box, same as entering a dimension on the sketch. Add the hover and selection mechanism, which now seems to work. Still not clear how to do imported parts, for assemblies and hierarchy. The handle formats may still have to change. [git-p4: depot-paths = "//depot/solvespace/": change = 1662]
2008-04-12 14:12:26 +00:00
Abstract all (ex-OpenGL) drawing operations into a Canvas interface. This has several desirable consequences: * It is now possible to port SolveSpace to a later version of OpenGL, such as OpenGLES 2, so that it runs on platforms that only have that OpenGL version; * The majority of geometry is now rendered without references to the camera in C++ code, so a renderer can now submit it to the video card once and re-rasterize with a different projection matrix every time the projection is changed, avoiding expensive reuploads; * The DOGD (draw or get distance) interface is now a straightforward Canvas implementation; * There are no more direct references to SS.GW.(projection) in sketch rendering code, which allows rendering to multiple viewports; * There are no more unnecessary framebuffer flips on CPU on Cocoa and GTK; * The platform-dependent GL code is now confined to rendergl1.cpp. * The Microsoft and Apple headers required by it that are prone to identifier conflicts are no longer included globally; * The rendergl1.cpp implementation can now be omitted from compilation to run SolveSpace headless or with a different OpenGL version. Note these implementation details of Canvas: * GetCamera currently always returns a reference to the field `Camera camera;`. This is so that a future renderer that caches geometry in the video memory can define it as asserting, which would provide assurance against code that could accidentally put something projection-dependent in the cache; * Line and triangle rendering is specified through a level of indirection, hStroke and hFill. This is so that a future renderer that batches geometry could cheaply group identical styles. * DrawPixmap and DrawVectorText accept a (o,u,v) and not a matrix. This is so that a future renderer into an output format that uses 2d transforms (e.g. SVG) could easily derive those. Some additional internal changes were required to enable this: * Pixmap is now always passed as std::shared_ptr<{const ,}Pixmap>. This is so that the renderer could cache uploaded textures between API calls, which requires it to capture a (weak) reference. * The PlatformPathEqual function was properly extracted into platform-specific code. This is so that the <windows.h> header could be included only where needed (in platform/w32* as well as rendergl1.cpp). * The SBsp{2,3}::DebugDraw functions were removed. They can be rewritten using the Canvas API if they are ever needed. While no visual changes were originally intended, some minor fixes happened anyway: * The "emphasis" yellow line from top-left corner is now correctly rendered much wider. * The marquee rectangle is now pixel grid aligned. * The hidden entities now do not clobber the depth buffer, removing some minor artifacts. * The workplane "tab" now scales with the font used to render the workplane name. * The workplane name font is now taken from the normals style. * Workplane and constraint line stipple is insignificantly different. This is so that it can reuse the existing stipple codepaths; rendering of workplanes and constraints predates those. Some debug functionality was added: * In graphics window, an fps counter that becomes red when rendering under 60fps is drawn.
2016-05-31 00:55:13 +00:00
void Draw(bool isHovered, Canvas *canvas);
Get rid of the command line from the text window; we'll say that's just for display, and any text entry will happen via some floating text box, same as entering a dimension on the sketch. Add the hover and selection mechanism, which now seems to work. Still not clear how to do imported parts, for assemblies and hierarchy. The handle formats may still have to change. [git-p4: depot-paths = "//depot/solvespace/": change = 1662]
2008-04-12 14:12:26 +00:00
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void Clear();
bool IsEmpty();
Get rid of the command line from the text window; we'll say that's just for display, and any text entry will happen via some floating text box, same as entering a dimension on the sketch. Add the hover and selection mechanism, which now seems to work. Still not clear how to do imported parts, for assemblies and hierarchy. The handle formats may still have to change. [git-p4: depot-paths = "//depot/solvespace/": change = 1662]
2008-04-12 14:12:26 +00:00
bool Equals(Selection *b);
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
bool HasEndpoints();
Get rid of the command line from the text window; we'll say that's just for display, and any text entry will happen via some floating text box, same as entering a dimension on the sketch. Add the hover and selection mechanism, which now seems to work. Still not clear how to do imported parts, for assemblies and hierarchy. The handle formats may still have to change. [git-p4: depot-paths = "//depot/solvespace/": change = 1662]
2008-04-12 14:12:26 +00:00
};
Choose entities to select in a way appropriate for the operation. Before this commit, when an entity is clicked at or dragged, and it shares a place with other entities, which of them is selected is decided more or less at random. This is particularly annoying when dragging. After this commit, when clicking, an entity from the current group is given preference, and when dragging, an entity from a request is given preference. This allows e.g. dragging points of a sketch even when an extrusion of that sketch is active.
2016-07-21 17:58:18 +00:00
// A hovered entity, with its location relative to the cursor.
class Hover {
public:
int zIndex;
double distance;
Selection selection;
};
List<Hover> hoverList;
Get rid of the command line from the text window; we'll say that's just for display, and any text entry will happen via some floating text box, same as entering a dimension on the sketch. Add the hover and selection mechanism, which now seems to work. Still not clear how to do imported parts, for assemblies and hierarchy. The handle formats may still have to change. [git-p4: depot-paths = "//depot/solvespace/": change = 1662]
2008-04-12 14:12:26 +00:00
Selection hover;
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
bool hoverWasSelectedOnMousedown;
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
List<Selection> selection;
Choose entities to select in a way appropriate for the operation. Before this commit, when an entity is clicked at or dragged, and it shares a place with other entities, which of them is selected is decided more or less at random. This is particularly annoying when dragging. After this commit, when clicking, an entity from the current group is given preference, and when dragging, an entity from a request is given preference. This allows e.g. dragging points of a sketch even when an extrusion of that sketch is active.
2016-07-21 17:58:18 +00:00
Selection ChooseFromHoverToSelect();
Selection ChooseFromHoverToDrag();
Add horizontal and vertical constraints. Those have their own 2d/3d issues, when the points are not all in the same coordinate system. All painful, of course. Also add continuous line drawing, and auto-constraining of line segments as I draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1683]
2008-04-23 07:29:19 +00:00
void HitTestMakeSelection(Point2d mp);
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void ClearSelection();
void ClearNonexistentSelectionItems();
Add the keyboard accelerator mechanism for menu items. Use that to implement zoom in/out, and orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1663]
2008-04-12 15:17:58 +00:00
struct {
Get rid of the MAX_SELECTED restriction in GroupSelection().
2016-08-13 05:20:43 +00:00
std::vector<hEntity> point;
std::vector<hEntity> entity;
std::vector<hEntity> anyNormal;
std::vector<hEntity> vector;
std::vector<hEntity> face;
std::vector<hConstraint> constraint;
Add the keyboard accelerator mechanism for menu items. Use that to implement zoom in/out, and orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1663]
2008-04-12 15:17:58 +00:00
int points;
int entities;
A great renaming. 2d coordinate systems are now called workplanes, and the associated entities are now just points. [git-p4: depot-paths = "//depot/solvespace/": change = 1690]
2008-04-27 03:26:27 +00:00
int workplanes;
Start to describe the selected entities in the text window. Also more starting work on the selectable faces, and fiddling in an attempt to remove dependencies when stuff gets deleted. [git-p4: depot-paths = "//depot/solvespace/": change = 1760]
2008-06-01 00:26:41 +00:00
int faces;
Now I can add a constraint (a length), and it's displayed on-screen, and I can drag the label. That's progress. Also implement a bunch of untested expression stuff, since I'll need that for the values of the dimensions, for example. [git-p4: depot-paths = "//depot/solvespace/": change = 1668]
2008-04-14 10:28:32 +00:00
int lineSegments;
Add a diameter constraint, and add a `distance' entity that I can remap when I copy circle entities, in order to make the radius numerical somehow (analogy with the POINT_ and NORMAL_XFRMD) thing. [git-p4: depot-paths = "//depot/solvespace/": change = 1710]
2008-05-07 08:19:37 +00:00
int circlesOrArcs;
Add tangency constraints, for line segments against arcs or cubics. These are just a convenience, since it would be possible to get the same result by drawing a construction line. [git-p4: depot-paths = "//depot/solvespace/": change = 1836]
2008-07-13 12:44:05 +00:00
int arcs;
int cubics;
Split cubic splines and periodic splines too; which is a pain, because it can't be C2 continuous after splitting (since I'm doing uniform splines only, and the parametrization changes). So just knock everything down to cubic Beziers. Also draw lines to indicate angle and origin when Ctrl+dragging to rotate in plane of screen. [git-p4: depot-paths = "//depot/solvespace/": change = 2075]
2009-11-10 03:57:24 +00:00
int periodicCubics;
Add parallel and same orientation constraints, that work on line segments and normals. [git-p4: depot-paths = "//depot/solvespace/": change = 1713]
2008-05-09 05:33:23 +00:00
int anyNormals;
int vectors;
Add angle constraints. I'm doing these differently from SketchFlat, as a constraint on the direction cosine, rather than driving the dot product against a rotated vector to zero. The drawing is the ugly part; to do that for skew lines, I gave up. Also add a function to clear non-existent items on the selection after solving, since that could have caused an oops(). [git-p4: depot-paths = "//depot/solvespace/": change = 1727]
2008-05-17 11:15:14 +00:00
int constraints;
Add ability to assign styles to cosmetic text (in the form of Constraint::COMMENTs), including line width and color, and text height and origin location. [git-p4: depot-paths = "//depot/solvespace/": change = 2033]
2009-09-24 15:52:48 +00:00
int stylables;
Allow snapping constraint labels to grid. This is pretty much the only way to get a sketch with tidily placed dimensions.
2016-04-18 06:40:42 +00:00
int constraintLabels;
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
int withEndpoints;
Add the keyboard accelerator mechanism for menu items. Use that to implement zoom in/out, and orient onto a csys. [git-p4: depot-paths = "//depot/solvespace/": change = 1663]
2008-04-12 15:17:58 +00:00
int n;
} gs;
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void GroupSelection();
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
bool IsSelected(Selection *s);
bool IsSelected(hEntity he);
void MakeSelected(hEntity he);
Allow copying and pasting constraints.
2016-05-20 14:19:50 +00:00
void MakeSelected(hConstraint hc);
Remove the toggle semantics from all the selection stuff. Now left-clicking always selects, and there's a special context menu item to deselect. Also streamline the right-click behavior by making that select the hovered item, and making all the context menu items work on the selection. [git-p4: depot-paths = "//depot/solvespace/": change = 2091]
2010-01-03 10:26:15 +00:00
void MakeSelected(Selection *s);
void MakeUnselected(hEntity he, bool coincidentPointTrick);
void MakeUnselected(Selection *s, bool coincidentPointTrick);
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void SelectByMarquee();
void ClearSuper();
Add angle constraints. I'm doing these differently from SketchFlat, as a constraint on the direction cosine, rather than driving the dot product against a rotated vector to zero. The drawing is the ugly part; to do that for skew lines, I gave up. Also add a function to clear non-existent items on the selection after solving, since that could have caused an oops(). [git-p4: depot-paths = "//depot/solvespace/": change = 1727]
2008-05-17 11:15:14 +00:00
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void ContextMenuListStyles();
Changed GetMilliseconds() to return a 64-bit value This function previously returned an int32_t. Presuming that it measures the length of time since the application was started, the 32-bit type would cause the returned value to wrap from 2^31-1 to -2^31 after a little less than twenty-five days.
2013-10-28 04:28:39 +00:00
int64_t contextMenuCancelTime;
Add a context menu, with a grab bag of options. That will need some refinement later, but it does not affect file formats so it's not very critical. [git-p4: depot-paths = "//depot/solvespace/": change = 2032]
2009-09-23 10:59:59 +00:00
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
// The toolbar, in toolbar.cpp
Abstract all (ex-OpenGL) drawing operations into a Canvas interface. This has several desirable consequences: * It is now possible to port SolveSpace to a later version of OpenGL, such as OpenGLES 2, so that it runs on platforms that only have that OpenGL version; * The majority of geometry is now rendered without references to the camera in C++ code, so a renderer can now submit it to the video card once and re-rasterize with a different projection matrix every time the projection is changed, avoiding expensive reuploads; * The DOGD (draw or get distance) interface is now a straightforward Canvas implementation; * There are no more direct references to SS.GW.(projection) in sketch rendering code, which allows rendering to multiple viewports; * There are no more unnecessary framebuffer flips on CPU on Cocoa and GTK; * The platform-dependent GL code is now confined to rendergl1.cpp. * The Microsoft and Apple headers required by it that are prone to identifier conflicts are no longer included globally; * The rendergl1.cpp implementation can now be omitted from compilation to run SolveSpace headless or with a different OpenGL version. Note these implementation details of Canvas: * GetCamera currently always returns a reference to the field `Camera camera;`. This is so that a future renderer that caches geometry in the video memory can define it as asserting, which would provide assurance against code that could accidentally put something projection-dependent in the cache; * Line and triangle rendering is specified through a level of indirection, hStroke and hFill. This is so that a future renderer that batches geometry could cheaply group identical styles. * DrawPixmap and DrawVectorText accept a (o,u,v) and not a matrix. This is so that a future renderer into an output format that uses 2d transforms (e.g. SVG) could easily derive those. Some additional internal changes were required to enable this: * Pixmap is now always passed as std::shared_ptr<{const ,}Pixmap>. This is so that the renderer could cache uploaded textures between API calls, which requires it to capture a (weak) reference. * The PlatformPathEqual function was properly extracted into platform-specific code. This is so that the <windows.h> header could be included only where needed (in platform/w32* as well as rendergl1.cpp). * The SBsp{2,3}::DebugDraw functions were removed. They can be rewritten using the Canvas API if they are ever needed. While no visual changes were originally intended, some minor fixes happened anyway: * The "emphasis" yellow line from top-left corner is now correctly rendered much wider. * The marquee rectangle is now pixel grid aligned. * The hidden entities now do not clobber the depth buffer, removing some minor artifacts. * The workplane "tab" now scales with the font used to render the workplane name. * The workplane name font is now taken from the normals style. * Workplane and constraint line stipple is insignificantly different. This is so that it can reuse the existing stipple codepaths; rendering of workplanes and constraints predates those. Some debug functionality was added: * In graphics window, an fps counter that becomes red when rendering under 60fps is drawn.
2016-05-31 00:55:13 +00:00
bool ToolbarDrawOrHitTest(int x, int y, UiCanvas *canvas, Command *menuHit);
void ToolbarDraw(UiCanvas *canvas);
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
bool ToolbarMouseMoved(int x, int y);
bool ToolbarMouseDown(int x, int y);
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
static void TimerCallback();
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
Command toolbarHovered;
Command toolbarTooltipped;
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
int toolbarMouseX, toolbarMouseY;
Start to use that text window a bit; user interface to show and hide things. [git-p4: depot-paths = "//depot/solvespace/": change = 1661]
2008-04-11 12:47:14 +00:00
// This sets what gets displayed.
A great renaming. 2d coordinate systems are now called workplanes, and the associated entities are now just points. [git-p4: depot-paths = "//depot/solvespace/": change = 1690]
2008-04-27 03:26:27 +00:00
bool showWorkplanes;
A big change, to add a concept of normals. These are "oriented vectors", represented by unit quaternions. This permits me to add circles, where the normal defines the plane of the circle. Still many things painful. The interface for editing normals is not so intuitive, and it's not yet clear how I would e.g. export a circle entity and recreate it properly, since that entity has a param not associated with a normal or point. And the transformed points/normals do not yet support rotations. That will be necessary soon. [git-p4: depot-paths = "//depot/solvespace/": change = 1705]
2008-05-05 06:18:01 +00:00
bool showNormals;
Start to use that text window a bit; user interface to show and hide things. [git-p4: depot-paths = "//depot/solvespace/": change = 1661]
2008-04-11 12:47:14 +00:00
bool showPoints;
bool showConstraints;
Standardize the behaviour of constraints, by assigning them a workplane: a free constraint works in three-space (e.g. true distance), and a constraint in a workplane works in that plane (e.g. projected distance). And make the solver go automatically, though solver itself has lots of pieces missing. [git-p4: depot-paths = "//depot/solvespace/": change = 1691]
2008-04-27 05:00:12 +00:00
bool showTextWindow;
Remove stupid "show any datum" link, and replace with a link to show/hide the mesh (drawn as wireframe triangles). [git-p4: depot-paths = "//depot/solvespace/": change = 1754]
2008-05-28 10:34:55 +00:00
bool showShaded;
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
bool showEdges;
Allow rendering solid outlines using a distinct style. A new button is added, "Show/hide outline of solid model". When the outline is hidden, it is rendered using the "solid edge" style. When the outline is shown, it is rendered using the "outline" style. In SolveSpace's true WYSIWYG tradition, the 2d view export follows the rendered view exactly. Moreover, shell edges are not rendered anymore, since there is not much need in them anymore and not drawing them lessens the overlap between various kinds of lines, which already includes entities, solid edges and outlines.
2016-03-14 16:14:24 +00:00
bool showOutlines;
Stipple the selected/hovered faces, instead of drawing them in solid red or yellow. And add user interface to `hide' the faces (i.e., to make them unselectable), defaulting to hidden in everything except extrudes or imports. [git-p4: depot-paths = "//depot/solvespace/": change = 1768]
2008-06-02 05:38:12 +00:00
bool showFaces;
Remove stupid "show any datum" link, and replace with a link to show/hide the mesh (drawn as wireframe triangles). [git-p4: depot-paths = "//depot/solvespace/": change = 1754]
2008-05-28 10:34:55 +00:00
bool showMesh;
Replace ugly text links to hide/show things with icons. So add code to draw those, and hit test with the mouse, and display tool tips when the user hovers with the mouse. Also, underline links only when they're hovered, and not otherwise. And add a separate menu option to align the view to the active workplane, vs. activating the active group's workplane, and remap the bottom two graphics window toolbar icons to that and "nearest iso view" instead of draw in 2d/3d, since people tended to click on those without understanding and cause trouble. And by default, we force a parallel projection; so the factory default camera tangent is now 0.3, not 0. [git-p4: depot-paths = "//depot/solvespace/": change = 2131]
2010-05-03 05:04:42 +00:00
void ToggleBool(bool *v);
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
Make "Show/hide hidden lines" a tri-state button instead. The states are: * Draw all lines (on top of shaded mesh). * Draw occluded (by shaded mesh) lines as stippled. * Do not draw occluded (by shaded mesh) lines. As usual, the export output follows the screen output.
2016-08-13 09:02:12 +00:00
enum class DrawOccludedAs { INVISIBLE, STIPPLED, VISIBLE };
DrawOccludedAs drawOccludedAs;
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
bool showSnapGrid;
Abstract all (ex-OpenGL) drawing operations into a Canvas interface. This has several desirable consequences: * It is now possible to port SolveSpace to a later version of OpenGL, such as OpenGLES 2, so that it runs on platforms that only have that OpenGL version; * The majority of geometry is now rendered without references to the camera in C++ code, so a renderer can now submit it to the video card once and re-rasterize with a different projection matrix every time the projection is changed, avoiding expensive reuploads; * The DOGD (draw or get distance) interface is now a straightforward Canvas implementation; * There are no more direct references to SS.GW.(projection) in sketch rendering code, which allows rendering to multiple viewports; * There are no more unnecessary framebuffer flips on CPU on Cocoa and GTK; * The platform-dependent GL code is now confined to rendergl1.cpp. * The Microsoft and Apple headers required by it that are prone to identifier conflicts are no longer included globally; * The rendergl1.cpp implementation can now be omitted from compilation to run SolveSpace headless or with a different OpenGL version. Note these implementation details of Canvas: * GetCamera currently always returns a reference to the field `Camera camera;`. This is so that a future renderer that caches geometry in the video memory can define it as asserting, which would provide assurance against code that could accidentally put something projection-dependent in the cache; * Line and triangle rendering is specified through a level of indirection, hStroke and hFill. This is so that a future renderer that batches geometry could cheaply group identical styles. * DrawPixmap and DrawVectorText accept a (o,u,v) and not a matrix. This is so that a future renderer into an output format that uses 2d transforms (e.g. SVG) could easily derive those. Some additional internal changes were required to enable this: * Pixmap is now always passed as std::shared_ptr<{const ,}Pixmap>. This is so that the renderer could cache uploaded textures between API calls, which requires it to capture a (weak) reference. * The PlatformPathEqual function was properly extracted into platform-specific code. This is so that the <windows.h> header could be included only where needed (in platform/w32* as well as rendergl1.cpp). * The SBsp{2,3}::DebugDraw functions were removed. They can be rewritten using the Canvas API if they are ever needed. While no visual changes were originally intended, some minor fixes happened anyway: * The "emphasis" yellow line from top-left corner is now correctly rendered much wider. * The marquee rectangle is now pixel grid aligned. * The hidden entities now do not clobber the depth buffer, removing some minor artifacts. * The workplane "tab" now scales with the font used to render the workplane name. * The workplane name font is now taken from the normals style. * Workplane and constraint line stipple is insignificantly different. This is so that it can reuse the existing stipple codepaths; rendering of workplanes and constraints predates those. Some debug functionality was added: * In graphics window, an fps counter that becomes red when rendering under 60fps is drawn.
2016-05-31 00:55:13 +00:00
void DrawSnapGrid(Canvas *canvas);
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
Remove arbitrary limits on the selection size, and permit more than one point to be dragged simultaneously. So now a dragged point drags all the selected points and entities, and a dragged entity drags its points (except for circles, which drag the radius). This means that the number of forced points for the solver must now be unlimited, and it is. Also add commands to invert the selection within the active group, and to select an edge chain starting from the current selection. And redo the context menus a bit; still not great, but less cluttered and more systematic. [git-p4: depot-paths = "//depot/solvespace/": change = 2064]
2009-11-03 18:54:49 +00:00
void AddPointToDraggedList(hEntity hp);
void StartDraggingByEntity(hEntity he);
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void StartDraggingBySelection();
A big change, to add a concept of normals. These are "oriented vectors", represented by unit quaternions. This permits me to add circles, where the normal defines the plane of the circle. Still many things painful. The interface for editing normals is not so intuitive, and it's not yet clear how I would e.g. export a circle entity and recreate it properly, since that entity has a param not associated with a normal or point. And the transformed points/normals do not yet support rotations. That will be necessary soon. [git-p4: depot-paths = "//depot/solvespace/": change = 1705]
2008-05-05 06:18:01 +00:00
void UpdateDraggedNum(Vector *pos, double mx, double my);
void UpdateDraggedPoint(hEntity hp, double mx, double my);
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
Add an interface for view-independent rendering. To actually achieve improved performance with the OpenGL 2 renderer, we have to cache geometry that doesn't change when the viewport does (note that the rendered pixels can change quite dramatically because we can reconfigure shaders; e.g. stippling can be drawn in screen coordinates). This commit adds a BatchCanvas interface that can be implemented by renderers, and uses it for drawing entities such as lines and points.
2016-06-30 15:54:35 +00:00
void DrawEntities(Canvas *canvas, bool persistent);
Abstract all (ex-OpenGL) drawing operations into a Canvas interface. This has several desirable consequences: * It is now possible to port SolveSpace to a later version of OpenGL, such as OpenGLES 2, so that it runs on platforms that only have that OpenGL version; * The majority of geometry is now rendered without references to the camera in C++ code, so a renderer can now submit it to the video card once and re-rasterize with a different projection matrix every time the projection is changed, avoiding expensive reuploads; * The DOGD (draw or get distance) interface is now a straightforward Canvas implementation; * There are no more direct references to SS.GW.(projection) in sketch rendering code, which allows rendering to multiple viewports; * There are no more unnecessary framebuffer flips on CPU on Cocoa and GTK; * The platform-dependent GL code is now confined to rendergl1.cpp. * The Microsoft and Apple headers required by it that are prone to identifier conflicts are no longer included globally; * The rendergl1.cpp implementation can now be omitted from compilation to run SolveSpace headless or with a different OpenGL version. Note these implementation details of Canvas: * GetCamera currently always returns a reference to the field `Camera camera;`. This is so that a future renderer that caches geometry in the video memory can define it as asserting, which would provide assurance against code that could accidentally put something projection-dependent in the cache; * Line and triangle rendering is specified through a level of indirection, hStroke and hFill. This is so that a future renderer that batches geometry could cheaply group identical styles. * DrawPixmap and DrawVectorText accept a (o,u,v) and not a matrix. This is so that a future renderer into an output format that uses 2d transforms (e.g. SVG) could easily derive those. Some additional internal changes were required to enable this: * Pixmap is now always passed as std::shared_ptr<{const ,}Pixmap>. This is so that the renderer could cache uploaded textures between API calls, which requires it to capture a (weak) reference. * The PlatformPathEqual function was properly extracted into platform-specific code. This is so that the <windows.h> header could be included only where needed (in platform/w32* as well as rendergl1.cpp). * The SBsp{2,3}::DebugDraw functions were removed. They can be rewritten using the Canvas API if they are ever needed. While no visual changes were originally intended, some minor fixes happened anyway: * The "emphasis" yellow line from top-left corner is now correctly rendered much wider. * The marquee rectangle is now pixel grid aligned. * The hidden entities now do not clobber the depth buffer, removing some minor artifacts. * The workplane "tab" now scales with the font used to render the workplane name. * The workplane name font is now taken from the normals style. * Workplane and constraint line stipple is insignificantly different. This is so that it can reuse the existing stipple codepaths; rendering of workplanes and constraints predates those. Some debug functionality was added: * In graphics window, an fps counter that becomes red when rendering under 60fps is drawn.
2016-05-31 00:55:13 +00:00
void DrawPersistent(Canvas *canvas);
void Draw(Canvas *canvas);
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
// These are called by the platform-specific code.
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void Paint();
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
void MouseMoved(double x, double y, bool leftDown, bool middleDown,
Start to add OpenGL support to SolveSpace, for the graphical view. I've got the user interface to pan and rotate an object, more or less works. [git-p4: depot-paths = "//depot/solvespace/": change = 1654]
2008-03-27 09:53:51 +00:00
bool rightDown, bool shiftDown, bool ctrlDown);
void MouseLeftDown(double x, double y);
Some graphics tweaks, to the order in which stuff gets drawn, to determine what goes in front (e.g. put a drawn line in front of the reference plane, even if the z order would want the opposite), and some tweaks to the mouse behaviour, and a function to modify constraints like dimensions so that the are initially satisfied. [git-p4: depot-paths = "//depot/solvespace/": change = 1681]
2008-04-22 10:53:42 +00:00
void MouseLeftUp(double x, double y);
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
void MouseLeftDoubleClick(double x, double y);
Add routines to remove T intersections from the mesh, which are introduced by the bsp routines. It's usually, though not always, possible to generate a watertight mesh. The occasions where it's not look ugly, floating point issues, no quick fix. And use those to generate a list of edges where two different faces meet, which I can emphasize for cosmetic reasons (and some UI to specify whether to do that, and with what color). And make the right mouse button rotate the model, since that was previously doing nothing. [git-p4: depot-paths = "//depot/solvespace/": change = 1821]
2008-07-06 07:56:24 +00:00
void MouseMiddleOrRightDown(double x, double y);
Add a context menu, with a grab bag of options. That will need some refinement later, but it does not affect file formats so it's not very critical. [git-p4: depot-paths = "//depot/solvespace/": change = 2032]
2009-09-23 10:59:59 +00:00
void MouseRightUp(double x, double y);
Bits and pieces of SolveSpace; zoom works now, and some stuff to draw planes that I will use to do the datum planes. Still haven't settled upon the request/entity/group structure, and that's the dependency before doing much real. [git-p4: depot-paths = "//depot/solvespace/": change = 1656]
2008-04-01 10:48:44 +00:00
void MouseScroll(double x, double y, int delta);
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void MouseLeave();
Treat delete, backspace, and browser back all identically. [git-p4: depot-paths = "//depot/solvespace/": change = 2036]
2009-09-28 10:01:34 +00:00
bool KeyDown(int c);
Added const qualifiers to edit-control string handling FLTK's Fl_Input widget, instantiated as {Graphics,Text}EditControl, returns a 'const char *' string. In order to handle this properly, several of SolveSpace's internal routines needed to gain a "const" qualifier on the edit-control string argument.
2013-09-16 19:51:20 +00:00
void EditControlDone(const char *s);
Add support for the 3dconnexion six degree of freedom input devices (in my case, a SpaceNavigator). I can transform the view of the part, or transform a part in an assembly. Also fix up mouse wheel input, so that it works even if it comes in chunks of less than 120 units. [git-p4: depot-paths = "//depot/solvespace/": change = 2019]
2009-07-20 19:05:33 +00:00
Changed GetMilliseconds() to return a 64-bit value This function previously returned an int32_t. Presuming that it measures the length of time since the application was started, the 32-bit type would cause the returned value to wrap from 2^31-1 to -2^31 after a little less than twenty-five days.
2013-10-28 04:28:39 +00:00
int64_t lastSpaceNavigatorTime;
Add support for the 3dconnexion six degree of freedom input devices (in my case, a SpaceNavigator). I can transform the view of the part, or transform a part in an assembly. Also fix up mouse wheel input, so that it works even if it comes in chunks of less than 120 units. [git-p4: depot-paths = "//depot/solvespace/": change = 2019]
2009-07-20 19:05:33 +00:00
hGroup lastSpaceNavigatorGroup;
void SpaceNavigatorMoved(double tx, double ty, double tz,
double rx, double ry, double rz, bool shiftDown);
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void SpaceNavigatorButtonUp();
Add hyperlink and colour support to the text window. Don't redraw the text window every time we refresh the graphics window, because that's slow. Use classes instead of structs for everything; I don't understand the template handling for structs. And implement the IdList, which I will try to use in many places. [git-p4: depot-paths = "//depot/solvespace/": change = 1655]
2008-03-28 10:00:37 +00:00
};
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
More fragments of SolveSpace work. Improve the command line window, and add some (non-functional) menus to the graphics window. Start to rough in some data structures to hold the sketch. No real work yet, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1653]
2008-03-26 09:18:12 +00:00
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
#endif