Use temp directory and don't prepend two backslashes, on WinCE

[wxWidgets.git] / wxPython / wx / lib / multisash.py

diff --git a/wxPython/wx/lib/multisash.py b/wxPython/wx/lib/multisash.py
index 9f5602e5a6647a4f52c441a64cadf837edb55221..6be5e730aaba69358ca4a0477e8b2940167e2eea 100644 (file)
--- a/wxPython/wx/lib/multisash.py
+++ b/wxPython/wx/lib/multisash.py
@@ -7,10 +7,20 @@
 # Created:      2002/11/20
 # Version:      0.1
 # RCS-ID:       $Id$
 # Created:      2002/11/20
 # Version:      0.1
 # RCS-ID:       $Id$

-# License:      wxWindows licensie
+# License:      wxWindows license

 #----------------------------------------------------------------------
 #----------------------------------------------------------------------

+# 12/09/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o 2.5 compatability update.
+#
+# 12/20/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o wxMultiSash -> MultiSash
+# o wxMultiSplit -> MultiSplit 
+# o wxMultiViewLeaf -> MultiViewLeaf
+#

 
 

-from wxPython.wx import *
+import wx

 
 MV_HOR = 0
 MV_VER = not MV_HOR
 
 MV_HOR = 0
 MV_VER = not MV_HOR


@@ -20,12 +30,12 @@ CR_SIZE = SH_SIZE * 3
 
 #----------------------------------------------------------------------
 
 
 #----------------------------------------------------------------------
 

-class wxMultiSash(wxWindow):
+class MultiSash(wx.Window):

     def __init__(self, *_args,**_kwargs):
     def __init__(self, *_args,**_kwargs):

-        apply(wxWindow.__init__,(self,) + _args,_kwargs)
+        apply(wx.Window.__init__,(self,) + _args,_kwargs)

         self._defChild = EmptyChild
         self._defChild = EmptyChild

-        self.child = wxMultiSplit(self,self,wxPoint(0,0),self.GetSize())
-        EVT_SIZE(self,self.OnMultiSize)
+        self.child = MultiSplit(self,self,(0,0),self.GetSize())
+        self.Bind(wx.EVT_SIZE,self.OnMultiSize)

 
     def SetDefaultChildClass(self,childCls):
         self._defChild = childCls
 
     def SetDefaultChildClass(self,childCls):
         self._defChild = childCls


@@ -39,23 +49,24 @@ class wxMultiSash(wxWindow):
 
     def Clear(self):
         old = self.child
 
     def Clear(self):
         old = self.child

-        self.child = wxMultiSplit(self,self,wxPoint(0,0),self.GetSize())
+        self.child = MultiSplit(self,self,(0,0),self.GetSize())

         old.Destroy()
         self.child.OnSize(None)
 
     def GetSaveData(self):
         saveData = {}
         old.Destroy()
         self.child.OnSize(None)
 
     def GetSaveData(self):
         saveData = {}

-        saveData['_defChild'] = str(self._defChild)
+        saveData['_defChild_class'] = self._defChild.__name__
+        saveData['_defChild_mod']   = self._defChild.__module__

         saveData['child'] = self.child.GetSaveData()
         return saveData
 
     def SetSaveData(self,data):
         saveData['child'] = self.child.GetSaveData()
         return saveData
 
     def SetSaveData(self,data):

-        dChild = data['_defChild']
-        mod = dChild.split('.')[0]
+        mod = data['_defChild_mod']
+        dChild = mod + '.' + data['_defChild_class']

         exec 'import %s' % mod
         self._defChild = eval(dChild)
         old = self.child
         exec 'import %s' % mod
         self._defChild = eval(dChild)
         old = self.child

-        self.child = wxMultiSplit(self,self,wxPoint(0,0),self.GetSize())
+        self.child = MultiSplit(self,self,wx.Point(0,0),self.GetSize())

         self.child.SetSaveData(data['child'])
         old.Destroy()
         self.OnMultiSize(None)
         self.child.SetSaveData(data['child'])
         old.Destroy()
         self.OnMultiSize(None)


@@ -65,10 +76,10 @@ class wxMultiSash(wxWindow):
 #----------------------------------------------------------------------
 
 
 #----------------------------------------------------------------------
 
 

-class wxMultiSplit(wxWindow):
+class MultiSplit(wx.Window):

     def __init__(self,multiView,parent,pos,size,view1 = None):
     def __init__(self,multiView,parent,pos,size,view1 = None):

