Add wx/crt.h redirecting to wx/wxcrtvarargs.h

[wxWidgets.git] / wxPython / demo / FloatCanvas.py
diff --git a/wxPython/demo/FloatCanvas.py b/wxPython/demo/FloatCanvas.py

index 94f2eab77cb4194a3200362e37ecc33bbf677d64..0b1c54cfd63aa96c33ea5dd63fc4c0c86428d7fc 100644 (file)
--- a/wxPython/demo/FloatCanvas.py
+++ b/wxPython/demo/FloatCanvas.py
@@ -1,324 +1,352 @@
+#!/usr/bin/env python
  
  try:
  
  try:
-    import Numeric
-    import RandomArray
-    haveNumeric = True
+    import numpy as N
+    import numpy.random as RandomArray
+    haveNumpy = True
+    #print "Using numpy, version:", N.__version__
  except ImportError:
  except ImportError:
-    try:
-        import numarray as Numeric
-        import numarray.random_array as RandomArray
-        haveNumeric = True
-    except ImportError:
-        haveNumeric = False
-
-if not haveNumeric:
-    errorText = """
-The FloatCanvas requires either the Numeric or Numarray module:
-You can get them at:
-     http://sourceforge.net/projects/numpy
-
-NOTE: The Numeric module is substantially faster than numarray for this
-purpose, if you have lot's of objects
-"""
-
-    def runTest(frame, nb, log):
-        dlg = wx.MessageDialog(frame, errorText, 'Sorry', wx.OK |
-                               wx.ICON_INFORMATION)
-        dlg.ShowModal()
-        dlg.Destroy()
+            # numpy isn't there
+            haveNumpy = False
+            errorText = (
+            "The FloatCanvas requires the numpy module, version 1.* \n\n"
+            "You can get info about it at:\n"
+            "http://numpy.scipy.org/\n\n"
+            )
+      
+#---------------------------------------------------------------------------
  
  
-    overview = ""
-    
-else:
-    StartUpDemo = "all"
-    if __name__ == "__main__": # parse options if run stand-alone
-        # check options:
-        import sys, getopt
-        optlist, args = getopt.getopt(sys.argv[1:],'l',["local","all","text","map","stext","hit","hitf","animate","speed","temp"])
-        
-        for opt in optlist:
-            if opt[0] == "--all":
-                StartUpDemo = "all"
-            elif opt[0] == "--text":
-                StartUpDemo = "text"
-            elif opt[0] == "--map":
-                StartUpDemo = "map"
-            elif opt[0] == "--stext":
-                StartUpDemo = "stext"
-            elif opt[0] == "--hit":
-                StartUpDemo = "hit"
-            elif opt[0] == "--hitf":
-                StartUpDemo = "hitf"
-            elif opt[0] == "--animate":
-                StartUpDemo = "animate"
-            elif opt[0] == "--speed":
-                StartUpDemo = "speed"
-            elif opt[0] == "--temp":
-                StartUpDemo = "temp"
-    import wx
-    import time, random
-    
-    def runTest(frame, nb, log):
-        """
-        This method is used by the wxPython Demo Framework for integrating
-        this demo with the rest.
-        """
-        win = DrawFrame(None, -1, "FloatCanvas Drawing Window",wx.DefaultPosition,(500,500))
-        frame.otherWin = win
-        win.Show(True)
-        win.DrawTest()
  
  
+def BuildDrawFrame(): # this gets called when needed, rather than on import
      try:
      try:
-        from floatcanvas import NavCanvas, FloatCanvas
+        from floatcanvas import NavCanvas, FloatCanvas, Resources
      except ImportError: # if it's not there locally, try the wxPython lib.
      except ImportError: # if it's not there locally, try the wxPython lib.
-        from wx.lib.floatcanvas import NavCanvas, FloatCanvas
+        from wx.lib.floatcanvas import NavCanvas, FloatCanvas, Resources
+    import wx.lib.colourdb
+    import time, random
  
  
-    import wxPython.lib.colourdb
-    
      class DrawFrame(wx.Frame):
      class DrawFrame(wx.Frame):
-    
+
          """
          A frame used for the FloatCanvas Demo
          """
          A frame used for the FloatCanvas Demo
-        
+
          """
          """
-        
-        
+
+
          def __init__(self,parent, id,title,position,size):
              wx.Frame.__init__(self,parent, id,title,position, size)
          def __init__(self,parent, id,title,position,size):
              wx.Frame.__init__(self,parent, id,title,position, size)
-            
+
              ## Set up the MenuBar
              MenuBar = wx.MenuBar()
              ## Set up the MenuBar
              MenuBar = wx.MenuBar()
-            
+
              file_menu = wx.Menu()
              item = file_menu.Append(-1, "&Close","Close this frame")
              self.Bind(wx.EVT_MENU, self.OnQuit, item)
              file_menu = wx.Menu()
              item = file_menu.Append(-1, "&Close","Close this frame")
              self.Bind(wx.EVT_MENU, self.OnQuit, item)
+
+            item = file_menu.Append(-1, "&SavePNG","Save the current image as a PNG")
+            self.Bind(wx.EVT_MENU, self.OnSavePNG, item)
              MenuBar.Append(file_menu, "&File")
              MenuBar.Append(file_menu, "&File")
-            
+
              draw_menu = wx.Menu()
  
              draw_menu = wx.Menu()
  
+            item = draw_menu.Append(-1, "&Clear","Clear the Canvas")
+            self.Bind(wx.EVT_MENU, self.Clear, item)
+
              item = draw_menu.Append(-1, "&Draw Test","Run a test of drawing random components")
              self.Bind(wx.EVT_MENU, self.DrawTest, item)
  
              item = draw_menu.Append(-1, "&Line Test","Run a test of drawing random lines")
              self.Bind(wx.EVT_MENU, self.LineTest, item)
              item = draw_menu.Append(-1, "&Draw Test","Run a test of drawing random components")
              self.Bind(wx.EVT_MENU, self.DrawTest, item)
  
              item = draw_menu.Append(-1, "&Line Test","Run a test of drawing random lines")
              self.Bind(wx.EVT_MENU, self.LineTest, item)
-            
+
              item = draw_menu.Append(-1, "Draw &Map","Run a test of drawing a map")
              self.Bind(wx.EVT_MENU, self.DrawMap, item)
              item = draw_menu.Append(-1, "Draw &Map","Run a test of drawing a map")
              self.Bind(wx.EVT_MENU, self.DrawMap, item)
+
              item = draw_menu.Append(-1, "&Text Test","Run a test of text drawing")
              self.Bind(wx.EVT_MENU, self.TestText, item)
              item = draw_menu.Append(-1, "&Text Test","Run a test of text drawing")
              self.Bind(wx.EVT_MENU, self.TestText, item)
+
              item = draw_menu.Append(-1, "&ScaledText Test","Run a test of text drawing")
              self.Bind(wx.EVT_MENU, self.TestScaledText, item)
              item = draw_menu.Append(-1, "&ScaledText Test","Run a test of text drawing")
              self.Bind(wx.EVT_MENU, self.TestScaledText, item)
-            item = draw_menu.Append(-1, "&Clear","Clear the Canvas")
-            self.Bind(wx.EVT_MENU, self.Clear, item)
+
+            item = draw_menu.Append(-1, "&ScaledTextBox Test","Run a test of the Scaled Text Box")
+            self.Bind(wx.EVT_MENU, self.TestScaledTextBox, item)
+
+            item = draw_menu.Append(-1, "&Bitmap Test","Run a test of the Bitmap Object")
+            self.Bind(wx.EVT_MENU, self.TestBitmap, item)
+
              item = draw_menu.Append(-1, "&Hit Test","Run a test of the hit test code")
              self.Bind(wx.EVT_MENU, self.TestHitTest, item)
              item = draw_menu.Append(-1, "&Hit Test","Run a test of the hit test code")
              self.Bind(wx.EVT_MENU, self.TestHitTest, item)
-            item = draw_menu.Append(-1, "&Hit Test Foreground","Run a test of the hit test code with a foreground Object")
+
+            item = draw_menu.Append(-1, "Hit Test &Foreground","Run a test of the hit test code with a foreground Object")
              self.Bind(wx.EVT_MENU, self.TestHitTestForeground, item)
              self.Bind(wx.EVT_MENU, self.TestHitTestForeground, item)
+
              item = draw_menu.Append(-1, "&Animation","Run a test of Animation")
              self.Bind(wx.EVT_MENU, self.TestAnimation, item)
              item = draw_menu.Append(-1, "&Animation","Run a test of Animation")
              self.Bind(wx.EVT_MENU, self.TestAnimation, item)
-            item = draw_menu.Append(-1, "&Speed","Run a test of Drawing Speed")
-            self.Bind(wx.EVT_MENU, self.SpeedTest, item)
+
+            #item = draw_menu.Append(-1, "&Speed","Run a test of Drawing Speed")
+            #self.Bind(wx.EVT_MENU, self.SpeedTest, item)
+
+            item = draw_menu.Append(-1, "Change &Properties","Run a test of Changing Object Properties")
+            self.Bind(wx.EVT_MENU, self.PropertiesChangeTest, item)
+
+            item = draw_menu.Append(-1, "&Arrows","Run a test of Arrows")
+            self.Bind(wx.EVT_MENU, self.ArrowTest, item)
+
+            item = draw_menu.Append(-1, "&ArrowLine Test","Run a test of drawing Arrow Lines")
+            self.Bind(wx.EVT_MENU, self.ArrowLineTest, item)
+
+            item = draw_menu.Append(-1, "&Hide","Run a test of hiding and showing objects")
+            self.Bind(wx.EVT_MENU, self.HideTest, item)
+
              MenuBar.Append(draw_menu, "&Tests")
              MenuBar.Append(draw_menu, "&Tests")
-            
+
              view_menu = wx.Menu()
              item = view_menu.Append(-1, "Zoom to &Fit","Zoom to fit the window")
              self.Bind(wx.EVT_MENU, self.ZoomToFit, item)
              MenuBar.Append(view_menu, "&View")
              view_menu = wx.Menu()
              item = view_menu.Append(-1, "Zoom to &Fit","Zoom to fit the window")
              self.Bind(wx.EVT_MENU, self.ZoomToFit, item)
              MenuBar.Append(view_menu, "&View")
-            
+
              help_menu = wx.Menu()
              item = help_menu.Append(-1, "&About",
                                      "More information About this program")
              self.Bind(wx.EVT_MENU, self.OnAbout, item)
              MenuBar.Append(help_menu, "&Help")
              help_menu = wx.Menu()
              item = help_menu.Append(-1, "&About",
                                      "More information About this program")
              self.Bind(wx.EVT_MENU, self.OnAbout, item)
              MenuBar.Append(help_menu, "&Help")
-            
+
              self.SetMenuBar(MenuBar)
              self.SetMenuBar(MenuBar)
+
+            self.CreateStatusBar()
+
              
              
-            self.CreateStatusBar()            
              # Add the Canvas
              # Add the Canvas
-            self.Canvas = NavCanvas.NavCanvas(self,
-                                              -1,
-                                              (500,500),
-                                              Debug = 1,
-                                              BackgroundColor = "DARK SLATE BLUE")
+            NC = NavCanvas.NavCanvas(self,
+                                     Debug = 0,
+                                     BackgroundColor = "DARK SLATE BLUE")
+
+            self.Canvas = NC.Canvas # reference the contained FloatCanvas
+
+            self.MsgWindow = wx.TextCtrl(self, wx.ID_ANY,
+                                         "Look Here for output from events\n",
+                                         style = (wx.TE_MULTILINE |
+                                                  wx.TE_READONLY |
+                                                  wx.SUNKEN_BORDER)
+                                         )
+            
+            ##Create a sizer to manage the Canvas and message window
+            MainSizer = wx.BoxSizer(wx.VERTICAL)
+            MainSizer.Add(NC, 4, wx.EXPAND)
+            MainSizer.Add(self.MsgWindow, 1, wx.EXPAND | wx.ALL, 5)
  
  
-            wx.EVT_CLOSE(self, self.OnCloseWindow)
+            self.SetSizer(MainSizer)
+            self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
  
  
-            FloatCanvas.EVT_MOTION(self.Canvas, self.OnMove ) 
-            #FloatCanvas.EVT_LEFT_UP(self.Canvas, self.OnLeftUp ) 
+            self.Canvas.Bind(FloatCanvas.EVT_MOTION, self.OnMove) 
+            self.Canvas.Bind(FloatCanvas.EVT_MOUSEWHEEL, self.OnWheel) 
  
              self.EventsAreBound = False
  
  
              self.EventsAreBound = False
  
-            ## getting all the colors and linestyles  for random objects
-            wxPython.lib.colourdb.updateColourDB()
-            self.colors = wxPython.lib.colourdb.getColourList()
-            #self.LineStyles = FloatCanvas.DrawObject.LineStyleList.keys()
+            ## getting all the colors for random objects
+            wx.lib.colourdb.updateColourDB()
+            self.colors = wx.lib.colourdb.getColourList()
  
  
              return None
  
  
  
              return None
  
+        def Log(self, text):
+            self.MsgWindow.AppendText(text)
+            if not text[-1] == "\n":
+                self.MsgWindow.AppendText("\n")
+            
+
          def BindAllMouseEvents(self):
              if not self.EventsAreBound:
                  ## Here is how you catch FloatCanvas mouse events
          def BindAllMouseEvents(self):
              if not self.EventsAreBound:
                  ## Here is how you catch FloatCanvas mouse events
-                FloatCanvas.EVT_LEFT_DOWN(self.Canvas, self.OnLeftDown ) 
-                FloatCanvas.EVT_LEFT_UP(self.Canvas, self.OnLeftUp )
-                FloatCanvas.EVT_LEFT_DCLICK(self.Canvas, self.OnLeftDouble ) 
+                self.Canvas.Bind(FloatCanvas.EVT_LEFT_DOWN, self.OnLeftDown) 
+                self.Canvas.Bind(FloatCanvas.EVT_LEFT_UP, self.OnLeftUp)
+                self.Canvas.Bind(FloatCanvas.EVT_LEFT_DCLICK, self.OnLeftDouble) 
  
  
-                FloatCanvas.EVT_MIDDLE_DOWN(self.Canvas, self.OnMiddleDown ) 
-                FloatCanvas.EVT_MIDDLE_UP(self.Canvas, self.OnMiddleUp ) 
-                FloatCanvas.EVT_MIDDLE_DCLICK(self.Canvas, self.OnMiddleDouble ) 
+                self.Canvas.Bind(FloatCanvas.EVT_MIDDLE_DOWN, self.OnMiddleDown) 
+                self.Canvas.Bind(FloatCanvas.EVT_MIDDLE_UP, self.OnMiddleUp) 
+                self.Canvas.Bind(FloatCanvas.EVT_MIDDLE_DCLICK, self.OnMiddleDouble) 
  
  
-                FloatCanvas.EVT_RIGHT_DOWN(self.Canvas, self.OnRightDown ) 
-                FloatCanvas.EVT_RIGHT_UP(self.Canvas, self.OnRightUp ) 
-                FloatCanvas.EVT_RIGHT_DCLICK(self.Canvas, self.OnRightDouble ) 
+                self.Canvas.Bind(FloatCanvas.EVT_RIGHT_DOWN, self.OnRightDown) 
+                self.Canvas.Bind(FloatCanvas.EVT_RIGHT_UP, self.OnRightUp) 
+                self.Canvas.Bind(FloatCanvas.EVT_RIGHT_DCLICK, self.OnRightDouble) 
  
  
-                FloatCanvas.EVT_MOUSEWHEEL(self.Canvas, self.OnWheel ) 
              self.EventsAreBound = True
  
              self.EventsAreBound = True
  
