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

#----------------------------------------------------------------------
# Name:         multisash
# Purpose:      Multi Sash control
#
# Author:       Gerrit van Dyk
#
# Created:      2002/11/20
# Version:      0.1
# RCS-ID:       $Id$
# License:      wxWindows licensie
#----------------------------------------------------------------------
# 12/09/2003 - Jeff Grimmett (grimmtooth@softhome.net)
#
# o 2.5 compatability update.
#

import wx

MV_HOR = 0
MV_VER = not MV_HOR

SH_SIZE = 5
CR_SIZE = SH_SIZE * 3

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

class wxMultiSash(wx.Window):
    def __init__(self, *_args,**_kwargs):
        apply(wx.Window.__init__,(self,) + _args,_kwargs)
        self._defChild = EmptyChild
        self.child = wxMultiSplit(self,self,(0,0),self.GetSize())
        self.Bind(wx.EVT_SIZE,self.OnMultiSize)

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

    def OnMultiSize(self,evt):
        self.child.SetSize(self.GetSize())

    def UnSelect(self):
        self.child.UnSelect()

    def Clear(self):
        old = self.child
        self.child = wxMultiSplit(self,self,(0,0),self.GetSize())
        old.Destroy()
        self.child.OnSize(None)

    def GetSaveData(self):
        saveData = {}
        saveData['_defChild'] = str(self._defChild)
        saveData['child'] = self.child.GetSaveData()
        return saveData

    def SetSaveData(self,data):
        dChild = data['_defChild']
        mod = dChild.split('.')[0]
        exec 'import %s' % mod
        self._defChild = eval(dChild)
        old = self.child
        self.child = wxMultiSplit(self,self,wxPoint(0,0),self.GetSize())
        self.child.SetSaveData(data['child'])
        old.Destroy()
        self.OnMultiSize(None)
        self.child.OnSize(None)


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


class wxMultiSplit(wx.Window):
    def __init__(self,multiView,parent,pos,size,view1 = None):
        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.view1 = view1
            self.view1.Reparent(self)
            self.view1.MoveXY(0,0)
        else:
            self.view1 = wxMultiViewLeaf(self.multiView,self,
                                         (0,0),self.GetSize())
        self.direction = None

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

    def GetSaveData(self):
        saveData = {}
        if self.view1:
            saveData['view1'] = self.view1.GetSaveData()
            if isinstance(self.view1,wxMultiSplit):
                saveData['view1IsSplit'] = 1
        if self.view2:
            saveData['view2'] = self.view2.GetSaveData()
            if isinstance(self.view2,wxMultiSplit):
                saveData['view2IsSplit'] = 1
        saveData['direction'] = self.direction
        v1,v2 = self.GetPosition()
        saveData['x'] = v1
        saveData['y'] = v2
        v1,v2 = self.GetSize()
        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'])
        v1Data = data.get('view1',None)
        if v1Data:
            isSplit = data.get('view1IsSplit',None)
            old = self.view1
            if isSplit:
                self.view1 = wxMultiSplit(self.multiView,self,
                                          (0,0),self.GetSize())
            else:
                self.view1 = wxMultiViewLeaf(self.multiView,self,
                                             (0,0),self.GetSize())
            self.view1.SetSaveData(v1Data)
            if old:
                old.Destroy()
        v2Data = data.get('view2',None)
        if v2Data:
            isSplit = data.get('view2IsSplit',None)
            old = self.view2
            if isSplit:
                self.view2 = wxMultiSplit(self.multiView,self,
                                          (0,0),self.GetSize())
            else:
                self.view2 = wxMultiViewLeaf(self.multiView,self,
                                             (0,0),self.GetSize())
            self.view2.SetSaveData(v2Data)
            if old:
                old.Destroy()
        if self.view1:
            self.view1.OnSize(None)
        if self.view2:
            self.view2.OnSize(None)

    def UnSelect(self):
        if self.view1:
            self.view1.UnSelect()
        if self.view2:
            self.view2.UnSelect()

    def DefaultChildChanged(self):
        if not self.view2:
            self.view1.DefaultChildChanged()

    def AddLeaf(self,direction,caller,pos):
        if self.view2:
            if caller == self.view1:
                self.view1 = wxMultiSplit(self.multiView,self,
                                          caller.GetPosition(),
                                          caller.GetSize(),
                                          caller)
                self.view1.AddLeaf(direction,caller,pos)
            else:
                self.view2 = wxMultiSplit(self.multiView,self,
                                          caller.GetPosition(),
                                          caller.GetSize(),
                                          caller)
                self.view2.AddLeaf(direction,caller,pos)
        else:
            self.direction = direction
            w,h = self.GetSize()
            if direction == MV_HOR:
                x,y = (pos,0)
                w1,h1 = (w-pos,h)
                w2,h2 = (pos,h)
            else:
                x,y = (0,pos)
                w1,h1 = (w,h-pos)
                w2,h2 = (w,pos)
            self.view2 = wxMultiViewLeaf(self.multiView, self, (x,y), (w1,h1))
            self.view1.SetSize((w2,h2))
            self.view2.OnSize(None)

    def DestroyLeaf(self,caller):
        if not self.view2:              # We will only have 2 windows if
            return                      # we need to destroy any
        parent = self.GetParent()       # Another splitview
        if parent == self.multiView:    # We'r at the root
            if caller == self.view1:
                old = self.view1
                self.view1 = self.view2
                self.view2 = None
                old.Destroy()
            else:
                self.view2.Destroy()
                self.view2 = None
            self.view1.SetSize(self.GetSize())
            self.view1.Move(self.GetPosition())
        else:
            w,h = self.GetSize()
            x,y = self.GetPosition()
            if caller == self.view1:
                if self == parent.view1:
                    parent.view1 = self.view2
                else:
                    parent.view2 = self.view2
                self.view2.Reparent(parent)
                self.view2.SetDimensions(x,y,w,h)
            else:
                if self == parent.view1:
                    parent.view1 = self.view1
                else:
                    parent.view2 = self.view1
                self.view1.Reparent(parent)
                self.view1.SetDimensions(x,y,w,h)
            self.view1 = None
            self.view2 = None
            self.Destroy()

    def CanSize(self,side,view):
        if self.SizeTarget(side,view):
            return True
        return False

    def SizeTarget(self,side,view):
        if self.direction == side and self.view2 and view == self.view1:
            return self
        parent = self.GetParent()
        if parent != self.multiView:
            return parent.SizeTarget(side,self)
        return None

    def SizeLeaf(self,leaf,pos,side):
        if self.direction != side:
            return
        if not (self.view1 and self.view2):
            return
        if pos < 10: return
        w,h = self.GetSize()
        if side == MV_HOR:
            if pos > w - 10: return
        else:
            if pos > h - 10: return
        if side == MV_HOR:
            self.view1.SetDimensions(0,0,pos,h)
            self.view2.SetDimensions(pos,0,w-pos,h)
        else:
            self.view1.SetDimensions(0,0,w,pos)
            self.view2.SetDimensions(0,pos,w,h-pos)

    def OnSize(self,evt):
        if not self.view2:
            self.view1.SetSize(self.GetSize())
            self.view1.OnSize(None)
            return
        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))
            v1w *= ratio
            v2w = w - v1w
            v2x = v1w
        else:
            v1w = v2w = w

        if v1y != v2y:
            ratio = float(h) / float((v1h + v2h))
            v1h *= ratio
            v2h = h - v1h
            v2y = v1h
        else:
            v1h = v2h = h

        self.view1.SetDimensions(v1x,v1y,v1w,v1h)
        self.view2.SetDimensions(v2x,v2y,v2w,v2h)
        self.view1.OnSize(None)
        self.view2.OnSize(None)


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