-        wxWindow.__init__(self,id = -1,parent = parent,pos = pos,size = size,
-                          style = wxCLIP_CHILDREN)
+        wx.Window.__init__(self,id = -1,parent = parent,pos = pos,size = size,
+                          style = wx.CLIP_CHILDREN)

         self.multiView = multiView
         self.view2 = None
         if view1:
         self.multiView = multiView
         self.view2 = None
         if view1:


@@ -76,44 +87,44 @@ class wxMultiSplit(wxWindow):
             self.view1.Reparent(self)
             self.view1.MoveXY(0,0)
         else:
             self.view1.Reparent(self)
             self.view1.MoveXY(0,0)
         else:

-            self.view1 = wxMultiViewLeaf(self.multiView,self,
-                                         wxPoint(0,0),self.GetSize())
+            self.view1 = MultiViewLeaf(self.multiView,self,
+                                         (0,0),self.GetSize())

         self.direction = None
 
         self.direction = None
 

-        EVT_SIZE(self,self.OnSize)
+        self.Bind(wx.EVT_SIZE,self.OnSize)

 
     def GetSaveData(self):
         saveData = {}
         if self.view1:
             saveData['view1'] = self.view1.GetSaveData()
 
     def GetSaveData(self):
         saveData = {}
         if self.view1:
             saveData['view1'] = self.view1.GetSaveData()

-            if isinstance(self.view1,wxMultiSplit):
+            if isinstance(self.view1,MultiSplit):

                 saveData['view1IsSplit'] = 1
         if self.view2:
             saveData['view2'] = self.view2.GetSaveData()
                 saveData['view1IsSplit'] = 1
         if self.view2:
             saveData['view2'] = self.view2.GetSaveData()

-            if isinstance(self.view2,wxMultiSplit):
+            if isinstance(self.view2,MultiSplit):

                 saveData['view2IsSplit'] = 1
         saveData['direction'] = self.direction
                 saveData['view2IsSplit'] = 1
         saveData['direction'] = self.direction

-        v1,v2 = self.GetPositionTuple()
+        v1,v2 = self.GetPosition()

         saveData['x'] = v1
         saveData['y'] = v2
         saveData['x'] = v1
         saveData['y'] = v2

-        v1,v2 = self.GetSizeTuple()
+        v1,v2 = self.GetSize()

         saveData['w'] = v1
         saveData['h'] = v2
         return saveData
 
     def SetSaveData(self,data):
         self.direction = data['direction']
         saveData['w'] = v1
         saveData['h'] = v2
         return saveData
 
     def SetSaveData(self,data):
         self.direction = data['direction']

-        self.SetDimensions(data['x'],data['y'],data['w'],data['h'])
+        self.SetDimensions(int(data['x']), int(data['y']), int(data['w']), int(data['h']))

         v1Data = data.get('view1',None)
         if v1Data:
             isSplit = data.get('view1IsSplit',None)
             old = self.view1
             if isSplit:
         v1Data = data.get('view1',None)
         if v1Data:
             isSplit = data.get('view1IsSplit',None)
             old = self.view1
             if isSplit:

-                self.view1 = wxMultiSplit(self.multiView,self,
-                                          wxPoint(0,0),self.GetSize())
+                self.view1 = MultiSplit(self.multiView,self,
+                                          (0,0),self.GetSize())

             else:
             else:

-                self.view1 = wxMultiViewLeaf(self.multiView,self,
-                                             wxPoint(0,0),self.GetSize())
+                self.view1 = MultiViewLeaf(self.multiView,self,
+                                             (0,0),self.GetSize())

             self.view1.SetSaveData(v1Data)
             if old:
                 old.Destroy()
             self.view1.SetSaveData(v1Data)
             if old:
                 old.Destroy()


@@ -122,11 +133,11 @@ class wxMultiSplit(wxWindow):
             isSplit = data.get('view2IsSplit',None)
             old = self.view2
             if isSplit:
             isSplit = data.get('view2IsSplit',None)
             old = self.view2
             if isSplit:

-                self.view2 = wxMultiSplit(self.multiView,self,
-                                          wxPoint(0,0),self.GetSize())
+                self.view2 = MultiSplit(self.multiView,self,
+                                          (0,0),self.GetSize())

             else:
             else:

-                self.view2 = wxMultiViewLeaf(self.multiView,self,
-                                             wxPoint(0,0),self.GetSize())
+                self.view2 = MultiViewLeaf(self.multiView,self,
+                                             (0,0),self.GetSize())

             self.view2.SetSaveData(v2Data)
             if old:
                 old.Destroy()
             self.view2.SetSaveData(v2Data)
             if old:
                 old.Destroy()


@@ -148,20 +159,20 @@ class wxMultiSplit(wxWindow):
     def AddLeaf(self,direction,caller,pos):
         if self.view2:
             if caller == self.view1:
     def AddLeaf(self,direction,caller,pos):
         if self.view2:
             if caller == self.view1:

-                self.view1 = wxMultiSplit(self.multiView,self,
+                self.view1 = MultiSplit(self.multiView,self,

                                           caller.GetPosition(),
                                           caller.GetSize(),
                                           caller)
                 self.view1.AddLeaf(direction,caller,pos)
             else:
                                           caller.GetPosition(),
                                           caller.GetSize(),
                                           caller)
                 self.view1.AddLeaf(direction,caller,pos)
             else:

-                self.view2 = wxMultiSplit(self.multiView,self,
+                self.view2 = MultiSplit(self.multiView,self,

                                           caller.GetPosition(),
                                           caller.GetSize(),
                                           caller)
                 self.view2.AddLeaf(direction,caller,pos)
         else:
             self.direction = direction
                                           caller.GetPosition(),
                                           caller.GetSize(),
                                           caller)
                 self.view2.AddLeaf(direction,caller,pos)
         else:
             self.direction = direction

-            w,h = self.GetSizeTuple()
+            w,h = self.GetSize()

             if direction == MV_HOR:
                 x,y = (pos,0)
                 w1,h1 = (w-pos,h)
             if direction == MV_HOR:
                 x,y = (pos,0)
                 w1,h1 = (w-pos,h)


@@ -170,9 +181,8 @@ class wxMultiSplit(wxWindow):
                 x,y = (0,pos)
                 w1,h1 = (w,h-pos)
                 w2,h2 = (w,pos)
                 x,y = (0,pos)
                 w1,h1 = (w,h-pos)
                 w2,h2 = (w,pos)

-            self.view2 = wxMultiViewLeaf(self.multiView,self,
-                                         wxPoint(x,y),wxSize(w1,h1))
-            self.view1.SetSize(wxSize(w2,h2))
+            self.view2 = MultiViewLeaf(self.multiView, self, (x,y), (w1,h1))
+            self.view1.SetSize((w2,h2))

             self.view2.OnSize(None)
 
     def DestroyLeaf(self,caller):
             self.view2.OnSize(None)
 
     def DestroyLeaf(self,caller):


@@ -191,8 +201,8 @@ class wxMultiSplit(wxWindow):
             self.view1.SetSize(self.GetSize())
             self.view1.Move(self.GetPosition())
         else:
             self.view1.SetSize(self.GetSize())
             self.view1.Move(self.GetPosition())
         else:

-            w,h = self.GetSizeTuple()
-            x,y = self.GetPositionTuple()
+            w,h = self.GetSize()
+            x,y = self.GetPosition()

             if caller == self.view1:
                 if self == parent.view1:
                     parent.view1 = self.view2
             if caller == self.view1:
                 if self == parent.view1:
                     parent.view1 = self.view2


@@ -230,7 +240,7 @@ class wxMultiSplit(wxWindow):
         if not (self.view1 and self.view2):
             return
         if pos < 10: return
         if not (self.view1 and self.view2):
             return
         if pos < 10: return

-        w,h = self.GetSizeTuple()
+        w,h = self.GetSize()

         if side == MV_HOR:
             if pos > w - 10: return
         else:
         if side == MV_HOR:
             if pos > w - 10: return
         else:


@@ -247,11 +257,11 @@ class wxMultiSplit(wxWindow):
             self.view1.SetSize(self.GetSize())
             self.view1.OnSize(None)
             return
             self.view1.SetSize(self.GetSize())
             self.view1.OnSize(None)
             return

-        v1w,v1h = self.view1.GetSizeTuple()
-        v2w,v2h = self.view2.GetSizeTuple()
-        v1x,v1y = self.view1.GetPositionTuple()
-        v2x,v2y = self.view2.GetPositionTuple()
-        w,h = self.GetSizeTuple()
+        v1w,v1h = self.view1.GetSize()
+        v2w,v2h = self.view2.GetSize()
+        v1x,v1y = self.view1.GetPosition()
+        v2x,v2y = self.view2.GetPosition()
+        w,h = self.GetSize()

 
         if v1x != v2x:
             ratio = float(w) / float((v1w + v2w))
 
         if v1x != v2x:
             ratio = float(w) / float((v1w + v2w))


@@ -269,8 +279,8 @@ class wxMultiSplit(wxWindow):
         else:
             v1h = v2h = h
 
         else:
             v1h = v2h = h
 

