root/trunk/RBSkinning/RBSkinning/wxTools/wxLockingFrame.py

#!/usr/bin/env python
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
##~ License 
##~ 
##- The RuneBlade Foundation library is intended to ease some 
##- aspects of writing intricate Jabber, XML, and User Interface (wxPython, etc.) 
##- applications, while providing the flexibility to modularly change the 
##- architecture. Enjoy.
##~ 
##~ Copyright (C) 2002  TechGame Networks, LLC.
##~ 
##~ This library is free software; you can redistribute it and/or
##~ modify it under the terms of the BSD style License as found in the 
##~ LICENSE file included with this distribution.
##~ 
##~ TechGame Networks, LLC can be reached at:
##~ 3578 E. Hartsel Drive #211
##~ Colorado Springs, Colorado, USA, 80920
##~
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

"""Frame locking (docking) code.

Frame locking (docking) is most useful when there are a LOT of windows about
and our human instincts plead for us to align them."""

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Imports 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

import weakref
from wxPython import wx
from RBFoundation.BindCallable import BindCallable

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Definitions 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class wxLockSide:
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Constants / Variables / Etc. 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    _DeltaWing = 10
    _DeltaAttract = 10
    _DeltaResist = 10

    _LockingSides = [
        ({}, 2), # Left - outer
        ({}, 3), # Top - outer
        ({}, 0), # Right - outer
        ({}, 1), # Bottom - outer

        ({}, 0), # Left - inner
        ({}, 1), # Top - inner
        ({}, 2), # Right - inner
        ({}, 3), # Bottom - inner
        ]

    SizeConstants = {
        'Left': 0, 'Top': 1, 'Right': 2, 'Bottom': 3,
        'LeftInner': 4, 'TopInner': 5, 'RightInner': 6, 'BottomInner': 7,
    }
    locals().update(SizeConstants)

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Class Methods
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    def RemoveSidePositions(self, key):
        for each in self._LockingSides:
            del each[0][key]

    def SaveSidePositions(self, key, rect):
        return self.SaveSidePositionsEx(key, rect, outsides=True, insides=True, deltas=(self._DeltaAttract, self._DeltaResist, self._DeltaWing))

    def SaveSidePositionsEx(Class, key, rect, outsides=True, insides=True, deltas=None):
        l,t,w,h = rect
        dAttract, dResist, dWing = deltas or (Class._DeltaAttract, Class._DeltaResist, Class._DeltaWing)
        if outsides:
            Class._LockingSides[Class.Left][0][key] = [(l-dAttract, t, l+dResist, t+h, l)]
            Class._LockingSides[Class.Right][0][key] = [(l+w-dResist, t, l+w+dAttract, t+h, l+w)]
            Class._LockingSides[Class.Bottom][0][key] = [(l, t+h-dResist, l+w, t+h+dAttract, t+h)]
            Class._LockingSides[Class.Top][0][key] = [(l, t-dAttract, l+w, t+dResist, t)]

        if insides:
            Class._LockingSides[Class.LeftInner][0][key] = [(l-dResist, t-dWing, l+dAttract, t, l), (l-dResist, t+h, l+dAttract, t+h+dWing, l)]
            Class._LockingSides[Class.RightInner][0][key] = [(l+w-dAttract, t-dWing, l+w+dResist, t, l+w), (l+w-dAttract, t+h, l+w+dResist, t+h+dWing, l+w)]
            Class._LockingSides[Class.BottomInner][0][key] = [(l-dWing, t+h-dAttract, l, t+h+dResist, t+h), (l+w, t+h-dAttract, l+w+dWing, t+h+dResist, t+h)]
            Class._LockingSides[Class.TopInner][0][key] = [(l-dWing, t-dResist, l, t+dAttract, t), (l+w, t-dResist, l+w+dWing, t+dAttract, t)]
    SaveSidePositionsEx = classmethod(SaveSidePositionsEx)

    def SetupInternalLockingSides(Class, key, rect, deltas=None):
        l,t,w,h = rect
        dAttract, dResist, dWing = deltas or (Class._DeltaAttract, Class._DeltaResist, Class._DeltaWing)
        Class._LockingSides[Class.LeftInner][0][key] = [(l-dResist, t, l+dAttract, t+h, l)]
        Class._LockingSides[Class.RightInner][0][key] = [(l+w-dAttract, t, l+w+dResist, t+h, l+w)]
        Class._LockingSides[Class.BottomInner][0][key] = [(l, t+h-dAttract, l+w, t+h+dResist, t+h)]
        Class._LockingSides[Class.TopInner][0][key] = [(l, t-dResist, l+w, t+dAttract, t)]
    SetupInternalLockingSides = classmethod(SetupInternalLockingSides)

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

