gtk_widget_destroy does not unref the widget unless it's a TLW or in a

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

index 7f1d2d0d002a4a99cf0a71d236f33f9d7d2318f8..0b1c54cfd63aa96c33ea5dd63fc4c0c86428d7fc 100644 (file)
--- a/wxPython/demo/FloatCanvas.py
+++ b/wxPython/demo/FloatCanvas.py
@@ -1,37 +1,27 @@
-#!/usr/bin/env python2.3
+#!/usr/bin/env python
  
  
-import wx
-
-##First, make sure Numeric or numarray can be imported.
  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:
-    # Numeric isn't there, let's try numarray
-    try:
-        import numarray as Numeric
-        import numarray.random_array as RandomArray
-        haveNumeric = True
-    except ImportError:
-        # numarray isn't there either
-        haveNumeric = False
-        errorText = (
-        "The FloatCanvas requires either the Numeric or numarray module\n\n"
-        "You can get them at:\n"
-        "http://sourceforge.net/projects/numpy\n\n"
-        "NOTE: The Numeric module is substantially faster than numarray for this\n"
-        "purpose, if you have lots of objects\n"
-        )
+            # 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"
+            )
        
  #---------------------------------------------------------------------------
  
        
  #---------------------------------------------------------------------------
  
+
  def BuildDrawFrame(): # this gets called when needed, rather than on import
      try:
  def BuildDrawFrame(): # this gets called when needed, rather than on import
      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 wx.lib.colourdb
      import time, random
  
@@ -52,10 +42,16 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
              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")
  
              draw_menu = wx.Menu()
  
              MenuBar.Append(file_menu, "&File")
  
              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, "&Draw Test","Run a test of drawing random components")
              self.Bind(wx.EVT_MENU, self.DrawTest, item)
  
@@ -64,25 +60,43 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
  
              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")
              self.Bind(wx.EVT_MENU, self.TestHitTestForeground, item)
              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)
+
              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, "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, "&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")
  
              view_menu = wx.Menu()
              MenuBar.Append(draw_menu, "&Tests")
  
              view_menu = wx.Menu()
@@ -98,124 +112,141 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
  
              self.SetMenuBar(MenuBar)
  
  
              self.SetMenuBar(MenuBar)
  
-            self.CreateStatusBar()            
-            # Add the Canvas
-            self.Canvas = NavCanvas.NavCanvas(self,
-                                              -1,
-                                              (500,500),
-                                              Debug = 0,
-                                              BackgroundColor = "DARK SLATE BLUE")
+            self.CreateStatusBar()
  
  
-            wx.EVT_CLOSE(self, self.OnCloseWindow)
-
-            FloatCanvas.EVT_MOTION(self.Canvas, self.OnMove ) 
-            #FloatCanvas.EVT_LEFT_UP(self.Canvas, self.OnLeftUp ) 
+            
+            # Add the Canvas
+            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)
+
+            self.SetSizer(MainSizer)
+            self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
+
+            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
+            ## getting all the colors for random objects
              wx.lib.colourdb.updateColourDB()
              self.colors = wx.lib.colourdb.getColourList()
              wx.lib.colourdb.updateColourDB()
              self.colors = wx.lib.colourdb.getColourList()
-            #self.LineStyles = FloatCanvas.DrawObject.LineStyleList.keys()
  
  
              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 unbind FloatCanvas mouse events
          def UnBindAllMouseEvents(self):
              ## Here is how you unbind FloatCanvas mouse events
-            FloatCanvas.EVT_LEFT_DOWN(self.Canvas, None ) 
-            FloatCanvas.EVT_LEFT_UP(self.Canvas, None )
-            FloatCanvas.EVT_LEFT_DCLICK(self.Canvas, None) 
+            self.Canvas.Unbind(FloatCanvas.EVT_LEFT_DOWN)
+            self.Canvas.Unbind(FloatCanvas.EVT_LEFT_UP)
+            self.Canvas.Unbind(FloatCanvas.EVT_LEFT_DCLICK)
  
  
-            FloatCanvas.EVT_MIDDLE_DOWN(self.Canvas, None )
-            FloatCanvas.EVT_MIDDLE_UP(self.Canvas, None )
-            FloatCanvas.EVT_MIDDLE_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_RIGHT_DOWN(self.Canvas, None )
-            FloatCanvas.EVT_RIGHT_UP(self.Canvas, None )
-            FloatCanvas.EVT_RIGHT_DCLICK(self.Canvas, None )
-
-            FloatCanvas.EVT_MOUSEWHEEL(self.Canvas, None )
-            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 )
-
-            FloatCanvas.EVT_RIGHT_DOWN(self.Canvas, None )
-            FloatCanvas.EVT_RIGHT_UP(self.Canvas, None )
-            FloatCanvas.EVT_RIGHT_DCLICK(self.Canvas, None )
-
-            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)
              Rot = event.GetWheelRotation()
              self.PrintCoords(event)
              Rot = event.GetWheelRotation()