class wxMultiViewLeaf(wx.Window):
    def __init__(self,multiView,parent,pos,size):
        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.sizerVer = MultiSizer(self,MV_VER)
        self.creatorHor = MultiCreator(self,MV_HOR)
        self.creatorVer = MultiCreator(self,MV_VER)
        self.detail = MultiClient(self,multiView._defChild)
        self.closer = MultiCloser(self)

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

    def GetSaveData(self):
        saveData = {}
        saveData['detailClass'] = str(self.detail.child.__class__)
        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.GetPosition()
        saveData['x'] = v1
        saveData['y'] = v2
        v1,v2 = self.GetSize()
        saveData['w'] = v1
        saveData['h'] = v2
        return saveData

    def SetSaveData(self,data):
        dChild = data['detailClass']
        mod = dChild.split('.')[0]
        exec 'import %s' % mod
        detClass = eval(dChild)
        self.SetDimensions(data['x'],data['y'],data['w'],data['h'])
        old = self.detail
        self.detail = MultiClient(self,detClass)
        dData = data.get('detail',None)
        if dData:
            if hasattr(self.detail.child,'SetSaveData'):
                attr = getattr(self.detail.child,'SetSaveData')
                if callable(attr):
                    attr(dData)
        old.Destroy()
        self.detail.OnSize(None)

    def UnSelect(self):
        self.detail.UnSelect()

    def DefaultChildChanged(self):
        self.detail.SetNewChildCls(self.multiView._defChild)

    def AddLeaf(self,direction,pos):
        if pos < 10: return
        w,h = self.GetSize()
        if direction == MV_VER:
            if pos > h - 10: return
        else:
            if pos > w - 10: return
        self.GetParent().AddLeaf(direction,self,pos)

    def DestroyLeaf(self):
        self.GetParent().DestroyLeaf(self)

    def SizeTarget(self,side):
        return self.GetParent().SizeTarget(side,self)

    def CanSize(self,side):
        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)

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


class MultiClient(wx.Window):
    def __init__(self,parent,childCls):
        w,h = self.CalcSize(parent)
        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.Bind(wx.EVT_SET_FOCUS,self.OnSetFocus)
        self.Bind(wx.EVT_CHILD_FOCUS,self.OnChildFocus)

    def UnSelect(self):
        if self.selected:
            self.selected = False
            self.SetBackgroundColour(self.normalColour)
            self.Refresh()

    def Select(self):
        self.GetParent().multiView.UnSelect()
        self.selected = True
        self.SetBackgroundColour(wx.Colour(255,255,0)) # Yellow
        self.Refresh()

    def CalcSize(self,parent):
        w,h = parent.GetSize()
        w -= SH_SIZE
        h -= SH_SIZE
        return (w,h)

    def OnSize(self,evt):
        w,h = self.CalcSize(self.GetParent())
        self.SetDimensions(0,0,w,h)
        w,h = self.GetClientSize()
        self.child.SetSize((w-4,h-4))

    def SetNewChildCls(self,childCls):
        if self.child:
            self.child.Destroy()
            self.child = None
        self.child = childCls(self)
        self.child.MoveXY(2,2)

    def OnSetFocus(self,evt):
        self.Select()

    def OnChildFocus(self,evt):
        self.OnSetFocus(evt)
##        from Funcs import FindFocusedChild
##        child = FindFocusedChild(self)
##        child.Bind(wx.EVT_KILL_FOCUS,self.OnChildKillFocus)


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


class MultiSizer(wx.Window):
    def __init__(self,parent,side):
        self.side = side
        x,y,w,h = self.CalcSizePos(parent)
        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.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)

    def CalcSizePos(self,parent):
        pw,ph = parent.GetSize()
        if self.side == MV_HOR:
            x = CR_SIZE + 2
            y = ph - SH_SIZE
            w = pw - CR_SIZE - SH_SIZE - 2
            h = SH_SIZE
        else:
            x = pw - SH_SIZE
            y = CR_SIZE + 2 + SH_SIZE
            w = SH_SIZE
            h = ph - CR_SIZE - SH_SIZE - 4 - SH_SIZE # For Closer
        return (x,y,w,h)

    def OnSize(self,evt):
        x,y,w,h = self.CalcSizePos(self.GetParent())
        self.SetDimensions(x,y,w,h)

    def OnLeave(self,evt):
        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:
            self.SetCursor(wx.StockCursor(wx.CURSOR_SIZENS))
        else:
            self.SetCursor(wx.StockCursor(wx.CURSOR_SIZEWE))

    def OnMouseMove(self,evt):
        if self.isDrag:
            DrawSash(self.dragTarget,self.px,self.py,self.side)
            self.px,self.py = self.ClientToScreenXY(evt.m_x,evt.m_y)
            self.px,self.py = self.dragTarget.ScreenToClientXY(self.px,self.py)
            DrawSash(self.dragTarget,self.px,self.py,self.side)
        else:
            evt.Skip()

    def OnPress(self,evt):
        self.dragTarget = self.GetParent().SizeTarget(not self.side)
        if self.dragTarget:
            self.isDrag = True
            self.px,self.py = self.ClientToScreenXY(evt.m_x,evt.m_y)
            self.px,self.py = self.dragTarget.ScreenToClientXY(self.px,self.py)
            DrawSash(self.dragTarget,self.px,self.py,self.side)
            self.CaptureMouse()
        else:
            evt.Skip()

    def OnRelease(self,evt):
        if self.isDrag:
            DrawSash(self.dragTarget,self.px,self.py,self.side)
            self.ReleaseMouse()
            self.isDrag = False
            if self.side == MV_HOR:
                self.dragTarget.SizeLeaf(self.GetParent(),
                                         self.py,not self.side)
            else:
                self.dragTarget.SizeLeaf(self.GetParent(),
                                         self.px,not self.side)
            self.dragTarget = None
        else:
            evt.Skip()

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