-        def UnBindAllMouseEvents(self):
-            ## Here is how you catch FloatCanvas mouse events
-            FloatCanvas.EVT_LEFT_DOWN(self.Canvas, None ) 
-            FloatCanvas.EVT_LEFT_UP(self.Canvas, None )
-            FloatCanvas.EVT_LEFT_DCLICK(self.Canvas, None) 
  
  
-            FloatCanvas.EVT_MIDDLE_DOWN(self.Canvas, None )
-            FloatCanvas.EVT_MIDDLE_UP(self.Canvas, None )
-            FloatCanvas.EVT_MIDDLE_DCLICK(self.Canvas, None )
+        def UnBindAllMouseEvents(self):
+            ## Here is how you unbind FloatCanvas mouse events
+            self.Canvas.Unbind(FloatCanvas.EVT_LEFT_DOWN)
+            self.Canvas.Unbind(FloatCanvas.EVT_LEFT_UP)
+            self.Canvas.Unbind(FloatCanvas.EVT_LEFT_DCLICK)
  
  
-            FloatCanvas.EVT_RIGHT_DOWN(self.Canvas, None )
-            FloatCanvas.EVT_RIGHT_UP(self.Canvas, None )
-            FloatCanvas.EVT_RIGHT_DCLICK(self.Canvas, None )
+            self.Canvas.Unbind(FloatCanvas.EVT_MIDDLE_DOWN)
+            self.Canvas.Unbind(FloatCanvas.EVT_MIDDLE_UP)
+            self.Canvas.Unbind(FloatCanvas.EVT_MIDDLE_DCLICK)
  
  
-            FloatCanvas.EVT_MOUSEWHEEL(self.Canvas, None )
+            self.Canvas.Unbind(FloatCanvas.EVT_RIGHT_DOWN)
+            self.Canvas.Unbind(FloatCanvas.EVT_RIGHT_UP)
+            self.Canvas.Unbind(FloatCanvas.EVT_RIGHT_DCLICK)
  
              self.EventsAreBound = False
  
  
              self.EventsAreBound = False
  
-        def PrintCoords(self,event):
-            print "coords are: %s"%(event.Coords,)
-            print "pixel coords are: %s\n"%(event.GetPosition(),)
  
  
+        def PrintCoords(self,event):
+            self.Log("coords are: %s"%(event.Coords,))
+            self.Log("pixel coords are: %s\n"%(event.GetPosition(),))
+
+        def OnSavePNG(self, event=None):
+            import os
+            dlg = wx.FileDialog(
+                self, message="Save file as ...", defaultDir=os.getcwd(), 
+                defaultFile="", wildcard="*.png", style=wx.SAVE
+                )
+            if dlg.ShowModal() == wx.ID_OK:
+                path = dlg.GetPath()
+                if not(path[-4:].lower() == ".png"):
+                    path = path+".png"
+                self.Canvas.SaveAsImage(path)
+
+                    
          def OnLeftDown(self, event):
          def OnLeftDown(self, event):
-            print "Left Button has been clicked in DrawFrame"
+            self.Log("LeftDown")
              self.PrintCoords(event)
  
          def OnLeftUp(self, event):
              self.PrintCoords(event)
  
          def OnLeftUp(self, event):
-            print "Left up in DrawFrame"
+            self.Log("LeftUp")
              self.PrintCoords(event)
  
          def OnLeftDouble(self, event):
              self.PrintCoords(event)
  
          def OnLeftDouble(self, event):
-            print "Left Double Click in DrawFrame"
+            self.Log("LeftDouble")
              self.PrintCoords(event)
  
          def OnMiddleDown(self, event):
              self.PrintCoords(event)
  
          def OnMiddleDown(self, event):
-            print "Middle Button clicked in DrawFrame"
+            self.Log("MiddleDown")
              self.PrintCoords(event)
  
          def OnMiddleUp(self, event):
              self.PrintCoords(event)
  
          def OnMiddleUp(self, event):
-            print "Middle Button Up in DrawFrame"
+            self.Log("MiddleUp")
              self.PrintCoords(event)
  
          def OnMiddleDouble(self, event):
              self.PrintCoords(event)
  
          def OnMiddleDouble(self, event):
-            print "Middle Button Double clicked in DrawFrame"
+            self.Log("MiddleDouble")
              self.PrintCoords(event)
  
          def OnRightDown(self, event):
              self.PrintCoords(event)
  
          def OnRightDown(self, event):
-            print "Right Button has been clicked in DrawFrame"
+            self.Log("RightDown")
              self.PrintCoords(event)
  
          def OnRightUp(self, event):
              self.PrintCoords(event)
  
          def OnRightUp(self, event):
-            print "Right Button Up in DrawFrame"
+            self.Log("RightUp")
              self.PrintCoords(event)
  
          def OnRightDouble(self, event):
              self.PrintCoords(event)
  
          def OnRightDouble(self, event):
-            print "Right Button Double clicked in DrawFrame"
+            self.Log("RightDouble")
              self.PrintCoords(event)
  
          def OnWheel(self, event):
              self.PrintCoords(event)
  
          def OnWheel(self, event):
-            print "Mouse Wheel Moved in DrawFrame"
+            self.Log("Mouse Wheel")
              self.PrintCoords(event)
              self.PrintCoords(event)
-
+            Rot = event.GetWheelRotation()
+            Rot = Rot / abs(Rot) * 0.1
+            if event.ControlDown(): # move left-right
+                self.Canvas.MoveImage( (Rot, 0), "Panel" )
+            else: # move up-down
+                self.Canvas.MoveImage( (0, Rot), "Panel" )
+                
          def OnMove(self, event):
              """
          def OnMove(self, event):
              """
-            Updates the staus bar with the world coordinates
+            Updates the status bar with the world coordinates
              """
              self.SetStatusText("%.2f, %.2f"%tuple(event.Coords))
              """
              self.SetStatusText("%.2f, %.2f"%tuple(event.Coords))
+            event.Skip()
  
          def OnAbout(self, event):
  
          def OnAbout(self, event):
-            print "OnAbout called"
-            
-            dlg = wx.MessageDialog(self, "This is a small program to demonstrate\n"
-                                                      "the use of the FloatCanvas\n",
-                                                      "About Me", wx.OK | wx.ICON_INFORMATION)
+            dlg = wx.MessageDialog(self,
+                                   "This is a small program to demonstrate\n"
+                                   "the use of the FloatCanvas\n",
+                                   "About Me",
+                                   wx.OK | wx.ICON_INFORMATION)
              dlg.ShowModal()
              dlg.Destroy()
              dlg.ShowModal()
              dlg.Destroy()
-            
+
          def ZoomToFit(self,event):
              self.Canvas.ZoomToBB()
          def ZoomToFit(self,event):
              self.Canvas.ZoomToBB()
-            
+
          def Clear(self,event = None):
              self.UnBindAllMouseEvents()
          def Clear(self,event = None):
              self.UnBindAllMouseEvents()
-            self.Canvas.ClearAll()
-            self.Canvas.SetProjectionFun(None)
+            self.Canvas.InitAll()
              self.Canvas.Draw()
              self.Canvas.Draw()
-            
+
          def OnQuit(self,event):
              self.Close(True)
          def OnQuit(self,event):
              self.Close(True)
-            
+
          def OnCloseWindow(self, event):
              self.Destroy()
          def OnCloseWindow(self, event):
              self.Destroy()
-            
+
          def DrawTest(self,event=None):
          def DrawTest(self,event=None):
+            """
+            This demo draws a few of everything
+
+            """
+            
              wx.GetApp().Yield(True)
              wx.GetApp().Yield(True)
-#            import random
-#            import RandomArray
+
              Range = (-10,10)
              colors = self.colors
  
              self.BindAllMouseEvents()
              Canvas = self.Canvas
  
              Range = (-10,10)
              colors = self.colors
  
              self.BindAllMouseEvents()
              Canvas = self.Canvas
  
-            Canvas.ClearAll()
-            Canvas.SetProjectionFun(None)
-
-            ##         Random tests of everything:
+            Canvas.InitAll()
+            #            
+            ## these set the limits for how much you can zoom in and out
+            Canvas.MinScale = 14
+            Canvas.MaxScale = 500
              
              
+
+            ############# Random tests of everything ##############
+
              # Rectangles
              for i in range(3):
              # Rectangles
              for i in range(3):
-                x,y = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+                xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
                  lw = random.randint(1,5)
                  cf = random.randint(0,len(colors)-1)
                  lw = random.randint(1,5)
                  cf = random.randint(0,len(colors)-1)
-                h = random.randint(1,5)
-                w = random.randint(1,5)
-                Canvas.AddRectangle(x,y,h,w,LineWidth = lw,FillColor = colors[cf])
-              
+                wh = (random.randint(1,5), random.randint(1,5))
+                Canvas.AddRectangle(xy, wh, LineWidth = lw, FillColor = colors[cf])
+
              # Ellipses
              for i in range(3):
              # Ellipses
              for i in range(3):
-                x,y = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+                xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
                  lw = random.randint(1,5)
                  cf = random.randint(0,len(colors)-1)
                  h = random.randint(1,5)
                  w = random.randint(1,5)
                  lw = random.randint(1,5)
                  cf = random.randint(0,len(colors)-1)
                  h = random.randint(1,5)
                  w = random.randint(1,5)
-                Canvas.AddEllipse(x,y,h,w,LineWidth = lw,FillColor = colors[cf])
-              
-##            # Dots -- Does anyone need this?
-##            for i in range(5):
-##                x,y = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
-##                D = random.randint(1,50)
-##                lw = random.randint(1,5)
-##                cf = random.randint(0,len(colors)-1)
-##                cl = random.randint(0,len(colors)-1)
-##                Canvas.AddDot(x,y,D,LineWidth = lw,LineColor = colors[cl],FillColor = colors[cf])
-              
-                # Circles
+                Canvas.AddEllipse(xy, (h,w), LineWidth = lw,FillColor = colors[cf])
+
+            # Points
              for i in range(5):
              for i in range(5):
-                x,y = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+                xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+                D = random.randint(1,50)
+                cf = random.randint(0,len(colors)-1)
+                Canvas.AddPoint(xy, Color = colors[cf], Diameter = D)
+
+            # SquarePoints
+            for i in range(500):
+                xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+                S = random.randint(1, 50)
+                cf = random.randint(0,len(colors)-1)
+                Canvas.AddSquarePoint(xy, Color = colors[cf], Size = S)
+
+            # Circles
+            for i in range(5):
+                xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
                  D = random.randint(1,5)
                  lw = random.randint(1,5)
                  cf = random.randint(0,len(colors)-1)
                  cl = random.randint(0,len(colors)-1)
                  D = random.randint(1,5)
                  lw = random.randint(1,5)
                  cf = random.randint(0,len(colors)-1)
                  cl = random.randint(0,len(colors)-1)
-                Canvas.AddCircle(x,y,D,LineWidth = lw,LineColor = colors[cl],FillColor = colors[cf])
-                Canvas.AddText("Circle # %i"%(i),x,y,Size = 12,BackgroundColor = None,Position = "cc")
-              
-                # Lines
+                Canvas.AddCircle(xy, D, LineWidth = lw, LineColor = colors[cl], FillColor = colors[cf])
+                Canvas.AddText("Circle # %i"%(i), xy, Size = 12, BackgroundColor = None, Position = "cc")
+            # Lines
              for i in range(5):
                  points = []
                  for j in range(random.randint(2,10)):
              for i in range(5):
                  points = []
                  for j in range(random.randint(2,10)):
@@ -328,8 +356,7 @@ else:
                  cf = random.randint(0,len(colors)-1)
                  cl = random.randint(0,len(colors)-1)
                  Canvas.AddLine(points, LineWidth = lw, LineColor = colors[cl])
                  cf = random.randint(0,len(colors)-1)
                  cl = random.randint(0,len(colors)-1)
                  Canvas.AddLine(points, LineWidth = lw, LineColor = colors[cl])
-              
-                # Polygons
+            # Polygons
              for i in range(3):
                  points = []
                  for j in range(random.randint(2,6)):
              for i in range(3):
                  points = []
                  for j in range(random.randint(2,6)):
@@ -343,7 +370,7 @@ else:
                                         LineColor = colors[cl],
                                         FillColor = colors[cf],
                                         FillStyle = 'Solid')
                                         LineColor = colors[cl],
                                         FillColor = colors[cf],
                                         FillStyle = 'Solid')
-                                
+
              ## Pointset
              for i in range(4):
                  points = []
              ## Pointset
              for i in range(4):
                  points = []
@@ -351,22 +378,45 @@ else:
                  cf = random.randint(0,len(colors)-1)
                  D = random.randint(1,4)
                  Canvas.AddPointSet(points, Color = colors[cf], Diameter = D)
                  cf = random.randint(0,len(colors)-1)
                  D = random.randint(1,4)
                  Canvas.AddPointSet(points, Color = colors[cf], Diameter = D)
-            
+
              # Text
              String = "Unscaled text"
              for i in range(3):
                  ts = random.randint(10,40)
                  cf = random.randint(0,len(colors)-1)
              # Text
              String = "Unscaled text"
              for i in range(3):
                  ts = random.randint(10,40)
                  cf = random.randint(0,len(colors)-1)
-                x,y = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
-                Canvas.AddText(String, x, y, Size = ts, Color = colors[cf], Position = "cc")
+                xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+                Canvas.AddText(String, xy, Size = ts, Color = colors[cf], Position = "cc")
  
              # Scaled Text
              String = "Scaled text"
              for i in range(3):
                  ts = random.random()*3 + 0.2
                  cf = random.randint(0,len(colors)-1)
  
              # Scaled Text
              String = "Scaled text"
              for i in range(3):
                  ts = random.random()*3 + 0.2
                  cf = random.randint(0,len(colors)-1)
