Shamusworld >> Repos - architektonas/blob - src/painter.cpp

   1 //
   2 // painter.cpp: Paint abstraction layer between Archtektonas and Qt
   3 //
   4 // Part of the Architektonas Project
   5 // (C) 2011 Underground Software
   6 // See the README and GPLv3 files for licensing and warranty information
   7 //
   8 // JLH = James Hammons <jlhamm@acm.org>
   9 //
  10 // WHO  WHEN        WHAT
  11 // ---  ----------  ------------------------------------------------------------
  12 // JLH  09/20/2011  Created this file
  13 //
  14
  15 #include "painter.h"
  16
  17 #include "mathconstants.h"
  18 #include "object.h"
  19
  20
  21 // Set class variable defaults
  22 Vector Painter::origin(-10.0, -10.0);
  23 double Painter::zoom = 1.0;
  24 Vector Painter::screenSize(200.0, 200.0);
  25
  26
  27 Painter::Painter(QPainter * p/*= NULL*/): painter(p)
  28 {
  29 }
  30
  31
  32 Painter::~Painter()
  33 {
  34 }
  35
  36
  37 Vector Painter::CartesianToQtCoords(Vector v)
  38 {
  39         // Convert regular Cartesian coordinates to the inverted Y-axis Qt coordinates
  40         // at the current origin and zoom level.
  41         return Vector((v.x - origin.x) * zoom, screenSize.y - ((v.y - origin.y) * zoom));
  42 }
  43
  44
  45 Vector Painter::QtToCartesianCoords(Vector v)
  46 {
  47         // Convert screen location, with inverted Y-axis coordinates, to regular
  48         // Cartesian coordinates at the current zoom level.
  49         return Vector((v.x / zoom) + origin.x, ((screenSize.y - v.y) / zoom) + origin.y);
  50 /*
  51 How to do it:
  52
  53 e.g., we have a point on the screen at Qt coords of 10, 10, screenSize is 100, 100.
  54 origin is -10, -10 and zoom level is 2 (200%)
  55
  56 1st, invert the Y: 10, 10 -> 10, 90
  57 2nd, add origin:   10, 90 ->  0, 80 (no, not right--err, yes, it is)
  58 3rd, aply zoom:     0, 80 ->  0, 40
  59
  60 or, is it:
  61
  62 1st, invert the Y: 10, 10 -> 10, 90
  63 2nd, aply zoom:    10, 90 ->  5, 45
  64 3rd, add origin:    5, 45 -> -5, 35
  65
  66 it depends on whether or not origin is in Qt coords or cartesian. If Qt, then the 1st
  67 is correct, otherwise, the 2nd is correct.
  68
  69 The way we calculate the Cartesian to Qt shows the 2nd (origin is cartesian) to be correct.
  70 */
  71 }
  72
  73
  74 void Painter::SetRenderHint(int hint)
  75 {
  76         if (!painter)
  77                 return;
  78
  79         painter->setRenderHint((QPainter::RenderHint)hint);
  80 }
  81
  82
  83 void Painter::SetBrush(QBrush brush)
  84 {
  85         if (!painter)
  86                 return;
  87
  88         painter->setBrush(brush);
  89 }
  90
  91
  92 void Painter::SetFont(QFont font)
  93 {
  94         if (!painter)
  95                 return;
  96
  97         painter->setFont(font);
  98 }
  99
 100
 101 void Painter::SetPen(QPen pen)
 102 {
 103         if (!painter)
 104                 return;
 105
 106         painter->setPen(pen);
 107 }
 108
 109
 110 void Painter::DrawAngledText(Vector center, double angle, QString text, double size)
 111 {
 112         if (!painter)
 113                 return;
 114
 115         // Strategy: Since Qt doesn't have any rotated text drawing functions,
 116         // we instead translate the origin to the center of the text to be drawn and
 117         // then rotate the frame to the desired angle.
 118         center = CartesianToQtCoords(center);
 119
 120         // We may need this stuff... If dimension text is large enough.
 121 //      int textWidth = QFontMetrics(painter->font()).width(text);
 122 //      int textHeight = QFontMetrics(painter->font()).height();
 123         QRectF textBox(-100.0 * zoom * size, -100.0 * zoom * size, 200.0 * zoom * size, 200.0 * zoom * size);   // x, y, w, h; x/y = upper left corner
 124
 125         // This is in pixels. Might not render correctly at all zoom levels.
 126         // Need to figure out if dimensions are always rendered at one size
 127         // regardless of zoom, or if they have a definite size, and are thus
 128         // zoomable.
 129         float yOffset = -12.0 * zoom * size;
 130
 131         // Fix text so it isn't upside down...
 132         if ((angle > PI * 0.5) && (angle < PI * 1.5))
 133         {
 134                 angle += PI;
 135                 yOffset = 12.0 * zoom * size;
 136         }
 137
 138         textBox.translate(0, yOffset);
 139         painter->save();
 140         painter->translate(center.x, center.y);
 141         // Angles are backwards in the Qt coord system, so we flip ours...
 142         painter->rotate(-angle * RADIANS_TO_DEGREES);
 143 //Need to fix this so the text scales as well...
 144         painter->drawText(textBox, Qt::AlignCenter, text);
 145         painter->restore();
 146 }
 147
 148
 149 void Painter::DrawArc(Vector center, double radius, double startAngle, double span)
 150 {
 151         center = CartesianToQtCoords(center);
 152         // Need to multiply scalar quantities by the zoom factor as well...
 153         radius *= zoom;
 154         QRectF rectangle(QPointF(center.x - radius, center.y - radius),
 155                 QPointF(center.x + radius, center.y + radius));
 156         int angle1 = (int)(startAngle * RADIANS_TO_DEGREES * 16.0);
 157         int angle2 = (int)(span * RADIANS_TO_DEGREES * 16.0);
 158         painter->drawArc(rectangle, angle1, angle2);
 159 }
 160
 161
 162 void Painter::DrawEllipse(Vector center, double axis1, double axis2)
 163 {
 164         // Need to multiply scalar quantities by the zoom factor as well...
 165         center = CartesianToQtCoords(center);
 166         painter->drawEllipse(QPointF(center.x, center.y), axis1 * zoom, axis2 * zoom);
 167 }
 168
 169
 170 // This function is for drawing object handles without regard for zoom level;
 171 // we don't want our object handle size to depend on the zoom level!
 172 void Painter::DrawHandle(Vector center)
 173 {
 174         center = CartesianToQtCoords(center);
 175         painter->setBrush(Qt::NoBrush);
 176         painter->drawEllipse(QPointF(center.x, center.y), 4.0, 4.0);
 177 }
 178
 179
 180 void Painter::DrawLine(int x1, int y1, int x2, int y2)
 181 {
 182         if (!painter)
 183                 return;
 184
 185         Vector v1 = CartesianToQtCoords(Vector(x1, y1));
 186         Vector v2 = CartesianToQtCoords(Vector(x2, y2));
 187         painter->drawLine(v1.x, v1.y, v2.x, v2.y);
 188 }
 189
 190
 191 void Painter::DrawLine(Vector v1, Vector v2)
 192 {
 193         if (!painter)
 194                 return;
 195
 196         v1 = CartesianToQtCoords(v1);
 197         v2 = CartesianToQtCoords(v2);
 198         painter->drawLine(QPointF(v1.x, v1.y), QPointF(v2.x, v2.y));
 199 }
 200
 201
 202 void Painter::DrawPoint(int x, int y)
 203 {
 204         if (!painter)
 205                 return;
 206
 207         Vector v = CartesianToQtCoords(Vector(x, y));
 208         painter->drawPoint(v.x, v.y);
 209 }
 210
 211
 212 // The rect passed in is in Qt coordinates...
 213 void Painter::DrawRoundedRect(QRectF rect, double radiusX, double radiusY)
 214 {
 215         if (!painter)
 216                 return;
 217
 218         painter->drawRoundedRect(rect, radiusX, radiusY);
 219 }
 220
 221
 222 // The rect passed in is in Cartesian but we want to pad it by a set number of
 223 // pixels (currently set at 8), so the pad looks the same regardless of zoom.
 224 void Painter::DrawPaddedRect(QRectF rect)
 225 {
 226         if (!painter)
 227                 return;
 228
 229         Vector v1 = CartesianToQtCoords(Vector(rect.x(), rect.y()));
 230         Vector v2 = CartesianToQtCoords(Vector(rect.right(), rect.bottom()));
 231         QRectF screenRect(QPointF(v1.x, v1.y), QPointF(v2.x, v2.y));
 232         screenRect.adjust(-8, 8, 8, -8);        // Left/top, right/bottom
 233         painter->drawRect(screenRect);
 234 }
 235
 236
 237 void Painter::DrawRect(QRectF rect)
 238 {
 239         if (!painter)
 240                 return;
 241
 242         Vector v1 = CartesianToQtCoords(Vector(rect.x(), rect.y()));
 243         Vector v2 = CartesianToQtCoords(Vector(rect.right(), rect.bottom()));
 244         QRectF screenRect(QPointF(v1.x, v1.y), QPointF(v2.x, v2.y));
 245         painter->drawRect(screenRect);
 246 }
 247
 248
 249 void Painter::DrawText(QRectF rect, int type, QString text)
 250 {
 251         if (!painter)
 252                 return;
 253
 254         painter->drawText(rect, (Qt::AlignmentFlag)type, text);
 255 }
 256
 257
 258 void Painter::DrawArrowhead(Vector head, Vector tail, double size)
 259 {
 260         if (!painter)
 261                 return;
 262
 263         QPolygonF arrow;
 264
 265         // We draw the arrowhead aligned along the line from tail to head
 266         double angle = Vector(head - tail).Angle();
 267         double orthoAngle = angle + (PI / 2.0);
 268         Vector orthogonal = Vector(cos(orthoAngle), sin(orthoAngle));
 269         Vector unit = Vector(head - tail).Unit();
 270
 271         Point p1 = head - (unit * 9.0 * size);
 272         Point p2 = p1 + (orthogonal * 3.0 * size);
 273         Point p3 = p1 - (orthogonal * 3.0 * size);
 274
 275         Point p4 = CartesianToQtCoords(head);
 276         Point p5 = CartesianToQtCoords(p2);
 277         Point p6 = CartesianToQtCoords(p3);
 278
 279         arrow << QPointF(p4.x, p4.y) << QPointF(p5.x, p5.y) << QPointF(p6.x, p6.y);
 280
 281         painter->drawPolygon(arrow);
 282 }
 283
 284
 285 // Point is given in Cartesian coordinates
 286 void Painter::DrawCrosshair(Vector point)
 287 {
 288         if (!painter)
 289                 return;
 290
 291         Vector screenPoint = CartesianToQtCoords(point);
 292         painter->drawLine(0, screenPoint.y, screenSize.x, screenPoint.y);
 293         painter->drawLine(screenPoint.x, 0, screenPoint.x, screenSize.y);
 294 }
 295
 296
 297 void Painter::DrawInformativeText(QString text)
 298 {
 299         painter->setFont(*Object::font);
 300         QRectF bounds = painter->boundingRect(QRectF(), Qt::AlignVCenter, text);
 301         bounds.moveTo(17.0, 17.0);
 302         QRectF textRect = bounds;
 303         textRect.adjust(-7.0, -7.0, 7.0, 7.0);
 304
 305         QPen pen = QPen(QColor(0x00, 0xFF, 0x00), 1.0, Qt::SolidLine);
 306         painter->setPen(pen);
 307         painter->setBrush(QBrush(QColor(0x40, 0xFF, 0x40, 0x9F)));
 308         painter->drawRoundedRect(textRect, 7.0, 7.0);
 309
 310         pen = QPen(QColor(0x00, 0x5F, 0xDF));
 311         painter->setPen(pen);
 312         painter->drawText(bounds, Qt::AlignVCenter, text);
 313 }
 314