class MultiCreator(wx.Window):
    def __init__(self,parent,side):
        self.side = side
        x,y,w,h = self.CalcSizePos(parent)
        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.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):
        pw,ph = parent.GetSize()
        if self.side == MV_HOR:
            x = 2
            y = ph - SH_SIZE
            w = CR_SIZE
            h = SH_SIZE
        else:
            x = pw - SH_SIZE
            y = 4 + SH_SIZE             # Make provision for closer
            w = SH_SIZE
            h = CR_SIZE
        return (x,y,w,h)

    def OnSize(self,evt):
        x,y,w,h = self.CalcSizePos(self.GetParent())
        self.SetDimensions(x,y,w,h)

    def OnLeave(self,evt):
        self.SetCursor(wx.StockCursor(wx.CURSOR_ARROW))

    def OnEnter(self,evt):
        if self.side == MV_HOR:
            self.SetCursor(wx.StockCursor(wx.CURSOR_HAND))
        else:
            self.SetCursor(wx.StockCursor(wx.CURSOR_POINT_LEFT))

    def OnMouseMove(self,evt):
        if self.isDrag:
            parent = self.GetParent()
            DrawSash(parent,self.px,self.py,self.side)
            self.px,self.py = self.ClientToScreenXY(evt.m_x,evt.m_y)
            self.px,self.py = parent.ScreenToClientXY(self.px,self.py)
            DrawSash(parent,self.px,self.py,self.side)
        else:
            evt.Skip()

    def OnPress(self,evt):
        self.isDrag = True
        parent = self.GetParent()
        self.px,self.py = self.ClientToScreenXY(evt.m_x,evt.m_y)
        self.px,self.py = parent.ScreenToClientXY(self.px,self.py)
        DrawSash(parent,self.px,self.py,self.side)
        self.CaptureMouse()

    def OnRelease(self,evt):
        if self.isDrag:
            parent = self.GetParent()
            DrawSash(parent,self.px,self.py,self.side)
            self.ReleaseMouse()
            self.isDrag = False

            if self.side == MV_HOR:
                parent.AddLeaf(MV_VER,self.py)
            else:
                parent.AddLeaf(MV_HOR,self.px)
        else:
            evt.Skip()

    def OnPaint(self,evt):
        dc = wx.PaintDC(self)
        dc.SetBackground(wx.Brush(self.GetBackgroundColour(),wx.SOLID))
        dc.Clear()

        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)
        dc.DrawLine((0,0), (0,h))
        dc.DrawLine((0,0), (w,0))
        dc.SetPen(black)
        dc.DrawLine((0,h), (w+1,h))
        dc.DrawLine((w,0), (w,h))
        dc.SetPen(shadow)
        dc.DrawLine((w-1,2), (w-1,h))

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


class MultiCloser(wx.Window):
    def __init__(self,parent):
        x,y,w,h = self.CalcSizePos(parent)
        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.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):
        self.SetCursor(wx.StockCursor(wx.CURSOR_ARROW))
        self.entered = False

    def OnEnter(self,evt):
        self.SetCursor(wx.StockCursor(wx.CURSOR_BULLSEYE))
        self.entered = True

    def OnPress(self,evt):
        self.down = True
        evt.Skip()

    def OnRelease(self,evt):
        if self.down and self.entered:
            self.GetParent().DestroyLeaf()
        else:
            evt.Skip()
        self.down = False

    def OnPaint(self,evt):
        dc = wx.PaintDC(self)
        dc.SetBackground(wx.Brush(wx.RED,wx.SOLID))
        dc.Clear()

    def CalcSizePos(self,parent):
        pw,ph = parent.GetSize()
        x = pw - SH_SIZE
        w = SH_SIZE
        h = SH_SIZE + 2
        y = 1
        return (x,y,w,h)

    def OnSize(self,evt):
        x,y,w,h = self.CalcSizePos(self.GetParent())
        self.SetDimensions(x,y,w,h)


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


class EmptyChild(wx.Window):
    def __init__(self,parent):
        wx.Window.__init__(self,parent,-1, style = wx.CLIP_CHILDREN)


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


def DrawSash(win,x,y,direction):
    dc = wx.ScreenDC()
    dc.StartDrawingOnTopWin(win)
    bmp = wx.EmptyBitmap(8,8)
    bdc = wx.MemoryDC()
    bdc.SelectObject(bmp)
    bdc.DrawRectangle((-1,-1), (10,10))
    for i in range(8):
        for j in range(8):
            if ((i + j) & 1):
                bdc.DrawPoint((i,j))

    brush = wx.Brush(wx.Colour(0,0,0))
    brush.SetStipple(bmp)

    dc.SetBrush(brush)
    dc.SetLogicalFunction(wx.XOR)

    body_w,body_h = win.GetClientSize()

    if y < 0:
        y = 0
    if y > body_h:
        y = body_h
    if x < 0:
        x = 0
    if x > body_w:
        x = body_w

    if direction == MV_HOR:
        x = 0
    else:
        y = 0

    x,y = win.ClientToScreenXY(x,y)

    w = body_w
    h = body_h

    if direction == MV_HOR:
        dc.DrawRectangle((x,y-2), (w,4))
    else:
        dc.DrawRectangle((x-2,y), (4,h))

    dc.EndDrawingOnTop()