-                x,y = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
-                Canvas.AddScaledText(String, x, y, Size = ts, Color = colors[cf], Position = "cc")
+                Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+                Canvas.AddScaledText(String, Point, Size = ts, Color = colors[cf], Position = "cc")
+
+            # Arrows
+            N = 5
+            Points = RandomArray.uniform(Range[0], Range[1], (N,2) )
+            for i in range(N):
+                Canvas.AddArrow(Points[i],
+                                random.uniform(20,100),
+                                Direction = random.uniform(0,360),
+                                LineWidth = random.uniform(1,5),
+                                LineColor = colors[random.randint(0,len(colors)-1)],
+                                ArrowHeadAngle = random.uniform(20,90))
+
+            # ArrowLines
+            for i in range(5):
+                points = []
+                for j in range(random.randint(2,10)):
+                    point = (random.randint(Range[0],Range[1]),random.randint(Range[0],Range[1]))
+                    points.append(point)
+                lw = random.randint(1,10)
+                cf = random.randint(0,len(colors)-1)
+                cl = random.randint(0,len(colors)-1)
+                Canvas.AddArrowLine(points, LineWidth = lw, LineColor = colors[cl], ArrowHeadSize= 16)
+
  
              Canvas.ZoomToBB()
  
  
              Canvas.ZoomToBB()
  
@@ -380,47 +430,42 @@ else:
              having to re-draw the whole background.
  
              """
              having to re-draw the whole background.
  
              """
-            print "Running TestAnimation"
              wx.GetApp().Yield(True)
              Range = (-10,10)
              self.Range = Range
  
              self.UnBindAllMouseEvents()
              Canvas = self.Canvas
              wx.GetApp().Yield(True)
              Range = (-10,10)
              self.Range = Range
  
              self.UnBindAllMouseEvents()
              Canvas = self.Canvas
-
-            Canvas.ClearAll()
-            Canvas.SetProjectionFun(None)
+            Canvas.InitAll()
  
              ##         Random tests of everything:
              colors = self.colors
              # Rectangles
              for i in range(3):
  
              ##         Random tests of everything:
              colors = self.colors
              # Rectangles
              for i in range(3):
-                x,y = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+                xy = (random.uniform(Range[0],Range[1]), random.uniform(Range[0],Range[1]))
                  lw = random.randint(1,5)
                  cf = random.randint(0,len(colors)-1)
                  lw = random.randint(1,5)
                  cf = random.randint(0,len(colors)-1)
-                h = random.randint(1,5)
-                w = random.randint(1,5)
-                Canvas.AddRectangle(x,y,h,w,LineWidth = lw,FillColor = colors[cf])
-              
+                wh = (random.randint(1,5), random.randint(1,5) )
+                Canvas.AddRectangle(xy, wh, LineWidth = lw, FillColor = colors[cf])
+
              # Ellipses
              for i in range(3):
              # Ellipses
              for i in range(3):
-                x,y = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+                xy = (random.uniform(Range[0],Range[1]), random.uniform(Range[0],Range[1]))
                  lw = random.randint(1,5)
                  cf = random.randint(0,len(colors)-1)
                  lw = random.randint(1,5)
                  cf = random.randint(0,len(colors)-1)
-                h = random.randint(1,5)
-                w = random.randint(1,5)
-                Canvas.AddEllipse(x,y,h,w,LineWidth = lw,FillColor = colors[cf])
-              
+                wh = (random.randint(1,5), random.randint(1,5) )
+                Canvas.AddEllipse(xy, wh, LineWidth = lw, FillColor = colors[cf])
+
              # Circles
              for i in range(5):
              # Circles
              for i in range(5):
-                x,y = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+                xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
                  D = random.randint(1,5)
                  lw = random.randint(1,5)
                  cf = random.randint(0,len(colors)-1)
                  cl = random.randint(0,len(colors)-1)
                  D = random.randint(1,5)
                  lw = random.randint(1,5)
                  cf = random.randint(0,len(colors)-1)
                  cl = random.randint(0,len(colors)-1)
-                Canvas.AddCircle(x,y,D,LineWidth = lw,LineColor = colors[cl],FillColor = colors[cf])
-                Canvas.AddText("Circle # %i"%(i),x,y,Size = 12,BackgroundColor = None,Position = "cc")
-              
+                Canvas.AddCircle(xy, D, LineWidth = lw, LineColor = colors[cl], FillColor = colors[cf])
+                Canvas.AddText("Circle # %i"%(i), xy, Size = 12, BackgroundColor = None, Position = "cc")
+
              # Lines
              for i in range(5):
                  points = []
              # Lines
              for i in range(5):
                  points = []
@@ -431,7 +476,7 @@ else:
                  cf = random.randint(0,len(colors)-1)
                  cl = random.randint(0,len(colors)-1)
                  Canvas.AddLine(points, LineWidth = lw, LineColor = colors[cl])
                  cf = random.randint(0,len(colors)-1)
                  cl = random.randint(0,len(colors)-1)
                  Canvas.AddLine(points, LineWidth = lw, LineColor = colors[cl])
-              
+
              # Polygons
              for i in range(3):
                  points = []
              # Polygons
              for i in range(3):
                  points = []
@@ -446,25 +491,25 @@ else:
                                         LineColor = colors[cl],
                                         FillColor = colors[cf],
                                         FillStyle = 'Solid')
                                         LineColor = colors[cl],
                                         FillColor = colors[cf],
                                         FillStyle = 'Solid')
-                                
+
              # Scaled Text
              String = "Scaled text"
              for i in range(3):
                  ts = random.random()*3 + 0.2
                  cf = random.randint(0,len(colors)-1)
              # Scaled Text
              String = "Scaled text"
              for i in range(3):
                  ts = random.random()*3 + 0.2
                  cf = random.randint(0,len(colors)-1)
-                x,y = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
-                Canvas.AddScaledText(String, x, y, Size = ts, Color = colors[cf], Position = "cc")
+                xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+                Canvas.AddScaledText(String, xy, Size = ts, Color = colors[cf], Position = "cc")
  
  
              # Now the Foreground Object:
  
  
              # Now the Foreground Object:
-            C = Canvas.AddCircle(0,0,7,LineWidth = 2,LineColor = "Black",FillColor = "Red", InForeground = True)
-            T = Canvas.AddScaledText("Click to Move",0,0, Size = 0.8, Position = 'cc', InForeground = True)
+            C = Canvas.AddCircle((0,0), 7, LineWidth = 2,LineColor = "Black",FillColor = "Red", InForeground = True)
+            T = Canvas.AddScaledText("Click to Move", (0,0), Size = 0.6, Position = 'cc', InForeground = True)
              C.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.MoveMe)
              C.Text = T
  
              self.Timer = wx.PyTimer(self.ShowFrame)
              self.FrameDelay = 50 # milliseconds
              C.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.MoveMe)
              C.Text = T
  
              self.Timer = wx.PyTimer(self.ShowFrame)
              self.FrameDelay = 50 # milliseconds
-            
+
              Canvas.ZoomToBB()
  
          def ShowFrame(self):
              Canvas.ZoomToBB()
  
          def ShowFrame(self):
@@ -483,7 +528,7 @@ else:
                  wx.GetApp().Yield(True)
              else:
                  self.Timer.Stop()
                  wx.GetApp().Yield(True)
              else:
                  self.Timer.Stop()
-            
+
  
          def MoveMe(self, Object):
              self.MovingObject = Object
  
          def MoveMe(self, Object):
              self.MovingObject = Object
@@ -492,230 +537,239 @@ else:
              self.dy = random.uniform(Range[0]/4,Range[1]/4)
              #import time
              #start = time.time()
              self.dy = random.uniform(Range[0]/4,Range[1]/4)
              #import time
              #start = time.time()
-            self.NumTimeSteps = 500
+            self.NumTimeSteps = 200
              self.TimeStep = 1
              self.Timer.Start(self.FrameDelay)
              #print "Did %i frames in %f seconds"%(N, (time.time() - start) )
              self.TimeStep = 1
              self.Timer.Start(self.FrameDelay)
              #print "Did %i frames in %f seconds"%(N, (time.time() - start) )
-                
-        def TestHitTest(self,event=None):
+
+        def TestHitTest(self, event=None):
              wx.GetApp().Yield(True)
  
              self.UnBindAllMouseEvents()
              Canvas = self.Canvas
  
              wx.GetApp().Yield(True)
  
              self.UnBindAllMouseEvents()
              Canvas = self.Canvas
  
-            Canvas.ClearAll()
-            Canvas.SetProjectionFun(None)
+            Canvas.InitAll()
  
  
-            #Add a HitAble rectangle
+            #Add a Hit-able rectangle
              w, h = 60, 20
  
              dx = 80
              dy = 40
              w, h = 60, 20
  
              dx = 80
              dy = 40
-            x,y = 20, 20
-            
+            x, y = 20, 20
+            FontSize = 10
+
              #Add one that is not HitAble
              #Add one that is not HitAble
-            Canvas.AddRectangle(x, y, w, h, LineWidth = 2)
-            Canvas.AddText("Not Hit-able", x, y, Position = "bl")
-            
+            Canvas.AddRectangle((x,y), (w, h), LineWidth = 2)
+            Canvas.AddText("Not Hit-able", (x,y), Size = FontSize, Position = "bl")
+
  
              x += dx
  
              x += dx
-            R = Canvas.AddRectangle(x, y, w, h,LineWidth = 2)
+            R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2)
              R.Name = "Line Rectangle"
              R.HitFill = False
              R.Name = "Line Rectangle"
              R.HitFill = False
+            R.HitLineWidth = 5 # Makes it a little easier to hit
              R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHit)
              R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHit)
-            Canvas.AddText("Left Click Line", x, y, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Position = "tl")
-            
+            Canvas.AddText("Left Click Line", (x,y), Size = FontSize, Position = "bl")
+            Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
  
              x += dx
              color = "Red"
  
              x += dx
              color = "Red"
-            R = Canvas.AddRectangle(x, y, w, h, LineWidth = 2, FillColor = color)
+            R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
              R.Name = color + "Rectangle"
              R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHit)
              R.Name = color + "Rectangle"
              R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHit)
-            Canvas.AddText("Left Click Fill", x, y, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Position = "tl")
+            Canvas.AddText("Left Click Fill", (x, y), Size = FontSize, Position = "bl")
+            Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
  
              x = 20
              y += dy
              color = "LightBlue"
  
              x = 20
              y += dy
              color = "LightBlue"
-            R = Canvas.AddRectangle(x, y, w, h, LineWidth = 2, FillColor = color)
+            R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
              R.Name = color + " Rectangle"
              R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHit)
              R.Name = color + " Rectangle"
              R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHit)
-            Canvas.AddText("Right Click Fill", x, y, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Position = "tl")
+            Canvas.AddText("Right Click Fill", (x, y), Size = FontSize,  Position = "bl")
+            Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
  
              x += dx
              color = "Grey"
  
              x += dx
              color = "Grey"
-            R = Canvas.AddEllipse(x, y, w, h,LineWidth = 2,FillColor = color)
+            R = Canvas.AddEllipse((x, y), (w, h),LineWidth = 2,FillColor = color)
              R.Name = color +" Ellipse"
              R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHit)
              R.Name = color +" Ellipse"
              R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHit)
-            Canvas.AddText("Right Click Fill", x, y, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Position = "tl")
+            Canvas.AddText("Right Click Fill", (x, y), Size = FontSize, Position = "bl")
+            Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
  
              x += dx
              color = "Brown"
  
              x += dx
              color = "Brown"
-            R = Canvas.AddCircle(x+dx/2, y+dy/2, dx/4, LineWidth = 2, FillColor = color)
+            R = Canvas.AddCircle((x+dx/2, y+dy/2), dx/4, LineWidth = 2, FillColor = color)
              R.Name = color + " Circle"
              R.HitFill = True
              R.Bind(FloatCanvas.EVT_FC_LEFT_DCLICK, self.RectGotHit)
              R.Name = color + " Circle"
              R.HitFill = True
              R.Bind(FloatCanvas.EVT_FC_LEFT_DCLICK, self.RectGotHit)
-            Canvas.AddText("Left D-Click Fill", x, y, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Position = "tl")
+            Canvas.AddText("Left D-Click Fill", (x, y), Size = FontSize, Position = "bl")
+            Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
  
              x = 20
              y += dy
              color = "Pink"
  
              x = 20
              y += dy
              color = "Pink"
-            R = Canvas.AddCircle(x+dx/2, y+dy/2, dx/4, LineWidth = 2,FillColor = color)
+            R = Canvas.AddCircle((x+dx/2, y+dy/2), dx/4, LineWidth = 2,FillColor = color)
              R.Name = color +  " Circle"
              R.Bind(FloatCanvas.EVT_FC_LEFT_UP, self.RectGotHit)
              R.Name = color +  " Circle"
              R.Bind(FloatCanvas.EVT_FC_LEFT_UP, self.RectGotHit)
-            Canvas.AddText("Left Up Fill", x, y, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Position = "tl")
+            Canvas.AddText("Left Up Fill", (x, y), Size = FontSize, Position = "bl")
+            Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
  
              x += dx
              color = "White"
  
              x += dx
              color = "White"
-            R = Canvas.AddRectangle(x, y, w, h, LineWidth = 2, FillColor = color)
+            R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
              R.Name = color + " Rectangle"
              R.Bind(FloatCanvas.EVT_FC_MIDDLE_DOWN, self.RectGotHit)
              R.Name = color + " Rectangle"
              R.Bind(FloatCanvas.EVT_FC_MIDDLE_DOWN, self.RectGotHit)
-            Canvas.AddText("Middle Down", x, y, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Position = "tl")
+            Canvas.AddText("Middle Down", (x, y), Size = FontSize, Position = "bl")
+            Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
  
              x += dx
              color = "AQUAMARINE"
  
              x += dx
              color = "AQUAMARINE"
-            R = Canvas.AddRectangle(x, y, w, h, LineWidth = 2, FillColor = color)
+            R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
              R.Name = color + " Rectangle"
              R.Bind(FloatCanvas.EVT_FC_MIDDLE_UP, self.RectGotHit)
              R.Name = color + " Rectangle"
              R.Bind(FloatCanvas.EVT_FC_MIDDLE_UP, self.RectGotHit)
-            Canvas.AddText("Middle Up", x, y, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Position = "tl")
+            Canvas.AddText("Middle Up", (x, y), Size = FontSize, Position = "bl")
+            Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
  
              x = 20
              y += dy
              color = "CORAL"
  
              x = 20
              y += dy
              color = "CORAL"
-            R = Canvas.AddRectangle(x, y, w, h, LineWidth = 2, FillColor = color)
+            R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
              R.Name = color + " Rectangle"
              R.Bind(FloatCanvas.EVT_FC_MIDDLE_DCLICK, self.RectGotHit)
              R.Name = color + " Rectangle"
              R.Bind(FloatCanvas.EVT_FC_MIDDLE_DCLICK, self.RectGotHit)
-            Canvas.AddText("Middle DoubleClick", x, y, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Position = "tl")
+            Canvas.AddText("Middle DoubleClick", (x, y), Size = FontSize, Position = "bl")
+            Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
  
              x += dx
              color = "CYAN"
  
              x += dx
              color = "CYAN"