-        self.view1.SetDimensions(v1x,v1y,v1w,v1h)
-        self.view2.SetDimensions(v2x,v2y,v2w,v2h)
+        self.view1.SetDimensions(int(v1x), int(v1y), int(v1w), int(v1h))
+        self.view2.SetDimensions(int(v2x), int(v2y), int(v2w), int(v2h))

         self.view1.OnSize(None)
         self.view2.OnSize(None)
 
         self.view1.OnSize(None)
         self.view2.OnSize(None)
 


@@ -278,10 +288,10 @@ class wxMultiSplit(wxWindow):
 #----------------------------------------------------------------------
 
 
 #----------------------------------------------------------------------
 
 

-class wxMultiViewLeaf(wxWindow):
+class MultiViewLeaf(wx.Window):

     def __init__(self,multiView,parent,pos,size):
     def __init__(self,multiView,parent,pos,size):

-        wxWindow.__init__(self,id = -1,parent = parent,pos = pos,size = size,
-                          style = wxCLIP_CHILDREN)
+        wx.Window.__init__(self,id = -1,parent = parent,pos = pos,size = size,
+                          style = wx.CLIP_CHILDREN)

         self.multiView = multiView
 
         self.sizerHor = MultiSizer(self,MV_HOR)
         self.multiView = multiView
 
         self.sizerHor = MultiSizer(self,MV_HOR)


@@ -291,28 +301,32 @@ class wxMultiViewLeaf(wxWindow):
         self.detail = MultiClient(self,multiView._defChild)
         self.closer = MultiCloser(self)
 
         self.detail = MultiClient(self,multiView._defChild)
         self.closer = MultiCloser(self)
 

-        EVT_SIZE(self,self.OnSize)
+        self.Bind(wx.EVT_SIZE,self.OnSize)
+
+        self.SetBackgroundColour(wx.SystemSettings.GetColour(wx.SYS_COLOUR_3DFACE))
+

 
     def GetSaveData(self):
         saveData = {}
 
     def GetSaveData(self):
         saveData = {}

-        saveData['detailClass'] = str(self.detail.child.__class__)
+        saveData['detailClass_class'] = self.detail.child.__class__.__name__
+        saveData['detailClass_mod'] = self.detail.child.__module__

         if hasattr(self.detail.child,'GetSaveData'):
             attr = getattr(self.detail.child,'GetSaveData')
             if callable(attr):
                 dData = attr()
                 if dData:
                     saveData['detail'] = dData
         if hasattr(self.detail.child,'GetSaveData'):
             attr = getattr(self.detail.child,'GetSaveData')
             if callable(attr):
                 dData = attr()
                 if dData:
                     saveData['detail'] = dData

-        v1,v2 = self.GetPositionTuple()
+        v1,v2 = self.GetPosition()

         saveData['x'] = v1
         saveData['y'] = v2
         saveData['x'] = v1
         saveData['y'] = v2

-        v1,v2 = self.GetSizeTuple()
+        v1,v2 = self.GetSize()

         saveData['w'] = v1
         saveData['h'] = v2
         return saveData
 
     def SetSaveData(self,data):
         saveData['w'] = v1
         saveData['h'] = v2
         return saveData
 
     def SetSaveData(self,data):

-        dChild = data['detailClass']
-        mod = dChild.split('.')[0]
+        mod = data['detailClass_mod']
+        dChild = mod + '.' + data['detailClass_class']

         exec 'import %s' % mod
         detClass = eval(dChild)
         self.SetDimensions(data['x'],data['y'],data['w'],data['h'])
         exec 'import %s' % mod
         detClass = eval(dChild)
         self.SetDimensions(data['x'],data['y'],data['w'],data['h'])


@@ -335,7 +349,7 @@ class wxMultiViewLeaf(wxWindow):
 
     def AddLeaf(self,direction,pos):
         if pos < 10: return
 
     def AddLeaf(self,direction,pos):
         if pos < 10: return

-        w,h = self.GetSizeTuple()
+        w,h = self.GetSize()

         if direction == MV_VER:
             if pos > h - 10: return
         else:
         if direction == MV_VER:
             if pos > h - 10: return
         else:


@@ -352,30 +366,35 @@ class wxMultiViewLeaf(wxWindow):
         return self.GetParent().CanSize(side,self)
 
     def OnSize(self,evt):
         return self.GetParent().CanSize(side,self)
 
     def OnSize(self,evt):

-        self.sizerHor.OnSize(evt)
-        self.sizerVer.OnSize(evt)
-        self.creatorHor.OnSize(evt)
-        self.creatorVer.OnSize(evt)
-        self.detail.OnSize(evt)
-        self.closer.OnSize(evt)
+        def doresize():
+            try:
+                self.sizerHor.OnSize(evt)
+                self.sizerVer.OnSize(evt)
+                self.creatorHor.OnSize(evt)
+                self.creatorVer.OnSize(evt)
+                self.detail.OnSize(evt)
+                self.closer.OnSize(evt)
+            except:
+                pass
+        wx.CallAfter(doresize)

 
 #----------------------------------------------------------------------
 
 
 
 #----------------------------------------------------------------------
 
 