Commit	Line	Data
d14a1e28 RD	1	#----------------------------------------------------------------------
	2	# Name: multisash
	3	# Purpose: Multi Sash control
	4	#
	5	# Author: Gerrit van Dyk
	6	#
	7	# Created: 2002/11/20
	8	# Version: 0.1
	9	# RCS-ID: $Id$
	10	# License: wxWindows licensie
	11	#----------------------------------------------------------------------
b881fc78 RD	12	# 12/09/2003 - Jeff Grimmett (grimmtooth@softhome.net)
	13	#
	14	# o 2.5 compatability update.
	15	#
1fded56b	16
b881fc78	17	import wx
1fded56b	18
d14a1e28 RD	19	MV_HOR = 0
	20	MV_VER = not MV_HOR
	21
	22	SH_SIZE = 5
	23	CR_SIZE = SH_SIZE * 3
	24
	25	#----------------------------------------------------------------------
	26
b881fc78	27	class wxMultiSash(wx.Window):
d14a1e28	28	def __init__(self, _args,*_kwargs):
b881fc78	29	apply(wx.Window.__init__,(self,) + _args,_kwargs)
d14a1e28	30	self._defChild = EmptyChild
b881fc78 RD	31	self.child = wxMultiSplit(self,self,(0,0),self.GetSize())
b881fc78 RD	32	self.Bind(wx.EVT_SIZE,self.OnMultiSize)
d14a1e28 RD	33
	34	def SetDefaultChildClass(self,childCls):
	35	self._defChild = childCls
	36	self.child.DefaultChildChanged()
	37
	38	def OnMultiSize(self,evt):
	39	self.child.SetSize(self.GetSize())
	40
	41	def UnSelect(self):
	42	self.child.UnSelect()
	43
	44	def Clear(self):
	45	old = self.child
b881fc78	46	self.child = wxMultiSplit(self,self,(0,0),self.GetSize())
d14a1e28 RD	47	old.Destroy()
	48	self.child.OnSize(None)
	49
	50	def GetSaveData(self):
	51	saveData = {}
	52	saveData['_defChild'] = str(self._defChild)
	53	saveData['child'] = self.child.GetSaveData()
	54	return saveData
	55
	56	def SetSaveData(self,data):
	57	dChild = data['_defChild']
	58	mod = dChild.split('.')[0]
	59	exec 'import %s' % mod
	60	self._defChild = eval(dChild)
	61	old = self.child
	62	self.child = wxMultiSplit(self,self,wxPoint(0,0),self.GetSize())
	63	self.child.SetSaveData(data['child'])
	64	old.Destroy()
	65	self.OnMultiSize(None)
	66	self.child.OnSize(None)
	67
	68
	69	#----------------------------------------------------------------------
	70
	71
b881fc78	72	class wxMultiSplit(wx.Window):
d14a1e28	73	def __init__(self,multiView,parent,pos,size,view1 = None):
b881fc78 RD	74	wx.Window.__init__(self,id = -1,parent = parent,pos = pos,size = size,
b881fc78 RD	75	style = wx.CLIP_CHILDREN)
d14a1e28 RD	76	self.multiView = multiView
	77	self.view2 = None
	78	if view1:
	79	self.view1 = view1
	80	self.view1.Reparent(self)
	81	self.view1.MoveXY(0,0)
	82	else:
	83	self.view1 = wxMultiViewLeaf(self.multiView,self,
b881fc78	84	(0,0),self.GetSize())
d14a1e28 RD	85	self.direction = None
d14a1e28 RD	86
b881fc78	87	self.Bind(wx.EVT_SIZE,self.OnSize)
d14a1e28 RD	88
	89	def GetSaveData(self):
	90	saveData = {}
	91	if self.view1:
	92	saveData['view1'] = self.view1.GetSaveData()
	93	if isinstance(self.view1,wxMultiSplit):
	94	saveData['view1IsSplit'] = 1
	95	if self.view2:
	96	saveData['view2'] = self.view2.GetSaveData()
	97	if isinstance(self.view2,wxMultiSplit):
	98	saveData['view2IsSplit'] = 1
	99	saveData['direction'] = self.direction
b881fc78	100	v1,v2 = self.GetPosition()
d14a1e28 RD	101	saveData['x'] = v1
d14a1e28 RD	102	saveData['y'] = v2
b881fc78	103	v1,v2 = self.GetSize()
d14a1e28 RD	104	saveData['w'] = v1
	105	saveData['h'] = v2
	106	return saveData
	107
	108	def SetSaveData(self,data):
	109	self.direction = data['direction']
	110	self.SetDimensions(data['x'],data['y'],data['w'],data['h'])
	111	v1Data = data.get('view1',None)
	112	if v1Data:
	113	isSplit = data.get('view1IsSplit',None)
	114	old = self.view1
	115	if isSplit:
	116	self.view1 = wxMultiSplit(self.multiView,self,
b881fc78	117	(0,0),self.GetSize())
d14a1e28 RD	118	else:
d14a1e28 RD	119	self.view1 = wxMultiViewLeaf(self.multiView,self,
b881fc78	120	(0,0),self.GetSize())
d14a1e28 RD	121	self.view1.SetSaveData(v1Data)
	122	if old:
	123	old.Destroy()
	124	v2Data = data.get('view2',None)
	125	if v2Data:
	126	isSplit = data.get('view2IsSplit',None)
	127	old = self.view2
	128	if isSplit:
	129	self.view2 = wxMultiSplit(self.multiView,self,
b881fc78	130	(0,0),self.GetSize())
d14a1e28 RD	131	else:
d14a1e28 RD	132	self.view2 = wxMultiViewLeaf(self.multiView,self,
b881fc78	133	(0,0),self.GetSize())
d14a1e28 RD	134	self.view2.SetSaveData(v2Data)
	135	if old:
	136	old.Destroy()
	137	if self.view1:
	138	self.view1.OnSize(None)
	139	if self.view2:
	140	self.view2.OnSize(None)
	141
	142	def UnSelect(self):
	143	if self.view1:
	144	self.view1.UnSelect()
	145	if self.view2:
	146	self.view2.UnSelect()
	147
	148	def DefaultChildChanged(self):
	149	if not self.view2:
	150	self.view1.DefaultChildChanged()
	151
	152	def AddLeaf(self,direction,caller,pos):
	153	if self.view2:
	154	if caller == self.view1:
	155	self.view1 = wxMultiSplit(self.multiView,self,
	156	caller.GetPosition(),
	157	caller.GetSize(),
	158	caller)
	159	self.view1.AddLeaf(direction,caller,pos)
	160	else:
	161	self.view2 = wxMultiSplit(self.multiView,self,
	162	caller.GetPosition(),
	163	caller.GetSize(),
	164	caller)
	165	self.view2.AddLeaf(direction,caller,pos)
	166	else:
	167	self.direction = direction
