root/trunk/RBSkinning/RBSkinning/wxPythonSkin/layout.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
##~
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

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

import warnings
from wxSkinLayoutObject import wx, wxSkinLayoutObject, wxSkinObjectNoData
from RBSkinning.wxTools import SetLayoutContainerSizeHints

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

class layout(wxSkinLayoutObject, wxSkinObjectNoData):
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Constants / Variables / Etc. 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    default_settings = wxSkinLayoutObject.default_settings.copy()
    default_settings.update({
        'ctxvar': 'layout',

        #'orientation': 'opposite',
        #'autosize': '1',
        #'sethints': '1',
        #'fit': '0',

        #'args': '()',
        })

    orientation_aliases = {
        'opp': 'opposite',
        'o': 'opposite',
        's': 'same',
        'vert': 'vertical',
        'v': 'vertical',
        'horiz':'horizontal',
        'h':'horizontal',
        }

    orientation_map = {
        # Opposite is default vertical
        'opposite': (wx.wxBoxSizer, (wx.wxVERTICAL,)),
        'same': (wx.wxBoxSizer, (wx.wxVERTICAL,)),
        'vertical': (wx.wxBoxSizer, (wx.wxVERTICAL,)),
        'horizontal': (wx.wxBoxSizer, (wx.wxHORIZONTAL,)),
        'box': (wx.wxBoxSizer, tuple()),
        'grid': (wx.wxGridSizer, tuple()),
        }

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Public 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    def SkinInitialize(self):

        # Create the layout sizer
        orientation = self._GetOrientation()
        sizerClass, preArgs = self.orientation_map[orientation]
        postArgs = self.wxEvalCond('args', ())
        self.object = sizerClass(*(preArgs + postArgs))
        self.wxInitialStandardOptions()

        # Tinker with the context to make things available
        self.PushContext()

    def SkinFinalize(self):
        minsize = self.wxEvalCond('sizehints', (-1, -1))[:2]
        if minsize != (-1,-1):
            self.object.SetMinSize(minsize)

        self.wxFinalStandardOptions()

        parent = self.wxGetParentObject((wx.wxSizerPtr, wx.wxWindowPtr))
        if parent is self.winParent:
            self.winParent.SetSizer(self.object)
            self.winParent.SetAutoLayout(self.wxEvalCond('autosize', 1))

            # Set size hints
            if self.wxEvalCond('sethints', 1): 
                SetLayoutContainerSizeHints(self.object, self.winParent)

            if self.wxEvalCond('fit', 1): 
                self.object.Fit(self.winParent)
        del self.winParent

    def wxAddChild(self, ChildNode):
        if isinstance(ChildNode.object, tuple):
            args = ChildNode.object
        elif isinstance(ChildNode.object, wx.wxNotebookPtr):
            ChildNode.sizerobject = wx.wxNotebookSizer(ChildNode.object)
            args = (ChildNode.sizerobject,)
        elif isinstance(ChildNode.object, wx.wxWindowPtr):
            if ChildNode.object.IsTopLevel():
                # Skip things like wxFrames, and wxDialogs
                return super(layout, self).wxAddChild(ChildNode)
            else:
                args = (ChildNode.object,)
        elif isinstance(ChildNode.object, wx.wxSizerPtr):
            args = (ChildNode.object,)
        else:
            # Whatever it is, this layout doesn't know what to do with it...
            return super(layout, self).wxAddChild(ChildNode)

        sizerargs, sizerkw = ChildNode.wxEvalCond('sizercfg', ((), {}), codefmtstr='argskw(%s)')
        
        # Add to our layout object
        self.object.Add(*(args+sizerargs), **sizerkw)

        # Check for minsize directives...
        if not isinstance(ChildNode.object, tuple):
            minsize = ChildNode.wxEvalCond('sizehints', (-1, -1))[:2]
            if minsize != (-1,-1):
                self.object.SetItemMinSize(ChildNode.object, *minsize)

    def _GetOrientation(self, orientation=None, default='opposite'):
        orientation = orientation or self.settings.get('orientation', None) or self.settings.get('orient', None) or default
        orientation = self.orientation_aliases.get(orientation, orientation)
        # Grab the window parent object, or the first layout derived parent
        self.winParent = self.wxGetParentObject((wx.wxWindowPtr, layout))
        if isinstance(self.winParent, wx.wxWindowPtr): 
            # Set sizercfg default for context, if not set
            if 'sizercfg' not in self.settings:
                self.settings['sizercfg'] = '1, wxEXPAND'
        else:
            # Set sizercfg default for context, if not set
            if 'sizercfg' not in self.settings:
                self.settings['sizercfg'] = '0, wxEXPAND'

            # Layouts cancel the window parent
            parentLayout = self.winParent
            self.winParent = None

            # Figure out what type of sizer we should be creating
            if orientation == 'opposite':
                orientation = 'vertical' # New Default
                # Calculate the "real" opposite
                try: GetOrientation = parentLayout.GetOrientation
                except AttributeError: pass
                else:
                    if GetOrientation() == wx.wxVERTICAL:
                        orientation = 'horizontal'
                    else: orientation = 'vertical'
            elif orientation == 'same':
                orientation = 'vertical' # New Default
                # Calculate the "real" value
                try: GetOrientation = parentLayout.GetOrientation
                except AttributeError: pass
                else:
                    if GetOrientation() == wx.wxVERTICAL:
                        orientation = 'vertical'
                    else: orientation = 'horizontal'

        orientation = self.orientation_aliases.get(orientation, orientation)
        return orientation