-            R = Canvas.AddRectangle(x, y, w, h, LineWidth = 2, FillColor = color)
+            R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
              R.Name = color + " Rectangle"
              R.Bind(FloatCanvas.EVT_FC_RIGHT_UP, self.RectGotHit)
              R.Name = color + " Rectangle"
              R.Bind(FloatCanvas.EVT_FC_RIGHT_UP, self.RectGotHit)
-            Canvas.AddText("Right Up", x, y, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Position = "tl")
+            Canvas.AddText("Right Up", (x, y), Size = FontSize, Position = "bl")
+            Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
  
              x += dx
              color = "LIME GREEN"
  
              x += dx
              color = "LIME GREEN"
-            R = Canvas.AddRectangle(x, y, w, h, LineWidth = 2, FillColor = color)
+            R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
              R.Name = color + " Rectangle"
              R.Bind(FloatCanvas.EVT_FC_RIGHT_DCLICK, self.RectGotHit)
              R.Name = color + " Rectangle"
              R.Bind(FloatCanvas.EVT_FC_RIGHT_DCLICK, self.RectGotHit)
-            Canvas.AddText("Right Double Click", x, y, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Position = "tl")
+            Canvas.AddText("Right Double Click", (x, y), Size = FontSize, Position = "bl")
+            Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
  
              x = 20
              y += dy
              color = "MEDIUM GOLDENROD"
  
              x = 20
              y += dy
              color = "MEDIUM GOLDENROD"
-            R = Canvas.AddRectangle(x, y, w, h, LineWidth = 2, FillColor = color)
+            R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
              R.Name = color
              R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHitRight)
              R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHitLeft)
              R.Name = color
              R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHitRight)
              R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHitLeft)
-            Canvas.AddText("L and R Click", x, y, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Position = "tl")
+            Canvas.AddText("L and R Click", (x, y), Size = FontSize, Position = "bl")
+            Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
  
              x += dx
              color = "SALMON"
  
              x += dx
              color = "SALMON"
-            R = Canvas.AddRectangle(x, y, w, h, LineWidth = 2, FillColor = color)
+            R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
              R.Name = color + " Rectangle"
              R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver)
              R.Name = color + " Rectangle"
              R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver)
-            Canvas.AddText("Mouse Enter", x, y, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Position = "tl")
+            Canvas.AddText("Mouse Enter", (x, y), Size = FontSize, Position = "bl")
+            Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
  
              x += dx
              color = "MEDIUM VIOLET RED"
  
              x += dx
              color = "MEDIUM VIOLET RED"
-            R = Canvas.AddRectangle(x, y, w, h, LineWidth = 2, FillColor = color)
+            R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
              R.Name = color
              R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave)
              R.Name = color
              R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave)
-            Canvas.AddText("Mouse Leave", x, y, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Position = "tl")
+            Canvas.AddText("Mouse Leave", (x, y), Size = FontSize, Position = "bl")
+            Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
  
              x = 20
              y += dy
              color = "SKY BLUE"
  
              x = 20
              y += dy
              color = "SKY BLUE"
-            R = Canvas.AddRectangle(x, y, w, h, LineWidth = 2, FillColor = color)
+            R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
              R.Name = color
              R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver)
              R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave)
              R.Name = color
              R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver)
              R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave)
-            Canvas.AddText("Enter and Leave", x, y, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Position = "tl")
+            Canvas.AddText("Enter and Leave", (x, y), Size = FontSize, Position = "bl")
+            Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
  
              x += dx
              color = "WHEAT"
  
              x += dx
              color = "WHEAT"
-            R = Canvas.AddRectangle(x, y, w+12, h, LineColor = None, FillColor = color)
+            R = Canvas.AddRectangle((x, y), (w+12, h), LineColor = None, FillColor = color)
              R.Name = color
              R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver)
              R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave)
              R.Name = color
              R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver)
              R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave)
-            Canvas.AddText("Mouse Enter&Leave", x, y, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Position = "tl")
+            Canvas.AddText("Mouse Enter&Leave", (x, y), Size = FontSize, Position = "bl")
+            Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
  
              x += dx
              color = "KHAKI"
  
              x += dx
              color = "KHAKI"
-            R = Canvas.AddRectangle(x-12, y, w+12, h, LineColor = None, FillColor = color)
+            R = Canvas.AddRectangle((x-12, y), (w+12, h), LineColor = None, FillColor = color)
              R.Name = color
              R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver)
              R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave)
              R.Name = color
              R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver)
              R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave)
-            Canvas.AddText("Mouse ENter&Leave", x, y, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Position = "tl")
+            Canvas.AddText("Mouse Enter&Leave", (x, y), Size = FontSize, Position = "bl")
+            Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
  
              x = 20
              y += dy
              L = Canvas.AddLine(( (x, y), (x+10, y+10), (x+w, y+h) ), LineWidth = 2, LineColor = "Red")
              L.Name = "A Line"
              L.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHitLeft)
  
              x = 20
              y += dy
              L = Canvas.AddLine(( (x, y), (x+10, y+10), (x+w, y+h) ), LineWidth = 2, LineColor = "Red")
              L.Name = "A Line"
              L.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHitLeft)
-            Canvas.AddText("Left Down", x, y, Position = "bl")
-            Canvas.AddText(L.Name, x, y+h, Position = "tl")
+            Canvas.AddText("Left Down", (x, y), Size = FontSize, Position = "bl")
+            Canvas.AddText(L.Name, (x, y+h), Size = FontSize, Position = "tl")
  
              x += dx
              color = "SEA GREEN"
  
              x += dx
              color = "SEA GREEN"
-            Points = Numeric.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) ), Numeric.Float)
+            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_)
              R = Canvas.AddPolygon(Points,  LineWidth = 2, FillColor = color)
              R.Name = color + " Polygon"
              R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHitRight)
              R = Canvas.AddPolygon(Points,  LineWidth = 2, FillColor = color)
              R.Name = color + " Polygon"
              R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHitRight)
-            Canvas.AddText("RIGHT_DOWN", x, y, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Position = "tl")
+            Canvas.AddText("RIGHT_DOWN", (x, y), Size = FontSize, Position = "bl")
+            Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
  
              x += dx
              color = "Red"
  
              x += dx
              color = "Red"
-            Points = Numeric.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) ), Numeric.Float)
+            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_)
              R = Canvas.AddPointSet(Points,  Diameter = 4, Color = color)
              R.Name = "PointSet"
              R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.PointSetGotHit)
              R = Canvas.AddPointSet(Points,  Diameter = 4, Color = color)
              R.Name = "PointSet"
              R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.PointSetGotHit)
-            Canvas.AddText("LEFT_DOWN", x, y, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Position = "tl")
+            Canvas.AddText("LEFT_DOWN", (x, y), Size = FontSize, Position = "bl")
+            Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
  
              x = 20
              y += dy
  
              x = 20
              y += dy
-            T = Canvas.AddText("Hit-able Text", x, y, Size = 15, Color = "Red", Position = 'tl')
+            T = Canvas.AddText("Hit-able Text", (x, y), Size = 15, Color = "Red", Position = 'tl')
              T.Name = "Hit-able Text"
              T.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHitLeft)
              T.Name = "Hit-able Text"
              T.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHitLeft)
-            Canvas.AddText("Left Down", x, y, Position = "bl")
+            Canvas.AddText("Left Down", (x, y), Size = FontSize, Position = "bl")
  
              x += dx
  
              x += dx
-            T = Canvas.AddScaledText("Scaled Text", x, y, Size = 1./2*h, Color = "Pink", Position = 'bl')
+            T = Canvas.AddScaledText("Scaled Text", (x, y), Size = 1./2*h, Color = "Pink", Position = 'bl')
              Canvas.AddPointSet( (x, y), Diameter = 3)
              T.Name = "Scaled Text"
              T.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHitLeft)
              Canvas.AddPointSet( (x, y), Diameter = 3)
              T.Name = "Scaled Text"
              T.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHitLeft)
-            Canvas.AddText("Left Down", x, y, Position = "tl")
+            Canvas.AddText("Left Down", (x, y), Size = FontSize, Position = "tl")
+
+            x += dx
+            color = "Cyan"
+            Point = (x + w/2, y)
+            #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_)
+            R = Canvas.AddSquarePoint(Point,  Size = 8, Color = color)
+            R.Name = "SquarePoint"
+            R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHit)
+            Canvas.AddText("LEFT_DOWN", (x, y), Size = FontSize, Position = "bl")
+            Canvas.AddText(R.Name, (x, y), Size = FontSize, Position = "tl")
+
  
              self.Canvas.ZoomToBB()
  
          def TestHitTestForeground(self,event=None):
  
              self.Canvas.ZoomToBB()
  
          def TestHitTestForeground(self,event=None):
-            print "Running: TestHitTestForeground"
              wx.GetApp().Yield(True)
  
              self.UnBindAllMouseEvents()
              Canvas = self.Canvas
  
              wx.GetApp().Yield(True)
  
              self.UnBindAllMouseEvents()
              Canvas = self.Canvas
  
-            Canvas.ClearAll()
-            Canvas.SetProjectionFun(None)
+            Canvas.InitAll()
  
              #Add a Hitable rectangle
              w, h = 60, 20
  
              #Add a Hitable rectangle
              w, h = 60, 20
@@ -723,66 +777,67 @@ else:
              dx = 80
              dy = 40
              x,y = 20, 20
              dx = 80
              dy = 40
              x,y = 20, 20
-            
+
              color = "Red"
              color = "Red"
-            R = Canvas.AddRectangle(x, y, w, h, LineWidth = 2, FillColor = color, InForeground = False)
+            R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color, InForeground = False)
              R.Name = color + "Rectangle"
              R.HitFill = True
              R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHit)
              R.Name = color + "Rectangle"
              R.HitFill = True
              R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHit)
-            Canvas.AddText("Left Click Fill", x, y, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Position = "tl")
+            Canvas.AddText("Left Click Fill", (x, y), Position = "bl")
+            Canvas.AddText(R.Name, (x, y+h), Position = "tl")
  
              ## A set of Rectangles that move together
  
              ## A set of Rectangles that move together
-            
+
              ## NOTE: In a real app, it might be better to create a new
              ## custom FloatCanvas DrawObject
              ## NOTE: In a real app, it might be better to create a new
              ## custom FloatCanvas DrawObject
-            
+
              self.MovingRects = []
              self.MovingRects = []
+            WH = (w/2, h/2)
              x += dx
              color = "LightBlue"
              x += dx
              color = "LightBlue"
-            R = Canvas.AddRectangle(x, y, w/2, h/2, LineWidth = 2, FillColor = color, InForeground = True)
+            R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True)
              R.HitFill = True
              R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveLeft)
              R.HitFill = True
              R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveLeft)
-            L = Canvas.AddText("Left", x + w/4, y + h/4, Position = "cc", InForeground = True)
+            L = Canvas.AddText("Left", (x + w/4, y + h/4), Position = "cc", InForeground = True)
              self.MovingRects.extend( (R,L) )
  
              x += w/2
              self.MovingRects.extend( (R,L) )
  
              x += w/2
-            R = Canvas.AddRectangle(x, y, w/2, h/2, LineWidth = 2, FillColor = color, InForeground = True)
+            R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True)
              R.HitFill = True
              R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveRight)
              R.HitFill = True
              R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveRight)
-            L = Canvas.AddText("Right", x + w/4, y + h/4, Position = "cc", InForeground = True)
+            L = Canvas.AddText("Right", (x + w/4, y + h/4), Position = "cc", InForeground = True)
              self.MovingRects.extend( (R,L) )
  
              x -= w/2
              y += h/2
              self.MovingRects.extend( (R,L) )
  
              x -= w/2
              y += h/2
-            R = Canvas.AddRectangle(x, y, w/2, h/2, LineWidth = 2, FillColor = color, InForeground = True)
+            R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True)
              R.HitFill = True
              R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveUp)
              R.HitFill = True
              R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveUp)
-            L = Canvas.AddText("Up", x + w/4, y + h/4, Position = "cc", InForeground = True)
+            L = Canvas.AddText("Up", (x + w/4, y + h/4), Position = "cc", InForeground = True)
              self.MovingRects.extend( (R,L) )
  
  
              x += w/2
              self.MovingRects.extend( (R,L) )
  
  
              x += w/2
-            R = Canvas.AddRectangle(x, y, w/2, h/2, LineWidth = 2, FillColor = color, InForeground = True)
+            R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True)
              R.HitFill = True
              R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveDown)
              R.HitFill = True
              R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveDown)
-            L = Canvas.AddText("Down", x + w/4, y + h/4, Position = "cc", InForeground = True)
+            L = Canvas.AddText("Down", (x + w/4, y + h/4), Position = "cc", InForeground = True)
              self.MovingRects.extend( (R,L) )
  
              self.Canvas.ZoomToBB()
  
          def RectMoveLeft(self,Object):
              self.MoveRects("left")
              self.MovingRects.extend( (R,L) )
  
              self.Canvas.ZoomToBB()
  
          def RectMoveLeft(self,Object):
              self.MoveRects("left")
-            
+
          def RectMoveRight(self,Object):
              self.MoveRects("right")
          def RectMoveRight(self,Object):
              self.MoveRects("right")
-                        
+
          def RectMoveUp(self,Object):
              self.MoveRects("up")
          def RectMoveUp(self,Object):
              self.MoveRects("up")
-                        
+
          def RectMoveDown(self,Object):
              self.MoveRects("down")
          def RectMoveDown(self,Object):
              self.MoveRects("down")
-                        
+
          def MoveRects(self, Dir):
              for Object in self.MovingRects:
                  X,Y = Object.XY
          def MoveRects(self, Dir):
              for Object in self.MovingRects:
                  X,Y = Object.XY
@@ -790,27 +845,26 @@ else:
                  elif Dir == "right": X += 10
                  elif Dir == "up": Y += 10
                  elif Dir == "down": Y -= 10
                  elif Dir == "right": X += 10
                  elif Dir == "up": Y += 10
                  elif Dir == "down": Y -= 10
-                Object.SetXY(X,Y)
+                Object.SetPoint((X,Y))
              self.Canvas.Draw()
              self.Canvas.Draw()
-                
-                        
+
          def PointSetGotHit(self, Object):
          def PointSetGotHit(self, Object):
-            print Object.Name, "Got Hit\n"
+            self.Log(Object.Name + "Got Hit\n")
  
          def RectGotHit(self, Object):
  
          def RectGotHit(self, Object):
-            print Object.Name, "Got Hit\n"
+            self.Log(Object.Name + "Got Hit\n")
  
          def RectGotHitRight(self, Object):
  
          def RectGotHitRight(self, Object):
-            print Object.Name, "Got Hit With Right\n"
+            self.Log(Object.Name + "Got Hit With Right\n")
  
          def RectGotHitLeft(self, Object):
  
          def RectGotHitLeft(self, Object):
-            print Object.Name, "Got Hit with Left\n"
+            self.Log(Object.Name + "Got Hit with Left\n")
  
          def RectMouseOver(self, Object):
  
          def RectMouseOver(self, Object):
