]> git.saurik.com Git - wxWidgets.git/blobdiff - wxPython/demo/FloatCanvas.py
added missing button state
[wxWidgets.git] / wxPython / demo / FloatCanvas.py
index 244313138874768090b68bfefdb0a79a278ecef2..038d496c662be5ae3b21f9e4887defcc17671973 100644 (file)
-# 11/25/2003 - Jeff Grimmett (grimmtooth@softhome.net)
-#
-# o Updated for V2.5
-#
 
 
-import  wx
 
 
-# Stuff to integrate FloatCanvas into wxPython Demo
+#print "running:", wx.__version__
+##First, make sure Numeric or numarray can be imported.
 try:
     import Numeric
 try:
     import Numeric
+    import RandomArray
     haveNumeric = True
 except ImportError:
     haveNumeric = True
 except ImportError:
-    haveNumeric = False
-
-
-if not haveNumeric:
-    errorText = """\
-The FloatCanvas requires the Numeric module:
-You can get it at:
-     http://sourceforge.net/projects/numpy
-"""     
-    def runTest(frame, nb, log):
-        dlg = wx.MessageDialog(
-                frame, errorText, 'Sorry', wx.OK | wx.ICON_INFORMATION
-                )
-
-        dlg.ShowModal()
-        dlg.Destroy()
-
-    overview = ""
-
-else:
-    from wxPython.lib import floatcanvas
-    import wxPython.lib.colourdb
-    
-    ID_ABOUT_MENU = wx.NewId()          
-    ID_EXIT_MENU  = wx.NewId() 
-    ID_ZOOM_TO_FIT_MENU = wx.NewId()
-    ID_DRAWTEST_MENU = wx.NewId()
-    ID_LINETEST_MENU = wx.NewId()
-    ID_DRAWMAP_MENU = wx.NewId()
-    ID_DRAWMAP2_MENU = wx.NewId()
-    ID_CLEAR_MENU = wx.NewId()
-
+    # 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"
+        )
+      
+#---------------------------------------------------------------------------
 
 
-    colors = []
-    LineStyles = floatcanvas.draw_object.LineStyleList.keys()
 
 
+def BuildDrawFrame(): # this gets called when needed, rather than on import
+    try:
+        from floatcanvas import NavCanvas, FloatCanvas, Resources
+    except ImportError: # if it's not there locally, try the wxPython lib.
+        from wx.lib.floatcanvas import NavCanvas, FloatCanvas, Resources
+    import wx.lib.colourdb
+    import time, random
 
 
-    
     class DrawFrame(wx.Frame):
     class DrawFrame(wx.Frame):
-    
+
         """
         """
-    
         A frame used for the FloatCanvas Demo
         A frame used for the FloatCanvas Demo
-        
+
         """
         """
-        
-        def __init__(self, parent, id, title, position, size):
+
+
+        def __init__(self,parent, id,title,position,size):
             wx.Frame.__init__(self,parent, id,title,position, size)
             wx.Frame.__init__(self,parent, id,title,position, size)
-            
-            # Set up the MenuBar
-            
+
+            ## Set up the MenuBar
             MenuBar = wx.MenuBar()
             MenuBar = wx.MenuBar()
-            
+
             file_menu = wx.Menu()
             file_menu = wx.Menu()
-            file_menu.Append(ID_EXIT_MENU, "&Close","Close this frame")
-            self.Bind(wx.EVT_MENU, self.OnQuit, id=ID_EXIT_MENU)
+            item = file_menu.Append(-1, "&Close","Close this frame")
+            self.Bind(wx.EVT_MENU, self.OnQuit, item)
+
+            item = file_menu.Append(-1, "&SavePNG","Save the current image as a PNG")
+            self.Bind(wx.EVT_MENU, self.OnSavePNG, item)
             MenuBar.Append(file_menu, "&File")
             MenuBar.Append(file_menu, "&File")
-            
+
             draw_menu = wx.Menu()
             draw_menu = wx.Menu()