-class MultiClient(wxWindow):
+class MultiClient(wx.Window):

     def __init__(self,parent,childCls):
         w,h = self.CalcSize(parent)
     def __init__(self,parent,childCls):
         w,h = self.CalcSize(parent)

-        wxWindow.__init__(self,id = -1,parent = parent,
-                          pos = wxPoint(0,0),
-                          size = wxSize(w,h),
-                          style = wxCLIP_CHILDREN | wxSUNKEN_BORDER)
+        wx.Window.__init__(self,id = -1,parent = parent,
+                          pos = (0,0),
+                          size = (w,h),
+                          style = wx.CLIP_CHILDREN | wx.SUNKEN_BORDER)

         self.child = childCls(self)
         self.child.MoveXY(2,2)
         self.normalColour = self.GetBackgroundColour()
         self.selected = False
 
         self.child = childCls(self)
         self.child.MoveXY(2,2)
         self.normalColour = self.GetBackgroundColour()
         self.selected = False
 

-        EVT_SET_FOCUS(self,self.OnSetFocus)
-        EVT_CHILD_FOCUS(self,self.OnChildFocus)
+        self.Bind(wx.EVT_SET_FOCUS,self.OnSetFocus)
+        self.Bind(wx.EVT_CHILD_FOCUS,self.OnChildFocus)

 
     def UnSelect(self):
         if self.selected:
 
     def UnSelect(self):
         if self.selected:


@@ -386,11 +405,11 @@ class MultiClient(wxWindow):
     def Select(self):
         self.GetParent().multiView.UnSelect()
         self.selected = True
     def Select(self):
         self.GetParent().multiView.UnSelect()
         self.selected = True

-        self.SetBackgroundColour(wxColour(255,255,0)) # Yellow
+        self.SetBackgroundColour(wx.Colour(255,255,0)) # Yellow

         self.Refresh()
 
     def CalcSize(self,parent):
         self.Refresh()
 
     def CalcSize(self,parent):

-        w,h = parent.GetSizeTuple()
+        w,h = parent.GetSize()

         w -= SH_SIZE
         h -= SH_SIZE
         return (w,h)
         w -= SH_SIZE
         h -= SH_SIZE
         return (w,h)


@@ -398,8 +417,8 @@ class MultiClient(wxWindow):
     def OnSize(self,evt):
         w,h = self.CalcSize(self.GetParent())
         self.SetDimensions(0,0,w,h)
     def OnSize(self,evt):
         w,h = self.CalcSize(self.GetParent())
         self.SetDimensions(0,0,w,h)

-        w,h = self.GetClientSizeTuple()
-        self.child.SetSize(wxSize(w-4,h-4))
+        w,h = self.GetClientSize()
+        self.child.SetSize((w-4,h-4))

 
     def SetNewChildCls(self,childCls):
         if self.child:
 
     def SetNewChildCls(self,childCls):
         if self.child:


@@ -415,34 +434,37 @@ class MultiClient(wxWindow):
         self.OnSetFocus(evt)
 ##        from Funcs import FindFocusedChild
 ##        child = FindFocusedChild(self)
         self.OnSetFocus(evt)
 ##        from Funcs import FindFocusedChild
 ##        child = FindFocusedChild(self)

-##        EVT_KILL_FOCUS(child,self.OnChildKillFocus)
+##        child.Bind(wx.EVT_KILL_FOCUS,self.OnChildKillFocus)

 
 
 #----------------------------------------------------------------------
 
 
 
 
 #----------------------------------------------------------------------
 
 

-class MultiSizer(wxWindow):
+class MultiSizer(wx.Window):

     def __init__(self,parent,side):
         self.side = side
         x,y,w,h = self.CalcSizePos(parent)
     def __init__(self,parent,side):
         self.side = side
         x,y,w,h = self.CalcSizePos(parent)

-        wxWindow.__init__(self,id = -1,parent = parent,
-                          pos = wxPoint(x,y),
-                          size = wxSize(w,h),
-                          style = wxCLIP_CHILDREN)
+        wx.Window.__init__(self,id = -1,parent = parent,
+                          pos = (x,y),
+                          size = (w,h),
+                          style = wx.CLIP_CHILDREN)

 
         self.px = None                  # Previous X
         self.py = None                  # Previous Y
         self.isDrag = False             # In Dragging
         self.dragTarget = None          # View being sized
 
 
         self.px = None                  # Previous X
         self.py = None                  # Previous Y
         self.isDrag = False             # In Dragging
         self.dragTarget = None          # View being sized
 