-            print "Mouse entered:", Object.Name
+            self.Log("Mouse entered:" +  Object.Name)
  
          def RectMouseLeave(self, Object):
  
          def RectMouseLeave(self, Object):
-            print "Mouse left ", Object.Name
+            self.Log("Mouse left " +  Object.Name)
  
  
          def TestText(self, event= None):
  
  
          def TestText(self, event= None):
@@ -818,58 +872,61 @@ else:
  
              self.BindAllMouseEvents()
              Canvas = self.Canvas
  
              self.BindAllMouseEvents()
              Canvas = self.Canvas
-            Canvas.ClearAll()
-            Canvas.SetProjectionFun(None)
+            Canvas.InitAll()
+            
  
  
-            x,y  = (0, 0)
+            DefaultSize = 12           
+            Point  = (3, 0)
  
              ## Add a non-visible rectangle, just to get a Bounding Box
              ## Text objects have a zero-size bounding box, because it changes with zoom
  
              ## Add a non-visible rectangle, just to get a Bounding Box
              ## Text objects have a zero-size bounding box, because it changes with zoom
-            Canvas.AddRectangle(-10,-10,20,20,LineWidth = 1, LineColor = None)
+            Canvas.AddRectangle((-10,-10),
+                                (20,20),
+                                LineWidth = 1,
+                                LineColor = None)
  
              # Text
              String = "Some text"
  
              # Text
              String = "Some text"
-##            for i in range(10):
-##                ts = random.randint(10,40)
-##                cf = random.randint(0,len(colors)-1)
-##                x,y = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
-            self.Canvas.AddText("Top Left",x,y,Size = 14,Color = "Yellow",BackgroundColor = "Blue", Position = "tl")
-            self.Canvas.AddText("Bottom Left",x,y,Size = 14,Color = "Cyan",BackgroundColor = "Black",Position = "bl")
-            self.Canvas.AddText("Top Right",x,y,Size = 14,Color = "Black",BackgroundColor = "Cyan",Position = "tr")
-            self.Canvas.AddText("Bottom Right",x,y,Size = 14,Color = "Blue",BackgroundColor = "Yellow",Position = "br")
-            Canvas.AddPointSet((x,y), Color = "White", Diameter = 2)
-
-            x,y  = (0, 2)
-            
-            Canvas.AddPointSet((x,y), Color = "White", Diameter = 2)
-            self.Canvas.AddText("Top Center",x,y,Size = 14,Color = "Black",Position = "tc")
-            self.Canvas.AddText("Bottom Center",x,y,Size = 14,Color = "White",Position = "bc")
+            self.Canvas.AddText("Top Left",Point,Size = DefaultSize,Color = "Yellow",BackgroundColor = "Blue", Position = "tl")
+            self.Canvas.AddText("Bottom Left",Point,Size = DefaultSize,Color = "Cyan",BackgroundColor = "Black",Position = "bl")
+            self.Canvas.AddText("Top Right",Point,Size = DefaultSize,Color = "Black",BackgroundColor = "Cyan",Position = "tr")
+            self.Canvas.AddText("Bottom Right",Point,Size = DefaultSize,Color = "Blue",BackgroundColor = "Yellow",Position = "br")
+            Canvas.AddPointSet((Point), Color = "White", Diameter = 2)
  
  
-            x,y  = (0, 4)
-            
-            Canvas.AddPointSet((x,y), Color = "White", Diameter = 2)
-            self.Canvas.AddText("Center Right",x,y,Size = 14,Color = "Black",Position = "cr")
-            self.Canvas.AddText("Center Left",x,y,Size = 14,Color = "Black",Position = "cl")
+            Point  = (3, 2)
  
  
-            x,y  = (0, -2)
-            
-            Canvas.AddPointSet((x,y), Color = "White", Diameter = 2)
-            self.Canvas.AddText("Center Center",x,y,Size = 14,Color = "Black",Position = "cc")
+            Canvas.AddPointSet((Point), Color = "White", Diameter = 2)
+            self.Canvas.AddText("Top Center",Point,Size = DefaultSize,Color = "Black",Position = "tc")
+            self.Canvas.AddText("Bottom Center",Point,Size = DefaultSize,Color = "White",Position = "bc")
+
+            Point  = (3, 4)
+
+            Canvas.AddPointSet((Point), Color = "White", Diameter = 2)
+            self.Canvas.AddText("Center Right",Point,Size = DefaultSize,Color = "Black",Position = "cr")
+            self.Canvas.AddText("Center Left",Point,Size = DefaultSize,Color = "Black",Position = "cl")
+
+            Point  = (3, -2)
  
  
-            self.Canvas.AddText("40 Pixels",-10,8,Size = 40)
-            self.Canvas.AddText("20 Pixels",-10,5,Size = 20)
-            self.Canvas.AddText("10 Pixels",-10,3,Size = 10)
+            Canvas.AddPointSet((Point), Color = "White", Diameter = 2)
+            self.Canvas.AddText("Center Center",
+                                Point, Size = DefaultSize,
+                                Color = "Black",
+                                Position = "cc")
  
  
-            self.Canvas.AddText("MODERN Font", -10, 0, Family = wx.MODERN)
-            self.Canvas.AddText("DECORATIVE Font", -10, -1, Family = wx.DECORATIVE)
-            self.Canvas.AddText("ROMAN Font", -10, -2, Family = wx.ROMAN)
-            self.Canvas.AddText("SCRIPT Font", -10, -3, Family = wx.SCRIPT)
-            self.Canvas.AddText("ROMAN BOLD Font", -10, -4, Family = wx.ROMAN, Weight=wx.BOLD)
-            self.Canvas.AddText("ROMAN ITALIC BOLD Font", -10, -5, Family = wx.ROMAN, Weight=wx.BOLD, Style=wx.ITALIC)
+            self.Canvas.AddText("40 Pixels", (-10,8), Size = 40)
+            self.Canvas.AddText("20 Pixels", (-10,5), Size = 20)
+            self.Canvas.AddText("10 Pixels", (-10,3), Size = 10)
+
+            self.Canvas.AddText("MODERN Font", (-10, 0), Family = wx.MODERN)
+            self.Canvas.AddText("DECORATIVE Font", (-10, -1), Family = wx.DECORATIVE)
+            self.Canvas.AddText("ROMAN Font", (-10, -2), Family = wx.ROMAN)
+            self.Canvas.AddText("SCRIPT Font", (-10, -3), Family = wx.SCRIPT)
+            self.Canvas.AddText("ROMAN BOLD Font", (-10, -4), Family = wx.ROMAN, Weight=wx.BOLD)
+            self.Canvas.AddText("ROMAN ITALIC BOLD Font", (-10, -5), Family = wx.ROMAN, Weight=wx.BOLD, Style=wx.ITALIC)
  
              # NOTE: this font exists on my Linux box..who knows were else you'll find it!
  
              # NOTE: this font exists on my Linux box..who knows were else you'll find it!
-            Font = wx.Font(20, wx.DEFAULT, wx.ITALIC, wx.NORMAL, False, "zapf chancery")
-            self.Canvas.AddText("zapf chancery Font", -10, -6, Font = Font)
+            Font = wx.Font(20, wx.DEFAULT, wx.ITALIC, wx.NORMAL, False, "helvetica")
+            self.Canvas.AddText("Helvetica Italic", (-10, -6), Font = Font)
  
              self.Canvas.ZoomToBB()
  
  
              self.Canvas.ZoomToBB()
  
@@ -878,62 +935,373 @@ else:
  
              self.BindAllMouseEvents()
              Canvas = self.Canvas
  
              self.BindAllMouseEvents()
              Canvas = self.Canvas
-            Canvas.ClearAll()
-            Canvas.SetProjectionFun(None)
+            Canvas.InitAll()
  
  
-            x,y  = (0, 0)
+            Point  = (0, 0)
  
  
-            T = Canvas.AddScaledText("Top Left",x,y,Size = 5,Color = "Yellow",BackgroundColor = "Blue", Position = "tl")
-            T = Canvas.AddScaledText("Bottom Left",x,y,Size = 5,Color = "Cyan",BackgroundColor = "Black",Position = "bl")
-            T = Canvas.AddScaledText("Top Right",x,y,Size = 5,Color = "Black",BackgroundColor = "Cyan",Position = "tr")
-            T = Canvas.AddScaledText("Bottom Right",x,y,Size = 5,Color = "Blue",BackgroundColor = "Yellow",Position = "br")
-            Canvas.AddPointSet((x,y), Color = "Red", Diameter = 4)
+            T = Canvas.AddScaledText("Top Left",
+                                     Point,
+                                     Size = 5,
+                                     Color = "Yellow",
+                                     BackgroundColor = "Blue",
+                                     Position = "tl")
+            T = Canvas.AddScaledText("Bottom Left",Point,Size = 5,Color = "Cyan",BackgroundColor = "Black",Position = "bl")
+            T = Canvas.AddScaledText("Top Right",Point,Size = 5,Color = "Black",BackgroundColor = "Cyan",Position = "tr")
+            T = Canvas.AddScaledText("Bottom Right",Point,Size = 5,Color = "Blue",BackgroundColor = "Yellow",Position = "br")
+            Canvas.AddPointSet((Point), Color = "Red", Diameter = 4)
  
  
  
  
-            x,y  = (0, 20)
-            
-            Canvas.AddScaledText("Top Center",x,y,Size = 7,Color = "Black",Position = "tc")
-            Canvas.AddScaledText("Bottom Center",x,y,Size = 7,Color = "White",Position = "bc")
-            Canvas.AddPointSet((x,y), Color = "White", Diameter = 4)
+            Point  = (0, 20)
  
  
-            x,y  = (0, -20)
-          
-            Canvas.AddScaledText("Center Right",x,y,Size = 9,Color = "Black",Position = "cr")
-            Canvas.AddScaledText("Center Left",x,y,Size = 9,Color = "Black",Position = "cl")
-            Canvas.AddPointSet((x,y), Color = "White", Diameter = 4)
+            Canvas.AddScaledText("Top Center",Point,Size = 7,Color = "Black",Position = "tc")
+            Canvas.AddScaledText("Bottom Center",Point,Size = 7,Color = "White",Position = "bc")
+            Canvas.AddPointSet((Point), Color = "White", Diameter = 4)
+
+            Point  = (0, -20)
+
+            Canvas.AddScaledText("Center Right",Point,Size = 9,Color = "Black",Position = "cr")
+            Canvas.AddScaledText("Center Left",Point,Size = 9,Color = "Black",Position = "cl")
+            Canvas.AddPointSet((Point), Color = "White", Diameter = 4)
  
              x = -200
  
  
              x = -200
  
-            self.Canvas.AddScaledText("MODERN Font", x, 0, Size = 7, Family = wx.MODERN, Color = (0,0,0))
-            self.Canvas.AddScaledText("DECORATIVE Font", x, -10, Size = 7, Family = wx.DECORATIVE, Color = (0,0,1))
-            self.Canvas.AddScaledText("ROMAN Font", x, -20, Size = 7, Family = wx.ROMAN)
-            self.Canvas.AddScaledText("SCRIPT Font", x, -30, Size = 7, Family = wx.SCRIPT)
-            self.Canvas.AddScaledText("ROMAN BOLD Font", x, -40, Size = 7, Family = wx.ROMAN, Weight=wx.BOLD)
-            self.Canvas.AddScaledText("ROMAN ITALIC BOLD Font", x, -50, Size = 7, Family = wx.ROMAN, Weight=wx.BOLD, Style=wx.ITALIC)
+            self.Canvas.AddScaledText("MODERN Font", (x, 0), Size = 7, Family = wx.MODERN, Color = (0,0,0))
+            self.Canvas.AddScaledText("DECORATIVE Font", (x, -10), Size = 7, Family = wx.DECORATIVE, Color = (0,0,1))
+            self.Canvas.AddScaledText("ROMAN Font", (x, -20), Size = 7, Family = wx.ROMAN)
+            self.Canvas.AddScaledText("SCRIPT Font", (x, -30), Size = 7, Family = wx.SCRIPT)
+            self.Canvas.AddScaledText("ROMAN BOLD Font", (x, -40), Size = 7, Family = wx.ROMAN, Weight=wx.BOLD)
+            self.Canvas.AddScaledText("ROMAN ITALIC BOLD Font", (x, -50), Size = 7, Family = wx.ROMAN, Weight=wx.BOLD, Style=wx.ITALIC)
              Canvas.AddPointSet((x,0), Color = "White", Diameter = 4)
  
  
              Canvas.AddPointSet((x,0), Color = "White", Diameter = 4)
  
  