-            print "Wheel Rotation is:", Rot
-            print "Wheel Delta is:", event.GetWheelDelta()
              Rot = Rot / abs(Rot) * 0.1
              if event.ControlDown(): # move left-right
                  self.Canvas.MoveImage( (Rot, 0), "Panel" )
              Rot = Rot / abs(Rot) * 0.1
              if event.ControlDown(): # move left-right
                  self.Canvas.MoveImage( (Rot, 0), "Panel" )
@@ -227,13 +258,14 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
              Updates the status bar with the world coordinates
              """
              self.SetStatusText("%.2f, %.2f"%tuple(event.Coords))
              Updates the status bar with the world coordinates
              """
              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()
  
@@ -242,8 +274,7 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
  
          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()
  
          def OnQuit(self,event):
              self.Canvas.Draw()
  
          def OnQuit(self,event):
@@ -253,7 +284,12 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
              self.Destroy()
  
          def DrawTest(self,event=None):
              self.Destroy()
  
          def DrawTest(self,event=None):
-            wx.GetApp().Yield()
+            """
+            This demo draws a few of everything
+
+            """
+            
+            wx.GetApp().Yield(True)
  
              Range = (-10,10)
              colors = self.colors
  
              Range = (-10,10)
              colors = self.colors
@@ -261,44 +297,55 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
              self.BindAllMouseEvents()
              Canvas = self.Canvas
  
              self.BindAllMouseEvents()
              Canvas = self.Canvas
  
-            Canvas.ClearAll()
-            Canvas.SetProjectionFun(None)
+            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:
+            ############# 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,w,h,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])
+                Canvas.AddEllipse(xy, (h,w), LineWidth = lw,FillColor = colors[cf])
  
              # Points
              for i in range(5):
  
              # Points
              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)
                  D = random.randint(1,50)
                  cf = random.randint(0,len(colors)-1)
-                Canvas.AddPoint((x,y), Color = colors[cf], Diameter = D)
+                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):
              # 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 = []
@@ -337,16 +384,16 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
              for i in range(3):
                  ts = random.randint(10,40)
                  cf = random.randint(0,len(colors)-1)
              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
  
              # Arrows
              N = 5
@@ -359,6 +406,18 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
                                  LineColor = colors[random.randint(0,len(colors)-1)],
                                  ArrowHeadAngle = random.uniform(20,90))
  
                                  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()
  
          def TestAnimation(self,event=None):
              Canvas.ZoomToBB()
  
          def TestAnimation(self,event=None):
@@ -371,45 +430,41 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
              having to re-draw the whole background.
  
              """
              having to re-draw the whole background.
  
              """
-            wx.GetApp().Yield()
+            wx.GetApp().Yield(True)
              Range = (-10,10)
              self.Range = Range
  
              self.UnBindAllMouseEvents()
              Canvas = self.Canvas
              Range = (-10,10)
              self.Range = Range
  
              self.UnBindAllMouseEvents()
              Canvas = self.Canvas
+            Canvas.InitAll()
  
  
-            Canvas.ClearAll()
-            Canvas.SetProjectionFun(None)
-
-            ##          Random tests of everything:
+            ##         Random tests of everything:
              colors = self.colors
              # Rectangles
              for i in range(3):
              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):
  
              # Lines
              for i in range(5):
@@ -442,13 +497,13 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
              for i in range(3):
                  ts = random.random()*3 + 0.2
                  cf = random.randint(0,len(colors)-1)
              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.6, 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
  
              C.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.MoveMe)
              C.Text = T
  
@@ -487,225 +542,234 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
              self.Timer.Start(self.FrameDelay)
              #print "Did %i frames in %f seconds"%(N, (time.time() - start) )
  
              self.Timer.Start(self.FrameDelay)
              #print "Did %i frames in %f seconds"%(N, (time.time() - start) )
  