b881fc78	168	w,h = self.GetSize()
d14a1e28 RD	169	if direction == MV_HOR:
	170	x,y = (pos,0)
	171	w1,h1 = (w-pos,h)
	172	w2,h2 = (pos,h)
	173	else:
	174	x,y = (0,pos)
	175	w1,h1 = (w,h-pos)
	176	w2,h2 = (w,pos)
b881fc78 RD	177	self.view2 = wxMultiViewLeaf(self.multiView, self, (x,y), (w1,h1))
b881fc78 RD	178	self.view1.SetSize((w2,h2))
d14a1e28 RD	179	self.view2.OnSize(None)
	180
	181	def DestroyLeaf(self,caller):
	182	if not self.view2: # We will only have 2 windows if
	183	return # we need to destroy any
	184	parent = self.GetParent() # Another splitview
	185	if parent == self.multiView: # We'r at the root
	186	if caller == self.view1:
	187	old = self.view1
	188	self.view1 = self.view2
	189	self.view2 = None
	190	old.Destroy()
	191	else:
	192	self.view2.Destroy()
	193	self.view2 = None
	194	self.view1.SetSize(self.GetSize())
	195	self.view1.Move(self.GetPosition())
	196	else:
b881fc78 RD	197	w,h = self.GetSize()
b881fc78 RD	198	x,y = self.GetPosition()
d14a1e28 RD	199	if caller == self.view1:
	200	if self == parent.view1:
	201	parent.view1 = self.view2
	202	else:
	203	parent.view2 = self.view2
	204	self.view2.Reparent(parent)
	205	self.view2.SetDimensions(x,y,w,h)
	206	else:
	207	if self == parent.view1:
	208	parent.view1 = self.view1
	209	else:
	210	parent.view2 = self.view1
	211	self.view1.Reparent(parent)
	212	self.view1.SetDimensions(x,y,w,h)
	213	self.view1 = None
	214	self.view2 = None
	215	self.Destroy()
	216
	217	def CanSize(self,side,view):
	218	if self.SizeTarget(side,view):
	219	return True
	220	return False
	221
	222	def SizeTarget(self,side,view):
	223	if self.direction == side and self.view2 and view == self.view1:
	224	return self
	225	parent = self.GetParent()
	226	if parent != self.multiView:
	227	return parent.SizeTarget(side,self)
	228	return None
	229
	230	def SizeLeaf(self,leaf,pos,side):
	231	if self.direction != side:
	232	return
	233	if not (self.view1 and self.view2):
	234	return
	235	if pos < 10: return
b881fc78	236	w,h = self.GetSize()
d14a1e28 RD	237	if side == MV_HOR:
	238	if pos > w - 10: return
	239	else:
	240	if pos > h - 10: return
	241	if side == MV_HOR:
	242	self.view1.SetDimensions(0,0,pos,h)
	243	self.view2.SetDimensions(pos,0,w-pos,h)
	244	else:
	245	self.view1.SetDimensions(0,0,w,pos)
	246	self.view2.SetDimensions(0,pos,w,h-pos)
	247
	248	def OnSize(self,evt):
	249	if not self.view2:
	250	self.view1.SetSize(self.GetSize())
	251	self.view1.OnSize(None)
	252	return
b881fc78 RD	253	v1w,v1h = self.view1.GetSize()
	254	v2w,v2h = self.view2.GetSize()
	255	v1x,v1y = self.view1.GetPosition()
	256	v2x,v2y = self.view2.GetPosition()
	257	w,h = self.GetSize()
d14a1e28 RD	258
	259	if v1x != v2x:
	260	ratio = float(w) / float((v1w + v2w))
	261	v1w *= ratio
	262	v2w = w - v1w
	263	v2x = v1w
	264	else:
	265	v1w = v2w = w
	266
	267	if v1y != v2y:
	268	ratio = float(h) / float((v1h + v2h))
	269	v1h *= ratio
	270	v2h = h - v1h
	271	v2y = v1h
	272	else:
	273	v1h = v2h = h
	274
	275	self.view1.SetDimensions(v1x,v1y,v1w,v1h)
	276	self.view2.SetDimensions(v2x,v2y,v2w,v2h)
	277	self.view1.OnSize(None)
	278	self.view2.OnSize(None)
	279
	280
	281	#----------------------------------------------------------------------
	282
	283
b881fc78	284	class wxMultiViewLeaf(wx.Window):
d14a1e28	285	def __init__(self,multiView,parent,pos,size):
b881fc78 RD	286	wx.Window.__init__(self,id = -1,parent = parent,pos = pos,size = size,
b881fc78 RD	287	style = wx.CLIP_CHILDREN)
d14a1e28 RD	288	self.multiView = multiView
	289
	290	self.sizerHor = MultiSizer(self,MV_HOR)
	291	self.sizerVer = MultiSizer(self,MV_VER)
	292	self.creatorHor = MultiCreator(self,MV_HOR)
	293	self.creatorVer = MultiCreator(self,MV_VER)
	294	self.detail = MultiClient(self,multiView._defChild)
	295	self.closer = MultiCloser(self)
	296