-            draw_menu.Append(ID_DRAWTEST_MENU, "&Draw Test","Run a test of drawing random components")
-            self.Bind(wx.EVT_MENU, self.DrawTest, id=ID_DRAWTEST_MENU)
-            draw_menu.Append(ID_LINETEST_MENU, "&Line Test","Run a test of drawing random lines")
-            self.Bind(wx.EVT_MENU, self.LineTest, id=ID_LINETEST_MENU)
-            draw_menu.Append(ID_DRAWMAP_MENU, "Draw &Map","Run a test of drawing a map")
-            self.Bind(wx.EVT_MENU, self.DrawMap, id=ID_DRAWMAP_MENU)
-            draw_menu.Append(ID_CLEAR_MENU, "&Clear","Clear the Canvas")
-            self.Bind(wx.EVT_MENU, self.Clear, id=ID_CLEAR_MENU)
-            MenuBar.Append(draw_menu, "&Draw")
+
+            item = draw_menu.Append(-1, "&Clear","Clear the Canvas")
+            self.Bind(wx.EVT_MENU, self.Clear, item)
+
+            item = draw_menu.Append(-1, "&Draw Test","Run a test of drawing random components")
+            self.Bind(wx.EVT_MENU, self.DrawTest, item)
+
+            item = draw_menu.Append(-1, "&Line Test","Run a test of drawing random lines")
+            self.Bind(wx.EVT_MENU, self.LineTest, item)
+
+            item = draw_menu.Append(-1, "Draw &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, "&ScaledText Test","Run a test of text drawing")
+            self.Bind(wx.EVT_MENU, self.TestScaledText, 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 &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, "&Speed","Run a test of Drawing Speed")
+            #self.Bind(wx.EVT_MENU, self.SpeedTest, item)
+
+            item = draw_menu.Append(-1, "Change &Properties","Run a test of Changing Object Properties")
+            self.Bind(wx.EVT_MENU, self.PropertiesChangeTest, item)
+
+            item = draw_menu.Append(-1, "&Arrows","Run a test of Arrows")
+            self.Bind(wx.EVT_MENU, self.ArrowTest, item)
+
+            item = draw_menu.Append(-1, "&Hide","Run a test of the Show() Hide() Show() and methods")
+            self.Bind(wx.EVT_MENU, self.HideTest, item)
+
+            MenuBar.Append(draw_menu, "&Tests")
 
             view_menu = wx.Menu()
 
             view_menu = wx.Menu()
-            view_menu.Append(ID_ZOOM_TO_FIT_MENU, "Zoom to &Fit","Zoom to fit the window")
-            self.Bind(wx.EVT_MENU, self.ZoomToFit, id=ID_ZOOM_TO_FIT_MENU)
+            item = view_menu.Append(-1, "Zoom to &Fit","Zoom to fit the window")
+            self.Bind(wx.EVT_MENU, self.ZoomToFit, item)
             MenuBar.Append(view_menu, "&View")
             MenuBar.Append(view_menu, "&View")
-            
+
             help_menu = wx.Menu()
             help_menu = wx.Menu()
-            help_menu.Append(ID_ABOUT_MENU, "&About",
+            item = help_menu.Append(-1, "&About",
                                     "More information About this program")
                                     "More information About this program")
-            self.Bind(wx.EVT_MENU, self.OnAbout, id=ID_ABOUT_MENU)
+            self.Bind(wx.EVT_MENU, self.OnAbout, item)
             MenuBar.Append(help_menu, "&Help")
             MenuBar.Append(help_menu, "&Help")
-            
+
             self.SetMenuBar(MenuBar)
             self.SetMenuBar(MenuBar)
-            
+
             self.CreateStatusBar()
             self.CreateStatusBar()
-            self.SetStatusText("")
-            
-            self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
-            
-            # Other event handlers:
-            self.Bind(wx.EVT_RIGHT_DOWN, self.RightButtonEvent)
+
             
             # Add the Canvas
             
             # Add the Canvas
-            self.Canvas = floatcanvas.FloatCanvas(self,-1,(500,500),
-                                      ProjectionFun = 'FlatEarth',
-                                      Debug = 0,
-                                      EnclosingFrame = self,
-                                      BackgroundColor = "DARK SLATE BLUE",
-                                      UseBackground = 0,
-                                      UseToolbar = 1)
-            self.Show(True)
-            
-            self.object_list = []
+            self.Canvas = NavCanvas.NavCanvas(self,
+                                              Debug = 0,
+                                              BackgroundColor = "DARK SLATE BLUE")
+
+            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(self.Canvas, 4, wx.EXPAND)
+            MainSizer.Add(self.MsgWindow, 1, wx.EXPAND | wx.ALL, 5)
+
+            self.SetSizer(MainSizer)
+            wx.EVT_CLOSE(self, self.OnCloseWindow)
+
+            FloatCanvas.EVT_MOTION(self.Canvas, self.OnMove ) 
+
+            self.EventsAreBound = False
+
+            ## getting all the colors for random objects
+            wx.lib.colourdb.updateColourDB()
+            self.colors = wx.lib.colourdb.getColourList()
+
+
             return None
             return None
+
+        def Log(self, text):
+            self.MsgWindow.AppendText(text)
+            if not text[-1] == "\n":
+                self.MsgWindow.AppendText("\n")
             
             
-        def RightButtonEvent(self,event):
-            print "Right Button has been clicked in DrawFrame"
-            print "coords are: %i, %i"%(event.GetX(),event.GetY())
-            event.Skip()
-            
-        def OnAbout(self, event):
-            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()
-            
-        def SetMode(self,event):
-            for id in [ID_ZOOM_IN_BUTTON,ID_ZOOM_OUT_BUTTON,ID_MOVE_MODE_BUTTON]:
-                self.ToolBar.ToggleTool(id,0)
-                
-            self.ToolBar.ToggleTool(event.GetId(),1)
 
 
-            if event.GetId() == ID_ZOOM_IN_BUTTON:
-                self.Canvas.SetGUIMode("ZoomIn")
+        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 ) 
+
+                FloatCanvas.EVT_MIDDLE_DOWN(self.Canvas, self.OnMiddleDown ) 
+                FloatCanvas.EVT_MIDDLE_UP(self.Canvas, self.OnMiddleUp ) 
+                FloatCanvas.EVT_MIDDLE_DCLICK(self.Canvas, 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 ) 
+
+                FloatCanvas.EVT_MOUSEWHEEL(self.Canvas, self.OnWheel ) 
+            self.EventsAreBound = True
+
+        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) 
+
+            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 )
+            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.EventsAreBound = False
 
 
-            elif event.GetId() == ID_ZOOM_OUT_BUTTON:
-                self.Canvas.SetGUIMode("ZoomOut")
 
 
-            elif event.GetId() == ID_MOVE_MODE_BUTTON:
-                self.Canvas.SetGUIMode("Move")
+        def PrintCoords(self,event):
+            #print "coords are: %s"%(event.Coords,)
+            #print "pixel coords are: %s\n"%(event.GetPosition(),)
+            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):
+            self.Log("LeftDown")
+            self.PrintCoords(event)
+
+        def OnLeftUp(self, event):
+            self.Log("LeftUp")
+            self.PrintCoords(event)
+
+        def OnLeftDouble(self, event):
+            self.Log("LeftDouble")
+            self.PrintCoords(event)
+
+        def OnMiddleDown(self, event):
+            self.Log("MiddleDown")
+            self.PrintCoords(event)
+
+        def OnMiddleUp(self, event):
+            self.Log("MiddleUp")
+            self.PrintCoords(event)
+
+        def OnMiddleDouble(self, event):
+            self.Log("MiddleDouble")
+            self.PrintCoords(event)
+
+        def OnRightDown(self, event):
+            self.Log("RightDown")
+            self.PrintCoords(event)
+
+        def OnRightUp(self, event):
+            self.Log("RightDown")
+            self.PrintCoords(event)
+
+        def OnRightDouble(self, event):
+            self.Log("RightDouble")
+            self.PrintCoords(event)
+
+        def OnWheel(self, event):
+            self.Log("Mouse Wheel")
+            self.PrintCoords(event)
+            Rot = event.GetWheelRotation()
+            Rot = Rot / abs(Rot) * 0.1
+            if event.ControlDown(): # move left-right
+                self.Canvas.MoveImage( (Rot, 0), "Panel" )
+            else: # move up-down
+                self.Canvas.MoveImage( (0, Rot), "Panel" )
                 
                 
+        def OnMove(self, event):
+            """
+            Updates the status bar with the world coordinates
+            """
+            self.SetStatusText("%.2f, %.2f"%tuple(event.Coords))
+
+        def OnAbout(self, event):
+            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()
+
         def ZoomToFit(self,event):
             self.Canvas.ZoomToBB()
         def ZoomToFit(self,event):
             self.Canvas.ZoomToBB()
-            
+
         def Clear(self,event = None):
         def Clear(self,event = None):
-            self.Canvas.RemoveObjects(self.object_list)
-            self.object_list = []
+            self.UnBindAllMouseEvents()
+            self.Canvas.ClearAll()
+            self.Canvas.SetProjectionFun(None)
             self.Canvas.Draw()
             self.Canvas.Draw()
-            
+
         def OnQuit(self,event):
             self.Close(True)
         def OnQuit(self,event):
             self.Close(True)
-            
+
         def OnCloseWindow(self, event):
             self.Destroy()
         def OnCloseWindow(self, event):
             self.Destroy()
-            
-        def DrawTest(self,event):
-            wx.GetApp().Yield()
 
 
-            import random
-            import RandomArray
+        def DrawTest(self,event=None):
+            wx.GetApp().Yield()
 
             Range = (-10,10)
 
             Range = (-10,10)
-            
+            colors = self.colors
+
+            self.BindAllMouseEvents()
             Canvas = self.Canvas
             Canvas = self.Canvas
-            object_list = self.object_list
-            
-            #          Random tests of everything:
-            
+
+            Canvas.ClearAll()
+            Canvas.SetProjectionFun(None)
+
+            ############# Random tests of everything ##############
+
             # Rectangles
             # Rectangles
-            for i in range(5):
-                x,y = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+            for i in range(3):
+                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)
-                object_list.append(Canvas.AddRectangle(x,y,h,w,LineWidth = lw,FillColor = colors[cf]))
-              
-                # Ellipses
-            for i in range(5):
-                x,y = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+                wh = (random.randint(1,5), random.randint(1,5))
+                Canvas.AddRectangle(xy, wh, LineWidth = lw, FillColor = colors[cf])
+
+            # Ellipses
+            for i in range(3):
+                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)
-                object_list.append(Canvas.AddEllipse(x,y,h,w,LineWidth = lw,FillColor = colors[cf]))
-              
-                # Dots
+                Canvas.AddEllipse(xy, (h,w), LineWidth = lw,FillColor = colors[cf])
+
+            # Points
             for i in range(5):
             for i in range(5):
-                x,y = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+                xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
                 D = random.randint(1,50)
                 D = random.randint(1,50)
-                lw = random.randint(1,5)
                 cf = random.randint(0,len(colors)-1)
                 cf = random.randint(0,len(colors)-1)
-                cl = random.randint(0,len(colors)-1)
-                object_list.append(Canvas.AddDot(x,y,D,LineWidth = lw,LineColor = colors[cl],FillColor = colors[cf]))
-              
-                # Circles
+                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):
             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)
-                object_list.append(Canvas.AddCircle(x,y,D,LineWidth = lw,LineColor = colors[cl],FillColor = colors[cf]))
-                self.object_list.append(self.Canvas.AddText("Circle # %i"%(i),x,y,Size = 12,BackGround = None,Position = "cc"))
-              
-                # Lines
+                Canvas.AddCircle(xy, D, LineWidth = lw, LineColor = colors[cl], FillColor = colors[cf])
+                Canvas.AddText("Circle # %i"%(i), xy, Size = 12, BackgroundColor = None, Position = "cc")
+            # Lines
             for i in range(5):
                 points = []
                 for j in range(random.randint(2,10)):
             for i in range(5):
                 points = []
                 for j in range(random.randint(2,10)):
