def run(self):
self.app = wx.App(0)
self.frame = wx.Frame(None,
wx.ID_ANY,
'GC Renderer Test',
size=(800, 600))
self.frame.Show()
# creation phase
renderer = GCRenderer(window=self.frame, double_buffered=False)
renderer.Clear('white')
black_brush = renderer.CreateBrush('plain', 'black')
red_brush = renderer.CreateBrush('plain', 'red')
black_pen = renderer.CreatePen(wx.Colour(0, 0, 0, 255), width=5)
red_pen = renderer.CreatePen(wx.Colour(255, 0, 0, 50), width=10)
red_pen.Activate()
bmp = wx.BitmapFromImage(wx.Image('../data/toucan.png'))
font = renderer.CreateFont(14, 'default', 'italic', 'normal', True,
'Arial', 'blue')
font.Activate()
path = renderer.CreatePath()
vertices = [(0, 20), (70, 35), (99, 46), (235, 11), (555, 555)]
path.MoveToPoint(*vertices[0])
for v in vertices[1:]:
path.AddLineToPoint(*v)
# do drawing
black_brush.Activate()
red_pen.Activate()
renderer.DrawEllipse(100, 100, 50, 80)
renderer.DrawLines([(0, 0), (200, 200)])
red_brush.Activate()
black_pen.Activate()
path.Stroke()
renderer.DrawRotatedText('Hello World!', 50, 300, angle=30)
renderer.DrawBitmap(bmp, 200, 200, 40, 40)
renderer.Present()
self.app.MainLoop()
import os.path
app = MyApp(0)
buffer = wx.EmptyBitmap(200, 200, 32)
dc = wx.MemoryDC(buffer)
dc.SetBackground(wx.WHITE_BRUSH)
dc.Clear()
dc = wx.GraphicsContext.Create(dc)
dc.SetBrush(dc.CreateBrush(wx.BLACK_BRUSH))
print('default matrix %s' % dc.GetTransform().Get())
import math
original_matrix = dc.GetTransform()
path = dc.CreatePath()
path.AddEllipse(0, 20, 40, 20)
path.MoveToPoint(0, 0)
path.AddLineToPoint(10, 10)
path.AddLineToPoint(20, 0)
path.CloseSubpath()
if wx.Platform == "__WXMSW__":
a = 45
else:
a = radians(45)
original = dc.CreateMatrix(*original_matrix.Get())
om = dc.CreateMatrix(*original_matrix.Get())
m0 = dc.CreateMatrix()
m0.Scale(0.5, 0.5)
m1 = dc.CreateMatrix()
m1.Translate(150, 150)
m2 = dc.CreateMatrix()
def _draw_balloon_bg(self, dc, inner_size, tip_pos, above, sticky):
"""
Draw the balloon background leaving inner_size for content.
tip_pos determines where the tip of the ballon should be.
above determines if the balloon should be above the tip (True) or below
(False). This is not currently implemented.
W
|----------------|
______________ _
/ \ | R = Corner Radius
| | | AA = Left Arrow-leg angle
| W_ARROW | | H MARGIN = Text margin
| |--| | | * = Starting point
\____ ______/ _
/ / |
/_/ | H_ARROW
* -
|----|
ARROW_OFFSET
Calculation of points starts at the tip of the arrow and continues
clockwise around the ballon.
Return (bounding_rect, x, y) where x and y is at top of inner region.
"""
# Prepare path object
gc = wx.GraphicsContext.Create(self.dc)
path = gc.CreatePath()
# Calculate path
R = BALLOON_RADIUS
W = 1 * R + inner_size[0]
H = 1 * R + inner_size[1]
H_ARROW = 14
W_ARROW = 15
AA = 20
# Starting point at the tip of the arrow
(tipx, tipy) = tip_pos
p0 = wx.Point(tipx, tipy)
path.MoveToPoint(p0.x, p0.y)
# Next point is the left base of the arrow
p1 = wx.Point(p0.x + H_ARROW * math.tan(math.radians(AA)),
p0.y - H_ARROW)
path.AddLineToPoint(p1.x, p1.y)
# Start of lower left rounded corner
p2 = wx.Point(p1.x - ARROW_OFFSET + R, p1.y)
path.AddLineToPoint(p2.x, p2.y)
# The lower left rounded corner. p3 is the center of the arc
p3 = wx.Point(p2.x, p2.y - R)
path.AddArc(p3.x, p3.y, R, math.radians(90), math.radians(180))
# The left side
p4 = wx.Point(p3.x - R, p3.y - H + R)
left_x = p4.x
path.AddLineToPoint(p4.x, p4.y)
# The upper left rounded corner. p5 is the center of the arc
p5 = wx.Point(p4.x + R, p4.y)
path.AddArc(p5.x, p5.y, R, math.radians(180), math.radians(-90))
# The upper side
p6 = wx.Point(p5.x + W - R, p5.y - R)
top_y = p6.y
path.AddLineToPoint(p6.x, p6.y)
# The upper right rounded corner. p7 is the center of the arc
p7 = wx.Point(p6.x, p6.y + R)
path.AddArc(p7.x, p7.y, R, math.radians(-90), math.radians(0))
# The right side
p8 = wx.Point(p7.x + R, p7.y + H - R)
path.AddLineToPoint(p8.x, p8.y)
# The lower right rounded corner. p9 is the center of the arc
p9 = wx.Point(p8.x - R, p8.y)
path.AddArc(p9.x, p9.y, R, math.radians(0), math.radians(90))
# The lower side
p10 = wx.Point(p9.x - W + W_ARROW + ARROW_OFFSET, p9.y + R)
path.AddLineToPoint(p10.x, p10.y)
path.CloseSubpath()
# Draw sharp lines on GTK which uses Cairo
# See: http://www.cairographics.org/FAQ/#sharp_lines
gc.Translate(0.5, 0.5)
# Draw the ballon
BORDER_COLOR = wx.Colour(127, 127, 127)
BG_COLOR = wx.Colour(255, 255, 231)
PEN = wx.Pen(BORDER_COLOR, 1, wx.SOLID)
BRUSH = wx.Brush(BG_COLOR, wx.SOLID)
gc.SetPen(PEN)
gc.SetBrush(BRUSH)
gc.DrawPath(path)
# Draw the pin
if sticky:
pin = wx.Bitmap(os.path.join(ICONS_DIR, "stickypin.png"))
else:
pin = wx.Bitmap(os.path.join(ICONS_DIR, "unstickypin.png"))
self.dc.DrawBitmap(pin, p7.x - 5, p6.y + 5, True)
# Return
bx = left_x
by = top_y
bw = W + R + 1
bh = H + R + H_ARROW + 1
bounding_rect = wx.Rect(bx, by, bw, bh)
return (bounding_rect, left_x + BALLOON_RADIUS, top_y + BALLOON_RADIUS)