-        EVT_LEAVE_WINDOW(self,self.OnLeave)
-        EVT_ENTER_WINDOW(self,self.OnEnter)
-        EVT_MOTION(self,self.OnMouseMove)
-        EVT_LEFT_DOWN(self,self.OnPress)
-        EVT_LEFT_UP(self,self.OnRelease)
+        self.Bind(wx.EVT_LEAVE_WINDOW,self.OnLeave)
+        self.Bind(wx.EVT_ENTER_WINDOW,self.OnEnter)
+        self.Bind(wx.EVT_MOTION,self.OnMouseMove)
+        self.Bind(wx.EVT_LEFT_DOWN,self.OnPress)
+        self.Bind(wx.EVT_LEFT_UP,self.OnRelease)
+
+        self.SetBackgroundColour(wx.SystemSettings.GetColour(wx.SYS_COLOUR_3DFACE))
+

 
     def CalcSizePos(self,parent):
 
     def CalcSizePos(self,parent):

-        pw,ph = parent.GetSizeTuple()
+        pw,ph = parent.GetSize()

         if self.side == MV_HOR:
             x = CR_SIZE + 2
             y = ph - SH_SIZE
         if self.side == MV_HOR:
             x = CR_SIZE + 2
             y = ph - SH_SIZE


@@ -460,15 +482,15 @@ class MultiSizer(wxWindow):
         self.SetDimensions(x,y,w,h)
 
     def OnLeave(self,evt):
         self.SetDimensions(x,y,w,h)
 
     def OnLeave(self,evt):

-        self.SetCursor(wxStockCursor(wxCURSOR_ARROW))
+        self.SetCursor(wx.StockCursor(wx.CURSOR_ARROW))

 
     def OnEnter(self,evt):
         if not self.GetParent().CanSize(not self.side):
             return
         if self.side == MV_HOR:
 
     def OnEnter(self,evt):
         if not self.GetParent().CanSize(not self.side):
             return
         if self.side == MV_HOR:

-            self.SetCursor(wxStockCursor(wxCURSOR_SIZENS))
+            self.SetCursor(wx.StockCursor(wx.CURSOR_SIZENS))

         else:
         else:

-            self.SetCursor(wxStockCursor(wxCURSOR_SIZEWE))
+            self.SetCursor(wx.StockCursor(wx.CURSOR_SIZEWE))

 
     def OnMouseMove(self,evt):
         if self.isDrag:
 
     def OnMouseMove(self,evt):
         if self.isDrag:


@@ -508,28 +530,28 @@ class MultiSizer(wxWindow):
 #----------------------------------------------------------------------
 
 
 #----------------------------------------------------------------------
 
 

-class MultiCreator(wxWindow):
+class MultiCreator(wx.Window):

     def __init__(self,parent,side):
         self.side = side
         x,y,w,h = self.CalcSizePos(parent)
     def __init__(self,parent,side):
         self.side = side
         x,y,w,h = self.CalcSizePos(parent)

-        wxWindow.__init__(self,id = -1,parent = parent,
-                          pos = wxPoint(x,y),
-                          size = wxSize(w,h),
-                          style = wxCLIP_CHILDREN)
+        wx.Window.__init__(self,id = -1,parent = parent,
+                          pos = (x,y),
+                          size = (w,h),
+                          style = wx.CLIP_CHILDREN)

 
         self.px = None                  # Previous X
         self.py = None                  # Previous Y
         self.isDrag = False           # In Dragging
 
 
         self.px = None                  # Previous X
         self.py = None                  # Previous Y
         self.isDrag = False           # In Dragging
 

-        EVT_LEAVE_WINDOW(self,self.OnLeave)
-        EVT_ENTER_WINDOW(self,self.OnEnter)
-        EVT_MOTION(self,self.OnMouseMove)
-        EVT_LEFT_DOWN(self,self.OnPress)
-        EVT_LEFT_UP(self,self.OnRelease)
-        EVT_PAINT(self,self.OnPaint)
+        self.Bind(wx.EVT_LEAVE_WINDOW,self.OnLeave)
+        self.Bind(wx.EVT_ENTER_WINDOW,self.OnEnter)
+        self.Bind(wx.EVT_MOTION,self.OnMouseMove)
+        self.Bind(wx.EVT_LEFT_DOWN,self.OnPress)
+        self.Bind(wx.EVT_LEFT_UP,self.OnRelease)
+        self.Bind(wx.EVT_PAINT,self.OnPaint)

 
     def CalcSizePos(self,parent):
 
     def CalcSizePos(self,parent):