@@ -214,9 +366,8 @@ else:
                 lw = random.randint(1,10)
                 cf = random.randint(0,len(colors)-1)
                 cl = random.randint(0,len(colors)-1)
                 lw = random.randint(1,10)
                 cf = random.randint(0,len(colors)-1)
                 cl = random.randint(0,len(colors)-1)
-                self.object_list.append(self.Canvas.AddLine(points, LineWidth = lw, LineColor = colors[cl]))
-              
-                # Polygons
+                Canvas.AddLine(points, LineWidth = lw, LineColor = colors[cl])
+            # Polygons
             for i in range(3):
                 points = []
                 for j in range(random.randint(2,6)):
             for i in range(3):
                 points = []
                 for j in range(random.randint(2,6)):
@@ -225,84 +376,957 @@ else:
                 lw = random.randint(1,6)
                 cf = random.randint(0,len(colors)-1)
                 cl = random.randint(0,len(colors)-1)
                 lw = random.randint(1,6)
                 cf = random.randint(0,len(colors)-1)
                 cl = random.randint(0,len(colors)-1)
-                self.object_list.append(self.Canvas.AddPolygon(points,
-                                                               LineWidth = lw,
-                                                               LineColor = colors[cl],
-                                                               FillColor = colors[cf],
-                                                               FillStyle = 'Solid'))
-                
-                
+                Canvas.AddPolygon(points,
+                                       LineWidth = lw,
+                                       LineColor = colors[cl],
+                                       FillColor = colors[cf],
+                                       FillStyle = 'Solid')
+
             ## Pointset
             for i in range(4):
                 points = []
                 points = RandomArray.uniform(Range[0],Range[1],(100,2))
                 cf = random.randint(0,len(colors)-1)
                 D = random.randint(1,4)
             ## Pointset
             for i in range(4):
                 points = []
                 points = RandomArray.uniform(Range[0],Range[1],(100,2))
                 cf = random.randint(0,len(colors)-1)
                 D = random.randint(1,4)
-                self.object_list.append(self.Canvas.AddPointSet(points, Color = colors[cf], Diameter = D))
-            
+                Canvas.AddPointSet(points, Color = colors[cf], Diameter = D)
+
             # Text
             # Text
-            String = "Some text"
-            for i in range(10):
+            String = "Unscaled text"
+            for i in range(3):
                 ts = random.randint(10,40)
                 cf = random.randint(0,len(colors)-1)
                 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.object_list.append(self.Canvas.AddText(String,x,y,Size = ts,ForeGround = 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)
+                Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+                Canvas.AddScaledText(String, Point, Size = ts, Color = colors[cf], Position = "cc")
+
+            # Arrows
+            N = 5
+            Points = RandomArray.uniform(Range[0], Range[1], (N,2) )
+            for i in range(N):
+                Canvas.AddArrow(Points[i],
+                                random.uniform(20,100),
+                                Direction = random.uniform(0,360),
+                                LineWidth = random.uniform(1,5),
+                                LineColor = colors[random.randint(0,len(colors)-1)],
+                                ArrowHeadAngle = random.uniform(20,90))
+
+            Canvas.ZoomToBB()
+
+        def TestAnimation(self,event=None):
+            """
+
+            In this test, a relatively complex background is drawn, and
+            a simple object placed in the foreground is moved over
+            it. This demonstrates how to use the InForeground attribute
+            to make an object in the foregorund draw fast, without
+            having to re-draw the whole background.
+
+            """
+            wx.GetApp().Yield()
+            Range = (-10,10)
+            self.Range = Range
+
+            self.UnBindAllMouseEvents()
+            Canvas = self.Canvas
+
+            Canvas.ClearAll()
+            Canvas.SetProjectionFun(None)
+
+            ##         Random tests of everything:
+            colors = self.colors
+            # Rectangles
+            for i in range(3):
+                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)
+                wh = (random.randint(1,5), random.randint(1,5) )
+                Canvas.AddRectangle(xy, wh, LineWidth = lw, FillColor = colors[cf])
+
+            # Ellipses
+            for i in range(3):
+                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)
+                wh = (random.randint(1,5), random.randint(1,5) )
+                Canvas.AddEllipse(xy, wh, LineWidth = lw, FillColor = colors[cf])
+
+            # Circles
+            for i in range(5):
+                xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+                D = random.randint(1,5)
+                lw = random.randint(1,5)
+                cf = random.randint(0,len(colors)-1)
+                cl = random.randint(0,len(colors)-1)
+                Canvas.AddCircle(xy, D, LineWidth = lw, LineColor = colors[cl], FillColor = colors[cf])
+                Canvas.AddText("Circle # %i"%(i), xy, Size = 12, BackgroundColor = None, Position = "cc")
+
+            # Lines
+            for i in range(5):
+                points = []
+                for j in range(random.randint(2,10)):
+                    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.AddLine(points, LineWidth = lw, LineColor = colors[cl])
+
+            # Polygons
+            for i in range(3):
+                points = []
+                for j in range(random.randint(2,6)):
+                    point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+                    points.append(point)
+                lw = random.randint(1,6)
+                cf = random.randint(0,len(colors)-1)
+                cl = random.randint(0,len(colors)-1)
+                Canvas.AddPolygon(points,
+                                       LineWidth = lw,
+                                       LineColor = colors[cl],
+                                       FillColor = colors[cf],
+                                       FillStyle = 'Solid')
+
+            # Scaled Text
+            String = "Scaled text"
+            for i in range(3):
+                ts = random.random()*3 + 0.2
+                cf = random.randint(0,len(colors)-1)
+                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:
+            C = Canvas.AddCircle((0,0), 7, LineWidth = 2,LineColor = "Black",FillColor = "Red", InForeground = True)
+            T = Canvas.AddScaledText("Click to Move", (0,0), Size = 0.6, Position = 'cc', InForeground = True)
+            C.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.MoveMe)
+            C.Text = T
+
+            self.Timer = wx.PyTimer(self.ShowFrame)
+            self.FrameDelay = 50 # milliseconds
+
+            Canvas.ZoomToBB()
+
+        def ShowFrame(self):
+            Object = self.MovingObject
+            Range = self.Range
+            if  self.TimeStep < self.NumTimeSteps:
+                x,y = Object.XY
+                if x > Range[1] or x < Range[0]:
+                    self.dx = -self.dx
+                if y > Range[1] or y < Range[0]:
+                    self.dy = -self.dy
+                Object.Move( (self.dx,self.dy) )
+                Object.Text.Move( (self.dx,self.dy))
+                self.Canvas.Draw()
+                self.TimeStep += 1
+                wx.GetApp().Yield(True)
+            else:
+                self.Timer.Stop()
+
+
+        def MoveMe(self, Object):
+            self.MovingObject = Object
+            Range = self.Range
+            self.dx = random.uniform(Range[0]/4,Range[1]/4)
+            self.dy = random.uniform(Range[0]/4,Range[1]/4)
+            #import time
+            #start = time.time()
+            self.NumTimeSteps = 200
+            self.TimeStep = 1
+            self.Timer.Start(self.FrameDelay)
+            #print "Did %i frames in %f seconds"%(N, (time.time() - start) )
+
+        def TestHitTest(self,event=None):
+            wx.GetApp().Yield()
+
+            self.UnBindAllMouseEvents()
+            Canvas = self.Canvas
+
+            Canvas.ClearAll()
+            Canvas.SetProjectionFun(None)
+
+            #Add a Hit-able rectangle
+            w, h = 60, 20
+
+            dx = 80
+            dy = 40
+            x, y = 20, 20
+            FontSize = 8
+
+            #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")
+
+
+            x += dx
+            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)
+            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"
+            R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
+            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")
+
+            x = 20
+            y += dy
+            color = "LightBlue"
+            R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
+            R.Name = color + " Rectangle"
+            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")
+
+            x += dx
+            color = "Grey"
+            R = Canvas.AddEllipse((x, y), (w, h),LineWidth = 2,FillColor = color)
+            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")
+
+            x += dx
+            color = "Brown"
+            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)
+            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"
+            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)
+            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"
+            R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
+            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")
+
+            x += dx
+            color = "AQUAMARINE"
+            R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
+            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")
+
+            x = 20
+            y += dy
+            color = "CORAL"
+            R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
+            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")
+
+            x += dx
+            color = "CYAN"
+            R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
+            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")
+
+            x += dx
+            color = "LIME GREEN"
+            R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
+            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")
+
+            x = 20
+            y += dy
+            color = "MEDIUM GOLDENROD"
+            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)
+            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"
+            R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
+            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")
+
+            x += dx
+            color = "MEDIUM VIOLET RED"
+            R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
+            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")
+
+            x = 20
+            y += dy
+            color = "SKY BLUE"
+            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)
+            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"
+            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)
+            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"
+            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)
+            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)
+            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"
+            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)
+            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")
+
+            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)
+            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")
+
+            x = 20
+            y += dy
+            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)
+            Canvas.AddText("Left Down", (x, y), Size = FontSize, Position = "bl")
+
+            x += dx
+            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.AddText("Left Down", (x, y), Size = FontSize, Position = "tl")
+
+            x += dx
+            color = "Cyan"
+            Point = (x + w/2, y)
+            #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)
+            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()
             self.Canvas.ZoomToBB()