b881fc78	297	self.Bind(wx.EVT_SIZE,self.OnSize)
d14a1e28 RD	298
	299	def GetSaveData(self):
	300	saveData = {}
	301	saveData['detailClass'] = str(self.detail.child.__class__)
	302	if hasattr(self.detail.child,'GetSaveData'):
	303	attr = getattr(self.detail.child,'GetSaveData')
	304	if callable(attr):
	305	dData = attr()
	306	if dData:
	307	saveData['detail'] = dData
b881fc78	308	v1,v2 = self.GetPosition()
d14a1e28 RD	309	saveData['x'] = v1
d14a1e28 RD	310	saveData['y'] = v2
b881fc78	311	v1,v2 = self.GetSize()
d14a1e28 RD	312	saveData['w'] = v1
	313	saveData['h'] = v2
	314	return saveData
	315
	316	def SetSaveData(self,data):
	317	dChild = data['detailClass']
	318	mod = dChild.split('.')[0]
	319	exec 'import %s' % mod
	320	detClass = eval(dChild)
	321	self.SetDimensions(data['x'],data['y'],data['w'],data['h'])
	322	old = self.detail
	323	self.detail = MultiClient(self,detClass)
	324	dData = data.get('detail',None)
	325	if dData:
	326	if hasattr(self.detail.child,'SetSaveData'):
	327	attr = getattr(self.detail.child,'SetSaveData')
	328	if callable(attr):
	329	attr(dData)
	330	old.Destroy()
	331	self.detail.OnSize(None)
	332
	333	def UnSelect(self):
	334	self.detail.UnSelect()
	335
	336	def DefaultChildChanged(self):
	337	self.detail.SetNewChildCls(self.multiView._defChild)
	338
	339	def AddLeaf(self,direction,pos):
	340	if pos < 10: return
b881fc78	341	w,h = self.GetSize()
d14a1e28 RD	342	if direction == MV_VER:
	343	if pos > h - 10: return
	344	else:
	345	if pos > w - 10: return
	346	self.GetParent().AddLeaf(direction,self,pos)
	347
	348	def DestroyLeaf(self):
	349	self.GetParent().DestroyLeaf(self)
	350
	351	def SizeTarget(self,side):
	352	return self.GetParent().SizeTarget(side,self)
	353
	354	def CanSize(self,side):
	355	return self.GetParent().CanSize(side,self)
	356
	357	def OnSize(self,evt):
	358	self.sizerHor.OnSize(evt)
	359	self.sizerVer.OnSize(evt)
	360	self.creatorHor.OnSize(evt)
	361	self.creatorVer.OnSize(evt)
	362	self.detail.OnSize(evt)
	363	self.closer.OnSize(evt)
	364
	365	#----------------------------------------------------------------------
	366
	367
b881fc78	368	class MultiClient(wx.Window):
d14a1e28 RD	369	def __init__(self,parent,childCls):
d14a1e28 RD	370	w,h = self.CalcSize(parent)
b881fc78 RD	371	wx.Window.__init__(self,id = -1,parent = parent,
	372	pos = (0,0),
	373	size = (w,h),
	374	style = wx.CLIP_CHILDREN \| wx.SUNKEN_BORDER)
d14a1e28 RD	375	self.child = childCls(self)
	376	self.child.MoveXY(2,2)
	377	self.normalColour = self.GetBackgroundColour()
	378	self.selected = False
	379
b881fc78 RD	380	self.Bind(wx.EVT_SET_FOCUS,self.OnSetFocus)
b881fc78 RD	381	self.Bind(wx.EVT_CHILD_FOCUS,self.OnChildFocus)
d14a1e28 RD	382
	383	def UnSelect(self):
	384	if self.selected:
	385	self.selected = False
	386	self.SetBackgroundColour(self.normalColour)
	387	self.Refresh()
	388
	389	def Select(self):
	390	self.GetParent().multiView.UnSelect()
	391	self.selected = True
b881fc78	392	self.SetBackgroundColour(wx.Colour(255,255,0)) # Yellow
d14a1e28 RD	393	self.Refresh()
	394
	395	def CalcSize(self,parent):
b881fc78	396	w,h = parent.GetSize()
d14a1e28 RD	397	w -= SH_SIZE
	398	h -= SH_SIZE
	399	return (w,h)
	400
	401	def OnSize(self,evt):
	402	w,h = self.CalcSize(self.GetParent())
	403	self.SetDimensions(0,0,w,h)
b881fc78 RD	404	w,h = self.GetClientSize()
b881fc78 RD	405	self.child.SetSize((w-4,h-4))
d14a1e28 RD	406
	407	def SetNewChildCls(self,childCls):
	408	if self.child:
	409	self.child.Destroy()
	410	self.child = None
	411	self.child = childCls(self)
	412	self.child.MoveXY(2,2)
	413
	414	def OnSetFocus(self,evt):
	415	self.Select()
	416
	417	def OnChildFocus(self,evt):
	418	self.OnSetFocus(evt)
	419	## from Funcs import FindFocusedChild
	420	## child = FindFocusedChild(self)
b881fc78	421	## child.Bind(wx.EVT_KILL_FOCUS,self.OnChildKillFocus)
d14a1e28 RD	422
	423
	424	#----------------------------------------------------------------------
	425
	426
b881fc78	427	class MultiSizer(wx.Window):
d14a1e28 RD	428	def __init__(self,parent,side):
	429	self.side = side
	430	x,y,w,h = self.CalcSizePos(parent)
b881fc78 RD	431	wx.Window.__init__(self,id = -1,parent = parent,
	432	pos = (x,y),
	433	size = (w,h),
	434	style = wx.CLIP_CHILDREN)
d14a1e28 RD	435
	436	self.px = None # Previous X
	437	self.py = None # Previous Y
	438	self.isDrag = False # In Dragging
	439	self.dragTarget = None # View being sized
	440
b881fc78 RD	441	self.Bind(wx.EVT_LEAVE_WINDOW,self.OnLeave)
	442	self.Bind(wx.EVT_ENTER_WINDOW,self.OnEnter)
	443	self.Bind(wx.EVT_MOTION,self.OnMouseMove)
	444	self.Bind(wx.EVT_LEFT_DOWN,self.OnPress)
	445	self.Bind(wx.EVT_LEFT_UP,self.OnRelease)