-        def TestHitTest(self,event=None):
-            wx.GetApp().Yield()
+        def TestHitTest(self, event=None):
+            wx.GetApp().Yield(True)
  
              self.UnBindAllMouseEvents()
              Canvas = self.Canvas
  
  
              self.UnBindAllMouseEvents()
              Canvas = self.Canvas
  
-            Canvas.ClearAll()
-            Canvas.SetProjectionFun(None)
+            Canvas.InitAll()
  
              #Add a Hit-able rectangle
              w, h = 60, 20
  
              dx = 80
              dy = 40
  
              #Add a Hit-able rectangle
              w, h = 60, 20
  
              dx = 80
              dy = 40
-            x,y = 20, 20
-            FontSize = 8
+            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, Size = FontSize, 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.HitLineWidth = 5 # Makes it a little easier to hit
              R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHit)
              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)
-            Canvas.AddText("Left Click Line", x, y, Size = FontSize, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Size = FontSize, 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, Size = FontSize, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Size = FontSize, 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, Size = FontSize, 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, Size = FontSize, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Size = FontSize, 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, Size = FontSize, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Size = FontSize, 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, Size = FontSize, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Size = FontSize, 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, Size = FontSize, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Size = FontSize, 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, Size = FontSize, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Size = FontSize, 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, Size = FontSize, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Size = FontSize, 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, Size = FontSize, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Size = FontSize, 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, Size = FontSize, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Size = FontSize, 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, Size = FontSize, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Size = FontSize, 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, Size = FontSize, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Size = FontSize, 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, Size = FontSize, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Size = FontSize, 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, Size = FontSize, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Size = FontSize, 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, Size = FontSize, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Size = FontSize, 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, Size = FontSize, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Size = FontSize, 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, Size = FontSize, Position = "bl")
-            Canvas.AddText(L.Name, x, y+h, Size = FontSize, 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, Size = FontSize, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Size = FontSize, 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, Size = FontSize, Position = "bl")
-            Canvas.AddText(R.Name, x, y+h, Size = FontSize, 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, Size = FontSize, 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, Size = FontSize, 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):
-            wx.GetApp().Yield()
+            wx.GetApp().Yield(True)
  
              self.UnBindAllMouseEvents()
              Canvas = self.Canvas
  
  
              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
@@ -715,12 +779,12 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
              x,y = 20, 20
  
              color = "Red"
              x,y = 20, 20
  
              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
  
@@ -728,35 +792,36 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
              ## custom FloatCanvas DrawObject
  
              self.MovingRects = []
              ## custom FloatCanvas DrawObject
  
              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()
              self.MovingRects.extend( (R,L) )
  
              self.Canvas.ZoomToBB()
@@ -780,145 +845,462 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
                  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):
-            wx.GetApp().Yield()
+            wx.GetApp().Yield(True)
  
              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"
-            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)
+            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, 2)
+            Point  = (3, 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")
+            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")
  
  
-            x,y  = (0, 4)
+            Point  = (3, 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")
+            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")
  
  
-            x,y  = (0, -2)
+            Point  = (3, -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("Center Center",
+                                Point, Size = DefaultSize,
+                                Color = "Black",
+                                Position = "cc")
  
  
-            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("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)
+            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()
  
          def TestScaledText(self, event= None):
  
              self.Canvas.ZoomToBB()
  
          def TestScaledText(self, event= None):
-            wx.GetApp().Yield()
+            wx.GetApp().Yield(True)
  
              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)
+            Point  = (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)
+            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)
  
  
-            x,y  = (0, -20)
+            Point  = (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("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',
+                                          )
+
+
+
+
+            self.Canvas.ZoomToBB()
+
+        def binding2(self, event):
+            self.Log("I'm the TextBox")
+
+        def TestBitmap(self, event= None):
+            wx.GetApp().Yield(True)
  
  
-            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.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):
  
              self.Canvas.ZoomToBB()
  
          def DrawMap(self,event = None):
-            wx.GetApp().Yield()
+            wx.GetApp().Yield(True)
              import os, time
              import os, time
+            
+            self.Canvas.InitAll()
+            self.Canvas.SetProjectionFun("FlatEarth")
              self.BindAllMouseEvents()
  
          ## Test of Actual Map Data
              self.BindAllMouseEvents()
  
          ## Test of Actual Map Data
-            self.Canvas.ClearAll()
-            self.Canvas.SetProjectionFun("FlatEarth")
              #start = time.clock()
              #start = time.clock()
+            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()
              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()
@@ -930,17 +1312,17 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
              #print "It took %f seconds to draw %i shorelines"%(time.clock() - start,len(Shorelines) )
  
  
              #print "It took %f seconds to draw %i shorelines"%(time.clock() - start,len(Shorelines) )
  
  
+
          def LineTest(self,event = None):
          def LineTest(self,event = None):
-            wx.GetApp().Yield()
+            wx.GetApp().Yield(True)
              import os, time
  #            import random
              colors = self.colors
              Range = (-10,10)
          ## Test of drawing lots of lines
              Canvas = self.Canvas
              import os, time
  #            import random
              colors = self.colors
              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 = []
@@ -959,22 +1341,49 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
              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):
          def SpeedTest(self,event=None):
-            wx.GetApp().Yield()
+            wx.GetApp().Yield(True)
              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)
