| | 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 | |
projects / wxWidgets.git / blame_incremental