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         dc.GradientFillLinear((20, 260, 50, 50),
 141                               "red", "blue")
 142         dc.GradientFillConcentric((20, 325, 50, 50),
 143                                   "red", "blue", (25,25))
 144         self.DrawSavedLines(dc)
 145         dc.EndDrawing()
 146
 147
 148     def DrawSavedLines(self, dc):
 149         dc.SetPen(wx.Pen('MEDIUM FOREST GREEN', 4))
 150
 151         for line in self.lines:
 152             for coords in line:
 153                 apply(dc.DrawLine, coords)
 154
 155
 156     def SetXY(self, event):
 157         self.x, self.y = self.ConvertEventCoords(event)
 158
 159     def ConvertEventCoords(self, event):
 160         xView, yView = self.GetViewStart()
 161         xDelta, yDelta = self.GetScrollPixelsPerUnit()
 162         return (event.GetX() + (xView * xDelta),
 163                 event.GetY() + (yView * yDelta))
 164
 165     def OnLeftButtonEvent(self, event):
 166         if event.LeftDown():
 167             self.SetFocus()
 168             self.SetXY(event)
 169             self.curLine = []
 170             self.CaptureMouse()
 171             self.drawing = True
 172
 173         elif event.Dragging() and self.drawing:
 174             if BUFFERED:
 175                 # If doing buffered drawing, create the buffered DC, giving it
 176                 # it a real DC to blit to when done.
 177                 cdc = wx.ClientDC(self)
 178                 self.PrepareDC(cdc)
 179                 dc = wx.BufferedDC(cdc, self.buffer)
 180             else:
 181                 dc = wx.ClientDC(self)
 182                 self.PrepareDC(dc)
 183
 184             dc.BeginDrawing()
 185             dc.SetPen(wx.Pen('MEDIUM FOREST GREEN', 4))
 186             coords = (self.x, self.y) + self.ConvertEventCoords(event)
 187             self.curLine.append(coords)
 188             dc.DrawLine(*coords)
 189             self.SetXY(event)
 190             dc.EndDrawing()
 191
 192
 193         elif event.LeftUp() and self.drawing:
 194             self.lines.append(self.curLine)
 195             self.curLine = []
 196             self.ReleaseMouse()
 197             self.drawing = False
 198
 199
 200 ## This is an example of what to do for the EVT_MOUSEWHEEL event,
 201 ## but since wx.ScrolledWindow does this already it's not
 202 ## necessary to do it ourselves. You would need to add an event table
 203 ## entry to __init__() to direct wheelmouse events to this handler.
 204
 205 ##     wheelScroll = 0
 206 ##     def OnWheel(self, evt):
 207 ##         delta = evt.GetWheelDelta()
 208 ##         rot = evt.GetWheelRotation()
 209 ##         linesPer = evt.GetLinesPerAction()
 210 ##         print delta, rot, linesPer
 211 ##         ws = self.wheelScroll
 212 ##         ws = ws + rot
 213 ##         lines = ws / delta
 214 ##         ws = ws - lines * delta
 215 ##         self.wheelScroll = ws
 216 ##         if lines != 0:
 217 ##             lines = lines * linesPer
 218 ##             vsx, vsy = self.GetViewStart()
 219 ##             scrollTo = vsy - lines
 220 ##             self.Scroll(-1, scrollTo)
 221
 222 #---------------------------------------------------------------------------
 223
 224 def runTest(frame, nb, log):
 225     win = MyCanvas(nb)
 226     return win
 227
 228 #---------------------------------------------------------------------------
 229
 230
 231
 232 overview = """
 233 <html>
 234 <body>
 235 The wx.ScrolledWindow class manages scrolling for its client area, transforming the
 236 coordinates according to the scrollbar positions, and setting the scroll positions,
 237 thumb sizes and ranges according to the area in view.
 238 </body>
 239 </html>
 240 """
 241
 242
 243 if __name__ == '__main__':
 244     import sys,os
 245     import run
 246     run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
 247