wxPython/demo/FloatCanvas.py

   1 #!/usr/bin/env python
   2
   3 try:
   4     import numpy as N
   5     import numpy.random as RandomArray
   6     haveNumpy = True
   7     #print "Using numpy, version:", N.__version__
   8 except ImportError:
   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             )
  16
  17 #---------------------------------------------------------------------------
  18
  19
  20 def BuildDrawFrame(): # this gets called when needed, rather than on import
  21     try:
  22         from floatcanvas import NavCanvas, FloatCanvas, Resources
  23     except ImportError: # if it's not there locally, try the wxPython lib.
  24         from wx.lib.floatcanvas import NavCanvas, FloatCanvas, Resources
  25     import wx.lib.colourdb
  26     import time, random
  27
  28     class DrawFrame(wx.Frame):
  29
  30         """
  31         A frame used for the FloatCanvas Demo
  32
  33         """
  34
  35
  36         def __init__(self,parent, id,title,position,size):
  37             wx.Frame.__init__(self,parent, id,title,position, size)
  38
  39             ## Set up the MenuBar
  40             MenuBar = wx.MenuBar()
  41
  42             file_menu = wx.Menu()
  43             item = file_menu.Append(-1, "&Close","Close this frame")
  44             self.Bind(wx.EVT_MENU, self.OnQuit, item)
  45
  46             item = file_menu.Append(-1, "&SavePNG","Save the current image as a PNG")
  47             self.Bind(wx.EVT_MENU, self.OnSavePNG, item)
  48             MenuBar.Append(file_menu, "&File")
  49
  50             draw_menu = wx.Menu()
  51
  52             item = draw_menu.Append(-1, "&Clear","Clear the Canvas")
  53             self.Bind(wx.EVT_MENU, self.Clear, item)
  54
  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)
  60
  61             item = draw_menu.Append(-1, "Draw &Map","Run a test of drawing a map")
  62             self.Bind(wx.EVT_MENU, self.DrawMap, item)
  63
  64             item = draw_menu.Append(-1, "&Text Test","Run a test of text drawing")
  65             self.Bind(wx.EVT_MENU, self.TestText, item)
  66
  67             item = draw_menu.Append(-1, "&ScaledText Test","Run a test of text drawing")
  68             self.Bind(wx.EVT_MENU, self.TestScaledText, item)
  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
  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)
  78
  79             item = draw_menu.Append(-1, "Hit Test &Foreground","Run a test of the hit test code with a foreground Object")
  80             self.Bind(wx.EVT_MENU, self.TestHitTestForeground, item)
  81
  82             item = draw_menu.Append(-1, "&Animation","Run a test of Animation")
  83             self.Bind(wx.EVT_MENU, self.TestAnimation, item)
  84
  85             #item = draw_menu.Append(-1, "&Speed","Run a test of Drawing Speed")
  86             #self.Bind(wx.EVT_MENU, self.SpeedTest, item)
  87
  88             item = draw_menu.Append(-1, "Change &Properties","Run a test of Changing Object Properties")
  89             self.Bind(wx.EVT_MENU, self.PropertiesChangeTest, item)
  90
  91             item = draw_menu.Append(-1, "&Arrows","Run a test of Arrows")
  92             self.Bind(wx.EVT_MENU, self.ArrowTest, item)
  93
  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")
  98             self.Bind(wx.EVT_MENU, self.HideTest, item)
  99
 100             MenuBar.Append(draw_menu, "&Tests")
 101
 102             view_menu = wx.Menu()
 103             item = view_menu.Append(-1, "Zoom to &Fit","Zoom to fit the window")
 104             self.Bind(wx.EVT_MENU, self.ZoomToFit, item)
 105             MenuBar.Append(view_menu, "&View")
 106
 107             help_menu = wx.Menu()
 108             item = help_menu.Append(-1, "&About",
 109                                     "More information About this program")
 110             self.Bind(wx.EVT_MENU, self.OnAbout, item)
 111             MenuBar.Append(help_menu, "&Help")
 112
 113             self.SetMenuBar(MenuBar)
 114
 115             self.CreateStatusBar()
 116
 117
 118             # Add the Canvas
 119             NC = NavCanvas.NavCanvas(self,
 120                                      Debug = 0,
 121                                      BackgroundColor = "DARK SLATE BLUE")
 122
 123             self.Canvas = NC.Canvas # reference the contained FloatCanvas
 124
 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)
 134             MainSizer.Add(NC, 4, wx.EXPAND)
 135             MainSizer.Add(self.MsgWindow, 1, wx.EXPAND | wx.ALL, 5)
 136
 137             self.SetSizer(MainSizer)
 138             self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
 139
 140             self.Canvas.Bind(FloatCanvas.EVT_MOTION, self.OnMove)
 141             self.Canvas.Bind(FloatCanvas.EVT_MOUSEWHEEL, self.OnWheel)
 142
 143             self.EventsAreBound = False
 144
 145             ## getting all the colors for random objects
 146             wx.lib.colourdb.updateColourDB()
 147             self.colors = wx.lib.colourdb.getColourList()
 148
 149
 150             return None
 151
 152         def Log(self, text):
 153             self.MsgWindow.AppendText(text)
 154             if not text[-1] == "\n":
 155                 self.MsgWindow.AppendText("\n")
 156
 157
 158         def BindAllMouseEvents(self):
 159             if not self.EventsAreBound:
 160                 ## Here is how you catch FloatCanvas mouse events
 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)
 164
 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)
 168
 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)
 172
 173             self.EventsAreBound = True
 174
 175
 176         def UnBindAllMouseEvents(self):
 177             ## Here is how you unbind FloatCanvas mouse events
 178             self.Canvas.Unbind(FloatCanvas.EVT_LEFT_DOWN)
 179             self.Canvas.Unbind(FloatCanvas.EVT_LEFT_UP)
 180             self.Canvas.Unbind(FloatCanvas.EVT_LEFT_DCLICK)
 181
 182             self.Canvas.Unbind(FloatCanvas.EVT_MIDDLE_DOWN)
 183             self.Canvas.Unbind(FloatCanvas.EVT_MIDDLE_UP)
 184             self.Canvas.Unbind(FloatCanvas.EVT_MIDDLE_DCLICK)
 185
 186             self.Canvas.Unbind(FloatCanvas.EVT_RIGHT_DOWN)
 187             self.Canvas.Unbind(FloatCanvas.EVT_RIGHT_UP)
 188             self.Canvas.Unbind(FloatCanvas.EVT_RIGHT_DCLICK)
 189
 190             self.EventsAreBound = False
 191
 192
 193         def PrintCoords(self,event):
 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
 210         def OnLeftDown(self, event):
 211             self.Log("LeftDown")
 212             self.PrintCoords(event)
 213
 214         def OnLeftUp(self, event):
 215             self.Log("LeftUp")
 216             self.PrintCoords(event)
 217
 218         def OnLeftDouble(self, event):
 219             self.Log("LeftDouble")
 220             self.PrintCoords(event)
 221
 222         def OnMiddleDown(self, event):
 223             self.Log("MiddleDown")
 224             self.PrintCoords(event)
 225
 226         def OnMiddleUp(self, event):
 227             self.Log("MiddleUp")
 228             self.PrintCoords(event)
 229
 230         def OnMiddleDouble(self, event):
 231             self.Log("MiddleDouble")
 232             self.PrintCoords(event)
 233
 234         def OnRightDown(self, event):
 235             self.Log("RightDown")
 236             self.PrintCoords(event)
 237
 238         def OnRightUp(self, event):
 239             self.Log("RightUp")
 240             self.PrintCoords(event)
 241
 242         def OnRightDouble(self, event):
 243             self.Log("RightDouble")
 244             self.PrintCoords(event)
 245
 246         def OnWheel(self, event):
 247             self.Log("Mouse Wheel")
 248             self.PrintCoords(event)
 249             Rot = event.GetWheelRotation()
 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
 256         def OnMove(self, event):
 257             """
 258             Updates the status bar with the world coordinates
 259             """
 260             self.SetStatusText("%.2f, %.2f"%tuple(event.Coords))
 261             event.Skip()
 262
 263         def OnAbout(self, event):
 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)
 269             dlg.ShowModal()
 270             dlg.Destroy()
 271
 272         def ZoomToFit(self,event):
 273             self.Canvas.ZoomToBB()
 274
 275         def Clear(self,event = None):
 276             self.UnBindAllMouseEvents()
 277             self.Canvas.InitAll()
 278             self.Canvas.Draw()
 279
 280         def OnQuit(self,event):
 281             self.Close(True)
 282
 283         def OnCloseWindow(self, event):
 284             self.Destroy()
 285
 286         def DrawTest(self,event=None):
 287             """
 288             This demo draws a few of everything
 289
 290             """
 291
 292             wx.GetApp().Yield(True)
 293
 294             Range = (-10,10)
 295             colors = self.colors
 296
 297             self.BindAllMouseEvents()
 298             Canvas = self.Canvas
 299
 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
 306
 307             ############# Random tests of everything ##############
 308
 309             # Rectangles
 310             for i in range(3):
 311                 xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
 312                 lw = random.randint(1,5)
 313                 cf = random.randint(0,len(colors)-1)
 314                 wh = (random.randint(1,5), random.randint(1,5))
 315                 Canvas.AddRectangle(xy, wh, LineWidth = lw, FillColor = colors[cf])
 316
 317             # Ellipses
 318             for i in range(3):
 319                 xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
 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)
 324                 Canvas.AddEllipse(xy, (h,w), LineWidth = lw,FillColor = colors[cf])
 325
 326             # Points
 327             for i in range(5):
 328                 xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
 329                 D = random.randint(1,50)
 330                 cf = random.randint(0,len(colors)-1)
 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
 340             # Circles
 341             for i in range(5):
 342                 xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
 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)
 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")
 349             # Lines
 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)
 358                 Canvas.AddLine(points, LineWidth = lw, LineColor = colors[cl])
 359             # Polygons
 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)
 368                 Canvas.AddPolygon(points,
 369                                        LineWidth = lw,
 370                                        LineColor = colors[cl],
 371                                        FillColor = colors[cf],
 372                                        FillStyle = 'Solid')
 373
 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)
 380                 Canvas.AddPointSet(points, Color = colors[cf], Diameter = D)
 381
 382             # Text
 383             String = "Unscaled text"
 384             for i in range(3):
 385                 ts = random.randint(10,40)
 386                 cf = random.randint(0,len(colors)-1)
 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")
 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)
 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")
 397
 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
 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
 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             """
 433             wx.GetApp().Yield(True)
 434             Range = (-10,10)
 435             self.Range = Range
 436
 437             self.UnBindAllMouseEvents()
 438             Canvas = self.Canvas
 439             Canvas.InitAll()
 440
 441             ##          Random tests of everything:
 442             colors = self.colors
 443             # Rectangles
 444             for i in range(3):
 445                 xy = (random.uniform(Range[0],Range[1]), random.uniform(Range[0],Range[1]))
 446                 lw = random.randint(1,5)
 447                 cf = random.randint(0,len(colors)-1)
 448                 wh = (random.randint(1,5), random.randint(1,5) )
 449                 Canvas.AddRectangle(xy, wh, LineWidth = lw, FillColor = colors[cf])
 450
 451             # Ellipses
 452             for i in range(3):
 453                 xy = (random.uniform(Range[0],Range[1]), random.uniform(Range[0],Range[1]))
 454                 lw = random.randint(1,5)
 455                 cf = random.randint(0,len(colors)-1)
 456                 wh = (random.randint(1,5), random.randint(1,5) )
 457                 Canvas.AddEllipse(xy, wh, LineWidth = lw, FillColor = colors[cf])
 458
 459             # Circles
 460             for i in range(5):
 461                 xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
 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)
 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")
 468
 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])
 479
 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')
 494
 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)
 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")
 502
 503
 504             # Now the Foreground Object:
 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)
 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
 512
 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
 528                 wx.GetApp().Yield(True)
 529             else:
 530                 self.Timer.Stop()
 531
 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()
 540             self.NumTimeSteps = 200
 541             self.TimeStep = 1
 542             self.Timer.Start(self.FrameDelay)
 543             #print "Did %i frames in %f seconds"%(N, (time.time() - start) )
 544
 545         def TestHitTest(self, event=None):
 546             wx.GetApp().Yield(True)
 547
 548             self.UnBindAllMouseEvents()
 549             Canvas = self.Canvas
 550
 551             Canvas.InitAll()
 552
 553             #Add a Hit-able rectangle
 554             w, h = 60, 20
 555
 556             dx = 80
 557             dy = 40
 558             x, y = 20, 20
 559             FontSize = 10
 560
 561             #Add one that is not HitAble
 562             Canvas.AddRectangle((x,y), (w, h), LineWidth = 2)
 563             Canvas.AddText("Not Hit-able", (x,y), Size = FontSize, Position = "bl")
 564
 565
 566             x += dx
 567             R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2)
 568             R.Name = "Line Rectangle"
 569             R.HitFill = False
 570             R.HitLineWidth = 5 # Makes it a little easier to hit
 571             R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHit)
 572             Canvas.AddText("Left Click Line", (x,y), Size = FontSize, Position = "bl")
 573             Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
 574
 575             x += dx
 576             color = "Red"
 577             R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
 578             R.Name = color + "Rectangle"
 579             R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHit)
 580             Canvas.AddText("Left Click Fill", (x, y), Size = FontSize, Position = "bl")
 581             Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
 582
 583             x = 20
 584             y += dy
 585             color = "LightBlue"
 586             R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
 587             R.Name = color + " Rectangle"
 588             R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHit)
 589             Canvas.AddText("Right Click Fill", (x, y), Size = FontSize,  Position = "bl")
 590             Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
 591
 592             x += dx
 593             color = "Grey"
 594             R = Canvas.AddEllipse((x, y), (w, h),LineWidth = 2,FillColor = color)
 595             R.Name = color +" Ellipse"
 596             R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHit)
 597             Canvas.AddText("Right Click Fill", (x, y), Size = FontSize, Position = "bl")
 598             Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
 599
 600             x += dx
 601             color = "Brown"
 602             R = Canvas.AddCircle((x+dx/2, y+dy/2), dx/4, LineWidth = 2, FillColor = color)
 603             R.Name = color + " Circle"
 604             R.HitFill = True
 605             R.Bind(FloatCanvas.EVT_FC_LEFT_DCLICK, self.RectGotHit)
 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")
 608
 609             x = 20
 610             y += dy
 611             color = "Pink"
 612             R = Canvas.AddCircle((x+dx/2, y+dy/2), dx/4, LineWidth = 2,FillColor = color)
 613             R.Name = color +  " Circle"
 614             R.Bind(FloatCanvas.EVT_FC_LEFT_UP, self.RectGotHit)
 615             Canvas.AddText("Left Up Fill", (x, y), Size = FontSize, Position = "bl")
 616             Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
 617
 618             x += dx
 619             color = "White"
 620             R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
 621             R.Name = color + " Rectangle"
 622             R.Bind(FloatCanvas.EVT_FC_MIDDLE_DOWN, self.RectGotHit)
 623             Canvas.AddText("Middle Down", (x, y), Size = FontSize, Position = "bl")
 624             Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
 625
 626             x += dx
 627             color = "AQUAMARINE"
 628             R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
 629             R.Name = color + " Rectangle"
 630             R.Bind(FloatCanvas.EVT_FC_MIDDLE_UP, self.RectGotHit)
 631             Canvas.AddText("Middle Up", (x, y), Size = FontSize, Position = "bl")
 632             Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
 633
 634             x = 20
 635             y += dy
 636             color = "CORAL"
 637             R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
 638             R.Name = color + " Rectangle"
 639             R.Bind(FloatCanvas.EVT_FC_MIDDLE_DCLICK, self.RectGotHit)
 640             Canvas.AddText("Middle DoubleClick", (x, y), Size = FontSize, Position = "bl")
 641             Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
 642
 643             x += dx
 644             color = "CYAN"
 645             R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
 646             R.Name = color + " Rectangle"
 647             R.Bind(FloatCanvas.EVT_FC_RIGHT_UP, self.RectGotHit)
 648             Canvas.AddText("Right Up", (x, y), Size = FontSize, Position = "bl")
 649             Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
 650
 651             x += dx
 652             color = "LIME GREEN"
 653             R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
 654             R.Name = color + " Rectangle"
 655             R.Bind(FloatCanvas.EVT_FC_RIGHT_DCLICK, self.RectGotHit)
 656             Canvas.AddText("Right Double Click", (x, y), Size = FontSize, Position = "bl")
 657             Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
 658
 659             x = 20
 660             y += dy
 661             color = "MEDIUM GOLDENROD"
 662             R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
 663             R.Name = color
 664             R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHitRight)
 665             R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHitLeft)
 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")
 668
 669             x += dx
 670             color = "SALMON"
 671             R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
 672             R.Name = color + " Rectangle"
 673             R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver)
 674             Canvas.AddText("Mouse Enter", (x, y), Size = FontSize, Position = "bl")
 675             Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
 676
 677             x += dx
 678             color = "MEDIUM VIOLET RED"
 679             R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
 680             R.Name = color
 681             R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave)
 682             Canvas.AddText("Mouse Leave", (x, y), Size = FontSize, Position = "bl")
 683             Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
 684
 685             x = 20
 686             y += dy
 687             color = "SKY BLUE"
 688             R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
 689             R.Name = color
 690             R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver)
 691             R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave)
 692             Canvas.AddText("Enter and Leave", (x, y), Size = FontSize, Position = "bl")
 693             Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
 694
 695             x += dx
 696             color = "WHEAT"
 697             R = Canvas.AddRectangle((x, y), (w+12, h), LineColor = None, FillColor = color)
 698             R.Name = color
 699             R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver)
 700             R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave)
 701             Canvas.AddText("Mouse Enter&Leave", (x, y), Size = FontSize, Position = "bl")
 702             Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
 703
 704             x += dx
 705             color = "KHAKI"
 706             R = Canvas.AddRectangle((x-12, y), (w+12, h), LineColor = None, FillColor = color)
 707             R.Name = color
 708             R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver)
 709             R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave)
 710             Canvas.AddText("Mouse Enter&Leave", (x, y), Size = FontSize, Position = "bl")
 711             Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
 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)
 718             Canvas.AddText("Left Down", (x, y), Size = FontSize, Position = "bl")
 719             Canvas.AddText(L.Name, (x, y+h), Size = FontSize, Position = "tl")
 720
 721             x += dx
 722             color = "SEA GREEN"
 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_)
 724             R = Canvas.AddPolygon(Points,  LineWidth = 2, FillColor = color)
 725             R.Name = color + " Polygon"
 726             R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHitRight)
 727             Canvas.AddText("RIGHT_DOWN", (x, y), Size = FontSize, Position = "bl")
 728             Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
 729
 730             x += dx
 731             color = "Red"
 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_)
 733             R = Canvas.AddPointSet(Points,  Diameter = 4, Color = color)
 734             R.Name = "PointSet"
 735             R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.PointSetGotHit)
 736             Canvas.AddText("LEFT_DOWN", (x, y), Size = FontSize, Position = "bl")
 737             Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
 738
 739             x = 20
 740             y += dy
 741             T = Canvas.AddText("Hit-able Text", (x, y), Size = 15, Color = "Red", Position = 'tl')
 742             T.Name = "Hit-able Text"
 743             T.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHitLeft)
 744             Canvas.AddText("Left Down", (x, y), Size = FontSize, Position = "bl")
 745
 746             x += dx
 747             T = Canvas.AddScaledText("Scaled Text", (x, y), Size = 1./2*h, Color = "Pink", Position = 'bl')
 748             Canvas.AddPointSet( (x, y), Diameter = 3)
 749             T.Name = "Scaled Text"
 750             T.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHitLeft)
 751             Canvas.AddText("Left Down", (x, y), Size = FontSize, Position = "tl")
 752
 753             x += dx
 754             color = "Cyan"
 755             Point = (x + w/2, y)
 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_)
 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
 763
 764             self.Canvas.ZoomToBB()
 765
 766         def TestHitTestForeground(self,event=None):
 767             wx.GetApp().Yield(True)
 768
 769             self.UnBindAllMouseEvents()
 770             Canvas = self.Canvas
 771
 772             Canvas.InitAll()
 773
 774             #Add a Hitable rectangle
 775             w, h = 60, 20
 776
 777             dx = 80
 778             dy = 40
 779             x,y = 20, 20
 780
 781             color = "Red"
 782             R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color, InForeground = False)
 783             R.Name = color + "Rectangle"
 784             R.HitFill = True
 785             R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHit)
 786             Canvas.AddText("Left Click Fill", (x, y), Position = "bl")
 787             Canvas.AddText(R.Name, (x, y+h), Position = "tl")
 788
 789             ## A set of Rectangles that move together
 790
 791             ## NOTE: In a real app, it might be better to create a new
 792             ## custom FloatCanvas DrawObject
 793
 794             self.MovingRects = []
 795             WH = (w/2, h/2)
 796             x += dx
 797             color = "LightBlue"
 798             R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True)
 799             R.HitFill = True
 800             R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveLeft)
 801             L = Canvas.AddText("Left", (x + w/4, y + h/4), Position = "cc", InForeground = True)
 802             self.MovingRects.extend( (R,L) )
 803
 804             x += w/2
 805             R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True)
 806             R.HitFill = True
 807             R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveRight)
 808             L = Canvas.AddText("Right", (x + w/4, y + h/4), Position = "cc", InForeground = True)
 809             self.MovingRects.extend( (R,L) )
 810
 811             x -= w/2
 812             y += h/2
 813             R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True)
 814             R.HitFill = True
 815             R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveUp)
 816             L = Canvas.AddText("Up", (x + w/4, y + h/4), Position = "cc", InForeground = True)
 817             self.MovingRects.extend( (R,L) )
 818
 819
 820             x += w/2
 821             R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True)
 822             R.HitFill = True
 823             R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveDown)
 824             L = Canvas.AddText("Down", (x + w/4, y + h/4), Position = "cc", InForeground = True)
 825             self.MovingRects.extend( (R,L) )
 826
 827             self.Canvas.ZoomToBB()
 828
 829         def RectMoveLeft(self,Object):
 830             self.MoveRects("left")
 831
 832         def RectMoveRight(self,Object):
 833             self.MoveRects("right")
 834
 835         def RectMoveUp(self,Object):
 836             self.MoveRects("up")
 837
 838         def RectMoveDown(self,Object):
 839             self.MoveRects("down")
 840
 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
 848                 Object.SetPoint((X,Y))
 849             self.Canvas.Draw()
 850
 851         def PointSetGotHit(self, Object):
 852             self.Log(Object.Name + "Got Hit\n")
 853
 854         def RectGotHit(self, Object):
 855             self.Log(Object.Name + "Got Hit\n")
 856
 857         def RectGotHitRight(self, Object):
 858             self.Log(Object.Name + "Got Hit With Right\n")
 859
 860         def RectGotHitLeft(self, Object):
 861             self.Log(Object.Name + "Got Hit with Left\n")
 862
 863         def RectMouseOver(self, Object):
 864             self.Log("Mouse entered:" +  Object.Name)
 865
 866         def RectMouseLeave(self, Object):
 867             self.Log("Mouse left " +  Object.Name)
 868
 869
 870         def TestText(self, event= None):
 871             wx.GetApp().Yield(True)
 872
 873             self.BindAllMouseEvents()
 874             Canvas = self.Canvas
 875             Canvas.InitAll()
 876
 877
 878             DefaultSize = 12
 879             Point  = (3, 0)
 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
 883             Canvas.AddRectangle((-10,-10),
 884                                 (20,20),
 885                                 LineWidth = 1,
 886                                 LineColor = None)
 887
 888             # Text
 889             String = "Some text"
 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")
 894             Canvas.AddPointSet((Point), Color = "White", Diameter = 2)
 895
 896             Point  = (3, 2)
 897
 898             Canvas.AddPointSet((Point), Color = "White", Diameter = 2)
 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")
 901
 902             Point  = (3, 4)
 903
 904             Canvas.AddPointSet((Point), Color = "White", Diameter = 2)
 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")
 907
 908             Point  = (3, -2)
 909
 910             Canvas.AddPointSet((Point), Color = "White", Diameter = 2)
 911             self.Canvas.AddText("Center Center",
 912                                 Point, Size = DefaultSize,
 913                                 Color = "Black",
 914                                 Position = "cc")
 915
 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)
 919
 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)
 926
 927             # NOTE: this font exists on my Linux box..who knows were else you'll find it!
 928             Font = wx.Font(20, wx.DEFAULT, wx.ITALIC, wx.NORMAL, False, "helvetica")
 929             self.Canvas.AddText("Helvetica Italic", (-10, -6), Font = Font)
 930
 931             self.Canvas.ZoomToBB()
 932
 933         def TestScaledText(self, event= None):
 934             wx.GetApp().Yield(True)
 935
 936             self.BindAllMouseEvents()
 937             Canvas = self.Canvas
 938             Canvas.InitAll()
 939
 940             Point  = (0, 0)
 941
 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)
 952
 953
 954             Point  = (0, 20)
 955
 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)
 959
 960             Point  = (0, -20)
 961
 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)
 965
 966             x = -200
 967
 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)
 974             Canvas.AddPointSet((x,0), Color = "White", Diameter = 4)
 975
 976
 977             # NOTE: this font exists on my OS-X.who knows were else you'll find it!
 978             Point = (-100, 50)
 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')
 981
 982             Point = (-50, -50)
 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)
 985
 986             self.Canvas.ZoomToBB()
 987
 988         def TestScaledTextBox(self, event= None):
 989             wx.GetApp().Yield(True)
 990
 991             self.UnBindAllMouseEvents()
 992             Canvas = self.Canvas
 993             Canvas.InitAll()
 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,
1009                                           Underlined = False,
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,
1057                                           Underlined = False,
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,
1075                                           Underlined = False,
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,
1096                                           Underlined = False,
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,
1114                                           Underlined = False,
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                                           )
1142             Point = N.array((100, -20), N.float_)
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
1156             Point = N.array((0, -40), N.float_)
1157     #        Point = N.array((0, 0), N.float_)
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
1175             Point = N.array((-20, 60), N.float_)
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
1191             Point = N.array((-20, 20), N.float_)
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
1206             Point = N.array((100, -60), N.float_)
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):
1229             wx.GetApp().Yield(True)
1230
1231             self.UnBindAllMouseEvents()
1232             Canvas = self.Canvas
1233             Canvas.InitAll()
1234
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)
1289
1290             self.Canvas.ZoomToBB()
1291
1292         def DrawMap(self,event = None):
1293             wx.GetApp().Yield(True)
1294             import os, time
1295
1296             self.Canvas.InitAll()
1297             self.Canvas.SetProjectionFun("FlatEarth")
1298             self.BindAllMouseEvents()
1299
1300         ## Test of Actual Map Data
1301             #start = time.clock()
1302             self.Log("Loading Map from a File")
1303             wx.GetApp().Yield(True) # so log text will get displayed now.
1304             Shorelines = self.Read_MapGen(os.path.join("data",'world.dat'),stats = 0)
1305             #print "It took %f seconds to load %i shorelines"%(time.clock() - start,len(Shorelines) )
1306             #start = time.clock()
1307             for segment in Shorelines:
1308                 self.Canvas.AddLine(segment)
1309             #print "It took %f seconds to add %i shorelines"%(time.clock() - start,len(Shorelines) )
1310             #start = time.clock()
1311             self.Canvas.ZoomToBB()
1312             #print "It took %f seconds to draw %i shorelines"%(time.clock() - start,len(Shorelines) )
1313
1314
1315
1316         def LineTest(self,event = None):
1317             wx.GetApp().Yield(True)
1318             import os, time
1319 #            import random
1320             colors = self.colors
1321             Range = (-10,10)
1322         ## Test of drawing lots of lines
1323             Canvas = self.Canvas
1324             Canvas.InitAll()
1325                         #start = time.clock()
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):
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
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
1372         def SpeedTest(self,event=None):
1373             wx.GetApp().Yield(True)
1374             BigRange = (-1000,1000)
1375             colors = self.colors
1376
1377             self.UnBindAllMouseEvents()
1378             Canvas = self.Canvas
1379
1380             Canvas.InitAll()
1381
1382             # Pointset
1383             coords = []
1384             for i in range(1000):
1385                 Point = (random.uniform(BigRange[0],BigRange[1]),random.uniform(BigRange[0],BigRange[1]))
1386                 coords.append( (Point) )
1387             print "Drawing the Points"
1388             start = time.clock()
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):
1395             wx.GetApp().Yield(True)
1396
1397             Range = (-10,10)
1398             colors = self.colors
1399
1400             self.UnBindAllMouseEvents()
1401             Canvas = self.Canvas
1402
1403             Canvas.InitAll()
1404
1405             self.ColorObjectsAll = []
1406             self.ColorObjectsLine = []
1407             self.ColorObjectsColor = []
1408             self.ColorObjectsText = []
1409             ##One of each object:
1410             # Rectangle
1411             Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
1412             lw = random.randint(1,5)
1413             cf = random.randint(0,len(colors)-1)
1414             wh = ( random.randint(1,5), random.randint(1,5) )
1415             self.Rectangle = Canvas.AddRectangle(Point, wh, LineWidth = lw, FillColor = colors[cf])
1416             self.ColorObjectsAll.append(self.Rectangle)
1417
1418             # Ellipse
1419             Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
1420             lw = random.randint(1,5)
1421             cf = random.randint(0,len(colors)-1)
1422             wh = ( random.randint(1,5), random.randint(1,5) )
1423             self.Ellipse = Canvas.AddEllipse(Point, wh, LineWidth = lw, FillColor = colors[cf])
1424             self.ColorObjectsAll.append(self.Ellipse)
1425
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))
1433
1434             # Circle
1435             Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
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)
1440             self.Circle = Canvas.AddCircle(Point, D, LineWidth = lw, LineColor = colors[cl], FillColor = colors[cf])
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]))
1452
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'))
1467
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)
1474
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)
1481
1482             # Text
1483             String = "Unscaled text"
1484             ts = random.randint(10,40)
1485             cf = random.randint(0,len(colors)-1)
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"))
1488
1489             # Scaled Text
1490             String = "Scaled text"
1491             ts = random.random()*3 + 0.2
1492             cf = random.randint(0,len(colors)-1)
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"))
1495
1496             # A "Button"
1497             Button = Canvas.AddRectangle((-10, -12), (20, 3), LineStyle = None, FillColor = "Red")
1498             Canvas.AddScaledText("Click Here To Change Properties",
1499                                  (0, -10.5),
1500                                  Size = 0.7,
1501                                  Color = "Black",
1502                                  Position = "cc")
1503
1504             Button.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.ChangeProperties)
1505
1506             Canvas.ZoomToBB()
1507
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):
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)
1534             self.Canvas.Draw(Force = True)
1535
1536         def ArrowTest(self,event=None):
1537             wx.GetApp().Yield(True)
1538             self.UnBindAllMouseEvents()
1539             Canvas = self.Canvas
1540
1541             Canvas.InitAll()
1542             Canvas.MinScale = 15
1543             Canvas.MaxScale = 30
1544
1545             # put in a rectangle to get a bounding box
1546             Canvas.AddRectangle((0,0), (20,20), LineColor = None)
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
1558             Canvas.AddText("Clickable Arrow", (4,18), Position = "bc")
1559             Arrow = Canvas.AddArrow((4,18), 80, Direction = 90 ,LineWidth = 3, LineColor = "Red",   ArrowHeadAngle = 30)
1560             Arrow.HitLineWidth = 6
1561             Arrow.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.ArrowClicked)
1562
1563             Canvas.AddText("Changable Arrow: try clicking it", (16,4), Position = "tc")
1564             self.RotArrow = Canvas.AddArrow((16,4), 80, Direction = 0 ,LineWidth = 3, LineColor = "Green",   ArrowHeadAngle = 30)
1565             self.RotArrow.HitLineWidth = 6
1566             self.RotArrow.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RotateArrow)
1567
1568             Canvas.ZoomToBB()
1569
1570         def ArrowClicked(self,event):
1571             self.Log("The Arrow was Clicked")
1572
1573         def RotateArrow(self,event):
1574             ##print "The Changeable Arrow was Clicked"
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) )
1581
1582             self.Canvas.Draw(Force = True)
1583
1584         def HideTest(self, event=None):
1585             wx.GetApp().Yield(True)
1586
1587             self.UnBindAllMouseEvents()
1588             Canvas = self.Canvas
1589             Canvas.InitAll()
1590
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
1643
1644             if Poly.Visible:
1645                 Poly.Visible = False
1646                 Button.SetText(Button.String.replace("Hide","Show"))
1647             else:
1648                 Poly.Visible = True
1649                 Button.SetText(Button.String.replace("Show", "Hide"))
1650             self.Canvas.Draw(True)
1651
1652
1653         def TempTest(self, event= None):
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)
1664
1665             self.UnBindAllMouseEvents()
1666             Canvas = self.Canvas
1667             Canvas.InitAll()
1668
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
1687
1688             Canvas.ZoomToBB()
1689
1690         def SelectPoly(self, Object):
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):
1709             self.Log("Point Num: %i Hit"%Point.VerticeNum)
1710             self.SelectedPoint = Point
1711
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.
1721
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
1733                         if segment: Shorelines.append(N.array(segment))
1734                         segment = []
1735                     else:
1736                         segment.append(map(float,string.split(line)))
1737             if segment: Shorelines.append(N.array(segment))
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__":
1763
1764     # running stand alone, Use wxversion:
1765 #    import wxversion
1766 #    wxversion.select("2.6")
1767 #    wxversion.select("2.8")
1768     import wx
1769
1770
1771     # check options:
1772     import sys, getopt
1773     optlist, args = getopt.getopt(sys.argv[1:],'l',["all",
1774                                                     "text",
1775                                                     "map",
1776                                                     "stext",
1777                                                     "stextbox",
1778                                                     "bitmap",
1779                                                     "hit",
1780                                                     "hitf",
1781                                                     "animate",
1782                                                     "speed",
1783                                                     "temp",
1784                                                     "props",
1785                                                     "arrow",
1786                                                     "arrowline",
1787                                                     "hide"])
1788
1789     if not haveNumpy:
1790         raise ImportError(errorText)
1791     StartUpDemo = "all" # the default
1792     if optlist:
1793         StartUpDemo = optlist[0][0][2:]
1794
1795
1796     class DemoApp(wx.App):
1797         """
1798         How the demo works:
1799
1800         Under the Draw menu, there are three options:
1801
1802         *Draw Test: will put up a picture of a bunch of randomly generated
1803         objects, of each kind supported.
1804
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.
1809
1810         *Clear: Clears the Canvas.
1811
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.
1815
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.
1820
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)
1826
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.
1831
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.
1836
1837
1838         Any bugs, comments, feedback, questions, and especially code are welcome:
1839
1840         -Chris Barker
1841
1842         Chris.Barker@noaa.gov
1843
1844         """
1845
1846         def __init__(self, *args, **kwargs):
1847             wx.App.__init__(self, *args, **kwargs)
1848
1849         def OnInit(self):
1850             wx.InitAllImageHandlers()
1851             DrawFrame = BuildDrawFrame()
1852             frame = DrawFrame(None, -1, "FloatCanvas Demo App",wx.DefaultPosition,(700,700))
1853
1854             self.SetTopWindow(frame)
1855             frame.Show()
1856
1857             ## check to see if the demo is set to start in a particular mode.
1858             ## fixme: should this be in a dict instead?
1859             if StartUpDemo == "text":
1860                 frame.TestText()
1861             elif StartUpDemo == "stext":
1862                 frame.TestScaledText()
1863             elif StartUpDemo == "stextbox":
1864                 frame.TestScaledTextBox()
1865             elif StartUpDemo == "bitmap":
1866                 frame.TestBitmap()
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":
1874                 frame.TestHitTestForeground()
1875             elif StartUpDemo == "animate":
1876                 frame.TestAnimation()
1877             elif StartUpDemo == "speed":
1878                 frame.SpeedTest()
1879             elif StartUpDemo == "temp":
1880                 frame.TempTest()
1881             elif StartUpDemo == "props":
1882                 frame.PropertiesChangeTest()
1883             elif StartUpDemo == "arrow":
1884                 frame.ArrowTest()
1885             elif StartUpDemo == "arrowline":
1886                 frame.ArrowLineTest()
1887             elif StartUpDemo == "hide":
1888                 frame.HideTest()
1889
1890             return True
1891
1892     app = DemoApp(False)# put in True if you want output to go to it's own window.
1893     app.MainLoop()
1894
1895 else:
1896     # It's not running stand-alone, set up for wxPython demo.
1897     # don't  neeed wxversion here.
1898     import wx
1899     if not haveNumpy:
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
1906                 from wx.lib.floatcanvas.ScreenShot import getScreenShotBitmap
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)
1914                 S.Add(wx.StaticBitmap(self,-1,getScreenShotBitmap()),0,wx.ALIGN_CENTER)
1915                 S.Add((10, 10), 1)
1916                 self.SetSizer(S)
1917                 self.Layout()
1918
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()
1946
1947     def runTest(frame, nb, log):
1948         win = TestPanel(nb, log)
1949         return win
1950
1951     # import to get the doc
1952     from wx.lib import floatcanvas
1953     overview = floatcanvas.__doc__
1954
1955
1956
1957
1958
1959
1960
1961