projects / wxWidgets.git / blame
| Commit | Line | Data |
|---|---|---|
| 0b0849b5 | 1 | #!/usr/bin/env python |
| 2a0495c9 | 2 | |
| 8b9a4190 | 3 | try: |
| 0b0849b5 RD |
4 | import numpy as N |
| 5 | import numpy.random as RandomArray | |
| 6 | haveNumpy = True | |
| 7 | #print "Using numpy, version:", N.__version__ | |
| 8b9a4190 | 8 | except ImportError: |
| 0b0849b5 RD |
9 | # numpy isn't there |
| 10 | haveNumpy = False | |
| 11 | errorText = ( | |
| 12 | "The FloatCanvas requires the numpy module, version 1.* \n\n" | |
| 13 | "You can get info about it at:\n" | |
| 14 | "http://numpy.scipy.org/\n\n" | |
| 15 | ) | |
| 2a0495c9 | 16 | |
| 2e839e96 | 17 | #--------------------------------------------------------------------------- |
| 34a544a6 | 18 | |
| 095315e2 | 19 | |
| 2a0495c9 | 20 | def BuildDrawFrame(): # this gets called when needed, rather than on import |
| 42463de2 | 21 | try: |
| 095315e2 | 22 | from floatcanvas import NavCanvas, FloatCanvas, Resources |
| 42463de2 | 23 | except ImportError: # if it's not there locally, try the wxPython lib. |
| 095315e2 | 24 | from wx.lib.floatcanvas import NavCanvas, FloatCanvas, Resources |
| 2a0495c9 RD |
25 | import wx.lib.colourdb |
| 26 | import time, random | |
| 2e839e96 | 27 | |
| 8fa876ca | 28 | class DrawFrame(wx.Frame): |
| 2e839e96 | 29 | |
| 8b9a4190 | 30 | """ |
| 8b9a4190 | 31 | A frame used for the FloatCanvas Demo |
| 2e839e96 | 32 | |
| 8b9a4190 | 33 | """ |
| 2e839e96 RD |
34 | |
| 35 | ||
| 42463de2 | 36 | def __init__(self,parent, id,title,position,size): |
| 8fa876ca | 37 | wx.Frame.__init__(self,parent, id,title,position, size) |
| 2e839e96 | 38 | |
| 42463de2 | 39 | ## Set up the MenuBar |
| 8fa876ca | 40 | MenuBar = wx.MenuBar() |
| 2e839e96 | 41 | |
| 8fa876ca | 42 | file_menu = wx.Menu() |
| 42463de2 RD |
43 | item = file_menu.Append(-1, "&Close","Close this frame") |
| 44 | self.Bind(wx.EVT_MENU, self.OnQuit, item) | |
| 095315e2 RD |
45 | |
| 46 | item = file_menu.Append(-1, "&SavePNG","Save the current image as a PNG") | |
| 47 | self.Bind(wx.EVT_MENU, self.OnSavePNG, item) | |
| 8b9a4190 | 48 | MenuBar.Append(file_menu, "&File") |
| 2e839e96 | 49 | |
| 8fa876ca | 50 | draw_menu = wx.Menu() |
| 8fa876ca | 51 | |
| 095315e2 RD |
52 | item = draw_menu.Append(-1, "&Clear","Clear the Canvas") |
| 53 | self.Bind(wx.EVT_MENU, self.Clear, item) | |
| 54 | ||
| 42463de2 RD |
55 | item = draw_menu.Append(-1, "&Draw Test","Run a test of drawing random components") |
| 56 | self.Bind(wx.EVT_MENU, self.DrawTest, item) | |
| 57 | ||
| 58 | item = draw_menu.Append(-1, "&Line Test","Run a test of drawing random lines") | |
| 59 | self.Bind(wx.EVT_MENU, self.LineTest, item) | |
| 2e839e96 | 60 | |
| 42463de2 RD |
61 | item = draw_menu.Append(-1, "Draw &Map","Run a test of drawing a map") |
| 62 | self.Bind(wx.EVT_MENU, self.DrawMap, item) | |
| 095315e2 | 63 | |
| 42463de2 RD |
64 | item = draw_menu.Append(-1, "&Text Test","Run a test of text drawing") |
| 65 | self.Bind(wx.EVT_MENU, self.TestText, item) | |
| 095315e2 | 66 | |
| 42463de2 RD |
67 | item = draw_menu.Append(-1, "&ScaledText Test","Run a test of text drawing") |
| 68 | self.Bind(wx.EVT_MENU, self.TestScaledText, item) | |
| 095315e2 RD |
69 | |
| 70 | item = draw_menu.Append(-1, "&ScaledTextBox Test","Run a test of the Scaled Text Box") | |
| 71 | self.Bind(wx.EVT_MENU, self.TestScaledTextBox, item) | |
| 72 | ||
| 73 | item = draw_menu.Append(-1, "&Bitmap Test","Run a test of the Bitmap Object") | |
| 74 | self.Bind(wx.EVT_MENU, self.TestBitmap, item) | |
| 75 | ||
| 42463de2 RD |
76 | item = draw_menu.Append(-1, "&Hit Test","Run a test of the hit test code") |
| 77 | self.Bind(wx.EVT_MENU, self.TestHitTest, item) | |
| 095315e2 | 78 | |
| 5e1796ef | 79 | item = draw_menu.Append(-1, "Hit Test &Foreground","Run a test of the hit test code with a foreground Object") |
| 42463de2 | 80 | self.Bind(wx.EVT_MENU, self.TestHitTestForeground, item) |
| 095315e2 | 81 | |
| 42463de2 RD |
82 | item = draw_menu.Append(-1, "&Animation","Run a test of Animation") |
| 83 | self.Bind(wx.EVT_MENU, self.TestAnimation, item) | |
| 095315e2 RD |
84 | |
| 85 | #item = draw_menu.Append(-1, "&Speed","Run a test of Drawing Speed") | |
| 86 | #self.Bind(wx.EVT_MENU, self.SpeedTest, item) | |
| 87 | ||
| 5e1796ef RD |
88 | item = draw_menu.Append(-1, "Change &Properties","Run a test of Changing Object Properties") |
| 89 | self.Bind(wx.EVT_MENU, self.PropertiesChangeTest, item) | |
| 095315e2 | 90 | |
| 2a0495c9 RD |
91 | item = draw_menu.Append(-1, "&Arrows","Run a test of Arrows") |
| 92 | self.Bind(wx.EVT_MENU, self.ArrowTest, item) | |
| 93 | ||
| 0b0849b5 RD |
94 | item = draw_menu.Append(-1, "&ArrowLine Test","Run a test of drawing Arrow Lines") |
| 95 | self.Bind(wx.EVT_MENU, self.ArrowLineTest, item) | |
| 96 | ||
| 97 | item = draw_menu.Append(-1, "&Hide","Run a test of hiding and showing objects") | |
| 095315e2 RD |
98 | self.Bind(wx.EVT_MENU, self.HideTest, item) |
| 99 | ||
| 42463de2 | 100 | MenuBar.Append(draw_menu, "&Tests") |
| 2e839e96 | 101 | |
| 8fa876ca | 102 | view_menu = wx.Menu() |
| 42463de2 RD |
103 | item = view_menu.Append(-1, "Zoom to &Fit","Zoom to fit the window") |
| 104 | self.Bind(wx.EVT_MENU, self.ZoomToFit, item) | |
| 8b9a4190 | 105 | MenuBar.Append(view_menu, "&View") |
| 2e839e96 | 106 | |
| 8fa876ca | 107 | help_menu = wx.Menu() |
| 42463de2 | 108 | item = help_menu.Append(-1, "&About", |
| 8b9a4190 | 109 | "More information About this program") |
| 42463de2 | 110 | self.Bind(wx.EVT_MENU, self.OnAbout, item) |
| 8b9a4190 | 111 | MenuBar.Append(help_menu, "&Help") |
| 2e839e96 | 112 | |
| 8b9a4190 | 113 | self.SetMenuBar(MenuBar) |
| 2e839e96 | 114 | |
| 095315e2 RD |
115 | self.CreateStatusBar() |
| 116 | ||
| 117 | ||
| 8b9a4190 | 118 | # Add the Canvas |
| 0b0849b5 RD |
119 | NC = NavCanvas.NavCanvas(self, |
| 120 | Debug = 0, | |
| 121 | BackgroundColor = "DARK SLATE BLUE") | |
| 122 | ||
| 123 | self.Canvas = NC.Canvas # reference the contained FloatCanvas | |
| 42463de2 | 124 | |
| 095315e2 RD |
125 | self.MsgWindow = wx.TextCtrl(self, wx.ID_ANY, |
| 126 | "Look Here for output from events\n", | |
| 127 | style = (wx.TE_MULTILINE | | |
| 128 | wx.TE_READONLY | | |
| 129 | wx.SUNKEN_BORDER) | |
| 130 | ) | |
| 131 | ||
| 132 | ##Create a sizer to manage the Canvas and message window | |
| 133 | MainSizer = wx.BoxSizer(wx.VERTICAL) | |
| 0b0849b5 | 134 | MainSizer.Add(NC, 4, wx.EXPAND) |
| 095315e2 RD |
135 | MainSizer.Add(self.MsgWindow, 1, wx.EXPAND | wx.ALL, 5) |
| 136 | ||
| 137 | self.SetSizer(MainSizer) | |
| 0b0849b5 | 138 | self.Bind(wx.EVT_CLOSE, self.OnCloseWindow) |
| 42463de2 | 139 | |
| 0b0849b5 RD |
140 | self.Canvas.Bind(FloatCanvas.EVT_MOTION, self.OnMove) |
| 141 | self.Canvas.Bind(FloatCanvas.EVT_MOUSEWHEEL, self.OnWheel) | |
| 42463de2 RD |
142 | |
| 143 | self.EventsAreBound = False | |
| 144 | ||
| 095315e2 | 145 | ## getting all the colors for random objects |
| 2a0495c9 RD |
146 | wx.lib.colourdb.updateColourDB() |
| 147 | self.colors = wx.lib.colourdb.getColourList() | |
| 42463de2 RD |
148 | |
| 149 | ||
| 8b9a4190 | 150 | return None |
| 42463de2 | 151 | |
| 095315e2 RD |
152 | def Log(self, text): |
| 153 | self.MsgWindow.AppendText(text) | |
| 154 | if not text[-1] == "\n": | |
| 155 | self.MsgWindow.AppendText("\n") | |
| 156 | ||
| 157 | ||
| 42463de2 RD |
158 | def BindAllMouseEvents(self): |
| 159 | if not self.EventsAreBound: | |
| 160 | ## Here is how you catch FloatCanvas mouse events | |
| 0b0849b5 RD |
161 | self.Canvas.Bind(FloatCanvas.EVT_LEFT_DOWN, self.OnLeftDown) |
| 162 | self.Canvas.Bind(FloatCanvas.EVT_LEFT_UP, self.OnLeftUp) | |
| 163 | self.Canvas.Bind(FloatCanvas.EVT_LEFT_DCLICK, self.OnLeftDouble) | |
| 42463de2 | 164 | |
| 0b0849b5 RD |
165 | self.Canvas.Bind(FloatCanvas.EVT_MIDDLE_DOWN, self.OnMiddleDown) |
| 166 | self.Canvas.Bind(FloatCanvas.EVT_MIDDLE_UP, self.OnMiddleUp) | |
| 167 | self.Canvas.Bind(FloatCanvas.EVT_MIDDLE_DCLICK, self.OnMiddleDouble) | |
| 42463de2 | 168 | |
| 0b0849b5 RD |
169 | self.Canvas.Bind(FloatCanvas.EVT_RIGHT_DOWN, self.OnRightDown) |
| 170 | self.Canvas.Bind(FloatCanvas.EVT_RIGHT_UP, self.OnRightUp) | |
| 171 | self.Canvas.Bind(FloatCanvas.EVT_RIGHT_DCLICK, self.OnRightDouble) | |
| 42463de2 | 172 | |
| 42463de2 RD |
173 | self.EventsAreBound = True |
| 174 | ||
| 0b0849b5 | 175 | |
| 42463de2 | 176 | def UnBindAllMouseEvents(self): |
| 2a0495c9 | 177 | ## Here is how you unbind FloatCanvas mouse events |
| 0b0849b5 RD |
178 | self.Canvas.Unbind(FloatCanvas.EVT_LEFT_DOWN) |
| 179 | self.Canvas.Unbind(FloatCanvas.EVT_LEFT_UP) | |
| 180 | self.Canvas.Unbind(FloatCanvas.EVT_LEFT_DCLICK) | |
| 42463de2 | 181 | |
| 0b0849b5 RD |
182 | self.Canvas.Unbind(FloatCanvas.EVT_MIDDLE_DOWN) |
| 183 | self.Canvas.Unbind(FloatCanvas.EVT_MIDDLE_UP) | |
| 184 | self.Canvas.Unbind(FloatCanvas.EVT_MIDDLE_DCLICK) | |
| 42463de2 | 185 | |
| 0b0849b5 RD |
186 | self.Canvas.Unbind(FloatCanvas.EVT_RIGHT_DOWN) |
| 187 | self.Canvas.Unbind(FloatCanvas.EVT_RIGHT_UP) | |
| 188 | self.Canvas.Unbind(FloatCanvas.EVT_RIGHT_DCLICK) | |
| 42463de2 RD |
189 | |
| 190 | self.EventsAreBound = False | |
| 191 | ||
| 42463de2 | 192 | |
| 095315e2 | 193 | def PrintCoords(self,event): |
| 095315e2 RD |
194 | self.Log("coords are: %s"%(event.Coords,)) |
| 195 | self.Log("pixel coords are: %s\n"%(event.GetPosition(),)) | |
| 196 | ||
| 197 | def OnSavePNG(self, event=None): | |
| 198 | import os | |
| 199 | dlg = wx.FileDialog( | |
| 200 | self, message="Save file as ...", defaultDir=os.getcwd(), | |
| 201 | defaultFile="", wildcard="*.png", style=wx.SAVE | |
| 202 | ) | |
| 203 | if dlg.ShowModal() == wx.ID_OK: | |
| 204 | path = dlg.GetPath() | |
| 205 | if not(path[-4:].lower() == ".png"): | |
| 206 | path = path+".png" | |
| 207 | self.Canvas.SaveAsImage(path) | |
| 208 | ||
| 209 | ||
| 42463de2 | 210 | def OnLeftDown(self, event): |
| 095315e2 | 211 | self.Log("LeftDown") |
| 42463de2 RD |
212 | self.PrintCoords(event) |
| 213 | ||
| 214 | def OnLeftUp(self, event): | |
| 095315e2 | 215 | self.Log("LeftUp") |
| 42463de2 RD |
216 | self.PrintCoords(event) |
| 217 | ||
| 218 | def OnLeftDouble(self, event): | |
| 095315e2 | 219 | self.Log("LeftDouble") |
| 42463de2 RD |
220 | self.PrintCoords(event) |
| 221 | ||
| 222 | def OnMiddleDown(self, event): | |
| 095315e2 | 223 | self.Log("MiddleDown") |
| 42463de2 RD |
224 | self.PrintCoords(event) |
| 225 | ||
| 226 | def OnMiddleUp(self, event): | |
| 095315e2 | 227 | self.Log("MiddleUp") |
| 42463de2 RD |
228 | self.PrintCoords(event) |
| 229 | ||
| 230 | def OnMiddleDouble(self, event): | |
| 095315e2 | 231 | self.Log("MiddleDouble") |
| 42463de2 RD |
232 | self.PrintCoords(event) |
| 233 | ||
| 234 | def OnRightDown(self, event): | |
| 095315e2 | 235 | self.Log("RightDown") |
| 42463de2 RD |
236 | self.PrintCoords(event) |
| 237 | ||
| 238 | def OnRightUp(self, event): | |
| 0b0849b5 | 239 | self.Log("RightUp") |
| 42463de2 RD |
240 | self.PrintCoords(event) |
| 241 | ||
| 242 | def OnRightDouble(self, event): | |
| 095315e2 | 243 | self.Log("RightDouble") |
| 42463de2 RD |
244 | self.PrintCoords(event) |
| 245 | ||
| 246 | def OnWheel(self, event): | |
| 095315e2 | 247 | self.Log("Mouse Wheel") |
| 42463de2 | 248 | self.PrintCoords(event) |
| 2a0495c9 | 249 | Rot = event.GetWheelRotation() |
| 2a0495c9 RD |
250 | Rot = Rot / abs(Rot) * 0.1 |
| 251 | if event.ControlDown(): # move left-right | |
| 252 | self.Canvas.MoveImage( (Rot, 0), "Panel" ) | |
| 253 | else: # move up-down | |
| 254 | self.Canvas.MoveImage( (0, Rot), "Panel" ) | |
| 255 | ||
| 42463de2 RD |
256 | def OnMove(self, event): |
| 257 | """ | |
| 2a0495c9 | 258 | Updates the status bar with the world coordinates |
| 42463de2 RD |
259 | """ |
| 260 | self.SetStatusText("%.2f, %.2f"%tuple(event.Coords)) | |
| 0b0849b5 | 261 | event.Skip() |
| 42463de2 | 262 | |
| 8b9a4190 | 263 | def OnAbout(self, event): |
| 095315e2 RD |
264 | dlg = wx.MessageDialog(self, |
| 265 | "This is a small program to demonstrate\n" | |
| 266 | "the use of the FloatCanvas\n", | |
| 267 | "About Me", | |
| 268 | wx.OK | wx.ICON_INFORMATION) | |
| 8b9a4190 RD |
269 | dlg.ShowModal() |
| 270 | dlg.Destroy() | |
| 2e839e96 | 271 | |
| 8b9a4190 RD |
272 | def ZoomToFit(self,event): |
| 273 | self.Canvas.ZoomToBB() | |
| 2e839e96 | 274 | |
| 8b9a4190 | 275 | def Clear(self,event = None): |
| 42463de2 | 276 | self.UnBindAllMouseEvents() |
| 0b0849b5 | 277 | self.Canvas.InitAll() |
| 8b9a4190 | 278 | self.Canvas.Draw() |
| 2e839e96 | 279 | |
| 8b9a4190 RD |
280 | def OnQuit(self,event): |
| 281 | self.Close(True) | |
| 2e839e96 | 282 | |
| 8b9a4190 RD |
283 | def OnCloseWindow(self, event): |
| 284 | self.Destroy() | |
| 2e839e96 | 285 | |
| 42463de2 | 286 | def DrawTest(self,event=None): |
| 0b0849b5 RD |
287 | """ |
| 288 | This demo draws a few of everything | |
| 289 | ||
| 290 | """ | |
| 291 | ||
| 292 | wx.GetApp().Yield(True) | |
| 2a0495c9 | 293 | |
| 8b9a4190 | 294 | Range = (-10,10) |
| 42463de2 RD |
295 | colors = self.colors |
| 296 | ||
| 297 | self.BindAllMouseEvents() | |
| 8b9a4190 | 298 | Canvas = self.Canvas |
| 42463de2 | 299 | |
| 0b0849b5 RD |
300 | Canvas.InitAll() |
| 301 | # | |
| 302 | ## these set the limits for how much you can zoom in and out | |
| 303 | Canvas.MinScale = 14 | |
| 304 | Canvas.MaxScale = 500 | |
| 305 | ||
| 42463de2 | 306 | |
| 095315e2 | 307 | ############# Random tests of everything ############## |
| 2e839e96 | 308 | |
| 8b9a4190 | 309 | # Rectangles |
| 42463de2 | 310 | for i in range(3): |
| 095315e2 | 311 | xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1])) |
| 8b9a4190 RD |
312 | lw = random.randint(1,5) |
| 313 | cf = random.randint(0,len(colors)-1) | |
| 095315e2 RD |
314 | wh = (random.randint(1,5), random.randint(1,5)) |
| 315 | Canvas.AddRectangle(xy, wh, LineWidth = lw, FillColor = colors[cf]) | |
| 2e839e96 | 316 | |
| 42463de2 RD |
317 | # Ellipses |
| 318 | for i in range(3): | |
| 095315e2 | 319 | xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1])) |
| 8b9a4190 RD |
320 | lw = random.randint(1,5) |
| 321 | cf = random.randint(0,len(colors)-1) | |
| 322 | h = random.randint(1,5) | |
| 323 | w = random.randint(1,5) | |
| 095315e2 | 324 | Canvas.AddEllipse(xy, (h,w), LineWidth = lw,FillColor = colors[cf]) |
| 2e839e96 | 325 | |
| 5e1796ef RD |
326 | # Points |
| 327 | for i in range(5): | |
| 095315e2 | 328 | xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1])) |
| 5e1796ef RD |
329 | D = random.randint(1,50) |
| 330 | cf = random.randint(0,len(colors)-1) | |
| 095315e2 RD |
331 | Canvas.AddPoint(xy, Color = colors[cf], Diameter = D) |
| 332 | ||
| 333 | # SquarePoints | |
| 334 | for i in range(500): | |
| 335 | xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1])) | |
| 336 | S = random.randint(1, 50) | |
| 337 | cf = random.randint(0,len(colors)-1) | |
| 338 | Canvas.AddSquarePoint(xy, Color = colors[cf], Size = S) | |
| 339 | ||
| 2a0495c9 | 340 | # Circles |
| 8b9a4190 | 341 | for i in range(5): |
| 095315e2 | 342 | xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1])) |
| 8b9a4190 RD |
343 | D = random.randint(1,5) |
| 344 | lw = random.randint(1,5) | |
| 345 | cf = random.randint(0,len(colors)-1) | |
| 346 | cl = random.randint(0,len(colors)-1) | |
| 095315e2 RD |
347 | Canvas.AddCircle(xy, D, LineWidth = lw, LineColor = colors[cl], FillColor = colors[cf]) |
| 348 | Canvas.AddText("Circle # %i"%(i), xy, Size = 12, BackgroundColor = None, Position = "cc") | |
| 2a0495c9 | 349 | # Lines |
| 8b9a4190 RD |
350 | for i in range(5): |
| 351 | points = [] | |
| 352 | for j in range(random.randint(2,10)): | |
| 353 | point = (random.randint(Range[0],Range[1]),random.randint(Range[0],Range[1])) | |
| 354 | points.append(point) | |
| 355 | lw = random.randint(1,10) | |
| 356 | cf = random.randint(0,len(colors)-1) | |
| 357 | cl = random.randint(0,len(colors)-1) | |
| 42463de2 | 358 | Canvas.AddLine(points, LineWidth = lw, LineColor = colors[cl]) |
| 2a0495c9 | 359 | # Polygons |
| 8b9a4190 RD |
360 | for i in range(3): |
| 361 | points = [] | |
| 362 | for j in range(random.randint(2,6)): | |
| 363 | point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1])) | |
| 364 | points.append(point) | |
| 365 | lw = random.randint(1,6) | |
| 366 | cf = random.randint(0,len(colors)-1) | |
| 367 | cl = random.randint(0,len(colors)-1) | |
| 42463de2 RD |
368 | Canvas.AddPolygon(points, |
| 369 | LineWidth = lw, | |
| 370 | LineColor = colors[cl], | |
| 371 | FillColor = colors[cf], | |
| 372 | FillStyle = 'Solid') | |
| 2e839e96 | 373 | |
| 8b9a4190 RD |
374 | ## Pointset |
| 375 | for i in range(4): | |
| 376 | points = [] | |
| 377 | points = RandomArray.uniform(Range[0],Range[1],(100,2)) | |
| 378 | cf = random.randint(0,len(colors)-1) | |
| 379 | D = random.randint(1,4) | |
| 42463de2 | 380 | Canvas.AddPointSet(points, Color = colors[cf], Diameter = D) |
| 2e839e96 | 381 | |
| 8b9a4190 | 382 | # Text |
| 42463de2 RD |
383 | String = "Unscaled text" |
| 384 | for i in range(3): | |
| 8b9a4190 RD |
385 | ts = random.randint(10,40) |
| 386 | cf = random.randint(0,len(colors)-1) | |
| 095315e2 RD |
387 | xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1])) |
| 388 | Canvas.AddText(String, xy, Size = ts, Color = colors[cf], Position = "cc") | |
| 42463de2 RD |
389 | |
| 390 | # Scaled Text | |
| 391 | String = "Scaled text" | |
| 392 | for i in range(3): | |
| 393 | ts = random.random()*3 + 0.2 | |
| 394 | cf = random.randint(0,len(colors)-1) | |
| 095315e2 RD |
395 | Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1])) |
| 396 | Canvas.AddScaledText(String, Point, Size = ts, Color = colors[cf], Position = "cc") | |
| 42463de2 | 397 | |
| 2a0495c9 RD |
398 | # Arrows |
| 399 | N = 5 | |
| 400 | Points = RandomArray.uniform(Range[0], Range[1], (N,2) ) | |
| 401 | for i in range(N): | |
| 402 | Canvas.AddArrow(Points[i], | |
| 403 | random.uniform(20,100), | |
| 404 | Direction = random.uniform(0,360), | |
| 405 | LineWidth = random.uniform(1,5), | |
| 406 | LineColor = colors[random.randint(0,len(colors)-1)], | |
| 407 | ArrowHeadAngle = random.uniform(20,90)) | |
| 408 | ||
| 0b0849b5 RD |
409 | # ArrowLines |
| 410 | for i in range(5): | |
| 411 | points = [] | |
| 412 | for j in range(random.randint(2,10)): | |
| 413 | point = (random.randint(Range[0],Range[1]),random.randint(Range[0],Range[1])) | |
| 414 | points.append(point) | |
| 415 | lw = random.randint(1,10) | |
| 416 | cf = random.randint(0,len(colors)-1) | |
| 417 | cl = random.randint(0,len(colors)-1) | |
| 418 | Canvas.AddArrowLine(points, LineWidth = lw, LineColor = colors[cl], ArrowHeadSize= 16) | |
| 419 | ||
| 420 | ||
| 42463de2 RD |
421 | Canvas.ZoomToBB() |
| 422 | ||
| 423 | def TestAnimation(self,event=None): | |
| 424 | """ | |
| 425 | ||
| 426 | In this test, a relatively complex background is drawn, and | |
| 427 | a simple object placed in the foreground is moved over | |
| 428 | it. This demonstrates how to use the InForeground attribute | |
| 429 | to make an object in the foregorund draw fast, without | |
| 430 | having to re-draw the whole background. | |
| 431 | ||
| 432 | """ | |
| 0b0849b5 | 433 | wx.GetApp().Yield(True) |
| 42463de2 RD |
434 | Range = (-10,10) |
| 435 | self.Range = Range | |
| 436 | ||
| 437 | self.UnBindAllMouseEvents() | |
| 438 | Canvas = self.Canvas | |
| 0b0849b5 | 439 | Canvas.InitAll() |
| 42463de2 | 440 | |
| 095315e2 | 441 | ## Random tests of everything: |
| 42463de2 RD |
442 | colors = self.colors |
| 443 | # Rectangles | |
| 444 | for i in range(3): | |
| 095315e2 | 445 | xy = (random.uniform(Range[0],Range[1]), random.uniform(Range[0],Range[1])) |
| 42463de2 RD |
446 | lw = random.randint(1,5) |
| 447 | cf = random.randint(0,len(colors)-1) | |
| 095315e2 RD |
448 | wh = (random.randint(1,5), random.randint(1,5) ) |
| 449 | Canvas.AddRectangle(xy, wh, LineWidth = lw, FillColor = colors[cf]) | |
| 2e839e96 | 450 | |
| 42463de2 RD |
451 | # Ellipses |
| 452 | for i in range(3): | |
| 095315e2 | 453 | xy = (random.uniform(Range[0],Range[1]), random.uniform(Range[0],Range[1])) |
| 42463de2 RD |
454 | lw = random.randint(1,5) |
| 455 | cf = random.randint(0,len(colors)-1) | |
| 095315e2 RD |
456 | wh = (random.randint(1,5), random.randint(1,5) ) |
| 457 | Canvas.AddEllipse(xy, wh, LineWidth = lw, FillColor = colors[cf]) | |
| 2e839e96 | 458 | |
| 42463de2 RD |
459 | # Circles |
| 460 | for i in range(5): | |
| 095315e2 | 461 | xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1])) |
| 42463de2 RD |
462 | D = random.randint(1,5) |
| 463 | lw = random.randint(1,5) | |
| 464 | cf = random.randint(0,len(colors)-1) | |
| 465 | cl = random.randint(0,len(colors)-1) | |
| 095315e2 RD |
466 | Canvas.AddCircle(xy, D, LineWidth = lw, LineColor = colors[cl], FillColor = colors[cf]) |
| 467 | Canvas.AddText("Circle # %i"%(i), xy, Size = 12, BackgroundColor = None, Position = "cc") | |
| 2e839e96 | 468 | |
| 42463de2 RD |
469 | # Lines |
| 470 | for i in range(5): | |
| 471 | points = [] | |
| 472 | for j in range(random.randint(2,10)): | |
| 473 | point = (random.randint(Range[0],Range[1]),random.randint(Range[0],Range[1])) | |
| 474 | points.append(point) | |
| 475 | lw = random.randint(1,10) | |
| 476 | cf = random.randint(0,len(colors)-1) | |
| 477 | cl = random.randint(0,len(colors)-1) | |
| 478 | Canvas.AddLine(points, LineWidth = lw, LineColor = colors[cl]) | |
| 2e839e96 | 479 | |
| 42463de2 RD |
480 | # Polygons |
| 481 | for i in range(3): | |
| 482 | points = [] | |
| 483 | for j in range(random.randint(2,6)): | |
| 484 | point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1])) | |
| 485 | points.append(point) | |
| 486 | lw = random.randint(1,6) | |
| 487 | cf = random.randint(0,len(colors)-1) | |
| 488 | cl = random.randint(0,len(colors)-1) | |
| 489 | Canvas.AddPolygon(points, | |
| 490 | LineWidth = lw, | |
| 491 | LineColor = colors[cl], | |
| 492 | FillColor = colors[cf], | |
| 493 | FillStyle = 'Solid') | |
| 2e839e96 | 494 | |
| 42463de2 RD |
495 | # Scaled Text |
| 496 | String = "Scaled text" | |
| 497 | for i in range(3): | |
| 498 | ts = random.random()*3 + 0.2 | |
| 499 | cf = random.randint(0,len(colors)-1) | |
| 095315e2 RD |
500 | xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1])) |
| 501 | Canvas.AddScaledText(String, xy, Size = ts, Color = colors[cf], Position = "cc") | |
| 42463de2 RD |
502 | |
| 503 | ||
| 504 | # Now the Foreground Object: | |
| 095315e2 RD |
505 | C = Canvas.AddCircle((0,0), 7, LineWidth = 2,LineColor = "Black",FillColor = "Red", InForeground = True) |
| 506 | T = Canvas.AddScaledText("Click to Move", (0,0), Size = 0.6, Position = 'cc', InForeground = True) | |
| 42463de2 RD |
507 | C.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.MoveMe) |
| 508 | C.Text = T | |
| 509 | ||
| 510 | self.Timer = wx.PyTimer(self.ShowFrame) | |
| 511 | self.FrameDelay = 50 # milliseconds | |
| 2e839e96 | 512 | |
| 42463de2 RD |
513 | Canvas.ZoomToBB() |
| 514 | ||
| 515 | def ShowFrame(self): | |
| 516 | Object = self.MovingObject | |
| 517 | Range = self.Range | |
| 518 | if self.TimeStep < self.NumTimeSteps: | |
| 519 | x,y = Object.XY | |
| 520 | if x > Range[1] or x < Range[0]: | |
| 521 | self.dx = -self.dx | |
| 522 | if y > Range[1] or y < Range[0]: | |
| 523 | self.dy = -self.dy | |
| 524 | Object.Move( (self.dx,self.dy) ) | |
| 525 | Object.Text.Move( (self.dx,self.dy)) | |
| 526 | self.Canvas.Draw() | |
| 527 | self.TimeStep += 1 | |
| 5e1796ef | 528 | wx.GetApp().Yield(True) |
| 42463de2 RD |
529 | else: |
| 530 | self.Timer.Stop() | |
| 2e839e96 | 531 | |
| 42463de2 RD |
532 | |
| 533 | def MoveMe(self, Object): | |
| 534 | self.MovingObject = Object | |
| 535 | Range = self.Range | |
| 536 | self.dx = random.uniform(Range[0]/4,Range[1]/4) | |
| 537 | self.dy = random.uniform(Range[0]/4,Range[1]/4) | |
| 538 | #import time | |
| 539 | #start = time.time() | |
| 5e1796ef | 540 | self.NumTimeSteps = 200 |
| 42463de2 RD |
541 | self.TimeStep = 1 |
| 542 | self.Timer.Start(self.FrameDelay) | |
| 543 | #print "Did %i frames in %f seconds"%(N, (time.time() - start) ) | |
| 2e839e96 | 544 | |
| 0b0849b5 RD |
545 | def TestHitTest(self, event=None): |
| 546 | wx.GetApp().Yield(True) | |
| 42463de2 RD |
547 | |
| 548 | self.UnBindAllMouseEvents() | |
| 549 | Canvas = self.Canvas | |
| 550 | ||
| 0b0849b5 | 551 | Canvas.InitAll() |
| 42463de2 | 552 | |
| 2a0495c9 | 553 | #Add a Hit-able rectangle |
| 42463de2 RD |
554 | w, h = 60, 20 |
| 555 | ||
| 556 | dx = 80 | |
| 557 | dy = 40 | |
| 095315e2 | 558 | x, y = 20, 20 |
| 0b0849b5 | 559 | FontSize = 10 |
| 2e839e96 | 560 | |
| 42463de2 | 561 | #Add one that is not HitAble |
| 095315e2 RD |
562 | Canvas.AddRectangle((x,y), (w, h), LineWidth = 2) |
| 563 | Canvas.AddText("Not Hit-able", (x,y), Size = FontSize, Position = "bl") | |
| 2e839e96 | 564 | |
| 42463de2 RD |
565 | |
| 566 | x += dx | |
| 095315e2 | 567 | R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2) |
| 42463de2 RD |
568 | R.Name = "Line Rectangle" |
| 569 | R.HitFill = False | |
| 5e1796ef | 570 | R.HitLineWidth = 5 # Makes it a little easier to hit |
| 42463de2 | 571 | R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHit) |
| 095315e2 RD |
572 | Canvas.AddText("Left Click Line", (x,y), Size = FontSize, Position = "bl") |
| 573 | Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl") | |
| 42463de2 RD |
574 | |
| 575 | x += dx | |
| 576 | color = "Red" | |
| 095315e2 | 577 | R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color) |
| 42463de2 RD |
578 | R.Name = color + "Rectangle" |
| 579 | R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHit) | |
| 095315e2 RD |
580 | Canvas.AddText("Left Click Fill", (x, y), Size = FontSize, Position = "bl") |
| 581 | Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl") | |
| 42463de2 RD |
582 | |
| 583 | x = 20 | |
| 584 | y += dy | |
| 585 | color = "LightBlue" | |
| 095315e2 | 586 | R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color) |
| 42463de2 RD |
587 | R.Name = color + " Rectangle" |
| 588 | R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHit) | |
| 095315e2 RD |
589 | Canvas.AddText("Right Click Fill", (x, y), Size = FontSize, Position = "bl") |
| 590 | Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl") | |
| 42463de2 RD |
591 | |
| 592 | x += dx | |
| 593 | color = "Grey" | |
| 095315e2 | 594 | R = Canvas.AddEllipse((x, y), (w, h),LineWidth = 2,FillColor = color) |
| 42463de2 RD |
595 | R.Name = color +" Ellipse" |
| 596 | R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHit) | |
| 095315e2 RD |
597 | Canvas.AddText("Right Click Fill", (x, y), Size = FontSize, Position = "bl") |
| 598 | Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl") | |
| 42463de2 RD |
599 | |
| 600 | x += dx | |
| 601 | color = "Brown" | |
| 095315e2 | 602 | R = Canvas.AddCircle((x+dx/2, y+dy/2), dx/4, LineWidth = 2, FillColor = color) |
| 42463de2 RD |
603 | R.Name = color + " Circle" |
| 604 | R.HitFill = True | |
| 605 | R.Bind(FloatCanvas.EVT_FC_LEFT_DCLICK, self.RectGotHit) | |
| 095315e2 RD |
606 | Canvas.AddText("Left D-Click Fill", (x, y), Size = FontSize, Position = "bl") |
| 607 | Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl") | |
| 42463de2 RD |
608 | |
| 609 | x = 20 | |
| 610 | y += dy | |
| 611 | color = "Pink" | |
| 095315e2 | 612 | R = Canvas.AddCircle((x+dx/2, y+dy/2), dx/4, LineWidth = 2,FillColor = color) |
| 42463de2 RD |
613 | R.Name = color + " Circle" |
| 614 | R.Bind(FloatCanvas.EVT_FC_LEFT_UP, self.RectGotHit) | |
| 095315e2 RD |
615 | Canvas.AddText("Left Up Fill", (x, y), Size = FontSize, Position = "bl") |
| 616 | Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl") | |
| 42463de2 RD |
617 | |
| 618 | x += dx | |
| 619 | color = "White" | |
| 095315e2 | 620 | R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color) |
| 42463de2 RD |
621 | R.Name = color + " Rectangle" |
| 622 | R.Bind(FloatCanvas.EVT_FC_MIDDLE_DOWN, self.RectGotHit) | |
| 095315e2 RD |
623 | Canvas.AddText("Middle Down", (x, y), Size = FontSize, Position = "bl") |
| 624 | Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl") | |
| 42463de2 RD |
625 | |
| 626 | x += dx | |
| 627 | color = "AQUAMARINE" | |
| 095315e2 | 628 | R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color) |
| 42463de2 RD |
629 | R.Name = color + " Rectangle" |
| 630 | R.Bind(FloatCanvas.EVT_FC_MIDDLE_UP, self.RectGotHit) | |
| 095315e2 RD |
631 | Canvas.AddText("Middle Up", (x, y), Size = FontSize, Position = "bl") |
| 632 | Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl") | |
| 42463de2 RD |
633 | |
| 634 | x = 20 | |
| 635 | y += dy | |
| 636 | color = "CORAL" | |
| 095315e2 | 637 | R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color) |
| 42463de2 RD |
638 | R.Name = color + " Rectangle" |
| 639 | R.Bind(FloatCanvas.EVT_FC_MIDDLE_DCLICK, self.RectGotHit) | |
| 095315e2 RD |
640 | Canvas.AddText("Middle DoubleClick", (x, y), Size = FontSize, Position = "bl") |
| 641 | Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl") | |
| 42463de2 RD |
642 | |
| 643 | x += dx | |
| 644 | color = "CYAN" | |
| 095315e2 | 645 | R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color) |
| 42463de2 RD |
646 | R.Name = color + " Rectangle" |
| 647 | R.Bind(FloatCanvas.EVT_FC_RIGHT_UP, self.RectGotHit) | |
| 095315e2 RD |
648 | Canvas.AddText("Right Up", (x, y), Size = FontSize, Position = "bl") |
| 649 | Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl") | |
| 42463de2 RD |
650 | |
| 651 | x += dx | |
| 652 | color = "LIME GREEN" | |
| 095315e2 | 653 | R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color) |
| 42463de2 RD |
654 | R.Name = color + " Rectangle" |
| 655 | R.Bind(FloatCanvas.EVT_FC_RIGHT_DCLICK, self.RectGotHit) | |
| 095315e2 RD |
656 | Canvas.AddText("Right Double Click", (x, y), Size = FontSize, Position = "bl") |
| 657 | Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl") | |
| 42463de2 RD |
658 | |
| 659 | x = 20 | |
| 660 | y += dy | |
| 661 | color = "MEDIUM GOLDENROD" | |
| 095315e2 | 662 | R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color) |
| 42463de2 RD |
663 | R.Name = color |
| 664 | R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHitRight) | |
| 665 | R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHitLeft) | |
| 095315e2 RD |
666 | Canvas.AddText("L and R Click", (x, y), Size = FontSize, Position = "bl") |
| 667 | Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl") | |
| 42463de2 RD |
668 | |
| 669 | x += dx | |
| 670 | color = "SALMON" | |
| 095315e2 | 671 | R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color) |
| 42463de2 RD |
672 | R.Name = color + " Rectangle" |
| 673 | R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver) | |
| 095315e2 RD |
674 | Canvas.AddText("Mouse Enter", (x, y), Size = FontSize, Position = "bl") |
| 675 | Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl") | |
| 42463de2 RD |
676 | |
| 677 | x += dx | |
| 678 | color = "MEDIUM VIOLET RED" | |
| 095315e2 | 679 | R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color) |
| 42463de2 RD |
680 | R.Name = color |
| 681 | R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave) | |
| 095315e2 RD |
682 | Canvas.AddText("Mouse Leave", (x, y), Size = FontSize, Position = "bl") |
| 683 | Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl") | |
| 42463de2 RD |
684 | |
| 685 | x = 20 | |
| 686 | y += dy | |
| 687 | color = "SKY BLUE" | |
| 095315e2 | 688 | R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color) |
| 42463de2 RD |
689 | R.Name = color |
| 690 | R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver) | |
| 691 | R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave) | |
| 095315e2 RD |
692 | Canvas.AddText("Enter and Leave", (x, y), Size = FontSize, Position = "bl") |
| 693 | Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl") | |
| 42463de2 RD |
694 | |
| 695 | x += dx | |
| 696 | color = "WHEAT" | |
| 095315e2 | 697 | R = Canvas.AddRectangle((x, y), (w+12, h), LineColor = None, FillColor = color) |
| 42463de2 RD |
698 | R.Name = color |
| 699 | R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver) | |
| 700 | R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave) | |
| 095315e2 RD |
701 | Canvas.AddText("Mouse Enter&Leave", (x, y), Size = FontSize, Position = "bl") |
| 702 | Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl") | |
| 42463de2 RD |
703 | |
| 704 | x += dx | |
| 705 | color = "KHAKI" | |
| 095315e2 | 706 | R = Canvas.AddRectangle((x-12, y), (w+12, h), LineColor = None, FillColor = color) |
| 42463de2 RD |
707 | R.Name = color |
| 708 | R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver) | |
| 709 | R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave) | |
| 0b0849b5 | 710 | Canvas.AddText("Mouse Enter&Leave", (x, y), Size = FontSize, Position = "bl") |
| 095315e2 | 711 | Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl") |
| 42463de2 RD |
712 | |
| 713 | x = 20 | |
| 714 | y += dy | |
| 715 | L = Canvas.AddLine(( (x, y), (x+10, y+10), (x+w, y+h) ), LineWidth = 2, LineColor = "Red") | |
| 716 | L.Name = "A Line" | |
| 717 | L.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHitLeft) | |
| 095315e2 RD |
718 | Canvas.AddText("Left Down", (x, y), Size = FontSize, Position = "bl") |
| 719 | Canvas.AddText(L.Name, (x, y+h), Size = FontSize, Position = "tl") | |
| 42463de2 RD |
720 | |
| 721 | x += dx | |
| 722 | color = "SEA GREEN" | |
| 0b0849b5 | 723 | Points = N.array(( (x, y), (x, y+2.*h/3), (x+w, y+h), (x+w, y+h/2.), (x + 2.*w/3, y+h/2.), (x + 2.*w/3,y) ), N.float_) |
| 42463de2 RD |
724 | R = Canvas.AddPolygon(Points, LineWidth = 2, FillColor = color) |
| 725 | R.Name = color + " Polygon" | |
| 726 | R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHitRight) | |
| 095315e2 RD |
727 | Canvas.AddText("RIGHT_DOWN", (x, y), Size = FontSize, Position = "bl") |
| 728 | Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl") | |
| 42463de2 RD |
729 | |
| 730 | x += dx | |
| 731 | color = "Red" | |
| 0b0849b5 | 732 | Points = N.array(( (x, y), (x, y+2.*h/3), (x+w, y+h), (x+w, y+h/2.), (x + 2.*w/3, y+h/2.), (x + 2.*w/3,y) ), N.float_) |
| 42463de2 RD |
733 | R = Canvas.AddPointSet(Points, Diameter = 4, Color = color) |
| 734 | R.Name = "PointSet" | |
| 735 | R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.PointSetGotHit) | |
| 095315e2 RD |
736 | Canvas.AddText("LEFT_DOWN", (x, y), Size = FontSize, Position = "bl") |
| 737 | Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl") | |
| 42463de2 RD |
738 | |
| 739 | x = 20 | |
| 740 | y += dy | |
| 095315e2 | 741 | T = Canvas.AddText("Hit-able Text", (x, y), Size = 15, Color = "Red", Position = 'tl') |
| 42463de2 RD |
742 | T.Name = "Hit-able Text" |
| 743 | T.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHitLeft) | |
| 095315e2 | 744 | Canvas.AddText("Left Down", (x, y), Size = FontSize, Position = "bl") |
| 42463de2 RD |
745 | |
| 746 | x += dx | |
| 095315e2 | 747 | T = Canvas.AddScaledText("Scaled Text", (x, y), Size = 1./2*h, Color = "Pink", Position = 'bl') |
| 42463de2 RD |
748 | Canvas.AddPointSet( (x, y), Diameter = 3) |
| 749 | T.Name = "Scaled Text" | |
| 750 | T.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHitLeft) | |
| 095315e2 RD |
751 | Canvas.AddText("Left Down", (x, y), Size = FontSize, Position = "tl") |
| 752 | ||
| 753 | x += dx | |
| 754 | color = "Cyan" | |
| 755 | Point = (x + w/2, y) | |
| 0b0849b5 | 756 | #Points = N.array(( (x, y), (x, y+2.*h/3), (x+w, y+h), (x+w, y+h/2.), (x + 2.*w/3, y+h/2.), (x + 2.*w/3,y) ), N.float_) |
| 095315e2 RD |
757 | R = Canvas.AddSquarePoint(Point, Size = 8, Color = color) |
| 758 | R.Name = "SquarePoint" | |
| 759 | R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHit) | |
| 760 | Canvas.AddText("LEFT_DOWN", (x, y), Size = FontSize, Position = "bl") | |
| 761 | Canvas.AddText(R.Name, (x, y), Size = FontSize, Position = "tl") | |
| 762 | ||
| 42463de2 RD |
763 | |
| 764 | self.Canvas.ZoomToBB() | |
| 765 | ||
| 766 | def TestHitTestForeground(self,event=None): | |
| 0b0849b5 | 767 | wx.GetApp().Yield(True) |
| 42463de2 RD |
768 | |
| 769 | self.UnBindAllMouseEvents() | |
| 770 | Canvas = self.Canvas | |
| 771 | ||
| 0b0849b5 | 772 | Canvas.InitAll() |
| 42463de2 RD |
773 | |
| 774 | #Add a Hitable rectangle | |
| 775 | w, h = 60, 20 | |
| 776 | ||
| 777 | dx = 80 | |
| 778 | dy = 40 | |
| 779 | x,y = 20, 20 | |
| 2e839e96 | 780 | |
| 42463de2 | 781 | color = "Red" |
| 095315e2 | 782 | R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color, InForeground = False) |
| 42463de2 RD |
783 | R.Name = color + "Rectangle" |
| 784 | R.HitFill = True | |
| 785 | R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHit) | |
| 095315e2 RD |
786 | Canvas.AddText("Left Click Fill", (x, y), Position = "bl") |
| 787 | Canvas.AddText(R.Name, (x, y+h), Position = "tl") | |
| 42463de2 RD |
788 | |
| 789 | ## A set of Rectangles that move together | |
| 2e839e96 | 790 | |
| 42463de2 RD |
791 | ## NOTE: In a real app, it might be better to create a new |
| 792 | ## custom FloatCanvas DrawObject | |
| 2e839e96 | 793 | |
| 42463de2 | 794 | self.MovingRects = [] |
| 095315e2 | 795 | WH = (w/2, h/2) |
| 42463de2 RD |
796 | x += dx |
| 797 | color = "LightBlue" | |
| 095315e2 | 798 | R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True) |
| 42463de2 RD |
799 | R.HitFill = True |
| 800 | R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveLeft) | |
| 095315e2 | 801 | L = Canvas.AddText("Left", (x + w/4, y + h/4), Position = "cc", InForeground = True) |
| 42463de2 RD |
802 | self.MovingRects.extend( (R,L) ) |
| 803 | ||
| 804 | x += w/2 | |
| 095315e2 | 805 | R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True) |
| 42463de2 RD |
806 | R.HitFill = True |
| 807 | R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveRight) | |
| 095315e2 | 808 | L = Canvas.AddText("Right", (x + w/4, y + h/4), Position = "cc", InForeground = True) |
| 42463de2 RD |
809 | self.MovingRects.extend( (R,L) ) |
| 810 | ||
| 811 | x -= w/2 | |
| 812 | y += h/2 | |
| 095315e2 | 813 | R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True) |
| 42463de2 RD |
814 | R.HitFill = True |
| 815 | R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveUp) | |
| 095315e2 | 816 | L = Canvas.AddText("Up", (x + w/4, y + h/4), Position = "cc", InForeground = True) |
| 42463de2 RD |
817 | self.MovingRects.extend( (R,L) ) |
| 818 | ||
| 819 | ||
| 820 | x += w/2 | |
| 095315e2 | 821 | R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True) |
| 42463de2 RD |
822 | R.HitFill = True |
| 823 | R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveDown) | |
| 095315e2 | 824 | L = Canvas.AddText("Down", (x + w/4, y + h/4), Position = "cc", InForeground = True) |
| 42463de2 RD |
825 | self.MovingRects.extend( (R,L) ) |
| 826 | ||
| 827 | self.Canvas.ZoomToBB() | |
| 828 | ||
| 829 | def RectMoveLeft(self,Object): | |
| 830 | self.MoveRects("left") | |
| 2e839e96 | 831 | |
| 42463de2 RD |
832 | def RectMoveRight(self,Object): |
| 833 | self.MoveRects("right") | |
| 2e839e96 | 834 | |
| 42463de2 RD |
835 | def RectMoveUp(self,Object): |
| 836 | self.MoveRects("up") | |
| 2e839e96 | 837 | |
| 42463de2 RD |
838 | def RectMoveDown(self,Object): |
| 839 | self.MoveRects("down") | |
| 2e839e96 | 840 | |
| 42463de2 RD |
841 | def MoveRects(self, Dir): |
| 842 | for Object in self.MovingRects: | |
| 843 | X,Y = Object.XY | |
| 844 | if Dir == "left": X -= 10 | |
| 845 | elif Dir == "right": X += 10 | |
| 846 | elif Dir == "up": Y += 10 | |
| 847 | elif Dir == "down": Y -= 10 | |
| 095315e2 | 848 | Object.SetPoint((X,Y)) |
| 42463de2 | 849 | self.Canvas.Draw() |
| 2e839e96 | 850 | |
| 42463de2 | 851 | def PointSetGotHit(self, Object): |
| 095315e2 | 852 | self.Log(Object.Name + "Got Hit\n") |
| 42463de2 RD |
853 | |
| 854 | def RectGotHit(self, Object): | |
| 095315e2 | 855 | self.Log(Object.Name + "Got Hit\n") |
| 42463de2 RD |
856 | |
| 857 | def RectGotHitRight(self, Object): | |
| 095315e2 | 858 | self.Log(Object.Name + "Got Hit With Right\n") |
| 42463de2 RD |
859 | |
| 860 | def RectGotHitLeft(self, Object): | |
| 095315e2 | 861 | self.Log(Object.Name + "Got Hit with Left\n") |
| 42463de2 RD |
862 | |
| 863 | def RectMouseOver(self, Object): | |
| 095315e2 | 864 | self.Log("Mouse entered:" + Object.Name) |
| 42463de2 RD |
865 | |
| 866 | def RectMouseLeave(self, Object): | |
| 095315e2 | 867 | self.Log("Mouse left " + Object.Name) |
| 42463de2 RD |
868 | |
| 869 | ||
| 870 | def TestText(self, event= None): | |
| 0b0849b5 | 871 | wx.GetApp().Yield(True) |
| 42463de2 RD |
872 | |
| 873 | self.BindAllMouseEvents() | |
| 874 | Canvas = self.Canvas | |
| 0b0849b5 RD |
875 | Canvas.InitAll() |
| 876 | ||
| 42463de2 | 877 | |
| 0b0849b5 | 878 | DefaultSize = 12 |
| 095315e2 | 879 | Point = (3, 0) |
| 42463de2 RD |
880 | |
| 881 | ## Add a non-visible rectangle, just to get a Bounding Box | |
| 882 | ## Text objects have a zero-size bounding box, because it changes with zoom | |
| 095315e2 RD |
883 | Canvas.AddRectangle((-10,-10), |
| 884 | (20,20), | |
| 885 | LineWidth = 1, | |
| 886 | LineColor = None) | |
| 42463de2 RD |
887 | |
| 888 | # Text | |
| 889 | String = "Some text" | |
| 0b0849b5 RD |
890 | self.Canvas.AddText("Top Left",Point,Size = DefaultSize,Color = "Yellow",BackgroundColor = "Blue", Position = "tl") |
| 891 | self.Canvas.AddText("Bottom Left",Point,Size = DefaultSize,Color = "Cyan",BackgroundColor = "Black",Position = "bl") | |
| 892 | self.Canvas.AddText("Top Right",Point,Size = DefaultSize,Color = "Black",BackgroundColor = "Cyan",Position = "tr") | |
| 893 | self.Canvas.AddText("Bottom Right",Point,Size = DefaultSize,Color = "Blue",BackgroundColor = "Yellow",Position = "br") | |
| 095315e2 | 894 | Canvas.AddPointSet((Point), Color = "White", Diameter = 2) |
| 42463de2 | 895 | |
| 095315e2 | 896 | Point = (3, 2) |
| 2e839e96 | 897 | |
| 095315e2 | 898 | Canvas.AddPointSet((Point), Color = "White", Diameter = 2) |
| 0b0849b5 RD |
899 | self.Canvas.AddText("Top Center",Point,Size = DefaultSize,Color = "Black",Position = "tc") |
| 900 | self.Canvas.AddText("Bottom Center",Point,Size = DefaultSize,Color = "White",Position = "bc") | |
| 42463de2 | 901 | |
| 095315e2 | 902 | Point = (3, 4) |
| 2e839e96 | 903 | |
| 095315e2 | 904 | Canvas.AddPointSet((Point), Color = "White", Diameter = 2) |
| 0b0849b5 RD |
905 | self.Canvas.AddText("Center Right",Point,Size = DefaultSize,Color = "Black",Position = "cr") |
| 906 | self.Canvas.AddText("Center Left",Point,Size = DefaultSize,Color = "Black",Position = "cl") | |
| 42463de2 | 907 | |
| 095315e2 | 908 | Point = (3, -2) |
| 2e839e96 | 909 | |
| 095315e2 RD |
910 | Canvas.AddPointSet((Point), Color = "White", Diameter = 2) |
| 911 | self.Canvas.AddText("Center Center", | |
| 0b0849b5 | 912 | Point, Size = DefaultSize, |
| 095315e2 RD |
913 | Color = "Black", |
| 914 | Position = "cc") | |
| 42463de2 | 915 | |
| 095315e2 RD |
916 | self.Canvas.AddText("40 Pixels", (-10,8), Size = 40) |
| 917 | self.Canvas.AddText("20 Pixels", (-10,5), Size = 20) | |
| 918 | self.Canvas.AddText("10 Pixels", (-10,3), Size = 10) | |
| 42463de2 | 919 | |
| 095315e2 RD |
920 | self.Canvas.AddText("MODERN Font", (-10, 0), Family = wx.MODERN) |
| 921 | self.Canvas.AddText("DECORATIVE Font", (-10, -1), Family = wx.DECORATIVE) | |
| 922 | self.Canvas.AddText("ROMAN Font", (-10, -2), Family = wx.ROMAN) | |
| 923 | self.Canvas.AddText("SCRIPT Font", (-10, -3), Family = wx.SCRIPT) | |
| 924 | self.Canvas.AddText("ROMAN BOLD Font", (-10, -4), Family = wx.ROMAN, Weight=wx.BOLD) | |
| 925 | self.Canvas.AddText("ROMAN ITALIC BOLD Font", (-10, -5), Family = wx.ROMAN, Weight=wx.BOLD, Style=wx.ITALIC) | |
| 42463de2 RD |
926 | |
| 927 | # NOTE: this font exists on my Linux box..who knows were else you'll find it! | |
| 0b0849b5 RD |
928 | Font = wx.Font(20, wx.DEFAULT, wx.ITALIC, wx.NORMAL, False, "helvetica") |
| 929 | self.Canvas.AddText("Helvetica Italic", (-10, -6), Font = Font) | |
| 42463de2 RD |
930 | |
| 931 | self.Canvas.ZoomToBB() | |
| 932 | ||
| 933 | def TestScaledText(self, event= None): | |
| 0b0849b5 | 934 | wx.GetApp().Yield(True) |
| 42463de2 RD |
935 | |
| 936 | self.BindAllMouseEvents() | |
| 937 | Canvas = self.Canvas | |
| 0b0849b5 | 938 | Canvas.InitAll() |
| 42463de2 | 939 | |
| 095315e2 | 940 | Point = (0, 0) |
| 42463de2 | 941 | |
| 095315e2 RD |
942 | T = Canvas.AddScaledText("Top Left", |
| 943 | Point, | |
| 944 | Size = 5, | |
| 945 | Color = "Yellow", | |
| 946 | BackgroundColor = "Blue", | |
| 947 | Position = "tl") | |
| 948 | T = Canvas.AddScaledText("Bottom Left",Point,Size = 5,Color = "Cyan",BackgroundColor = "Black",Position = "bl") | |
| 949 | T = Canvas.AddScaledText("Top Right",Point,Size = 5,Color = "Black",BackgroundColor = "Cyan",Position = "tr") | |
| 950 | T = Canvas.AddScaledText("Bottom Right",Point,Size = 5,Color = "Blue",BackgroundColor = "Yellow",Position = "br") | |
| 951 | Canvas.AddPointSet((Point), Color = "Red", Diameter = 4) | |
| 42463de2 RD |
952 | |
| 953 | ||
| 095315e2 | 954 | Point = (0, 20) |
| 2e839e96 | 955 | |
| 095315e2 RD |
956 | Canvas.AddScaledText("Top Center",Point,Size = 7,Color = "Black",Position = "tc") |
| 957 | Canvas.AddScaledText("Bottom Center",Point,Size = 7,Color = "White",Position = "bc") | |
| 958 | Canvas.AddPointSet((Point), Color = "White", Diameter = 4) | |
| 42463de2 | 959 | |
| 095315e2 | 960 | Point = (0, -20) |
| 2e839e96 | 961 | |
| 095315e2 RD |
962 | Canvas.AddScaledText("Center Right",Point,Size = 9,Color = "Black",Position = "cr") |
| 963 | Canvas.AddScaledText("Center Left",Point,Size = 9,Color = "Black",Position = "cl") | |
| 964 | Canvas.AddPointSet((Point), Color = "White", Diameter = 4) | |
| 42463de2 RD |
965 | |
| 966 | x = -200 | |
| 967 | ||
| 095315e2 RD |
968 | self.Canvas.AddScaledText("MODERN Font", (x, 0), Size = 7, Family = wx.MODERN, Color = (0,0,0)) |
| 969 | self.Canvas.AddScaledText("DECORATIVE Font", (x, -10), Size = 7, Family = wx.DECORATIVE, Color = (0,0,1)) | |
| 970 | self.Canvas.AddScaledText("ROMAN Font", (x, -20), Size = 7, Family = wx.ROMAN) | |
| 971 | self.Canvas.AddScaledText("SCRIPT Font", (x, -30), Size = 7, Family = wx.SCRIPT) | |
| 972 | self.Canvas.AddScaledText("ROMAN BOLD Font", (x, -40), Size = 7, Family = wx.ROMAN, Weight=wx.BOLD) | |
| 973 | self.Canvas.AddScaledText("ROMAN ITALIC BOLD Font", (x, -50), Size = 7, Family = wx.ROMAN, Weight=wx.BOLD, Style=wx.ITALIC) | |
| 42463de2 RD |
974 | Canvas.AddPointSet((x,0), Color = "White", Diameter = 4) |
| 975 | ||
| 976 | ||
| 0b0849b5 | 977 | # NOTE: this font exists on my OS-X.who knows were else you'll find it! |
| 095315e2 | 978 | Point = (-100, 50) |
| 0b0849b5 RD |
979 | Font = wx.Font(12, wx.DEFAULT, wx.ITALIC, wx.NORMAL, False, "helvetica") |
| 980 | T = self.Canvas.AddScaledText("Helvetica Italic", Point, Size = 20, Font = Font, Position = 'bc') | |
| 42463de2 | 981 | |
| 095315e2 | 982 | Point = (-50, -50) |
| 0b0849b5 RD |
983 | Font = wx.Font(12, wx.DEFAULT, wx.ITALIC, wx.NORMAL, False, "times") |
| 984 | T = self.Canvas.AddScaledText("Times Font", Point, Size = 8, Font = Font) | |
| 095315e2 RD |
985 | |
| 986 | self.Canvas.ZoomToBB() | |
| 987 | ||
| 988 | def TestScaledTextBox(self, event= None): | |
| 0b0849b5 | 989 | wx.GetApp().Yield(True) |
| 095315e2 RD |
990 | |
| 991 | self.UnBindAllMouseEvents() | |
| 992 | Canvas = self.Canvas | |
| 0b0849b5 | 993 | Canvas.InitAll() |
| 095315e2 RD |
994 | |
| 995 | Point = (45,40) | |
| 996 | Box = Canvas.AddScaledTextBox("A Two Line\nString", | |
| 997 | Point, | |
| 998 | 2, | |
| 999 | Color = "Black", | |
| 1000 | BackgroundColor = None, | |
| 1001 | LineColor = "Red", | |
| 1002 | LineStyle = "Solid", | |
| 1003 | LineWidth = 1, | |
| 1004 | Width = None, | |
| 1005 | PadSize = 5, | |
| 1006 | Family = wx.ROMAN, | |
| 1007 | Style = wx.NORMAL, | |
| 1008 | Weight = wx.NORMAL, | |
| 0b0849b5 | 1009 | Underlined = False, |
| 095315e2 RD |
1010 | Position = 'br', |
| 1011 | Alignment = "left", | |
| 1012 | InForeground = False) | |
| 1013 | ||
| 1014 | # All defaults | |
| 1015 | Box = Canvas.AddScaledTextBox("A Two Line\nString", | |
| 1016 | Point, | |
| 1017 | 2) | |
| 1018 | ||
| 1019 | Box = Canvas.AddScaledTextBox("A Two Line\nString", | |
| 1020 | Point, | |
| 1021 | 2, | |
| 1022 | BackgroundColor = "Yellow", | |
| 1023 | LineColor = "Red", | |
| 1024 | LineStyle = "Solid", | |
| 1025 | PadSize = 5, | |
| 1026 | Family = wx.TELETYPE, | |
| 1027 | Position = 'bl') | |
| 1028 | ||
| 1029 | Box = Canvas.AddScaledTextBox("A String\nThis box is clickable", | |
| 1030 | Point, | |
| 1031 | 2, | |
| 1032 | BackgroundColor = "Yellow", | |
| 1033 | LineColor = "Red", | |
| 1034 | LineStyle = "Solid", | |
| 1035 | PadSize = 5, | |
| 1036 | Family = wx.TELETYPE, | |
| 1037 | Position = 'tr') | |
| 1038 | ||
| 1039 | Box.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.binding2) | |
| 1040 | ||
| 1041 | Canvas.AddPoint(Point, Diameter = 4) | |
| 1042 | ||
| 1043 | Point = (45,15) | |
| 1044 | Box = Canvas.AddScaledTextBox("A Two Line\nString", | |
| 1045 | Point, | |
| 1046 | 2, | |
| 1047 | Color = "Black", | |
| 1048 | BackgroundColor = 'Red', | |
| 1049 | LineColor = "Blue", | |
| 1050 | LineStyle = "LongDash", | |
| 1051 | LineWidth = 2, | |
| 1052 | Width = None, | |
| 1053 | PadSize = 5, | |
| 1054 | Family = wx.TELETYPE, | |
| 1055 | Style = wx.NORMAL, | |
| 1056 | Weight = wx.NORMAL, | |
| 0b0849b5 | 1057 | Underlined = False, |
| 095315e2 RD |
1058 | Position = 'cr', |
| 1059 | Alignment = "left", | |
| 1060 | InForeground = False) | |
| 1061 | ||
| 1062 | Box = Canvas.AddScaledTextBox("A Two Line\nString", | |
| 1063 | Point, | |
| 1064 | 1.5, | |
| 1065 | Color = "Black", | |
| 1066 | BackgroundColor = 'Red', | |
| 1067 | LineColor = "Blue", | |
| 1068 | LineStyle = "LongDash", | |
| 1069 | LineWidth = 2, | |
| 1070 | Width = None, | |
| 1071 | PadSize = 5, | |
| 1072 | Family = wx.TELETYPE, | |
| 1073 | Style = wx.NORMAL, | |
| 1074 | Weight = wx.NORMAL, | |
| 0b0849b5 | 1075 | Underlined = False, |
| 095315e2 RD |
1076 | Position = 'cl', |
| 1077 | Alignment = "left", | |
| 1078 | InForeground = False) | |
| 1079 | ||
| 1080 | Canvas.AddPoint(Point, Diameter = 4) | |
| 1081 | ||
| 1082 | Point = (45,-10) | |
| 1083 | Box = Canvas.AddScaledTextBox("A Two Line\nString", | |
| 1084 | Point, | |
| 1085 | 2, | |
| 1086 | Color = "Black", | |
| 1087 | BackgroundColor = 'Red', | |
| 1088 | LineColor = "Blue", | |
| 1089 | LineStyle = "LongDash", | |
| 1090 | LineWidth = 2, | |
| 1091 | Width = None, | |
| 1092 | PadSize = 3, | |
| 1093 | Family = wx.TELETYPE, | |
| 1094 | Style = wx.NORMAL, | |
| 1095 | Weight = wx.NORMAL, | |
| 0b0849b5 | 1096 | Underlined = False, |
| 095315e2 RD |
1097 | Position = 'tc', |
| 1098 | Alignment = "left", | |
| 1099 | InForeground = False) | |
| 1100 | ||
| 1101 | Box = Canvas.AddScaledTextBox("A three\nLine\nString", | |
| 1102 | Point, | |
| 1103 | 1.5, | |
| 1104 | Color = "Black", | |
| 1105 | BackgroundColor = 'Red', | |
| 1106 | LineColor = "Blue", | |
| 1107 | LineStyle = "LongDash", | |
| 1108 | LineWidth = 2, | |
| 1109 | Width = None, | |
| 1110 | PadSize = 0.5, | |
| 1111 | Family = wx.TELETYPE, | |
| 1112 | Style = wx.NORMAL, | |
| 1113 | Weight = wx.NORMAL, | |
| 0b0849b5 | 1114 | Underlined = False, |
| 095315e2 RD |
1115 | Position = 'bc', |
| 1116 | Alignment = "left", | |
| 1117 | InForeground = False) | |
| 1118 | ||
| 1119 | ||
| 1120 | Canvas.AddPoint(Point, Diameter = 4) | |
| 1121 | ||
| 1122 | Box = Canvas.AddScaledTextBox("Some Auto Wrapped Text. There is enough to do.", | |
| 1123 | (80,40), | |
| 1124 | 2, | |
| 1125 | BackgroundColor = 'White', | |
| 1126 | LineWidth = 2, | |
| 1127 | Width = 20, | |
| 1128 | PadSize = 0.5, | |
| 1129 | Family = wx.TELETYPE, | |
| 1130 | ) | |
| 1131 | ||
| 1132 | Box = Canvas.AddScaledTextBox("Some more auto wrapped text. Wrapped to a different width.\n\nThis is another paragraph.", | |
| 1133 | (80,20), | |
| 1134 | 2, | |
| 1135 | BackgroundColor = 'White', | |
| 1136 | LineWidth = 2, | |
| 1137 | Width = 40, | |
| 1138 | PadSize = 0.5, | |
| 1139 | Family = wx.ROMAN, | |
| 1140 | Alignment = "right" | |
| 1141 | ) | |
| 0b0849b5 | 1142 | Point = N.array((100, -20), N.float_) |
| 095315e2 RD |
1143 | Box = Canvas.AddScaledTextBox("Here is even more auto wrapped text. This time the line spacing is set to 0.8. \n\nThe Padding is set to 0.", |
| 1144 | Point, | |
| 1145 | Size = 3, | |
| 1146 | BackgroundColor = 'White', | |
| 1147 | LineWidth = 1, | |
| 1148 | Width = 40, | |
| 1149 | PadSize = 0.0, | |
| 1150 | Family = wx.ROMAN, | |
| 1151 | Position = "cc", | |
| 1152 | LineSpacing = 0.8 | |
| 1153 | ) | |
| 1154 | Canvas.AddPoint(Point, "Red", 2) | |
| 1155 | ||
| 0b0849b5 RD |
1156 | Point = N.array((0, -40), N.float_) |
| 1157 | # Point = N.array((0, 0), N.float_) | |
| 095315e2 RD |
1158 | for Position in ["tl", "bl", "tr", "br"]: |
| 1159 | # for Position in ["br"]: | |
| 1160 | Box = Canvas.AddScaledTextBox("Here is a\nfour liner\nanother line\nPosition=%s"%Position, | |
| 1161 | Point, | |
| 1162 | Size = 4, | |
| 1163 | Color = "Red", | |
| 1164 | BackgroundColor = None,#'LightBlue', | |
| 1165 | LineWidth = 1, | |
| 1166 | LineColor = "White", | |
| 1167 | Width = None, | |
| 1168 | PadSize = 2, | |
| 1169 | Family = wx.ROMAN, | |
| 1170 | Position = Position, | |
| 1171 | LineSpacing = 0.8 | |
| 1172 | ) | |
| 1173 | Canvas.AddPoint(Point, "Red", 4) | |
| 1174 | ||
| 0b0849b5 | 1175 | Point = N.array((-20, 60), N.float_) |
| 095315e2 RD |
1176 | Box = Canvas.AddScaledTextBox("Here is some\ncentered\ntext", |
| 1177 | Point, | |
| 1178 | Size = 4, | |
| 1179 | Color = "Red", | |
| 1180 | BackgroundColor = 'LightBlue', | |
| 1181 | LineWidth = 1, | |
| 1182 | LineColor = "White", | |
| 1183 | Width = None, | |
| 1184 | PadSize = 2, | |
| 1185 | Family = wx.ROMAN, | |
| 1186 | Position = "tl", | |
| 1187 | Alignment = "center", | |
| 1188 | LineSpacing = 0.8 | |
| 1189 | ) | |
| 1190 | ||
| 0b0849b5 | 1191 | Point = N.array((-20, 20), N.float_) |
| 095315e2 RD |
1192 | Box = Canvas.AddScaledTextBox("Here is some\nright aligned\ntext", |
| 1193 | Point, | |
| 1194 | Size = 4, | |
| 1195 | Color = "Red", | |
| 1196 | BackgroundColor = 'LightBlue', | |
| 1197 | LineColor = None, | |
| 1198 | Width = None, | |
| 1199 | PadSize = 2, | |
| 1200 | Family = wx.ROMAN, | |
| 1201 | Position = "tl", | |
| 1202 | Alignment = "right", | |
| 1203 | LineSpacing = 0.8 | |
| 1204 | ) | |
| 1205 | ||
| 0b0849b5 | 1206 | Point = N.array((100, -60), N.float_) |
| 095315e2 RD |
1207 | Box = Canvas.AddScaledTextBox("Here is some auto wrapped text. This time it is centered, rather than right aligned.\n\nThe Padding is set to 2.", |
| 1208 | Point, | |
| 1209 | Size = 3, | |
| 1210 | BackgroundColor = 'White', | |
| 1211 | LineWidth = 1, | |
| 1212 | Width = 40, | |
| 1213 | PadSize = 2.0, | |
| 1214 | Family = wx.ROMAN, | |
| 1215 | Position = "cc", | |
| 1216 | LineSpacing = 0.8, | |
| 1217 | Alignment = 'center', | |
| 1218 | ) | |
| 1219 | ||
| 1220 | ||
| 1221 | ||
| 1222 | ||
| 1223 | self.Canvas.ZoomToBB() | |
| 1224 | ||
| 1225 | def binding2(self, event): | |
| 1226 | self.Log("I'm the TextBox") | |
| 1227 | ||
| 1228 | def TestBitmap(self, event= None): | |
| 0b0849b5 | 1229 | wx.GetApp().Yield(True) |
| 095315e2 RD |
1230 | |
| 1231 | self.UnBindAllMouseEvents() | |
| 1232 | Canvas = self.Canvas | |
| 0b0849b5 RD |
1233 | Canvas.InitAll() |
| 1234 | ||
| 095315e2 RD |
1235 | Canvas.AddRectangle((10, 20), |
| 1236 | (400, 100), | |
| 1237 | LineWidth = 3, | |
| 1238 | LineColor = "Blue", | |
| 1239 | FillColor = "Red") | |
| 1240 | ||
| 1241 | bmp = Resources.getMagPlusBitmap() | |
| 1242 | ||
| 1243 | Canvas.AddText("These are Unscaled Bitmaps:", (140, 90)) | |
| 1244 | ||
| 1245 | Point = (150, 50) | |
| 1246 | BitMap = Canvas.AddBitmap(bmp, Point, Position = "cc" ) | |
| 1247 | Canvas.AddPoint(Point, Diameter=4, Color="Green") | |
| 1248 | ||
| 1249 | Point = (200, 50) | |
| 1250 | BitMap = Canvas.AddBitmap(bmp, Point, Position = "br" ) | |
| 1251 | Canvas.AddPoint(Point, Diameter=4, Color="Green") | |
| 1252 | ||
| 1253 | Point = (200, 50) | |
| 1254 | BitMap = Canvas.AddBitmap(bmp, Point, Position = "bl" ) | |
| 1255 | Canvas.AddPoint(Point, Diameter=4, Color="Green") | |
| 1256 | ||
| 1257 | Point = (200, 50) | |
| 1258 | BitMap = Canvas.AddBitmap(bmp, Point, Position = "tr" ) | |
| 1259 | Canvas.AddPoint(Point, Diameter=4, Color="Green") | |
| 1260 | ||
| 1261 | Point = (200, 50) | |
| 1262 | BitMap = Canvas.AddBitmap(bmp, Point, Position = "tl" ) | |
| 1263 | Canvas.AddPoint(Point, Diameter=4, Color="Green") | |
| 1264 | ||
| 1265 | Point = (250, 50) | |
| 1266 | BitMap = Canvas.AddBitmap(bmp, Point, Position = "cr" ) | |
| 1267 | Canvas.AddPoint(Point, Diameter=4, Color="Green") | |
| 1268 | ||
| 1269 | Point = (250, 50) | |
| 1270 | BitMap = Canvas.AddBitmap(bmp, Point, Position = "cl" ) | |
| 1271 | Canvas.AddPoint(Point, Diameter=4, Color="Green") | |
| 1272 | ||
| 1273 | Point = (300, 50) | |
| 1274 | BitMap = Canvas.AddBitmap(bmp, Point, Position = "tc" ) | |
| 1275 | Canvas.AddPoint(Point, Diameter=4, Color="Green") | |
| 1276 | ||
| 1277 | Point = (300, 50) | |
| 1278 | BitMap = Canvas.AddBitmap(bmp, Point, Position = "bc" ) | |
| 1279 | Canvas.AddPoint(Point, Diameter=4, Color="Green") | |
| 1280 | ||
| 1281 | Canvas.AddScaledText("These are Scaled Bitmaps:", (220, -60), Size = 10, Position = "tr") | |
| 1282 | Point = (250, -100) | |
| 1283 | BitMap = Canvas.AddScaledBitmap(bmp, Point, Height = 50, Position = "bc" ) | |
| 1284 | BitMap = Canvas.AddScaledBitmap(bmp, Point, Height = 50, Position = "tc" ) | |
| 1285 | Canvas.AddPoint(Point, Diameter=4, Color="Green") | |
| 1286 | ||
| 1287 | Point = (300, -100) | |
| 1288 | BitMap = Canvas.AddScaledBitmap(Resources.getMondrianImage(), Point, Height = 50) | |
| 42463de2 | 1289 | |
| 8b9a4190 | 1290 | self.Canvas.ZoomToBB() |
| 2e839e96 | 1291 | |
| 8b9a4190 | 1292 | def DrawMap(self,event = None): |
| 0b0849b5 | 1293 | wx.GetApp().Yield(True) |
| 8b9a4190 | 1294 | import os, time |
| 0b0849b5 RD |
1295 | |
| 1296 | self.Canvas.InitAll() | |
| 1297 | self.Canvas.SetProjectionFun("FlatEarth") | |
| 42463de2 | 1298 | self.BindAllMouseEvents() |
| 2e839e96 | 1299 | |
| 8b9a4190 | 1300 | ## Test of Actual Map Data |
| 42463de2 | 1301 | #start = time.clock() |
| 095315e2 | 1302 | self.Log("Loading Map from a File") |
| 0b0849b5 | 1303 | wx.GetApp().Yield(True) # so log text will get displayed now. |
| 2a0495c9 | 1304 | Shorelines = self.Read_MapGen(os.path.join("data",'world.dat'),stats = 0) |
| 42463de2 RD |
1305 | #print "It took %f seconds to load %i shorelines"%(time.clock() - start,len(Shorelines) ) |
| 1306 | #start = time.clock() | |
| 8b9a4190 | 1307 | for segment in Shorelines: |
| 42463de2 RD |
1308 | self.Canvas.AddLine(segment) |
| 1309 | #print "It took %f seconds to add %i shorelines"%(time.clock() - start,len(Shorelines) ) | |
| 1310 | #start = time.clock() | |
| 8b9a4190 | 1311 | self.Canvas.ZoomToBB() |
| 42463de2 | 1312 | #print "It took %f seconds to draw %i shorelines"%(time.clock() - start,len(Shorelines) ) |
| 2e839e96 RD |
1313 | |
| 1314 | ||
| 0b0849b5 | 1315 | |
| 8b9a4190 | 1316 | def LineTest(self,event = None): |
| 0b0849b5 | 1317 | wx.GetApp().Yield(True) |
| 8b9a4190 | 1318 | import os, time |
| 42463de2 RD |
1319 | # import random |
| 1320 | colors = self.colors | |
| 8b9a4190 RD |
1321 | Range = (-10,10) |
| 1322 | ## Test of drawing lots of lines | |
| 42463de2 | 1323 | Canvas = self.Canvas |
| 0b0849b5 RD |
1324 | Canvas.InitAll() |
| 1325 | #start = time.clock() | |
| 8b9a4190 RD |
1326 | linepoints = [] |
| 1327 | linecolors = [] | |
| 1328 | linewidths = [] | |
| 1329 | for i in range(2000): | |
| 1330 | points = (random.randint(Range[0],Range[1]), | |
| 1331 | random.randint(Range[0],Range[1]), | |
| 1332 | random.randint(Range[0],Range[1]), | |
| 1333 | random.randint(Range[0],Range[1])) | |
| 1334 | linepoints.append(points) | |
| 1335 | linewidths.append(random.randint(1,10) ) | |
| 1336 | linecolors.append(random.randint(0,len(colors)-1) ) | |
| 1337 | for (points,color,width) in zip(linepoints,linecolors,linewidths): | |
| 42463de2 RD |
1338 | Canvas.AddLine((points[0:2],points[2:4]), LineWidth = width, LineColor = colors[color]) |
| 1339 | #print "It took %f seconds to add %i lines"%(time.clock() - start,len(linepoints) ) | |
| 1340 | #start = time.clock() | |
| 1341 | Canvas.ZoomToBB() | |
| 1342 | #print "It took %f seconds to draw %i lines"%(time.clock() - start,len(linepoints) ) | |
| 1343 | ||
| 0b0849b5 RD |
1344 | def ArrowLineTest(self,event = None): |
| 1345 | wx.GetApp().Yield(True) | |
| 1346 | Canvas = self.Canvas | |
| 1347 | Canvas.InitAll() | |
| 1348 | # import os, time | |
| 1349 | ## import random | |
| 1350 | Range = (-100,100) | |
| 1351 | colors = self.colors | |
| 1352 | ||
| 1353 | # Lines | |
| 1354 | for i in range(5): | |
| 1355 | points = [] | |
| 1356 | for j in range(random.randint(2,10)): | |
| 1357 | point = (random.randint(Range[0],Range[1]),random.randint(Range[0],Range[1])) | |
| 1358 | points.append(point) | |
| 1359 | lw = random.randint(1,4) | |
| 1360 | cf = random.randint(0,len(colors)-1) | |
| 1361 | cl = random.randint(0,len(colors)-1) | |
| 1362 | al = random.randint(8,20) | |
| 1363 | aa = random.randint(20,90) | |
| 1364 | Canvas.AddArrowLine(points, | |
| 1365 | LineWidth = lw, | |
| 1366 | LineColor = colors[cl], | |
| 1367 | ArrowHeadSize = al, | |
| 1368 | ArrowHeadAngle = aa) | |
| 1369 | ||
| 1370 | Canvas.ZoomToBB() | |
| 1371 | ||
| 42463de2 | 1372 | def SpeedTest(self,event=None): |
| 0b0849b5 | 1373 | wx.GetApp().Yield(True) |
| 42463de2 RD |
1374 | BigRange = (-1000,1000) |
| 1375 | colors = self.colors | |
| 1376 | ||
| 1377 | self.UnBindAllMouseEvents() | |
| 1378 | Canvas = self.Canvas | |
| 1379 | ||
| 0b0849b5 RD |
1380 | Canvas.InitAll() |
| 1381 | ||
| 5e1796ef | 1382 | # Pointset |
| 42463de2 | 1383 | coords = [] |
| 5e1796ef | 1384 | for i in range(1000): |
| 095315e2 RD |
1385 | Point = (random.uniform(BigRange[0],BigRange[1]),random.uniform(BigRange[0],BigRange[1])) |
| 1386 | coords.append( (Point) ) | |
| 5e1796ef | 1387 | print "Drawing the Points" |
| 8b9a4190 | 1388 | start = time.clock() |
| 5e1796ef RD |
1389 | for Point in coords: |
| 1390 | Canvas.AddPoint(Point, Diameter = 4) | |
| 1391 | print "It took %s seconds to add the points"%(time.clock() - start) | |
| 1392 | Canvas.ZoomToBB() | |
| 1393 | ||
| 1394 | def PropertiesChangeTest(self,event=None): | |
| 0b0849b5 | 1395 | wx.GetApp().Yield(True) |
| 5e1796ef RD |
1396 | |
| 1397 | Range = (-10,10) | |
| 1398 | colors = self.colors | |
| 1399 | ||
| 1400 | self.UnBindAllMouseEvents() | |
| 1401 | Canvas = self.Canvas | |
| 1402 | ||
| 0b0849b5 RD |
1403 | Canvas.InitAll() |
| 1404 | ||
| 5e1796ef RD |
1405 | self.ColorObjectsAll = [] |
| 1406 | self.ColorObjectsLine = [] | |
| 1407 | self.ColorObjectsColor = [] | |
| 1408 | self.ColorObjectsText = [] | |
| 1409 | ##One of each object: | |
| 1410 | # Rectangle | |
| 095315e2 | 1411 | Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1])) |
| 5e1796ef RD |
1412 | lw = random.randint(1,5) |
| 1413 | cf = random.randint(0,len(colors)-1) | |
| 095315e2 RD |
1414 | wh = ( random.randint(1,5), random.randint(1,5) ) |
| 1415 | self.Rectangle = Canvas.AddRectangle(Point, wh, LineWidth = lw, FillColor = colors[cf]) | |
| 5e1796ef | 1416 | self.ColorObjectsAll.append(self.Rectangle) |
| 2e839e96 | 1417 | |
| 5e1796ef | 1418 | # Ellipse |
| 095315e2 | 1419 | Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1])) |
| 5e1796ef RD |
1420 | lw = random.randint(1,5) |
| 1421 | cf = random.randint(0,len(colors)-1) | |
| 095315e2 RD |
1422 | wh = ( random.randint(1,5), random.randint(1,5) ) |
| 1423 | self.Ellipse = Canvas.AddEllipse(Point, wh, LineWidth = lw, FillColor = colors[cf]) | |
| 5e1796ef | 1424 | self.ColorObjectsAll.append(self.Ellipse) |
| 2e839e96 | 1425 | |
| 5e1796ef RD |
1426 | # Point |
| 1427 | xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1])) | |
| 1428 | D = random.randint(1,50) | |
| 1429 | lw = random.randint(1,5) | |
| 1430 | cf = random.randint(0,len(colors)-1) | |
| 1431 | cl = random.randint(0,len(colors)-1) | |
| 1432 | self.ColorObjectsColor.append(Canvas.AddPoint(xy, colors[cf], D)) | |
| 2e839e96 | 1433 | |
| 5e1796ef | 1434 | # Circle |
| 095315e2 | 1435 | Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1])) |
| 5e1796ef RD |
1436 | D = random.randint(1,5) |
| 1437 | lw = random.randint(1,5) | |
| 1438 | cf = random.randint(0,len(colors)-1) | |
| 1439 | cl = random.randint(0,len(colors)-1) | |
| 095315e2 | 1440 | self.Circle = Canvas.AddCircle(Point, D, LineWidth = lw, LineColor = colors[cl], FillColor = colors[cf]) |
| 5e1796ef RD |
1441 | self.ColorObjectsAll.append(self.Circle) |
| 1442 | ||
| 1443 | # Line | |
| 1444 | points = [] | |
| 1445 | for j in range(random.randint(2,10)): | |
| 1446 | point = (random.randint(Range[0],Range[1]),random.randint(Range[0],Range[1])) | |
| 1447 | points.append(point) | |
| 1448 | lw = random.randint(1,10) | |
| 1449 | cf = random.randint(0,len(colors)-1) | |
| 1450 | cl = random.randint(0,len(colors)-1) | |
| 1451 | self.ColorObjectsLine.append(Canvas.AddLine(points, LineWidth = lw, LineColor = colors[cl])) | |
| 2e839e96 | 1452 | |
| 5e1796ef RD |
1453 | # Polygon |
| 1454 | ## points = [] | |
| 1455 | ## for j in range(random.randint(2,6)): | |
| 1456 | ## point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1])) | |
| 1457 | ## points.append(point) | |
| 1458 | points = RandomArray.uniform(Range[0],Range[1],(6,2)) | |
| 1459 | lw = random.randint(1,6) | |
| 1460 | cf = random.randint(0,len(colors)-1) | |
| 1461 | cl = random.randint(0,len(colors)-1) | |
| 1462 | self.ColorObjectsAll.append(Canvas.AddPolygon(points, | |
| 1463 | LineWidth = lw, | |
| 1464 | LineColor = colors[cl], | |
| 1465 | FillColor = colors[cf], | |
| 1466 | FillStyle = 'Solid')) | |
| 2e839e96 | 1467 | |
| 5e1796ef RD |
1468 | ## Pointset |
| 1469 | points = RandomArray.uniform(Range[0],Range[1],(100,2)) | |
| 1470 | cf = random.randint(0,len(colors)-1) | |
| 1471 | D = random.randint(1,4) | |
| 1472 | self.PointSet = Canvas.AddPointSet(points, Color = colors[cf], Diameter = D) | |
| 1473 | self.ColorObjectsColor.append(self.PointSet) | |
| 2e839e96 | 1474 | |
| 5e1796ef RD |
1475 | ## Point |
| 1476 | point = RandomArray.uniform(Range[0],Range[1],(2,)) | |
| 1477 | cf = random.randint(0,len(colors)-1) | |
| 1478 | D = random.randint(1,4) | |
| 1479 | self.Point = Canvas.AddPoint(point, Color = colors[cf], Diameter = D) | |
| 1480 | self.ColorObjectsColor.append(self.Point) | |
| 2e839e96 | 1481 | |
| 5e1796ef RD |
1482 | # Text |
| 1483 | String = "Unscaled text" | |
| 1484 | ts = random.randint(10,40) | |
| 1485 | cf = random.randint(0,len(colors)-1) | |
| 095315e2 RD |
1486 | Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1])) |
| 1487 | self.ColorObjectsText.append(Canvas.AddText(String, Point, Size = ts, Color = colors[cf], Position = "cc")) | |
| 5e1796ef RD |
1488 | |
| 1489 | # Scaled Text | |
| 1490 | String = "Scaled text" | |
| 1491 | ts = random.random()*3 + 0.2 | |
| 1492 | cf = random.randint(0,len(colors)-1) | |
| 095315e2 RD |
1493 | Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1])) |
| 1494 | self.ColorObjectsText.append(Canvas.AddScaledText(String, Point, Size = ts, Color = colors[cf], Position = "cc")) | |
| 42463de2 | 1495 | |
| 5e1796ef | 1496 | # A "Button" |
| 095315e2 | 1497 | Button = Canvas.AddRectangle((-10, -12), (20, 3), LineStyle = None, FillColor = "Red") |
| 5e1796ef | 1498 | Canvas.AddScaledText("Click Here To Change Properties", |
| 095315e2 | 1499 | (0, -10.5), |
| 5e1796ef RD |
1500 | Size = 0.7, |
| 1501 | Color = "Black", | |
| 1502 | Position = "cc") | |
| 1503 | ||
| 1504 | Button.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.ChangeProperties) | |
| 42463de2 RD |
1505 | |
| 1506 | Canvas.ZoomToBB() | |
| 1507 | ||
| 5e1796ef RD |
1508 | def ChangeProperties(self, Object = None): |
| 1509 | colors = self.colors | |
| 1510 | Range = (-10,10) | |
| 1511 | ||
| 1512 | for Object in self.ColorObjectsAll: | |
| 1513 | pass | |
| 1514 | Object.SetFillColor(colors[random.randint(0,len(colors)-1)]) | |
| 1515 | Object.SetLineColor(colors[random.randint(0,len(colors)-1)]) | |
| 1516 | Object.SetLineWidth(random.randint(1,7)) | |
| 1517 | Object.SetLineStyle(FloatCanvas.DrawObject.LineStyleList.keys()[random.randint(0,5)]) | |
| 1518 | for Object in self.ColorObjectsLine: | |
| 1519 | Object.SetLineColor(colors[random.randint(0,len(colors)-1)]) | |
| 1520 | Object.SetLineWidth(random.randint(1,7)) | |
| 1521 | Object.SetLineStyle(FloatCanvas.DrawObject.LineStyleList.keys()[random.randint(0,5)]) | |
| 1522 | for Object in self.ColorObjectsColor: | |
| 1523 | Object.SetColor(colors[random.randint(0,len(colors)-1)]) | |
| 1524 | for Object in self.ColorObjectsText: | |
| 1525 | Object.SetColor(colors[random.randint(0,len(colors)-1)]) | |
| 1526 | Object.SetBackgroundColor(colors[random.randint(0,len(colors)-1)]) | |
| 1527 | self.Circle.SetDiameter(random.randint(1,10)) | |
| 1528 | self.PointSet.SetDiameter(random.randint(1,8)) | |
| 1529 | self.Point.SetDiameter(random.randint(1,8)) | |
| 1530 | for Object in (self.Rectangle, self.Ellipse): | |
| 095315e2 RD |
1531 | Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1])) |
| 1532 | wh = ( random.randint(1,5), random.randint(1,5) ) | |
| 1533 | Object.SetShape(Point, wh) | |
| 2a0495c9 RD |
1534 | self.Canvas.Draw(Force = True) |
| 1535 | ||
| 1536 | def ArrowTest(self,event=None): | |
| 0b0849b5 | 1537 | wx.GetApp().Yield(True) |
| 2a0495c9 RD |
1538 | self.UnBindAllMouseEvents() |
| 1539 | Canvas = self.Canvas | |
| 1540 | ||
| 0b0849b5 RD |
1541 | Canvas.InitAll() |
| 1542 | Canvas.MinScale = 15 | |
| 1543 | Canvas.MaxScale = 30 | |
| 1544 | ||
| 2a0495c9 | 1545 | # put in a rectangle to get a bounding box |
| 095315e2 | 1546 | Canvas.AddRectangle((0,0), (20,20), LineColor = None) |
| 2a0495c9 RD |
1547 | |
| 1548 | # Draw some Arrows | |
| 1549 | Canvas.AddArrow((10,10),Length = 40, Direction = 0) | |
| 1550 | Canvas.AddArrow((10,10),Length = 50, Direction = 45 ,LineWidth = 2, LineColor = "Black", ArrowHeadAngle = 20) | |
| 1551 | Canvas.AddArrow((10,10),Length = 60, Direction = 90 ,LineWidth = 3, LineColor = "Red", ArrowHeadAngle = 30) | |
| 1552 | Canvas.AddArrow((10,10),Length = 70, Direction = 135,LineWidth = 4, LineColor = "Red", ArrowHeadAngle = 40) | |
| 1553 | Canvas.AddArrow((10,10),Length = 80, Direction = 180,LineWidth = 5, LineColor = "Blue", ArrowHeadAngle = 50) | |
| 1554 | Canvas.AddArrow((10,10),Length = 90, Direction = 225,LineWidth = 4, LineColor = "Blue", ArrowHeadAngle = 60) | |
| 1555 | Canvas.AddArrow((10,10),Length = 100,Direction = 270,LineWidth = 3, LineColor = "Green", ArrowHeadAngle = 70) | |
| 1556 | Canvas.AddArrow((10,10),Length = 110,Direction = 315,LineWidth = 2, LineColor = "Green", ArrowHeadAngle = 90 ) | |
| 1557 | ||
| 095315e2 | 1558 | Canvas.AddText("Clickable Arrow", (4,18), Position = "bc") |
| 2a0495c9 | 1559 | Arrow = Canvas.AddArrow((4,18), 80, Direction = 90 ,LineWidth = 3, LineColor = "Red", ArrowHeadAngle = 30) |
| 0b0849b5 | 1560 | Arrow.HitLineWidth = 6 |
| 2a0495c9 RD |
1561 | Arrow.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.ArrowClicked) |
| 1562 | ||
| 0b0849b5 | 1563 | Canvas.AddText("Changable Arrow: try clicking it", (16,4), Position = "tc") |
| 2a0495c9 | 1564 | self.RotArrow = Canvas.AddArrow((16,4), 80, Direction = 0 ,LineWidth = 3, LineColor = "Green", ArrowHeadAngle = 30) |
| 0b0849b5 | 1565 | self.RotArrow.HitLineWidth = 6 |
| 2a0495c9 RD |
1566 | self.RotArrow.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RotateArrow) |
| 1567 | ||
| 2a0495c9 RD |
1568 | Canvas.ZoomToBB() |
| 1569 | ||
| 1570 | def ArrowClicked(self,event): | |
| 0b0849b5 | 1571 | self.Log("The Arrow was Clicked") |
| 2a0495c9 RD |
1572 | |
| 1573 | def RotateArrow(self,event): | |
| 095315e2 | 1574 | ##print "The Changeable Arrow was Clicked" |
| 2a0495c9 RD |
1575 | ## You can do them either one at a time, or both at once |
| 1576 | ## Doing them both at once prevents the arrow points from being calculated twice | |
| 1577 | #self.RotArrow.SetDirection(self.RotArrow.Direction + random.uniform(-90,90)) | |
| 1578 | #self.RotArrow.SetLength(self.RotArrow.Length + random.randint(-20,20)) | |
| 1579 | self.RotArrow.SetLengthDirection(self.RotArrow.Length + random.randint(-20,20), | |
| 1580 | self.RotArrow.Direction + random.uniform(-90,90) ) | |
| 2e839e96 | 1581 | |
| 5e1796ef | 1582 | self.Canvas.Draw(Force = True) |
| 42463de2 | 1583 | |
| 095315e2 | 1584 | def HideTest(self, event=None): |
| 0b0849b5 | 1585 | wx.GetApp().Yield(True) |
| 095315e2 RD |
1586 | |
| 1587 | self.UnBindAllMouseEvents() | |
| 1588 | Canvas = self.Canvas | |
| 0b0849b5 RD |
1589 | Canvas.InitAll() |
| 1590 | ||
| 095315e2 RD |
1591 | Range = (-10,10) |
| 1592 | ||
| 1593 | # Create a couple random Polygons | |
| 1594 | points = [] | |
| 1595 | for j in range(6): | |
| 1596 | point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1])) | |
| 1597 | points.append(point) | |
| 1598 | Poly = Canvas.AddPolygon(points, | |
| 1599 | LineWidth = 2, | |
| 1600 | LineColor = "Black", | |
| 1601 | FillColor = "LightBlue", | |
| 1602 | FillStyle = 'Solid') | |
| 1603 | ||
| 1604 | points = [] | |
| 1605 | for j in range(6): | |
| 1606 | point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1])) | |
| 1607 | points.append(point) | |
| 1608 | Poly2 = Canvas.AddPolygon(points, | |
| 1609 | LineWidth = 2, | |
| 1610 | LineColor = "Black", | |
| 1611 | FillColor = "Purple", | |
| 1612 | FillStyle = 'Solid', | |
| 1613 | InForeground = True) | |
| 1614 | ||
| 1615 | HideButton = Canvas.AddScaledTextBox("Click To Hide\nBackground Polygon", | |
| 1616 | (-10, 0), | |
| 1617 | .5, | |
| 1618 | BackgroundColor="Red", | |
| 1619 | PadSize = 0.5, | |
| 1620 | Position = 'tr', | |
| 1621 | Alignment="center", | |
| 1622 | ) | |
| 1623 | HideButton.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.HidePoly) | |
| 1624 | HideButton.HidePoly = Poly | |
| 1625 | ||
| 1626 | HideButton2 = Canvas.AddScaledTextBox("Click To Hide\nForeground Polygon", | |
| 1627 | (-10, 5), | |
| 1628 | .5, | |
| 1629 | BackgroundColor="Red", | |
| 1630 | PadSize = 0.5, | |
| 1631 | Position = 'tr', | |
| 1632 | Alignment="center", | |
| 1633 | ) | |
| 1634 | # Put a reference to the Polygon in the Button object | |
| 1635 | HideButton2.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.HidePoly) | |
| 1636 | HideButton2.HidePoly = Poly2 | |
| 1637 | ||
| 1638 | ||
| 1639 | Canvas.ZoomToBB() | |
| 1640 | ||
| 1641 | def HidePoly(self, Button): | |
| 1642 | Poly = Button.HidePoly | |
| 0b0849b5 | 1643 | |
| 095315e2 | 1644 | if Poly.Visible: |
| 0b0849b5 | 1645 | Poly.Visible = False |
| 095315e2 RD |
1646 | Button.SetText(Button.String.replace("Hide","Show")) |
| 1647 | else: | |
| 0b0849b5 | 1648 | Poly.Visible = True |
| 095315e2 RD |
1649 | Button.SetText(Button.String.replace("Show", "Hide")) |
| 1650 | self.Canvas.Draw(True) | |
| 1651 | ||
| 0b0849b5 | 1652 | |
| 42463de2 | 1653 | def TempTest(self, event= None): |
| 0b0849b5 RD |
1654 | """ |
| 1655 | ||
| 1656 | This is the start of a poly editor test, but it's not complete | |
| 1657 | so you can only run it through a command line flag: | |
| 1658 | ||
| 1659 | python FloatCanvasDemo.py --temp | |
| 1660 | ||
| 1661 | """ | |
| 1662 | ||
| 1663 | wx.GetApp().Yield(True) | |
| 42463de2 RD |
1664 | |
| 1665 | self.UnBindAllMouseEvents() | |
| 1666 | Canvas = self.Canvas | |
| 0b0849b5 RD |
1667 | Canvas.InitAll() |
| 1668 | ||
| 42463de2 RD |
1669 | Range = (-10,10) |
| 1670 | ||
| 1671 | # Create a random Polygon | |
| 1672 | points = [] | |
| 1673 | for j in range(6): | |
| 1674 | point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1])) | |
| 1675 | points.append(point) | |
| 1676 | Poly = Canvas.AddPolygon(points, | |
| 1677 | LineWidth = 2, | |
| 1678 | LineColor = "Black", | |
| 1679 | FillColor = "LightBlue", | |
| 1680 | FillStyle = 'Solid') | |
| 1681 | ||
| 1682 | Poly.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.SelectPoly) | |
| 1683 | ||
| 1684 | self.SelectedPoly = None | |
| 1685 | self.SelectPoints = [] | |
| 1686 | self.SelectedPoint = None | |
| 2e839e96 | 1687 | |
| 42463de2 RD |
1688 | Canvas.ZoomToBB() |
| 1689 | ||
| 1690 | def SelectPoly(self, Object): | |
| 42463de2 RD |
1691 | Canvas = self.Canvas |
| 1692 | if Object is self.SelectedPoly: | |
| 1693 | pass | |
| 1694 | else: | |
| 1695 | #fixme: Do something to unselect the old one | |
| 1696 | self.SelectedPoly = Object | |
| 1697 | Canvas.RemoveObjects(self.SelectPoints) | |
| 1698 | self.SelectPoints = [] | |
| 1699 | # Draw points on the Vertices of the Selected Poly: | |
| 1700 | for i, point in enumerate(Object.Points): | |
| 1701 | P = Canvas.AddPointSet(point, Diameter = 6, Color = "Red") | |
| 1702 | P.VerticeNum = i | |
| 1703 | P.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.SelectPointHit) | |
| 1704 | self.SelectPoints.append(P) | |
| 1705 | #Canvas.ZoomToBB() | |
| 1706 | Canvas.Draw() | |
| 1707 | ||
| 1708 | def SelectPointHit(self, Point): | |
| 0b0849b5 | 1709 | self.Log("Point Num: %i Hit"%Point.VerticeNum) |
| 42463de2 RD |
1710 | self.SelectedPoint = Point |
| 1711 | ||
| 2a0495c9 RD |
1712 | def Read_MapGen(self, filename, stats = 0,AllLines=0): |
| 1713 | """ | |
| 1714 | This function reads a MapGen Format file, and | |
| 1715 | returns a list of NumPy arrays with the line segments in them. | |
| 1716 | ||
| 1717 | Each NumPy array in the list is an NX2 array of Python Floats. | |
| 1718 | ||
| 1719 | The demo should have come with a file, "world.dat" that is the | |
| 1720 | shorelines of the whole world, in MapGen format. | |
| 2e839e96 | 1721 | |
| 2a0495c9 RD |
1722 | """ |
| 1723 | import string | |
| 1724 | file = open(filename,'rt') | |
| 1725 | data = file.readlines() | |
| 1726 | data = map(string.strip,data) | |
| 1727 | ||
| 1728 | Shorelines = [] | |
| 1729 | segment = [] | |
| 1730 | for line in data: | |
| 1731 | if line: | |
| 1732 | if line == "# -b": #New segment beginning | |
| 0b0849b5 | 1733 | if segment: Shorelines.append(N.array(segment)) |
| 2a0495c9 RD |
1734 | segment = [] |
| 1735 | else: | |
| 1736 | segment.append(map(float,string.split(line))) | |
| 0b0849b5 | 1737 | if segment: Shorelines.append(N.array(segment)) |
| 2a0495c9 RD |
1738 | |
| 1739 | if stats: | |
| 1740 | NumSegments = len(Shorelines) | |
| 1741 | NumPoints = 0 | |
| 1742 | for segment in Shorelines: | |
| 1743 | NumPoints = NumPoints + len(segment) | |
| 1744 | AvgPoints = NumPoints / NumSegments | |
| 1745 | print "Number of Segments: ", NumSegments | |
| 1746 | print "Average Number of Points per segment: ",AvgPoints | |
| 1747 | if AllLines: | |
| 1748 | Lines = [] | |
| 1749 | for segment in Shorelines: | |
| 1750 | Lines.append(segment[0]) | |
| 1751 | for point in segment[1:-1]: | |
| 1752 | Lines.append(point) | |
| 1753 | Lines.append(point) | |
| 1754 | Lines.append(segment[-1]) | |
| 1755 | return Lines | |
| 1756 | else: | |
| 1757 | return Shorelines | |
| 1758 | return DrawFrame | |
| 1759 | ||
| 1760 | #--------------------------------------------------------------------------- | |
| 1761 | ||
| 1762 | if __name__ == "__main__": | |
| 095315e2 | 1763 | |
| 0b0849b5 RD |
1764 | # running stand alone, Use wxversion: |
| 1765 | # import wxversion | |
| 1766 | # wxversion.select("2.6") | |
| 1767 | # wxversion.select("2.8") | |
| 095315e2 RD |
1768 | import wx |
| 1769 | ||
| 1770 | ||
| 2a0495c9 RD |
1771 | # check options: |
| 1772 | import sys, getopt | |
| 0b0849b5 | 1773 | optlist, args = getopt.getopt(sys.argv[1:],'l',["all", |
| 095315e2 RD |
1774 | "text", |
| 1775 | "map", | |
| 1776 | "stext", | |
| 1777 | "stextbox", | |
| 1778 | "bitmap", | |
| 1779 | "hit", | |
| 1780 | "hitf", | |
| 1781 | "animate", | |
| 1782 | "speed", | |
| 1783 | "temp", | |
| 1784 | "props", | |
| 1785 | "arrow", | |
| 0b0849b5 | 1786 | "arrowline", |
| 095315e2 | 1787 | "hide"]) |
| 2a0495c9 | 1788 | |
| 0b0849b5 | 1789 | if not haveNumpy: |
| 2a0495c9 RD |
1790 | raise ImportError(errorText) |
| 1791 | StartUpDemo = "all" # the default | |
| 0b0849b5 RD |
1792 | if optlist: |
| 1793 | StartUpDemo = optlist[0][0][2:] | |
| 1794 | ||
| 2e839e96 | 1795 | |
| 8fa876ca | 1796 | class DemoApp(wx.App): |
| 8b9a4190 RD |
1797 | """ |
| 1798 | How the demo works: | |
| 2e839e96 | 1799 | |
| 8b9a4190 | 1800 | Under the Draw menu, there are three options: |
| 2e839e96 | 1801 | |
| 8b9a4190 RD |
1802 | *Draw Test: will put up a picture of a bunch of randomly generated |
| 1803 | objects, of each kind supported. | |
| 2e839e96 | 1804 | |
| 8b9a4190 RD |
1805 | *Draw Map: will draw a map of the world. Be patient, it is a big map, |
| 1806 | with a lot of data, and will take a while to load and draw (about 10 sec | |
| 1807 | on my 450Mhz PIII). Redraws take about 2 sec. This demonstrates how the | |
| 1808 | performance is not very good for large drawings. | |
| 2e839e96 | 1809 | |
| 8b9a4190 | 1810 | *Clear: Clears the Canvas. |
| 2e839e96 | 1811 | |
| 8b9a4190 RD |
1812 | Once you have a picture drawn, you can zoom in and out and move about |
| 1813 | the picture. There is a tool bar with three tools that can be | |
| 1814 | selected. | |
| 2e839e96 | 1815 | |
| 8b9a4190 RD |
1816 | The magnifying glass with the plus is the zoom in tool. Once selected, |
| 1817 | if you click the image, it will zoom in, centered on where you | |
| 1818 | clicked. If you click and drag the mouse, you will get a rubber band | |
| 1819 | box, and the image will zoom to fit that box when you release it. | |
| 2e839e96 | 1820 | |
| 8b9a4190 RD |
1821 | The magnifying glass with the minus is the zoom out tool. Once selected, |
| 1822 | if you click the image, it will zoom out, centered on where you | |
| 1823 | clicked. (note that this takes a while when you are looking at the map, | |
| 1824 | as it has a LOT of lines to be drawn. The image is double buffered, so | |
| 1825 | you don't see the drawing in progress) | |
| 2e839e96 | 1826 | |
| 8b9a4190 RD |
1827 | The hand is the move tool. Once selected, if you click and drag on the |
| 1828 | image, it will move so that the part you clicked on ends up where you | |
| 1829 | release the mouse. Nothing is changed while you are dragging. The | |
| 1830 | drawing is too slow for that. | |
| 2e839e96 | 1831 | |
| 8b9a4190 RD |
1832 | I'd like the cursor to change as you change tools, but the stock |
| 1833 | wxCursors didn't include anything I liked, so I stuck with the | |
| 1834 | pointer. Please let me know if you have any nice cursor images for me to | |
| 1835 | use. | |
| 2e839e96 RD |
1836 | |
| 1837 | ||
| 8b9a4190 | 1838 | Any bugs, comments, feedback, questions, and especially code are welcome: |
| 2e839e96 | 1839 | |
| 8b9a4190 | 1840 | -Chris Barker |
| 2e839e96 | 1841 | |
| 8b9a4190 | 1842 | Chris.Barker@noaa.gov |
| 2e839e96 | 1843 | |
| 8b9a4190 | 1844 | """ |
| 42463de2 RD |
1845 | |
| 1846 | def __init__(self, *args, **kwargs): | |
| 1847 | wx.App.__init__(self, *args, **kwargs) | |
| 2e839e96 | 1848 | |
| 8b9a4190 | 1849 | def OnInit(self): |
| 42463de2 | 1850 | wx.InitAllImageHandlers() |
| 2a0495c9 | 1851 | DrawFrame = BuildDrawFrame() |
| 42463de2 | 1852 | frame = DrawFrame(None, -1, "FloatCanvas Demo App",wx.DefaultPosition,(700,700)) |
| 2e839e96 | 1853 | |
| 8b9a4190 | 1854 | self.SetTopWindow(frame) |
| 42463de2 RD |
1855 | frame.Show() |
| 1856 | ||
| 1857 | ## check to see if the demo is set to start in a particular mode. | |
| 0b0849b5 | 1858 | ## fixme: should this be in a dict instead? |
| 42463de2 RD |
1859 | if StartUpDemo == "text": |
| 1860 | frame.TestText() | |
| 095315e2 | 1861 | elif StartUpDemo == "stext": |
| 42463de2 | 1862 | frame.TestScaledText() |
| 095315e2 RD |
1863 | elif StartUpDemo == "stextbox": |
| 1864 | frame.TestScaledTextBox() | |
| 1865 | elif StartUpDemo == "bitmap": | |
| 1866 | frame.TestBitmap() | |
| 42463de2 RD |
1867 | elif StartUpDemo == "all": |
| 1868 | frame.DrawTest() | |
| 1869 | elif StartUpDemo == "map": | |
| 1870 | frame.DrawMap() | |
| 1871 | elif StartUpDemo == "hit": | |
| 1872 | frame.TestHitTest() | |
| 1873 | elif StartUpDemo == "hitf": | |
| 42463de2 RD |
1874 | frame.TestHitTestForeground() |
| 1875 | elif StartUpDemo == "animate": | |
| 42463de2 RD |
1876 | frame.TestAnimation() |
| 1877 | elif StartUpDemo == "speed": | |
| 42463de2 RD |
1878 | frame.SpeedTest() |
| 1879 | elif StartUpDemo == "temp": | |
| 42463de2 | 1880 | frame.TempTest() |
| 5e1796ef | 1881 | elif StartUpDemo == "props": |
| 5e1796ef | 1882 | frame.PropertiesChangeTest() |
| 2a0495c9 | 1883 | elif StartUpDemo == "arrow": |
| 2a0495c9 | 1884 | frame.ArrowTest() |
| 0b0849b5 RD |
1885 | elif StartUpDemo == "arrowline": |
| 1886 | frame.ArrowLineTest() | |
| 095315e2 | 1887 | elif StartUpDemo == "hide": |
| 095315e2 | 1888 | frame.HideTest() |
| 2e839e96 | 1889 | |
| 8b9a4190 | 1890 | return True |
| 2e839e96 | 1891 | |
| 2a0495c9 RD |
1892 | app = DemoApp(False)# put in True if you want output to go to it's own window. |
| 1893 | app.MainLoop() | |
| 2e839e96 RD |
1894 | |
| 1895 | else: | |
| 2a0495c9 | 1896 | # It's not running stand-alone, set up for wxPython demo. |
| 095315e2 RD |
1897 | # don't neeed wxversion here. |
| 1898 | import wx | |
| 0b0849b5 | 1899 | if not haveNumpy: |
| 2a0495c9 RD |
1900 | ## TestPanel and runTest used for integration into wxPython Demo |
| 1901 | class TestPanel(wx.Panel): | |
| 1902 | def __init__(self, parent, log): | |
| 1903 | self.log = log | |
| 1904 | wx.Panel.__init__(self, parent, -1) | |
| 1905 | ||
| 0b0849b5 | 1906 | from wx.lib.floatcanvas.ScreenShot import getScreenShotBitmap |
| 2a0495c9 RD |
1907 | |
| 1908 | note1 = wx.StaticText(self, -1, errorText) | |
| 1909 | note2 = wx.StaticText(self, -1, "This is what the FloatCanvas can look like:") | |
| 1910 | S = wx.BoxSizer(wx.VERTICAL) | |
| 1911 | S.Add((10, 10), 1) | |
| 1912 | S.Add(note1, 0, wx.ALIGN_CENTER) | |
| 1913 | S.Add(note2, 0, wx.ALIGN_CENTER | wx.BOTTOM, 4) | |
| 0b0849b5 | 1914 | S.Add(wx.StaticBitmap(self,-1,getScreenShotBitmap()),0,wx.ALIGN_CENTER) |
| 2a0495c9 RD |
1915 | S.Add((10, 10), 1) |
| 1916 | self.SetSizer(S) | |
| 1917 | self.Layout() | |
| 42463de2 | 1918 | |
| 2a0495c9 RD |
1919 | else: |
| 1920 | ## TestPanel and runTest used for integration into wxPython Demo | |
| 1921 | class TestPanel(wx.Panel): | |
| 1922 | def __init__(self, parent, log): | |
| 1923 | self.log = log | |
| 1924 | wx.Panel.__init__(self, parent, -1) | |
| 1925 | note1 = wx.StaticText(self, -1, "The FloatCanvas Demo needs") | |
| 1926 | note2 = wx.StaticText(self, -1, "a separate frame") | |
| 1927 | b = wx.Button(self, -1, "Open Demo Frame Now") | |
| 1928 | b.Bind(wx.EVT_BUTTON, self.OnButton) | |
| 1929 | ||
| 1930 | S = wx.BoxSizer(wx.VERTICAL) | |
| 1931 | S.Add((10, 10), 1) | |
| 1932 | S.Add(note1, 0, wx.ALIGN_CENTER) | |
| 1933 | S.Add(note2, 0, wx.ALIGN_CENTER | wx.BOTTOM, 5) | |
| 1934 | S.Add(b, 0, wx.ALIGN_CENTER | wx.ALL, 5) | |
| 1935 | S.Add((10, 10), 1) | |
| 1936 | self.SetSizer(S) | |
| 1937 | self.Layout() | |
| 1938 | ||
| 1939 | def OnButton(self, evt): | |
| 1940 | DrawFrame = BuildDrawFrame() | |
| 1941 | frame = DrawFrame(None, -1, "FloatCanvas Drawing Window",wx.DefaultPosition,(500,500)) | |
| 1942 | ||
| 1943 | #win = wx.lib.plot.TestFrame(self, -1, "PlotCanvas Demo") | |
| 1944 | frame.Show() | |
| 1945 | frame.DrawTest() | |
| 42463de2 | 1946 | |
| 2a0495c9 RD |
1947 | def runTest(frame, nb, log): |
| 1948 | win = TestPanel(nb, log) | |
| 1949 | return win | |
| 42463de2 | 1950 | |
| 2a0495c9 RD |
1951 | # import to get the doc |
| 1952 | from wx.lib import floatcanvas | |
| 1953 | overview = floatcanvas.__doc__ | |
| 42463de2 RD |
1954 | |
| 1955 | ||
| 1956 | ||
| 1957 | ||
| 1958 | ||
| 1959 | ||
| 1960 | ||
| 1961 |