]> git.saurik.com Git - wxWidgets.git/blobdiff - wxPython/wx/lib/floatcanvas.py
New style
[wxWidgets.git] / wxPython / wx / lib / floatcanvas.py
index 1fc4e66d8a1be71c059bad807f23c8a12ab299b4..79481c9977276dba87efaa3853571e46a9db5e9f 100644 (file)
+import wx
+
+from Numeric import array,Float,cos,pi,sum,minimum,maximum,Int32
+from time import clock, sleep
+import types
+import os        
+
+ID_ZOOM_IN_BUTTON = wx.NewId()
+ID_ZOOM_OUT_BUTTON = wx.NewId()
+ID_ZOOM_TO_FIT_BUTTON = wx.NewId()
+ID_MOVE_MODE_BUTTON = wx.NewId()
+ID_TEST_BUTTON = wx.NewId()
+
+ID_ABOUT_MENU = wx.NewId()          
+ID_EXIT_MENU  = wx.NewId() 
+ID_ZOOM_TO_FIT_MENU = wx.NewId()
+ID_DRAWTEST_MENU = wx.NewId()
+ID_DRAWMAP_MENU = wx.NewId()
+ID_CLEAR_MENU = wx.NewId()
+
+ID_TEST = wx.NewId()
+
+
+### These are some functions for bitmaps of icons.
+import cPickle, zlib
+
+def GetHandData():
+    return cPickle.loads(zlib.decompress(
+'x\xda\xd3\xc8)0\xe4\nV72T\x00!\x05Cu\xae\xc4`u=\x85d\x05\xa7\x9c\xc4\xe4l0O\
+\x01\xc8S\xb6t\x06A(\x1f\x0b\xa0\xa9\x8c\x9e\x1e6\x19\xa0\xa8\x1e\x88\xd4C\
+\x97\xd1\x83\xe8\x80 \x9c2zh\xa6\xc1\x11X\n\xab\x8c\x02\x8a\x0cD!\x92\x12\
+\x98\x8c\x1e\x8a\x8b\xd1d\x14\xf4\x90%\x90LC\xf6\xbf\x1e\xba\xab\x91%\xd0\
+\xdc\x86C\x06\xd9m\xe8!\xaa\x87S\x86\x1a1\xa7\x07\x00v\x0f[\x17' ))
+
+def GetHandBitmap():
+    return wx.BitmapFromXPMData(GetHandData())
+
+#----------------------------------------------------------------------
+def GetPlusData():
+    return cPickle.loads(zlib.decompress(
+'x\xda\xd3\xc8)0\xe4\nV72T\x00!\x05Cu\xae\xc4`u=\x85d\x05\xa7\x9c\xc4\xe4l0O\
+\x01\xc8S\xb6t\x06A(\x1f\x0b RF\x0f\x08\xb0\xc9@D\xe1r\x08\x19\xb8j=l2`\r\
+\xe82HF\xe9a\xc8\xe8\xe9A\x9c@\x8a\x0c\x0e\xd3p\xbb\x00\x8f\xab\xe1>\xd5\xd3\
+\xc3\x15:P)l!\n\x91\xc2\x1a\xd6`)\xec\xb1\x00\x92\xc2\x11?\xb8e\x88\x8fSt\
+\x19=\x00\x82\x16[\xf7' ))
+
+def GetPlusBitmap():
+    return wx.BitmapFromXPMData(GetPlusData())
+
+#----------------------------------------------------------------------
+def GetMinusData():
+    return cPickle.loads(zlib.decompress(
+'x\xda\xd3\xc8)0\xe4\nV72T\x00!\x05Cu\xae\xc4`u=\x85d\x05\xa7\x9c\xc4\xe4l0O\
+\x01\xc8S\xb6t\x06A(\x1f\x0b RF\x0f\x08\xb0\xc9@D\xe1r\x08\x19\xb8j=\xa2e\
+\x10\x16@\x99\xc82zz\x10\'\x90"\x83\xc34r\xdc\x86\xf0\xa9\x9e\x1e\xae\xd0\
+\x81Ja\x0bQ\x88\x14\xd6\xb0\x06Ka\x8f\x05\x90\x14\x8e\xf8\xc1-C|\x9c\xa2\xcb\
+\xe8\x01\x00\xed\x0f[\x87' ))
+
+def GetMinusBitmap():
+    return wx.BitmapFromXPMData(GetMinusData())
+
+## This is a bunch of stuff for implimenting interactive use: catching
+## when objects are clicked on by the mouse, etc. I've made a start, so if
+## you are interesed in making that work, let me know, I may have gotten
+## it going by then
+
+#### I probably want a full set of events someday:
+## #### mouse over, right click, left click mouse up etc, etc.
+## ##FLOATCANVAS_EVENT_LEFT_DOWN = wx.NewEventType()
+## ##FLOATCANVAS_EVENT_LEFT_UP = wx.NewEventType()
+## ##FLOATCANVAS_EVENT_RIGHT_DOWN = wx.NewEventType()
+## ##FLOATCANVAS_EVENT_RIGHT_UP = wx.NewEventType()
+## ##FLOATCANVAS_EVENT_MOUSE_OVER = wx.NewEventType()
+
+##WXFLOATCANVASEVENT = wx.NewEventType()
+
+##def EVT_WXFLOATCANVASEVENT( window, function ): 
+
+##    """Your documentation here""" 
+
+##    window.Connect( -1, -1, WXFLOATCANVASEVENT, function ) 
+
+##class wxFloatCanvasObjectEvent(wx.PyCommandEvent):
+##    def __init__(self, WindowID,Object):
+##        wx.PyCommandEvent.__init__(self, WXFLOATCANVASEVENT, WindowID)
+##        self.Object = Object
+
+##    def Clone( self ): 
+##        self.__class__( self.GetId() ) 
+
+##class ColorGenerator:
+
+##    """ An instance of this class generates a unique color each time
+##    GetNextColor() is called. Someday I will use a proper Python
+##    generator for this class.
+
+##    The point of this generator is for the hit-test bitmap, each object
+##    needs to be a unique color. Also, each system can be running a
+##    different number of colors, and it doesn't appear to be possible to
+##    have a wxMemDC with a different colordepth as the screen so this
+##    generates colors far enough apart that they can be distinguished on
+##    a 16bit screen. Anything less than 16bits won't work.
+##    """
+
+##    def __init__(self,depth = 16):
+##        self.r = 0
+##        self.g = 0
+##        self.b = 0
+##        if depth == 16:
+##            self.step = 8
+##        elif depth >= 24:
+##            self.step = 1
+##        else:
+##            raise "ColorGenerator does not work with depth = %s"%depth
+
+##    def GetNextColor(self):
+##        step = self.step
+##        ##r,g,b = self.r,self.g,self.b
+##        self.r += step
+##        if self.r > 255:
+##            self.r = step
+##            self.g += step
+##            if self.g > 255:
+##                self.g = step
+##                self.b += step
+##                if self.b > 255:
+##                    ## fixme: this should be a derived exception
+##                    raise "Too many objects for HitTest"
+##        return (self.r,self.g,self.b)
+
+
+class draw_object:
+        """
+        This is the base class for all the objects that can be drawn.
+        
+        each object has the following properties; (incomplete)
+        
+        BoundingBox :  is of the form: array((min_x,min_y),(max_x,max_y)) 
+        Pen
+        Brush
+
+        """
+
+        def __init__(self,Foreground  = 0):
+            self.Foreground = Foreground
+
+            self._Canvas = None
+
+        # I pre-define all these as class variables to provide an easier
+        # interface, and perhaps speed things up by caching all the Pens
+        # and Brushes, although that may not help, as I think wx now
+        # does that on it's own. Send me a note if you know!
+
+        BrushList = {
+                ( None,"Transparent")  : wx.TRANSPARENT_BRUSH,
+                ("Blue","Solid")       : wx.BLUE_BRUSH,
+                ("Green","Solid")      : wx.GREEN_BRUSH,
+                ("White","Solid")      : wx.WHITE_BRUSH,
+                ("Black","Solid")      : wx.BLACK_BRUSH,
+                ("Grey","Solid")       : wx.GREY_BRUSH,
+                ("MediumGrey","Solid") : wx.MEDIUM_GREY_BRUSH,
+                ("LightGrey","Solid")  : wx.LIGHT_GREY_BRUSH,
+                ("Cyan","Solid")       : wx.CYAN_BRUSH,
+                ("Red","Solid")        : wx.RED_BRUSH
+                        }
+        PenList = {
+                (None,"Transparent",1)   : wx.TRANSPARENT_PEN,
+                ("Green","Solid",1)      : wx.GREEN_PEN,
+                ("White","Solid",1)      : wx.WHITE_PEN,
+                ("Black","Solid",1)      : wx.BLACK_PEN,
+                ("Grey","Solid",1)       : wx.GREY_PEN,
+                ("MediumGrey","Solid",1) : wx.MEDIUM_GREY_PEN,
+                ("LightGrey","Solid",1)  : wx.LIGHT_GREY_PEN,
+                ("Cyan","Solid",1)       : wx.CYAN_PEN,
+                ("Red","Solid",1)        : wx.RED_PEN
+                }
+        
+        FillStyleList = {
+                "Transparent"    : wx.TRANSPARENT,
+                "Solid"          : wx.SOLID,
+                "BiDiagonalHatch": wx.BDIAGONAL_HATCH,
+                "CrossDiagHatch" : wx.CROSSDIAG_HATCH,
+                "FDiagonal_Hatch": wx.FDIAGONAL_HATCH,
+                "CrossHatch"     : wx.CROSS_HATCH,
+                "HorizontalHatch": wx.HORIZONTAL_HATCH,
+                "VerticalHatch"  : wx.VERTICAL_HATCH
+                }
+        
+        LineStyleList = {
+                "Solid"      : wx.SOLID,
+                "Transparent": wx.TRANSPARENT,
+                "Dot"        : wx.DOT,
+                "LongDash"   : wx.LONG_DASH,
+                "ShortDash"  : wx.SHORT_DASH,
+                "DotDash"    : wx.DOT_DASH,
+                }
+        
+        def SetBrush(self,FillColor,FillStyle):
+            if FillColor is None or FillStyle is None:
+                self.Brush = wx.TRANSPARENT_BRUSH
+                self.FillStyle = "Transparent"
+            else:
+                if not self.BrushList.has_key((FillColor,FillStyle)):
+                    self.BrushList[(FillColor,FillStyle)] = wx.Brush(FillColor,self.FillStyleList[FillStyle])
+                self.Brush = self.BrushList[(FillColor,FillStyle)]
+                
+        def SetPen(self,LineColor,LineStyle,LineWidth):
+            if (LineColor is None) or (LineStyle is None):
+                self.Pen = wx.TRANSPARENT_PEN
+                self.LineStyle = 'Transparent'
+            else:
+                if not self.PenList.has_key((LineColor,LineStyle,LineWidth)):
+                    self.PenList[(LineColor,LineStyle,LineWidth)] = wx.Pen(LineColor,LineWidth,self.LineStyleList[LineStyle])
+                self.Pen = self.PenList[(LineColor,LineStyle,LineWidth)]
+
+        def SetPens(self,LineColors,LineStyles,LineWidths):
+            """
+            This method used when an object could have a list of pens, rather than just one
+            It is used for LineSet, and perhaps others in the future.
+
+            fixme: this is really kludgy, there has got to be a better way!
+            
+            """
+
+            length = 1
+            if type(LineColors) == types.ListType:
+                length = len(LineColors)
+            else:
+                LineColors = [LineColors]
+
+            if type(LineStyles) == types.ListType:
+                length = len(LineStyles)
+            else:
+                LineStyles = [LineStyles]
+
+            if type(LineWidths) == types.ListType:
+                length = len(LineWidths)
+            else:
+                LineWidths = [LineWidths]
+
+            if length > 1:
+                if len(LineColors) == 1:
+                    LineColors = LineColors*length
+                if len(LineStyles) == 1:
+                    LineStyles = LineStyles*length
+                if len(LineWidths) == 1:
+                    LineWidths = LineWidths*length
+
+            self.Pens = []
+            for (LineColor,LineStyle,LineWidth) in zip(LineColors,LineStyles,LineWidths):
+                if LineColor is None or LineStyle is None:
+                    self.Pens.append(wx.TRANSPARENT_PEN)
+                    # what's this for?> self.LineStyle = 'Transparent'
+                if not self.PenList.has_key((LineColor,LineStyle,LineWidth)):
+                    Pen = wx.Pen(LineColor,LineWidth,self.LineStyleList[LineStyle])
+                    self.Pens.append(Pen)
+                else:
+                    self.Pens.append(self.PenList[(LineColor,LineStyle,LineWidth)])
+            if length == 1:
+                self.Pens = self.Pens[0]
+
+        def PutInBackground(self):
+            if self._Canvas and self.Foreground:
+                self._Canvas._TopDrawList.remove(self)
+                self._Canvas._DrawList.append(self)
+                self._Canvas._BackgroundDirty = 1
+                self.Foreground = 0
+
+        def PutInForeground(self):
+            if self._Canvas and (not self.Foreground):
+                self._Canvas._TopDrawList.append(self)
+                self._Canvas._DrawList.remove(self)
+                self._Canvas._BackgroundDirty = 1
+                self.Foreground = 1
+            
+        
+class Polygon(draw_object):
+
+    """
+
+    The Polygon class takes a list of 2-tuples, or a NX2 NumPy array of
+    point coordinates.  so that Points[N][0] is the x-coordinate of
+    point N and Points[N][1] is the y-coordinate or Points[N,0] is the
+    x-coordinate of point N and Points[N,1] is the y-coordinate for
+    arrays.
+
+    """
+    def __init__(self,Points,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground = 0):
+        draw_object.__init__(self,Foreground)
+        self.Points = array(Points,Float)
+        self.BoundingBox = array(((min(self.Points[:,0]),min(self.Points[:,1])),(max(self.Points[:,0]),max(self.Points[:,1]))),Float)
+
+        self.LineColor = LineColor
+        self.LineStyle = LineStyle
+        self.LineWidth = LineWidth
+        self.FillColor = FillColor
+        self.FillStyle = FillStyle
+
+        self.SetPen(LineColor,LineStyle,LineWidth)
+        self.SetBrush(FillColor,FillStyle)
+
+
+    def _Draw(self,dc,WorldToPixel,ScaleFunction):
+        Points = WorldToPixel(self.Points)
+        dc.SetPen(self.Pen)
+        dc.SetBrush(self.Brush)
+        #dc.DrawPolygon(map(lambda x: (x[0],x[1]), Points.tolist()))
+        dc.DrawPolygon(Points)
+
+class PolygonSet(draw_object):
+    """
+    The PolygonSet class takes a Geometry.Polygon object.
+    so that Points[N] = (x1,y1) and Points[N+1] = (x2,y2). N must be an even number!
+    
+    it creates a set of line segments, from (x1,y1) to (x2,y2)
+    
+    """
+    
+    def __init__(self,PolySet,LineColors,LineStyles,LineWidths,FillColors,FillStyles,Foreground = 0):
+        draw_object.__init__(self, Foreground)
+
+        ##fixme: there should be some error checking for everything being the right length.
+
+        
+        self.Points = array(Points,Float)
+        self.BoundingBox = array(((min(self.Points[:,0]),min(self.Points[:,1])),(max(self.Points[:,0]),max(self.Points[:,1]))),Float)
+
+        self.LineColors = LineColors
+        self.LineStyles = LineStyles
+        self.LineWidths = LineWidths
+        self.FillColors = FillColors
+        self.FillStyles = FillStyles
+
+        self.SetPens(LineColors,LineStyles,LineWidths)
+
+    def _Draw(self,dc,WorldToPixel,ScaleFunction):
+        Points = WorldToPixel(self.Points)
+        Points.shape = (-1,4)
+        dc.DrawLineList(Points,self.Pens)
+
+class Line(draw_object):
+    """
+    The Line class takes a list of 2-tuples, or a NX2 NumPy array of point coordinates.
+    so that Points[N][0] is the x-coordinate of point N and Points[N][1] is the y-coordinate
+    or  Points[N,0] is the x-coordinate of point N and Points[N,1] is the y-coordinate for arrays.
+
+    It will draw a straight line if there are two points, and a polyline if there are more than two.
+
+    """
+    def __init__(self,Points,LineColor,LineStyle,LineWidth,Foreground = 0):
+        draw_object.__init__(self, Foreground)
+
+        self.Points = array(Points,Float)
+        self.BoundingBox = array(((min(self.Points[:,0]),min(self.Points[:,1])),(max(self.Points[:,0]),max(self.Points[:,1]))),Float)
+
+        self.LineColor = LineColor
+        self.LineStyle = LineStyle
+        self.LineWidth = LineWidth
+
+        self.SetPen(LineColor,LineStyle,LineWidth)
+
+    def SetPoints(self,Points):
+        self.Points = Points
+        self.BoundingBox = array(((min(self.Points[:,0]),min(self.Points[:,1])),(max(self.Points[:,0]),max(self.Points[:,1]))),Float)
+        if self._Canvas:
+            # It looks like this shouldn't be private
+            self._Canvas.BoundingBoxDirty = 1
+            
+    def _Draw(self,dc,WorldToPixel,ScaleFunction):
+        Points = WorldToPixel(self.Points)
+        dc.SetPen(self.Pen)
+        #dc.DrawLines(map(lambda x: (x[0],x[1]), Points.tolist()))
+        dc.DrawLines(Points)
+
+
+class LineSet(draw_object):
+    """
+    The LineSet class takes a list of 2-tuples, or a NX2 NumPy array of point coordinates.
+    so that Points[N] = (x1,y1) and Points[N+1] = (x2,y2). N must be an even number!
+    
+    it creates a set of line segments, from (x1,y1) to (x2,y2)
+    
+    """
+    
+    def __init__(self,Points,LineColors,LineStyles,LineWidths,Foreground = 0):
+        draw_object.__init__(self, Foreground)
+
+        NumLines = len(Points) / 2
+        ##fixme: there should be some error checking for everything being the right length.
+
+        
+        self.Points = array(Points,Float)
+        self.BoundingBox = array(((min(self.Points[:,0]),min(self.Points[:,1])),(max(self.Points[:,0]),max(self.Points[:,1]))),Float)
+
+        self.LineColors = LineColors
+        self.LineStyles = LineStyles
+        self.LineWidths = LineWidths
+
+        self.SetPens(LineColors,LineStyles,LineWidths)
+
+    def _Draw(self,dc,WorldToPixel,ScaleFunction):
+        Points = WorldToPixel(self.Points)
+        Points.shape = (-1,4)
+        dc.DrawLineList(Points,self.Pens)
+
+class PointSet(draw_object):
+        """
+        The PointSet class takes a list of 2-tuples, or a NX2 NumPy array of point coordinates.
+        so that Points[N][0] is the x-coordinate of point N and Points[N][1] is the y-coordinate
+        or  Points[N,0] is the x-coordinate of point N and Points[N,1] is the y-coordinate for arrays.
+        
+        Each point will be drawn the same color and Diameter. The Diameter is in screen points,
+        not world coordinates.
+        
+        """
+        def __init__(self,Points,Color,Diameter,Foreground = 0):
+            draw_object.__init__(self,Foreground)
+
+            self.Points = array(Points,Float)
+            self.Points.shape = (-1,2) # Make sure it is a NX2 array, even if there is only one point
+            self.BoundingBox = array(((min(self.Points[:,0]),min(self.Points[:,1])),(max(self.Points[:,0]),max(self.Points[:,1]))),Float)
+            
+            self.Color = Color
+            self.Diameter = Diameter
+            
+            self.SetPen(Color,"Solid",1)
+            self.SetBrush(Color,"Solid")
+
+        def SetPoints(self,Points):
+            self.Points = Points
+            self.BoundingBox = array(((min(self.Points[:,0]),min(self.Points[:,1])),(max(self.Points[:,0]),max(self.Points[:,1]))),Float)
+            if self._Canvas:
+                # It looks like this shouldn't be private
+                self._Canvas.BoundingBoxDirty = 1
+            
+        def _Draw(self,dc,WorldToPixel,ScaleFunction):
+            dc.SetPen(self.Pen)
+            Points = WorldToPixel(self.Points)
+            if self.Diameter <= 1:
+                dc.DrawPointList(Points)
+            elif self.Diameter <= 2:
+                # A Little optimization for a diameter2 - point
+                dc.DrawPointList(Points)
+                dc.DrawPointList(Points + (1,0))
+                dc.DrawPointList(Points + (0,1))
+                dc.DrawPointList(Points + (1,1))
+            else:
+                dc.SetBrush(self.Brush)
+                radius = int(round(self.Diameter/2))
+                for (x,y) in Points:
+                    dc.DrawEllipse(((x - radius), (y - radius)), (self.Diameter, self.Diameter))
+
+
+                    
+class Dot(draw_object):
+    """
+    The Dot class takes an x.y coordinate pair, and the Diameter of the circle.
+    The Diameter is in pixels, so it won't change with zoom.
+
+    Also Fill and line data
+
+    """
+    def __init__(self,x,y,Diameter,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground = 0):
+        draw_object.__init__(self,Foreground)
+
+        self.X = x
+        self.Y = y
+        self.Diameter = Diameter
+        # NOTE: the bounding box does not include the diameter of the dot, as that is in pixel coords.
+        # If this is  a problem, perhaps you should use a circle, instead!
+        self.BoundingBox = array(((x,y),(x,y)),Float)
+
+        self.LineColor = LineColor
+        self.LineStyle = LineStyle
+        self.LineWidth = LineWidth
+        self.FillColor = FillColor
+        self.FillStyle = FillStyle
+
+        self.SetPen(LineColor,LineStyle,LineWidth)
+        self.SetBrush(FillColor,FillStyle)
+
+    def _Draw(self,dc,WorldToPixel,ScaleFunction):
+        dc.SetPen(self.Pen)
+        dc.SetBrush(self.Brush)
+        radius = int(round(self.Diameter/2))
+        (X,Y) = WorldToPixel((self.X,self.Y))
+        dc.DrawEllipse(((X - radius), (Y - radius)), (self.Diameter, self.Diameter))
+
+
+class Rectangle(draw_object):
+    def __init__(self,x,y,width,height,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground = 0):
+        draw_object.__init__(self,Foreground)
+
+        self.X = x
+        self.Y = y
+        self.Width = width
+        self.Height = height
+        self.BoundingBox = array(((x,y),(x+width,y+height)),Float)
+        self.LineColor = LineColor
+        self.LineStyle = LineStyle
+        self.LineWidth = LineWidth
+        self.FillColor = FillColor
+        self.FillStyle = FillStyle
+
+        self.SetPen(LineColor,LineStyle,LineWidth)
+        self.SetBrush(FillColor,FillStyle)
+
+    def _Draw(self,dc,WorldToPixel,ScaleFunction):
+        (X,Y) = WorldToPixel((self.X,self.Y))
+        (Width,Height) = ScaleFunction((self.Width,self.Height))
+
+        dc.SetPen(self.Pen)
+        dc.SetBrush(self.Brush)
+        dc.DrawRectangle((X,Y), (Width,Height))
+
+class Ellipse(draw_object):
+    def __init__(self,x,y,width,height,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground = 0):
+        draw_object.__init__(self,Foreground)
+
+        self.X = x
+        self.Y = y
+        self.Width = width
+        self.Height = height
+        self.BoundingBox = array(((x,y),(x+width,y+height)),Float)
+        self.LineColor = LineColor
+        self.LineStyle = LineStyle
+        self.LineWidth = LineWidth
+        self.FillColor = FillColor
+        self.FillStyle = FillStyle
+
+        self.SetPen(LineColor,LineStyle,LineWidth)
+        self.SetBrush(FillColor,FillStyle)
+
+    def _Draw(self,dc,WorldToPixel,ScaleFunction):
+        (X,Y) = WorldToPixel((self.X,self.Y))
+        (Width,Height) = ScaleFunction((self.Width,self.Height))
+
+        dc.SetPen(self.Pen)
+        dc.SetBrush(self.Brush)
+        dc.DrawEllipse((X,Y), (Width,Height))
+
+class Circle(draw_object):
+    def __init__(self,x,y,Diameter,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground = 0):
+        draw_object.__init__(self,Foreground)
+
+        self.X = x
+        self.Y = y
+        self.Diameter = Diameter
+        self.BoundingBox = array(((x-Diameter/2,y-Diameter/2),(x+Diameter/2,y+Diameter/2)),Float)
+        self.LineColor = LineColor
+        self.LineStyle = LineStyle
+        self.LineWidth = LineWidth
+        self.FillColor = FillColor
+        self.FillStyle = FillStyle
+
+        self.SetPen(LineColor,LineStyle,LineWidth)
+        self.SetBrush(FillColor,FillStyle)
+
+    def _Draw(self,dc,WorldToPixel,ScaleFunction):
+        (X,Y) = WorldToPixel((self.X,self.Y))
+        (Diameter,dummy) = ScaleFunction((self.Diameter,self.Diameter))
+
+        dc.SetPen(self.Pen)
+        dc.SetBrush(self.Brush)
+        dc.DrawEllipse((X-Diameter/2,Y-Diameter/2), (Diameter,Diameter))
+
+class Text(draw_object):
+    """
+
+    This class creates a text object, placed at the coordinates,
+    x,y. the "Position" argument is a two charactor string, indicating
+    where in relation to the coordinates the string should be oriented.
+
+    The first letter is:  t, c, or b, for top, center and bottom
+    The second letter is: l, c, or r, for left, center and right
+
+    I've provided arguments for Family, Style, and Weight of font, but
+    have not yet implimented them, so all text is:  wx.SWISS, wx.NORMAL, wx.NORMAL.
+    I'd love it if someone would impliment that!
+
+    The size is fixed, and does not scale with the drawing.
+
+    """
+    
+    def __init__(self,String,x,y,Size,ForeGround,BackGround,Family,Style,Weight,Underline,Position,Foreground = 0):
+        draw_object.__init__(self,Foreground)
+
+        self.String = String
+        self.Size = Size
+
+        self.ForeGround = ForeGround
+        if BackGround is None:
+            self.BackGround = None
+        else:
+            self.BackGround = BackGround
+        self.Family = Family
+        self.Style  = Style
+        self.Weight = Weight
+        self.Underline = Underline
+        self.Position = Position
+        # fixme: this should use the passed in parameters!
+        self.Font = wx.Font(Size, wx.MODERN, wx.NORMAL, wx.NORMAL, Underline, )
+
+        self.BoundingBox = array(((x,y),(x,y)),Float)
+
+        self.X = x
+        self.Y = y
+        self.x_shift = None
+        self.y_shift = None
+
+    def _Draw(self,dc,WorldToPixel,ScaleFunction):
+        (X,Y) = WorldToPixel((self.X,self.Y))
+        dc.SetFont(self.Font)
+        dc.SetTextForeground(self.ForeGround)
+        if self.BackGround:
+            dc.SetBackgroundMode(wx.SOLID)
+            dc.SetTextBackground(self.BackGround)
+        else:
+            dc.SetBackgroundMode(wx.TRANSPARENT)
+
+        # compute the shift, and adjust the coordinates, if neccesary
+        # This had to be put in here, becsuse there is no wx.DC during __init__
+        if self.x_shift is None or self.y_shift is None:
+            if self.Position == 'tl':
+                x_shift,y_shift = 0,0
+            else:
+                (w,h) = dc.GetTextExtent(self.String)
+                if self.Position[0] == 't':
+                    y_shift = 0
+                elif self.Position[0] == 'c':
+                    y_shift = h/2
+                elif self.Position[0] == 'b':
+                    y_shift = h
+                else:
+                    ##fixme: this should be a real derived exception
+                    raise "Invalid value for Text Object Position Attribute"
+                if self.Position[1] == 'l':
+                    x_shift = 0
+                elif self.Position[1] == 'c':
+                    x_shift = w/2
+                elif self.Position[1] == 'r':
+                    x_shift = w
+                else:
+                    ##fixme: this should be a real derived exception
+                    raise "Invalid value for Text Object Position Attribute"
+            self.x_shift = x_shift
+            self.y_shift = y_shift
+        dc.DrawText(self.String, (X-self.x_shift, Y-self.y_shift))
+
+
+#---------------------------------------------------------------------------
+    
+class FloatCanvas(wx.Panel):
+    """
+    FloatCanvas.py
+
+    This is a high level window for drawing maps and anything else in an
+    arbitrary coordinate system.
+
+    The goal is to provide a convenient way to draw stuff on the screen
+    without having to deal with handling OnPaint events, converting to pixel
+    coordinates, knowing about wxWindows brushes, pens, and colors, etc. It
+    also provides virtually unlimited zooming and scrolling
+
+    I am using it for two things:
+    1) general purpose drawing in floating point coordinates
+    2) displaying map data in Lat-long coordinates
+
+    If the projection is set to None, it will draw in general purpose
+    floating point coordinates. If the projection is set to 'FlatEarth', it
+    will draw a FlatEarth projection, centered on the part of the map that
+    you are viewing. You can also pass in your own projection function.
+
+    It is double buffered, so re-draws after the window is uncovered by something
+    else are very quick.
+
+    It relies on NumPy, which is needed for speed
+
+    Bugs and Limitations:
+        Lots: patches, fixes welcome
+
+    For Map drawing: It ignores the fact that the world is, in fact, a
+    sphere, so it will do strange things if you are looking at stuff near
+    the poles or the date line. so far I don't have a need to do that, so I
+    havn't bothered to add any checks for that yet.
+
+    Zooming:
+    I have set no zoom limits. What this means is that if you zoom in really 
+    far, you can get integer overflows, and get wierd results. It
+    doesn't seem to actually cause any problems other than wierd output, at
+    least when I have run it.
+
+    Speed:
+    I have done a couple of things to improve speed in this app. The one
+    thing I have done is used NumPy Arrays to store the coordinates of the
+    points of the objects. This allowed me to use array oriented functions
+    when doing transformations, and should provide some speed improvement
+    for objects with a lot of points (big polygons, polylines, pointsets).
+
+    The real slowdown comes when you have to draw a lot of objects, because
+    you have to call the wx.DC.DrawSomething call each time. This is plenty
+    fast for tens of objects, OK for hundreds of objects, but pretty darn
+    slow for thousands of objects.
+
+    The solution is to be able to pass some sort of object set to the DC
+    directly. I've used DC.DrawPointList(Points), and it helped a lot with
+    drawing lots of points. I havn't got a LineSet type object, so I havn't
+    used DC.DrawLineList yet. I'd like to get a full set of DrawStuffList()
+    methods implimented, and then I'd also have a full set of Object sets
+    that could take advantage of them. I hope to get to it some day.
+
+    Copyright: Christopher Barker
+
+    License: Same as wxPython
+
+    Please let me know if you're using this!!!
+
+    Contact me at:
+
+    Chris.Barker@noaa.gov
+
+    """ 
+    
+    def __init__(self, parent, id = -1,
+                 size = wx.DefaultSize,
+                 ProjectionFun = None,
+                 BackgroundColor = "WHITE",
+                 Debug = 0,
+                 EnclosingFrame = None,
+                 UseToolbar = 1,
+                 UseBackground = 0,
+                 UseHitTest = 0):
+
+        wx.Panel.__init__( self, parent, id, wx.DefaultPosition, size)
+
+        if ProjectionFun == 'FlatEarth':
+            self.ProjectionFun = self.FlatEarthProjection 
+        elif type(ProjectionFun) == types.FunctionType:
+            self.ProjectionFun = ProjectionFun 
+        elif ProjectionFun is None:
+            self.ProjectionFun = lambda x=None: array( (1,1), Float)
+        else:
+            raise('Projectionfun must be either: "FlatEarth", None, or a function that takes the ViewPortCenter and returns a MapProjectionVector')
+
+        self.UseBackground = UseBackground
+        self.UseHitTest = UseHitTest
+
+        self.NumBetweenBlits = 40
+
+        ## you can have a toolbar with buttons for zoom-in, zoom-out and
+        ## move.  If you don't use the toolbar, you should provide your
+        ## own way of navigating the canvas
+        if UseToolbar:
+            ## Create the vertical sizer for the toolbar and Panel
+            box = wx.BoxSizer(wx.VERTICAL)
+            box.Add(self.BuildToolbar(), 0, wx.ALL | wx.ALIGN_LEFT | wx.GROW, 4)
+            
+            self.DrawPanel = wx.Window(self,-1,wx.DefaultPosition,wx.DefaultSize,wx.SUNKEN_BORDER)
+            box.Add(self.DrawPanel,1,wx.GROW)
+            
+            box.Fit(self)
+            self.SetAutoLayout(True)
+            self.SetSizer(box)
+        else:
+            self.DrawPanel = self
+
+        self.DrawPanel.BackgroundBrush = wx.Brush(BackgroundColor,wx.SOLID)
+
+        self.Debug = Debug
+
+        self.EnclosingFrame = EnclosingFrame
+        
+        wx.EVT_PAINT(self.DrawPanel, self.OnPaint)
+        wx.EVT_SIZE(self.DrawPanel, self.OnSize)
+        
+        wx.EVT_LEFT_DOWN(self.DrawPanel, self.LeftButtonEvent)
+        wx.EVT_LEFT_UP(self.DrawPanel, self.LeftButtonEvent)
+        wx.EVT_RIGHT_DOWN(self.DrawPanel, self.RightButtonEvent)
+        wx.EVT_MOTION(self.DrawPanel,    self.LeftButtonEvent)
+        
+        
+        self._DrawList = []
+        if self.UseBackground:
+            self._TopDrawList = []
+        self.BoundingBox = None
+        self.BoundingBoxDirty = 0
+        self.ViewPortCenter= array( (0,0), Float)
+        
+        self.MapProjectionVector = array( (1,1), Float) # No Projection to start!
+        self.TransformVector = array( (1,-1), Float) # default Transformation
+        
+        self.Scale = 1
+
+        self.GUIMode = None
+        self.StartRBBox = None
+        self.PrevRBBox = None
+        self.StartMove = None
+        self.PrevMoveBox = None
+        # called just to make sure everything is initialized
+        self.OnSize(None)
+
+        
+    def BuildToolbar(self):
+        tb = wx.ToolBar(self,-1)
+        self.ToolBar = tb
+        
+        tb.SetToolBitmapSize((23,23))
+        
+        tb.AddTool(ID_ZOOM_IN_BUTTON, GetPlusBitmap(), isToggle=True,shortHelpString = "Zoom In")
+        wx.EVT_TOOL(self, ID_ZOOM_IN_BUTTON, self.SetMode)
+        
+        tb.AddTool(ID_ZOOM_OUT_BUTTON, GetMinusBitmap(), isToggle=True,shortHelpString = "Zoom Out")
+        wx.EVT_TOOL(self, ID_ZOOM_OUT_BUTTON, self.SetMode)
+        
+        tb.AddTool(ID_MOVE_MODE_BUTTON, GetHandBitmap(), isToggle=True,shortHelpString = "Move")
+        wx.EVT_TOOL(self, ID_MOVE_MODE_BUTTON, self.SetMode)
+        
+        tb.AddSeparator()
+        
+        tb.AddControl(wx.Button(tb, ID_ZOOM_TO_FIT_BUTTON, "Zoom To Fit",wx.DefaultPosition, wx.DefaultSize))
+        wx.EVT_BUTTON(self, ID_ZOOM_TO_FIT_BUTTON, self.ZoomToFit)
+
+        tb.Realize()
+        return tb
+
+    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.SetGUIMode("ZoomIn")
+        elif event.GetId() == ID_ZOOM_OUT_BUTTON:
+            self.SetGUIMode("ZoomOut")
+        elif event.GetId() == ID_MOVE_MODE_BUTTON:
+            self.SetGUIMode("Move")
+
+    
+    def SetGUIMode(self,Mode):
+        if Mode in ["ZoomIn","ZoomOut","Move",None]:
+            self.GUIMode = Mode
+        else:
+            raise "Not a valid Mode"
+            
+    def FlatEarthProjection(self,CenterPoint):
+        return array((cos(pi*CenterPoint[1]/180),1),Float)
+        
+    def LeftButtonEvent(self,event):
+        if self.EnclosingFrame:
+            if event.Moving:
+                position = self.PixelToWorld((event.GetX(),event.GetY()))
+                self.EnclosingFrame.SetStatusText("%8.3f, %8.3f"%tuple(position))
+        if self.GUIMode:
+            if self.GUIMode == "ZoomIn":
+                if event.LeftDown():
+                    self.StartRBBox = (event.GetX(),event.GetY())
+                    self.PrevRBBox = None
+                elif event.Dragging() and event.LeftIsDown() and self.StartRBBox:
+                    x0,y0 = self.StartRBBox
+                    x1,y1 = event.GetX(),event.GetY()
+                    w, h = abs(x1-x0),abs(y1-y0)
+                    w = max(w,int(h*self.AspectRatio))
+                    h = int(w/self.AspectRatio)
+                    x_c, y_c = (x0+x1)/2 , (y0+y1)/2
+                    dc = wx.ClientDC(self.DrawPanel)
+                    dc.BeginDrawing()
+                    dc.SetPen(wx.Pen('WHITE', 2,wx.SHORT_DASH))
+                    dc.SetBrush(wx.TRANSPARENT_BRUSH)
+                    dc.SetLogicalFunction(wx.XOR)
+                    if self.PrevRBBox:
+                        dc.DrawRectangleXY(*self.PrevRBBox)
+                    dc.DrawRectangleXY(x_c-w/2,y_c-h/2,w,h)
+                    self.PrevRBBox = (x_c-w/2,y_c-h/2,w,h)
+                    dc.EndDrawing()
+                    
+                elif event.LeftUp() and self.StartRBBox :
+                    self.PrevRBBox = None
+                    EndRBBox = (event.GetX(),event.GetY())
+                    StartRBBox = self.StartRBBox
+                    # if mouse has moved less that ten pixels, don't use the box.
+                    if abs(StartRBBox[0] - EndRBBox[0]) > 10 and abs(StartRBBox[1] - EndRBBox[1]) > 10:
+                        EndRBBox = self.PixelToWorld(EndRBBox)
+                        StartRBBox = self.PixelToWorld(StartRBBox)
+                        BB = array(((min(EndRBBox[0],StartRBBox[0]), min(EndRBBox[1],StartRBBox[1])),
+                                    (max(EndRBBox[0],StartRBBox[0]), max(EndRBBox[1],StartRBBox[1]))),Float)
+                        self.ZoomToBB(BB)
+                    else:
+                        Center = self.PixelToWorld(StartRBBox)
+                        self.Zoom(1.5,Center)
+                    self.StartRBBox = None
+                    
+            if self.GUIMode == "ZoomOut":
+                if event.LeftDown():
+                    Center = self.PixelToWorld((event.GetX(),event.GetY()))
+                    self.Zoom(1/1.5,Center)
+            elif self.GUIMode == "Move":
+                if event.LeftDown():
+                    self.StartMove = array((event.GetX(),event.GetY()))
+                    self.PrevMoveBox = None
+                elif event.Dragging() and event.LeftIsDown() and self.StartMove:
+                    x_1,y_1 = event.GetX(),event.GetY()
+                    w, h = self.PanelSize
+                    x_tl, y_tl = x_1 - self.StartMove[0], y_1 - self.StartMove[1]
+                    dc = wx.ClientDC(self.DrawPanel)
+                    dc.BeginDrawing()
+                    dc.SetPen(wx.Pen('WHITE', 1,))
+                    dc.SetBrush(wx.TRANSPARENT_BRUSH)
+                    dc.SetLogicalFunction(wx.XOR)
+                    if self.PrevMoveBox:
+                        dc.DrawRectangleXY(*self.PrevMoveBox)
+                    dc.DrawRectangleXY(x_tl,y_tl,w,h)
+                    self.PrevMoveBox = (x_tl,y_tl,w,h)
+                    dc.EndDrawing()
+                  
+                elif event.LeftUp() and self.StartMove:
+                    self.PrevMoveBox = None
+                    StartMove = self.StartMove
+                    EndMove = array((event.GetX(),event.GetY()))
+                    if sum((StartMove-EndMove)**2) > 16:
+                        self.Move(StartMove-EndMove,'Pixel')
+                    self.StartMove = None
+                    
+    def RightButtonEvent(self,event):
+        if self.GUIMode:
+            if self.GUIMode == "ZoomIn":
+                Center = self.PixelToWorld((event.GetX(),event.GetY()))
+                self.Zoom(1/1.5,Center)
+            elif self.GUIMode == "ZoomOut":
+                Center = self.PixelToWorld((event.GetX(),event.GetY()))
+                self.Zoom(1.5,Center)
+            else:
+                event.Skip()
+        event.Skip()
+                
+    def MakeNewBuffers(self):
+        # Make new offscreen bitmap:
+        self._Buffer = wx.EmptyBitmap(self.PanelSize[0],self.PanelSize[1])
+        if self.UseBackground:
+            self._BackBuffer = wx.EmptyBitmap(self.PanelSize[0],self.PanelSize[1])
+            self._BackgroundDirty = 1
+        else:
+            pass
+                
+    def OnSize(self,event):
+        self.PanelSize  = array(self.DrawPanel.GetClientSizeTuple(),Int32)
+        try:
+            self.AspectRatio = self.PanelSize[0]/self.PanelSize[1]
+        except ZeroDivisionError:
+            self.AspectRatio = 1.0
+        self.MakeNewBuffers()
+        self.Draw()
+        
+    def OnPaint(self, event):
+        #dc = wx.BufferedPaintDC(self.DrawPanel, self._Buffer)
+        dc = wx.PaintDC(self.DrawPanel)
+        dc.DrawBitmap(self._Buffer, (0,0))
+
+    def Draw(self):
+        """
+        The Draw method gets pretty complicated because of all the buffers
+
+        There is a main buffer set up to double buffer the screen, so
+        you can get quick re-draws when the window gets uncovered.
+
+        If self.UseBackground is set, and an object is set up with the
+        "ForeGround" flag, then it gets drawn to the screen after blitting
+        the background. This is done so that you can have a complicated
+        background, but have something changing on the foreground,
+        without having to wait for the background to get re-drawn. This
+        can be used to support simple animation, for instance.
+        
+        """
+        if self.Debug: start = clock()
+        ScreenDC =  wx.ClientDC(self.DrawPanel)
+        ViewPortWorld = ( self.PixelToWorld((0,0)), self.PixelToWorld(self.PanelSize) )
+        ViewPortBB = array( ( minimum.reduce(ViewPortWorld), maximum.reduce(ViewPortWorld) ) )
+        if self.UseBackground:
+            dc = wx.MemoryDC()
+            dc.SelectObject(self._BackBuffer)
+            dc.SetBackground(self.DrawPanel.BackgroundBrush)
+            if self._DrawList:
+                if  self._BackgroundDirty:
+                    dc.BeginDrawing()
+                    dc.Clear()
+                    i = 0
+                    for Object in self._DrawList:
+                        if self.BBCheck(Object.BoundingBox,ViewPortBB):
+                            #print "object is in Bounding Box"
+                            i+=1
+                            Object._Draw(dc,self.WorldToPixel,self.ScaleFunction)
+                            if i % self.NumBetweenBlits == 0:
+                                ScreenDC.Blit((0, 0), self.PanelSize, dc, (0, 0))
+                    dc.EndDrawing()
+            else:
+                dc.Clear()
+            self._BackgroundDirty = 0
+            dc.SelectObject(self._Buffer)
+            dc.BeginDrawing()
+            ##Draw Background on Main Buffer:
+            dc.DrawBitmap(self._BackBuffer,0,0)
+            #Draw the OnTop stuff
+            i = 0
+            for Object in self._TopDrawList:
+                i+=1
+                Object._Draw(dc,self.WorldToPixel,self.ScaleFunction)
+                if i % self.NumBetweenBlits == 0:
+                    ScreenDC.Blit((0, 0), self.PanelSize, dc, (0, 0))
+            dc.EndDrawing()
+        else: # not using a Background DC
+            dc = wx.MemoryDC()
+            dc.SelectObject(self._Buffer)
+            dc.SetBackground(self.DrawPanel.BackgroundBrush)
+            if self._DrawList:
+                dc.BeginDrawing()
+                dc.Clear()
+                i = 0
+                for Object in self._DrawList:
+                    if self.BBCheck(Object.BoundingBox,ViewPortBB):
+                        #print "object is in Bounding Box"
+                        i+=1
+                        Object._Draw(dc,self.WorldToPixel,self.ScaleFunction)
+                        if i % self.NumBetweenBlits == 0:
+                            ScreenDC.Blit((0, 0), self.PanelSize, dc, (0, 0))
+                dc.EndDrawing()
+            else:
+                dc.Clear()
+        # now refresh the screen
+        #ScreenDC.DrawBitmap(self._Buffer,0,0) #NOTE: uisng DrawBitmap didn't work right on MSW
+        ScreenDC.Blit((0, 0), self.PanelSize, dc, (0, 0))
+
+        # If the canvas is in the middle of a zoom or move, the Rubber Band box needs to be re-drawn
+        if self.PrevRBBox:
+            ScreenDC.SetPen(wx.Pen('WHITE', 2,wx.SHORT_DASH))
+            ScreenDC.SetBrush(wx.TRANSPARENT_BRUSH)
+            ScreenDC.SetLogicalFunction(wx.XOR)
+            ScreenDC.DrawRectangleXY(*self.PrevRBBox)
+        elif self.PrevMoveBox:
+            ScreenDC.SetPen(wx.Pen('WHITE', 1,))
+            ScreenDC.SetBrush(wx.TRANSPARENT_BRUSH)
+            ScreenDC.SetLogicalFunction(wx.XOR)
+            ScreenDC.DrawRectangleXY(*self.PrevMoveBox)
+        if self.Debug: print "Drawing took %f seconds of CPU time"%(clock()-start)
+
+    def BBCheck(self, BB1, BB2):
+        """
+
+        BBCheck(BB1, BB2) returns True is the Bounding boxes intesect, False otherwise
+
+        """
+        if ( (BB1[1,0] > BB2[0,0]) and (BB1[0,0] < BB2[1,0]) and
+             (BB1[1,1] > BB2[0,1]) and (BB1[0,1] < BB2[1,1]) ):
+            return True
+        else:
+            return False
+
+    def Move(self,shift,CoordType):
+        """
+        move the image in the window.
+
+        shift is an (x,y) tuple, specifying the amount to shift in each direction
+
+        It can be in any of three coordinates: Panel, Pixel, World,
+        specified by the CoordType parameter
+
+        Panel coordinates means you want to shift the image by some
+        fraction of the size of the displaed image
+
+        Pixel coordinates means you want to shift the image by some number of pixels
+
+        World coordinates meand you want to shift the image by an amount
+        in Floating point world coordinates
+
+        """
+        
+        shift = array(shift,Float)
+        if CoordType == 'Panel':# convert from panel coordinates
+            shift = shift * array((-1,1),Float) *self.PanelSize/self.TransformVector
+        elif CoordType == 'Pixel': # convert from pixel coordinates
+            shift = shift/self.TransformVector
+        elif CoordType == 'World': # No conversion
+            pass
+        else:
+            raise 'CoordType must be either "Panel", "Pixel", or "World"'
+            
+        self.ViewPortCenter = self.ViewPortCenter + shift 
+        self.MapProjectionVector = self.ProjectionFun(self.ViewPortCenter)
+        self.TransformVector = array((self.Scale,-self.Scale),Float)* self.MapProjectionVector
+        self._BackgroundDirty = 1
+        self.Draw()
+        
+    def Zoom(self,factor,center = None):
+    
+        """
+        Zoom(factor, center) changes the amount of zoom of the image by factor.
+        If factor is greater than one, the image gets larger.
+        If factor is less than one, the image gets smaller.
+        
+        Center is a tuple of (x,y) coordinates of the center of the viewport, after zooming.
+        If center is not given, the center will stay the same.
+        
+        """
+        self.Scale = self.Scale*factor
+        if center:
+            self.ViewPortCenter = array(center,Float)
+        self.MapProjectionVector = self.ProjectionFun(self.ViewPortCenter)
+        self.TransformVector = array((self.Scale,-self.Scale),Float)* self.MapProjectionVector
+        self._BackgroundDirty = 1
+        self.Draw()
+        
+    def ZoomToFit(self,event):
+        self.ZoomToBB()
+        
+    def ZoomToBB(self,NewBB = None,DrawFlag = 1):
+
+        """
+
+        Zooms the image to the bounding box given, or to the bounding
+        box of all the objects on the canvas, if none is given.
+
+        """
+        
+        if NewBB:
+            BoundingBox = NewBB
+        else:
+            if self.BoundingBoxDirty:
+                self._ResetBoundingBox()
+            BoundingBox = self.BoundingBox
+        if BoundingBox:
+            self.ViewPortCenter = array(((BoundingBox[0,0]+BoundingBox[1,0])/2,
+                                                                     (BoundingBox[0,1]+BoundingBox[1,1])/2 ),Float)
+            self.MapProjectionVector = self.ProjectionFun(self.ViewPortCenter)
+            # Compute the new Scale
+            BoundingBox = BoundingBox * self.MapProjectionVector
+            try:
+                self.Scale = min((self.PanelSize[0]  / (BoundingBox[1,0]-BoundingBox[0,0])),
+                                        (self.PanelSize[1] / (BoundingBox[1,1]-BoundingBox[0,1])))*0.95
+            except ZeroDivisionError: # this will happen if the BB has zero width or height
+                try: #width
+                    self.Scale = (self.PanelSize[0]  / (BoundingBox[1,0]-BoundingBox[0,0]))*0.95
+                except ZeroDivisionError:
+                    try: # height
+                        self.Scale = (self.PanelSize[1]  / (BoundingBox[1,1]-BoundingBox[0,1]))*0.95
+                    except ZeroDivisionError: #zero size! (must be a single point)
+                        self.Scale = 1
+                        
+            self.TransformVector = array((self.Scale,-self.Scale),Float)* self.MapProjectionVector
+            if DrawFlag:
+                self._BackgroundDirty = 1
+                self.Draw()
+                
+    def RemoveObjects(self,Objects):
+        for Object in Objects:
+            self.RemoveObject(Object,ResetBB = 0)
+        self.BoundingBoxDirty = 1
+        
+    def RemoveObject(self,Object,ResetBB = 1):
+        if Object.Foreground:
+            self._TopDrawList.remove(Object)
+        else:
+            self._DrawList.remove(Object)
+            self._BackgroundDirty = 1
+
+        if ResetBB:
+            self.BoundingBoxDirty = 1
+
+    def Clear(self, ResetBB = True):
+        self._DrawList = []
+        if self.UseBackground:
+            self._TopDrawList = []
+            self._BackgroundDirty = 1
+        if ResetBB:
+            self._ResetBoundingBox()
+
+    def _AddBoundingBox(self,NewBB):
+        if self.BoundingBox is None:
+            self.BoundingBox = NewBB
+            self.ZoomToBB(NewBB,DrawFlag = 0)
+        else:
+            self.BoundingBox = array(((min(self.BoundingBox[0,0],NewBB[0,0]),
+                                       min(self.BoundingBox[0,1],NewBB[0,1])),
+                                      (max(self.BoundingBox[1,0],NewBB[1,0]),
+                                       max(self.BoundingBox[1,1],NewBB[1,1]))),Float)
+    def _ResetBoundingBox(self):
+        # NOTE: could you remove an item without recomputing the entire bounding box?
+        self.BoundingBox = None
+        if self._DrawList:
+            self.BoundingBox = self._DrawList[0].BoundingBox
+        for Object in self._DrawList[1:]:
+            self._AddBoundingBox(Object.BoundingBox)
+        if self.UseBackground:
+            for Object in self._TopDrawList:
+                self._AddBoundingBox(Object.BoundingBox)
+        if self.BoundingBox is None:
+            self.ViewPortCenter= array( (0,0), Float)
+            self.TransformVector = array( (1,-1), Float)
+            self.MapProjectionVector = array( (1,1), Float)                    
+            self.Scale = 1
+        self.BoundingBoxDirty = 0
+
+    def PixelToWorld(self,Points):
+        """
+        Converts coordinates from Pixel coordinates to world coordinates.
+        
+        Points is a tuple of (x,y) coordinates, or a list of such tuples, or a NX2 Numpy array of x,y coordinates.
+        
+        """
+        return  (((array(Points,Float) - (self.PanelSize/2))/self.TransformVector) + self.ViewPortCenter)
+        
+    def WorldToPixel(self,Coordinates):
+        """
+        This function will get passed to the drawing functions of the objects,
+        to transform from world to pixel coordinates.
+        Coordinates should be a NX2 array of (x,y) coordinates, or
+        a 2-tuple, or sequence of 2-tuples.
+        """
+        return  (((array(Coordinates,Float) - self.ViewPortCenter)*self.TransformVector)+(self.PanelSize/2)).astype('i')
+        
+    def ScaleFunction(self,Lengths):
+        """
+        This function will get passed to the drawing functions of the objects,
+        to Change a length from world to pixel coordinates.
+        
+        Lengths should be a NX2 array of (x,y) coordinates, or
+        a 2-tuple, or sequence of 2-tuples.
+        """
+        return  (array(Lengths,Float)*self.TransformVector).astype('i')
+        
+            
+    ## This is a set of methods that add objects to the Canvas. It kind
+    ## of seems like a lot of duplication, but I wanted to be able to
+    ## instantiate the draw objects separatley form adding them, but
+    ## also to be able to do add one oin one step. I'm open to better
+    ## ideas...
+    def AddRectangle(self,x,y,width,height,
+                                     LineColor = "Black",
+                                     LineStyle = "Solid",
+                                     LineWidth    = 1,
+                                     FillColor    = None,
+                                     FillStyle    = "Solid",
+                                     Foreground = 0):
+        Object = Rectangle(x,y,width,height,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground)
+        self.AddObject(Object)
+        return Object
+        
+    def AddEllipse(self,x,y,width,height,
+                                     LineColor = "Black",
+                                     LineStyle = "Solid",
+                                     LineWidth    = 1,
+                                     FillColor    = None,
+                                     FillStyle    = "Solid",
+                                     Foreground = 0):
+        Object = Ellipse(x,y,width,height,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground)
+        self.AddObject(Object)
+        return Object
+        
+    def AddCircle(self,x,y,Diameter,
+                                     LineColor = "Black",
+                                     LineStyle = "Solid",
+                                     LineWidth    = 1,
+                                     FillColor    = None,
+                                     FillStyle    = "Solid",
+                                     Foreground = 0):
+        Object = Circle(x,y,Diameter,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground)
+        self.AddObject(Object)
+        return Object
+        
+    def AddDot(self,x,y,Diameter,
+                                     LineColor = "Black",
+                                     LineStyle = "Solid",
+                                     LineWidth    = 1,
+                                     FillColor    = None,
+                                     FillStyle    = "Solid",
+                                     Foreground = 0):
+        Object = Dot(x,y,Diameter,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground)
+        self.AddObject(Object)
+        return Object
+        
+    def AddPolygon(self,Points,
+                               LineColor = "Black",
+                               LineStyle = "Solid",
+                               LineWidth    = 1,
+                               FillColor    = None,
+                               FillStyle    = "Solid",
+                                     Foreground = 0):
+    
+        Object = Polygon(Points,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground)
+        self.AddObject(Object)
+        return Object
+        
+    def AddLine(self,Points,
+                            LineColor = "Black",
+                            LineStyle = "Solid",
+                            LineWidth    = 1,
+                                     Foreground = 0):
+    
+        Object = Line(Points,LineColor,LineStyle,LineWidth,Foreground)
+        self.AddObject(Object)
+        return Object
+
+    def AddLineSet(self,Points,
+                   LineColors = "Black",
+                   LineStyles = "Solid",
+                   LineWidths = 1,
+                   Foreground = 0):
+    
+        Object = LineSet(Points,LineColors,LineStyles,LineWidths,Foreground)
+        self.AddObject(Object)
+        return Object
+
+    def AddPointSet(self,Points,
+                                    Color = "Black",
+                                    Diameter = 1,
+                                     Foreground = 0):
+        
+        Object = PointSet(Points,Color,Diameter,Foreground)
+        self.AddObject(Object)
+        return Object
+        
+    def AddText(self,String,x,y,
+                            Size = 20,
+                            ForeGround = 'Black',
+                            BackGround = None,
+                            Family = 'Swiss',
+                            Style = 'Normal',
+                            Weight = 'Normal',
+                            Underline = 0,
+                            Position = 'tl',
+                                     Foreground = 0):
+        Object = Text(String,x,y,Size,ForeGround,BackGround,Family,Style,Weight,Underline,Position,Foreground)
+        self.AddObject(Object)
+        return Object
+        
+    def AddObject(self,obj):
+        # put in a reference to the Canvas, so remove and other stuff can work
+        obj._Canvas = self
+        if  obj.Foreground and self.UseBackground:
+            self._TopDrawList.append(obj)
+        else:
+            self._DrawList.append(obj)
+            self._backgrounddirty = 1
+        self._AddBoundingBox(obj.BoundingBox)
+        return None
+        
+
+
+
+
 
-"""Renamer stub: provides a way to drop the wx prefix from wxPython objects."""
 
-from wx import _rename
-from wxPython.lib import floatcanvas
-_rename(globals(), floatcanvas.__dict__, modulename='lib.floatcanvas')
-del floatcanvas
-del _rename