-            # NOTE: this font exists on my Linux box..who knows were else you'll find it!
-            x,y = (-100, 50)
-            Font = wx.Font(12, wx.DEFAULT, wx.ITALIC, wx.NORMAL, False, "zapf chancery")
-            T = self.Canvas.AddScaledText("zapf chancery Font", x, y, Size = 20, Font = Font, Position = 'bc')
+            # NOTE: this font exists on my OS-X.who knows were else you'll find it!
+            Point = (-100, 50)
+            Font = wx.Font(12, wx.DEFAULT, wx.ITALIC, wx.NORMAL, False, "helvetica")
+            T = self.Canvas.AddScaledText("Helvetica Italic", Point, Size = 20, Font = Font, Position = 'bc')
+
+            Point = (-50, -50)
+            Font = wx.Font(12, wx.DEFAULT, wx.ITALIC, wx.NORMAL, False, "times")
+            T = self.Canvas.AddScaledText("Times Font", Point, Size = 8, Font = Font)
+
+            self.Canvas.ZoomToBB()
+
+        def TestScaledTextBox(self, event= None):
+            wx.GetApp().Yield(True)
+
+            self.UnBindAllMouseEvents()
+            Canvas = self.Canvas
+            Canvas.InitAll()
+
+            Point = (45,40)
+            Box = Canvas.AddScaledTextBox("A Two Line\nString",
+                                          Point,
+                                          2,
+                                          Color = "Black",
+                                          BackgroundColor = None,
+                                          LineColor = "Red",
+                                          LineStyle = "Solid",
+                                          LineWidth = 1,
+                                          Width = None,
+                                          PadSize = 5,
+                                          Family = wx.ROMAN,
+                                          Style = wx.NORMAL,
+                                          Weight = wx.NORMAL,
+                                          Underlined = False,
+                                          Position = 'br',
+                                          Alignment = "left",
+                                          InForeground = False)
+
+            # All defaults
+            Box = Canvas.AddScaledTextBox("A Two Line\nString",
+                                          Point,
+                                          2)
+
+            Box = Canvas.AddScaledTextBox("A Two Line\nString",
+                                          Point,
+                                          2,
+                                          BackgroundColor = "Yellow",
+                                          LineColor = "Red",
+                                          LineStyle = "Solid",
+                                          PadSize = 5,
+                                          Family = wx.TELETYPE,
+                                          Position = 'bl')
+
+            Box = Canvas.AddScaledTextBox("A String\nThis box is clickable",
+                                          Point,
+                                          2,
+                                          BackgroundColor = "Yellow",
+                                          LineColor = "Red",
+                                          LineStyle = "Solid",
+                                          PadSize = 5,
+                                          Family = wx.TELETYPE,
+                                          Position = 'tr')
+
+            Box.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.binding2)
+
+            Canvas.AddPoint(Point, Diameter = 4)
+
+            Point = (45,15)
+            Box = Canvas.AddScaledTextBox("A Two Line\nString",
+                                          Point,
+                                          2,
+                                          Color = "Black",
+                                          BackgroundColor = 'Red',
+                                          LineColor = "Blue",
+                                          LineStyle = "LongDash",
+                                          LineWidth = 2,
+                                          Width = None,
+                                          PadSize = 5,
+                                          Family = wx.TELETYPE,
+                                          Style = wx.NORMAL,
+                                          Weight = wx.NORMAL,
+                                          Underlined = False,
+                                          Position = 'cr',
+                                          Alignment = "left",
+                                          InForeground = False)
+
+            Box = Canvas.AddScaledTextBox("A Two Line\nString",
+                                          Point,
+                                          1.5,
+                                          Color = "Black",
+                                          BackgroundColor = 'Red',
+                                          LineColor = "Blue",
+                                          LineStyle = "LongDash",
+                                          LineWidth = 2,
+                                          Width = None,
+                                          PadSize = 5,
+                                          Family = wx.TELETYPE,
+                                          Style = wx.NORMAL,
+                                          Weight = wx.NORMAL,
+                                          Underlined = False,
+                                          Position = 'cl',
+                                          Alignment = "left",
+                                          InForeground = False)
+
+            Canvas.AddPoint(Point, Diameter = 4)
+
+            Point = (45,-10)
+            Box = Canvas.AddScaledTextBox("A Two Line\nString",
+                                          Point,
+                                          2,
+                                          Color = "Black",
+                                          BackgroundColor = 'Red',
+                                          LineColor = "Blue",
+                                          LineStyle = "LongDash",
+                                          LineWidth = 2,
+                                          Width = None,
+                                          PadSize = 3,
+                                          Family = wx.TELETYPE,
+                                          Style = wx.NORMAL,
+                                          Weight = wx.NORMAL,
+                                          Underlined = False,
+                                          Position = 'tc',
+                                          Alignment = "left",
+                                          InForeground = False)
+
+            Box = Canvas.AddScaledTextBox("A three\nLine\nString",
+                                          Point,
+                                          1.5,
+                                          Color = "Black",
+                                          BackgroundColor = 'Red',
+                                          LineColor = "Blue",
+                                          LineStyle = "LongDash",
+                                          LineWidth = 2,
+                                          Width = None,
+                                          PadSize = 0.5,
+                                          Family = wx.TELETYPE,
+                                          Style = wx.NORMAL,
+                                          Weight = wx.NORMAL,
+                                          Underlined = False,
+                                          Position = 'bc',
+                                          Alignment = "left",
+                                          InForeground = False)
+
+
+            Canvas.AddPoint(Point, Diameter = 4)
+
+            Box = Canvas.AddScaledTextBox("Some Auto Wrapped Text. There is enough to do.",
+                                          (80,40),
+                                          2,
+                                          BackgroundColor = 'White',
+                                          LineWidth = 2,
+                                          Width = 20,
+                                          PadSize = 0.5,
+                                          Family = wx.TELETYPE,
+                                          )
+
+            Box = Canvas.AddScaledTextBox("Some more auto wrapped text. Wrapped to a different width.\n\nThis is another paragraph.",
+                                          (80,20),
+                                          2,
+                                          BackgroundColor = 'White',
+                                          LineWidth = 2,
+                                          Width = 40,
+                                          PadSize = 0.5,
+                                          Family = wx.ROMAN,
+                                          Alignment = "right"
+                                          )
+            Point = N.array((100, -20), N.float_)
+            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.",
+                                          Point,
+                                          Size = 3,
+                                          BackgroundColor = 'White',
+                                          LineWidth = 1,
+                                          Width = 40,
+                                          PadSize = 0.0,
+                                          Family = wx.ROMAN,
+                                          Position = "cc",
+                                          LineSpacing = 0.8
+                                          )
+            Canvas.AddPoint(Point, "Red", 2)
+
+            Point = N.array((0, -40), N.float_)
+    #        Point = N.array((0, 0), N.float_)
+            for Position in ["tl", "bl", "tr", "br"]:
+    #        for Position in ["br"]:
+                Box = Canvas.AddScaledTextBox("Here is a\nfour liner\nanother line\nPosition=%s"%Position,
+                                          Point,
+                                          Size = 4,
+                                          Color = "Red",
+                                          BackgroundColor = None,#'LightBlue',
+                                          LineWidth = 1,
+                                          LineColor = "White",
+                                          Width = None,
+                                          PadSize = 2,
+                                          Family = wx.ROMAN,
+                                          Position = Position,
+                                          LineSpacing = 0.8
+                                          )
+            Canvas.AddPoint(Point, "Red", 4)
+
+            Point = N.array((-20, 60), N.float_)
+            Box = Canvas.AddScaledTextBox("Here is some\ncentered\ntext",
+                                          Point,
+                                          Size = 4,
+                                          Color = "Red",
+                                          BackgroundColor = 'LightBlue',
+                                          LineWidth = 1,
+                                          LineColor = "White",
+                                          Width = None,
+                                          PadSize = 2,
+                                          Family = wx.ROMAN,
+                                          Position = "tl",
+                                          Alignment = "center",
+                                          LineSpacing = 0.8
+                                          )
+
+            Point = N.array((-20, 20), N.float_)
+            Box = Canvas.AddScaledTextBox("Here is some\nright aligned\ntext",
+                                          Point,
+                                          Size = 4,
+                                          Color = "Red",
+                                          BackgroundColor = 'LightBlue',
+                                          LineColor = None,
+                                          Width = None,
+                                          PadSize = 2,
+                                          Family = wx.ROMAN,
+                                          Position = "tl",
+                                          Alignment = "right",
+                                          LineSpacing = 0.8
+                                          )
+
+            Point = N.array((100, -60), N.float_)
+            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.",
+                                          Point,
+                                          Size = 3,
+                                          BackgroundColor = 'White',
+                                          LineWidth = 1,
+                                          Width = 40,
+                                          PadSize = 2.0,
+                                          Family = wx.ROMAN,
+                                          Position = "cc",
+                                          LineSpacing = 0.8,
+                                          Alignment = 'center',
+                                          )
+
+
  
  
-            x,y = (-50, -50)
-            Font = wx.Font(12, wx.DEFAULT, wx.ITALIC, wx.NORMAL, False, "bookman")
-            T = self.Canvas.AddScaledText("Bookman Font", x, y, Size = 8, Font = Font)
  
              self.Canvas.ZoomToBB()
  
              self.Canvas.ZoomToBB()
+
+        def binding2(self, event):
+            self.Log("I'm the TextBox")
+
+        def TestBitmap(self, event= None):
+            wx.GetApp().Yield(True)
+
+            self.UnBindAllMouseEvents()
+            Canvas = self.Canvas
+            Canvas.InitAll()
              
              
+            Canvas.AddRectangle((10, 20),
+                                (400, 100),
+                                LineWidth = 3,
+                                LineColor = "Blue",
+                                FillColor = "Red")
+
+            bmp = Resources.getMagPlusBitmap()
+
+            Canvas.AddText("These are Unscaled Bitmaps:", (140, 90))
+          
+            Point = (150, 50)
+            BitMap = Canvas.AddBitmap(bmp, Point, Position = "cc" )
+            Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+            Point = (200, 50)
+            BitMap = Canvas.AddBitmap(bmp, Point, Position = "br" )
+            Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+            Point = (200, 50)
+            BitMap = Canvas.AddBitmap(bmp, Point, Position = "bl" )
+            Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+            Point = (200, 50)
+            BitMap = Canvas.AddBitmap(bmp, Point, Position = "tr" )
+            Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+            Point = (200, 50)
+            BitMap = Canvas.AddBitmap(bmp, Point, Position = "tl" )
+            Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+            Point = (250, 50)
+            BitMap = Canvas.AddBitmap(bmp, Point, Position = "cr" )
+            Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+            Point = (250, 50)
+            BitMap = Canvas.AddBitmap(bmp, Point, Position = "cl" )
+            Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+            Point = (300, 50)
+            BitMap = Canvas.AddBitmap(bmp, Point, Position = "tc" )
+            Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+            Point = (300, 50)
+            BitMap = Canvas.AddBitmap(bmp, Point, Position = "bc" )
+            Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+            Canvas.AddScaledText("These are Scaled Bitmaps:", (220, -60), Size = 10, Position = "tr")
+            Point = (250, -100)
+            BitMap = Canvas.AddScaledBitmap(bmp, Point, Height = 50, Position = "bc" )
+            BitMap = Canvas.AddScaledBitmap(bmp, Point, Height = 50, Position = "tc" )
+            Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+            Point = (300, -100)
+            BitMap = Canvas.AddScaledBitmap(Resources.getMondrianImage(), Point, Height = 50)
+
+            self.Canvas.ZoomToBB()
+
          def DrawMap(self,event = None):
              wx.GetApp().Yield(True)
              import os, time
          def DrawMap(self,event = None):
              wx.GetApp().Yield(True)
              import os, time
-            self.BindAllMouseEvents()
              
              
-        ## Test of Actual Map Data
-            self.Canvas.ClearAll()
+            self.Canvas.InitAll()
              self.Canvas.SetProjectionFun("FlatEarth")
              self.Canvas.SetProjectionFun("FlatEarth")
+            self.BindAllMouseEvents()
+
+        ## Test of Actual Map Data
              #start = time.clock()
              #start = time.clock()
-            Shorelines = Read_MapGen(os.path.join("data",'world.dat'),stats = 0)
+            self.Log("Loading Map from a File")
+            wx.GetApp().Yield(True) # so log text will get displayed now.
+            Shorelines = self.Read_MapGen(os.path.join("data",'world.dat'),stats = 0)
              #print "It took %f seconds to load %i shorelines"%(time.clock() - start,len(Shorelines) )
              #start = time.clock()
              for segment in Shorelines:
              #print "It took %f seconds to load %i shorelines"%(time.clock() - start,len(Shorelines) )
              #start = time.clock()
              for segment in Shorelines:
@@ -942,8 +1310,9 @@ else:
              #start = time.clock()
              self.Canvas.ZoomToBB()
              #print "It took %f seconds to draw %i shorelines"%(time.clock() - start,len(Shorelines) )
              #start = time.clock()
              self.Canvas.ZoomToBB()
              #print "It took %f seconds to draw %i shorelines"%(time.clock() - start,len(Shorelines) )
-    
- 
+
+
+
          def LineTest(self,event = None):
              wx.GetApp().Yield(True)
              import os, time
          def LineTest(self,event = None):
              wx.GetApp().Yield(True)
              import os, time
@@ -952,9 +1321,8 @@ else:
              Range = (-10,10)
          ## Test of drawing lots of lines
              Canvas = self.Canvas
              Range = (-10,10)
          ## Test of drawing lots of lines
              Canvas = self.Canvas
-            Canvas.ClearAll()
-            Canvas.SetProjectionFun(None)
-            #start = time.clock()
+            Canvas.InitAll()
+                        #start = time.clock()
              linepoints = []
              linecolors = []
              linewidths = []
              linepoints = []
              linecolors = []
              linewidths = []
@@ -973,149 +1341,331 @@ else:
              Canvas.ZoomToBB()
              #print "It took %f seconds to draw %i lines"%(time.clock() - start,len(linepoints) )
  
              Canvas.ZoomToBB()
              #print "It took %f seconds to draw %i lines"%(time.clock() - start,len(linepoints) )
  
+        def ArrowLineTest(self,event = None):
+            wx.GetApp().Yield(True)
+            Canvas = self.Canvas
+            Canvas.InitAll()
+            #            import os, time
+##            import random
+            Range = (-100,100)
+            colors = self.colors
+
+            # Lines
+            for i in range(5):
+                points = []
+                for j in range(random.randint(2,10)):
+                    point = (random.randint(Range[0],Range[1]),random.randint(Range[0],Range[1]))
+                    points.append(point)
+                lw = random.randint(1,4)
+                cf = random.randint(0,len(colors)-1)
+                cl = random.randint(0,len(colors)-1)
+                al = random.randint(8,20)
+                aa = random.randint(20,90)
+                Canvas.AddArrowLine(points,
+                                    LineWidth = lw,
+                                    LineColor = colors[cl],
+                                    ArrowHeadSize = al,
+                                    ArrowHeadAngle = aa)
+
+            Canvas.ZoomToBB()
+
          def SpeedTest(self,event=None):
              wx.GetApp().Yield(True)
          def SpeedTest(self,event=None):
              wx.GetApp().Yield(True)
-#            import random
-#            import RandomArray
              BigRange = (-1000,1000)
              colors = self.colors
  
              self.UnBindAllMouseEvents()
              Canvas = self.Canvas
  
              BigRange = (-1000,1000)
              colors = self.colors
  
              self.UnBindAllMouseEvents()
              Canvas = self.Canvas
  
-            Canvas.ClearAll()
-            Canvas.SetProjectionFun(None)
-
-            # Lots of Text
-            String = "Unscaled text"
+            Canvas.InitAll()
+            
+            # Pointset
              coords = []
              coords = []
-            text = []
-            for i in range(5000):
-                x,y = (random.uniform(BigRange[0],BigRange[1]),random.uniform(BigRange[0],BigRange[1]))
-                coords.append( (x,y) )
-            print "Drawing the Numbers"
+            for i in range(1000):
+                Point = (random.uniform(BigRange[0],BigRange[1]),random.uniform(BigRange[0],BigRange[1]))
+                coords.append( (Point) )
+            print "Drawing the Points"
              start = time.clock()
              start = time.clock()