-        pw,ph = parent.GetSizeTuple()
+        pw,ph = parent.GetSize()

         if self.side == MV_HOR:
             x = 2
             y = ph - SH_SIZE
         if self.side == MV_HOR:
             x = 2
             y = ph - SH_SIZE


@@ -547,13 +569,13 @@ class MultiCreator(wxWindow):
         self.SetDimensions(x,y,w,h)
 
     def OnLeave(self,evt):
         self.SetDimensions(x,y,w,h)
 
     def OnLeave(self,evt):

-        self.SetCursor(wxStockCursor(wxCURSOR_ARROW))
+        self.SetCursor(wx.StockCursor(wx.CURSOR_ARROW))

 
     def OnEnter(self,evt):
         if self.side == MV_HOR:
 
     def OnEnter(self,evt):
         if self.side == MV_HOR:

-            self.SetCursor(wxStockCursor(wxCURSOR_HAND))
+            self.SetCursor(wx.StockCursor(wx.CURSOR_HAND))

         else:
         else:

-            self.SetCursor(wxStockCursor(wxCURSOR_POINT_LEFT))
+            self.SetCursor(wx.StockCursor(wx.CURSOR_POINT_LEFT))

 
     def OnMouseMove(self,evt):
         if self.isDrag:
 
     def OnMouseMove(self,evt):
         if self.isDrag:


@@ -588,55 +610,53 @@ class MultiCreator(wxWindow):
             evt.Skip()
 
     def OnPaint(self,evt):
             evt.Skip()
 
     def OnPaint(self,evt):

-        dc = wxPaintDC(self)
-        dc.SetBackground(wxBrush(self.GetBackgroundColour(),wxSOLID))
+        dc = wx.PaintDC(self)
+        dc.SetBackground(wx.Brush(self.GetBackgroundColour(),wx.SOLID))

         dc.Clear()
 
         dc.Clear()
 

-        highlight = wxPen(wxSystemSettings_GetSystemColour(
-            wxSYS_COLOUR_BTNHIGHLIGHT),1,wxSOLID)
-        shadow = wxPen(wxSystemSettings_GetSystemColour(
-            wxSYS_COLOUR_BTNSHADOW),1,wxSOLID)
-        black = wxPen(wxBLACK,1,wxSOLID)
-        w,h = self.GetSizeTuple()
+        highlight = wx.Pen(wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNHIGHLIGHT), 1, wx.SOLID)
+        shadow = wx.Pen(wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNSHADOW), 1, wx.SOLID)
+        black = wx.Pen(wx.BLACK,1,wx.SOLID)
+        w,h = self.GetSize()

         w -= 1
         h -= 1
 
         # Draw outline
         dc.SetPen(highlight)
         w -= 1
         h -= 1
 
         # Draw outline
         dc.SetPen(highlight)

-        dc.DrawLine(0,0,0,h)
-        dc.DrawLine(0,0,w,0)
+        dc.DrawLine(0,0, 0,h)
+        dc.DrawLine(0,0, w,0)

         dc.SetPen(black)
         dc.SetPen(black)

-        dc.DrawLine(0,h,w+1,h)
-        dc.DrawLine(w,0,w,h)
+        dc.DrawLine(0,h, w+1,h)
+        dc.DrawLine(w,0, w,h)

         dc.SetPen(shadow)
         dc.SetPen(shadow)

-        dc.DrawLine(w-1,2,w-1,h)
+        dc.DrawLine(w-1,2, w-1,h)

 
 #----------------------------------------------------------------------
 
 
 
 #----------------------------------------------------------------------
 
 

-class MultiCloser(wxWindow):
+class MultiCloser(wx.Window):

     def __init__(self,parent):
         x,y,w,h = self.CalcSizePos(parent)
     def __init__(self,parent):
         x,y,w,h = self.CalcSizePos(parent)

-        wxWindow.__init__(self,id = -1,parent = parent,
-                          pos = wxPoint(x,y),
-                          size = wxSize(w,h),
-                          style = wxCLIP_CHILDREN)
+        wx.Window.__init__(self,id = -1,parent = parent,
+                          pos = (x,y),
+                          size = (w,h),
+                          style = wx.CLIP_CHILDREN)

 
         self.down = False
         self.entered = False
 
 
         self.down = False
         self.entered = False
 