-
+            Canvas.InitAll()
+            
              # Pointset
              coords = []
              for i in range(1000):
              # Pointset
              coords = []
              for i in range(1000):
-                x,y = (random.uniform(BigRange[0],BigRange[1]),random.uniform(BigRange[0],BigRange[1]))
-                coords.append( (x,y) )
+                Point = (random.uniform(BigRange[0],BigRange[1]),random.uniform(BigRange[0],BigRange[1]))
+                coords.append( (Point) )
              print "Drawing the Points"
              start = time.clock()
              for Point in coords:
              print "Drawing the Points"
              start = time.clock()
              for Point in coords:
@@ -983,7 +1392,7 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
              Canvas.ZoomToBB()
  
          def PropertiesChangeTest(self,event=None):
              Canvas.ZoomToBB()
  
          def PropertiesChangeTest(self,event=None):
-            wx.GetApp().Yield()
+            wx.GetApp().Yield(True)
  
              Range = (-10,10)
              colors = self.colors
  
              Range = (-10,10)
              colors = self.colors
@@ -991,30 +1400,27 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
              self.UnBindAllMouseEvents()
              Canvas = self.Canvas
  
              self.UnBindAllMouseEvents()
              Canvas = self.Canvas
  
-            Canvas.ClearAll()
-            Canvas.SetProjectionFun(None)
-
+            Canvas.InitAll()
+            
              self.ColorObjectsAll = []
              self.ColorObjectsLine = []
              self.ColorObjectsColor = []
              self.ColorObjectsText = []
              ##One of each object:
              # Rectangle
              self.ColorObjectsAll = []
              self.ColorObjectsLine = []
              self.ColorObjectsColor = []
              self.ColorObjectsText = []
              ##One of each object:
              # Rectangle
-            x,y = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+            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)
              lw = random.randint(1,5)
              cf = random.randint(0,len(colors)-1)
-            h = random.randint(1,5)
-            w = random.randint(1,5)
-            self.Rectangle = Canvas.AddRectangle(x,y,w,h,LineWidth = lw,FillColor = colors[cf])
+            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
              self.ColorObjectsAll.append(self.Rectangle)
  
              # Ellipse
-            x,y = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+            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)
              lw = random.randint(1,5)
              cf = random.randint(0,len(colors)-1)
-            h = random.randint(1,5)
-            w = random.randint(1,5)
-            self.Ellipse = Canvas.AddEllipse(x,y,h,w,LineWidth = lw,FillColor = colors[cf])
+            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 
              self.ColorObjectsAll.append(self.Ellipse)
  
              # Point 
@@ -1026,12 +1432,12 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
              self.ColorObjectsColor.append(Canvas.AddPoint(xy, colors[cf], D))
  
              # Circle
              self.ColorObjectsColor.append(Canvas.AddPoint(xy, colors[cf], D))
  
              # Circle
-            x,y = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+            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)
              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(x,y,D,LineWidth = lw,LineColor = colors[cl],FillColor = colors[cf])
+            self.Circle = Canvas.AddCircle(Point, D, LineWidth = lw, LineColor = colors[cl], FillColor = colors[cf])
              self.ColorObjectsAll.append(self.Circle)
  
              # Line
              self.ColorObjectsAll.append(self.Circle)
  
              # Line