d14a1e28 RD	446
d14a1e28 RD	447	def CalcSizePos(self,parent):
b881fc78	448	pw,ph = parent.GetSize()
d14a1e28 RD	449	if self.side == MV_HOR:
	450	x = CR_SIZE + 2
	451	y = ph - SH_SIZE
	452	w = pw - CR_SIZE - SH_SIZE - 2
	453	h = SH_SIZE
	454	else:
	455	x = pw - SH_SIZE
	456	y = CR_SIZE + 2 + SH_SIZE
	457	w = SH_SIZE
	458	h = ph - CR_SIZE - SH_SIZE - 4 - SH_SIZE # For Closer
	459	return (x,y,w,h)
	460
	461	def OnSize(self,evt):
	462	x,y,w,h = self.CalcSizePos(self.GetParent())
	463	self.SetDimensions(x,y,w,h)
	464
	465	def OnLeave(self,evt):
b881fc78	466	self.SetCursor(wx.StockCursor(wx.CURSOR_ARROW))
d14a1e28 RD	467
	468	def OnEnter(self,evt):
	469	if not self.GetParent().CanSize(not self.side):
	470	return
	471	if self.side == MV_HOR:
b881fc78	472	self.SetCursor(wx.StockCursor(wx.CURSOR_SIZENS))
d14a1e28	473	else:
b881fc78	474	self.SetCursor(wx.StockCursor(wx.CURSOR_SIZEWE))
d14a1e28 RD	475
	476	def OnMouseMove(self,evt):
	477	if self.isDrag:
	478	DrawSash(self.dragTarget,self.px,self.py,self.side)
	479	self.px,self.py = self.ClientToScreenXY(evt.m_x,evt.m_y)
	480	self.px,self.py = self.dragTarget.ScreenToClientXY(self.px,self.py)
	481	DrawSash(self.dragTarget,self.px,self.py,self.side)
	482	else:
	483	evt.Skip()
	484
	485	def OnPress(self,evt):
	486	self.dragTarget = self.GetParent().SizeTarget(not self.side)
	487	if self.dragTarget:
	488	self.isDrag = True
	489	self.px,self.py = self.ClientToScreenXY(evt.m_x,evt.m_y)
	490	self.px,self.py = self.dragTarget.ScreenToClientXY(self.px,self.py)
	491	DrawSash(self.dragTarget,self.px,self.py,self.side)
	492	self.CaptureMouse()
	493	else:
	494	evt.Skip()
	495
	496	def OnRelease(self,evt):
	497	if self.isDrag:
	498	DrawSash(self.dragTarget,self.px,self.py,self.side)
	499	self.ReleaseMouse()
	500	self.isDrag = False
	501	if self.side == MV_HOR:
	502	self.dragTarget.SizeLeaf(self.GetParent(),
	503	self.py,not self.side)
	504	else:
	505	self.dragTarget.SizeLeaf(self.GetParent(),
	506	self.px,not self.side)
	507	self.dragTarget = None
	508	else:
	509	evt.Skip()
	510
	511	#----------------------------------------------------------------------
	512
	513
b881fc78	514	class MultiCreator(wx.Window):
d14a1e28 RD	515	def __init__(self,parent,side):
	516	self.side = side
	517	x,y,w,h = self.CalcSizePos(parent)
b881fc78 RD	518	wx.Window.__init__(self,id = -1,parent = parent,
	519	pos = (x,y),
	520	size = (w,h),
	521	style = wx.CLIP_CHILDREN)
d14a1e28 RD	522
	523	self.px = None # Previous X
	524	self.py = None # Previous Y
	525	self.isDrag = False # In Dragging
	526
b881fc78 RD	527	self.Bind(wx.EVT_LEAVE_WINDOW,self.OnLeave)
	528	self.Bind(wx.EVT_ENTER_WINDOW,self.OnEnter)
	529	self.Bind(wx.EVT_MOTION,self.OnMouseMove)
	530	self.Bind(wx.EVT_LEFT_DOWN,self.OnPress)
	531	self.Bind(wx.EVT_LEFT_UP,self.OnRelease)
	532	self.Bind(wx.EVT_PAINT,self.OnPaint)
d14a1e28 RD	533
d14a1e28 RD	534	def CalcSizePos(self,parent):
b881fc78	535	pw,ph = parent.GetSize()
d14a1e28 RD	536	if self.side == MV_HOR:
	537	x = 2
	538	y = ph - SH_SIZE
	539	w = CR_SIZE
	540	h = SH_SIZE
	541	else:
	542	x = pw - SH_SIZE
	543	y = 4 + SH_SIZE # Make provision for closer
	544	w = SH_SIZE
	545	h = CR_SIZE
	546	return (x,y,w,h)
	547
	548	def OnSize(self,evt):
	549	x,y,w,h = self.CalcSizePos(self.GetParent())
	550	self.SetDimensions(x,y,w,h)
	551
	552	def OnLeave(self,evt):
b881fc78	553	self.SetCursor(wx.StockCursor(wx.CURSOR_ARROW))
d14a1e28 RD	554
	555	def OnEnter(self,evt):
	556	if self.side == MV_HOR:
b881fc78	557	self.SetCursor(wx.StockCursor(wx.CURSOR_HAND))
d14a1e28	558	else:
b881fc78	559	self.SetCursor(wx.StockCursor(wx.CURSOR_POINT_LEFT))
d14a1e28 RD	560
	561	def OnMouseMove(self,evt):
	562	if self.isDrag:
	563	parent = self.GetParent()
	564	DrawSash(parent,self.px,self.py,self.side)
	565	self.px,self.py = self.ClientToScreenXY(evt.m_x,evt.m_y)
	566	self.px,self.py = parent.ScreenToClientXY(self.px,self.py)
	567	DrawSash(parent,self.px,self.py,self.side)
	568	else:
	569	evt.Skip()
	570
	571	def OnPress(self,evt):
	572	self.isDrag = True
	573	parent = self.GetParent()
	574	self.px,self.py = self.ClientToScreenXY(evt.m_x,evt.m_y)
	575	self.px,self.py = parent.ScreenToClientXY(self.px,self.py)
	576	DrawSash(parent,self.px,self.py,self.side)
	577	self.CaptureMouse()
	578
	579	def OnRelease(self,evt):
	580	if self.isDrag:
	581	parent = self.GetParent()
	582	DrawSash(parent,self.px,self.py,self.side)
	583	self.ReleaseMouse()
	584	self.isDrag = False
	585
	586	if self.side == MV_HOR:
	587	parent.AddLeaf(MV_VER,self.py)
	588	else:
	589	parent.AddLeaf(MV_HOR,self.px)
	590	else:
	591	evt.Skip()
	592
	593	def OnPaint(self,evt):
