--- /dev/null
+# -*- coding: iso-8859-1 -*-
+#----------------------------------------------------------------------------
+# Name: drawn.py
+# Purpose: DrawnShape class
+#
+# Author: Pierre Hjälm (from C++ original by Julian Smart)
+#
+# Created: 2004-08-25
+# RCS-ID: $Id$
+# Copyright: (c) 2004 Pierre Hjälm - 1998 Julian Smart
+# License: wxWindows license
+#----------------------------------------------------------------------------
+
+import os.path
+
+from _basic import RectangleShape
+from _oglmisc import *
+
+METAFLAGS_OUTLINE = 1
+METAFLAGS_ATTACHMENTS = 2
+
+DRAWN_ANGLE_0 = 0
+DRAWN_ANGLE_90 = 1
+DRAWN_ANGLE_180 = 2
+DRAWN_ANGLE_270 = 3
+
+# Drawing operations
+DRAWOP_SET_PEN = 1
+DRAWOP_SET_BRUSH = 2
+DRAWOP_SET_FONT = 3
+DRAWOP_SET_TEXT_COLOUR = 4
+DRAWOP_SET_BK_COLOUR = 5
+DRAWOP_SET_BK_MODE = 6
+DRAWOP_SET_CLIPPING_RECT = 7
+DRAWOP_DESTROY_CLIPPING_RECT = 8
+
+DRAWOP_DRAW_LINE = 20
+DRAWOP_DRAW_POLYLINE = 21
+DRAWOP_DRAW_POLYGON = 22
+DRAWOP_DRAW_RECT = 23
+DRAWOP_DRAW_ROUNDED_RECT = 24
+DRAWOP_DRAW_ELLIPSE = 25
+DRAWOP_DRAW_POINT = 26
+DRAWOP_DRAW_ARC = 27
+DRAWOP_DRAW_TEXT = 28
+DRAWOP_DRAW_SPLINE = 29
+DRAWOP_DRAW_ELLIPTIC_ARC = 30
+
+class DrawOp(object):
+ def __init__(self, theOp):
+ self._op = theOp
+
+ def GetOp(self):
+ return self._op
+
+ def GetPerimeterPoint(self, x1, y1, x2, y2, xOffset, yOffset, attachmentMode):
+ return False
+
+ def Scale(self,scaleX, scaleY):
+ pass
+
+ def Translate(self, x, y):
+ pass
+
+class OpSetGDI(DrawOp):
+ """Set font, brush, text colour."""
+ def __init__(self, theOp, theImage, theGdiIndex, theMode = 0):
+ DrawOp.__init__(self, theOp)
+
+ self._gdiIndex = theGdiIndex
+ self._image = theImage
+ self._mode = theMode
+
+ def Do(self, dc, xoffset = 0, yoffset = 0):
+ if self._op == DRAWOP_SET_PEN:
+ # Check for overriding this operation for outline colour
+ if self._gdiIndex in self._image._outlineColours:
+ if self._image._outlinePen:
+ dc.SetPen(self._image._outlinePen)
+ else:
+ try:
+ dc.SetPen(self._image._gdiObjects[self._gdiIndex])
+ except IndexError:
+ pass
+ elif self._op == DRAWOP_SET_BRUSH:
+ # Check for overriding this operation for outline or fill colour
+ if self._gdiIndex in self._image._outlineColours:
+ # Need to construct a brush to match the outline pen's colour
+ if self._image._outlinePen:
+ br = wx.TheBrushList.FindOrCreateBrush(self._image._outlinePen, wx.SOLID)
+ if br:
+ dc.SetBrush(br)
+ elif self._gdiIndex in self._image._fillColours:
+ if self._image._fillBrush:
+ dc.SetBrush(self._image._fillBrush)
+ else:
+ brush = self._image._gdiObjects[self._gdiIndex]
+ if brush:
+ dc.SetBrush(brush)
+ elif self._op == DRAWOP_SET_FONT:
+ try:
+ dc.SetFont(self._image._gdiObjects[self._gdiIndex])
+ except IndexError:
+ pass
+ elif self._op == DRAWOP_SET_TEXT_COLOUR:
+ dc.SetTextForeground(wx.Colour(self._r, self._g, self._b))
+ elif self._op == DRAWOP_SET_BK_COLOUR:
+ dc.SetTextBackground(wx.Colour(self._r, self._g, self._b))
+ elif self._op == DRAWOP_SET_BK_MODE:
+ dc.SetBackgroundMode(self._mode)
+
+
+class OpSetClipping(DrawOp):
+ """Set/destroy clipping."""
+ def __init__(self, theOp, theX1, theY1, theX2, theY2):
+ DrawOp.__init__(self, theOp)
+
+ self._x1 = theX1
+ self._y1 = theY1
+ self._x2 = theX2
+ self._y2 = theY2
+
+ def Do(self, dc, xoffset, yoffset):
+ if self._op == DRAWOP_SET_CLIPPING_RECT:
+ dc.SetClippingRegion(self._x1 + xoffset, self._y1 + yoffset, self._x2 + xoffset, self._y2 + yoffset)
+ elif self._op == DRAWOP_DESTROY_CLIPPING_RECT:
+ dc.DestroyClippingRegion()
+
+ def Scale(self, scaleX, scaleY):
+ self._x1 *= scaleX
+ self._y1 *= scaleY
+ self._x2 *= scaleX
+ self._y2 *= scaleY
+
+ def Translate(self, x, y):
+ self._x1 += x
+ self._y1 += y
+
+
+class OpDraw(DrawOp):
+ """Draw line, rectangle, rounded rectangle, ellipse, point, arc, text."""
+ def __init__(self, theOp, theX1, theY1, theX2, theY2, theRadius = 0.0, s = ""):
+ DrawOp.__init__(self, theOp)
+
+ self._x1 = theX1
+ self._y1 = theY1
+ self._x2 = theX2
+ self._y2 = theY2
+ self._x3 = 0.0
+ self._y3 = 0.0
+ self._radius = theRadius
+ self._textString = s
+
+ def Do(self, dc, xoffset, yoffset):
+ if self._op == DRAWOP_DRAW_LINE:
+ dc.DrawLine(self._x1 + xoffset, self._y1 + yoffset, self._x2 + xoffset, self._y2 + yoffset)
+ elif self._op == DRAWOP_DRAW_RECT:
+ dc.DrawRectangle(self._x1 + xoffset, self._y1 + yoffset, self._x2, self._y2)
+ elif self._op == DRAWOP_DRAW_ROUNDED_RECT:
+ dc.DrawRoundedRectangle(self._x1 + xoffset, self._y1 + yoffset, self._x2, self._y2, self._radius)
+ elif self._op == DRAWOP_DRAW_ELLIPSE:
+ dc.DrawEllipse(self._x1 + xoffset, self._y1 + yoffset, self._x2, self._y2)
+ elif self._op == DRAWOP_DRAW_ARC:
+ dc.DrawArc(self._x2 + xoffset, self._y2 + yoffset, self._x3 + xoffset, self._y3 + yoffset, self._x1 + xoffset, self._y1 + yoffset)
+ elif self._op == DRAWOP_DRAW_ELLIPTIC_ARC:
+ dc.DrawEllipticArc(self._x1 + xoffset, self._y1 + yoffset, self._x2, self._y2, self._x3 * 360 / (2 * math.pi), self.y3 * 360 / (2 * math.pi))
+ elif self._op == DRAWOP_DRAW_POINT:
+ dc.DrawPoint(self._x1 + xoffset, self._y1 + yoffset)
+ elif self._op == DRAWOP_DRAW_TEXT:
+ dc.DrawText(self._textString, self._x1 + xoffset, self._y1 + yoffset)
+ def Scale(self, scaleX, scaleY):
+ self._x1 *= scaleX
+ self._y1 *= scaleY
+ self._x2 *= scaleX
+ self._y2 *= scaleY
+
+ if self._op != DRAWOP_DRAW_ELLIPTIC_ARC:
+ self._x3 *= scaleX
+ self._y3 *= scaleY
+
+ self._radius *= scaleX
+
+ def Translate(self, x, y):
+ self._x1 += x
+ self._y1 += y
+
+ if self._op == DRAWOP_DRAW_LINE:
+ self._x2 += x
+ self._y2 += y
+ elif self._op == DRAWOP_DRAW_ARC:
+ self._x2 += x
+ self._y2 += y
+ self._x3 += x
+ self._y3 += y
+
+ def Rotate(self, x, y, theta, sinTheta, cosTheta):
+ newX1 = self._x1 * cosTheta + self._y1 * sinTheta + x * (1 - cosTheta) + y * sinTheta
+ newY1 = self._x1 * sinTheta + self._y1 * cosTheta + y * (1 - cosTheta) + x * sinTheta
+
+ if self._op == DRAWOP_DRAW_LINE:
+ newX2 = self._x2 * cosTheta - self._y2 * sinTheta + x * (1 - cosTheta) + y * sinTheta
+ newY2 = self._x2 * sinTheta + self._y2 * cosTheta + y * (1 - cosTheta) + x * sinTheta;
+
+ self._x1 = newX1
+ self._y1 = newY1
+ self._x2 = newX2
+ self._y2 = newY2
+
+ elif self._op in [DRAWOP_DRAW_RECT, DRAWOP_DRAW_ROUNDED_RECT, DRAWOP_DRAW_ELLIPTIC_ARC]:
+ # Assume only 0, 90, 180, 270 degree rotations.
+ # oldX1, oldY1 represents the top left corner. Find the
+ # bottom right, and rotate that. Then the width/height is
+ # the difference between x/y values.
+ oldBottomRightX = self._x1 + self._x2
+ oldBottomRightY = self._y1 + self._y2
+ newBottomRightX = oldBottomRightX * cosTheta - oldBottomRightY * sinTheta + x * (1 - cosTheta) + y * sinTheta
+ newBottomRightY = oldBottomRightX * sinTheta + oldBottomRightY * cosTheta + y * (1 - cosTheta) + x * sinTheta
+
+ # Now find the new top-left, bottom-right coordinates.
+ minX = min(newX1, newBottomRightX)
+ minY = min(newY1, newBottomRightY)
+ maxX = max(newX1, newBottomRightX)
+ maxY = max(newY1, newBottomRightY)
+
+ self._x1 = minX
+ self._y1 = minY
+ self._x2 = maxX - minX # width
+ self._y2 = maxY - minY # height
+
+ if self._op == DRAWOP_DRAW_ELLIPTIC_ARC:
+ # Add rotation to angles
+ self._x3 += theta
+ self._y3 += theta
+ elif self._op == DRAWOP_DRAW_ARC:
+ newX2 = self._x2 * cosTheta - self._y2 * sinTheta + x * (1 - cosTheta) + y * sinTheta
+ newY2 = self._x2 * sinTheta + self._y2 * cosTheta + y * (1 - cosTheta) + x * sinTheta
+ newX3 = self._x3 * cosTheta - self._y3 * sinTheta + x * (1 - cosTheta) + y * sinTheta
+ newY3 = self._x3 * sinTheta + self._y3 * cosTheta + y * (1 - cosTheta) + x * sinTheta
+
+ self._x1 = newX1
+ self._y1 = newY1
+ self._x2 = newX2
+ self._y2 = newY2
+ self._x3 = newX3
+ self._y3 = newY3
+
+
+class OpPolyDraw(DrawOp):
+ """Draw polygon, polyline, spline."""
+ def __init__(self, theOp, thePoints):
+ DrawOp.__init__(self, theOp)
+
+ self._noPoints = len(thePoints)
+ self._points = thePoints
+
+ def Do(self, dc, xoffset, yoffset):
+ if self._op == DRAWOP_DRAW_POLYLINE:
+ dc.DrawLines(self._points, xoffset, yoffset)
+ elif self._op == DRAWOP_DRAW_POLYGON:
+ dc.DrawPolygon(self._points, xoffset, yoffset)
+ elif self._op == DRAWOP_DRAW_SPLINE:
+ dc.DrawSpline(self._points) # no offsets in DrawSpline
+
+ def Scale(self, scaleX, scaleY):
+ for i in range(self._noPoints):
+ self._points[i] = self._points[i][0] * scaleX, self._points[i][1] * scaleY
+
+ def Translate(self, x, y):
+ for i in range(self._noPoints):
+ self._points[i][0] += x
+ self._points[i][1] += y
+
+ def Rotate(self, x, y, theta, sinTheta, cosTheta):
+ for i in range(self._noPoints):
+ x1 = self._points[i][0]
+ y1 = self._points[i][1]
+
+ self._points[i][0] = x1 * cosTheta - y1 * sinTheta + x * (1 - cosTheta) + y * sinTheta
+ self._points[i][1] = x1 * sinTheta + y1 * cosTheta + y * (1 - cosTheta) + x * sinTheta
+
+ def OnDrawOutline(self, dc, x, y, w, h, oldW, oldH):
+ dc.SetBrush(wx.TRANSPARENT_BRUSH)
+
+ # Multiply all points by proportion of new size to old size
+ x_proportion = abs(w / oldW)
+ y_proportion = abs(h / oldH)
+
+ dc.DrawPolygon([(x_proportion * x, y_proportion * y) for x, y in self._points], x, y)
+
+ def GetPerimeterPoint(self, x1, y1, x2, y2, xOffset, yOffset, attachmentMode):
+ # First check for situation where the line is vertical,
+ # and we would want to connect to a point on that vertical --
+ # oglFindEndForPolyline can't cope with this (the arrow
+ # gets drawn to the wrong place).
+ if attachmentMode == ATTACHMENT_MODE_NONE and x1 == x2:
+ # Look for the point we'd be connecting to. This is
+ # a heuristic...
+ for point in self._points:
+ if point[0] == 0:
+ if y2 > y1 and point[1] > 0:
+ return point[0]+xOffset, point[1]+yOffset
+ elif y2 < y1 and point[1] < 0:
+ return point[0]+xOffset, point[1]+yOffset
+
+ return FindEndForPolyline([ p[0] + xOffset for p in self._points ],
+ [ p[1] + yOffset for p in self._points ],
+ x1, y1, x2, y2)
+
+
+class PseudoMetaFile(object):
+ """
+ A simple metafile-like class which can load data from a Windows
+ metafile on all platforms.
+ """
+ def __init__(self):
+ self._currentRotation = 0
+ self._rotateable = True
+ self._width = 0.0
+ self._height = 0.0
+ self._outlinePen = None
+ self._fillBrush = None
+ self._outlineOp = -1
+
+ self._ops = []
+ self._gdiObjects = []
+
+ self._outlineColours = []
+ self._fillColours = []
+
+ def Clear(self):
+ self._ops = []
+ self._gdiObjects = []
+ self._outlineColours = []
+ self._fillColours = []
+ self._outlineColours = -1
+
+ def IsValid(self):
+ return self._ops != []
+
+ def GetOps(self):
+ return self._ops
+
+ def SetOutlineOp(self, op):
+ self._outlineOp = op
+
+ def GetOutlineOp(self):
+ return self._outlineOp
+
+ def SetOutlinePen(self, pen):
+ self._outlinePen = pen
+
+ def GetOutlinePen(self, pen):
+ return self._outlinePen
+
+ def SetFillBrush(self, brush):
+ self._fillBrush = brush
+
+ def GetFillBrush(self):
+ return self._fillBrush
+
+ def SetSize(self, w, h):
+ self._width = w
+ self._height = h
+
+ def SetRotateable(self, rot):
+ self._rotateable = rot
+
+ def GetRotateable(self):
+ return self._rotateable
+
+ def GetFillColours(self):
+ return self._fillColours
+
+ def GetOutlineColours(self):
+ return self._outlineColours
+
+ def Draw(self, dc, xoffset, yoffset):
+ for op in self._ops:
+ op.Do(dc, xoffset, yoffset)
+
+ def Scale(self, sx, sy):
+ for op in self._ops:
+ op.Scale(sx, sy)
+
+ self._width *= sx
+ self._height *= sy
+
+ def Translate(self, x, y):
+ for op in self._ops:
+ op.Translate(x, y)
+
+ def Rotate(self, x, y, theta):
+ theta1 = theta - self._currentRotation
+ if theta1 == 0:
+ return
+
+ cosTheta = cos(theta1)
+ sinTheta = sin(theta1)
+
+ for op in self._ops:
+ op.Rotate(x, y, theta, sinTheta, cosTheta)
+
+ self._currentRotation = theta
+
+ def LoadFromMetaFile(self, filename, rwidth, rheight):
+ if not os.path.exist(filename):
+ return False
+
+ print "LoadFromMetaFile not implemented yet."
+ return False # TODO
+
+ # Scale to fit size
+ def ScaleTo(self, w, h):
+ scaleX = w / self._width
+ scaleY = h / self._height
+
+ self.Scale(scaleX, scaleY)
+
+ def GetBounds(self):
+ maxX, maxY, minX, minY = -99999.9, -99999.9, 99999.9, 99999.9
+
+ for op in self._ops:
+ if op.GetOp() in [DRAWOP_DRAW_LINE, DRAWOP_DRAW_RECT, DRAWOP_DRAW_ROUNDED_RECT, DRAWOP_DRAW_ELLIPSE, DRAWOP_DRAW_POINT, DRAWOP_DRAW_TEXT]:
+ if op._x1 < minX:
+ minX = op._x1
+ if op._x1 > maxX:
+ maxX = op._x1
+ if op._y1 < minY:
+ minY = op._y1
+ if op._y1 > maxY:
+ maxY = op._y1
+ if op.GetOp() == DRAWOP_DRAW_LINE:
+ if op._x2 < minX:
+ minX = op._x2
+ if op._x2 > maxX:
+ maxX = op._x2
+ if op._y2 < minY:
+ minY = op._y2
+ if op._y2 > maxY:
+ maxY = op._y2
+ elif op.GetOp() in [ DRAWOP_DRAW_RECT, DRAWOP_DRAW_ROUNDED_RECT, DRAWOP_DRAW_ELLIPSE]:
+ if op._x1 + op._x2 < minX:
+ minX = op._x1 + op._x2
+ if op._x1 + op._x2 > maxX:
+ maxX = op._x1 + op._x2
+ if op._y1 + op._y2 < minY:
+ minY = op._y1 + op._y2
+ if op._y1 + op._y2 > maxX:
+ maxY = op._y1 + op._y2
+ elif op.GetOp() == DRAWOP_DRAW_ARC:
+ # TODO: don't yet know how to calculate the bounding box
+ # for an arc. So pretend it's a line; to get a correct
+ # bounding box, draw a blank rectangle first, of the
+ # correct size.
+ if op._x1 < minX:
+ minX = op._x1
+ if op._x1 > maxX:
+ maxX = op._x1
+ if op._y1 < minY:
+ minY = op._y1
+ if op._y1 > maxY:
+ maxY = op._y1
+ if op._x2 < minX:
+ minX = op._x2
+ if op._x2 > maxX:
+ maxX = op._x2
+ if op._y2 < minY:
+ minY = op._y2
+ if op._y2 > maxY:
+ maxY = op._y2
+ elif op.GetOp() in [DRAWOP_DRAW_POLYLINE, DRAWOP_DRAW_POLYGON, DRAWOP_DRAW_SPLINE]:
+ for point in op._points:
+ if point[0] < minX:
+ minX = point[0]
+ if point[0] > maxX:
+ maxX = point[0]
+ if point[1] < minY:
+ minY = point[1]
+ if point[1] > maxY:
+ maxY = point[1]
+
+ return [minX, minY, maxX, maxY]
+
+ # Calculate size from current operations
+ def CalculateSize(self, shape):
+ boundMinX, boundMinY, boundMaxX, boundMaxY = self.GetBounds()
+
+ # By Pierre Hjälm: This is NOT in the old version, which
+ # gets this totally wrong. Since the drawing is centered, we
+ # cannot get the width by measuring from left to right, we
+ # must instead make enough room to handle the largest
+ # coordinates
+ #self.SetSize(boundMaxX - boundMinX, boundMaxY - boundMinY)
+
+ w = max(abs(boundMinX), abs(boundMaxX)) * 2
+ h = max(abs(boundMinY), abs(boundMaxY)) * 2
+
+ self.SetSize(w, h)
+
+ if shape:
+ shape.SetWidth(self._width)
+ shape.SetHeight(self._height)
+
+ # Set of functions for drawing into a pseudo metafile
+ def DrawLine(self, pt1, pt2):
+ op = OpDraw(DRAWOP_DRAW_LINE, pt1[0], pt1[1], pt2[0], pt2[1])
+ self._ops.append(op)
+
+ def DrawRectangle(self, rect):
+ op = OpDraw(DRAWOP_DRAW_RECT, rect[0], rect[1], rect[2], rect[3])
+ self._ops.append(op)
+
+ def DrawRoundedRectangle(self, rect, radius):
+ op = OpDraw(DRAWOP_DRAW_ROUNDED_RECT, rect[0], rect[1], rect[2], rect[3])
+ op._radius = radius
+ self._ops.append(op)
+
+ def DrawEllipse(self, rect):
+ op = OpDraw(DRAWOP_DRAW_ELLIPSE, rect[0], rect[1], rect[2], rect[3])
+ self._ops.append(op)
+
+ def DrawArc(self, centrePt, startPt, endPt):
+ op = OpDraw(DRAWOP_DRAW_ARC, centrePt[0], centrePt[1], startPt[0], startPt[1])
+ op._x3, op._y3 = endPt
+
+ self._ops.append(op)
+
+ def DrawEllipticArc(self, rect, startAngle, endAngle):
+ startAngleRadians = startAngle * math.pi * 2 / 360
+ endAngleRadians = endAngle * math.pi * 2 / 360
+
+ op = OpDraw(DRAWOP_DRAW_ELLIPTIC_ARC, rect[0], rect[1], rect[2], rect[3])
+ op._x3 = startAngleRadians
+ op._y3 = endAngleRadians
+
+ self._ops.append(op)
+
+ def DrawPoint(self, pt):
+ op = OpDraw(DRAWOP_DRAW_POINT, pt[0], pt[1], 0, 0)
+ self._ops.append(op)
+
+ def DrawText(self, text, pt):
+ op = OpDraw(DRAWOP_DRAW_TEXT, pt[0], pt[1], 0, 0)
+ op._textString = text
+ self._ops.append(op)
+
+ def DrawLines(self, pts):
+ op = OpPolyDraw(DRAWOP_DRAW_POLYLINE, pts)
+ self._ops.append(op)
+
+ # flags:
+ # oglMETAFLAGS_OUTLINE: will be used for drawing the outline and
+ # also drawing lines/arrows at the circumference.
+ # oglMETAFLAGS_ATTACHMENTS: will be used for initialising attachment
+ # points at the vertices (perhaps a rare case...)
+ def DrawPolygon(self, pts, flags = 0):
+ op = OpPolyDraw(DRAWOP_DRAW_POLYGON, pts)
+ self._ops.append(op)
+
+ if flags & METAFLAGS_OUTLINE:
+ self._outlineOp = len(self._ops) - 1
+
+ def DrawSpline(self, pts):
+ op = OpPolyDraw(DRAWOP_DRAW_SPLINE, pts)
+ self._ops.append(op)
+
+ def SetClippingRect(self, rect):
+ OpSetClipping(DRAWOP_SET_CLIPPING_RECT, rect[0], rect[1], rect[2], rect[3])
+
+ def DestroyClippingRect(self):
+ op = OpSetClipping(DRAWOP_DESTROY_CLIPPING_RECT, 0, 0, 0, 0)
+ self._ops.append(op)
+
+ def SetPen(self, pen, isOutline = False):
+ self._gdiObjects.append(pen)
+ op = OpSetGDI(DRAWOP_SET_PEN, self, len(self._gdiObjects) - 1)
+ self._ops.append(op)
+
+ if isOutline:
+ self._outlineColours.append(len(self._gdiObjects) - 1)
+
+ def SetBrush(self, brush, isFill = False):
+ self._gdiObjects.append(brush)
+ op = OpSetGDI(DRAWOP_SET_BRUSH, self, len(self._gdiObjects) - 1)
+ self._ops.append(op)
+
+ if isFill:
+ self._fillColours.append(len(self._gdiObjects) - 1)
+
+ def SetFont(self, font):
+ self._gdiObjects.append(font)
+ op = OpSetGDI(DRAWOP_SET_FONT, self, len(self._gdiObjects) - 1)
+ self._ops.append(op)
+
+ def SetTextColour(self, colour):
+ op = OpSetGDI(DRAWOP_SET_TEXT_COLOUR, self, 0)
+ op._r, op._g, op._b = colour.Red(), colour.Green(), colour.Blue()
+
+ self._ops.append(op)
+
+ def SetBackgroundColour(self, colour):
+ op = OpSetGDI(DRAWOP_SET_BK_COLOUR, self, 0)
+ op._r, op._g, op._b = colour.Red(), colour.Green(), colour.Blue()
+
+ self._ops.append(op)
+
+ def SetBackgroundMode(self, mode):
+ op = OpSetGDI(DRAWOP_SET_BK_MODE, self, 0)
+ self._ops.append(op)
+
+class DrawnShape(RectangleShape):
+ """
+ Draws a pseudo-metafile shape, which can be loaded from a simple
+ Windows metafile.
+
+ wxDrawnShape allows you to specify a different shape for each of four
+ orientations (North, West, South and East). It also provides a set of
+ drawing functions for programmatic drawing of a shape, so that during
+ construction of the shape you can draw into it as if it were a device
+ context.
+
+ Derived from:
+ RectangleShape
+ """
+ def __init__(self):
+ RectangleShape.__init__(self, 100, 50)
+ self._saveToFile = True
+ self._currentAngle = DRAWN_ANGLE_0
+
+ self._metafiles=PseudoMetaFile(), PseudoMetaFile(), PseudoMetaFile(), PseudoMetaFile()
+
+ def OnDraw(self, dc):
+ # Pass pen and brush in case we have force outline
+ # and fill colours
+ if self._shadowMode != SHADOW_NONE:
+ if self._shadowBrush:
+ self._metafiles[self._currentAngle]._fillBrush = self._shadowBrush
+ self._metafiles[self._currentAngle]._outlinePen = wx.Pen(wx.WHITE, 1, wx.TRANSPARENT)
+ self._metafiles[self._currentAngle].Draw(dc, self._xpos + self._shadowOffsetX, self._ypos + self._shadowOffsetY)
+
+ self._metafiles[self._currentAngle]._outlinePen = self._pen
+ self._metafiles[self._currentAngle]._fillBrush = self._brush
+ self._metafiles[self._currentAngle].Draw(dc, self._xpos, self._ypos)
+
+ def SetSize(self, w, h, recursive = True):
+ self.SetAttachmentSize(w, h)
+
+ if self.GetWidth() == 0.0:
+ scaleX = 1
+ else:
+ scaleX = w / self.GetWidth()
+
+ if self.GetHeight() == 0.0:
+ scaleY = 1
+ else:
+ scaleY = h / self.GetHeight()
+
+ for i in range(4):
+ if self._metafiles[i].IsValid():
+ self._metafiles[i].Scale(scaleX, scaleY)
+
+ self._width = w
+ self._height = h
+ self.SetDefaultRegionSize()
+
+ def Scale(self, sx, sy):
+ """Scale the shape by the given amount."""
+ for i in range(4):
+ if self._metafiles[i].IsValid():
+ self._metafiles[i].Scale(sx, sy)
+ self._metafiles[i].CalculateSize(self)
+
+ def Translate(self, x, y):
+ """Translate the shape by the given amount."""
+ for i in range(4):
+ if self._metafiles[i].IsValid():
+ self._metafiles[i].Translate(x, y)
+ self._metafiles[i].CalculateSize(self)
+
+ # theta is absolute rotation from the zero position
+ def Rotate(self, x, y, theta):
+ """Rotate about the given axis by the given amount in radians."""
+ self._currentAngle = self.DetermineMetaFile(theta)
+
+ if self._currentAngle == 0:
+ # Rotate metafile
+ if not self._metafiles[0].GetRotateable():
+ return
+
+ self._metafiles[0].Rotate(x, y, theta)
+
+ actualTheta = theta - self._rotation
+
+ # Rotate attachment points
+ sinTheta = math.sin(actualTheta)
+ cosTheta = math.cos(actualTheta)
+
+ for point in self._attachmentPoints:
+ x1 = point._x
+ y1 = point._y
+
+ point._x = x1 * cosTheta - y1 * sinTheta + x * (1.0 - cosTheta) + y * sinTheta
+ point._y = x1 * sinTheta + y1 * cosTheta + y * (1.0 - cosTheta) + x * sinTheta
+
+ self._rotation = theta
+
+ self._metafiles[self._currentAngle].CalculateSize(self)
+
+ # Which metafile do we use now? Based on current rotation and validity
+ # of metafiles.
+ def DetermineMetaFile(self, rotation):
+ tolerance = 0.0001
+ angles = [0.0, math.pi / 2, math.pi, 3 * pi / 2]
+
+ whichMetaFile = 0
+
+ for i in range(4):
+ if RoughlyEqual(rotation, angles[i], tolerance):
+ whichMetaFile = i
+ break
+
+ if whichMetaFile > 0 and not self._metafiles[whichMetaFile].IsValid():
+ whichMetaFile = 0
+
+ return whichMetaFile
+
+ def OnDrawOutline(self, dc, x, y, w, h):
+ if self._metafiles[self._currentAngle].GetOutlineOp() != -1:
+ op = self._metafiles[self._currentAngle].GetOps()[self._metafiles[self._currentAngle].GetOutlineOp()]
+ if op.OnDrawOutline(dc, x, y, w, h, self._width, self._height):
+ return
+
+ # Default... just use a rectangle
+ RectangleShape.OnDrawOutline(self, dc, x, y, w, h)
+
+ # Get the perimeter point using the special outline op, if there is one,
+ # otherwise use default wxRectangleShape scheme
+ def GetPerimeterPoint(self, x1, y1, x2, y2):
+ if self._metafiles[self._currentAngle].GetOutlineOp() != -1:
+ op = self._metafiles[self._currentAngle].GetOps()[self._metafiles[self._currentAngle].GetOutlineOp()]
+ p = op.GetPerimeterPoint(x1, y1, x2, y2, self.GetX(), self.GetY(), self.GetAttachmentMode())
+ if p:
+ return p
+
+ return RectangleShape.GetPerimeterPoint(self, x1, y1, x2, y2)
+
+ def LoadFromMetaFile(self, filename):
+ """Load a (very simple) Windows metafile, created for example by
+ Top Draw, the Windows shareware graphics package."""
+ return self._metafiles[0].LoadFromMetaFile(filename)
+
+ # Set of functions for drawing into a pseudo metafile.
+ # They use integers, but doubles are used internally for accuracy
+ # when scaling.
+ def DrawLine(self, pt1, pt2):
+ self._metafiles[self._currentAngle].DrawLine(pt1, pt2)
+
+ def DrawRectangle(self, rect):
+ self._metafiles[self._currentAngle].DrawRectangle(rect)
+
+ def DrawRoundedRectangle(self, rect, radius):
+ """Draw a rounded rectangle.
+
+ radius is the corner radius. If radius is negative, it expresses
+ the radius as a proportion of the smallest dimension of the rectangle.
+ """
+ self._metafiles[self._currentAngle].DrawRoundedRectangle(rect, radius)
+
+ def DrawEllipse(self, rect):
+ self._metafiles[self._currentAngle].DrawEllipse(rect)
+
+ def DrawArc(self, centrePt, startPt, endPt):
+ """Draw an arc."""
+ self._metafiles[self._currentAngle].DrawArc(centrePt, startPt, endPt)
+
+ def DrawEllipticArc(self, rect, startAngle, endAngle):
+ """Draw an elliptic arc."""
+ self._metafiles[self._currentAngle].DrawEllipticArc(rect, startAngle, endAngle)
+
+ def DrawPoint(self, pt):
+ self._metafiles[self._currentAngle].DrawPoint(pt)
+
+ def DrawText(self, text, pt):
+ self._metafiles[self._currentAngle].DrawText(text, pt)
+
+ def DrawLines(self, pts):
+ self._metafiles[self._currentAngle].DrawLines(pts)
+
+ def DrawPolygon(self, pts, flags = 0):
+ """Draw a polygon.
+
+ flags can be one or more of:
+ METAFLAGS_OUTLINE (use this polygon for the drag outline) and
+ METAFLAGS_ATTACHMENTS (use the vertices of this polygon for attachments).
+ """
+ if flags and METAFLAGS_ATTACHMENTS:
+ self.ClearAttachments()
+ for i in range(len(pts)):
+ self._attachmentPoints.append(AttachmentPoint(i,pts[i][0],pts[i][1]))
+ self._metafiles[self._currentAngle].DrawPolygon(pts, flags)
+
+ def DrawSpline(self, pts):
+ self._metafiles[self._currentAngle].DrawSpline(pts)
+
+ def SetClippingRect(self, rect):
+ """Set the clipping rectangle."""
+ self._metafiles[self._currentAngle].SetClippingRect(rect)
+
+ def DestroyClippingRect(self):
+ """Destroy the clipping rectangle."""
+ self._metafiles[self._currentAngle].DestroyClippingRect()
+
+ def SetDrawnPen(self, pen, isOutline = False):
+ """Set the pen for this metafile.
+
+ If isOutline is True, this pen is taken to indicate the outline
+ (and if the outline pen is changed for the whole shape, the pen
+ will be replaced with the outline pen).
+ """
+ self._metafiles[self._currentAngle].SetPen(pen, isOutline)
+
+ def SetDrawnBrush(self, brush, isFill = False):
+ """Set the brush for this metafile.
+
+ If isFill is True, the brush is used as the fill brush.
+ """
+ self._metafiles[self._currentAngle].SetBrush(brush, isFill)
+
+ def SetDrawnFont(self, font):
+ self._metafiles[self._currentAngle].SetFont(font)
+
+ def SetDrawnTextColour(self, colour):
+ """Set the current text colour for the current metafile."""
+ self._metafiles[self._currentAngle].SetTextColour(colour)
+
+ def SetDrawnBackgroundColour(self, colour):
+ """Set the current background colour for the current metafile."""
+ self._metafiles[self._currentAngle].SetBackgroundColour(colour)
+
+ def SetDrawnBackgroundMode(self, mode):
+ """Set the current background mode for the current metafile."""
+ self._metafiles[self._currentAngle].SetBackgroundMode(mode)
+
+ def CalculateSize(self):
+ """Calculate the wxDrawnShape size from the current metafile.
+
+ Call this after you have drawn into the shape.
+ """
+ self._metafiles[self._currentAngle].CalculateSize(self)
+
+ def DrawAtAngle(self, angle):
+ """Set the metafile for the given orientation, which can be one of:
+
+ * DRAWN_ANGLE_0
+ * DRAWN_ANGLE_90
+ * DRAWN_ANGLE_180
+ * DRAWN_ANGLE_270
+ """
+ self._currentAngle = angle
+
+ def GetAngle(self):
+ """Return the current orientation, which can be one of:
+
+ * DRAWN_ANGLE_0
+ * DRAWN_ANGLE_90
+ * DRAWN_ANGLE_180
+ * DRAWN_ANGLE_270
+ """
+ return self._currentAngle
+
+ def GetRotation(self):
+ """Return the current rotation of the shape in radians."""
+ return self._rotation
+
+ def SetSaveToFile(self, save):
+ """If save is True, the image will be saved along with the shape's
+ other attributes. The reason why this might not be desirable is that
+ if there are many shapes with the same image, it would be more
+ efficient for the application to save one copy, and not duplicate
+ the information for every shape. The default is True.
+ """
+ self._saveToFile = save
+
+ def GetMetaFile(self, which = 0):
+ """Return a reference to the internal 'pseudo-metafile'."""
+ return self._metafiles[which]
projects / wxWidgets.git / commitdiff