-            
+
+        def TestHitTestForeground(self,event=None):
+            wx.GetApp().Yield()
+
+            self.UnBindAllMouseEvents()
+            Canvas = self.Canvas
+
+            Canvas.ClearAll()
+            Canvas.SetProjectionFun(None)
+
+            #Add a Hitable rectangle
+            w, h = 60, 20
+
+            dx = 80
+            dy = 40
+            x,y = 20, 20
+
+            color = "Red"
+            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)
+            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
+
+            ## NOTE: In a real app, it might be better to create a new
+            ## custom FloatCanvas DrawObject
+
+            self.MovingRects = []
+            WH = (w/2, h/2)
+            x += dx
+            color = "LightBlue"
+            R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True)
+            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)
+            self.MovingRects.extend( (R,L) )
+
+            x += w/2
+            R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True)
+            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)
+            self.MovingRects.extend( (R,L) )
+
+            x -= w/2
+            y += h/2
+            R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True)
+            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)
+            self.MovingRects.extend( (R,L) )
+
+
+            x += w/2
+            R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True)
+            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)
+            self.MovingRects.extend( (R,L) )
+
+            self.Canvas.ZoomToBB()
+
+        def RectMoveLeft(self,Object):
+            self.MoveRects("left")
+
+        def RectMoveRight(self,Object):
+            self.MoveRects("right")
+
+        def RectMoveUp(self,Object):
+            self.MoveRects("up")
+
+        def RectMoveDown(self,Object):
+            self.MoveRects("down")
+
+        def MoveRects(self, Dir):
+            for Object in self.MovingRects:
+                X,Y = Object.XY
+                if Dir == "left": X -= 10
+                elif Dir == "right": X += 10
+                elif Dir == "up": Y += 10
+                elif Dir == "down": Y -= 10
+                Object.SetPoint((X,Y))
+            self.Canvas.Draw()
+
+        def PointSetGotHit(self, Object):
+            self.Log(Object.Name + "Got Hit\n")
+
+        def RectGotHit(self, Object):
+            self.Log(Object.Name + "Got Hit\n")
+
+        def RectGotHitRight(self, Object):
+            self.Log(Object.Name + "Got Hit With Right\n")
+
+        def RectGotHitLeft(self, Object):
+            self.Log(Object.Name + "Got Hit with Left\n")
+
+        def RectMouseOver(self, Object):
+            self.Log("Mouse entered:" +  Object.Name)
+
+        def RectMouseLeave(self, Object):
+            self.Log("Mouse left " +  Object.Name)
+
+
+        def TestText(self, event= None):
+            wx.GetApp().Yield()
+
+            self.BindAllMouseEvents()
+            Canvas = self.Canvas
+            Canvas.ClearAll()
+            Canvas.SetProjectionFun(None)
+
+            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
+            Canvas.AddRectangle((-10,-10),
+                                (20,20),
+                                LineWidth = 1,
+                                LineColor = None)
+
+            # Text
+            String = "Some text"
+            self.Canvas.AddText("Top Left",Point,Size = 14,Color = "Yellow",BackgroundColor = "Blue", Position = "tl")
+            self.Canvas.AddText("Bottom Left",Point,Size = 14,Color = "Cyan",BackgroundColor = "Black",Position = "bl")
+            self.Canvas.AddText("Top Right",Point,Size = 14,Color = "Black",BackgroundColor = "Cyan",Position = "tr")
+            self.Canvas.AddText("Bottom Right",Point,Size = 14,Color = "Blue",BackgroundColor = "Yellow",Position = "br")
+            Canvas.AddPointSet((Point), Color = "White", Diameter = 2)
+
+            Point  = (3, 2)
+
+            Canvas.AddPointSet((Point), Color = "White", Diameter = 2)
+            self.Canvas.AddText("Top Center",Point,Size = 14,Color = "Black",Position = "tc")
+            self.Canvas.AddText("Bottom Center",Point,Size = 14,Color = "White",Position = "bc")
+
+            Point  = (3, 4)
+
+            Canvas.AddPointSet((Point), Color = "White", Diameter = 2)
+            self.Canvas.AddText("Center Right",Point,Size = 14,Color = "Black",Position = "cr")
+            self.Canvas.AddText("Center Left",Point,Size = 14,Color = "Black",Position = "cl")
+
+            Point  = (3, -2)
+
+            Canvas.AddPointSet((Point), Color = "White", Diameter = 2)
+            self.Canvas.AddText("Center Center",
+                                Point, Size = 14,
+                                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("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!
+            Font = wx.Font(20, wx.DEFAULT, wx.ITALIC, wx.NORMAL, False, "zapf chancery")
+            self.Canvas.AddText("zapf chancery Font", (-10, -6), Font = Font)
+
+            self.Canvas.ZoomToBB()
+
+        def TestScaledText(self, event= None):
+            wx.GetApp().Yield()
+
+            self.BindAllMouseEvents()
+            Canvas = self.Canvas
+            Canvas.ClearAll()
+            Canvas.SetProjectionFun(None)
+
+            Point  = (0, 0)
+
+            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)
+
+
+            Point  = (0, 20)
+
+            Canvas.AddScaledText("Top Center",Point,Size = 7,Color = "Black",Position = "tc")
+            Canvas.AddScaledText("Bottom Center",Point,Size = 7,Color = "White",Position = "bc")
+            Canvas.AddPointSet((Point), Color = "White", Diameter = 4)
+
+            Point  = (0, -20)
+
+            Canvas.AddScaledText("Center Right",Point,Size = 9,Color = "Black",Position = "cr")
+            Canvas.AddScaledText("Center Left",Point,Size = 9,Color = "Black",Position = "cl")
+            Canvas.AddPointSet((Point), Color = "White", Diameter = 4)
+
+            x = -200
+
+            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)
+
+
+            # NOTE: this font exists on my Linux box..who knows were else you'll find it!
+            Point = (-100, 50)
+            Font = wx.Font(12, wx.DEFAULT, wx.ITALIC, wx.NORMAL, False, "zapf chancery")
+            T = self.Canvas.AddScaledText("zapf chancery Font", Point, Size = 20, Font = Font, Position = 'bc')
+
+            Point = (-50, -50)
+            Font = wx.Font(12, wx.DEFAULT, wx.ITALIC, wx.NORMAL, False, "bookman")
+            T = self.Canvas.AddScaledText("Bookman Font", Point, Size = 8, Font = Font)
+
+            self.Canvas.ZoomToBB()
+
+        def TestScaledTextBox(self, event= None):
+            wx.GetApp().Yield()
+
+            self.UnBindAllMouseEvents()
+            Canvas = self.Canvas
+            Canvas.ClearAll()
+            Canvas.SetProjectionFun(None)
+
+            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,
+                                          Underline = 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,
+                                          Underline = 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,
+                                          Underline = 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,
+                                          Underline = 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,
+                                          Underline = 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 = Numeric.array((100, -20), Numeric.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 = Numeric.array((0, -40), Numeric.Float)
+    #        Point = Numeric.array((0, 0), Numeric.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 = Numeric.array((-20, 60), Numeric.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 = Numeric.array((-20, 20), Numeric.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 = Numeric.array((100, -60), Numeric.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()
+
+            self.UnBindAllMouseEvents()
+            Canvas = self.Canvas
+            Canvas.ClearAll()
+            Canvas.SetProjectionFun(None)
+
+            Canvas.AddRectangle((10, 20),
+                                (400, 100),
+                                LineWidth = 3,
+                                LineColor = "Blue",
+                                FillColor = "Red")
+
+            bmp = Resources.getMagPlusBitmap()
+
+            Canvas.AddText("These are Unscaled Bitmaps:", (140, 90))
+          
+            Point = (150, 50)
+            BitMap = Canvas.AddBitmap(bmp, Point, Position = "cc" )
+            Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+            Point = (200, 50)
+            BitMap = Canvas.AddBitmap(bmp, Point, Position = "br" )
+            Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+            Point = (200, 50)
+            BitMap = Canvas.AddBitmap(bmp, Point, Position = "bl" )
+            Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+            Point = (200, 50)
+            BitMap = Canvas.AddBitmap(bmp, Point, Position = "tr" )
+            Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+            Point = (200, 50)
+            BitMap = Canvas.AddBitmap(bmp, Point, Position = "tl" )
+            Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+            Point = (250, 50)
+            BitMap = Canvas.AddBitmap(bmp, Point, Position = "cr" )
+            Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+            Point = (250, 50)
+            BitMap = Canvas.AddBitmap(bmp, Point, Position = "cl" )
+            Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+            Point = (300, 50)
+            BitMap = Canvas.AddBitmap(bmp, Point, Position = "tc" )
+            Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+            Point = (300, 50)
+            BitMap = Canvas.AddBitmap(bmp, Point, Position = "bc" )
+            Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+            Canvas.AddScaledText("These are Scaled Bitmaps:", (220, -60), Size = 10, Position = "tr")
+            Point = (250, -100)
+            BitMap = Canvas.AddScaledBitmap(bmp, Point, Height = 50, Position = "bc" )
+            BitMap = Canvas.AddScaledBitmap(bmp, Point, Height = 50, Position = "tc" )
+            Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+            Point = (300, -100)
+            BitMap = Canvas.AddScaledBitmap(Resources.getMondrianImage(), Point, Height = 50)
+
+            self.Canvas.ZoomToBB()
+
         def DrawMap(self,event = None):
             wx.GetApp().Yield()
             import os, time
         def DrawMap(self,event = None):
             wx.GetApp().Yield()
             import os, time
+            self.BindAllMouseEvents()
+
         ## Test of Actual Map Data
         ## Test of Actual Map Data
-            self.Clear()
-            start = time.clock()
-            Shorelines = 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()
+            self.Canvas.ClearAll()
+            self.Canvas.SetProjectionFun("FlatEarth")
+            #start = time.clock()
+            self.Log("Loading Map from a File")
+            wx.GetApp().Yield() # so log text will get displayed now.
+            Shorelines = self.Read_MapGen(os.path.join("data",'world.dat'),stats = 0)
+            #print "It took %f seconds to load %i shorelines"%(time.clock() - start,len(Shorelines) )
+            #start = time.clock()
             for segment in Shorelines:
             for segment in Shorelines:
-                self.object_list.append(self.Canvas.AddLine(segment))
-            print "It took %f seconds to add %i shorelines"%(time.clock() - start,len(Shorelines) )
-            start = time.clock()
+                self.Canvas.AddLine(segment)
+            #print "It took %f seconds to add %i shorelines"%(time.clock() - start,len(Shorelines) )
+            #start = time.clock()
             self.Canvas.ZoomToBB()
             self.Canvas.ZoomToBB()
-            print "It took %f seconds to draw %i shorelines"%(time.clock() - start,len(Shorelines) )
-    
-    ##    def LineTest(self,event = None):
-    ##        wxGetApp().Yield()
-    ##        import os, time
-    ##        import random
-    ##        Range = (-10,10)
-    ##    ## Test of drawing lots of lines
-    ##        self.Clear()
-    ##        start = time.clock()
-    ##        linepoints = []
-    ##        linecolors = []
-    ##        linewidths = []
-    ##        linestyles = []
-    ##        for i in range(500):
-    ##            points = (random.randint(Range[0],Range[1]),
-    ##                     random.randint(Range[0],Range[1]))
-    ##            linepoints.append(points)
-    ##            points = (random.randint(Range[0],Range[1]),
-    ##                     random.randint(Range[0],Range[1]))
-    ##            linepoints.append(points)
-    ##            linewidths.append(random.randint(1,10) )
-    ##            linecolors.append(colors[random.randint(0,len(colors)-1) ])
-    ##            linestyles.append(LineStyles[random.randint(0, len(LineStyles)-1)])
-    
-    ##        self.object_list.append(self.Canvas.AddLineSet(linepoints, LineWidths = linewidths, LineColors = linecolors, LineStyles = linestyles))
-    ##        print "It took %f seconds to add %i lines"%(time.clock() - start,len(linepoints) )
-    ##        start = time.clock()
-    ##        self.Canvas.ZoomToBB()
-    ##        print "It took %f seconds to draw %i lines"%(time.clock() - start,len(linepoints) )
-    
+            #print "It took %f seconds to draw %i shorelines"%(time.clock() - start,len(Shorelines) )
+
+
         def LineTest(self,event = None):
             wx.GetApp().Yield()
             import os, time
         def LineTest(self,event = None):
             wx.GetApp().Yield()
             import os, time
-            import random
+#            import random
+            colors = self.colors
             Range = (-10,10)
         ## Test of drawing lots of lines
             Range = (-10,10)
         ## Test of drawing lots of lines
-            self.Clear()
-            start = time.clock()
+            Canvas = self.Canvas
+            Canvas.ClearAll()
+            Canvas.SetProjectionFun(None)
+            #start = time.clock()
             linepoints = []
             linecolors = []
             linewidths = []
             linepoints = []
             linecolors = []
             linewidths = []
@@ -315,161 +1339,616 @@ else:
                 linewidths.append(random.randint(1,10) )
                 linecolors.append(random.randint(0,len(colors)-1) )
             for (points,color,width) in zip(linepoints,linecolors,linewidths):
                 linewidths.append(random.randint(1,10) )
                 linecolors.append(random.randint(0,len(colors)-1) )
             for (points,color,width) in zip(linepoints,linecolors,linewidths):
-                self.object_list.append(self.Canvas.AddLine((points[0:2],points[2:4]), LineWidth = width, LineColor = colors[color]))
-            print "It took %f seconds to add %i lines"%(time.clock() - start,len(linepoints) )
+                Canvas.AddLine((points[0:2],points[2:4]), LineWidth = width, LineColor = colors[color])
+            #print "It took %f seconds to add %i lines"%(time.clock() - start,len(linepoints) )
+            #start = time.clock()
+            Canvas.ZoomToBB()
+            #print "It took %f seconds to draw %i lines"%(time.clock() - start,len(linepoints) )
+
+        def SpeedTest(self,event=None):
+            wx.GetApp().Yield()
+            BigRange = (-1000,1000)
+            colors = self.colors
+
+            self.UnBindAllMouseEvents()
+            Canvas = self.Canvas
+
+            Canvas.ClearAll()
+            Canvas.SetProjectionFun(None)
+
+            # Pointset
+            coords = []
+            for i in range(1000):
+                Point = (random.uniform(BigRange[0],BigRange[1]),random.uniform(BigRange[0],BigRange[1]))
+                coords.append( (Point) )
+            print "Drawing the Points"
             start = time.clock()
             start = time.clock()
-            self.Canvas.ZoomToBB()
-            print "It took %f seconds to draw %i lines"%(time.clock() - start,len(linepoints) )
+            for Point in coords:
+                Canvas.AddPoint(Point, Diameter = 4)
+            print "It took %s seconds to add the points"%(time.clock() - start)
+            Canvas.ZoomToBB()
+
+        def PropertiesChangeTest(self,event=None):
+            wx.GetApp().Yield()
+
+            Range = (-10,10)
+            colors = self.colors
+
+            self.UnBindAllMouseEvents()
+            Canvas = self.Canvas
+
+            Canvas.ClearAll()
+            Canvas.SetProjectionFun(None)
+
+            self.ColorObjectsAll = []
+            self.ColorObjectsLine = []
+            self.ColorObjectsColor = []
+            self.ColorObjectsText = []
+            ##One of each object:
+            # Rectangle
+            Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+            lw = random.randint(1,5)
+            cf = random.randint(0,len(colors)-1)
+            wh = ( random.randint(1,5), random.randint(1,5) )
+            self.Rectangle = Canvas.AddRectangle(Point, wh, LineWidth = lw, FillColor = colors[cf])
+            self.ColorObjectsAll.append(self.Rectangle)
+
+            # Ellipse
+            Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+            lw = random.randint(1,5)
+            cf = random.randint(0,len(colors)-1)
+            wh = ( random.randint(1,5), random.randint(1,5) )
+            self.Ellipse = Canvas.AddEllipse(Point, wh, LineWidth = lw, FillColor = colors[cf])
+            self.ColorObjectsAll.append(self.Ellipse)
+
+            # Point 
+            xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+            D = random.randint(1,50)
+            lw = random.randint(1,5)
+            cf = random.randint(0,len(colors)-1)
+            cl = random.randint(0,len(colors)-1)
+            self.ColorObjectsColor.append(Canvas.AddPoint(xy, colors[cf], D))
+
+            # Circle
+            Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+            D = random.randint(1,5)
+            lw = random.randint(1,5)
+            cf = random.randint(0,len(colors)-1)
+            cl = random.randint(0,len(colors)-1)
+            self.Circle = Canvas.AddCircle(Point, D, LineWidth = lw, LineColor = colors[cl], FillColor = colors[cf])
+            self.ColorObjectsAll.append(self.Circle)
+
+            # Line
+            points = []
+            for j in range(random.randint(2,10)):
+                point = (random.randint(Range[0],Range[1]),random.randint(Range[0],Range[1]))
+                points.append(point)
+            lw = random.randint(1,10)
+            cf = random.randint(0,len(colors)-1)
+            cl = random.randint(0,len(colors)-1)
+            self.ColorObjectsLine.append(Canvas.AddLine(points, LineWidth = lw, LineColor = colors[cl]))
+
+            # Polygon
+##            points = []
+##            for j in range(random.randint(2,6)):
+##                point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+##                points.append(point)
+            points = RandomArray.uniform(Range[0],Range[1],(6,2))
+            lw = random.randint(1,6)
+            cf = random.randint(0,len(colors)-1)
+            cl = random.randint(0,len(colors)-1)
+            self.ColorObjectsAll.append(Canvas.AddPolygon(points,
+                                                       LineWidth = lw, 
+                                                       LineColor = colors[cl],
+                                                       FillColor = colors[cf],
+                                                       FillStyle = 'Solid'))
+
+            ## Pointset
+            points = RandomArray.uniform(Range[0],Range[1],(100,2))
+            cf = random.randint(0,len(colors)-1)
+            D = random.randint(1,4)
+            self.PointSet = Canvas.AddPointSet(points, Color = colors[cf], Diameter = D)
+            self.ColorObjectsColor.append(self.PointSet)
+
+            ## Point
+            point = RandomArray.uniform(Range[0],Range[1],(2,))
+            cf = random.randint(0,len(colors)-1)
+            D = random.randint(1,4)
+            self.Point = Canvas.AddPoint(point, Color = colors[cf], Diameter = D)
+            self.ColorObjectsColor.append(self.Point)
+
+            # Text
+            String = "Unscaled text"
+            ts = random.randint(10,40)
+            cf = random.randint(0,len(colors)-1)
+            Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+            self.ColorObjectsText.append(Canvas.AddText(String, Point, Size = ts, Color = colors[cf], Position = "cc"))
+
+            # Scaled Text
+            String = "Scaled text"
+            ts = random.random()*3 + 0.2
+            cf = random.randint(0,len(colors)-1)
+            Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+            self.ColorObjectsText.append(Canvas.AddScaledText(String, Point, Size = ts, Color = colors[cf], Position = "cc"))
+
+            # A "Button"
+            Button = Canvas.AddRectangle((-10, -12), (20, 3), LineStyle = None, FillColor = "Red")
+            Canvas.AddScaledText("Click Here To Change Properties",
+                                 (0, -10.5),
+                                 Size = 0.7,
+                                 Color = "Black",
+                                 Position = "cc")
+
+            Button.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.ChangeProperties)
+
+            Canvas.ZoomToBB()
+
+        def ChangeProperties(self, Object = None):
+            colors = self.colors
+            Range = (-10,10)
+
+            for Object in self.ColorObjectsAll:
+                pass
+                Object.SetFillColor(colors[random.randint(0,len(colors)-1)])
+                Object.SetLineColor(colors[random.randint(0,len(colors)-1)])
+                Object.SetLineWidth(random.randint(1,7))
+                Object.SetLineStyle(FloatCanvas.DrawObject.LineStyleList.keys()[random.randint(0,5)])
+            for Object in self.ColorObjectsLine:
+                Object.SetLineColor(colors[random.randint(0,len(colors)-1)])
+                Object.SetLineWidth(random.randint(1,7))
+                Object.SetLineStyle(FloatCanvas.DrawObject.LineStyleList.keys()[random.randint(0,5)])
+            for Object in self.ColorObjectsColor:
+                Object.SetColor(colors[random.randint(0,len(colors)-1)])
+            for Object in self.ColorObjectsText:
+                Object.SetColor(colors[random.randint(0,len(colors)-1)])
+                Object.SetBackgroundColor(colors[random.randint(0,len(colors)-1)])
+            self.Circle.SetDiameter(random.randint(1,10))
+            self.PointSet.SetDiameter(random.randint(1,8))
+            self.Point.SetDiameter(random.randint(1,8))
+            for Object in (self.Rectangle, self.Ellipse):
+                Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+                wh = ( random.randint(1,5), random.randint(1,5) )
+                Object.SetShape(Point, wh)
+            self.Canvas.Draw(Force = True)
+
+        def ArrowTest(self,event=None):
+            wx.GetApp().Yield()
+            self.UnBindAllMouseEvents()
+            Canvas = self.Canvas
+
+            Canvas.ClearAll()
+            Canvas.SetProjectionFun(None)
+
+            # put in a rectangle to get a bounding box
+            Canvas.AddRectangle((0,0), (20,20), LineColor = None)
+
+            # Draw some Arrows
+            Canvas.AddArrow((10,10),Length = 40, Direction = 0)
+            Canvas.AddArrow((10,10),Length = 50, Direction = 45 ,LineWidth = 2, LineColor = "Black", ArrowHeadAngle = 20)
+            Canvas.AddArrow((10,10),Length = 60, Direction = 90 ,LineWidth = 3, LineColor = "Red",   ArrowHeadAngle = 30)
+            Canvas.AddArrow((10,10),Length = 70, Direction = 135,LineWidth = 4, LineColor = "Red",   ArrowHeadAngle = 40)
+            Canvas.AddArrow((10,10),Length = 80, Direction = 180,LineWidth = 5, LineColor = "Blue",  ArrowHeadAngle = 50)
+            Canvas.AddArrow((10,10),Length = 90, Direction = 225,LineWidth = 4, LineColor = "Blue",  ArrowHeadAngle = 60)
+            Canvas.AddArrow((10,10),Length = 100,Direction = 270,LineWidth = 3, LineColor = "Green", ArrowHeadAngle = 70)
+            Canvas.AddArrow((10,10),Length = 110,Direction = 315,LineWidth = 2, LineColor = "Green", ArrowHeadAngle = 90 )
+
+            Canvas.AddText("Clickable Arrow", (4,18), Position = "bc")
+            Arrow = Canvas.AddArrow((4,18), 80, Direction = 90 ,LineWidth = 3, LineColor = "Red",   ArrowHeadAngle = 30)
+            Arrow.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.ArrowClicked)
+
+            Canvas.AddText("Changable Arrow", (16,4), Position = "cc")
+            self.RotArrow = Canvas.AddArrow((16,4), 80, Direction = 0 ,LineWidth = 3, LineColor = "Green",   ArrowHeadAngle = 30)
+            self.RotArrow.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RotateArrow)
+
+            Canvas.ZoomToBB()
+
+        def ArrowClicked(self,event):
+            print "The Arrow was Clicked"
+
+        def RotateArrow(self,event):
+            ##print "The Changeable Arrow was Clicked"
+            ## You can do them either one at a time, or both at once
+            ## Doing them both at once prevents the arrow points from being calculated twice
+            #self.RotArrow.SetDirection(self.RotArrow.Direction + random.uniform(-90,90))
+            #self.RotArrow.SetLength(self.RotArrow.Length + random.randint(-20,20))
+            self.RotArrow.SetLengthDirection(self.RotArrow.Length + random.randint(-20,20),
+                                             self.RotArrow.Direction + random.uniform(-90,90) )
+
+            self.Canvas.Draw(Force = True)
+
+        def HideTest(self, event=None):
+            wx.GetApp().Yield()
+
+            self.UnBindAllMouseEvents()
+            Canvas = self.Canvas
+            Canvas.ClearAll()
+            Canvas.SetProjectionFun(None)
+
+            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.Hide()
+                Button.SetText(Button.String.replace("Hide","Show"))
+            else:
+                Poly.Show()
+                Button.SetText(Button.String.replace("Show", "Hide"))
+            self.Canvas.Draw(True)
+
+        def TempTest(self, event= None):
+            wx.GetApp().Yield()
+
+            self.UnBindAllMouseEvents()
+            Canvas = self.Canvas
+            Canvas.ClearAll()
+            Canvas.SetProjectionFun(None)
+
+            Range = (-10,10)
+
+            # Create a random Polygon
+            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')
+
+            Poly.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.SelectPoly)
+
+            self.SelectedPoly = None
+            self.SelectPoints = []
+            self.SelectedPoint = None
+
+            Canvas.ZoomToBB()
+
+        def SelectPoly(self, Object):
+            print "In SelectPoly"
+            Canvas = self.Canvas
+            if Object is self.SelectedPoly:
+                pass
+            else:
+                #fixme: Do something to unselect the old one
+                self.SelectedPoly = Object
+                Canvas.RemoveObjects(self.SelectPoints)
+                self.SelectPoints = []
+            # Draw points on the Vertices of the Selected Poly:
+            for i, point in enumerate(Object.Points):
+                P = Canvas.AddPointSet(point, Diameter = 6, Color = "Red")
+                P.VerticeNum = i
+                P.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.SelectPointHit)
+                self.SelectPoints.append(P)
+            #Canvas.ZoomToBB()
+            Canvas.Draw()
+
+        def SelectPointHit(self, Point):
+            print "Point Num: %i Hit"%Point.VerticeNum
+            self.SelectedPoint = Point
+
+        def Read_MapGen(self, filename, stats = 0,AllLines=0):
+            """
+            This function reads a MapGen Format file, and
+            returns a list of NumPy arrays with the line segments in them.
+
+            Each NumPy array in the list is an NX2 array of Python Floats.
+
+            The demo should have come with a file, "world.dat" that is the
+            shorelines of the whole world, in MapGen format.
+
+            """
+            import string
+            file = open(filename,'rt')
+            data = file.readlines()
+            data = map(string.strip,data)
+
+            Shorelines = []
+            segment = []
+            for line in data:
+                if line:
+                    if line == "# -b": #New segment beginning
+                        if segment: Shorelines.append(Numeric.array(segment))
+                        segment = []
+                    else:
+                        segment.append(map(float,string.split(line)))
+            if segment: Shorelines.append(Numeric.array(segment))
+
+            if stats:
+                NumSegments = len(Shorelines)
+                NumPoints = 0
+                for segment in Shorelines:
+                    NumPoints = NumPoints + len(segment)
+                AvgPoints = NumPoints / NumSegments
+                print "Number of Segments: ", NumSegments
+                print "Average Number of Points per segment: ",AvgPoints
+            if AllLines:
+                Lines = []
+                for segment in Shorelines:
+                    Lines.append(segment[0])
+                    for point in segment[1:-1]:
+                        Lines.append(point)
+                        Lines.append(point)
+                    Lines.append(segment[-1])
+                return Lines
+            else:
+                return Shorelines
+    return DrawFrame 
+
+#---------------------------------------------------------------------------
+      
+if __name__ == "__main__":
+
+    import wx
+   
     
     
+    # check options:
+    import sys, getopt
+    optlist, args = getopt.getopt(sys.argv[1:],'l',["local",
+                                                    "all",
+                                                    "text",
+                                                    "map",
+                                                    "stext",
+                                                    "stextbox",
+                                                    "bitmap",
+                                                    "hit",
+                                                    "hitf",
+                                                    "animate",
+                                                    "speed",
+                                                    "temp",
+                                                    "props",
+                                                    "arrow",
+                                                    "hide"])
+
+    if not haveNumeric:
+        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] == "--stextbox":
+            StartUpDemo = "stextbox"
+        elif opt[0] == "--bitmap":
+            StartUpDemo = "bitmap"
+        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"
+        elif opt[0] == "--hide":
+            StartUpDemo = "hide"
+
     class DemoApp(wx.App):
         """
         How the demo works:
     class DemoApp(wx.App):
         """
         How the demo works:
-        
+
         Under the Draw menu, there are three options:
         Under the Draw menu, there are three options:
-        
+
         *Draw Test: will put up a picture of a bunch of randomly generated
         objects, of each kind supported.
         *Draw Test: will put up a picture of a bunch of randomly generated
         objects, of each kind supported.
-        
+
         *Draw Map: will draw a map of the world. Be patient, it is a big map,
         with a lot of data, and will take a while to load and draw (about 10 sec 
         on my 450Mhz PIII). Redraws take about 2 sec. This demonstrates how the
         performance is not very good for large drawings.
         *Draw Map: will draw a map of the world. Be patient, it is a big map,
         with a lot of data, and will take a while to load and draw (about 10 sec 
         on my 450Mhz PIII). Redraws take about 2 sec. This demonstrates how the
         performance is not very good for large drawings.
-        
+
         *Clear: Clears the Canvas.
         *Clear: Clears the Canvas.
-        
+
         Once you have a picture drawn, you can zoom in and out and move about
         the picture. There is a tool bar with three tools that can be
         selected. 
         Once you have a picture drawn, you can zoom in and out and move about
         the picture. There is a tool bar with three tools that can be
         selected. 
-        
+
         The magnifying glass with the plus is the zoom in tool. Once selected,
         if you click the image, it will zoom in, centered on where you
         clicked. If you click and drag the mouse, you will get a rubber band
         box, and the image will zoom to fit that box when you release it.
         The magnifying glass with the plus is the zoom in tool. Once selected,
         if you click the image, it will zoom in, centered on where you
         clicked. If you click and drag the mouse, you will get a rubber band
         box, and the image will zoom to fit that box when you release it.