@@ -1077,20 +1483,20 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
              String = "Unscaled text"
              ts = random.randint(10,40)
              cf = random.randint(0,len(colors)-1)
              String = "Unscaled text"
              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.ColorObjectsText.append(Canvas.AddText(String, x, y, Size = ts, Color = colors[cf], Position = "cc"))
+            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)
  
              # Scaled Text
              String = "Scaled text"
              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]))
-            self.ColorObjectsText.append(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]))
+            self.ColorObjectsText.append(Canvas.AddScaledText(String, Point, Size = ts, Color = colors[cf], Position = "cc"))
  
              # A "Button"
  
              # A "Button"
-            Button = Canvas.AddRectangle(-10, -12, 20, 3, LineStyle = None, FillColor = "Red")
+            Button = Canvas.AddRectangle((-10, -12), (20, 3), LineStyle = None, FillColor = "Red")
              Canvas.AddScaledText("Click Here To Change Properties",
              Canvas.AddScaledText("Click Here To Change Properties",
-                                 0, -10.5,
+                                 (0, -10.5),
                                   Size = 0.7,
                                   Color = "Black",
                                   Position = "cc")
                                   Size = 0.7,
                                   Color = "Black",
                                   Position = "cc")
@@ -1122,21 +1528,22 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
              self.PointSet.SetDiameter(random.randint(1,8))
              self.Point.SetDiameter(random.randint(1,8))
              for Object in (self.Rectangle, self.Ellipse):
              self.PointSet.SetDiameter(random.randint(1,8))
              self.Point.SetDiameter(random.randint(1,8))
              for Object in (self.Rectangle, self.Ellipse):
-                x,y = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
-                w,h = random.randint(1,5), random.randint(1,5)
-                Object.SetShape(x,y,w,h)
+                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):
              self.Canvas.Draw(Force = True)
  
          def ArrowTest(self,event=None):
-            wx.GetApp().Yield()
+            wx.GetApp().Yield(True)
              self.UnBindAllMouseEvents()
              Canvas = self.Canvas
  
              self.UnBindAllMouseEvents()
              Canvas = self.Canvas
  
-            Canvas.ClearAll()
-            Canvas.SetProjectionFun(None)
-
+            Canvas.InitAll()
+            Canvas.MinScale = 15
+            Canvas.MaxScale = 30
+            
              # put in a rectangle to get a bounding box
              # put in a rectangle to get a bounding box
-            Canvas.AddRectangle(0,0,20,20,LineColor = None)
+            Canvas.AddRectangle((0,0), (20,20), LineColor = None)
  
              # Draw some Arrows
              Canvas.AddArrow((10,10),Length = 40, Direction = 0)
  
              # Draw some Arrows
              Canvas.AddArrow((10,10),Length = 40, Direction = 0)
@@ -1148,23 +1555,23 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
              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.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")
+            Canvas.AddText("Clickable Arrow", (4,18), Position = "bc")
              Arrow = Canvas.AddArrow((4,18), 80, Direction = 90 ,LineWidth = 3, LineColor = "Red",   ArrowHeadAngle = 30)
              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)
  
              Arrow.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.ArrowClicked)
  
-            Canvas.AddText("Changable Arrow",16,4,Position = "cc")
+            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 = 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)
  
              self.RotArrow.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RotateArrow)
  
-
-
              Canvas.ZoomToBB()
  
          def ArrowClicked(self,event):
              Canvas.ZoomToBB()
  
          def ArrowClicked(self,event):
-            print "The Arrow was Clicked"
+            self.Log("The Arrow was Clicked")
  
          def RotateArrow(self,event):
  
          def RotateArrow(self,event):
-            print "The Changeable Arrow was Clicked"
+            ##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))
              ## 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))
@@ -1174,14 +1581,91 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
  
              self.Canvas.Draw(Force = True)
  
  
              self.Canvas.Draw(Force = True)
  
-        def TempTest(self, event= None):
-            wx.GetApp().Yield()
+        def HideTest(self, event=None):
+            wx.GetApp().Yield(True)
  
              self.UnBindAllMouseEvents()
              Canvas = self.Canvas
  
              self.UnBindAllMouseEvents()
              Canvas = self.Canvas