-        EVT_LEFT_DOWN(self,self.OnPress)
-        EVT_LEFT_UP(self,self.OnRelease)
-        EVT_PAINT(self,self.OnPaint)
-        EVT_LEAVE_WINDOW(self,self.OnLeave)
-        EVT_ENTER_WINDOW(self,self.OnEnter)
+        self.Bind(wx.EVT_LEFT_DOWN,self.OnPress)
+        self.Bind(wx.EVT_LEFT_UP,self.OnRelease)
+        self.Bind(wx.EVT_PAINT,self.OnPaint)
+        self.Bind(wx.EVT_LEAVE_WINDOW,self.OnLeave)
+        self.Bind(wx.EVT_ENTER_WINDOW,self.OnEnter)

 
     def OnLeave(self,evt):
 
     def OnLeave(self,evt):

-        self.SetCursor(wxStockCursor(wxCURSOR_ARROW))
+        self.SetCursor(wx.StockCursor(wx.CURSOR_ARROW))

         self.entered = False
 
     def OnEnter(self,evt):
         self.entered = False
 
     def OnEnter(self,evt):

-        self.SetCursor(wxStockCursor(wxCURSOR_BULLSEYE))
+        self.SetCursor(wx.StockCursor(wx.CURSOR_BULLSEYE))

         self.entered = True
 
     def OnPress(self,evt):
         self.entered = True
 
     def OnPress(self,evt):


@@ -651,12 +671,12 @@ class MultiCloser(wxWindow):
         self.down = False
 
     def OnPaint(self,evt):
         self.down = False
 
     def OnPaint(self,evt):

-        dc = wxPaintDC(self)
-        dc.SetBackground(wxBrush(wxRED,wxSOLID))
+        dc = wx.PaintDC(self)
+        dc.SetBackground(wx.Brush(wx.RED,wx.SOLID))

         dc.Clear()
 
     def CalcSizePos(self,parent):
         dc.Clear()
 
     def CalcSizePos(self,parent):

-        pw,ph = parent.GetSizeTuple()
+        pw,ph = parent.GetSize()

         x = pw - SH_SIZE
         w = SH_SIZE
         h = SH_SIZE + 2
         x = pw - SH_SIZE
         w = SH_SIZE
         h = SH_SIZE + 2


@@ -671,33 +691,33 @@ class MultiCloser(wxWindow):
 #----------------------------------------------------------------------
 
 
 #----------------------------------------------------------------------
 
 

-class EmptyChild(wxWindow):
+class EmptyChild(wx.Window):

     def __init__(self,parent):
     def __init__(self,parent):

-        wxWindow.__init__(self,parent,-1, style = wxCLIP_CHILDREN)
+        wx.Window.__init__(self,parent,-1, style = wx.CLIP_CHILDREN)

 
 
 #----------------------------------------------------------------------
 
 
 def DrawSash(win,x,y,direction):
 
 
 #----------------------------------------------------------------------
 
 
 def DrawSash(win,x,y,direction):

-    dc = wxScreenDC()
+    dc = wx.ScreenDC()

     dc.StartDrawingOnTopWin(win)
     dc.StartDrawingOnTopWin(win)

-    bmp = wxEmptyBitmap(8,8)
-    bdc = wxMemoryDC()
+    bmp = wx.EmptyBitmap(8,8)
+    bdc = wx.MemoryDC()

     bdc.SelectObject(bmp)
     bdc.SelectObject(bmp)

-    bdc.DrawRectangle(-1,-1,10,10)
+    bdc.DrawRectangle(-1,-1, 10,10)

     for i in range(8):
         for j in range(8):
             if ((i + j) & 1):
                 bdc.DrawPoint(i,j)
 
     for i in range(8):
         for j in range(8):
             if ((i + j) & 1):
                 bdc.DrawPoint(i,j)
 

-    brush = wxBrush(wxColour(0,0,0))
+    brush = wx.Brush(wx.Colour(0,0,0))

     brush.SetStipple(bmp)
 
     dc.SetBrush(brush)
     brush.SetStipple(bmp)
 
     dc.SetBrush(brush)

-    dc.SetLogicalFunction(wxXOR)
+    dc.SetLogicalFunction(wx.XOR)

 
 

-    body_w,body_h = win.GetClientSizeTuple()
+    body_w,body_h = win.GetClientSize()

 
     if y < 0:
         y = 0
 
     if y < 0:
         y = 0


@@ -719,8 +739,8 @@ def DrawSash(win,x,y,direction):
     h = body_h
 
     if direction == MV_HOR:
     h = body_h
 
     if direction == MV_HOR:

-        dc.DrawRectangle(x,y-2,w,4)
+        dc.DrawRectangle(x,y-2, w,4)

     else:
     else:

-        dc.DrawRectangle(x-2,y,4,h)
+        dc.DrawRectangle(x-2,y, 4,h)

 
     dc.EndDrawingOnTop()
 
     dc.EndDrawingOnTop()