def LockWindowsTogether(HostWin, AttachWin, LockSideIndicies=(wxLockSide.Bottom,wxLockSide.LeftInner), LockSizeIndicies=tuple()):
    # Lookup the constant aliases
    LockSideIndicies = [wxLockSide.SizeConstants.get(i, i) for i in LockSideIndicies]
    LockSizeIndicies = [wxLockSide.SizeConstants.get(i, i) for i in LockSizeIndicies]

    if HostWin.IsTopLevel() ^ AttachWin.IsTopLevel():
        # If both HostWin xor AttachWin are top level windows (Frame or Dialog), then figure out screen coordinates
        hostrect = HostWin.ClientToScreen((0,0)).asTuple() + HostWin.GetSize().asTuple()
    else:
        # Otherwise, assume that they are in the same frame of reference.  (Until we get a bug for shortsightedness ;)
        hostrect = HostWin.GetRect().asTuple()
    Positions = _GetIntersectionPositions(*(hostrect + AttachWin.GetSizeTuple()))
    return _DoLockWindowToPositon(AttachWin, Positions, LockSideIndicies, LockSizeIndicies)

def LockToDesktop(AttachWin, LockSideIndicies=(wxLockSide.TopInner,wxLockSide.LeftInner), LockSizeIndicies=tuple()):
    LockSideIndicies = [wxLockSide.SizeConstants.get(i, i) for i in LockSideIndicies]
    LockSizeIndicies = [wxLockSide.SizeConstants.get(i, i) for i in LockSizeIndicies]
    Positions = _GetIntersectionPositions(*(wx.wxGetClientDisplayRect().asTuple() + AttachWin.GetSizeTuple()))
    return _DoLockWindowToPositon(AttachWin, Positions, LockSideIndicies, LockSizeIndicies)

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class wxLockingFrameBase(wx.wxFrame, wxLockSide):
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Constants / Variables / Etc. 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    _weakself = None
    __bLocking = 0

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Special 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    def __init__(self, *args, **kw):
        wx.wxFrame.__init__(self, *args, **kw)

        wx.EVT_SIZE(self, BindCallable(self._OnSizeFrame))
        wx.EVT_MOVE(self, BindCallable(self._OnMoveFrame))
        self.PushEventHandler(wx.wxEvtHandler())

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Public Methods 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    def Show(self, bShow=1):
        result = wx.wxFrame.Show(self, bShow)
        self._SaveSidePositions()
        return result

    def Move(self, pos):
        self.__bLocking = 1
        if isinstance(pos, (tuple, list)): newpos = pos
        else: newpos = pos.x, pos.y

        newpos, newsize = self._OnLockingMove(newpos, self.GetSizeTuple()) or newpos
        result = wx.wxFrame.Move(self, newpos)

        self.__bLocking = 0
        return result

    def SetDimensions(self, x, y, w, h, *args, **kw):
        self.__bLocking= 1
        newpos, newsize = self._OnLockingMove((x,y), (w,h))
        newpos, newsize = self._OnLockingSize(newpos, newsize)
        result = self._DoSetDimensions(*(newpos + newsize + args), **kw)
        self.__bLocking= 0
        return result

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    
    def LockFrameToSelf(self, frame, LockSideIndicies=(wxLockSide.Bottom,wxLockSide.LeftInner), LockSizeIndicies=tuple()):
        return LockWindowsTogether(self, frame, LockSideIndicies, LockSizeIndicies)

    def LockToFrame(self, frame, LockSideIndicies=(wxLockSide.Bottom,wxLockSide.LeftInner), LockSizeIndicies=tuple()):
        return LockWindowsTogether(frame, self, LockSideIndicies, LockSizeIndicies)

    def LockToDesktop(self, LockSideIndicies=(wxLockSide.TopInner,wxLockSide.LeftInner), LockSizeIndicies=tuple()):
        return LockToDesktop(self, LockSideIndicies, LockSizeIndicies)

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Event Handlers
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    def _OnSizeFrame(self, evt):
        if not self.__bLocking:
            self.__bLocking = 1
            pos, size = self.GetPositionTuple(), self.GetSizeTuple()
            newpos, newsize = self._OnLockingSize(pos, size)
            self._DoSetDimensions(*(newpos + newsize))
            self.__bLocking = 0
        self._SaveSidePositions()
        evt.Skip()

    def _OnMoveFrame(self, evt):
        if not self.__bLocking:
            self.__bLocking= 1
            pos, size = self.GetPositionTuple(), self.GetSizeTuple()
            newpos, newsize = self._OnLockingMove(pos, size)
            self._DoSetDimensions(*(newpos + newsize))
            self.__bLocking= 0
        self._SaveSidePositions()
        evt.Skip()

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Protected Methods 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    def _DoSetDimensions(self, *args, **kw):
        wx.wxFrame.SetDimensions(self, *args, **kw)

    def _RemoveSidePositions(self):
        if self._weakself:
            self.RemoveSidePositions(self._weakself)
            self._weakself = None

    def _SaveSidePositions(self):
        if not self.IsShown() or self.IsIconized():
            return self._RemoveSidePositions()
        self._weakself = weakref.ref(self)
        l,t,w,h = self.GetRect().asTuple()
        self.SaveSidePositions(self._weakself, (l,t,w,h))

    def _OnLockingMove(self, pos, size):
        (l,t),(w,h) = pos, size
        IntersectionSides = _GetIntersectionSides(l,t,w,h)
        for (LockingSides, WidthIdx), FrameSide in zip(self._LockingSides, IntersectionSides):
            for weakframe, SideList in LockingSides.iteritems():
                if weakframe is self._weakself: continue
                for Side in SideList:
                    if _Intersects(FrameSide, Side):
                        if WidthIdx == 0: pos = Side[-1], pos[1], 
                        elif WidthIdx == 1: pos = pos[0], Side[-1], 
                        elif WidthIdx == 2: pos = Side[-1]-w, pos[1], 
                        elif WidthIdx == 3: pos = pos[0], Side[-1]-h, 
                        break
        return pos, size

    def _OnLockingSize(self, pos, size):
        (l,t),(w,h) = pos, size
        IntersectionSides = _GetIntersectionSides(l,t,w,h)
        for (LockingSides, WidthIdx), FrameSide in zip(self._LockingSides, IntersectionSides):
            for weakframe, SideList in LockingSides.iteritems():
                if weakframe is self._weakself: continue
                for Side in SideList:
                    if _Intersects(FrameSide, Side):
                        if WidthIdx == 0: pos = Side[-1], pos[1], 
                        elif WidthIdx == 1: pos = pos[0], Side[-1], 
                        elif WidthIdx == 2: size = Side[-1]-pos[0], size[1], 
                        elif WidthIdx == 3: size = size[0], Side[-1]-pos[1], 
                        break
        return pos, size

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Utilities 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

