Further progress on Polylines: Polylines can be selected and moved.

[architektonas] / src / structs.h

diff --git a/src/structs.h b/src/structs.h
index b9f6e9b9bcf78a32c10ddbb269f854c759b14d75..e7e7b30643ffa82465922fe2fdc3fead7d6a61cb 100644 (file)
--- a/src/structs.h
+++ b/src/structs.h
@@ -2,63 +2,136 @@
 #define __STRUCTS_H__
 
 #include <stdint.h>
-#include <vector>
 #include <string>
+#include <vector>
+#include "global.h"
+#include "rect.h"
 #include "vector.h"
 
+enum ObjectType { OTNone = 0, OTLine, OTCircle, OTEllipse, OTArc, OTDimension, OTPolyline, OTSpline, OTText, OTContainer, OTCount };
+
+enum DimensionType { DTLinear = 0, DTLinearVert, DTLinearHorz, DTRadial, DTDiametric, DTCircumferential, DTAngular, DTLeader, DTCount };
+
+enum ToolType { TTNone, TTLine, TTCircle, TTEllipse, TTArc, TTDimension, TTText, TTPolygon, TTSpline, TTRotate, TTMirror, TTTrim, TTTriangulate, TTDelete, TTParallel };
+
+enum ToolState { TSNone, TSPoint1, TSPoint2, TSPoint3, TSPoint4, TSDone };
+
+enum BasicUnit { BUInch = 0, BUFoot, BUYard, BUMile, BUMM, BUCM, BUM, BUKM, BUCount };
+
+extern const char objName[OTCount][16];
+extern const char dimName[DTCount][32];
+extern const char buShortName[BUCount][8];
+extern const double buInInches[BUCount];
+
 #define OBJECT_COMMON \
-       int type;       \
-       uint32_t id;    \
-       int layer;      \
-       uint32_t color; \
-       float thickness;
+       int type;         \
+       uint32_t id;      \
+       int layer;        \
+       uint32_t color;   \
+       float thickness;  \
+       int style;        \
+       bool selected;    \
+       bool hovered;     \
+       bool hitPoint[5]; \
+       bool hitObject;   \
+       Point p[5];       \
+       double angle[3];  \
+       double radius[2]; \
+       double length;
+
+struct Object {
+       OBJECT_COMMON;
+};
 
 struct Line {
        OBJECT_COMMON;
-       Point p1;
-       Point p2;
+
+       Line();
+       Line(Vector pt1, Vector pt2, float th = 1.0, uint32_t c = 0, int l = LSSolid);
+       Vector Vect(void);
+       Vector Unit(void);
+       double Length(void);
 };
 
 struct Circle {
        OBJECT_COMMON;
-       Point p1;
-       double radius;
+
+       Circle();
+       Circle(Vector pt1, double r, float th = 1.0, uint32_t c = 0, int l = LSSolid);
+};
+
+struct Ellipse {
+       OBJECT_COMMON;
+
+       Ellipse();
+       Ellipse(Vector pt1, Vector pt2, double r1, double r2, float th = 1.0, uint32_t c = 0, int l = LSSolid);
 };
 
 struct Arc {
        OBJECT_COMMON;
-       Point p1;
-       double radius;
-       double angle1;
-       double angle2;
+
+       Arc();
+       Arc(Vector pt1, double r, double a1, double a2, float th = 1.0, uint32_t c = 0, int l = LSSolid);
+       Rect Bounds(void);
+};
+
+struct Dimension {
+       OBJECT_COMMON;
+       int subtype;
+       double offset;
+       Point lp[2];            // Line point, the actual dimension line
+       Object * obj[2];        // Pointer to attached objects (circle, lines for angle)
+
+       Dimension();
+       Dimension(Vector pt1, Vector pt2, DimensionType dt = DTLinear, double offs = 0, float th = 1.0, uint32_t c = 0x0000FF, int l = LSSolid);
 };
 
 struct Text {
        OBJECT_COMMON;
-       Point p1;
+       Rect extents;
+       bool measured;
        std::string s;
+
+       Text();
+       Text(Vector pt1, const char * str, float th = 10.0, uint32_t c = 0);
 };
 
-struct Container {
+struct Polyline {
        OBJECT_COMMON;
-       Point p1;
-       std::vector<void *> objects;
-       double angle;
-       double scale;
+       std::vector<Point> points;
+//     bool closed; //need this?  could just repeat the endpoint as well...
+//     Object * clicked;
+       int ptNum;
+
+       Polyline(float th = 1.0, uint32_t c = 0, int l = LSSolid);
+       Polyline(std::vector<Point>, float th = 1.0, uint32_t c = 0, int l = LSSolid);
+       void Add(Point);
+       void Add(std::vector<Point>);
+       Rect Bounds(void);
+       void Translate(Point);
 };
 
-struct Dimension {
+struct Spline {
        OBJECT_COMMON;
-       int subtype;
-       Point p1;
-       Point p2;
-       double offset;
+
+       Spline();
 };
 
-struct Object {
+struct Container {
        OBJECT_COMMON;
-};
+       VPVector objects;
+       double scale;
+       bool topLevel;
+       Object * clicked;
 
+       int baseUnit;            // Type of BasicUnit as seen above
+       int unitStyle;           // 0 = decimal, 1 = fractional
+       int decimalPrecision;    // 0-5, which, +1, is # of decimal places
+       int fractionalPrecision; // 0-5, which, +1, is 1/(2^n)
 
-#endif // __STRUCTS_H__
+       Container(bool tl = false);
+       void Add(void * obj);
+       void Add(VPVector objs);
+};
 
+#endif // __STRUCTS_H__