-        
+
         The magnifying glass with the minus is the zoom out tool. Once selected,
         if you click the image, it will zoom out, centered on where you
         clicked. (note that this takes a while when you are looking at the map,
         as it has a LOT of lines to be drawn. The image is double buffered, so
         you don't see the drawing in progress)
         The magnifying glass with the minus is the zoom out tool. Once selected,
         if you click the image, it will zoom out, centered on where you
         clicked. (note that this takes a while when you are looking at the map,
         as it has a LOT of lines to be drawn. The image is double buffered, so
         you don't see the drawing in progress)
-        
+
         The hand is the move tool. Once selected, if you click and drag on the
         image, it will move so that the part you clicked on ends up where you
         release the mouse. Nothing is changed while you are dragging. The
         drawing is too slow for that.
         The hand is the move tool. Once selected, if you click and drag on the
         image, it will move so that the part you clicked on ends up where you
         release the mouse. Nothing is changed while you are dragging. The
         drawing is too slow for that.
-        
+
         I'd like the cursor to change as you change tools, but the stock
         wxCursors didn't include anything I liked, so I stuck with the
         pointer. Please let me know if you have any nice cursor images for me to
         use.
         I'd like the cursor to change as you change tools, but the stock
         wxCursors didn't include anything I liked, so I stuck with the
         pointer. Please let me know if you have any nice cursor images for me to
         use.
-        
-        
+
+
         Any bugs, comments, feedback, questions, and especially code are welcome:
         Any bugs, comments, feedback, questions, and especially code are welcome:
-        
+
         -Chris Barker
         -Chris Barker
-        
+
         Chris.Barker@noaa.gov
         Chris.Barker@noaa.gov
-    
+
         """
         """
-        
+
+        def __init__(self, *args, **kwargs):
+            wx.App.__init__(self, *args, **kwargs)
+
         def OnInit(self):
         def OnInit(self):
-            global colors
-            wxPython.lib.colourdb.updateColourDB()
-            colors = wxPython.lib.colourdb.getColourList()
-            
-            frame = DrawFrame(None, -1, "FloatCanvas Demo App",
-                              wx.DefaultPosition, (700,700))
-    
+            wx.InitAllImageHandlers()
+            DrawFrame = BuildDrawFrame()
+            frame = DrawFrame(None, -1, "FloatCanvas Demo App",wx.DefaultPosition,(700,700))
+
             self.SetTopWindow(frame)
             self.SetTopWindow(frame)
-    
+            frame.Show()
+
+            ## check to see if the demo is set to start in a particular mode.
+            if StartUpDemo == "text":
+                frame.TestText()
+            elif StartUpDemo == "stext":
+                frame.TestScaledText()
+            elif StartUpDemo == "stextbox":
+                frame.TestScaledTextBox()
+            elif StartUpDemo == "bitmap":
+                frame.TestBitmap()
+            elif StartUpDemo == "all":
+                frame.DrawTest()
+            elif StartUpDemo == "map":
+                frame.DrawMap()
+            elif StartUpDemo == "hit":
+                frame.TestHitTest()
+            elif StartUpDemo == "hitf":
+                "starting TestHitTestForeground"
+                frame.TestHitTestForeground()
+            elif StartUpDemo == "animate":
+                "starting TestAnimation"
+                frame.TestAnimation()
+            elif StartUpDemo == "speed":
+                "starting SpeedTest"
+                frame.SpeedTest()
+            elif StartUpDemo == "temp":
+                "starting temp Test"
+                frame.TempTest()
+            elif StartUpDemo == "props":
+                "starting PropertiesChange Test"
+                frame.PropertiesChangeTest()
+            elif StartUpDemo == "arrow":
+                "starting arrow Test"
+                frame.ArrowTest()
+            elif StartUpDemo == "hide":
+                "starting Hide Test"
+                frame.HideTest()
+
             return True
             return True
-                
-    def Read_MapGen(filename,stats = 0,AllLines=0):
-        """
-        This function reads a MapGen Format file, and
-        returns a list of NumPy arrays with the line segments in them.
-        
-        Each NumPy array in the list is an NX2 array of Python Floats.
-        
-        The demo should have come with a file, "world.dat" that is the
-        shorelines of the whole world, in MapGen format.
-        
-        """
-        import string
-        from Numeric import array
-        file = open(filename,'rt')
-        data = file.readlines()
-        data = map(string.strip,data)
-        
-        Shorelines = []
-        segment = []
-        for line in data:
-            if line:
-                if line == "# -b": #New segment beginning
-                    if segment: Shorelines.append(array(segment))
-                    segment = []
-                else:
-                    segment.append(map(float,string.split(line)))
-        if segment: Shorelines.append(array(segment))
-        
-        if stats:
-            NumSegments = len(Shorelines)
-            NumPoints = 0
-            for segment in Shorelines:
-                NumPoints = NumPoints + len(segment)
-            AvgPoints = NumPoints / NumSegments
-            print "Number of Segments: ", NumSegments
-            print "Average Number of Points per segment: ",AvgPoints
-        if AllLines:
-            Lines = []
-            for segment in Shorelines:
-                Lines.append(segment[0])
-                for point in segment[1:-1]:
-                    Lines.append(point)
-                    Lines.append(point)
-                Lines.append(segment[-1])
-            #print Shorelines
-            #for point in Lines: print point
-            return Lines
-        else:
-            return Shorelines
-
-
-    #----------------------------------------------------------------------
-    
+
+    app = DemoApp(False)# put in True if you want output to go to it's own window.
+    app.MainLoop()
+
+else:
+    # It's not running stand-alone, set up for wxPython demo.
+    # don't  neeed wxversion here.
+    import wx
+    if not haveNumeric:
+        ## 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
+
+                note1 = wx.StaticText(self, -1, errorText)
+                note2 = wx.StaticText(self, -1, "This is what the FloatCanvas can look like:")
+                S = wx.BoxSizer(wx.VERTICAL)
+                S.Add((10, 10), 1)
+                S.Add(note1, 0, wx.ALIGN_CENTER)
+                S.Add(note2, 0, wx.ALIGN_CENTER | wx.BOTTOM, 4)
+                S.Add(wx.StaticBitmap(self,-1,images.getFloatCanvasBitmap()),0,wx.ALIGN_CENTER)
+                S.Add((10, 10), 1)
+                self.SetSizer(S)
+                self.Layout()
+
+    else:
+        ## TestPanel and runTest used for integration into wxPython Demo
+        class TestPanel(wx.Panel):
+            def __init__(self, parent, log):
+                self.log = log
+                wx.Panel.__init__(self, parent, -1)
+                note1 = wx.StaticText(self, -1, "The FloatCanvas Demo needs")
+                note2 = wx.StaticText(self, -1, "a separate frame")
+                b = wx.Button(self, -1, "Open Demo Frame Now")
+                b.Bind(wx.EVT_BUTTON, self.OnButton)
+
+                S = wx.BoxSizer(wx.VERTICAL)
+                S.Add((10, 10), 1)
+                S.Add(note1, 0, wx.ALIGN_CENTER)
+                S.Add(note2, 0, wx.ALIGN_CENTER | wx.BOTTOM, 5)
+                S.Add(b, 0, wx.ALIGN_CENTER | wx.ALL, 5)
+                S.Add((10, 10), 1)
+                self.SetSizer(S)
+                self.Layout()
+
+            def OnButton(self, evt):
+                DrawFrame = BuildDrawFrame()
+                frame = DrawFrame(None, -1, "FloatCanvas Drawing Window",wx.DefaultPosition,(500,500))
+
+                #win = wx.lib.plot.TestFrame(self, -1, "PlotCanvas Demo")
+                frame.Show()
+                frame.DrawTest()
+
     def runTest(frame, nb, log):
     def runTest(frame, nb, log):
-        """
-        This method is used by the wxPython Demo Framework for integrating
-        this demo with the rest.
-        """
-        global colors
-        wxPython.lib.colourdb.updateColourDB()
-        colors = wxPython.lib.colourdb.getColourList()
+        win = TestPanel(nb, log)
+        return win
+
+    # import to get the doc
+    from wx.lib import floatcanvas
+    overview = floatcanvas.__doc__
 
 
-        win = DrawFrame(None, -1, "FloatCanvas Drawing Window",
-                        wx.DefaultPosition, (500,500))
-        frame.otherWin = win
-        win.Show(True)
 
 
 
 
 
 
-    
-    ## for the wxPython demo:
-    overview = floatcanvas.FloatCanvas.__doc__
 
 
 
 
-      
-if __name__ == "__main__":
-    if not haveNumeric:
-        print errorText
-    else:
-        app = DemoApp(0)
 
 
-        import  wx.lib.colourdb
-        wx.lib.colourdb.updateColourDB()
-        colors = wx.lib.colourdb.getColourList()
 
 
-        app.MainLoop()
-    
-    
-    
-