-            Canvas.ClearAll()
-            Canvas.SetProjectionFun(None)
+            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')
+
+            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()
  
  
+        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):
+            """
+            
+            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
+            Canvas.InitAll()
+            
              Range = (-10,10)
  
              # Create a random Polygon
              Range = (-10,10)
  
              # Create a random Polygon
@@ -1204,7 +1688,6 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
              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
@@ -1223,7 +1706,7 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
              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
  
          def Read_MapGen(self, filename, stats = 0,AllLines=0):
              self.SelectedPoint = Point
  
          def Read_MapGen(self, filename, stats = 0,AllLines=0):
@@ -1247,11 +1730,11 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
              for line in data:
                  if line:
                      if line == "# -b": #New segment beginning
              for line in data:
                  if line:
                      if line == "# -b": #New segment beginning
-                        if segment: Shorelines.append(Numeric.array(segment))
+                        if segment: Shorelines.append(N.array(segment))
                          segment = []
                      else:
                          segment.append(map(float,string.split(line)))
                          segment = []
                      else:
                          segment.append(map(float,string.split(line)))
-            if segment: Shorelines.append(Numeric.array(segment))
+            if segment: Shorelines.append(N.array(segment))
  
              if stats:
                  NumSegments = len(Shorelines)
  
              if stats:
                  NumSegments = len(Shorelines)
@@ -1277,44 +1760,38 @@ def BuildDrawFrame(): # this gets called when needed, rather than on import
  #---------------------------------------------------------------------------
        
  if __name__ == "__main__":
  #---------------------------------------------------------------------------
        
  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
      # check options:
      import sys, getopt
-    optlist, args = getopt.getopt(sys.argv[1:],'l',["local","all","text","map","stext","hit","hitf","animate","speed","temp","props","arrow"])
-
-    if not haveNumeric:
+    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
          raise ImportError(errorText)
      StartUpDemo = "all" # the default
-    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"
-        elif opt[0] == "--props":
-            StartUpDemo = "props"
-        elif opt[0] == "--arrow":
-            StartUpDemo = "arrow"
-    try:
-        import fixdc
-    except ImportError:
-        print  ("\n *************Notice*************\n"
-                "The fixdc module fixes the DC API for wxPython2.5.1.6 You can get the module from:\n"
-                "http://prdownloads.sourceforge.net/wxpython/fixdc.py?download\n"
-                " It will set up the DC methods to match both older and upcoming versions\n")
-        raise
+    if optlist:
+        StartUpDemo = optlist[0][0][2:]
+
  
      class DemoApp(wx.App):
          """
  
      class DemoApp(wx.App):
          """
@@ -1378,10 +1855,15 @@ if __name__ == "__main__":
              frame.Show()
  
              ## check to see if the demo is set to start in a particular mode.
              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":
@@ -1389,23 +1871,21 @@ if __name__ == "__main__":
              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()
              elif StartUpDemo == "props":
                  frame.TempTest()
              elif StartUpDemo == "props":
-                "starting PropertiesChange Test"
                  frame.PropertiesChangeTest()
              elif StartUpDemo == "arrow":
                  frame.PropertiesChangeTest()
              elif StartUpDemo == "arrow":
-                "starting arrow Test"
                  frame.ArrowTest()
                  frame.ArrowTest()
+            elif StartUpDemo == "arrowline":
+                frame.ArrowLineTest()
+            elif StartUpDemo == "hide":
+                frame.HideTest()
  
              return True
  
  
              return True
  
@@ -1414,14 +1894,16 @@ if __name__ == "__main__":
  
  else:
      # It's not running stand-alone, set up for wxPython demo.
  
  else:
      # It's not running stand-alone, set up for wxPython demo.
-    if not haveNumeric:
+    # 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)
  
          ## 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)
  
-                import images
+                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:")
  
                  note1 = wx.StaticText(self, -1, errorText)
                  note2 = wx.StaticText(self, -1, "This is what the FloatCanvas can look like:")
@@ -1429,7 +1911,7 @@ else:
                  S.Add((10, 10), 1)
                  S.Add(note1, 0, wx.ALIGN_CENTER)
                  S.Add(note2, 0, wx.ALIGN_CENTER | wx.BOTTOM, 4)
                  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,images.getFloatCanvasBitmap()),0,wx.ALIGN_CENTER)
+                S.Add(wx.StaticBitmap(self,-1,getScreenShotBitmap()),0,wx.ALIGN_CENTER)
                  S.Add((10, 10), 1)
                  self.SetSizer(S)
                  self.Layout()
                  S.Add((10, 10), 1)
                  self.SetSizer(S)
                  self.Layout()