def _DoLockWindowToPositon(window, Positions, LockSideIndicies, LockSizeIndicies, pos=None, size=None):
    pos, size = pos or window.GetPositionTuple(), size or window.GetSizeTuple()
    for LockIndex in LockSideIndicies:
        if LockIndex & 1: pos = pos[0], Positions[LockIndex] 
        else: pos = Positions[LockIndex], pos[1]

    newpos, pos = pos, (pos[0] + size[0], pos[1] + size[1])
    for LockIndex in LockSizeIndicies:
        if LockIndex & 1: pos = pos[0], Positions[LockIndex] 
        else: pos = Positions[LockIndex], pos[1]

    newsize = abs(pos[0] - newpos[0]), abs(pos[1] - newpos[1])
    newpos = tuple(map(min, zip(pos, newpos)))

    return window.SetDimensions(*(newpos + newsize))

def _GetIntersectionPositions(l, t, w, h, wP=0, hP=0):
    return [
        l-wP, #LeftSide
        t-hP, #TopSide
        l+w, #RightSide
        t+h, #BottomSide

        l, #LeftInnerSide
        t, #TopInnerSide
        l+w-wP, #RightInnerSide
        t+h-hP, #BottomInnerSide
        ]

def _GetIntersectionSides(l, t, w, h):
    return [
        (l+w, t, l+w, t+h), # Right - Outter
        (l, t+h, l+w, t+h), # Bottom - Outter
        (l, t, l, t+h), # Left - Outter
        (l, t, l+w, t), # Top - Outter

        (l, t, l, t+h), # Left - Inner
        (l, t, l+w, t), # Top - Inner
        (l+w, t, l+w, t+h), # Right - Inner
        (l, t+h, l+w, t+h), # Bottom - Inner
        ]

def _Intersects(A, B):
    if A[0] > B[2]: return 0
    if B[0] > A[2]: return 0
    if A[1] > B[3]: return 0
    if B[1] > A[3]: return 0
    return 1


#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

wxLockingFrameBase.SetupInternalLockingSides(None, wx.wxGetClientDisplayRect().asTuple())

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class wxAttractiveLockingFrame(wxLockingFrameBase):
    _DeltaAttract = 20
    _DeltaResist = 0

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class wxResistiveLockingFrame(wxLockingFrameBase):
    _DeltaAttract = 0
    _DeltaResist = 20

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class wxLockingFrame(wxLockingFrameBase):
    _DeltaAttract = 10
    _DeltaResist = 10