wxPython/demo/ScrolledWindow.py

   1
   2 import  wx
   3 import  images
   4
   5 BUFFERED = 1
   6
   7 #---------------------------------------------------------------------------
   8
   9 class MyCanvas(wx.ScrolledWindow):
  10     def __init__(self, parent, id = -1, size = wx.DefaultSize):
  11         wx.ScrolledWindow.__init__(self, parent, id, (0, 0), size=size, style=wx.SUNKEN_BORDER)
  12
  13         self.lines = []
  14         self.maxWidth  = 1000
  15         self.maxHeight = 1000
  16         self.x = self.y = 0
  17         self.curLine = []
  18         self.drawing = False
  19
  20         self.SetBackgroundColour("WHITE")
  21         self.SetCursor(wx.StockCursor(wx.CURSOR_PENCIL))
  22         bmp = images.getTest2Bitmap()
  23         mask = wx.Mask(bmp, wx.BLUE)
  24         bmp.SetMask(mask)
  25         self.bmp = bmp
  26
  27         self.SetVirtualSize((self.maxWidth, self.maxHeight))
  28         self.SetScrollRate(20,20)
  29
  30         if BUFFERED:
  31             # Initialize the buffer bitmap.  No real DC is needed at this point.
  32             self.buffer = wx.EmptyBitmap(self.maxWidth, self.maxHeight)
  33             dc = wx.BufferedDC(None, self.buffer)
  34             dc.SetBackground(wx.Brush(self.GetBackgroundColour()))
  35             dc.Clear()
  36             self.DoDrawing(dc)
  37
  38         self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftButtonEvent)
  39         self.Bind(wx.EVT_LEFT_UP,   self.OnLeftButtonEvent)
  40         self.Bind(wx.EVT_MOTION,    self.OnLeftButtonEvent)
  41         self.Bind(wx.EVT_PAINT, self.OnPaint)
  42
  43
  44     def getWidth(self):
  45         return self.maxWidth
  46
  47     def getHeight(self):
  48         return self.maxHeight
  49
  50
  51     def OnPaint(self, event):
  52         if BUFFERED:
  53             # Create a buffered paint DC.  It will create the real
  54             # wx.PaintDC and then blit the bitmap to it when dc is
  55             # deleted.  Since we don't need to draw anything else
  56             # here that's all there is to it.
  57             dc = wx.BufferedPaintDC(self, self.buffer, wx.BUFFER_VIRTUAL_AREA)
  58         else:
  59             dc = wx.PaintDC(self)
  60             self.PrepareDC(dc)
  61             # since we're not buffering in this case, we have to
  62             # paint the whole window, potentially very time consuming.
  63             self.DoDrawing(dc)
  64
  65
  66     def DoDrawing(self, dc, printing=False):
  67         dc.BeginDrawing()
  68         dc.SetPen(wx.Pen('RED'))
  69         dc.DrawRectangle(5, 5, 50, 50)
  70
  71         dc.SetBrush(wx.LIGHT_GREY_BRUSH)
  72         dc.SetPen(wx.Pen('BLUE', 4))
  73         dc.DrawRectangle(15, 15, 50, 50)
  74
  75         dc.SetFont(wx.Font(14, wx.SWISS, wx.NORMAL, wx.NORMAL))
  76         dc.SetTextForeground(wx.Colour(0xFF, 0x20, 0xFF))
  77         te = dc.GetTextExtent("Hello World")
  78         dc.DrawText("Hello World", 60, 65)
  79
  80         dc.SetPen(wx.Pen('VIOLET', 4))
  81         dc.DrawLine(5, 65+te[1], 60+te[0], 65+te[1])
  82
  83         lst = [(100,110), (150,110), (150,160), (100,160)]
  84         dc.DrawLines(lst, -60)
  85         dc.SetPen(wx.GREY_PEN)
  86         dc.DrawPolygon(lst, 75)
  87         dc.SetPen(wx.GREEN_PEN)
  88         dc.DrawSpline(lst+[(100,100)])
  89
  90         dc.DrawBitmap(self.bmp, 200, 20, True)
  91         dc.SetTextForeground(wx.Colour(0, 0xFF, 0x80))
  92         dc.DrawText("a bitmap", 200, 85)
  93
  94 ##         dc.SetFont(wx.Font(14, wx.SWISS, wx.NORMAL, wx.NORMAL))
  95 ##         dc.SetTextForeground("BLACK")
  96 ##         dc.DrawText("TEST this STRING", 10, 200)
  97 ##         print dc.GetFullTextExtent("TEST this STRING")
  98
  99         font = wx.Font(20, wx.SWISS, wx.NORMAL, wx.NORMAL)
 100         dc.SetFont(font)
 101         dc.SetTextForeground(wx.BLACK)
 102
 103         for a in range(0, 360, 45):
 104             dc.DrawRotatedText("Rotated text...", 300, 300, a)
 105
 106         dc.SetPen(wx.TRANSPARENT_PEN)
 107         dc.SetBrush(wx.BLUE_BRUSH)
 108         dc.DrawRectangle(50,500, 50,50)
 109         dc.DrawRectangle(100,500, 50,50)
 110
 111         dc.SetPen(wx.Pen('RED'))
 112         dc.DrawEllipticArc(200,500, 50,75, 0, 90)
 113
 114         if not printing:
 115             # This has troubles when used on a print preview in wxGTK,
 116             # probably something to do with the pen styles and the scaling
 117             # it does...
 118             y = 20
 119
 120             for style in [wx.DOT, wx.LONG_DASH, wx.SHORT_DASH, wx.DOT_DASH, wx.USER_DASH]:
 121                 pen = wx.Pen("DARK ORCHID", 1, style)
 122                 if style == wx.USER_DASH:
 123                     pen.SetCap(wx.CAP_BUTT)
 124                     pen.SetDashes([1,2])
 125                     pen.SetColour("RED")
 126                 dc.SetPen(pen)
 127                 dc.DrawLine(300,y, 400,y)
 128                 y = y + 10
 129
 130         dc.SetBrush(wx.TRANSPARENT_BRUSH)
 131         dc.SetPen(wx.Pen(wx.Colour(0xFF, 0x20, 0xFF), 1, wx.SOLID))
 132         dc.DrawRectangle(450,50,  100,100)
 133         old_pen = dc.GetPen()
 134         new_pen = wx.Pen("BLACK", 5)
 135         dc.SetPen(new_pen)
 136         dc.DrawRectangle(470,70,  60,60)
 137         dc.SetPen(old_pen)
 138         dc.DrawRectangle(490,90, 20,20)
 139
 140         self.DrawSavedLines(dc)
 141         dc.EndDrawing()
 142
 143
 144     def DrawSavedLines(self, dc):
 145         dc.SetPen(wx.Pen('MEDIUM FOREST GREEN', 4))
 146
 147         for line in self.lines:
 148             for coords in line:
 149                 apply(dc.DrawLine, coords)
 150
 151
 152     def SetXY(self, event):
 153         self.x, self.y = self.ConvertEventCoords(event)
 154
 155     def ConvertEventCoords(self, event):
 156         xView, yView = self.GetViewStart()
 157         xDelta, yDelta = self.GetScrollPixelsPerUnit()
 158         return (event.GetX() + (xView * xDelta),
 159                 event.GetY() + (yView * yDelta))
 160
 161     def OnLeftButtonEvent(self, event):
 162         if event.LeftDown():
 163             self.SetFocus()
 164             self.SetXY(event)
 165             self.curLine = []
 166             self.CaptureMouse()
 167             self.drawing = True
 168
 169         elif event.Dragging() and self.drawing:
 170             if BUFFERED:
 171                 # If doing buffered drawing, create the buffered DC, giving it
 172                 # it a real DC to blit to when done.
 173                 cdc = wx.ClientDC(self)
 174                 self.PrepareDC(cdc)
 175                 dc = wx.BufferedDC(cdc, self.buffer)
 176             else:
 177                 dc = wx.ClientDC(self)
 178                 self.PrepareDC(dc)
 179
 180             dc.BeginDrawing()
 181             dc.SetPen(wx.Pen('MEDIUM FOREST GREEN', 4))
 182             coords = (self.x, self.y) + self.ConvertEventCoords(event)
 183             self.curLine.append(coords)
 184             dc.DrawLine(*coords)
 185             self.SetXY(event)
 186             dc.EndDrawing()
 187
 188
 189         elif event.LeftUp() and self.drawing:
 190             self.lines.append(self.curLine)
 191             self.curLine = []
 192             self.ReleaseMouse()
 193             self.drawing = False
 194
 195
 196 ## This is an example of what to do for the EVT_MOUSEWHEEL event,
 197 ## but since wx.ScrolledWindow does this already it's not
 198 ## necessary to do it ourselves. You would need to add an event table
 199 ## entry to __init__() to direct wheelmouse events to this handler.
 200
 201 ##     wheelScroll = 0
 202 ##     def OnWheel(self, evt):
 203 ##         delta = evt.GetWheelDelta()
 204 ##         rot = evt.GetWheelRotation()
 205 ##         linesPer = evt.GetLinesPerAction()
 206 ##         print delta, rot, linesPer
 207 ##         ws = self.wheelScroll
 208 ##         ws = ws + rot
 209 ##         lines = ws / delta
 210 ##         ws = ws - lines * delta
 211 ##         self.wheelScroll = ws
 212 ##         if lines != 0:
 213 ##             lines = lines * linesPer
 214 ##             vsx, vsy = self.GetViewStart()
 215 ##             scrollTo = vsy - lines
 216 ##             self.Scroll(-1, scrollTo)
 217
 218 #---------------------------------------------------------------------------
 219
 220 def runTest(frame, nb, log):
 221     win = MyCanvas(nb)
 222     return win
 223
 224 #---------------------------------------------------------------------------
 225
 226
 227
 228 overview = """
 229 <html>
 230 <body>
 231 The wx.ScrolledWindow class manages scrolling for its client area, transforming the
 232 coordinates according to the scrollbar positions, and setting the scroll positions,
 233 thumb sizes and ranges according to the area in view.
 234 </body>
 235 </html>
 236 """
 237
 238
 239 if __name__ == '__main__':
 240     import sys,os
 241     import run
 242     run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
 243