-            for i in xrange( len(coords) ):
-                Canvas.AddText("%i"%(i),
-                               coords[i][0],
-                               coords[i][1],
-                               Size = 12,
-                               Position = "cc",
-                               BackgroundColor = "White")
-            print "It took %s seconds to add the numbers"%(time.clock() - start)
-
-
-##            ObjectList = []
-
-##            print "Building a list of lots of random objects"
-##            ##               Random tests of everything:
-##            def MakeRange():
-##                while True:
-##                    Range = ( random.randint(BigRange[0],BigRange[1]), random.randint(BigRange[0],BigRange[1]) ) 
-##                    if abs (Range[0] -  Range[1]) < 10:
-##                        continue
-##                    if Range[0] > Range[1]:
-##                        Range = ( Range[1], Range[0] )
-##                    break
-##                return Range
-
-##            # Rectangles
-##            for i in range(300):
-##                Range = MakeRange()
-##                x,y = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
-##                lw = random.randint(1,5)
-##                cf = random.randint(0,len(colors)-1)
-##                h = random.randint(1, Range[1] - Range[0])
-##                w = random.randint(1, Range[1] - Range[0])
-##                ObjectList.append(FloatCanvas.Rectangle(x,y,h,w,LineWidth = lw,FillColor = colors[cf]))
-              
-##            # Ellipses
-##            for i in range(300):
-##                Range = MakeRange()
-##                x,y = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
-##                lw = random.randint(1,5)
-##                cf = random.randint(0,len(colors)-1)
-##                h = random.randint(1, Range[1] - Range[0])
-##                w = random.randint(1, Range[1] - Range[0])
-##                ObjectList.append(FloatCanvas.Ellipse(x,y,h,w,LineWidth = lw,FillColor = colors[cf]))
-              
+            for Point in coords:
+                Canvas.AddPoint(Point, Diameter = 4)
+            print "It took %s seconds to add the points"%(time.clock() - start)
+            Canvas.ZoomToBB()
+
+        def PropertiesChangeTest(self,event=None):
+            wx.GetApp().Yield(True)
+
+            Range = (-10,10)
+            colors = self.colors
+
+            self.UnBindAllMouseEvents()
+            Canvas = self.Canvas
+
+            Canvas.InitAll()
              
              
-##            # Circles
-##            for i in range(500):
-##                Range = MakeRange()
-##                x,y = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
-##                D = random.randint(1, (Range[1] - Range[0]) / 2)
-##                lw = random.randint(1,5)
-##                cf = random.randint(0,len(colors)-1)
-##                cl = random.randint(0,len(colors)-1)
-##                ObjectList.append(FloatCanvas.Circle(x,y,D,LineWidth = lw,LineColor = colors[cl],FillColor = colors[cf]))
-##                #ObjectList.append(FloatCanvas.Text("Circle # %i"%(i),x,y,Size = 12,BackgroundColor = None,Position = "cc"))
-              
-##                # Lines
-##            for i in range(500):
-##                Range = MakeRange()
-##                points = []
-##                for j in range(random.randint(2,100)):
-##                    point = (random.randint(Range[0],Range[1]),random.randint(Range[0],Range[1]))
-##                    points.append(point)
-##                lw = random.randint(1,10)
-##                cf = random.randint(0,len(colors)-1)
-##                cl = random.randint(0,len(colors)-1)
-##                ObjectList.append(FloatCanvas.Line(points, LineWidth = lw, LineColor = colors[cl]) )
-              
-##                # Polygons
-##            for i in range(300):
-##                Range = MakeRange()
-##                points = []
-##                for j in range(random.randint(2,60)):
-##                    point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
-##                    points.append(point)
-##                lw = random.randint(1,6)
-##                cf = random.randint(0,len(colors)-1)
-##                cl = random.randint(0,len(colors)-1)
-##                ObjectList.append(FloatCanvas.Polygon(points,
-##                                       LineWidth = lw,
-##                                       LineColor = colors[cl],
-##                                       FillColor = colors[cf],
-##                                       FillStyle = 'Solid') )
-##            random.shuffle(ObjectList)
-##            print "Adding lots of random objects"
-##            start = time.clock()
-##            for Object in ObjectList:
-##                Canvas.AddObject(Object)
-##            print "It took %s Seconds to add %i objects "%(time.clock() - start, len(ObjectList) )
-
-##            ## Pointset
-##            for i in range(100):
-##                points = []
-##                points = RandomArray.uniform(Range[0],Range[1],(100,2))
-##                cf = random.randint(0,len(colors)-1)
-##                D = random.randint(1,4)
-##                Canvas.AddPointSet(points, Color = colors[cf], Diameter = D)
+            self.ColorObjectsAll = []
+            self.ColorObjectsLine = []
+            self.ColorObjectsColor = []
+            self.ColorObjectsText = []
+            ##One of each object:
+            # Rectangle
+            Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+            lw = random.randint(1,5)
+            cf = random.randint(0,len(colors)-1)
+            wh = ( random.randint(1,5), random.randint(1,5) )
+            self.Rectangle = Canvas.AddRectangle(Point, wh, LineWidth = lw, FillColor = colors[cf])
+            self.ColorObjectsAll.append(self.Rectangle)
+
+            # Ellipse
+            Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+            lw = random.randint(1,5)
+            cf = random.randint(0,len(colors)-1)
+            wh = ( random.randint(1,5), random.randint(1,5) )
+            self.Ellipse = Canvas.AddEllipse(Point, wh, LineWidth = lw, FillColor = colors[cf])
+            self.ColorObjectsAll.append(self.Ellipse)
+
+            # Point 
+            xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+            D = random.randint(1,50)
+            lw = random.randint(1,5)
+            cf = random.randint(0,len(colors)-1)
+            cl = random.randint(0,len(colors)-1)
+            self.ColorObjectsColor.append(Canvas.AddPoint(xy, colors[cf], D))
+
+            # Circle
+            Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+            D = random.randint(1,5)
+            lw = random.randint(1,5)
+            cf = random.randint(0,len(colors)-1)
+            cl = random.randint(0,len(colors)-1)
+            self.Circle = Canvas.AddCircle(Point, D, LineWidth = lw, LineColor = colors[cl], FillColor = colors[cf])
+            self.ColorObjectsAll.append(self.Circle)
+
+            # Line
+            points = []
+            for j in range(random.randint(2,10)):
+                point = (random.randint(Range[0],Range[1]),random.randint(Range[0],Range[1]))
+                points.append(point)
+            lw = random.randint(1,10)
+            cf = random.randint(0,len(colors)-1)
+            cl = random.randint(0,len(colors)-1)
+            self.ColorObjectsLine.append(Canvas.AddLine(points, LineWidth = lw, LineColor = colors[cl]))
+
+            # Polygon
+##            points = []
+##            for j in range(random.randint(2,6)):
+##                point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+##                points.append(point)
+            points = RandomArray.uniform(Range[0],Range[1],(6,2))
+            lw = random.randint(1,6)
+            cf = random.randint(0,len(colors)-1)
+            cl = random.randint(0,len(colors)-1)
+            self.ColorObjectsAll.append(Canvas.AddPolygon(points,
+                                                       LineWidth = lw, 
+                                                       LineColor = colors[cl],
+                                                       FillColor = colors[cf],
+                                                       FillStyle = 'Solid'))
+
+            ## Pointset
+            points = RandomArray.uniform(Range[0],Range[1],(100,2))
+            cf = random.randint(0,len(colors)-1)
+            D = random.randint(1,4)
+            self.PointSet = Canvas.AddPointSet(points, Color = colors[cf], Diameter = D)
+            self.ColorObjectsColor.append(self.PointSet)
+
+            ## Point
+            point = RandomArray.uniform(Range[0],Range[1],(2,))
+            cf = random.randint(0,len(colors)-1)
+            D = random.randint(1,4)
+            self.Point = Canvas.AddPoint(point, Color = colors[cf], Diameter = D)
+            self.ColorObjectsColor.append(self.Point)
+
+            # Text
+            String = "Unscaled text"
+            ts = random.randint(10,40)
+            cf = random.randint(0,len(colors)-1)
+            Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+            self.ColorObjectsText.append(Canvas.AddText(String, Point, Size = ts, Color = colors[cf], Position = "cc"))
+
+            # Scaled Text
+            String = "Scaled text"
+            ts = random.random()*3 + 0.2
+            cf = random.randint(0,len(colors)-1)
+            Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+            self.ColorObjectsText.append(Canvas.AddScaledText(String, Point, Size = ts, Color = colors[cf], Position = "cc"))
+
+            # A "Button"
+            Button = Canvas.AddRectangle((-10, -12), (20, 3), LineStyle = None, FillColor = "Red")
+            Canvas.AddScaledText("Click Here To Change Properties",
+                                 (0, -10.5),
+                                 Size = 0.7,
+                                 Color = "Black",
+                                 Position = "cc")
+
+            Button.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.ChangeProperties)
+
+            Canvas.ZoomToBB()
+
+        def ChangeProperties(self, Object = None):
+            colors = self.colors
+            Range = (-10,10)
+
+            for Object in self.ColorObjectsAll:
+                pass
+                Object.SetFillColor(colors[random.randint(0,len(colors)-1)])
+                Object.SetLineColor(colors[random.randint(0,len(colors)-1)])
+                Object.SetLineWidth(random.randint(1,7))
+                Object.SetLineStyle(FloatCanvas.DrawObject.LineStyleList.keys()[random.randint(0,5)])
+            for Object in self.ColorObjectsLine:
+                Object.SetLineColor(colors[random.randint(0,len(colors)-1)])
+                Object.SetLineWidth(random.randint(1,7))
+                Object.SetLineStyle(FloatCanvas.DrawObject.LineStyleList.keys()[random.randint(0,5)])
+            for Object in self.ColorObjectsColor:
+                Object.SetColor(colors[random.randint(0,len(colors)-1)])
+            for Object in self.ColorObjectsText:
+                Object.SetColor(colors[random.randint(0,len(colors)-1)])
+                Object.SetBackgroundColor(colors[random.randint(0,len(colors)-1)])
+            self.Circle.SetDiameter(random.randint(1,10))
+            self.PointSet.SetDiameter(random.randint(1,8))
+            self.Point.SetDiameter(random.randint(1,8))
+            for Object in (self.Rectangle, self.Ellipse):
+                Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+                wh = ( random.randint(1,5), random.randint(1,5) )
+                Object.SetShape(Point, wh)
+            self.Canvas.Draw(Force = True)
+
+        def ArrowTest(self,event=None):
+            wx.GetApp().Yield(True)
+            self.UnBindAllMouseEvents()
+            Canvas = self.Canvas
+
+            Canvas.InitAll()
+            Canvas.MinScale = 15
+            Canvas.MaxScale = 30
+            
+            # put in a rectangle to get a bounding box
+            Canvas.AddRectangle((0,0), (20,20), LineColor = None)
+
+            # Draw some Arrows
+            Canvas.AddArrow((10,10),Length = 40, Direction = 0)
+            Canvas.AddArrow((10,10),Length = 50, Direction = 45 ,LineWidth = 2, LineColor = "Black", ArrowHeadAngle = 20)
+            Canvas.AddArrow((10,10),Length = 60, Direction = 90 ,LineWidth = 3, LineColor = "Red",   ArrowHeadAngle = 30)
+            Canvas.AddArrow((10,10),Length = 70, Direction = 135,LineWidth = 4, LineColor = "Red",   ArrowHeadAngle = 40)
+            Canvas.AddArrow((10,10),Length = 80, Direction = 180,LineWidth = 5, LineColor = "Blue",  ArrowHeadAngle = 50)
+            Canvas.AddArrow((10,10),Length = 90, Direction = 225,LineWidth = 4, LineColor = "Blue",  ArrowHeadAngle = 60)
+            Canvas.AddArrow((10,10),Length = 100,Direction = 270,LineWidth = 3, LineColor = "Green", ArrowHeadAngle = 70)
+            Canvas.AddArrow((10,10),Length = 110,Direction = 315,LineWidth = 2, LineColor = "Green", ArrowHeadAngle = 90 )
+
+            Canvas.AddText("Clickable Arrow", (4,18), Position = "bc")
+            Arrow = Canvas.AddArrow((4,18), 80, Direction = 90 ,LineWidth = 3, LineColor = "Red",   ArrowHeadAngle = 30)
+            Arrow.HitLineWidth = 6
+            Arrow.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.ArrowClicked)
+
+            Canvas.AddText("Changable Arrow: try clicking it", (16,4), Position = "tc")
+            self.RotArrow = Canvas.AddArrow((16,4), 80, Direction = 0 ,LineWidth = 3, LineColor = "Green",   ArrowHeadAngle = 30)
+            self.RotArrow.HitLineWidth = 6
+            self.RotArrow.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RotateArrow)
+
+            Canvas.ZoomToBB()
+
+        def ArrowClicked(self,event):
+            self.Log("The Arrow was Clicked")
+
+        def RotateArrow(self,event):
+            ##print "The Changeable Arrow was Clicked"
+            ## You can do them either one at a time, or both at once
+            ## Doing them both at once prevents the arrow points from being calculated twice
+            #self.RotArrow.SetDirection(self.RotArrow.Direction + random.uniform(-90,90))
+            #self.RotArrow.SetLength(self.RotArrow.Length + random.randint(-20,20))
+            self.RotArrow.SetLengthDirection(self.RotArrow.Length + random.randint(-20,20),
+                                             self.RotArrow.Direction + random.uniform(-90,90) )
+
+            self.Canvas.Draw(Force = True)
+
+        def HideTest(self, event=None):
+            wx.GetApp().Yield(True)
+
+            self.UnBindAllMouseEvents()
+            Canvas = self.Canvas
+            Canvas.InitAll()
              
              
+            Range = (-10,10)
+
+            # Create a couple random Polygons
+            points = []
+            for j in range(6):
+                point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+                points.append(point)
+            Poly = Canvas.AddPolygon(points,
+                                     LineWidth = 2,
+                                     LineColor = "Black",
+                                     FillColor = "LightBlue",
+                                     FillStyle = 'Solid')
  
  
-##            # Scaled Text
-##            String = "Scaled text"
-##            for i in range(30):
-##                ts = random.random()*3 + 0.2
-##                cf = random.randint(0,len(colors)-1)
-##                x,y = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
-##                Canvas.AddScaledText(String, x, y, Size = ts, Color = colors[cf], Position = "cc")
+            points = []
+            for j in range(6):
+                point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+                points.append(point)
+            Poly2 = Canvas.AddPolygon(points,
+                                     LineWidth = 2,
+                                     LineColor = "Black",
+                                     FillColor = "Purple",
+                                     FillStyle = 'Solid',
+                                     InForeground = True)
+
+            HideButton = Canvas.AddScaledTextBox("Click To Hide\nBackground Polygon",
+                                                      (-10, 0),
+                                                      .5,
+                                                      BackgroundColor="Red",
+                                                      PadSize = 0.5,
+                                                      Position = 'tr',
+                                                      Alignment="center",
+                                                      )
+            HideButton.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.HidePoly)
+            HideButton.HidePoly = Poly
+            
+            HideButton2 = Canvas.AddScaledTextBox("Click To Hide\nForeground Polygon",
+                                                      (-10, 5),
+                                                      .5,
+                                                      BackgroundColor="Red",
+                                                      PadSize = 0.5,
+                                                      Position = 'tr',
+                                                      Alignment="center",
+                                                      )
+            # Put a reference to the Polygon in the Button object
+            HideButton2.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.HidePoly)
+            HideButton2.HidePoly = Poly2
+            
  
              Canvas.ZoomToBB()
  
  
              Canvas.ZoomToBB()
  
+        def HidePoly(self, Button):
+            Poly = Button.HidePoly
+
+            if Poly.Visible:
+                Poly.Visible = False
+                Button.SetText(Button.String.replace("Hide","Show"))
+            else:
+                Poly.Visible = True
+                Button.SetText(Button.String.replace("Show", "Hide"))
+            self.Canvas.Draw(True)
+
  
          def TempTest(self, event= None):
  
          def TempTest(self, event= None):