b881fc78 RD	594	dc = wx.PaintDC(self)
b881fc78 RD	595	dc.SetBackground(wx.Brush(self.GetBackgroundColour(),wx.SOLID))
d14a1e28 RD	596	dc.Clear()
d14a1e28 RD	597
b881fc78 RD	598	highlight = wx.Pen(wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNHIGHLIGHT), 1, wx.SOLID)
	599	shadow = wx.Pen(wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNSHADOW), 1, wx.SOLID)
	600	black = wx.Pen(wx.BLACK,1,wx.SOLID)
	601	w,h = self.GetSize()
d14a1e28 RD	602	w -= 1
	603	h -= 1
	604
	605	# Draw outline
	606	dc.SetPen(highlight)
7722248d RD	607	dc.DrawLine((0,0), (0,h))
7722248d RD	608	dc.DrawLine((0,0), (w,0))
d14a1e28	609	dc.SetPen(black)
7722248d RD	610	dc.DrawLine((0,h), (w+1,h))
7722248d RD	611	dc.DrawLine((w,0), (w,h))
d14a1e28	612	dc.SetPen(shadow)
7722248d	613	dc.DrawLine((w-1,2), (w-1,h))
d14a1e28 RD	614
	615	#----------------------------------------------------------------------
	616
	617
b881fc78	618	class MultiCloser(wx.Window):
d14a1e28 RD	619	def __init__(self,parent):
d14a1e28 RD	620	x,y,w,h = self.CalcSizePos(parent)
b881fc78 RD	621	wx.Window.__init__(self,id = -1,parent = parent,
	622	pos = (x,y),
	623	size = (w,h),
	624	style = wx.CLIP_CHILDREN)
d14a1e28 RD	625
	626	self.down = False
	627	self.entered = False
	628
b881fc78 RD	629	self.Bind(wx.EVT_LEFT_DOWN,self.OnPress)
	630	self.Bind(wx.EVT_LEFT_UP,self.OnRelease)
	631	self.Bind(wx.EVT_PAINT,self.OnPaint)
	632	self.Bind(wx.EVT_LEAVE_WINDOW,self.OnLeave)
	633	self.Bind(wx.EVT_ENTER_WINDOW,self.OnEnter)
d14a1e28 RD	634
d14a1e28 RD	635	def OnLeave(self,evt):
b881fc78	636	self.SetCursor(wx.StockCursor(wx.CURSOR_ARROW))
d14a1e28 RD	637	self.entered = False
	638
	639	def OnEnter(self,evt):
b881fc78	640	self.SetCursor(wx.StockCursor(wx.CURSOR_BULLSEYE))
d14a1e28 RD	641	self.entered = True
	642
	643	def OnPress(self,evt):
	644	self.down = True
	645	evt.Skip()
	646
	647	def OnRelease(self,evt):
	648	if self.down and self.entered:
	649	self.GetParent().DestroyLeaf()
	650	else:
	651	evt.Skip()
	652	self.down = False
	653
	654	def OnPaint(self,evt):
b881fc78 RD	655	dc = wx.PaintDC(self)
b881fc78 RD	656	dc.SetBackground(wx.Brush(wx.RED,wx.SOLID))
d14a1e28 RD	657	dc.Clear()
	658
	659	def CalcSizePos(self,parent):
b881fc78	660	pw,ph = parent.GetSize()
d14a1e28 RD	661	x = pw - SH_SIZE
	662	w = SH_SIZE
	663	h = SH_SIZE + 2
	664	y = 1
	665	return (x,y,w,h)
	666
	667	def OnSize(self,evt):
	668	x,y,w,h = self.CalcSizePos(self.GetParent())
	669	self.SetDimensions(x,y,w,h)
	670
	671
	672	#----------------------------------------------------------------------
	673
	674
b881fc78	675	class EmptyChild(wx.Window):
d14a1e28	676	def __init__(self,parent):
b881fc78	677	wx.Window.__init__(self,parent,-1, style = wx.CLIP_CHILDREN)
d14a1e28 RD	678
	679
	680	#----------------------------------------------------------------------
	681
	682
	683	def DrawSash(win,x,y,direction):
b881fc78	684	dc = wx.ScreenDC()
d14a1e28	685	dc.StartDrawingOnTopWin(win)
b881fc78 RD	686	bmp = wx.EmptyBitmap(8,8)
b881fc78 RD	687	bdc = wx.MemoryDC()
d14a1e28	688	bdc.SelectObject(bmp)
7722248d	689	bdc.DrawRectangle((-1,-1), (10,10))
d14a1e28 RD	690	for i in range(8):
	691	for j in range(8):
	692	if ((i + j) & 1):
7722248d	693	bdc.DrawPoint((i,j))
d14a1e28	694
b881fc78	695	brush = wx.Brush(wx.Colour(0,0,0))
d14a1e28 RD	696	brush.SetStipple(bmp)
	697
	698	dc.SetBrush(brush)
b881fc78	699	dc.SetLogicalFunction(wx.XOR)
d14a1e28	700
b881fc78	701	body_w,body_h = win.GetClientSize()
d14a1e28 RD	702
	703	if y < 0:
	704	y = 0
	705	if y > body_h:
	706	y = body_h
	707	if x < 0:
	708	x = 0
	709	if x > body_w:
	710	x = body_w
	711
	712	if direction == MV_HOR:
	713	x = 0
	714	else:
	715	y = 0
	716
	717	x,y = win.ClientToScreenXY(x,y)
	718
	719	w = body_w
	720	h = body_h
	721
	722	if direction == MV_HOR:
7722248d	723	dc.DrawRectangle((x,y-2), (w,4))
d14a1e28	724	else:
7722248d	725	dc.DrawRectangle((x-2,y), (4,h))
d14a1e28 RD	726
d14a1e28 RD	727	dc.EndDrawingOnTop()