HEADERS = \
src/about.h \
- src/action.h \
src/applicationwindow.h \
- src/arc.h \
src/baseunittab.h \
src/blockitemwidget.h \
src/blockwidget.h \
- src/circle.h \
- src/connection.h \
- src/container.h \
- src/dimension.h \
src/drawingview.h \
- src/drawarcaction.h \
- src/drawcircleaction.h \
- src/drawdimensionaction.h \
- src/drawlineaction.h \
- src/drawsplineaction.h \
- src/drawtextaction.h \
- src/ellipse.h \
src/fileio.h \
src/generaltab.h \
- src/geometry.h \
+ src/global.h \
src/layerwidget.h \
src/layeritemwidget.h \
- src/line.h \
src/main.h \
- src/mirroraction.h \
src/mathconstants.h \
- src/object.h \
src/painter.h \
- src/rotateaction.h \
src/settingsdialog.h \
- src/spline.h \
- src/text.h \
- src/triangulateaction.h \
- src/trimaction.h \
+ src/structs.h \
src/vector.h
+# src/action.h \
+# src/arc.h \
+# src/circle.h \
+# src/connection.h \
+# src/container.h \
+# src/dimension.h \
+# src/drawarcaction.h \
+# src/drawcircleaction.h \
+# src/drawdimensionaction.h \
+# src/drawlineaction.h \
+# src/drawsplineaction.h \
+# src/drawtextaction.h \
+# src/ellipse.h \
+# src/geometry.h \
+# src/line.h \
+# src/mirroraction.h \
+# src/object.h \
+# src/rotateaction.h \
+# src/spline.h \
+# src/text.h \
+# src/triangulateaction.h \
+# src/trimaction.h \
+
+
SOURCES = \
src/about.cpp \
- src/action.cpp \
src/applicationwindow.cpp \
- src/arc.cpp \
src/baseunittab.cpp \
src/blockitemwidget.cpp \
src/blockwidget.cpp \
- src/circle.cpp \
- src/connection.cpp \
- src/container.cpp \
- src/dimension.cpp \
src/drawingview.cpp \
- src/drawarcaction.cpp \
- src/drawcircleaction.cpp \
- src/drawdimensionaction.cpp \
- src/drawlineaction.cpp \
- src/drawsplineaction.cpp \
- src/drawtextaction.cpp \
- src/ellipse.cpp \
src/fileio.cpp \
src/generaltab.cpp \
- src/geometry.cpp \
+ src/global.cpp \
src/layerwidget.cpp \
src/layeritemwidget.cpp \
- src/line.cpp \
src/main.cpp \
- src/mirroraction.cpp \
- src/object.cpp \
src/painter.cpp \
- src/rotateaction.cpp \
src/settingsdialog.cpp \
- src/spline.cpp \
- src/text.cpp \
- src/triangulateaction.cpp \
- src/trimaction.cpp \
src/vector.cpp
+# src/action.cpp \
+# src/arc.cpp \
+# src/circle.cpp \
+# src/connection.cpp \
+# src/container.cpp \
+# src/dimension.cpp \
+# src/drawarcaction.cpp \
+# src/drawcircleaction.cpp \
+# src/drawdimensionaction.cpp \
+# src/drawlineaction.cpp \
+# src/drawsplineaction.cpp \
+# src/drawtextaction.cpp \
+# src/ellipse.cpp \
+# src/geometry.cpp \
+# src/line.cpp \
+# src/mirroraction.cpp \
+# src/object.cpp \
+# src/rotateaction.cpp \
+# src/spline.cpp \
+# src/text.cpp \
+# src/triangulateaction.cpp \
+# src/trimaction.cpp \
+
//
#include "about.h"
+//testing... #include "structs.h"
+
AboutWindow::AboutWindow(QWidget * parent/*= 0*/): QWidget(parent, Qt::Dialog)
{
#include "about.h"
#include "blockwidget.h"
-#include "dimension.h"
+//#include "dimension.h"
#include "drawingview.h"
-#include "drawarcaction.h"
-#include "drawcircleaction.h"
-#include "drawdimensionaction.h"
-#include "drawlineaction.h"
-#include "drawsplineaction.h"
+//#include "drawarcaction.h"
+//#include "drawcircleaction.h"
+//#include "drawdimensionaction.h"
+//#include "drawlineaction.h"
+//#include "drawsplineaction.h"
#include "fileio.h"
#include "generaltab.h"
-#include "geometry.h"
+//#include "geometry.h"
+#include "global.h"
#include "layerwidget.h"
-#include "line.h"
-#include "mirroraction.h"
+//#include "line.h"
+//#include "mirroraction.h"
#include "painter.h"
-#include "rotateaction.h"
+//#include "rotateaction.h"
#include "settingsdialog.h"
-#include "triangulateaction.h"
-#include "trimaction.h"
+//#include "triangulateaction.h"
+//#include "trimaction.h"
// Class variables
ReadSettings();
setUnifiedTitleAndToolBarOnMac(true);
- Object::SetFont(new QFont("Verdana", 15, QFont::Bold));
+ Global::font = new QFont("Verdana", 15, QFont::Bold);
connect(lw, SIGNAL(LayerSelected(int)), drawing, SLOT(SetCurrentLayer(int)));
}
void ApplicationWindow::FileNew(void)
{
// Should warn the user if drawing hasn't been saved...
- drawing->document.Clear();
+// drawing->document.Clear();
+ drawing->document.objects.empty();
drawing->update();
documentName.clear();
setWindowTitle("Architektonas - Untitled");
return;
}
- Container container(Vector(0, 0));
+ Container container;//(Vector(0, 0));
bool successful = FileIO::LoadAtnsFile(file, &container);
fclose(file);
void ApplicationWindow::SnapToGridTool(void)
{
- Object::SetSnapMode(snapToGridAct->isChecked());
+ Global::snapToGrid = snapToGridAct->isChecked();
}
void ApplicationWindow::FixAngle(void)
{
- Object::SetFixedAngle(fixAngleAct->isChecked());
+ Global::fixedAngle = fixAngleAct->isChecked();
}
void ApplicationWindow::FixLength(void)
{
- Object::SetFixedLength(fixLengthAct->isChecked());
+ Global::fixedLength = fixLengthAct->isChecked();
}
{
// For this tool, we check first to see if anything is selected. If so, we
// delete those and *don't* select the delete tool.
+#if 0
if (drawing->document.ItemsSelected() > 0)
{
drawing->document.DeleteSelectedItems();
deleteAct->setChecked(false);
return;
}
+#endif
// Otherwise, toggle the state of the tool
ClearUIToolStatesExcept(deleteAct);
// This just zooms leaving origin intact... should zoom in at the current
// center! [DONE]
Painter::zoom *= zoomFactor;
- Object::gridSpacing = drawing->gridPixels / Painter::zoom;
+ Global::gridSpacing = drawing->gridPixels / Painter::zoom;
drawing->UpdateGridBackground();
drawing->update();
- zoomIndicator->setText(QString("Grid: %1\", BU: Inch").arg(Object::gridSpacing));
- baseUnitInput->setText(QString("%1").arg(Object::gridSpacing));
+ zoomIndicator->setText(QString("Grid: %1\", BU: Inch").arg(Global::gridSpacing));
+ baseUnitInput->setText(QString("%1").arg(Global::gridSpacing));
}
// This just zooms leaving origin intact... should zoom out at the current
// center! [DONE]
Painter::zoom /= zoomFactor;
- Object::gridSpacing = drawing->gridPixels / Painter::zoom;
+ Global::gridSpacing = drawing->gridPixels / Painter::zoom;
drawing->UpdateGridBackground();
drawing->update();
- zoomIndicator->setText(QString("Grid: %1\", BU: Inch").arg(Object::gridSpacing));
- baseUnitInput->setText(QString("%1").arg(Object::gridSpacing));
+ zoomIndicator->setText(QString("Grid: %1\", BU: Inch").arg(Global::gridSpacing));
+ baseUnitInput->setText(QString("%1").arg(Global::gridSpacing));
}
void ApplicationWindow::SetInternalToolStates(void)
{
- Object::SetDeleteActive(deleteAct->isChecked());
- Object::SetDimensionActive(addDimensionAct->isChecked());
+ Global::deleteActive = deleteAct->isChecked();
+ Global::dimensionActive = addDimensionAct->isChecked();
// We can be sure that if we've come here, then either an active tool is
// being deactivated, or a new tool is being created. In either case, the
// old tool needs to be deleted.
+#if 0
if (drawing->toolAction)
{
delete drawing->toolAction;
drawing->toolAction = NULL;
- Object::ignoreClicks = false;
+ Global::ignoreClicks = false;
}
drawing->SetToolActive(addLineAct->isChecked() ? new DrawLineAction() : NULL);
drawing->SetToolActive(triangulateAct->isChecked() ? new TriangulateAction() : NULL);
if (drawing->toolAction)
- Object::ignoreClicks = true;
+ Global::ignoreClicks = true;
+#endif
drawing->update();
}
//
void ApplicationWindow::HandleGrouping(void)
{
+#if 0
int itemsSelected = drawing->document.ItemsSelected();
// If nothing selected, do nothing
container->state = OSSelected;
statusBar()->showMessage(QString(tr("Grouped %1 objects.")).arg(itemsSelected));
}
+#endif
drawing->update();
}
void ApplicationWindow::HandleConnection(void)
{
+#if 0
//double tt = Geometry::ParameterOfLineAndPoint(Vector(0, 0), Vector(10, 0), Vector(8, 2));
//printf("Parameter of point @ (8,2) of line (0,0), (10,0): %lf\n", tt);
int itemsSelected = drawing->document.ItemsSelected();
}
}
}
+#endif
}
// drawing->gridSpacing = value;
// Painter::zoom = drawing->gridPixels / drawing->gridSpacing;
- Object::gridSpacing = value;
- Painter::zoom = drawing->gridPixels / Object::gridSpacing;
+ Global::gridSpacing = value;
+ Painter::zoom = drawing->gridPixels / Global::gridSpacing;
drawing->UpdateGridBackground();
drawing->update();
}
if (!ok || value == 0)
return;
- drawing->document.ResizeAllDimensions(value);
-// drawing->gridSpacing = value;
-// Painter::zoom = drawing->gridPixels / drawing->gridSpacing;
-// drawing->UpdateGridBackground();
+// drawing->document.ResizeAllDimensions(value);
drawing->update();
}
// Forward declarations
-//class EditWindow;
-//class CharWindow;
class AboutWindow;
class DrawingView;
class QLabel;
};
#endif // __APPLICATIONWINDOW_H__
+
#include <stdint.h>
#include "mathconstants.h"
-#include "arc.h"
-#include "circle.h"
-#include "dimension.h"
-#include "geometry.h"
-#include "line.h"
+//#include "arc.h"
+//#include "circle.h"
+//#include "dimension.h"
+//#include "geometry.h"
+//#include "line.h"
+#include "global.h"
#include "painter.h"
// The value in the settings file will override this.
useAntialiasing(true),
gridBackground(BACKGROUND_MAX_SIZE, BACKGROUND_MAX_SIZE),
- scale(1.0), offsetX(-10), offsetY(-10), document(Vector(0, 0)),
- gridPixels(0), collided(false), toolAction(NULL)
+ scale(1.0), offsetX(-10), offsetY(-10),// document(Vector(0, 0)),
+ gridPixels(0), collided(false)//, toolAction(NULL)
{
- document.isTopLevelContainer = true;
+// document.isTopLevelContainer = true;
+//wtf? doesn't work except in c++11??? document = { 0 };
setBackgroundRole(QPalette::Base);
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
- Object::gridSpacing = 12.0; // In base units (inch is default)
+ Global::gridSpacing = 12.0; // In base units (inch is default)
+#if 0
Line * line = new Line(Vector(5, 5), Vector(50, 40), &document);
document.Add(line);
document.Add(new Line(Vector(50, 40), Vector(10, 83), &document));
// Alternate way to do the above...
line->SetDimensionOnLine();
#endif
+#endif
/*
Here we set the grid size in pixels--12 in this case. Initially, we have our
Really, the 100% zoom level can be set at *any* zoom level, it's more of a
convenience function than any measure of absolutes. Doing things that way we
could rid ourselves of the whole SCREEN_ZOOM parameter and all the attendant
-shittyness that comes with it.
+shittiness that comes with it.
However, it seems that SCREEN_ZOOM is used to make text and arrow sizes show up
a certain way, which means we should probably create something else in those
}
+#if 0
void DrawingView::SetToolActive(Action * action)
{
if (action != NULL)
connect(toolAction, SIGNAL(NeedRefresh()), this, SLOT(HandleActionUpdate()));
}
}
+#endif
void DrawingView::SetGridSize(uint32_t size)
// Set up new BG brush & zoom level (pixels per base unit)
// Painter::zoom = gridPixels / gridSpacing;
- Painter::zoom = gridPixels / Object::gridSpacing;
+ Painter::zoom = gridPixels / Global::gridSpacing;
UpdateGridBackground();
}
{
if (object)
{
- object->Reparent(&document);
- document.Add(object);
+// object->Reparent(&document);
+// document.Add(object);
update();
}
//printf("DrawingView::AddNewObjectToDocument(). object=%08X\n", object);
void DrawingView::SetCurrentLayer(int layer)
{
- Object::currentLayer = layer;
+ Global::currentLayer = layer;
//printf("DrawingView::CurrentLayer = %i\n", layer);
}
if (useAntialiasing)
qtPainter.setRenderHint(QPainter::Antialiasing);
- Object::SetViewportHeight(size().height());
+ Global::viewportHeight = size().height();
// Draw coordinate axes
painter.SetPen(QPen(Qt::blue, 1.0, Qt::DotLine));
painter.DrawLine(-16384, 0, 16384, 0);
// The top level document takes care of rendering for us...
- document.Draw(&painter);
+// document.Draw(&painter);
+#if 0
if (toolAction)
{
painter.SetPen(QPen(QColor(200, 100, 0, 255), 1.0, Qt::DashLine));
painter.DrawCrosshair(oldPoint);
toolAction->Draw(&painter);
}
+#endif
- if (Object::selectionInProgress)
+#if 1
+ if (Global::selectionInProgress)
{
painter.SetPen(QPen(QColor(255, 127, 0, 255)));
painter.SetBrush(QBrush(QColor(255, 127, 0, 100)));
- painter.DrawRect(Object::selection);
+ painter.DrawRect(Global::selection);
}
+#endif
}
if (event->button() == Qt::LeftButton)
{
Vector point = Painter::QtToCartesianCoords(Vector(event->x(), event->y()));
- collided = document.Collided(point);
+// collided = document.Collided(point);
+ collided = false;
// Do an update if collided with at least *one* object in the document
- if (collided)
- update();
+// if (collided)
+// update();
+#if 0
if (toolAction)
{
- if (Object::snapToGrid)
- point = Object::SnapPointToGrid(point);
+ if (Global::snapToGrid)
+ point = Global::SnapPointToGrid(point);
// We always snap to object points, and they take precendence over
// grid points...
- if (Object::snapPointIsValid)
- point = Object::snapPoint;
+ if (Global::snapPointIsValid)
+ point = Global::snapPoint;
toolAction->MouseDown(point);
}
+#endif
+#if 1
// Didn't hit any object and not using a tool, so do a selection rectangle
- if (!(collided || toolAction))
+ if (!(collided))// || toolAction))
{
- Object::selectionInProgress = true;
- Object::selection.setTopLeft(QPointF(point.x, point.y));
- Object::selection.setBottomRight(QPointF(point.x, point.y));
+ Global::selectionInProgress = true;
+ Global::selection.setTopLeft(QPointF(point.x, point.y));
+ Global::selection.setBottomRight(QPointF(point.x, point.y));
}
+#endif
}
else if (event->button() == Qt::MiddleButton)
{
void DrawingView::mouseMoveEvent(QMouseEvent * event)
{
Vector point = Painter::QtToCartesianCoords(Vector(event->x(), event->y()));
- Object::selection.setBottomRight(QPointF(point.x, point.y));
+ Global::selection.setBottomRight(QPointF(point.x, point.y));
// Only needs to be done here, as mouse down is always preceded by movement
- Object::snapPointIsValid = false;
+ Global::snapPointIsValid = false;
// Scrolling...
if (event->buttons() & Qt::MiddleButton)
return;
}
-#if 0
+#if 1
// Grid processing... (only snap here is left button is down)
- if ((event->buttons() & Qt::LeftButton) && Object::snapToGrid)
+ if ((event->buttons() & Qt::LeftButton) && Global::snapToGrid)
{
- point = Object::SnapPointToGrid(point);
+ point = SnapPointToGrid(point);
}
// Snap points on objects always take precedence over the grid, whether
// dragging an object or not...
//thisnowok
- if (Object::snapPointIsValid)
+ if (Global::snapPointIsValid)
{
// Uncommenting this causes the cursor to become unresponsive after the first
// object is added.
-// point = Object::snapPoint;
+// point = Global::snapPoint;
}
#endif
//we should keep track of the last point here and only pass this down *if* the point
//changed...
+#if 0
// This returns true if we've moved over an object...
if (document.PointerMoved(point))
{
if (n == 1)
{
- Object::snapPoint = document.lastObjectHovered->GetPointAtParameter(t);
- Object::snapPointIsValid = true;
+ Global::snapPoint = document.lastObjectHovered->GetPointAtParameter(t);
+ Global::snapPointIsValid = true;
}
}
else if ((document.lastObjectHovered->type == OTCircle) && (document.penultimateObjectHovered->type == OTCircle))
if (n == 1)
{
- Object::snapPoint = p1;
- Object::snapPointIsValid = true;
+ Global::snapPoint = p1;
+ Global::snapPointIsValid = true;
}
else if (n == 2)
{
double d2 = Vector(point, p2).Magnitude();
if (d1 < d2)
- Object::snapPoint = p1;
+ Global::snapPoint = p1;
else
- Object::snapPoint = p2;
+ Global::snapPoint = p2;
- Object::snapPointIsValid = true;
+ Global::snapPointIsValid = true;
}
}
}
if (toolAction)
{
- if (Object::snapToGrid)
- point = Object::SnapPointToGrid(point);
+ if (Global::snapToGrid)
+ point = Global::SnapPointToGrid(point);
// We always snap to object points, and they take precendence over
// grid points...
- if (Object::snapPointIsValid)
- point = Object::snapPoint;
+ if (Global::snapPointIsValid)
+ point = Global::snapPoint;
toolAction->MouseMoved(point);
}
+#endif
// This is used to draw the tool crosshair...
oldPoint = point;
- if (document.NeedsUpdate() || Object::selectionInProgress || toolAction)
+#if 1
+ if (/*document.NeedsUpdate() ||*/ Global::selectionInProgress /*|| toolAction*/)
update();
+#endif
}
{
if (event->button() == Qt::LeftButton)
{
+#if 0
document.PointerReleased();
+#endif
//We need to update especially if nothing collided and the state needs to change. !!! FIX !!!
//could set it up to use the document's update function (assumes that all object updates
// if (collided)
update(); // Do an update if collided with at least *one* object in the document
+#if 0
if (toolAction)
toolAction->MouseReleased();
+#endif
- if (Object::selectionInProgress)
+ if (Global::selectionInProgress)
{
// Select all the stuff inside of selection
- Object::selectionInProgress = false;
+ Global::selectionInProgress = false;
}
}
else if (event->button() == Qt::MiddleButton)
Painter::zoom /= zoomFactor;
}
-// Object::gridSpacing = gridPixels / Painter::zoom;
+#if 1
+// Global::gridSpacing = gridPixels / Painter::zoom;
// UpdateGridBackground();
- SetGridSize(Object::gridSpacing * Painter::zoom);
+ SetGridSize(Global::gridSpacing * Painter::zoom);
update();
-// zoomIndicator->setText(QString("Grid: %1\", BU: Inch").arg(Object::gridSpacing));
+// zoomIndicator->setText(QString("Grid: %1\", BU: Inch").arg(Global::gridSpacing));
+#endif
}
void DrawingView::keyPressEvent(QKeyEvent * event)
{
+#if 0
if (toolAction)
toolAction->KeyDown(event->key());
+#endif
}
void DrawingView::keyReleaseEvent(QKeyEvent * event)
{
+#if 0
if (toolAction)
toolAction->KeyReleased(event->key());
+#endif
+}
+
+//
+// This looks strange, but it's really quite simple: We want a point that's
+// more than half-way to the next grid point to snap there while conversely we
+// want a point that's less than half-way to to the next grid point then snap
+// to the one before it. So we add half of the grid spacing to the point, then
+// divide by it so that we can remove the fractional part, then multiply it
+// back to get back to the correct answer.
+//
+Point DrawingView::SnapPointToGrid(Point point)
+{
+ point += Global::gridSpacing / 2.0; // *This* adds to Z!!!
+ point /= Global::gridSpacing;
+ point.x = floor(point.x);//need to fix this for negative numbers...
+ point.y = floor(point.y);
+ point.z = 0; // Make *sure* Z doesn't go anywhere!!!
+ point *= Global::gridSpacing;
+ return point;
}
#include <QtWidgets>
#include <stdint.h>
-#include "action.h"
-#include "container.h"
+//#include "action.h"
+//#include "container.h"
+#include "structs.h"
class DrawingView: public QWidget
{
DrawingView(QWidget * parent = NULL);
public:
-// void SetRotateToolActive(bool state = true);
- void SetToolActive(Action * action);
+// void SetToolActive(Action * action);
void SetGridSize(uint32_t);
void UpdateGridBackground(void);
+ Point SnapPointToGrid(Point);
public slots:
void AddNewObjectToDocument(Object *);
uint32_t gridPixels; // Grid size in pixels
private:
bool collided;
-//Should this go into Object's class variables???
-//maybe, maybe not... :-P
-// bool rotateTool;
-// double rx, ry;
bool scrollDrag;
Vector oldPoint;
-// bool addLineTool;
-// bool addCircleTool;
-// bool addDimensionTool;
public:
- Action * toolAction;
+// Action * toolAction;
// public:
// static Container document;
#include <stdlib.h>
#include <string.h>
#include <vector>
-#include "arc.h"
-#include "circle.h"
-#include "container.h"
-#include "dimension.h"
-#include "line.h"
+//#include "arc.h"
+//#include "circle.h"
+//#include "container.h"
+//#include "dimension.h"
+//#include "line.h"
+#include "structs.h"
/*
How to handle connected objects
enumerates all objects within itself. */
fprintf(file, "ARCHITEKTONAS DRAWING V1.0\n");
-#if 1
+#if 0
object->Enumerate(file);
fprintf(file, "END\n");
return true;
add objects to it until an "endContainer" marker is found. This will require a
stack to maintain the current Container. */
-#if 1
+#if 0
std::vector<Container *> containerStack;
Container * currentTopContainer = drawing;//new Container(Vector(0, 0));
Object * object;
/*static*/ bool FileIO::GetObjectFromFile(FILE * file, Object * parent, Object ** object, int * objectType)
{
+#if 0
char buffer[256];
int foundLayer = 0;
int num = fscanf(file, "%s", buffer);
(*object)->layer = foundLayer;
return recognized;
+#else
+ return false;
+#endif
}
#define __FILEIO_H__
#include <stdio.h>
-
-class Container;
-class Object;
+#include "structs.h"
+//class Container;
+//class Object;
// NB: The methods in this class are all static, so there's no need to
// instantiate an object of this type to use its functions.
--- /dev/null
+//
+// This page intentionally left (mostly) blank
+//
+
+#include <QFont>
+#include "global.h"
+
+// Initialize static variables
+
+bool Global::fixedAngle = false;
+bool Global::fixedLength = false;
+QFont * Global::font = 0;
+int Global::viewportHeight = 0;
+bool Global::deleteActive = false;
+bool Global::dimensionActive = false;
+bool Global::snapToGrid = true;
+//snapToPoints all well here?
+bool Global::ignoreClicks = false;
+bool Global::dontMove = false;
+bool Global::selectionInProgress = false;
+QRectF Global::selection;
+double Global::gridSpacing;
+int Global::currentLayer = 0;
+Point Global::snapPoint;
+bool Global::snapPointIsValid = false;
--- /dev/null
+#ifndef __GLOBALS_H__
+#define __GLOBALS_H__
+
+// Global variable class. Note that all vars are class vars, so we don't have
+// to do any instantiation shite.
+
+#include <QRectF>
+#include "vector.h"
+
+class QFont;
+
+class Global
+{
+ public:
+ static double gridSpacing;
+ static bool selectionInProgress;
+ static QRectF selection;
+ static int currentLayer;
+ static QFont * font;
+ static Point snapPoint;
+ static bool snapPointIsValid;
+
+ static bool fixedAngle;
+ static bool fixedLength;
+ static int viewportHeight;
+ static bool deleteActive;
+ static bool dimensionActive;
+
+ static bool snapToGrid;
+ static bool ignoreClicks;
+ static bool dontMove;
+
+ // Coming soon...
+ static Point origin;
+ static double zoom;
+ static Vector screenSize;
+};
+
+#endif // __GLOBALS_H__
+
#include "painter.h"
#include "mathconstants.h"
-#include "object.h"
+//#include "object.h"
+#include "global.h"
// Set class variable defaults
void Painter::DrawInformativeText(QString text)
{
- painter->setFont(*Object::font);
+ painter->setFont(*Global::font);
QRectF bounds = painter->boundingRect(QRectF(), Qt::AlignVCenter, text);
bounds.moveTo(17.0, 17.0);
QRectF textRect = bounds;
--- /dev/null
+#ifndef __STRUCTS_H__
+#define __STRUCTS_H__
+
+#include <stdint.h>
+#include <vector>
+#include <string>
+#include "vector.h"
+
+#define OBJECT_COMMON \
+ int type; \
+ uint32_t id; \
+ int layer; \
+ uint32_t color; \
+ float thickness;
+
+struct Line {
+ OBJECT_COMMON;
+ Point p1;
+ Point p2;
+};
+
+struct Circle {
+ OBJECT_COMMON;
+ Point p1;
+ double radius;
+};
+
+struct Arc {
+ OBJECT_COMMON;
+ Point p1;
+ double radius;
+ double angle1;
+ double angle2;
+};
+
+struct Text {
+ OBJECT_COMMON;
+ Point p1;
+ std::string s;
+};
+
+struct Container {
+ OBJECT_COMMON;
+ Point p1;
+ std::vector<void *> objects;
+ double angle;
+ double scale;
+};
+
+struct Dimension {
+ OBJECT_COMMON;
+ int subtype;
+ Point p1;
+ Point p2;
+ double offset;
+};
+
+struct Object {
+ OBJECT_COMMON;
+};
+
+
+#endif // __STRUCTS_H__
+
projects / architektonas / commitdiff