-            "Running the Temporary test"
+            """
+            
+            This is the start of a poly editor test, but it's not complete
+            so you can only run it through a command line flag:
+            
+            python FloatCanvasDemo.py --temp
+            
+            """
+            
              wx.GetApp().Yield(True)
  
              self.UnBindAllMouseEvents()
              Canvas = self.Canvas
              wx.GetApp().Yield(True)
  
              self.UnBindAllMouseEvents()
              Canvas = self.Canvas
-            Canvas.ClearAll()
-            Canvas.SetProjectionFun(None)
-
-#            import random
-#            import RandomArray
+            Canvas.InitAll()
+            
              Range = (-10,10)
  
              # Create a random Polygon
              Range = (-10,10)
  
              # Create a random Polygon
@@ -1134,11 +1684,10 @@ else:
              self.SelectedPoly = None
              self.SelectPoints = []
              self.SelectedPoint = None
              self.SelectedPoly = None
              self.SelectPoints = []
              self.SelectedPoint = None
-            
+
              Canvas.ZoomToBB()
  
          def SelectPoly(self, Object):
              Canvas.ZoomToBB()
  
          def SelectPoly(self, Object):
-            print "In SelectPoly"
              Canvas = self.Canvas
              if Object is self.SelectedPoly:
                  pass
              Canvas = self.Canvas
              if Object is self.SelectedPoly:
                  pass
@@ -1157,76 +1706,164 @@ else:
              Canvas.Draw()
  
          def SelectPointHit(self, Point):
              Canvas.Draw()
  
          def SelectPointHit(self, Point):
-            print "Point Num: %i Hit"%Point.VerticeNum
+            self.Log("Point Num: %i Hit"%Point.VerticeNum)
              self.SelectedPoint = Point
  
              self.SelectedPoint = Point
  
-            
+        def Read_MapGen(self, filename, stats = 0,AllLines=0):
+            """
+            This function reads a MapGen Format file, and
+            returns a list of NumPy arrays with the line segments in them.
+
+            Each NumPy array in the list is an NX2 array of Python Floats.
+
+            The demo should have come with a file, "world.dat" that is the
+            shorelines of the whole world, in MapGen format.
+
+            """
+            import string
+            file = open(filename,'rt')
+            data = file.readlines()
+            data = map(string.strip,data)
+
+            Shorelines = []
+            segment = []
+            for line in data:
+                if line:
+                    if line == "# -b": #New segment beginning
+                        if segment: Shorelines.append(N.array(segment))
+                        segment = []
+                    else:
+                        segment.append(map(float,string.split(line)))
+            if segment: Shorelines.append(N.array(segment))
+
+            if stats:
+                NumSegments = len(Shorelines)
+                NumPoints = 0
+                for segment in Shorelines:
+                    NumPoints = NumPoints + len(segment)
+                AvgPoints = NumPoints / NumSegments
+                print "Number of Segments: ", NumSegments
+                print "Average Number of Points per segment: ",AvgPoints
+            if AllLines:
+                Lines = []
+                for segment in Shorelines:
+                    Lines.append(segment[0])
+                    for point in segment[1:-1]:
+                        Lines.append(point)
+                        Lines.append(point)
+                    Lines.append(segment[-1])
+                return Lines
+            else:
+                return Shorelines
+    return DrawFrame 
+
+#---------------------------------------------------------------------------
+      
+if __name__ == "__main__":
+
+    # running stand alone, Use wxversion:
+#    import wxversion
+#    wxversion.select("2.6")
+#    wxversion.select("2.8")
+    import wx
     
     
+    
+    # check options:
+    import sys, getopt
+    optlist, args = getopt.getopt(sys.argv[1:],'l',["all",
+                                                    "text",
+                                                    "map",
+                                                    "stext",
+                                                    "stextbox",
+                                                    "bitmap",
+                                                    "hit",
+                                                    "hitf",
+                                                    "animate",
+                                                    "speed",
+                                                    "temp",
+                                                    "props",
+                                                    "arrow",
+                                                    "arrowline",
+                                                    "hide"])
+
+    if not haveNumpy:
+        raise ImportError(errorText)
+    StartUpDemo = "all" # the default
+    if optlist:
+        StartUpDemo = optlist[0][0][2:]
+
+
      class DemoApp(wx.App):
          """
          How the demo works:
      class DemoApp(wx.App):
          """
          How the demo works:
-        
+
          Under the Draw menu, there are three options:
          Under the Draw menu, there are three options:
-        
+
          *Draw Test: will put up a picture of a bunch of randomly generated
          objects, of each kind supported.
          *Draw Test: will put up a picture of a bunch of randomly generated
          objects, of each kind supported.
-        
+
          *Draw Map: will draw a map of the world. Be patient, it is a big map,
          with a lot of data, and will take a while to load and draw (about 10 sec 
          on my 450Mhz PIII). Redraws take about 2 sec. This demonstrates how the
          performance is not very good for large drawings.
          *Draw Map: will draw a map of the world. Be patient, it is a big map,
          with a lot of data, and will take a while to load and draw (about 10 sec 
          on my 450Mhz PIII). Redraws take about 2 sec. This demonstrates how the
          performance is not very good for large drawings.
-        
+
          *Clear: Clears the Canvas.
          *Clear: Clears the Canvas.
-        
+
          Once you have a picture drawn, you can zoom in and out and move about
          the picture. There is a tool bar with three tools that can be
          selected. 
          Once you have a picture drawn, you can zoom in and out and move about
          the picture. There is a tool bar with three tools that can be
          selected. 
-        
+
          The magnifying glass with the plus is the zoom in tool. Once selected,
          if you click the image, it will zoom in, centered on where you
          clicked. If you click and drag the mouse, you will get a rubber band
          box, and the image will zoom to fit that box when you release it.
          The magnifying glass with the plus is the zoom in tool. Once selected,
          if you click the image, it will zoom in, centered on where you
          clicked. If you click and drag the mouse, you will get a rubber band
          box, and the image will zoom to fit that box when you release it.
-        
+
          The magnifying glass with the minus is the zoom out tool. Once selected,
          if you click the image, it will zoom out, centered on where you
          clicked. (note that this takes a while when you are looking at the map,
          as it has a LOT of lines to be drawn. The image is double buffered, so
          you don't see the drawing in progress)
          The magnifying glass with the minus is the zoom out tool. Once selected,
          if you click the image, it will zoom out, centered on where you
          clicked. (note that this takes a while when you are looking at the map,
          as it has a LOT of lines to be drawn. The image is double buffered, so
          you don't see the drawing in progress)
-        
+
          The hand is the move tool. Once selected, if you click and drag on the
          image, it will move so that the part you clicked on ends up where you
          release the mouse. Nothing is changed while you are dragging. The
          drawing is too slow for that.
          The hand is the move tool. Once selected, if you click and drag on the
          image, it will move so that the part you clicked on ends up where you
          release the mouse. Nothing is changed while you are dragging. The
          drawing is too slow for that.
-        
+
          I'd like the cursor to change as you change tools, but the stock
          wxCursors didn't include anything I liked, so I stuck with the
          pointer. Please let me know if you have any nice cursor images for me to
          use.
          I'd like the cursor to change as you change tools, but the stock
          wxCursors didn't include anything I liked, so I stuck with the
          pointer. Please let me know if you have any nice cursor images for me to
          use.
-        
-        
+
+
          Any bugs, comments, feedback, questions, and especially code are welcome:
          Any bugs, comments, feedback, questions, and especially code are welcome:
-        
+
          -Chris Barker
          -Chris Barker
-        
+
          Chris.Barker@noaa.gov
          Chris.Barker@noaa.gov
-    
+
          """
  
          def __init__(self, *args, **kwargs):
              wx.App.__init__(self, *args, **kwargs)
          """
  
          def __init__(self, *args, **kwargs):
              wx.App.__init__(self, *args, **kwargs)
-        
+
          def OnInit(self):
              wx.InitAllImageHandlers()
          def OnInit(self):
              wx.InitAllImageHandlers()
+            DrawFrame = BuildDrawFrame()
              frame = DrawFrame(None, -1, "FloatCanvas Demo App",wx.DefaultPosition,(700,700))
              frame = DrawFrame(None, -1, "FloatCanvas Demo App",wx.DefaultPosition,(700,700))
-    
+
              self.SetTopWindow(frame)
              frame.Show()
  
              ## check to see if the demo is set to start in a particular mode.
              self.SetTopWindow(frame)
              frame.Show()
  
              ## check to see if the demo is set to start in a particular mode.
+            ## fixme: should this be in a dict instead?
              if StartUpDemo == "text":
                  frame.TestText()
              if StartUpDemo == "text":
                  frame.TestText()
-            if StartUpDemo == "stext":
+            elif StartUpDemo == "stext":
                  frame.TestScaledText()
                  frame.TestScaledText()
+            elif StartUpDemo == "stextbox":
+                frame.TestScaledTextBox()
+            elif StartUpDemo == "bitmap":
+                frame.TestBitmap()
              elif StartUpDemo == "all":
                  frame.DrawTest()
              elif StartUpDemo == "map":
              elif StartUpDemo == "all":
                  frame.DrawTest()
              elif StartUpDemo == "map":
@@ -1234,95 +1871,86 @@ else:
              elif StartUpDemo == "hit":
                  frame.TestHitTest()
              elif StartUpDemo == "hitf":
              elif StartUpDemo == "hit":
                  frame.TestHitTest()
              elif StartUpDemo == "hitf":
-                "starting TestHitTestForeground"
                  frame.TestHitTestForeground()
              elif StartUpDemo == "animate":
                  frame.TestHitTestForeground()
              elif StartUpDemo == "animate":
-                "starting TestAnimation"
                  frame.TestAnimation()
              elif StartUpDemo == "speed":
                  frame.TestAnimation()
              elif StartUpDemo == "speed":
-                "starting SpeedTest"
                  frame.SpeedTest()
              elif StartUpDemo == "temp":
                  frame.SpeedTest()
              elif StartUpDemo == "temp":
-                "starting temp Test"
                  frame.TempTest()
                  frame.TempTest()
-                
-            return True
-                
-    def Read_MapGen(filename,stats = 0,AllLines=0):
-        """
-        This function reads a MapGen Format file, and
-        returns a list of NumPy arrays with the line segments in them.
-        
-        Each NumPy array in the list is an NX2 array of Python Floats.
-        
-        The demo should have come with a file, "world.dat" that is the
-        shorelines of the whole world, in MapGen format.
-        
-        """
-        import string
-        file = open(filename,'rt')
-        data = file.readlines()
-        data = map(string.strip,data)
-        
-        Shorelines = []
-        segment = []
-        for line in data:
-            if line:
-                if line == "# -b": #New segment beginning
-                    if segment: Shorelines.append(Numeric.array(segment))
-                    segment = []
-                else:
-                    segment.append(map(float,string.split(line)))
-        if segment: Shorelines.append(Numeric.array(segment))
-        
-        if stats:
-            NumSegments = len(Shorelines)
-            NumPoints = 0
-            for segment in Shorelines:
-                NumPoints = NumPoints + len(segment)
-            AvgPoints = NumPoints / NumSegments
-            print "Number of Segments: ", NumSegments
-            print "Average Number of Points per segment: ",AvgPoints
-        if AllLines:
-            Lines = []
-            for segment in Shorelines:
-                Lines.append(segment[0])
-                for point in segment[1:-1]:
-                    Lines.append(point)
-                    Lines.append(point)
-                Lines.append(segment[-1])
-            return Lines
-        else:
-            return Shorelines
-    
-    ## for the wxPython demo:
-    try:
-        import floatcanvas
-    except ImportError: # if it's not there locally, try the wxPython lib.
-        from wx.lib import floatcanvas
-
-    overview = floatcanvas.__doc__
-      
-if __name__ == "__main__":
-    if not haveNumeric:
-        print errorText
-    else:
-        app = DemoApp(False)# put in True if you want output to go to it's own window.
-        app.MainLoop()
-    
-    
-    
-    
-
-
-
-
+            elif StartUpDemo == "props":
+                frame.PropertiesChangeTest()
+            elif StartUpDemo == "arrow":
+                frame.ArrowTest()
+            elif StartUpDemo == "arrowline":
+                frame.ArrowLineTest()
+            elif StartUpDemo == "hide":
+                frame.HideTest()
  
  
+            return True
  
  
+    app = DemoApp(False)# put in True if you want output to go to it's own window.
+    app.MainLoop()
  
  
+else:
+    # It's not running stand-alone, set up for wxPython demo.
+    # don't  neeed wxversion here.
+    import wx
+    if not haveNumpy:
+        ## TestPanel and runTest used for integration into wxPython Demo
+        class TestPanel(wx.Panel):
+            def __init__(self, parent, log):
+                self.log = log
+                wx.Panel.__init__(self, parent, -1)
+
+                from wx.lib.floatcanvas.ScreenShot import getScreenShotBitmap
+
+                note1 = wx.StaticText(self, -1, errorText)
+                note2 = wx.StaticText(self, -1, "This is what the FloatCanvas can look like:")
+                S = wx.BoxSizer(wx.VERTICAL)
+                S.Add((10, 10), 1)
+                S.Add(note1, 0, wx.ALIGN_CENTER)
+                S.Add(note2, 0, wx.ALIGN_CENTER | wx.BOTTOM, 4)
+                S.Add(wx.StaticBitmap(self,-1,getScreenShotBitmap()),0,wx.ALIGN_CENTER)
+                S.Add((10, 10), 1)
+                self.SetSizer(S)
+                self.Layout()
  
  
+    else:
+        ## TestPanel and runTest used for integration into wxPython Demo
+        class TestPanel(wx.Panel):
+            def __init__(self, parent, log):
+                self.log = log
+                wx.Panel.__init__(self, parent, -1)
+                note1 = wx.StaticText(self, -1, "The FloatCanvas Demo needs")
+                note2 = wx.StaticText(self, -1, "a separate frame")
+                b = wx.Button(self, -1, "Open Demo Frame Now")
+                b.Bind(wx.EVT_BUTTON, self.OnButton)
+
+                S = wx.BoxSizer(wx.VERTICAL)
+                S.Add((10, 10), 1)
+                S.Add(note1, 0, wx.ALIGN_CENTER)
+                S.Add(note2, 0, wx.ALIGN_CENTER | wx.BOTTOM, 5)
+                S.Add(b, 0, wx.ALIGN_CENTER | wx.ALL, 5)
+                S.Add((10, 10), 1)
+                self.SetSizer(S)
+                self.Layout()
+
+            def OnButton(self, evt):
+                DrawFrame = BuildDrawFrame()
+                frame = DrawFrame(None, -1, "FloatCanvas Drawing Window",wx.DefaultPosition,(500,500))
+
+                #win = wx.lib.plot.TestFrame(self, -1, "PlotCanvas Demo")
+                frame.Show()
+                frame.DrawTest()
  
  
+    def runTest(frame, nb, log):
+        win = TestPanel(nb, log)
+        return win
  
  
+    # import to get the doc
+    from wx.lib import floatcanvas
+    overview = floatcanvas.__doc__