AGW Logo

Source code for aui.framemanager

# --------------------------------------------------------------------------- #
# AUI Library wxPython IMPLEMENTATION
#
# Original C++ Code From Kirix (wxAUI). You Can Find It At:
#
#    License: wxWidgets license
#
# http:#www.kirix.com/en/community/opensource/wxaui/about_wxaui.html
#
# Current wxAUI Version Tracked: wxWidgets 2.9.0 SVN HEAD
#
#
# Python Code By:
#
# Andrea Gavana, @ 23 Dec 2005
# Latest Revision: 07 Mar 2012, 21.00 GMT
#
# For All Kind Of Problems, Requests Of Enhancements And Bug Reports, Please
# Write To Me At:
#
# andrea.gavana@gmail.com
# andrea.gavana@maerskoil.com
#
# Or, Obviously, To The wxPython Mailing List!!!
#
# End Of Comments
# --------------------------------------------------------------------------- #

"""
Description
===========

`framemanager.py` is the central module of the AUI class framework.

L{AuiManager} manages the panes associated with it for a particular `wx.Frame`, using
a pane's L{AuiPaneInfo} information to determine each pane's docking and floating
behavior. AuiManager uses wxPython' sizer mechanism to plan the layout of each frame.
It uses a replaceable dock art class to do all drawing, so all drawing is localized
in one area, and may be customized depending on an application's specific needs.

AuiManager works as follows: the programmer adds panes to the class, or makes
changes to existing pane properties (dock position, floating state, show state, etc...).
To apply these changes, AuiManager's L{AuiManager.Update} function is called. This batch
processing can be used to avoid flicker, by modifying more than one pane at a time,
and then "committing" all of the changes at once by calling `Update()`.

Panes can be added quite easily::

    text1 = wx.TextCtrl(self, -1)
    text2 = wx.TextCtrl(self, -1)
    self._mgr.AddPane(text1, AuiPaneInfo().Left().Caption("Pane Number One"))
    self._mgr.AddPane(text2, AuiPaneInfo().Bottom().Caption("Pane Number Two"))

    self._mgr.Update()


Later on, the positions can be modified easily. The following will float an
existing pane in a tool window::

    self._mgr.GetPane(text1).Float()


Layers, Rows and Directions, Positions
======================================

Inside AUI, the docking layout is figured out by checking several pane parameters.
Four of these are important for determining where a pane will end up.

**Direction** - Each docked pane has a direction, `Top`, `Bottom`, `Left`, `Right`, or `Center`.
This is fairly self-explanatory. The pane will be placed in the location specified
by this variable.

**Position** - More than one pane can be placed inside of a "dock". Imagine two panes
being docked on the left side of a window. One pane can be placed over another.
In proportionally managed docks, the pane position indicates it's sequential position,
starting with zero. So, in our scenario with two panes docked on the left side, the
top pane in the dock would have position 0, and the second one would occupy position 1. 

**Row** - A row can allow for two docks to be placed next to each other. One of the most
common places for this to happen is in the toolbar. Multiple toolbar rows are allowed,
the first row being in row 0, and the second in row 1. Rows can also be used on
vertically docked panes. 

**Layer** - A layer is akin to an onion. Layer 0 is the very center of the managed pane.
Thus, if a pane is in layer 0, it will be closest to the center window (also sometimes
known as the "content window"). Increasing layers "swallow up" all layers of a lower
value. This can look very similar to multiple rows, but is different because all panes
in a lower level yield to panes in higher levels. The best way to understand layers
is by running the AUI sample (`AUI.py`).
"""

__author__ = "Andrea Gavana <andrea.gavana@gmail.com>"
__date__ = "31 March 2009"


import wx
import time
import types
import warnings

import auibar
import auibook
import tabmdi
import dockart
import tabart

from aui_utilities import Clip, PaneCreateStippleBitmap, GetDockingImage, GetSlidingPoints

from aui_constants import *

# Define this as a translation function
_ = wx.GetTranslation

_winxptheme = False
if wx.Platform == "__WXMSW__":
    try:
        import winxptheme
        _winxptheme = True
    except ImportError:
        pass

# wxPython version string
_VERSION_STRING = wx.VERSION_STRING

# AUI Events
wxEVT_AUI_PANE_BUTTON = wx.NewEventType()
wxEVT_AUI_PANE_CLOSE = wx.NewEventType()
wxEVT_AUI_PANE_MAXIMIZE = wx.NewEventType()
wxEVT_AUI_PANE_RESTORE = wx.NewEventType()
wxEVT_AUI_RENDER = wx.NewEventType()
wxEVT_AUI_FIND_MANAGER = wx.NewEventType()
wxEVT_AUI_PANE_MINIMIZE = wx.NewEventType()
wxEVT_AUI_PANE_MIN_RESTORE = wx.NewEventType()
wxEVT_AUI_PANE_FLOATING = wx.NewEventType()
wxEVT_AUI_PANE_FLOATED = wx.NewEventType()
wxEVT_AUI_PANE_DOCKING = wx.NewEventType()
wxEVT_AUI_PANE_DOCKED = wx.NewEventType()
wxEVT_AUI_PANE_ACTIVATED = wx.NewEventType()
wxEVT_AUI_PERSPECTIVE_CHANGED = wx.NewEventType()

EVT_AUI_PANE_BUTTON = wx.PyEventBinder(wxEVT_AUI_PANE_BUTTON, 0)
""" Fires an event when the user left-clicks on a pane button. """
EVT_AUI_PANE_CLOSE = wx.PyEventBinder(wxEVT_AUI_PANE_CLOSE, 0)
""" A pane in `AuiManager` has been closed. """
EVT_AUI_PANE_MAXIMIZE = wx.PyEventBinder(wxEVT_AUI_PANE_MAXIMIZE, 0)
""" A pane in `AuiManager` has been maximized. """
EVT_AUI_PANE_RESTORE = wx.PyEventBinder(wxEVT_AUI_PANE_RESTORE, 0)
""" A pane in `AuiManager` has been restored from a maximized state. """
EVT_AUI_RENDER = wx.PyEventBinder(wxEVT_AUI_RENDER, 0)
""" Fires an event every time the AUI frame is being repainted. """
EVT_AUI_FIND_MANAGER = wx.PyEventBinder(wxEVT_AUI_FIND_MANAGER, 0)
""" Used to find which AUI manager is controlling a certain pane. """
EVT_AUI_PANE_MINIMIZE = wx.PyEventBinder(wxEVT_AUI_PANE_MINIMIZE, 0)
""" A pane in `AuiManager` has been minimized. """
EVT_AUI_PANE_MIN_RESTORE = wx.PyEventBinder(wxEVT_AUI_PANE_MIN_RESTORE, 0)
""" A pane in `AuiManager` has been restored from a minimized state. """
EVT_AUI_PANE_FLOATING = wx.PyEventBinder(wxEVT_AUI_PANE_FLOATING, 0)
""" A pane in `AuiManager` is about to be floated. """
EVT_AUI_PANE_FLOATED = wx.PyEventBinder(wxEVT_AUI_PANE_FLOATED, 0)
""" A pane in `AuiManager` has been floated. """
EVT_AUI_PANE_DOCKING = wx.PyEventBinder(wxEVT_AUI_PANE_DOCKING, 0)
""" A pane in `AuiManager` is about to be docked. """
EVT_AUI_PANE_DOCKED = wx.PyEventBinder(wxEVT_AUI_PANE_DOCKED, 0)
""" A pane in `AuiManager` has been docked. """
EVT_AUI_PANE_ACTIVATED = wx.PyEventBinder(wxEVT_AUI_PANE_ACTIVATED, 0)
""" A pane in `AuiManager` has been activated. """
EVT_AUI_PERSPECTIVE_CHANGED = wx.PyEventBinder(wxEVT_AUI_PERSPECTIVE_CHANGED, 0)
""" The layout in `AuiManager` has been changed. """

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

[docs]class AuiDockInfo(object): """ A class to store all properties of a dock. """
[docs] def __init__(self): """ Default class constructor. Used internally, do not call it in your code! """ object.__init__(self) self.dock_direction = 0 self.dock_layer = 0 self.dock_row = 0 self.size = 0 self.min_size = 0 self.resizable = True self.fixed = False self.toolbar = False self.rect = wx.Rect() self.panes = []
[docs] def IsOk(self): """ Returns whether a dock is valid or not. In order to be valid, a dock needs to have a non-zero `dock_direction`. """ return self.dock_direction != 0
[docs] def IsHorizontal(self): """ Returns whether the dock is horizontal or not. """ return self.dock_direction in [AUI_DOCK_TOP, AUI_DOCK_BOTTOM]
[docs] def IsVertical(self): """ Returns whether the dock is vertical or not. """ return self.dock_direction in [AUI_DOCK_LEFT, AUI_DOCK_RIGHT, AUI_DOCK_CENTER] # ---------------------------------------------------------------------------- #
[docs]class AuiDockingGuideInfo(object): """ A class which holds information about VS2005 docking guide windows. """
[docs] def __init__(self, other=None): """ Default class constructor. Used internally, do not call it in your code! :param `other`: another instance of L{AuiDockingGuideInfo}. """ if other: self.Assign(other) else: # window representing the docking target self.host = None # dock direction (top, bottom, left, right, center) self.dock_direction = AUI_DOCK_NONE
[docs] def Assign(self, other): """ Assigns the properties of the `other` L{AuiDockingGuideInfo} to `self`. :param `other`: another instance of L{AuiDockingGuideInfo}. """ self.host = other.host self.dock_direction = other.dock_direction
[docs] def Host(self, h): """ Hosts a docking guide window. :param `h`: an instance of L{AuiSingleDockingGuide} or L{AuiCenterDockingGuide}. """ self.host = h return self
[docs] def Left(self): """ Sets the guide window to left docking. """ self.dock_direction = AUI_DOCK_LEFT return self
[docs] def Right(self): """ Sets the guide window to right docking. """ self.dock_direction = AUI_DOCK_RIGHT return self
[docs] def Top(self): """ Sets the guide window to top docking. """ self.dock_direction = AUI_DOCK_TOP return self
[docs] def Bottom(self): """ Sets the guide window to bottom docking. """ self.dock_direction = AUI_DOCK_BOTTOM return self
[docs] def Center(self): """ Sets the guide window to center docking. """ self.dock_direction = AUI_DOCK_CENTER return self
[docs] def Centre(self): """ Sets the guide window to centre docking. """ self.dock_direction = AUI_DOCK_CENTRE return self # ---------------------------------------------------------------------------- #
[docs]class AuiDockUIPart(object): """ A class which holds attributes for a UI part in the interface. """ typeCaption = 0 typeGripper = 1 typeDock = 2 typeDockSizer = 3 typePane = 4 typePaneSizer = 5 typeBackground = 6 typePaneBorder = 7 typePaneButton = 8
[docs] def __init__(self): """ Default class constructor. Used internally, do not call it in your code! """ self.orientation = wx.VERTICAL self.type = 0 self.rect = wx.Rect() # ---------------------------------------------------------------------------- #
[docs]class AuiPaneButton(object): """ A simple class which describes the caption pane button attributes. """
[docs] def __init__(self, button_id): """ Default class constructor. Used internally, do not call it in your code! :param `button_id`: the pane button identifier. """ self.button_id = button_id # ---------------------------------------------------------------------------- # # event declarations/classes
[docs]class AuiManagerEvent(wx.PyCommandEvent): """ A specialized command event class for events sent by L{AuiManager}. """
[docs] def __init__(self, eventType, id=1): """ Default class constructor. :param `eventType`: the event kind; :param `id`: the event identification number. """ wx.PyCommandEvent.__init__(self, eventType, id) self.manager = None self.pane = None self.button = 0 self.veto_flag = False self.canveto_flag = True self.dc = None
[docs] def SetManager(self, mgr): """ Associates a L{AuiManager} to the current event. :param `mgr`: an instance of L{AuiManager}. """ self.manager = mgr
[docs] def SetDC(self, pdc): """ Associates a `wx.DC` device context to this event. :param `pdc`: a `wx.DC` device context object. """ self.dc = pdc
[docs] def SetPane(self, p): """ Associates a L{AuiPaneInfo} instance to this event. :param `p`: a L{AuiPaneInfo} instance. """ self.pane = p
[docs] def SetButton(self, b): """ Associates a L{AuiPaneButton} instance to this event. :param `b`: a L{AuiPaneButton} instance. """ self.button = b
[docs] def GetManager(self): """ Returns the associated L{AuiManager} (if any). """ return self.manager
[docs] def GetDC(self): """ Returns the associated `wx.DC` device context (if any). """ return self.dc
[docs] def GetPane(self): """ Returns the associated L{AuiPaneInfo} structure (if any). """ return self.pane
[docs] def GetButton(self): """ Returns the associated L{AuiPaneButton} instance (if any). """ return self.button
[docs] def Veto(self, veto=True): """ Prevents the change announced by this event from happening. It is in general a good idea to notify the user about the reasons for vetoing the change because otherwise the applications behaviour (which just refuses to do what the user wants) might be quite surprising. :param `veto`: ``True`` to veto the event, ``False`` otherwise. """ self.veto_flag = veto
[docs] def GetVeto(self): """ Returns whether the event has been vetoed or not. """ return self.veto_flag
[docs] def SetCanVeto(self, can_veto): """ Sets whether the event can be vetoed or not. :param `can_veto`: a bool flag. ``True`` if the event can be vetoed, ``False`` otherwise. """ self.canveto_flag = can_veto
[docs] def CanVeto(self): """ Returns whether the event can be vetoed and has been vetoed. """ return self.canveto_flag and self.veto_flag # ---------------------------------------------------------------------------- #
[docs]class AuiPaneInfo(object): """ AuiPaneInfo specifies all the parameters for a pane. These parameters specify where the pane is on the screen, whether it is docked or floating, or hidden. In addition, these parameters specify the pane's docked position, floating position, preferred size, minimum size, caption text among many other parameters. """ optionFloating = 2**0 optionHidden = 2**1 optionLeftDockable = 2**2 optionRightDockable = 2**3 optionTopDockable = 2**4 optionBottomDockable = 2**5 optionFloatable = 2**6 optionMovable = 2**7 optionResizable = 2**8 optionPaneBorder = 2**9 optionCaption = 2**10 optionGripper = 2**11 optionDestroyOnClose = 2**12 optionToolbar = 2**13 optionActive = 2**14 optionGripperTop = 2**15 optionMaximized = 2**16 optionDockFixed = 2**17 optionNotebookDockable = 2**18 optionMinimized = 2**19 optionLeftSnapped = 2**20 optionRightSnapped = 2**21 optionTopSnapped = 2**22 optionBottomSnapped = 2**23 optionFlyOut = 2**24 optionCaptionLeft = 2**25 buttonClose = 2**26 buttonMaximize = 2**27 buttonMinimize = 2**28 buttonPin = 2**29 buttonCustom1 = 2**30 buttonCustom2 = 2**31 buttonCustom3 = 2**32 savedHiddenState = 2**33 # used internally actionPane = 2**34 # used internally wasMaximized = 2**35 # used internally needsRestore = 2**36 # used internally
[docs] def __init__(self): """ Default class constructor. """ self.window = None self.frame = None self.state = 0 self.dock_direction = AUI_DOCK_LEFT self.dock_layer = 0 self.dock_row = 0 self.dock_pos = 0 self.minimize_mode = AUI_MINIMIZE_POS_SMART self.floating_pos = wx.Point(-1, -1) self.floating_size = wx.Size(-1, -1) self.best_size = wx.Size(-1, -1) self.min_size = wx.Size(-1, -1) self.max_size = wx.Size(-1, -1) self.dock_proportion = 0 self.caption = "" self.buttons = [] self.name = "" self.icon = wx.NullIcon self.rect = wx.Rect() self.notebook_id = -1 self.transparent = 255 self.needsTransparency = False self.previousDockPos = None self.previousDockSize = 0 self.snapped = 0 self.minimize_target = None self.DefaultPane()
[docs] def dock_direction_get(self): """ Getter for the `dock_direction`. :see: L{dock_direction_set} for a set of valid docking directions. """ if self.IsMaximized(): return AUI_DOCK_CENTER else: return self._dock_direction
[docs] def dock_direction_set(self, value): """ Setter for the `dock_direction`. :param `value`: the docking direction. This cab ne one of the following bits: ============================ ======= ============================================= Dock Flag Value Description ============================ ======= ============================================= ``AUI_DOCK_NONE`` 0 No docking direction. ``AUI_DOCK_TOP`` 1 Top docking direction. ``AUI_DOCK_RIGHT`` 2 Right docking direction. ``AUI_DOCK_BOTTOM`` 3 Bottom docking direction. ``AUI_DOCK_LEFT`` 4 Left docking direction. ``AUI_DOCK_CENTER`` 5 Center docking direction. ``AUI_DOCK_CENTRE`` 5 Centre docking direction. ``AUI_DOCK_NOTEBOOK_PAGE`` 6 Automatic AuiNotebooks docking style. ============================ ======= ============================================= """ self._dock_direction = value
dock_direction = property(dock_direction_get, dock_direction_set)
[docs] def IsOk(self): """ Returns ``True`` if the L{AuiPaneInfo} structure is valid. :note: A pane structure is valid if it has an associated window. """ return self.window != None
[docs] def IsMaximized(self): """ Returns ``True`` if the pane is maximized. """ return self.HasFlag(self.optionMaximized)
[docs] def IsMinimized(self): """ Returns ``True`` if the pane is minimized. """ return self.HasFlag(self.optionMinimized)
[docs] def IsFixed(self): """ Returns ``True`` if the pane cannot be resized. """ return not self.HasFlag(self.optionResizable)
[docs] def IsResizeable(self): """ Returns ``True`` if the pane can be resized. """ return self.HasFlag(self.optionResizable)
[docs] def IsShown(self): """ Returns ``True`` if the pane is currently shown. """ return not self.HasFlag(self.optionHidden)
[docs] def IsFloating(self): """ Returns ``True`` if the pane is floating. """ return self.HasFlag(self.optionFloating)
[docs] def IsDocked(self): """ Returns ``True`` if the pane is docked. """ return not self.HasFlag(self.optionFloating)
[docs] def IsToolbar(self): """ Returns ``True`` if the pane contains a toolbar. """ return self.HasFlag(self.optionToolbar)
[docs] def IsTopDockable(self): """ Returns ``True`` if the pane can be docked at the top of the managed frame. """ return self.HasFlag(self.optionTopDockable)
[docs] def IsBottomDockable(self): """ Returns ``True`` if the pane can be docked at the bottom of the managed frame. """ return self.HasFlag(self.optionBottomDockable)
[docs] def IsLeftDockable(self): """ Returns ``True`` if the pane can be docked at the left of the managed frame. """ return self.HasFlag(self.optionLeftDockable)
[docs] def IsRightDockable(self): """ Returns ``True`` if the pane can be docked at the right of the managed frame. """ return self.HasFlag(self.optionRightDockable)
[docs] def IsDockable(self): """ Returns ``True`` if the pane can be docked. """ return self.IsTopDockable() or self.IsBottomDockable() or self.IsLeftDockable() or \ self.IsRightDockable() or self.IsNotebookDockable()
[docs] def IsFloatable(self): """ Returns ``True`` if the pane can be undocked and displayed as a floating window. """ return self.HasFlag(self.optionFloatable)
[docs] def IsMovable(self): """ Returns ``True`` if the docked frame can be undocked or moved to another dock position. """ return self.HasFlag(self.optionMovable)
[docs] def IsDestroyOnClose(self): """ Returns ``True`` if the pane should be destroyed when it is closed. Normally a pane is simply hidden when the close button is clicked. Calling L{DestroyOnClose} with a ``True`` input parameter will cause the window to be destroyed when the user clicks the pane's close button. """ return self.HasFlag(self.optionDestroyOnClose)
[docs] def IsNotebookDockable(self): """ Returns ``True`` if a pane can be docked on top to another to create a L{AuiNotebook}. """ return self.HasFlag(self.optionNotebookDockable)
[docs] def IsTopSnappable(self): """ Returns ``True`` if the pane can be snapped at the top of the managed frame. """ return self.HasFlag(self.optionTopSnapped)
[docs] def IsBottomSnappable(self): """ Returns ``True`` if the pane can be snapped at the bottom of the managed frame. """ return self.HasFlag(self.optionBottomSnapped)
[docs] def IsLeftSnappable(self): """ Returns ``True`` if the pane can be snapped on the left of the managed frame. """ return self.HasFlag(self.optionLeftSnapped)
[docs] def IsRightSnappable(self): """ Returns ``True`` if the pane can be snapped on the right of the managed frame. """ return self.HasFlag(self.optionRightSnapped)
[docs] def IsSnappable(self): """ Returns ``True`` if the pane can be snapped. """ return self.IsTopSnappable() or self.IsBottomSnappable() or self.IsLeftSnappable() or \ self.IsRightSnappable()
[docs] def IsFlyOut(self): """ Returns ``True`` if the floating pane has a "fly-out" effect. """ return self.HasFlag(self.optionFlyOut)
[docs] def HasCaption(self): """ Returns ``True`` if the pane displays a caption. """ return self.HasFlag(self.optionCaption)
[docs] def HasCaptionLeft(self): """ Returns ``True`` if the pane displays a caption on the left (rotated by 90 degrees). """ return self.HasFlag(self.optionCaptionLeft)
[docs] def HasGripper(self): """ Returns ``True`` if the pane displays a gripper. """ return self.HasFlag(self.optionGripper)
[docs] def HasBorder(self): """ Returns ``True`` if the pane displays a border. """ return self.HasFlag(self.optionPaneBorder)
[docs] def HasCloseButton(self): """ Returns ``True`` if the pane displays a button to close the pane. """ return self.HasFlag(self.buttonClose)
[docs] def HasMaximizeButton(self): """ Returns ``True`` if the pane displays a button to maximize the pane. """ return self.HasFlag(self.buttonMaximize)
[docs] def HasMinimizeButton(self): """ Returns ``True`` if the pane displays a button to minimize the pane. """ return self.HasFlag(self.buttonMinimize)
[docs] def GetMinimizeMode(self): """ Returns the minimization style for this pane. Possible return values are: ============================== ========= ============================== Minimize Mode Flag Hex Value Description ============================== ========= ============================== ``AUI_MINIMIZE_POS_SMART`` 0x01 Minimizes the pane on the closest tool bar ``AUI_MINIMIZE_POS_TOP`` 0x02 Minimizes the pane on the top tool bar ``AUI_MINIMIZE_POS_LEFT`` 0x03 Minimizes the pane on its left tool bar ``AUI_MINIMIZE_POS_RIGHT`` 0x04 Minimizes the pane on its right tool bar ``AUI_MINIMIZE_POS_BOTTOM`` 0x05 Minimizes the pane on its bottom tool bar ``AUI_MINIMIZE_POS_TOOLBAR`` 0x06 Minimizes the pane on a target L{AuiToolBar} ``AUI_MINIMIZE_POS_MASK`` 0x17 Mask to filter the position flags ``AUI_MINIMIZE_CAPT_HIDE`` 0x0 Hides the caption of the minimized pane ``AUI_MINIMIZE_CAPT_SMART`` 0x08 Displays the caption in the best rotation (horizontal or clockwise) ``AUI_MINIMIZE_CAPT_HORZ`` 0x10 Displays the caption horizontally ``AUI_MINIMIZE_CAPT_MASK`` 0x18 Mask to filter the caption flags ============================== ========= ============================== The flags can be filtered with the following masks: ============================== ========= ============================== Minimize Mask Flag Hex Value Description ============================== ========= ============================== ``AUI_MINIMIZE_POS_MASK`` 0x17 Filters the position flags ``AUI_MINIMIZE_CAPT_MASK`` 0x18 Filters the caption flags ============================== ========= ============================== """ return self.minimize_mode
[docs] def HasPinButton(self): """ Returns ``True`` if the pane displays a button to float the pane. """ return self.HasFlag(self.buttonPin)
[docs] def HasGripperTop(self): """ Returns ``True`` if the pane displays a gripper at the top. """ return self.HasFlag(self.optionGripperTop)
[docs] def Window(self, w): """ Associate a `wx.Window` derived window to this pane. This normally does not need to be specified, as the window pointer is automatically assigned to the L{AuiPaneInfo} structure as soon as it is added to the manager. :param `w`: a `wx.Window` derived window. """ self.window = w return self
[docs] def Name(self, name): """ Sets the name of the pane so it can be referenced in lookup functions. If a name is not specified by the user, a random name is assigned to the pane when it is added to the manager. :param `name`: a string specifying the pane name. :warning: If you are using L{AuiManager.SavePerspective} and L{AuiManager.LoadPerspective}, you will have to specify a name for your pane using L{Name}, as randomly generated names can not be properly restored. """ self.name = name return self
[docs] def Caption(self, caption): """ Sets the caption of the pane. :param `caption`: a string specifying the pane caption. """ self.caption = caption return self
[docs] def Left(self): """ Sets the pane dock position to the left side of the frame. :note: This is the same thing as calling L{Direction} with ``AUI_DOCK_LEFT`` as parameter. """ self.dock_direction = AUI_DOCK_LEFT return self
[docs] def Right(self): """ Sets the pane dock position to the right side of the frame. :note: This is the same thing as calling L{Direction} with ``AUI_DOCK_RIGHT`` as parameter. """ self.dock_direction = AUI_DOCK_RIGHT return self
[docs] def Top(self): """ Sets the pane dock position to the top of the frame. :note: This is the same thing as calling L{Direction} with ``AUI_DOCK_TOP`` as parameter. """ self.dock_direction = AUI_DOCK_TOP return self
[docs] def Bottom(self): """ Sets the pane dock position to the bottom of the frame. :note: This is the same thing as calling L{Direction} with ``AUI_DOCK_BOTTOM`` as parameter. """ self.dock_direction = AUI_DOCK_BOTTOM return self
[docs] def Center(self): """ Sets the pane to the center position of the frame. The centre pane is the space in the middle after all border panes (left, top, right, bottom) are subtracted from the layout. :note: This is the same thing as calling L{Direction} with ``AUI_DOCK_CENTER`` as parameter. """ self.dock_direction = AUI_DOCK_CENTER return self
[docs] def Centre(self): """ Sets the pane to the center position of the frame. The centre pane is the space in the middle after all border panes (left, top, right, bottom) are subtracted from the layout. :note: This is the same thing as calling L{Direction} with ``AUI_DOCK_CENTRE`` as parameter. """ self.dock_direction = AUI_DOCK_CENTRE return self
[docs] def Direction(self, direction): """ Determines the direction of the docked pane. It is functionally the same as calling L{Left}, L{Right}, L{Top} or L{Bottom}, except that docking direction may be specified programmatically via the parameter `direction`. :param `direction`: the direction of the docked pane. :see: L{dock_direction_set} for a list of valid docking directions. """ self.dock_direction = direction return self
[docs] def Layer(self, layer): """ Determines the layer of the docked pane. The dock layer is similar to an onion, the inner-most layer being layer 0. Each shell moving in the outward direction has a higher layer number. This allows for more complex docking layout formation. :param `layer`: the layer of the docked pane. """ self.dock_layer = layer return self
[docs] def Row(self, row): """ Determines the row of the docked pane. :param `row`: the row of the docked pane. """ self.dock_row = row return self
[docs] def Position(self, pos): """ Determines the position of the docked pane. :param `pos`: the position of the docked pane. """ self.dock_pos = pos return self
[docs] def MinSize(self, arg1=None, arg2=None): """ Sets the minimum size of the pane. This method is split in 2 versions depending on the input type. If `arg1` is a `wx.Size` object, then L{MinSize1} is called. Otherwise, L{MinSize2} is called. :param `arg1`: a `wx.Size` object, a (x, y) tuple or or a `x` coordinate. :param `arg2`: a `y` coordinate (only if `arg1` is a `x` coordinate, otherwise unused). """ if isinstance(arg1, wx.Size): ret = self.MinSize1(arg1) elif isinstance(arg1, types.TupleType): ret = self.MinSize1(wx.Size(*arg1)) elif isinstance(arg1, types.IntType) and arg2 is not None: ret = self.MinSize2(arg1, arg2) else: raise Exception("Invalid argument passed to `MinSize`: arg1=%s, arg2=%s"%(repr(arg1), repr(arg2))) return ret
[docs] def MinSize1(self, size): """ Sets the minimum size of the pane. :see: L{MinSize} for an explanation of input parameters. """ self.min_size = size return self
[docs] def MinSize2(self, x, y): """ Sets the minimum size of the pane. :see: L{MinSize} for an explanation of input parameters. """ self.min_size = wx.Size(x, y) return self
[docs] def MaxSize(self, arg1=None, arg2=None): """ Sets the maximum size of the pane. This method is split in 2 versions depending on the input type. If `arg1` is a `wx.Size` object, then L{MaxSize1} is called. Otherwise, L{MaxSize2} is called. :param `arg1`: a `wx.Size` object, a (x, y) tuple or a `x` coordinate. :param `arg2`: a `y` coordinate (only if `arg1` is a `x` coordinate, otherwise unused). """ if isinstance(arg1, wx.Size): ret = self.MaxSize1(arg1) elif isinstance(arg1, types.TupleType): ret = self.MaxSize1(wx.Size(*arg1)) elif isinstance(arg1, types.IntType) and arg2 is not None: ret = self.MaxSize2(arg1, arg2) else: raise Exception("Invalid argument passed to `MaxSize`: arg1=%s, arg2=%s"%(repr(arg1), repr(arg2))) return ret
[docs] def MaxSize1(self, size): """ Sets the maximum size of the pane. :see: L{MaxSize} for an explanation of input parameters. """ self.max_size = size return self
[docs] def MaxSize2(self, x, y): """ Sets the maximum size of the pane. :see: L{MaxSize} for an explanation of input parameters. """ self.max_size.Set(x,y) return self
[docs] def BestSize(self, arg1=None, arg2=None): """ Sets the ideal size for the pane. The docking manager will attempt to use this size as much as possible when docking or floating the pane. This method is split in 2 versions depending on the input type. If `arg1` is a `wx.Size` object, then L{BestSize1} is called. Otherwise, L{BestSize2} is called. :param `arg1`: a `wx.Size` object, a (x, y) tuple or a `x` coordinate. :param `arg2`: a `y` coordinate (only if `arg1` is a `x` coordinate, otherwise unused). """ if isinstance(arg1, wx.Size): ret = self.BestSize1(arg1) elif isinstance(arg1, types.TupleType): ret = self.BestSize1(wx.Size(*arg1)) elif isinstance(arg1, types.IntType) and arg2 is not None: ret = self.BestSize2(arg1, arg2) else: raise Exception("Invalid argument passed to `BestSize`: arg1=%s, arg2=%s"%(repr(arg1), repr(arg2))) return ret
[docs] def BestSize1(self, size): """ Sets the best size of the pane. :see: L{BestSize} for an explanation of input parameters. """ self.best_size = size return self
[docs] def BestSize2(self, x, y): """ Sets the best size of the pane. :see: L{BestSize} for an explanation of input parameters. """ self.best_size.Set(x,y) return self
[docs] def FloatingPosition(self, pos): """ Sets the position of the floating pane. :param `pos`: a `wx.Point` or a tuple indicating the pane floating position. """ self.floating_pos = wx.Point(*pos) return self
[docs] def FloatingSize(self, size): """ Sets the size of the floating pane. :param `size`: a `wx.Size` or a tuple indicating the pane floating size. """ self.floating_size = wx.Size(*size) return self
[docs] def Maximize(self): """ Makes the pane take up the full area.""" return self.SetFlag(self.optionMaximized, True)
[docs] def Minimize(self): """ Makes the pane minimized in a L{AuiToolBar}. Clicking on the minimize button causes a new L{AuiToolBar} to be created and added to the frame manager, (currently the implementation is such that panes at West will have a toolbar at the right, panes at South will have toolbars at the bottom etc...) and the pane is hidden in the manager. Clicking on the restore button on the newly created toolbar will result in the toolbar being removed and the original pane being restored. """ return self.SetFlag(self.optionMinimized, True)
[docs] def MinimizeMode(self, mode): """ Sets the expected minimized mode if the MinimizeButton() is visible. The minimized pane can have a specific position in the work space: ============================== ========= ============================== Minimize Mode Flag Hex Value Description ============================== ========= ============================== ``AUI_MINIMIZE_POS_SMART`` 0x01 Minimizes the pane on the closest tool bar ``AUI_MINIMIZE_POS_TOP`` 0x02 Minimizes the pane on the top tool bar ``AUI_MINIMIZE_POS_LEFT`` 0x03 Minimizes the pane on its left tool bar ``AUI_MINIMIZE_POS_RIGHT`` 0x04 Minimizes the pane on its right tool bar ``AUI_MINIMIZE_POS_BOTTOM`` 0x05 Minimizes the pane on its bottom tool bar ``AUI_MINIMIZE_POS_TOOLBAR`` 0x06 Minimizes the pane on a target L{AuiToolBar} ============================== ========= ============================== The caption of the minimized pane can be displayed in different modes: ============================== ========= ============================== Caption Mode Flag Hex Value Description ============================== ========= ============================== ``AUI_MINIMIZE_CAPT_HIDE`` 0x0 Hides the caption of the minimized pane ``AUI_MINIMIZE_CAPT_SMART`` 0x08 Displays the caption in the best rotation (horizontal in the top and in the bottom tool bar or clockwise in the right and in the left tool bar) ``AUI_MINIMIZE_CAPT_HORZ`` 0x10 Displays the caption horizontally ============================== ========= ============================== :note: In order to use the ``AUI_MINIMIZE_POS_TOOLBAR`` flag, the instance of L{AuiPaneInfo} you pass as an input for L{MinimizeTarget} **must** have a real name and not the randomly generated one. Remember to set the L{Name} property of the toolbar pane before calling this method. """ self.minimize_mode = mode return self
[docs] def MinimizeTarget(self, toolbarPane): """ Minimizes the panes using a L{AuiPaneInfo} as a target. As L{AuiPaneInfo} properties need to be copied back and forth every time the perspective has changed, we only store the toobar **name**. :param `toolbarPane`: an instance of L{AuiPaneInfo}, containing a L{AuiToolBar}. :note: In order to use this functionality (and with the ``AUI_MINIMIZE_POS_TOOLBAR`` flag set), the instance of L{AuiPaneInfo} you pass as an input **must** have a real name and not the randomly generated one. Remember to set the L{Name} property of the toolbar pane before calling this method. """ self.minimize_target = toolbarPane.name return self
[docs] def Restore(self): """ Is the reverse of L{Maximize} and L{Minimize}.""" return self.SetFlag(self.optionMaximized or self.optionMinimized, False)
[docs] def Fixed(self): """ Forces a pane to be fixed size so that it cannot be resized. After calling L{Fixed}, L{IsFixed} will return ``True``. """ return self.SetFlag(self.optionResizable, False)
[docs] def Resizable(self, resizable=True): """ Allows a pane to be resizable if `resizable` is ``True``, and forces it to be a fixed size if `resizeable` is ``False``. If `resizable` is ``False``, this is simply an antonym for L{Fixed}. :param `resizable`: whether the pane will be resizeable or not. """ return self.SetFlag(self.optionResizable, resizable)
[docs] def Transparent(self, alpha): """ Makes the pane transparent when floating. :param `alpha`: an integer value between 0 and 255 for pane transparency. """ if alpha < 0 or alpha > 255: raise Exception("Invalid transparency value (%s)"%repr(alpha)) self.transparent = alpha self.needsTransparency = True
[docs] def Dock(self): """ Indicates that a pane should be docked. It is the opposite of L{Float}. """ if self.IsNotebookPage(): self.notebook_id = -1 self.dock_direction = AUI_DOCK_NONE return self.SetFlag(self.optionFloating, False)
[docs] def Float(self): """ Indicates that a pane should be floated. It is the opposite of L{Dock}. """ if self.IsNotebookPage(): self.notebook_id = -1 self.dock_direction = AUI_DOCK_NONE return self.SetFlag(self.optionFloating, True)
[docs] def Hide(self): """ Indicates that a pane should be hidden. Calling L{Show} (``False``) achieve the same effect. """ return self.SetFlag(self.optionHidden, True)
[docs] def Show(self, show=True): """ Indicates that a pane should be shown. :param `show`: whether the pane should be shown or not. """ return self.SetFlag(self.optionHidden, not show) # By defaulting to 1000, the tab will get placed at the end
[docs] def NotebookPage(self, id, tab_position=1000): """ Forces a pane to be a notebook page, so that the pane can be docked on top to another to create a L{AuiNotebook}. :param `id`: the notebook id; :param `tab_position`: the tab number of the pane once docked in a notebook. """ # Remove any floating frame self.Dock() self.notebook_id = id self.dock_pos = tab_position self.dock_row = 0 self.dock_layer = 0 self.dock_direction = AUI_DOCK_NOTEBOOK_PAGE return self
[docs] def NotebookControl(self, id): """ Forces a pane to be a notebook control (L{AuiNotebook}). :param `id`: the notebook id. """ self.notebook_id = id self.window = None self.buttons = [] if self.dock_direction == AUI_DOCK_NOTEBOOK_PAGE: self.dock_direction = AUI_DOCK_NONE return self
[docs] def HasNotebook(self): """ Returns whether a pane has a L{AuiNotebook} or not. """ return self.notebook_id >= 0
[docs] def IsNotebookPage(self): """ Returns whether the pane is a notebook page in a L{AuiNotebook}. """ return self.notebook_id >= 0 and self.dock_direction == AUI_DOCK_NOTEBOOK_PAGE
[docs] def IsNotebookControl(self): """ Returns whether the pane is a notebook control (L{AuiNotebook}). """ return not self.IsNotebookPage() and self.HasNotebook()
[docs] def SetNameFromNotebookId(self): """ Sets the pane name once docked in a L{AuiNotebook} using the notebook id. """ if self.notebook_id >= 0: self.name = "__notebook_%d"%self.notebook_id return self
[docs] def CaptionVisible(self, visible=True, left=False): """ Indicates that a pane caption should be visible. If `visible` is ``False``, no pane caption is drawn. :param `visible`: whether the caption should be visible or not; :param `left`: whether the caption should be drawn on the left (rotated by 90 degrees) or not. """ if left: self.SetFlag(self.optionCaption, False) return self.SetFlag(self.optionCaptionLeft, visible) self.SetFlag(self.optionCaptionLeft, False) return self.SetFlag(self.optionCaption, visible)
[docs] def PaneBorder(self, visible=True): """ Indicates that a border should be drawn for the pane. :param `visible`: whether the pane border should be visible or not. """ return self.SetFlag(self.optionPaneBorder, visible)
[docs] def Gripper(self, visible=True): """ Indicates that a gripper should be drawn for the pane. :param `visible`: whether the gripper should be visible or not. """ return self.SetFlag(self.optionGripper, visible)
[docs] def GripperTop(self, attop=True): """ Indicates that a gripper should be drawn at the top of the pane. :param `attop`: whether the gripper should be drawn at the top or not. """ return self.SetFlag(self.optionGripperTop, attop)
[docs] def CloseButton(self, visible=True): """ Indicates that a close button should be drawn for the pane. :param `visible`: whether the close button should be visible or not. """ return self.SetFlag(self.buttonClose, visible)
[docs] def MaximizeButton(self, visible=True): """ Indicates that a maximize button should be drawn for the pane. :param `visible`: whether the maximize button should be visible or not. """ return self.SetFlag(self.buttonMaximize, visible)
[docs] def MinimizeButton(self, visible=True): """ Indicates that a minimize button should be drawn for the pane. :param `visible`: whether the minimize button should be visible or not. """ return self.SetFlag(self.buttonMinimize, visible)
[docs] def PinButton(self, visible=True): """ Indicates that a pin button should be drawn for the pane. :param `visible`: whether the pin button should be visible or not. """ return self.SetFlag(self.buttonPin, visible)
[docs] def DestroyOnClose(self, b=True): """ Indicates whether a pane should be destroyed when it is closed. Normally a pane is simply hidden when the close button is clicked. Setting `b` to ``True`` will cause the window to be destroyed when the user clicks the pane's close button. :param `b`: whether the pane should be destroyed when it is closed or not. """ return self.SetFlag(self.optionDestroyOnClose, b)
[docs] def TopDockable(self, b=True): """ Indicates whether a pane can be docked at the top of the frame. :param `b`: whether the pane can be docked at the top or not. """ return self.SetFlag(self.optionTopDockable, b)
[docs] def BottomDockable(self, b=True): """ Indicates whether a pane can be docked at the bottom of the frame. :param `b`: whether the pane can be docked at the bottom or not. """ return self.SetFlag(self.optionBottomDockable, b)
[docs] def LeftDockable(self, b=True): """ Indicates whether a pane can be docked on the left of the frame. :param `b`: whether the pane can be docked at the left or not. """ return self.SetFlag(self.optionLeftDockable, b)
[docs] def RightDockable(self, b=True): """ Indicates whether a pane can be docked on the right of the frame. :param `b`: whether the pane can be docked at the right or not. """ return self.SetFlag(self.optionRightDockable, b)
[docs] def Floatable(self, b=True): """ Sets whether the user will be able to undock a pane and turn it into a floating window. :param `b`: whether the pane can be floated or not. """ return self.SetFlag(self.optionFloatable, b)
[docs] def Movable(self, b=True): """ Indicates whether a pane can be moved. :param `b`: whether the pane can be moved or not. """ return self.SetFlag(self.optionMovable, b)
[docs] def NotebookDockable(self, b=True): """ Indicates whether a pane can be docked in an automatic L{AuiNotebook}. :param `b`: whether the pane can be docked in a notebook or not. """ return self.SetFlag(self.optionNotebookDockable, b)
[docs] def DockFixed(self, b=True): """ Causes the containing dock to have no resize sash. This is useful for creating panes that span the entire width or height of a dock, but should not be resizable in the other direction. :param `b`: whether the pane will have a resize sash or not. """ return self.SetFlag(self.optionDockFixed, b)
[docs] def Dockable(self, b=True): """ Specifies whether a frame can be docked or not. It is the same as specifying L{TopDockable} . L{BottomDockable} . L{LeftDockable} . L{RightDockable} . :param `b`: whether the frame can be docked or not. """ return self.TopDockable(b).BottomDockable(b).LeftDockable(b).RightDockable(b)
[docs] def TopSnappable(self, b=True): """ Indicates whether a pane can be snapped at the top of the main frame. :param `b`: whether the pane can be snapped at the top of the main frame or not. """ return self.SetFlag(self.optionTopSnapped, b)
[docs] def BottomSnappable(self, b=True): """ Indicates whether a pane can be snapped at the bottom of the main frame. :param `b`: whether the pane can be snapped at the bottom of the main frame or not. """ return self.SetFlag(self.optionBottomSnapped, b)
[docs] def LeftSnappable(self, b=True): """ Indicates whether a pane can be snapped on the left of the main frame. :param `b`: whether the pane can be snapped at the left of the main frame or not. """ return self.SetFlag(self.optionLeftSnapped, b)
[docs] def RightSnappable(self, b=True): """ Indicates whether a pane can be snapped on the right of the main frame. :param `b`: whether the pane can be snapped at the right of the main frame or not. """ return self.SetFlag(self.optionRightSnapped, b)
[docs] def Snappable(self, b=True): """ Indicates whether a pane can be snapped on the main frame. This is equivalent as calling L{TopSnappable} . L{BottomSnappable} . L{LeftSnappable} . L{RightSnappable} . :param `b`: whether the pane can be snapped on the main frame or not. """ return self.TopSnappable(b).BottomSnappable(b).LeftSnappable(b).RightSnappable(b)
[docs] def FlyOut(self, b=True): """ Indicates whether a pane, when floating, has a "fly-out" effect (i.e., floating panes which only show themselves when moused over). :param `b`: whether the pane can be snapped on the main frame or not. """ return self.SetFlag(self.optionFlyOut, b) # Copy over the members that pertain to docking position
[docs] def SetDockPos(self, source): """ Copies the `source` pane members that pertain to docking position to `self`. :param `source`: the source pane from where to copy the attributes. """ self.dock_direction = source.dock_direction self.dock_layer = source.dock_layer self.dock_row = source.dock_row self.dock_pos = source.dock_pos self.dock_proportion = source.dock_proportion self.floating_pos = wx.Point(*source.floating_pos) self.floating_size = wx.Size(*source.floating_size) self.rect = wx.Rect(*source.rect) return self
[docs] def DefaultPane(self): """ Specifies that the pane should adopt the default pane settings. """ state = self.state state |= self.optionTopDockable | self.optionBottomDockable | \ self.optionLeftDockable | self.optionRightDockable | \ self.optionNotebookDockable | \ self.optionFloatable | self.optionMovable | self.optionResizable | \ self.optionCaption | self.optionPaneBorder | self.buttonClose self.state = state return self
[docs] def CentrePane(self): """ Specifies that the pane should adopt the default center pane settings. Centre panes usually do not have caption bars. This function provides an easy way of preparing a pane to be displayed in the center dock position. """ return self.CenterPane()
[docs] def CenterPane(self): """ Specifies that the pane should adopt the default center pane settings. Centre panes usually do not have caption bars. This function provides an easy way of preparing a pane to be displayed in the center dock position. """ self.state = 0 return self.Center().PaneBorder().Resizable()
[docs] def ToolbarPane(self): """ Specifies that the pane should adopt the default toolbar pane settings. """ self.DefaultPane() state = self.state state |= (self.optionToolbar | self.optionGripper) state &= ~(self.optionResizable | self.optionCaption | self.optionCaptionLeft) if self.dock_layer == 0: self.dock_layer = 10 self.state = state return self
[docs] def Icon(self, icon): """ Specifies whether an icon is drawn on the left of the caption text when the pane is docked. If `icon` is ``None`` or `wx.NullIcon`, no icon is drawn on the caption space. :param icon: an icon to draw on the caption space, or ``None``. """ if icon is None: icon = wx.NullIcon self.icon = icon return self
[docs] def SetFlag(self, flag, option_state): """ Turns the property given by `flag` on or off with the `option_state` parameter. :param `flag`: the property to set; :param `option_state`: either ``True`` or ``False``. """ state = self.state if option_state: state |= flag else: state &= ~flag self.state = state if flag in [self.buttonClose, self.buttonMaximize, self.buttonMinimize, self.buttonPin]: self.ResetButtons() return self
[docs] def HasFlag(self, flag): """ Returns ``True`` if the the property specified by flag is active for the pane. :param `flag`: the property to check for activity. """ return (self.state & flag and [True] or [False])[0]
[docs] def ResetButtons(self): """ Resets all the buttons and recreates them from scratch depending on the L{AuiPaneInfo} flags. """ floating = self.HasFlag(self.optionFloating) self.buttons = [] if not floating and self.HasMinimizeButton(): button = AuiPaneButton(AUI_BUTTON_MINIMIZE) self.buttons.append(button) if not floating and self.HasMaximizeButton(): button = AuiPaneButton(AUI_BUTTON_MAXIMIZE_RESTORE) self.buttons.append(button) if not floating and self.HasPinButton(): button = AuiPaneButton(AUI_BUTTON_PIN) self.buttons.append(button) if self.HasCloseButton(): button = AuiPaneButton(AUI_BUTTON_CLOSE) self.buttons.append(button)
[docs] def CountButtons(self): """ Returns the number of visible buttons in the docked pane. """ n = 0 if self.HasCaption() or self.HasCaptionLeft(): if isinstance(wx.GetTopLevelParent(self.window), AuiFloatingFrame): return 1 if self.HasCloseButton(): n += 1 if self.HasMaximizeButton(): n += 1 if self.HasMinimizeButton(): n += 1 if self.HasPinButton(): n += 1 return n
[docs] def IsHorizontal(self): """ Returns ``True`` if the pane `dock_direction` is horizontal. """ return self.dock_direction in [AUI_DOCK_TOP, AUI_DOCK_BOTTOM]
[docs] def IsVertical(self): """ Returns ``True`` if the pane `dock_direction` is vertical. """ return self.dock_direction in [AUI_DOCK_LEFT, AUI_DOCK_RIGHT] # Null AuiPaneInfo reference
NonePaneInfo = AuiPaneInfo() # ---------------------------------------------------------------------------- #
[docs]class AuiDockingGuide(wx.Frame): """ Base class for L{AuiCenterDockingGuide} and L{AuiSingleDockingGuide}."""
[docs] def __init__(self, parent, id=wx.ID_ANY, title="", pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.FRAME_TOOL_WINDOW | wx.STAY_ON_TOP | wx.FRAME_NO_TASKBAR | wx.NO_BORDER, name="AuiDockingGuide"): """ Default class constructor. Used internally, do not call it in your code! :param `parent`: the L{AuiDockingGuide} parent; :param `id`: the window identifier. It may take a value of -1 to indicate a default value. :param `title`: the caption to be displayed on the frame's title bar. :param `pos`: the window position. A value of (-1, -1) indicates a default position, chosen by either the windowing system or wxPython, depending on platform. :param `size`: the window size. A value of (-1, -1) indicates a default size, chosen by either the windowing system or wxPython, depending on platform. :param `style`: the window style. :param `name`: the name of the window. This parameter is used to associate a name with the item, allowing the application user to set Motif resource values for individual windows. """ wx.Frame.__init__(self, parent, id, title, pos, size, style, name=name)
[docs] def HitTest(self, x, y): """ To be overridden by parent classes. :param `x`: the `x` mouse position; :param `y`: the `y` mouse position. """ return 0
[docs] def ValidateNotebookDocking(self, valid): """ To be overridden by parent classes. :param `valid`: whether a pane can be docked on top to another to form an automatic L{AuiNotebook}. """ return 0 # ============================================================================ # implementation # ============================================================================ # --------------------------------------------------------------------------- # AuiDockingGuideWindow # ---------------------------------------------------------------------------
[docs]class AuiDockingGuideWindow(wx.Window): """ Target class for L{AuiSingleDockingGuide} and L{AuiCenterDockingGuide}. """
[docs] def __init__(self, parent, rect, direction=0, center=False, useAero=False): """ Default class constructor. Used internally, do not call it in your code! :param `parent`: the L{AuiDockingGuideWindow} parent; :param `rect`: the window rect; :param `direction`: one of ``wx.TOP``, ``wx.BOTTOM``, ``wx.LEFT``, ``wx.RIGHT``, ``wx.CENTER``; :param `center`: whether the calling class is a L{AuiCenterDockingGuide}; :param `useAero`: whether to use the new Aero-style bitmaps or Whidbey-style bitmaps for the docking guide. """ wx.Window.__init__(self, parent, -1, rect.GetPosition(), rect.GetSize(), wx.NO_BORDER) self._direction = direction self._center = center self._valid = True self._useAero = useAero self._bmp_unfocus, self._bmp_focus = GetDockingImage(direction, useAero, center) self._currentImage = self._bmp_unfocus self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM) self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground) self.Bind(wx.EVT_PAINT, self.OnPaint)
[docs] def SetValid(self, valid): """ Sets the docking direction as valid or invalid. :param `valid`: whether the docking direction is allowed or not. """ self._valid = valid
[docs] def IsValid(self): """ Returns whether the docking direction is valid. """ return self._valid
[docs] def OnEraseBackground(self, event): """ Handles the ``wx.EVT_ERASE_BACKGROUND`` event for L{AuiDockingGuideWindow}. :param `event`: a `wx.EraseEvent` to be processed. :note: This is intentionally empty to reduce flickering while drawing. """ pass
[docs] def DrawBackground(self, dc): """ Draws the docking guide background. :param `dc`: a `wx.DC` device context object. """ rect = self.GetClientRect() dc.SetPen(wx.TRANSPARENT_PEN) dc.SetBrush(wx.Brush(colourTargetBackground)) dc.DrawRectangleRect(rect) dc.SetPen(wx.Pen(colourTargetBorder)) left = rect.GetLeft() top = rect.GetTop() right = rect.GetRight() bottom = rect.GetBottom() if self._direction != wx.CENTER: if not self._center or self._direction != wx.BOTTOM: dc.DrawLine(left, top, right+1, top) if not self._center or self._direction != wx.RIGHT: dc.DrawLine(left, top, left, bottom+1) if not self._center or self._direction != wx.LEFT: dc.DrawLine(right, top, right, bottom+1) if not self._center or self._direction != wx.TOP: dc.DrawLine(left, bottom, right+1, bottom) dc.SetPen(wx.Pen(colourTargetShade)) if self._direction != wx.RIGHT: dc.DrawLine(left + 1, top + 1, left + 1, bottom) if self._direction != wx.BOTTOM: dc.DrawLine(left + 1, top + 1, right, top + 1)
[docs] def DrawDottedLine(self, dc, point, length, vertical): """ Draws a dotted line (not used if the docking guide images are ok). :param `dc`: a `wx.DC` device context object; :param `point`: a `wx.Point` where to start drawing the dotted line; :param `length`: the length of the dotted line; :param `vertical`: whether it is a vertical docking guide window or not. """ for i in xrange(0, length, 2): dc.DrawPoint(point.x, point.y) if vertical: point.y += 2 else: point.x += 2
[docs] def DrawIcon(self, dc): """ Draws the docking guide icon (not used if the docking guide images are ok). :param `dc`: a `wx.DC` device context object. """ rect = wx.Rect(*self.GetClientRect()) point = wx.Point() length = 0 rect.Deflate(4, 4) dc.SetPen(wx.Pen(colourIconBorder)) dc.SetBrush(wx.Brush(colourIconBackground)) dc.DrawRectangleRect(rect) right1 = rect.GetRight() + 1 bottom1 = rect.GetBottom() + 1 dc.SetPen(wx.Pen(colourIconShadow)) dc.DrawLine(rect.x + 1, bottom1, right1 + 1, bottom1) dc.DrawLine(right1, rect.y + 1, right1, bottom1 + 1) rect.Deflate(1, 1) if self._direction == wx.TOP: rect.height -= rect.height / 2 point = rect.GetBottomLeft() length = rect.width elif self._direction == wx.LEFT: rect.width -= rect.width / 2 point = rect.GetTopRight() length = rect.height elif self._direction == wx.RIGHT: rect.x += rect.width / 2 rect.width -= rect.width / 2 point = rect.GetTopLeft() length = rect.height elif self._direction == wx.BOTTOM: rect.y += rect.height / 2 rect.height -= rect.height / 2 point = rect.GetTopLeft() length = rect.width elif self._direction == wx.CENTER: rect.Deflate(1, 1) point = rect.GetTopLeft() length = rect.width dc.GradientFillLinear(rect, colourIconDockingPart1, colourIconDockingPart2, self._direction) dc.SetPen(wx.Pen(colourIconBorder)) if self._direction == wx.CENTER: self.DrawDottedLine(dc, rect.GetTopLeft(), rect.width, False) self.DrawDottedLine(dc, rect.GetTopLeft(), rect.height, True) self.DrawDottedLine(dc, rect.GetBottomLeft(), rect.width, False) self.DrawDottedLine(dc, rect.GetTopRight(), rect.height, True) elif self._direction in [wx.TOP, wx.BOTTOM]: self.DrawDottedLine(dc, point, length, False) else: self.DrawDottedLine(dc, point, length, True)
[docs] def DrawArrow(self, dc): """ Draws the docking guide arrow icon (not used if the docking guide images are ok). :param `dc`: a `wx.DC` device context object. """ rect = self.GetClientRect() point = wx.Point() point.x = (rect.GetLeft() + rect.GetRight()) / 2 point.y = (rect.GetTop() + rect.GetBottom()) / 2 rx, ry = wx.Size(), wx.Size() if self._direction == wx.TOP: rx = wx.Size(1, 0) ry = wx.Size(0, 1) elif self._direction == wx.LEFT: rx = wx.Size(0, -1) ry = wx.Size(1, 0) elif self._direction == wx.RIGHT: rx = wx.Size(0, 1) ry = wx.Size(-1, 0) elif self._direction == wx.BOTTOM: rx = wx.Size(-1, 0) ry = wx.Size(0, -1) point.x += ry.x*3 point.y += ry.y*3 dc.SetPen(wx.Pen(colourIconArrow)) for i in xrange(4): pt1 = wx.Point(point.x - rx.x*i, point.y - rx.y*i) pt2 = wx.Point(point.x + rx.x*(i+1), point.y + rx.y*(i+1)) dc.DrawLinePoint(pt1, pt2) point.x += ry.x point.y += ry.y
[docs] def OnPaint(self, event): """ Handles the ``wx.EVT_PAINT`` event for L{AuiDockingGuideWindow}. :param `event`: a `wx.PaintEvent` to be processed. """ dc = wx.AutoBufferedPaintDC(self) if self._currentImage.IsOk() and self._valid: dc.DrawBitmap(self._currentImage, 0, 0, True) else: self.Draw(dc)
[docs] def Draw(self, dc): """ Draws the whole docking guide window (not used if the docking guide images are ok). :param `dc`: a `wx.DC` device context object. """ self.DrawBackground(dc) if self._valid: self.DrawIcon(dc) self.DrawArrow(dc)
[docs] def UpdateDockGuide(self, pos): """ Updates the docking guide images depending on the mouse position, using focused images if the mouse is inside the docking guide or unfocused images if it is outside. :param `pos`: a `wx.Point` mouse position. """ inside = self.GetScreenRect().Contains(pos) if inside: image = self._bmp_focus else: image = self._bmp_unfocus if image != self._currentImage: self._currentImage = image self.Refresh() self.Update() # --------------------------------------------------------------------------- # AuiSingleDockingGuide # ---------------------------------------------------------------------------
[docs]class AuiSingleDockingGuide(AuiDockingGuide): """ A docking guide window for single docking hint (not diamond-shaped HUD). """
[docs] def __init__(self, parent, direction=0): """ Default class constructor. Used internally, do not call it in your code! :param `parent`: the L{AuiSingleDockingGuide} parent; :param `direction`: one of ``wx.TOP``, ``wx.BOTTOM``, ``wx.LEFT``, ``wx.RIGHT``. """ self._direction = direction style = wx.FRAME_TOOL_WINDOW | wx.STAY_ON_TOP | \ wx.FRAME_NO_TASKBAR | wx.NO_BORDER # Use of FRAME_SHAPED on wxMac causes the frame to be visible # breaking the docking hints. if wx.Platform != '__WXMAC__': style |= wx.FRAME_SHAPED AuiDockingGuide.__init__(self, parent, style=style, name="auiSingleDockTarget") self.Hide() useAero = GetManager(self.GetParent()).GetAGWFlags() & AUI_MGR_AERO_DOCKING_GUIDES useWhidbey = GetManager(self.GetParent()).GetAGWFlags() & AUI_MGR_WHIDBEY_DOCKING_GUIDES self._useAero = useAero or useWhidbey self._valid = True if useAero: sizeX, sizeY = aeroguideSizeX, aeroguideSizeY elif useWhidbey: sizeX, sizeY = whidbeySizeX, whidbeySizeY else: sizeX, sizeY = guideSizeX, guideSizeY if direction not in [wx.TOP, wx.BOTTOM]: sizeX, sizeY = sizeY, sizeX if self._useAero: self.CreateShapesWithStyle(useWhidbey) if wx.Platform == "__WXGTK__": self.Bind(wx.EVT_WINDOW_CREATE, self.SetGuideShape) else: self.SetGuideShape() self.SetSize(self.region.GetBox().GetSize()) else: self.SetSize((sizeX, sizeY)) self.rect = wx.Rect(0, 0, sizeX, sizeY) if self._useAero: useAero = (useWhidbey and [2] or [1])[0] else: useAero = 0 self.target = AuiDockingGuideWindow(self, self.rect, direction, False, useAero)
[docs] def CreateShapesWithStyle(self, useWhidbey): """ Creates the docking guide window shape based on which docking bitmaps are used. :param `useWhidbey`: if ``True``, use Whidbey-style bitmaps; if ``False``, use the Aero-style bitmaps. """ sizeX, sizeY = aeroguideSizeX, aeroguideSizeY if useWhidbey: sizeX, sizeY = whidbeySizeX, whidbeySizeY if self._direction not in [wx.TOP, wx.BOTTOM]: sizeX, sizeY = sizeY, sizeX useAero = (useWhidbey and [2] or [1])[0] bmp, dummy = GetDockingImage(self._direction, useAero, False) region = wx.RegionFromBitmap(bmp) self.region = region
[docs] def AeroMove(self, pos): """ Moves the docking window to the new position. Overridden in children classes. :param `pos`: the new docking guide position. """ pass
[docs] def SetGuideShape(self, event=None): """ Sets the correct shape for the docking guide window. :param `event`: on wxGTK, a `wx.WindowCreateEvent` event to process. """ self.SetShape(self.region) if event is not None: # Skip the event on wxGTK event.Skip() wx.CallAfter(wx.SafeYield, self, True)
[docs] def SetShape(self, region): """ If the platform supports it, sets the shape of the window to that depicted by `region`. The system will not display or respond to any mouse event for the pixels that lie outside of the region. To reset the window to the normal rectangular shape simply call L{SetShape} again with an empty region. :param `region`: the shape of the frame. :note: Overridden for wxMac. """ if wx.Platform == '__WXMAC__': # HACK so we don't crash when SetShape is called return else: super(AuiSingleDockingGuide, self).SetShape(region)
[docs] def SetValid(self, valid): """ Sets the docking direction as valid or invalid. :param `valid`: whether the docking direction is allowed or not. """ self._valid = valid
[docs] def IsValid(self): """ Returns whether the docking direction is valid. """ return self._valid
[docs] def UpdateDockGuide(self, pos): """ Updates the docking guide images depending on the mouse position, using focused images if the mouse is inside the docking guide or unfocused images if it is outside. :param `pos`: a `wx.Point` mouse position. """ self.target.UpdateDockGuide(pos)
[docs] def HitTest(self, x, y): """ Checks if the mouse position is inside the target window rect. :param `x`: the `x` mouse position; :param `y`: the `y` mouse position. """ if self.target.GetScreenRect().Contains((x, y)): return wx.ALL return -1 # --------------------------------------------------------------------------- # AuiCenterDockingGuide # ---------------------------------------------------------------------------
[docs]class AuiCenterDockingGuide(AuiDockingGuide): """ A docking guide window for multiple docking hint (diamond-shaped HUD). """
[docs] def __init__(self, parent): """ Default class constructor. Used internally, do not call it in your code! :param `parent`: the L{AuiCenterDockingGuide} parent. """ AuiDockingGuide.__init__(self, parent, style=wx.FRAME_TOOL_WINDOW | wx.STAY_ON_TOP | wx.FRAME_NO_TASKBAR | wx.NO_BORDER | wx.FRAME_SHAPED, name="auiCenterDockTarget") self.Hide() self.CreateShapesWithStyle() self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM) if wx.Platform == "__WXGTK__": self.Bind(wx.EVT_WINDOW_CREATE, self.SetGuideShape) else: self.SetGuideShape() self.SetSize(self.region.GetBox().GetSize()) self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground) self.Bind(wx.EVT_PAINT, self.OnPaint)
[docs] def CreateShapesWithStyle(self): """ Creates the docking guide window shape based on which docking bitmaps are used. """ useAero = (GetManager(self.GetParent()).GetAGWFlags() & AUI_MGR_AERO_DOCKING_GUIDES) != 0 useWhidbey = (GetManager(self.GetParent()).GetAGWFlags() & AUI_MGR_WHIDBEY_DOCKING_GUIDES) != 0 self._useAero = 0 if useAero: self._useAero = 1 elif useWhidbey: self._useAero = 2 if useAero: sizeX, sizeY = aeroguideSizeX, aeroguideSizeY elif useWhidbey: sizeX, sizeY = whidbeySizeX, whidbeySizeY else: sizeX, sizeY = guideSizeX, guideSizeY rectLeft = wx.Rect(0, sizeY, sizeY, sizeX) rectTop = wx.Rect(sizeY, 0, sizeX, sizeY) rectRight = wx.Rect(sizeY+sizeX, sizeY, sizeY, sizeX) rectBottom = wx.Rect(sizeY, sizeX + sizeY, sizeX, sizeY) rectCenter = wx.Rect(sizeY, sizeY, sizeX, sizeX) if not self._useAero: self.targetLeft = AuiDockingGuideWindow(self, rectLeft, wx.LEFT, True, useAero) self.targetTop = AuiDockingGuideWindow(self, rectTop, wx.TOP, True, useAero) self.targetRight = AuiDockingGuideWindow(self, rectRight, wx.RIGHT, True, useAero) self.targetBottom = AuiDockingGuideWindow(self, rectBottom, wx.BOTTOM, True, useAero) self.targetCenter = AuiDockingGuideWindow(self, rectCenter, wx.CENTER, True, useAero) # top-left diamond tld = [wx.Point(rectTop.x, rectTop.y+rectTop.height-8), wx.Point(rectLeft.x+rectLeft.width-8, rectLeft.y), rectTop.GetBottomLeft()] # bottom-left diamond bld = [wx.Point(rectLeft.x+rectLeft.width-8, rectLeft.y+rectLeft.height), wx.Point(rectBottom.x, rectBottom.y+8), rectBottom.GetTopLeft()] # top-right diamond trd = [wx.Point(rectTop.x+rectTop.width, rectTop.y+rectTop.height-8), wx.Point(rectRight.x+8, rectRight.y), rectRight.GetTopLeft()] # bottom-right diamond brd = [wx.Point(rectRight.x+8, rectRight.y+rectRight.height), wx.Point(rectBottom.x+rectBottom.width, rectBottom.y+8), rectBottom.GetTopRight()] self._triangles = [tld[0:2], bld[0:2], [wx.Point(rectTop.x+rectTop.width-1, rectTop.y+rectTop.height-8), wx.Point(rectRight.x+7, rectRight.y)], [wx.Point(rectRight.x+7, rectRight.y+rectRight.height), wx.Point(rectBottom.x+rectBottom.width-1, rectBottom.y+8)]] region = wx.Region() region.UnionRect(rectLeft) region.UnionRect(rectTop) region.UnionRect(rectRight) region.UnionRect(rectBottom) region.UnionRect(rectCenter) region.UnionRegion(wx.RegionFromPoints(tld)) region.UnionRegion(wx.RegionFromPoints(bld)) region.UnionRegion(wx.RegionFromPoints(trd)) region.UnionRegion(wx.RegionFromPoints(brd)) elif useAero: self._aeroBmp = aero_dock_pane.GetBitmap() region = wx.RegionFromBitmap(self._aeroBmp) self._allAeroBmps = [aero_dock_pane_left.GetBitmap(), aero_dock_pane_top.GetBitmap(), aero_dock_pane_right.GetBitmap(), aero_dock_pane_bottom.GetBitmap(), aero_dock_pane_center.GetBitmap(), aero_dock_pane.GetBitmap()] self._deniedBitmap = aero_denied.GetBitmap() self._aeroRects = [rectLeft, rectTop, rectRight, rectBottom, rectCenter] self._valid = True elif useWhidbey: self._aeroBmp = whidbey_dock_pane.GetBitmap() region = wx.RegionFromBitmap(self._aeroBmp) self._allAeroBmps = [whidbey_dock_pane_left.GetBitmap(), whidbey_dock_pane_top.GetBitmap(), whidbey_dock_pane_right.GetBitmap(), whidbey_dock_pane_bottom.GetBitmap(), whidbey_dock_pane_center.GetBitmap(), whidbey_dock_pane.GetBitmap()] self._deniedBitmap = whidbey_denied.GetBitmap() self._aeroRects = [rectLeft, rectTop, rectRight, rectBottom, rectCenter] self._valid = True self.region = region
[docs] def SetGuideShape(self, event=None): """ Sets the correct shape for the docking guide window. :param `event`: on wxGTK, a `wx.WindowCreateEvent` event to process. """ self.SetShape(self.region) if event is not None: # Skip the event on wxGTK event.Skip() wx.CallAfter(wx.SafeYield, self, True)
[docs] def UpdateDockGuide(self, pos): """ Updates the docking guides images depending on the mouse position, using focused images if the mouse is inside the docking guide or unfocused images if it is outside. :param `pos`: a `wx.Point` mouse position. """ if not self._useAero: for target in self.GetChildren(): target.UpdateDockGuide(pos) else: lenRects = len(self._aeroRects) for indx, rect in enumerate(self._aeroRects): if rect.Contains(pos): if self._allAeroBmps[indx] != self._aeroBmp: if indx < lenRects - 1 or (indx == lenRects - 1 and self._valid): self._aeroBmp = self._allAeroBmps[indx] self.Refresh() else: self._aeroBmp = self._allAeroBmps[-1] self.Refresh() return if self._aeroBmp != self._allAeroBmps[-1]: self._aeroBmp = self._allAeroBmps[-1] self.Refresh()
[docs] def HitTest(self, x, y): """ Checks if the mouse position is inside the target windows rect. :param `x`: the `x` mouse position; :param `y`: the `y` mouse position. """ if not self._useAero: if self.targetLeft.GetScreenRect().Contains((x, y)): return wx.LEFT if self.targetTop.GetScreenRect().Contains((x, y)): return wx.UP if self.targetRight.GetScreenRect().Contains((x, y)): return wx.RIGHT if self.targetBottom.GetScreenRect().Contains((x, y)): return wx.DOWN if self.targetCenter.IsValid() and self.targetCenter.GetScreenRect().Contains((x, y)): return wx.CENTER else: constants = [wx.LEFT, wx.UP, wx.RIGHT, wx.DOWN, wx.CENTER] lenRects = len(self._aeroRects) for indx, rect in enumerate(self._aeroRects): if rect.Contains((x, y)): if indx < lenRects or (indx == lenRects-1 and self._valid): return constants[indx] return -1
[docs] def ValidateNotebookDocking(self, valid): """ Sets whether a pane can be docked on top of another to create an automatic L{AuiNotebook}. :param `valid`: whether a pane can be docked on top to another to form an automatic L{AuiNotebook}. """ if not self._useAero: if self.targetCenter.IsValid() != valid: self.targetCenter.SetValid(valid) self.targetCenter.Refresh() else: if self._valid != valid: self._valid = valid self.Refresh()
[docs] def AeroMove(self, pos): """ Moves the docking guide window to the new position. :param `pos`: the new docking guide position. """ if not self._useAero: return useWhidbey = (GetManager(self.GetParent()).GetAGWFlags() & AUI_MGR_WHIDBEY_DOCKING_GUIDES) != 0 if useWhidbey: sizeX, sizeY = whidbeySizeX, whidbeySizeY else: sizeX, sizeY = aeroguideSizeX, aeroguideSizeY size = self.GetSize() leftRect, topRect, rightRect, bottomRect, centerRect = self._aeroRects thePos = pos + wx.Point((size.x-sizeY)/2, (size.y-sizeX)/2) centerRect.SetPosition(thePos) leftRect.SetPosition(thePos + wx.Point(-sizeY, 0)) topRect.SetPosition(thePos + wx.Point(0, -sizeY)) rightRect.SetPosition(thePos + wx.Point(sizeX, 0)) bottomRect.SetPosition(thePos + wx.Point(0, sizeX))
[docs] def OnEraseBackground(self, event): """ Handles the ``wx.EVT_ERASE_BACKGROUND`` event for L{AuiCenterDockingGuide}. :param `event`: `wx.EraseEvent` to be processed. :note: This is intentionally empty to reduce flickering while drawing. """ pass
[docs] def OnPaint(self, event): """ Handles the ``wx.EVT_PAINT`` event for L{AuiCenterDockingGuide}. :param `event`: a `wx.PaintEvent` to be processed. """ dc = wx.AutoBufferedPaintDC(self) if self._useAero: dc.SetBrush(wx.TRANSPARENT_BRUSH) dc.SetPen(wx.TRANSPARENT_PEN) else: dc.SetBrush(wx.Brush(colourTargetBackground)) dc.SetPen(wx.Pen(colourTargetBorder)) rect = self.GetClientRect() dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height) if self._useAero: dc.DrawBitmap(self._aeroBmp, 0, 0, True) if not self._valid: diff = (self._useAero == 2 and [1] or [0])[0] bmpX, bmpY = self._deniedBitmap.GetWidth(), self._deniedBitmap.GetHeight() xPos, yPos = (rect.x + (rect.width)/2 - bmpX/2), (rect.y + (rect.height)/2 - bmpY/2) dc.DrawBitmap(self._deniedBitmap, xPos+1, yPos+diff, True) return dc.SetPen(wx.Pen(colourTargetBorder, 2)) for pts in self._triangles: dc.DrawLinePoint(pts[0], pts[1]) # ---------------------------------------------------------------------------- # AuiDockingHintWindow # ----------------------------------------------------------------------------
[docs]class AuiDockingHintWindow(wx.Frame): """ The original wxAUI docking window hint. """
[docs] def __init__(self, parent, id=wx.ID_ANY, title="", pos=wx.DefaultPosition, size=wx.Size(1, 1), style=wx.FRAME_TOOL_WINDOW | wx.FRAME_FLOAT_ON_PARENT | wx.FRAME_NO_TASKBAR | wx.NO_BORDER | wx.FRAME_SHAPED, name="auiHintWindow"): """ Default class constructor. Used internally, do not call it in your code! :param `parent`: the L{AuiDockingGuide} parent; :param `id`: the window identifier. It may take a value of -1 to indicate a default value. :param `title`: the caption to be displayed on the frame's title bar; :param `pos`: the window position. A value of (-1, -1) indicates a default position, chosen by either the windowing system or wxPython, depending on platform; :param `size`: the window size. A value of (-1, -1) indicates a default size, chosen by either the windowing system or wxPython, depending on platform; :param `style`: the window style; :param `name`: the name of the window. This parameter is used to associate a name with the item, allowing the application user to set Motif resource values for individual windows. """ if wx.Platform == '__WXMAC__' and style & wx.FRAME_SHAPED: # Having the shaped frame causes the frame to not be visible # with the transparent style hints. style -= wx.FRAME_SHAPED wx.Frame.__init__(self, parent, id, title, pos, size, style, name=name) self._blindMode = False self.SetBackgroundColour(colourHintBackground) # Can't set background colour on a frame on wxMac # so add a panel to set the colour on. if wx.Platform == '__WXMAC__': sizer = wx.BoxSizer(wx.HORIZONTAL) self.panel = wx.Panel(self) sizer.Add(self.panel, 1, wx.EXPAND) self.SetSizer(sizer) self.panel.SetBackgroundColour(colourHintBackground) self.Bind(wx.EVT_SIZE, self.OnSize)
[docs] def MakeVenetianBlinds(self): """ Creates the "venetian blind" effect if L{AuiManager} has the ``AUI_MGR_VENETIAN_BLINDS_HINT`` flag set. """ amount = 128 size = self.GetClientSize() region = wx.Region(0, 0, size.x, 1) for y in xrange(size.y): # Reverse the order of the bottom 4 bits j = (y & 8 and [1] or [0])[0] | (y & 4 and [2] or [0])[0] | \ (y & 2 and [4] or [0])[0] | (y & 1 and [8] or [0])[0] if 16*j+8 < amount: region.Union(0, y, size.x, 1) self.SetShape(region)
[docs] def SetBlindMode(self, agwFlags): """ Sets whether venetian blinds or transparent hints will be shown as docking hint. This depends on the L{AuiManager} flags. :param `agwFlags`: the L{AuiManager} flags. """ self._blindMode = (agwFlags & AUI_MGR_VENETIAN_BLINDS_HINT) != 0 if self._blindMode or not self.CanSetTransparent(): self.MakeVenetianBlinds() self.SetTransparent(255) else: self.SetShape(wx.Region()) if agwFlags & AUI_MGR_HINT_FADE == 0: self.SetTransparent(80) else: self.SetTransparent(0)
[docs] def SetShape(self, region): """ If the platform supports it, sets the shape of the window to that depicted by `region`. The system will not display or respond to any mouse event for the pixels that lie outside of the region. To reset the window to the normal rectangular shape simply call L{SetShape} again with an empty region. :param `region`: the shape of the frame (an instance of `wx.Region`). :note: Overridden for wxMac. """ if wx.Platform == '__WXMAC__': # HACK so we don't crash when SetShape is called return else: super(AuiDockingHintWindow, self).SetShape(region)
[docs] def Show(self, show=True): """ Show the hint window. :param `show`: whether to show or hide the hint docking window. """ super(AuiDockingHintWindow, self).Show(show) if wx.Platform == '__WXMAC__': # Need to manually do layout since its a borderless frame. self.Layout()
[docs] def OnSize(self, event): """ Handles the ``wx.EVT_SIZE`` event for L{AuiDockingHintWindow}. :param `event`: a `wx.SizeEvent` to be processed. """ if self._blindMode or not self.CanSetTransparent(): self.MakeVenetianBlinds() # ---------------------------------------------------------------------------- # # -- AuiFloatingFrame class implementation --
[docs]class AuiFloatingFrame(wx.MiniFrame): """ AuiFloatingFrame is the frame class that holds floating panes. """
[docs] def __init__(self, parent, owner_mgr, pane=None, id=wx.ID_ANY, title="", style=wx.FRAME_TOOL_WINDOW | wx.FRAME_FLOAT_ON_PARENT | wx.FRAME_NO_TASKBAR | wx.CLIP_CHILDREN): """ Default class constructor. Used internally, do not call it in your code! :param `parent`: the L{AuiFloatingFrame} parent; :param `owner_mgr`: the L{AuiManager} that manages the floating pane; :param `pane`: the L{AuiPaneInfo} pane that is about to float; :param `id`: the window identifier. It may take a value of -1 to indicate a default value. :param `title`: the caption to be displayed on the frame's title bar. :param `style`: the window style. """ if pane and pane.IsResizeable(): style += wx.RESIZE_BORDER if pane: self._is_toolbar = pane.IsToolbar() self._useNativeMiniframes = False if AuiManager_UseNativeMiniframes(owner_mgr): # On wxMac we always use native miniframes self._useNativeMiniframes = True style += wx.CAPTION + wx.SYSTEM_MENU if pane.HasCloseButton(): style += wx.CLOSE_BOX if pane.HasMaximizeButton(): style += wx.MAXIMIZE_BOX if pane.HasMinimizeButton(): style += wx.MINIMIZE_BOX wx.MiniFrame.__init__(self, parent, id, title, pos=pane.floating_pos, size=pane.floating_size, style=style, name="auiFloatingFrame") self._fly_timer = wx.Timer(self, wx.ID_ANY) self._check_fly_timer = wx.Timer(self, wx.ID_ANY) self.Bind(wx.EVT_CLOSE, self.OnClose) self.Bind(wx.EVT_SIZE, self.OnSize) self.Bind(wx.EVT_ACTIVATE, self.OnActivate) self.Bind(wx.EVT_TIMER, self.OnCheckFlyTimer, self._check_fly_timer) self.Bind(wx.EVT_TIMER, self.OnFlyTimer, self._fly_timer) self.Bind(EVT_AUI_FIND_MANAGER, self.OnFindManager) if self._useNativeMiniframes: self.Bind(wx.EVT_MOVE, self.OnMoveEvent) self.Bind(wx.EVT_MOVING, self.OnMoveEvent) self.Bind(wx.EVT_IDLE, self.OnIdle) self._useNativeMiniframes = True self.SetExtraStyle(wx.WS_EX_PROCESS_IDLE) else: self.Bind(wx.EVT_MOVE, self.OnMove) self._fly = False self._send_size = True self._alpha_amount = 255 self._owner_mgr = owner_mgr self._moving = False self._lastDirection = None self._transparent = 255 self._last_rect = wx.Rect() self._last2_rect = wx.Rect() self._last3_rect = wx.Rect() self._mgr = AuiManager() self._mgr.SetManagedWindow(self) self._mgr.SetArtProvider(owner_mgr.GetArtProvider()) self._mgr.SetAGWFlags(owner_mgr.GetAGWFlags())
[docs] def CopyAttributes(self, pane): """ Copies all the attributes of the input `pane` into another L{AuiPaneInfo}. :param `pane`: the source L{AuiPaneInfo} from where to copy attributes. """ contained_pane = AuiPaneInfo() contained_pane.name = pane.name contained_pane.caption = pane.caption contained_pane.window = pane.window contained_pane.frame = pane.frame contained_pane.state = pane.state contained_pane.dock_direction = pane.dock_direction contained_pane.dock_layer = pane.dock_layer contained_pane.dock_row = pane.dock_row contained_pane.dock_pos = pane.dock_pos contained_pane.best_size = wx.Size(*pane.best_size) contained_pane.min_size = wx.Size(*pane.min_size) contained_pane.max_size = wx.Size(*pane.max_size) contained_pane.floating_pos = wx.Point(*pane.floating_pos) contained_pane.floating_size = wx.Size(*pane.floating_size) contained_pane.dock_proportion = pane.dock_proportion contained_pane.buttons = pane.buttons contained_pane.rect = wx.Rect(*pane.rect) contained_pane.icon = pane.icon contained_pane.notebook_id = pane.notebook_id contained_pane.transparent = pane.transparent contained_pane.snapped = pane.snapped contained_pane.minimize_mode = pane.minimize_mode contained_pane.minimize_target = pane.minimize_target return contained_pane
[docs] def SetPaneWindow(self, pane): """ Sets all the properties of a pane. :param `pane`: the L{AuiPaneInfo} to analyze. """ self._is_toolbar = pane.IsToolbar() self._pane_window = pane.window if isinstance(pane.window, auibar.AuiToolBar): pane.window.SetAuiManager(self._mgr) self._pane_window.Reparent(self) contained_pane = self.CopyAttributes(pane) contained_pane.Dock().Center().Show(). \ CaptionVisible(False). \ PaneBorder(False). \ Layer(0).Row(0).Position(0) if not contained_pane.HasGripper() and not self._useNativeMiniframes: contained_pane.CaptionVisible(True) indx = self._owner_mgr._panes.index(pane) # Carry over the minimum size pane_min_size = pane.window.GetMinSize() # if the best size is smaller than the min size # then set the min size to the best size as well pane_best_size = contained_pane.best_size if pane_best_size.IsFullySpecified() and (pane_best_size.x < pane_min_size.x or \ pane_best_size.y < pane_min_size.y): pane_min_size = pane_best_size self._pane_window.SetMinSize(pane_min_size) # if the frame window's max size is greater than the min size # then set the max size to the min size as well cur_max_size = self.GetMaxSize() if cur_max_size.IsFullySpecified() and (cur_max_size.x < pane_min_size.x or \ cur_max_size.y < pane_min_size.y): self.SetMaxSize(pane_min_size) art_provider = self._mgr.GetArtProvider() caption_size = art_provider.GetMetric(AUI_DOCKART_CAPTION_SIZE) button_size = art_provider.GetMetric(AUI_DOCKART_PANE_BUTTON_SIZE) + \ 4*art_provider.GetMetric(AUI_DOCKART_PANE_BORDER_SIZE) min_size = pane.window.GetMinSize() if min_size.y < caption_size or min_size.x < button_size: new_x, new_y = min_size.x, min_size.y if min_size.y < caption_size: new_y = (pane.IsResizeable() and [2*wx.SystemSettings.GetMetric(wx.SYS_EDGE_Y)+caption_size] or [1])[0] if min_size.x < button_size: new_x = (pane.IsResizeable() and [2*wx.SystemSettings.GetMetric(wx.SYS_EDGE_X)+button_size] or [1])[0] self.SetMinSize((new_x, new_y)) else: self.SetMinSize(min_size) self._mgr.AddPane(self._pane_window, contained_pane) self._mgr.Update() if pane.min_size.IsFullySpecified(): # because SetSizeHints() calls Fit() too (which sets the window # size to its minimum allowed), we keep the size before calling # SetSizeHints() and reset it afterwards... tmp = self.GetSize() self.GetSizer().SetSizeHints(self) self.SetSize(tmp) self.SetTitle(pane.caption) if pane.floating_size != wx.Size(-1, -1): self.SetSize(pane.floating_size) else: size = pane.best_size if size == wx.Size(-1, -1): size = pane.min_size if size == wx.Size(-1, -1): size = self._pane_window.GetSize() if self._owner_mgr and pane.HasGripper(): if pane.HasGripperTop(): size.y += self._owner_mgr._art.GetMetric(AUI_DOCKART_GRIPPER_SIZE) else: size.x += self._owner_mgr._art.GetMetric(AUI_DOCKART_GRIPPER_SIZE) if not self._useNativeMiniframes: size.y += self._owner_mgr._art.GetMetric(AUI_DOCKART_CAPTION_SIZE) pane.floating_size = size self.SetClientSize(size) self._owner_mgr._panes[indx] = pane self._fly_step = abs(pane.floating_size.y - \ (caption_size + 2*wx.SystemSettings.GetMetric(wx.SYS_EDGE_Y)))/10 self._floating_size = wx.Size(*self.GetSize()) if pane.IsFlyOut(): self._check_fly_timer.Start(50)
[docs] def GetOwnerManager(self): """ Returns the L{AuiManager} that manages the pane. """ return self._owner_mgr
[docs] def OnSize(self, event): """ Handles the ``wx.EVT_SIZE`` event for L{AuiFloatingFrame}. :param `event`: a `wx.SizeEvent` to be processed. """ if self._owner_mgr and self._send_size: self._owner_mgr.OnFloatingPaneResized(self._pane_window, event.GetSize())
[docs] def OnClose(self, event): """ Handles the ``wx.EVT_CLOSE`` event for L{AuiFloatingFrame}. :param `event`: a `wx.CloseEvent` to be processed. """ if self._owner_mgr: self._owner_mgr.OnFloatingPaneClosed(self._pane_window, event) if not event.GetVeto(): self._mgr.DetachPane(self._pane_window) if isinstance(self._pane_window, auibar.AuiToolBar): self._pane_window.SetAuiManager(self._owner_mgr) # if we do not do this, then we can crash... if self._owner_mgr and self._owner_mgr._action_window == self: self._owner_mgr._action_window = None self.Destroy()
[docs] def OnActivate(self, event): """ Handles the ``wx.EVT_ACTIVATE`` event for L{AuiFloatingFrame}. :param `event`: a `wx.ActivateEvent` to be processed. """ if self._owner_mgr and event.GetActive(): self._owner_mgr.OnFloatingPaneActivated(self._pane_window)
[docs] def OnMove(self, event): """ Handles the ``wx.EVT_MOVE`` event for L{AuiFloatingFrame}. :param `event`: a `wx.MoveEvent` to be processed. :note: This event is not processed on wxMAC or if L{AuiManager} is not using the ``AUI_MGR_USE_NATIVE_MINIFRAMES`` style. """ if self._owner_mgr: self._owner_mgr.OnFloatingPaneMoved(self._pane_window, event)
[docs] def OnMoveEvent(self, event): """ Handles the ``wx.EVT_MOVE`` and ``wx.EVT_MOVING`` events for L{AuiFloatingFrame}. :param `event`: a `wx.MoveEvent` to be processed. :note: This event is only processed on wxMAC or if L{AuiManager} is using the ``AUI_MGR_USE_NATIVE_MINIFRAMES`` style. """ win_rect = self.GetRect() if win_rect == self._last_rect: return # skip the first move event if self._last_rect.IsEmpty(): self._last_rect = wx.Rect(*win_rect) return # skip if moving too fast to avoid massive redraws and # jumping hint windows if abs(win_rect.x - self._last_rect.x) > 3 or abs(win_rect.y - self._last_rect.y) > 3: self._last3_rect = wx.Rect(*self._last2_rect) self._last2_rect = wx.Rect(*self._last_rect) self._last_rect = wx.Rect(*win_rect) return # prevent frame redocking during resize if self._last_rect.GetSize() != win_rect.GetSize(): self._last3_rect = wx.Rect(*self._last2_rect) self._last2_rect = wx.Rect(*self._last_rect) self._last_rect = wx.Rect(*win_rect) return self._last3_rect = wx.Rect(*self._last2_rect) self._last2_rect = wx.Rect(*self._last_rect) self._last_rect = wx.Rect(*win_rect) if _VERSION_STRING < "2.9": leftDown = wx.GetMouseState().LeftDown() else: leftDown = wx.GetMouseState().LeftIsDown() if not leftDown: return if not self._moving: self.OnMoveStart(event) self._moving = True if self._last3_rect.IsEmpty(): return self.OnMoving(event)
[docs] def OnIdle(self, event): """ Handles the ``wx.EVT_IDLE`` event for L{AuiFloatingFrame}. :param `event`: a `wx.IdleEvent` event to be processed. :note: This event is only processed on wxMAC or if L{AuiManager} is using the ``AUI_MGR_USE_NATIVE_MINIFRAMES`` style. """ if self._moving: if _VERSION_STRING < "2.9": leftDown = wx.GetMouseState().LeftDown() else: leftDown = wx.GetMouseState().LeftIsDown() if not leftDown: self._moving = False self.OnMoveFinished() else: event.RequestMore()
[docs] def OnMoveStart(self, event): """ The user has just started moving the floating pane. :param `event`: an instance of `wx.MouseEvent`. :note: This method is used only on wxMAC or if L{AuiManager} is using the ``AUI_MGR_USE_NATIVE_MINIFRAMES`` style. """ # notify the owner manager that the pane has started to move if self._owner_mgr: if self._owner_mgr._from_move: return self._owner_mgr._action_window = self._pane_window point = wx.GetMousePosition() action_offset = point - self.GetPosition() if self._is_toolbar: self._owner_mgr._toolbar_action_offset = action_offset self._owner_mgr.OnMotion_DragToolbarPane(point) else: self._owner_mgr._action_offset = action_offset self._owner_mgr.OnMotion_DragFloatingPane(point)
[docs] def OnMoving(self, event): """ The user is moving the floating pane. :param `event`: an instance of `wx.MouseEvent`. :note: This method is used only on wxMAC or if L{AuiManager} is using the ``AUI_MGR_USE_NATIVE_MINIFRAMES`` style. """ # notify the owner manager that the pane is moving self.OnMoveStart(event)
[docs] def OnMoveFinished(self): """ The user has just finished moving the floating pane. :note: This method is used only on wxMAC or if L{AuiManager} is using the ``AUI_MGR_USE_NATIVE_MINIFRAMES`` style. """ # notify the owner manager that the pane has finished moving if self._owner_mgr: self._owner_mgr._action_window = self._pane_window point = wx.GetMousePosition() if self._is_toolbar: self._owner_mgr.OnLeftUp_DragToolbarPane(point) else: self._owner_mgr.OnLeftUp_DragFloatingPane(point) self._owner_mgr.OnFloatingPaneMoved(self._pane_window, point)
[docs] def OnCheckFlyTimer(self, event): """ Handles the ``wx.EVT_TIMER`` event for L{AuiFloatingFrame}. :param `event`: a `wx.TimerEvent` to be processed. :note: This is used solely for "fly-out" panes. """ if self._owner_mgr: pane = self._mgr.GetPane(self._pane_window) if pane.IsFlyOut(): if self.IsShownOnScreen(): self.FlyOut()
[docs] def OnFindManager(self, event): """ Handles the ``EVT_AUI_FIND_MANAGER`` event for L{AuiFloatingFrame}. :param `event`: a L{AuiManagerEvent} event to be processed. """ event.SetManager(self._owner_mgr)
[docs] def FlyOut(self): """ Starts the flying in and out of a floating pane. """ if self._fly_timer.IsRunning(): return if _VERSION_STRING < "2.9": leftDown = wx.GetMouseState().LeftDown() else: leftDown = wx.GetMouseState().LeftIsDown() if leftDown: return rect = wx.Rect(*self.GetScreenRect()) rect.Inflate(10, 10) if rect.Contains(wx.GetMousePosition()): if not self._fly: return self._send_size = False self._fly_timer.Start(5) else: if self._fly: return self._send_size = False self._fly_timer.Start(5)
[docs] def OnFlyTimer(self, event): """ Handles the ``wx.EVT_TIMER`` event for L{AuiFloatingFrame}. :param `event`: a `wx.TimerEvent` to be processed. """ current_size = self.GetClientSize() floating_size = wx.Size(*self._owner_mgr.GetPane(self._pane_window).floating_size) if floating_size.y == -1: floating_size = self._floating_size if not self._fly: min_size = self._mgr.GetArtProvider().GetMetric(AUI_DOCKART_CAPTION_SIZE) if wx.Platform != "__WXMSW__": min_size += 2*wx.SystemSettings.GetMetric(wx.SYS_EDGE_Y) if current_size.y - self._fly_step <= min_size: self.SetClientSize((current_size.x, min_size)) self._fly = True self._fly_timer.Stop() self._send_size = True else: self.SetClientSize((current_size.x, current_size.y-self._fly_step)) else: if current_size.y + self._fly_step >= floating_size.y: self.SetClientSize((current_size.x, floating_size.y)) self._fly = False self._fly_timer.Stop() self._send_size = True else: self.SetClientSize((current_size.x, current_size.y+self._fly_step)) self.Update() self.Refresh()
[docs] def FadeOut(self): """ Actually starts the fading out of the floating pane. """ while 1: self._alpha_amount -= 10 if self._alpha_amount <= 0: self._alpha_amount = 255 return self.SetTransparent(self._alpha_amount) wx.SafeYield() wx.MilliSleep(15) # -- static utility functions --
[docs]def DrawResizeHint(dc, rect): """ Draws a resize hint while a sash is dragged. :param `rect`: a `wx.Rect` rectangle which specifies the sash dimensions. """ if wx.Platform == "__WXMSW__" and wx.App.GetComCtl32Version() >= 600: if wx.GetOsVersion()[1] > 5: # Windows Vista dc.SetPen(wx.Pen("black", 2, wx.SOLID)) dc.SetBrush(wx.TRANSPARENT_BRUSH) else: # Draw the nice XP style splitter dc.SetPen(wx.TRANSPARENT_PEN) dc.SetBrush(wx.BLACK_BRUSH) dc.SetLogicalFunction(wx.INVERT) dc.DrawRectangleRect(rect) dc.SetLogicalFunction(wx.COPY) else: stipple = PaneCreateStippleBitmap() brush = wx.BrushFromBitmap(stipple) dc.SetBrush(brush) dc.SetPen(wx.TRANSPARENT_PEN) dc.SetLogicalFunction(wx.XOR) dc.DrawRectangleRect(rect)
[docs]def CopyDocksAndPanes(src_docks, src_panes): """ This utility function creates shallow copies of the dock and pane info. L{AuiDockInfo} usually contain pointers to L{AuiPaneInfo} classes, thus this function is necessary to reliably reconstruct that relationship in the new dock info and pane info arrays. :param `src_docks`: a list of L{AuiDockInfo} classes; :param `src_panes`: a list of L{AuiPaneInfo} classes. """ dest_docks = src_docks dest_panes = src_panes for ii in xrange(len(dest_docks)): dock = dest_docks[ii] for jj in xrange(len(dock.panes)): for kk in xrange(len(src_panes)): if dock.panes[jj] == src_panes[kk]: dock.panes[jj] = dest_panes[kk] return dest_docks, dest_panes
[docs]def CopyDocksAndPanes2(src_docks, src_panes): """ This utility function creates full copies of the dock and pane info. L{AuiDockInfo} usually contain pointers to L{AuiPaneInfo} classes, thus this function is necessary to reliably reconstruct that relationship in the new dock info and pane info arrays. :param `src_docks`: a list of L{AuiDockInfo} classes; :param `src_panes`: a list of L{AuiPaneInfo} classes. """ dest_docks = [] for ii in xrange(len(src_docks)): dest_docks.append(AuiDockInfo()) dest_docks[ii].dock_direction = src_docks[ii].dock_direction dest_docks[ii].dock_layer = src_docks[ii].dock_layer dest_docks[ii].dock_row = src_docks[ii].dock_row dest_docks[ii].size = src_docks[ii].size dest_docks[ii].min_size = src_docks[ii].min_size dest_docks[ii].resizable = src_docks[ii].resizable dest_docks[ii].fixed = src_docks[ii].fixed dest_docks[ii].toolbar = src_docks[ii].toolbar dest_docks[ii].panes = src_docks[ii].panes dest_docks[ii].rect = wx.Rect(*src_docks[ii].rect) dest_panes = [] for ii in xrange(len(src_panes)): dest_panes.append(AuiPaneInfo()) dest_panes[ii].name = src_panes[ii].name dest_panes[ii].caption = src_panes[ii].caption dest_panes[ii].window = src_panes[ii].window dest_panes[ii].frame = src_panes[ii].frame dest_panes[ii].state = src_panes[ii].state dest_panes[ii].dock_direction = src_panes[ii].dock_direction dest_panes[ii].dock_layer = src_panes[ii].dock_layer dest_panes[ii].dock_row = src_panes[ii].dock_row dest_panes[ii].dock_pos = src_panes[ii].dock_pos dest_panes[ii].best_size = wx.Size(*src_panes[ii].best_size) dest_panes[ii].min_size = wx.Size(*src_panes[ii].min_size) dest_panes[ii].max_size = wx.Size(*src_panes[ii].max_size) dest_panes[ii].floating_pos = wx.Point(*src_panes[ii].floating_pos) dest_panes[ii].floating_size = wx.Size(*src_panes[ii].floating_size) dest_panes[ii].dock_proportion = src_panes[ii].dock_proportion dest_panes[ii].buttons = src_panes[ii].buttons dest_panes[ii].rect = wx.Rect(*src_panes[ii].rect) dest_panes[ii].icon = src_panes[ii].icon dest_panes[ii].notebook_id = src_panes[ii].notebook_id dest_panes[ii].transparent = src_panes[ii].transparent dest_panes[ii].snapped = src_panes[ii].snapped dest_panes[ii].minimize_mode = src_panes[ii].minimize_mode dest_panes[ii].minimize_target = src_panes[ii].minimize_target for ii in xrange(len(dest_docks)): dock = dest_docks[ii] for jj in xrange(len(dock.panes)): for kk in xrange(len(src_panes)): if dock.panes[jj] == src_panes[kk]: dock.panes[jj] = dest_panes[kk] dest_docks[ii] = dock return dest_docks, dest_panes
[docs]def GetMaxLayer(docks, dock_direction): """ This is an internal function which returns the highest layer inside the specified dock. :param `docks`: a list of L{AuiDockInfo}; :param `dock_direction`: the L{AuiDockInfo} docking direction to analyze. """ max_layer = 0 for dock in docks: if dock.dock_direction == dock_direction and dock.dock_layer > max_layer and not dock.fixed: max_layer = dock.dock_layer return max_layer
[docs]def GetMaxRow(panes, dock_direction, dock_layer): """ This is an internal function which returns the highest layer inside the specified dock. :param `panes`: a list of L{AuiPaneInfo}; :param `dock_direction`: the L{AuiPaneInfo} docking direction to analyze; :param `dock_layer`: the L{AuiPaneInfo} layer to analyze. """ max_row = 0 for pane in panes: if pane.dock_direction == dock_direction and pane.dock_layer == dock_layer and \ pane.dock_row > max_row: max_row = pane.dock_row return max_row
[docs]def DoInsertDockLayer(panes, dock_direction, dock_layer): """ This is an internal function that inserts a new dock layer by incrementing all existing dock layer values by one. :param `panes`: a list of L{AuiPaneInfo}; :param `dock_direction`: the L{AuiPaneInfo} docking direction to analyze; :param `dock_layer`: the L{AuiPaneInfo} layer to analyze. """ for ii in xrange(len(panes)): pane = panes[ii] if not pane.IsFloating() and pane.dock_direction == dock_direction and pane.dock_layer >= dock_layer: pane.dock_layer = pane.dock_layer + 1 panes[ii] = pane return panes
[docs]def DoInsertDockRow(panes, dock_direction, dock_layer, dock_row): """ This is an internal function that inserts a new dock row by incrementing all existing dock row values by one. :param `panes`: a list of L{AuiPaneInfo}; :param `dock_direction`: the L{AuiPaneInfo} docking direction to analyze; :param `dock_layer`: the L{AuiPaneInfo} layer to analyze; :param `dock_row`: the L{AuiPaneInfo} row to analyze. """ for pane in panes: if not pane.IsFloating() and pane.dock_direction == dock_direction and \ pane.dock_layer == dock_layer and pane.dock_row >= dock_row: pane.dock_row += 1 return panes
[docs]def DoInsertPane(panes, dock_direction, dock_layer, dock_row, dock_pos): """ This is an internal function that inserts a new pane by incrementing all existing dock position values by one. :param `panes`: a list of L{AuiPaneInfo}; :param `dock_direction`: the L{AuiPaneInfo} docking direction to analyze; :param `dock_layer`: the L{AuiPaneInfo} layer to analyze; :param `dock_row`: the L{AuiPaneInfo} row to analyze; :param `dock_pos`: the L{AuiPaneInfo} row to analyze. """ for ii in xrange(len(panes)): pane = panes[ii] if not pane.IsFloating() and pane.dock_direction == dock_direction and \ pane.dock_layer == dock_layer and pane.dock_row == dock_row and \ pane.dock_pos >= dock_pos: pane.dock_pos = pane.dock_pos + 1 panes[ii] = pane return panes
[docs]def FindDocks(docks, dock_direction, dock_layer=-1, dock_row=-1, reverse=False): """ This is an internal function that returns a list of docks which meet the specified conditions in the parameters and returns a sorted array (sorted by layer and then row). :param `docks`: a list of L{AuiDockInfo}; :param `dock_direction`: the L{AuiDockInfo} docking direction to analyze; :param `dock_layer`: the L{AuiDockInfo} layer to analyze; :param `dock_row`: the L{AuiDockInfo} row to analyze; """ matchDocks = [(d.dock_layer, d.dock_row, d.dock_direction, d) for d in docks if \ (dock_direction == -1 or dock_direction == d.dock_direction) and \ ((dock_layer == -1 or dock_layer == d.dock_layer) and \ (dock_row == -1 or dock_row == d.dock_row))] arr = [x[-1] for x in sorted(matchDocks, reverse=reverse)] return arr
[docs]def FindOppositeDocks(docks, dock_direction): """ This is an internal function that returns a list of docks which is related to the opposite direction. :param `docks`: a list of L{AuiDockInfo}; :param `dock_direction`: the L{AuiDockInfo} docking direction to analyze; """ if dock_direction == AUI_DOCK_LEFT: arr = FindDocks(docks, AUI_DOCK_RIGHT, -1, -1) elif dock_direction == AUI_DOCK_TOP: arr = FindDocks(docks, AUI_DOCK_BOTTOM, -1, -1) elif dock_direction == AUI_DOCK_RIGHT: arr = FindDocks(docks, AUI_DOCK_LEFT, -1, -1) elif dock_direction == AUI_DOCK_BOTTOM: arr = FindDocks(docks, AUI_DOCK_TOP, -1, -1) return arr
[docs]def FindPaneInDock(dock, window): """ This method looks up a specified window pointer inside a dock. If found, the corresponding L{AuiPaneInfo} pointer is returned, otherwise ``None``. :param `dock`: a L{AuiDockInfo} structure; :param `window`: a `wx.Window` derived window (associated to a pane). """ for p in dock.panes: if p.window == window: return p return None
[docs]def GetToolBarDockOffsets(docks): """ Returns the toolbar dock offsets (top-left and bottom-right). :param `docks`: a list of L{AuiDockInfo} to analyze. """ top_left = wx.Size(0, 0) bottom_right = wx.Size(0, 0) for dock in docks: if dock.toolbar: dock_direction = dock.dock_direction if dock_direction == AUI_DOCK_LEFT: top_left.x += dock.rect.width bottom_right.x += dock.rect.width elif dock_direction == AUI_DOCK_TOP: top_left.y += dock.rect.height bottom_right.y += dock.rect.height elif dock_direction == AUI_DOCK_RIGHT: bottom_right.x += dock.rect.width elif dock_direction == AUI_DOCK_BOTTOM: bottom_right.y += dock.rect.height return top_left, bottom_right
[docs]def GetInternalFrameRect(window, docks): """ Returns the window rectangle excluding toolbars. :param `window`: a `wx.Window` derived window; :param `docks`: a list of L{AuiDockInfo} structures. """ frameRect = wx.Rect() frameRect.SetTopLeft(window.ClientToScreen(window.GetClientAreaOrigin())) frameRect.SetSize(window.GetClientSize()) top_left, bottom_right = GetToolBarDockOffsets(docks) # make adjustments for toolbars frameRect.x += top_left.x frameRect.y += top_left.y frameRect.width -= bottom_right.x frameRect.height -= bottom_right.y return frameRect
[docs]def CheckOutOfWindow(window, pt): """ Checks if a point is outside the window rectangle. :param `window`: a `wx.Window` derived window; :param `pt`: a `wx.Point` object. """ auiWindowMargin = 30 marginRect = wx.Rect(*window.GetClientRect()) marginRect.Inflate(auiWindowMargin, auiWindowMargin) return not marginRect.Contains(pt)
[docs]def CheckEdgeDrop(window, docks, pt): """ Checks on which edge of a window the drop action has taken place. :param `window`: a `wx.Window` derived window; :param `docks`: a list of L{AuiDockInfo} structures; :param `pt`: a `wx.Point` object. """ screenPt = window.ClientToScreen(pt) clientSize = window.GetClientSize() frameRect = GetInternalFrameRect(window, docks) if screenPt.y >= frameRect.GetTop() and screenPt.y < frameRect.GetBottom(): if pt.x < auiLayerInsertOffset and pt.x > auiLayerInsertOffset - auiLayerInsertPixels: return wx.LEFT if pt.x >= clientSize.x - auiLayerInsertOffset and \ pt.x < clientSize.x - auiLayerInsertOffset + auiLayerInsertPixels: return wx.RIGHT if screenPt.x >= frameRect.GetLeft() and screenPt.x < frameRect.GetRight(): if pt.y < auiLayerInsertOffset and pt.y > auiLayerInsertOffset - auiLayerInsertPixels: return wx.TOP if pt.y >= clientSize.y - auiLayerInsertOffset and \ pt.y < clientSize.y - auiLayerInsertOffset + auiLayerInsertPixels: return wx.BOTTOM return -1
[docs]def RemovePaneFromDocks(docks, pane, exc=None): """ Removes a pane window from all docks with a possible exception specified by parameter `exc`. :param `docks`: a list of L{AuiDockInfo} structures; :param `pane`: the L{AuiPaneInfo} pane to be removed; :param `exc`: the possible pane exception. """ for ii in xrange(len(docks)): d = docks[ii] if d == exc: continue pi = FindPaneInDock(d, pane.window) if pi: d.panes.remove(pi) docks[ii] = d return docks
[docs]def RenumberDockRows(docks): """ Takes a dock and assigns sequential numbers to existing rows. Basically it takes out the gaps so if a dock has rows with numbers 0, 2, 5, they will become 0, 1, 2. :param `docks`: a list of L{AuiDockInfo} structures. """ for ii in xrange(len(docks)): dock = docks[ii] dock.dock_row = ii for jj in xrange(len(dock.panes)): dock.panes[jj].dock_row = ii docks[ii] = dock return docks
[docs]def SetActivePane(panes, active_pane): """ Sets the active pane, as well as cycles through every other pane and makes sure that all others' active flags are turned off. :param `panes`: a list of L{AuiPaneInfo} structures; :param `active_pane`: the pane to be made active (if found). """ for pane in panes: pane.state &= ~AuiPaneInfo.optionActive for pane in panes: if pane.window == active_pane and not pane.IsNotebookPage(): pane.state |= AuiPaneInfo.optionActive return True, panes return False, panes
[docs]def ShowDockingGuides(guides, show): """ Shows or hide the docking guide windows. :param `guides`: a list of L{AuiDockingGuideInfo} classes; :param `show`: whether to show or hide the docking guide windows. """ for target in guides: if show and not target.host.IsShown(): target.host.Show() target.host.Update() elif not show and target.host.IsShown(): target.host.Hide()
[docs]def RefreshDockingGuides(guides): """ Refreshes the docking guide windows. :param `guides`: a list of L{AuiDockingGuideInfo} classes; """ for target in guides: if target.host.IsShown(): target.host.Refresh()
[docs]def PaneSortFunc(p1, p2): """ This function is used to sort panes by dock position. :param `p1`: a L{AuiPaneInfo} instance; :param `p2`: another L{AuiPaneInfo} instance. """ return (p1.dock_pos < p2.dock_pos and [-1] or [1])[0]
[docs]def GetNotebookRoot(panes, notebook_id): """ Returns the L{AuiPaneInfo} which has the specified `notebook_id`. :param `panes`: a list of L{AuiPaneInfo} instances; :param `notebook_id`: the target notebook id. """ for paneInfo in panes: if paneInfo.IsNotebookControl() and paneInfo.notebook_id == notebook_id: return paneInfo return None
[docs]def EscapeDelimiters(s): """ Changes ``;`` into ``\`` and ``|`` into ``\|`` in the input string. :param `s`: the string to be analyzed. :note: This is an internal functions which is used for saving perspectives. """ result = s.replace(";", "\\") result = result.replace("|", "|\\") return result
[docs]def IsDifferentDockingPosition(pane1, pane2): """ Returns whether `pane1` and `pane2` are in a different docking position based on pane status, docking direction, docking layer and docking row. :param `pane1`: a L{AuiPaneInfo} instance; :param `pane2`: another L{AuiPaneInfo} instance. """ return pane1.IsFloating() != pane2.IsFloating() or \ pane1.dock_direction != pane2.dock_direction or \ pane1.dock_layer != pane2.dock_layer or \ pane1.dock_row != pane2.dock_row # Convenience function
[docs]def AuiManager_HasLiveResize(manager): """ Static function which returns if the input `manager` should have "live resize" behaviour. :param `manager`: an instance of L{AuiManager}. :note: This method always returns ``True`` on wxMac as this platform doesn't have the ability to use `wx.ScreenDC` to draw sashes. """ # With Core Graphics on Mac, it's not possible to show sash feedback, # so we'll always use live update instead. if wx.Platform == "__WXMAC__": return True else: return (manager.GetAGWFlags() & AUI_MGR_LIVE_RESIZE) == AUI_MGR_LIVE_RESIZE # Convenience function
[docs]def AuiManager_UseNativeMiniframes(manager): """ Static function which returns if the input `manager` should use native `wx.MiniFrame` as floating panes. :param `manager`: an instance of L{AuiManager}. :note: This method always returns ``True`` on wxMac as this platform doesn't have the ability to use custom drawn miniframes. """ # With Core Graphics on Mac, it's not possible to show sash feedback, # so we'll always use live update instead. if wx.Platform == "__WXMAC__": return True else: return (manager.GetAGWFlags() & AUI_MGR_USE_NATIVE_MINIFRAMES) == AUI_MGR_USE_NATIVE_MINIFRAMES
[docs]def GetManager(window): """ This function will return the aui manager for a given window. :param `window`: this parameter should be any child window or grand-child window (and so on) of the frame/window managed by L{AuiManager}. The window does not need to be managed by the manager itself, nor does it even need to be a child or sub-child of a managed window. It must however be inside the window hierarchy underneath the managed window. """ if not isinstance(wx.GetTopLevelParent(window), AuiFloatingFrame): if isinstance(window, auibar.AuiToolBar): return window.GetAuiManager() evt = AuiManagerEvent(wxEVT_AUI_FIND_MANAGER) evt.SetManager(None) evt.ResumePropagation(wx.EVENT_PROPAGATE_MAX) if not window.GetEventHandler().ProcessEvent(evt): return None return evt.GetManager() # ---------------------------------------------------------------------------- #
[docs]class AuiManager(wx.EvtHandler): """ AuiManager manages the panes associated with it for a particular `wx.Frame`, using a pane's L{AuiPaneInfo} information to determine each pane's docking and floating behavior. L{AuiManager} uses wxPython's sizer mechanism to plan the layout of each frame. It uses a replaceable dock art class to do all drawing, so all drawing is localized in one area, and may be customized depending on an applications' specific needs. L{AuiManager} works as follows: the programmer adds panes to the class, or makes changes to existing pane properties (dock position, floating state, show state, etc...). To apply these changes, the L{AuiManager.Update} function is called. This batch processing can be used to avoid flicker, by modifying more than one pane at a time, and then "committing" all of the changes at once by calling `Update()`. Panes can be added quite easily:: text1 = wx.TextCtrl(self, -1) text2 = wx.TextCtrl(self, -1) self._mgr.AddPane(text1, AuiPaneInfo().Left().Caption("Pane Number One")) self._mgr.AddPane(text2, AuiPaneInfo().Bottom().Caption("Pane Number Two")) self._mgr.Update() Later on, the positions can be modified easily. The following will float an existing pane in a tool window:: self._mgr.GetPane(text1).Float() **Layers, Rows and Directions, Positions:** Inside AUI, the docking layout is figured out by checking several pane parameters. Four of these are important for determining where a pane will end up. **Direction** - Each docked pane has a direction, `Top`, `Bottom`, `Left`, `Right`, or `Center`. This is fairly self-explanatory. The pane will be placed in the location specified by this variable. **Position** - More than one pane can be placed inside of a "dock". Imagine two panes being docked on the left side of a window. One pane can be placed over another. In proportionally managed docks, the pane position indicates it's sequential position, starting with zero. So, in our scenario with two panes docked on the left side, the top pane in the dock would have position 0, and the second one would occupy position 1. **Row** - A row can allow for two docks to be placed next to each other. One of the most common places for this to happen is in the toolbar. Multiple toolbar rows are allowed, the first row being in row 0, and the second in row 1. Rows can also be used on vertically docked panes. **Layer** - A layer is akin to an onion. Layer 0 is the very center of the managed pane. Thus, if a pane is in layer 0, it will be closest to the center window (also sometimes known as the "content window"). Increasing layers "swallow up" all layers of a lower value. This can look very similar to multiple rows, but is different because all panes in a lower level yield to panes in higher levels. The best way to understand layers is by running the AUI sample (`AUI.py`). """
[docs] def __init__(self, managed_window=None, agwFlags=None): """ Default class constructor. :param `managed_window`: specifies the window which should be managed; :param `agwFlags`: specifies options which allow the frame management behavior to be modified. `agwFlags` can be a combination of the following style bits: ==================================== ================================== Flag name Description ==================================== ================================== ``AUI_MGR_ALLOW_FLOATING`` Allow floating of panes ``AUI_MGR_ALLOW_ACTIVE_PANE`` If a pane becomes active, "highlight" it in the interface ``AUI_MGR_TRANSPARENT_DRAG`` If the platform supports it, set transparency on a floating pane while it is dragged by the user ``AUI_MGR_TRANSPARENT_HINT`` If the platform supports it, show a transparent hint window when the user is about to dock a floating pane ``AUI_MGR_VENETIAN_BLINDS_HINT`` Show a "venetian blind" effect when the user is about to dock a floating pane ``AUI_MGR_RECTANGLE_HINT`` Show a rectangle hint effect when the user is about to dock a floating pane ``AUI_MGR_HINT_FADE`` If the platform supports it, the hint window will fade in and out ``AUI_MGR_NO_VENETIAN_BLINDS_FADE`` Disables the "venetian blind" fade in and out ``AUI_MGR_LIVE_RESIZE`` Live resize when the user drag a sash ``AUI_MGR_ANIMATE_FRAMES`` Fade-out floating panes when they are closed (all platforms which support frames transparency) and show a moving rectangle when they are docked (Windows < Vista and GTK only) ``AUI_MGR_AERO_DOCKING_GUIDES`` Use the new Aero-style bitmaps as docking guides ``AUI_MGR_PREVIEW_MINIMIZED_PANES`` Slide in and out minimized panes to preview them ``AUI_MGR_WHIDBEY_DOCKING_GUIDES`` Use the new Whidbey-style bitmaps as docking guides ``AUI_MGR_SMOOTH_DOCKING`` Performs a "smooth" docking of panes (a la PyQT) ``AUI_MGR_USE_NATIVE_MINIFRAMES`` Use miniframes with native caption bar as floating panes instead or custom drawn caption bars (forced on wxMac) ``AUI_MGR_AUTONB_NO_CAPTION`` Panes that merge into an automatic notebook will not have the pane caption visible ==================================== ================================== Default value for `agwFlags` is: ``AUI_MGR_DEFAULT`` = ``AUI_MGR_ALLOW_FLOATING`` | ``AUI_MGR_TRANSPARENT_HINT`` | ``AUI_MGR_HINT_FADE`` | ``AUI_MGR_NO_VENETIAN_BLINDS_FADE`` :note: If using the ``AUI_MGR_USE_NATIVE_MINIFRAMES``, double-clicking on a floating pane caption will not re-dock the pane, but simply maximize it (if L{AuiPaneInfo.MaximizeButton} has been set to ``True``) or do nothing. """ wx.EvtHandler.__init__(self) self._action = actionNone self._action_window = None self._hover_button = None self._art = dockart.AuiDefaultDockArt() self._hint_window = None self._active_pane = None self._has_maximized = False self._has_minimized = False self._frame = None self._dock_constraint_x = 0.3 self._dock_constraint_y = 0.3 self._reserved = None self._panes = [] self._docks = [] self._uiparts = [] self._guides = [] self._notebooks = [] self._masterManager = None self._currentDragItem = -1 self._lastknowndocks = {} self._hint_fadetimer = wx.Timer(self, wx.ID_ANY) self._hint_fademax = 50 self._last_hint = wx.Rect() self._from_move = False self._last_rect = wx.Rect() if agwFlags is None: agwFlags = AUI_MGR_DEFAULT self._agwFlags = agwFlags self._is_docked = (False, wx.RIGHT, wx.TOP, 0) self._snap_limits = (15, 15) if wx.Platform == "__WXMSW__": self._animation_step = 30.0 else: self._animation_step = 5.0 self._hint_rect = wx.Rect() self._preview_timer = wx.Timer(self, wx.ID_ANY) self._sliding_frame = None self._autoNBTabArt = tabart.AuiDefaultTabArt() self._autoNBStyle = AUI_NB_DEFAULT_STYLE | AUI_NB_BOTTOM | \ AUI_NB_SUB_NOTEBOOK | AUI_NB_TAB_EXTERNAL_MOVE self._autoNBStyle -= AUI_NB_DRAW_DND_TAB if managed_window: self.SetManagedWindow(managed_window) self.Bind(wx.EVT_PAINT, self.OnPaint) self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground) self.Bind(wx.EVT_SIZE, self.OnSize) self.Bind(wx.EVT_SET_CURSOR, self.OnSetCursor) self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown) self.Bind(wx.EVT_LEFT_DCLICK, self.OnLeftDClick) self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp) self.Bind(wx.EVT_MOTION, self.OnMotion) self.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeaveWindow) self.Bind(wx.EVT_CHILD_FOCUS, self.OnChildFocus) self.Bind(wx.EVT_MOUSE_CAPTURE_LOST, self.OnCaptureLost) self.Bind(wx.EVT_TIMER, self.OnHintFadeTimer, self._hint_fadetimer) self.Bind(wx.EVT_TIMER, self.SlideIn, self._preview_timer) self.Bind(wx.EVT_MOVE, self.OnMove) self.Bind(wx.EVT_SYS_COLOUR_CHANGED, self.OnSysColourChanged) self.Bind(EVT_AUI_PANE_BUTTON, self.OnPaneButton) self.Bind(EVT_AUI_RENDER, self.OnRender) self.Bind(EVT_AUI_FIND_MANAGER, self.OnFindManager) self.Bind(EVT_AUI_PANE_MIN_RESTORE, self.OnRestoreMinimizedPane) self.Bind(EVT_AUI_PANE_DOCKED, self.OnPaneDocked) self.Bind(auibook.EVT_AUINOTEBOOK_BEGIN_DRAG, self.OnTabBeginDrag) self.Bind(auibook.EVT_AUINOTEBOOK_PAGE_CLOSE, self.OnTabPageClose) self.Bind(auibook.EVT_AUINOTEBOOK_PAGE_CHANGED, self.OnTabSelected)
[docs] def CreateFloatingFrame(self, parent, pane_info): """ Creates a floating frame for the windows. :param `parent`: the floating frame parent; :param `pane_info`: the L{AuiPaneInfo} class with all the pane's information. """ return AuiFloatingFrame(parent, self, pane_info)
[docs] def CanDockPanel(self, p): """ Returns whether a pane can be docked or not. :param `p`: the L{AuiPaneInfo} class with all the pane's information. """ # is the pane dockable? if not p.IsDockable(): return False # if a key modifier is pressed while dragging the frame, # don't dock the window return not (wx.GetKeyState(wx.WXK_CONTROL) or wx.GetKeyState(wx.WXK_ALT))
[docs] def GetPaneByWidget(self, window): """ This version of L{GetPane} looks up a pane based on a 'pane window'. :param `window`: a `wx.Window` derived window. :see: L{GetPane} """ for p in self._panes: if p.window == window: return p return NonePaneInfo
[docs] def GetPaneByName(self, name): """ This version of L{GetPane} looks up a pane based on a 'pane name'. :param `name`: the pane name. :see: L{GetPane} """ for p in self._panes: if p.name == name: return p return NonePaneInfo
[docs] def GetPane(self, item): """ Looks up a L{AuiPaneInfo} structure based on the supplied window pointer. Upon failure, L{GetPane} returns an empty L{AuiPaneInfo}, a condition which can be checked by calling L{AuiPaneInfo.IsOk}. The pane info's structure may then be modified. Once a pane's info is modified, L{Update} must be called to realize the changes in the UI. :param `item`: either a pane name or a `wx.Window`. """ if isinstance(item, basestring): return self.GetPaneByName(item) else: return self.GetPaneByWidget(item)
[docs] def GetAllPanes(self): """ Returns a reference to all the pane info structures. """ return self._panes
[docs] def ShowPane(self, window, show): """ Shows or hides a pane based on the window passed as input. :param `window`: a `wx.Window` derived window; :param `show`: ``True`` to show the pane, ``False`` otherwise. """ p = self.GetPane(window) if p.IsOk(): if p.IsNotebookPage(): if show: notebook = self._notebooks[p.notebook_id] id = notebook.GetPageIndex(p.window) if id >= 0: notebook.SetSelection(id) self.ShowPane(notebook, True) else: p.Show(show) if p.frame: p.frame.Raise() self.Update()
[docs] def HitTest(self, x, y): """ This is an internal function which determines which UI item the specified coordinates are over. :param `x`: specifies a x position in client coordinates; :param `y`: specifies a y position in client coordinates. """ result = None for item in self._uiparts: # we are not interested in typeDock, because this space # isn't used to draw anything, just for measurements # besides, the entire dock area is covered with other # rectangles, which we are interested in. if item.type == AuiDockUIPart.typeDock: continue # if we already have a hit on a more specific item, we are not # interested in a pane hit. If, however, we don't already have # a hit, returning a pane hit is necessary for some operations if item.type in [AuiDockUIPart.typePane, AuiDockUIPart.typePaneBorder] and result: continue # if the point is inside the rectangle, we have a hit if item.rect.Contains((x, y)): result = item return result
[docs] def PaneHitTest(self, panes, pt): """ Similar to L{HitTest}, but it checks in which L{AuiPaneInfo} rectangle the input point belongs to. :param `panes`: a list of L{AuiPaneInfo} instances; :param `pt`: a `wx.Point` object. """ for paneInfo in panes: if paneInfo.IsDocked() and paneInfo.IsShown() and paneInfo.rect.Contains(pt): return paneInfo return NonePaneInfo # SetAGWFlags() and GetAGWFlags() allow the owner to set various # options which are global to AuiManager
[docs] def SetAGWFlags(self, agwFlags): """ This method is used to specify L{AuiManager}'s settings flags. :param `agwFlags`: specifies options which allow the frame management behavior to be modified. `agwFlags` can be one of the following style bits: ==================================== ================================== Flag name Description ==================================== ================================== ``AUI_MGR_ALLOW_FLOATING`` Allow floating of panes ``AUI_MGR_ALLOW_ACTIVE_PANE`` If a pane becomes active, "highlight" it in the interface ``AUI_MGR_TRANSPARENT_DRAG`` If the platform supports it, set transparency on a floating pane while it is dragged by the user ``AUI_MGR_TRANSPARENT_HINT`` If the platform supports it, show a transparent hint window when the user is about to dock a floating pane ``AUI_MGR_VENETIAN_BLINDS_HINT`` Show a "venetian blind" effect when the user is about to dock a floating pane ``AUI_MGR_RECTANGLE_HINT`` Show a rectangle hint effect when the user is about to dock a floating pane ``AUI_MGR_HINT_FADE`` If the platform supports it, the hint window will fade in and out ``AUI_MGR_NO_VENETIAN_BLINDS_FADE`` Disables the "venetian blind" fade in and out ``AUI_MGR_LIVE_RESIZE`` Live resize when the user drag a sash ``AUI_MGR_ANIMATE_FRAMES`` Fade-out floating panes when they are closed (all platforms which support frames transparency) and show a moving rectangle when they are docked (Windows < Vista and GTK only) ``AUI_MGR_AERO_DOCKING_GUIDES`` Use the new Aero-style bitmaps as docking guides ``AUI_MGR_PREVIEW_MINIMIZED_PANES`` Slide in and out minimized panes to preview them ``AUI_MGR_WHIDBEY_DOCKING_GUIDES`` Use the new Whidbey-style bitmaps as docking guides ``AUI_MGR_SMOOTH_DOCKING`` Performs a "smooth" docking of panes (a la PyQT) ``AUI_MGR_USE_NATIVE_MINIFRAMES`` Use miniframes with native caption bar as floating panes instead or custom drawn caption bars (forced on wxMac) ``AUI_MGR_AUTONB_NO_CAPTION`` Panes that merge into an automatic notebook will not have the pane caption visible ==================================== ================================== :note: If using the ``AUI_MGR_USE_NATIVE_MINIFRAMES``, double-clicking on a floating pane caption will not re-dock the pane, but simply maximize it (if L{AuiPaneInfo.MaximizeButton} has been set to ``True``) or do nothing. """ self._agwFlags = agwFlags if len(self._guides) > 0: self.CreateGuideWindows() if self._hint_window and agwFlags & AUI_MGR_RECTANGLE_HINT == 0: self.CreateHintWindow()
[docs] def GetAGWFlags(self): """ Returns the current manager's flags. :see: L{SetAGWFlags} for a list of possible L{AuiManager} flags. """ return self._agwFlags
[docs] def SetManagedWindow(self, managed_window): """ Called to specify the frame or window which is to be managed by L{AuiManager}. Frame management is not restricted to just frames. Child windows or custom controls are also allowed. :param `managed_window`: specifies the window which should be managed by the AUI manager. """ if not managed_window: raise Exception("Specified managed window must be non-null. ") self._frame = managed_window self._frame.PushEventHandler(self) # if the owner is going to manage an MDI parent frame, # we need to add the MDI client window as the default # center pane if isinstance(self._frame, wx.MDIParentFrame): mdi_frame = self._frame client_window = mdi_frame.GetClientWindow() if not client_window: raise Exception("Client window is None!") self.AddPane(client_window, AuiPaneInfo().Name("mdiclient"). CenterPane().PaneBorder(False)) elif isinstance(self._frame, tabmdi.AuiMDIParentFrame): mdi_frame = self._frame client_window = mdi_frame.GetClientWindow() if not client_window: raise Exception("Client window is None!") self.AddPane(client_window, AuiPaneInfo().Name("mdiclient"). CenterPane().PaneBorder(False))
[docs] def GetManagedWindow(self): """ Returns the window being managed by L{AuiManager}. """ return self._frame
[docs] def SetFrame(self, managed_window): """ Called to specify the frame or window which is to be managed by L{AuiManager}. Frame management is not restricted to just frames. Child windows or custom controls are also allowed. :param `managed_window`: specifies the window which should be managed by the AUI manager. :warning: This method is now deprecated, use L{SetManagedWindow} instead. """ DeprecationWarning("This method is deprecated, use SetManagedWindow instead.") return self.SetManagedWindow(managed_window)
[docs] def GetFrame(self): """ Returns the window being managed by L{AuiManager}. :warning: This method is now deprecated, use L{GetManagedWindow} instead. """ DeprecationWarning("This method is deprecated, use GetManagedWindow instead.") return self._frame
[docs] def CreateGuideWindows(self): """ Creates the VS2005 HUD guide windows. """ self.DestroyGuideWindows() self._guides.append(AuiDockingGuideInfo().Left(). Host(AuiSingleDockingGuide(self._frame, wx.LEFT))) self._guides.append(AuiDockingGuideInfo().Top(). Host(AuiSingleDockingGuide(self._frame, wx.TOP))) self._guides.append(AuiDockingGuideInfo().Right(). Host(AuiSingleDockingGuide(self._frame, wx.RIGHT))) self._guides.append(AuiDockingGuideInfo().Bottom(). Host(AuiSingleDockingGuide(self._frame, wx.BOTTOM))) self._guides.append(AuiDockingGuideInfo().Centre(). Host(AuiCenterDockingGuide(self._frame)))
[docs] def DestroyGuideWindows(self): """ Destroys the VS2005 HUD guide windows. """ for guide in self._guides: if guide.host: guide.host.Destroy() self._guides = []
[docs] def CreateHintWindow(self): """ Creates the standard wxAUI hint window. """ self.DestroyHintWindow() self._hint_window = AuiDockingHintWindow(self._frame) self._hint_window.SetBlindMode(self._agwFlags)
[docs] def DestroyHintWindow(self): """ Destroys the standard wxAUI hint window. """ if self._hint_window: self._hint_window.Destroy() self._hint_window = None
[docs] def UnInit(self): """ Uninitializes the framework and should be called before a managed frame or window is destroyed. L{UnInit} is usually called in the managed `wx.Frame` / `wx.Window` destructor. It is necessary to call this function before the managed frame or window is destroyed, otherwise the manager cannot remove its custom event handlers from a window. """ if not self._frame: self.Destroy() return for klass in [self._frame] + list(self._frame.GetChildren()): handler = klass.GetEventHandler() if klass is not handler: if isinstance(handler, AuiManager): klass.PopEventHandler(True)
[docs] def GetArtProvider(self): """ Returns the current art provider being used. """ return self._art
[docs] def ProcessMgrEvent(self, event): """ Process the AUI events sent to the manager. :param `event`: the event to process, an instance of L{AuiManagerEvent}. """ # first, give the owner frame a chance to override if self._frame: if self._frame.GetEventHandler().ProcessEvent(event): return self.ProcessEvent(event)
[docs] def FireEvent(self, evtType, pane, canVeto=False): """ Fires one of the ``EVT_AUI_PANE_FLOATED``/``FLOATING``/``DOCKING``/``DOCKED``/``ACTIVATED`` event. :param `evtType`: one of the aforementioned events; :param `pane`: the L{AuiPaneInfo} instance associated to this event; :param `canVeto`: whether the event can be vetoed or not. """ event = AuiManagerEvent(evtType) event.SetPane(pane) event.SetCanVeto(canVeto) self.ProcessMgrEvent(event) return event
[docs] def CanUseModernDockArt(self): """ Returns whether L{ModernDockArt} can be used (Windows XP / Vista / 7 only, requires Mark Hammonds's `pywin32` package). """ if not _winxptheme: return False # Get the size of a small close button (themed) hwnd = self._frame.GetHandle() hTheme = winxptheme.OpenThemeData(hwnd, "Window") if not hTheme: return False return True
[docs] def SetArtProvider(self, art_provider): """ Instructs L{AuiManager} to use art provider specified by the parameter `art_provider` for all drawing calls. This allows plugable look-and-feel features. :param `art_provider`: a AUI dock art provider. :note: The previous art provider object, if any, will be deleted by L{AuiManager}. """ # delete the last art provider, if any del self._art # assign the new art provider self._art = art_provider for pane in self.GetAllPanes(): if pane.IsFloating() and pane.frame: pane.frame._mgr.SetArtProvider(art_provider) pane.frame._mgr.Update()
[docs] def AddPane(self, window, arg1=None, arg2=None, target=None): """ Tells the frame manager to start managing a child window. There are four versions of this function. The first verison allows the full spectrum of pane parameter possibilities (L{AddPane1}). The second version is used for simpler user interfaces which do not require as much configuration (L{AddPane2}). The L{AddPane3} version allows a drop position to be specified, which will determine where the pane will be added. The L{AddPane4} version allows to turn the target L{AuiPaneInfo} pane into a notebook and the added pane into a page. In wxPython, simply call L{AddPane}. :param `window`: the child window to manage; :param `arg1`: a L{AuiPaneInfo} or an integer value (direction); :param `arg2`: a L{AuiPaneInfo} or a `wx.Point` (drop position); :param `target`: a L{AuiPaneInfo} to be turned into a notebook and new pane added to it as a page. (additionally, target can be any pane in an existing notebook) """ if target in self._panes: return self.AddPane4(window, arg1, target) if type(arg1) == type(1): # This Is Addpane2 if arg1 is None: arg1 = wx.LEFT if arg2 is None: arg2 = "" return self.AddPane2(window, arg1, arg2) else: if isinstance(arg2, wx.Point): return self.AddPane3(window, arg1, arg2) else: return self.AddPane1(window, arg1)
[docs] def AddPane1(self, window, pane_info): """ See comments on L{AddPane}. """ # check if the pane has a valid window if not window: return False # check if the pane already exists if self.GetPane(pane_info.window).IsOk(): return False # check if the pane name already exists, this could reveal a # bug in the library user's application already_exists = False if pane_info.name != "" and self.GetPane(pane_info.name).IsOk(): warnings.warn("A pane with the name '%s' already exists in the manager!"%pane_info.name) already_exists = True # if the new pane is docked then we should undo maximize if pane_info.IsDocked(): self.RestoreMaximizedPane() self._panes.append(pane_info) pinfo = self._panes[-1] # set the pane window pinfo.window = window # if the pane's name identifier is blank, create a random string if pinfo.name == "" or already_exists: pinfo.name = ("%s%08x%08x%08x")%(pinfo.window.GetName(), time.time(), time.clock(), len(self._panes)) # set initial proportion (if not already set) if pinfo.dock_proportion == 0: pinfo.dock_proportion = 100000 floating = isinstance(self._frame, AuiFloatingFrame) pinfo.buttons = [] if not floating and pinfo.HasMinimizeButton(): button = AuiPaneButton(AUI_BUTTON_MINIMIZE) pinfo.buttons.append(button) if not floating and pinfo.HasMaximizeButton(): button = AuiPaneButton(AUI_BUTTON_MAXIMIZE_RESTORE) pinfo.buttons.append(button) if not floating and pinfo.HasPinButton(): button = AuiPaneButton(AUI_BUTTON_PIN) pinfo.buttons.append(button) if pinfo.HasCloseButton(): button = AuiPaneButton(AUI_BUTTON_CLOSE) pinfo.buttons.append(button) if pinfo.HasGripper(): if isinstance(pinfo.window, auibar.AuiToolBar): # prevent duplicate gripper -- both AuiManager and AuiToolBar # have a gripper control. The toolbar's built-in gripper # meshes better with the look and feel of the control than ours, # so turn AuiManager's gripper off, and the toolbar's on. tb = pinfo.window pinfo.SetFlag(AuiPaneInfo.optionGripper, False) tb.SetGripperVisible(True) if pinfo.window: if pinfo.best_size == wx.Size(-1, -1): pinfo.best_size = pinfo.window.GetClientSize() if isinstance(pinfo.window, wx.ToolBar): # GetClientSize() doesn't get the best size for # a toolbar under some newer versions of wxWidgets, # so use GetBestSize() pinfo.best_size = pinfo.window.GetBestSize() # this is needed for Win2000 to correctly fill toolbar backround # it should probably be repeated once system colour change happens if wx.Platform == "__WXMSW__" and pinfo.window.UseBgCol(): pinfo.window.SetBackgroundColour(self.GetArtProvider().GetColour(AUI_DOCKART_BACKGROUND_COLOUR)) if pinfo.min_size != wx.Size(-1, -1): if pinfo.best_size.x < pinfo.min_size.x: pinfo.best_size.x = pinfo.min_size.x if pinfo.best_size.y < pinfo.min_size.y: pinfo.best_size.y = pinfo.min_size.y self._panes[-1] = pinfo if isinstance(window, auibar.AuiToolBar): window.SetAuiManager(self) return True
[docs] def AddPane2(self, window, direction, caption): """ See comments on L{AddPane}. """ pinfo = AuiPaneInfo() pinfo.Caption(caption) if direction == wx.TOP: pinfo.Top() elif direction == wx.BOTTOM: pinfo.Bottom() elif direction == wx.LEFT: pinfo.Left() elif direction == wx.RIGHT: pinfo.Right() elif direction == wx.CENTER: pinfo.CenterPane() return self.AddPane(window, pinfo)
[docs] def AddPane3(self, window, pane_info, drop_pos): """ See comments on L{AddPane}. """ if not self.AddPane(window, pane_info): return False pane = self.GetPane(window) indx = self._panes.index(pane) ret, pane = self.DoDrop(self._docks, self._panes, pane, drop_pos, wx.Point(0, 0)) self._panes[indx] = pane return True
[docs] def AddPane4(self, window, pane_info, target): """ See comments on L{AddPane}. """ if not self.AddPane(window, pane_info): return False paneInfo = self.GetPane(window) if not paneInfo.IsNotebookDockable(): return self.AddPane1(window, pane_info) if not target.IsNotebookDockable() and not target.IsNotebookControl(): return self.AddPane1(window, pane_info) if not target.HasNotebook(): self.CreateNotebookBase(self._panes, target) # Add new item to notebook paneInfo.NotebookPage(target.notebook_id) # we also want to remove our captions sometimes self.RemoveAutoNBCaption(paneInfo) self.UpdateNotebook() return True
[docs] def InsertPane(self, window, pane_info, insert_level=AUI_INSERT_PANE): """ This method is used to insert either a previously unmanaged pane window into the frame manager, or to insert a currently managed pane somewhere else. L{InsertPane} will push all panes, rows, or docks aside and insert the window into the position specified by `pane_info`. Because `pane_info` can specify either a pane, dock row, or dock layer, the `insert_level` parameter is used to disambiguate this. The parameter `insert_level` can take a value of ``AUI_INSERT_PANE``, ``AUI_INSERT_ROW`` or ``AUI_INSERT_DOCK``. :param `window`: the window to be inserted and managed; :param `pane_info`: the insert location for the new window; :param `insert_level`: the insertion level of the new pane. """ if not window: raise Exception("Invalid window passed to InsertPane.") # shift the panes around, depending on the insert level if insert_level == AUI_INSERT_PANE: self._panes = DoInsertPane(self._panes, pane_info.dock_direction, pane_info.dock_layer, pane_info.dock_row, pane_info.dock_pos) elif insert_level == AUI_INSERT_ROW: self._panes = DoInsertDockRow(self._panes, pane_info.dock_direction, pane_info.dock_layer, pane_info.dock_row) elif insert_level == AUI_INSERT_DOCK: self._panes = DoInsertDockLayer(self._panes, pane_info.dock_direction, pane_info.dock_layer) # if the window already exists, we are basically just moving/inserting the # existing window. If it doesn't exist, we need to add it and insert it existing_pane = self.GetPane(window) indx = self._panes.index(existing_pane) if not existing_pane.IsOk(): return self.AddPane(window, pane_info) else: if pane_info.IsFloating(): existing_pane.Float() if pane_info.floating_pos != wx.Point(-1, -1): existing_pane.FloatingPosition(pane_info.floating_pos) if pane_info.floating_size != wx.Size(-1, -1): existing_pane.FloatingSize(pane_info.floating_size) else: # if the new pane is docked then we should undo maximize self.RestoreMaximizedPane() existing_pane.Direction(pane_info.dock_direction) existing_pane.Layer(pane_info.dock_layer) existing_pane.Row(pane_info.dock_row) existing_pane.Position(pane_info.dock_pos) self._panes[indx] = existing_pane return True
[docs] def DetachPane(self, window): """ Tells the L{AuiManager} to stop managing the pane specified by `window`. The window, if in a floated frame, is reparented to the frame managed by L{AuiManager}. :param `window`: the window to be un-managed. """ for p in self._panes: if p.window == window: if p.frame: # we have a floating frame which is being detached. We need to # reparent it to self._frame and destroy the floating frame # reduce flicker p.window.SetSize((1, 1)) if p.frame.IsShown(): p.frame.Show(False) if self._action_window == p.frame: self._action_window = None # reparent to self._frame and destroy the pane p.window.Reparent(self._frame) p.frame.SetSizer(None) p.frame.Destroy() p.frame = None elif p.IsNotebookPage(): notebook = self._notebooks[p.notebook_id] id = notebook.GetPageIndex(p.window) notebook.RemovePage(id) # make sure there are no references to this pane in our uiparts, # just in case the caller doesn't call Update() immediately after # the DetachPane() call. This prevets obscure crashes which would # happen at window repaint if the caller forgets to call Update() counter = 0 for pi in xrange(len(self._uiparts)): part = self._uiparts[counter] if part.pane == p: self._uiparts.pop(counter) counter -= 1 counter += 1 self._panes.remove(p) return True return False
[docs] def ClosePane(self, pane_info): """ Destroys or hides the pane depending on its flags. :param `pane_info`: a L{AuiPaneInfo} instance. """ # if we were maximized, restore if pane_info.IsMaximized(): self.RestorePane(pane_info) if pane_info.frame: if self._agwFlags & AUI_MGR_ANIMATE_FRAMES: pane_info.frame.FadeOut() # first, hide the window if pane_info.window and pane_info.window.IsShown(): pane_info.window.Show(False) # make sure that we are the parent of this window if pane_info.window and pane_info.window.GetParent() != self._frame: pane_info.window.Reparent(self._frame) # if we have a frame, destroy it if pane_info.frame: pane_info.frame.Destroy() pane_info.frame = None elif pane_info.IsNotebookPage(): # if we are a notebook page, remove ourselves... # the code would index out of bounds # if the last page of a sub-notebook was closed # because the notebook would be deleted, before this # code is executed. # This code just prevents an out-of bounds error. if self._notebooks: nid = pane_info.notebook_id if nid >= 0 and nid < len(self._notebooks): notebook = self._notebooks[nid] page_idx = notebook.GetPageIndex(pane_info.window) if page_idx >= 0: notebook.RemovePage(page_idx) # now we need to either destroy or hide the pane to_destroy = 0 if pane_info.IsDestroyOnClose(): to_destroy = pane_info.window self.DetachPane(to_destroy) else: if isinstance(pane_info.window, auibar.AuiToolBar) and pane_info.IsFloating(): tb = pane_info.window if pane_info.dock_direction in [AUI_DOCK_LEFT, AUI_DOCK_RIGHT]: tb.SetAGWWindowStyleFlag(tb.GetAGWWindowStyleFlag() | AUI_TB_VERTICAL) pane_info.Dock().Hide() if pane_info.IsNotebookControl(): notebook = self._notebooks[pane_info.notebook_id] while notebook.GetPageCount(): window = notebook.GetPage(0) notebook.RemovePage(0) info = self.GetPane(window) if info.IsOk(): info.notebook_id = -1 info.dock_direction = AUI_DOCK_NONE # Note: this could change our paneInfo reference ... self.ClosePane(info) if to_destroy: to_destroy.Destroy()
[docs] def MaximizePane(self, pane_info, savesizes=True): """ Maximizes the input pane. :param `pane_info`: a L{AuiPaneInfo} instance. :param `savesizes`: whether to save previous dock sizes. """ if savesizes: self.SavePreviousDockSizes(pane_info) for p in self._panes: # save hidden state p.SetFlag(p.savedHiddenState, p.HasFlag(p.optionHidden)) if not p.IsToolbar() and not p.IsFloating(): p.Restore() # hide the pane, because only the newly # maximized pane should show p.Hide() pane_info.previousDockPos = pane_info.dock_pos # mark ourselves maximized pane_info.Maximize() pane_info.Show() self._has_maximized = True # last, show the window if pane_info.window and not pane_info.window.IsShown(): pane_info.window.Show(True)
[docs] def SavePreviousDockSizes(self, pane_info): """ Stores the previous dock sizes, to be used in a "restore" action later. :param `pane_info`: a L{AuiPaneInfo} instance. """ for d in self._docks: if not d.toolbar: for p in d.panes: p.previousDockSize = d.size if pane_info is not p: p.SetFlag(p.needsRestore, True)
[docs] def RestorePane(self, pane_info): """ Restores the input pane from a previous maximized or minimized state. :param `pane_info`: a L{AuiPaneInfo} instance. """ # restore all the panes for p in self._panes: if not p.IsToolbar(): p.SetFlag(p.optionHidden, p.HasFlag(p.savedHiddenState)) pane_info.SetFlag(pane_info.needsRestore, True) # mark ourselves non-maximized pane_info.Restore() self._has_maximized = False self._has_minimized = False # last, show the window if pane_info.window and not pane_info.window.IsShown(): pane_info.window.Show(True)
[docs] def RestoreMaximizedPane(self): """ Restores the current maximized pane (if any). """ # restore all the panes for p in self._panes: if p.IsMaximized(): self.RestorePane(p) break
[docs] def ActivatePane(self, window): """ Activates the pane to which `window` is associated. :param `window`: a `wx.Window` derived window. """ if self.GetAGWFlags() & AUI_MGR_ALLOW_ACTIVE_PANE: while window: ret, self._panes = SetActivePane(self._panes, window) if ret: break window = window.GetParent() self.RefreshCaptions() self.FireEvent(wxEVT_AUI_PANE_ACTIVATED, window, canVeto=False)
[docs] def CreateNotebook(self): """ Creates an automatic L{AuiNotebook} when a pane is docked on top of another pane. """ notebook = auibook.AuiNotebook(self._frame, -1, wx.Point(0, 0), wx.Size(0, 0), agwStyle=self._autoNBStyle) # This is so we can get the tab-drag event. notebook.GetAuiManager().SetMasterManager(self) notebook.SetArtProvider(self._autoNBTabArt.Clone()) self._notebooks.append(notebook) return notebook
[docs] def SetAutoNotebookTabArt(self, art): """ Sets the default tab art provider for automatic notebooks. :param `art`: a tab art provider. """ for nb in self._notebooks: nb.SetArtProvider(art.Clone()) nb.Refresh() nb.Update() self._autoNBTabArt = art
[docs] def GetAutoNotebookTabArt(self): """ Returns the default tab art provider for automatic notebooks. """ return self._autoNBTabArt
[docs] def SetAutoNotebookStyle(self, agwStyle): """ Sets the default AGW-specific window style for automatic notebooks. :param `agwStyle`: the underlying L{AuiNotebook} window style. This can be a combination of the following bits: ==================================== ================================== Flag name Description ==================================== ================================== ``AUI_NB_TOP`` With this style, tabs are drawn along the top of the notebook ``AUI_NB_LEFT`` With this style, tabs are drawn along the left of the notebook. Not implemented yet. ``AUI_NB_RIGHT`` With this style, tabs are drawn along the right of the notebook. Not implemented yet. ``AUI_NB_BOTTOM`` With this style, tabs are drawn along the bottom of the notebook ``AUI_NB_TAB_SPLIT`` Allows the tab control to be split by dragging a tab ``AUI_NB_TAB_MOVE`` Allows a tab to be moved horizontally by dragging ``AUI_NB_TAB_EXTERNAL_MOVE`` Allows a tab to be moved to another tab control ``AUI_NB_TAB_FIXED_WIDTH`` With this style, all tabs have the same width ``AUI_NB_SCROLL_BUTTONS`` With this style, left and right scroll buttons are displayed ``AUI_NB_WINDOWLIST_BUTTON`` With this style, a drop-down list of windows is available ``AUI_NB_CLOSE_BUTTON`` With this style, a close button is available on the tab bar ``AUI_NB_CLOSE_ON_ACTIVE_TAB`` With this style, a close button is available on the active tab ``AUI_NB_CLOSE_ON_ALL_TABS`` With this style, a close button is available on all tabs ``AUI_NB_MIDDLE_CLICK_CLOSE`` Allows to close L{AuiNotebook} tabs by mouse middle button click ``AUI_NB_SUB_NOTEBOOK`` This style is used by {AuiManager} to create automatic AuiNotebooks ``AUI_NB_HIDE_ON_SINGLE_TAB`` Hides the tab window if only one tab is present ``AUI_NB_SMART_TABS`` Use Smart Tabbing, like ``Alt`` + ``Tab`` on Windows ``AUI_NB_USE_IMAGES_DROPDOWN`` Uses images on dropdown window list menu instead of check items ``AUI_NB_CLOSE_ON_TAB_LEFT`` Draws the tab close button on the left instead of on the right (a la Camino browser) ``AUI_NB_TAB_FLOAT`` Allows the floating of single tabs. Known limitation: when the notebook is more or less full screen, tabs cannot be dragged far enough outside of the notebook to become floating pages ``AUI_NB_DRAW_DND_TAB`` Draws an image representation of a tab while dragging (on by default) ==================================== ================================== """ for nb in self._notebooks: nb.SetAGWWindowStyleFlag(agwStyle) nb.Refresh() nb.Update() self._autoNBStyle = agwStyle
[docs] def GetAutoNotebookStyle(self): """ Returns the default AGW-specific window style for automatic notebooks. :see: L{SetAutoNotebookStyle} method for a list of possible styles. """ return self._autoNBStyle
[docs] def SavePaneInfo(self, pane): """ This method is similar to L{SavePerspective}, with the exception that it only saves information about a single pane. It is used in combination with L{LoadPaneInfo}. :param `pane`: a L{AuiPaneInfo} instance to save. """ result = "name=" + EscapeDelimiters(pane.name) + ";" result += "caption=" + EscapeDelimiters(pane.caption) + ";" result += "state=%u;"%pane.state result += "dir=%d;"%pane.dock_direction result += "layer=%d;"%pane.dock_layer result += "row=%d;"%pane.dock_row result += "pos=%d;"%pane.dock_pos result += "prop=%d;"%pane.dock_proportion result += "bestw=%d;"%pane.best_size.x result += "besth=%d;"%pane.best_size.y result += "minw=%d;"%pane.min_size.x result += "minh=%d;"%pane.min_size.y result += "maxw=%d;"%pane.max_size.x result += "maxh=%d;"%pane.max_size.y result += "floatx=%d;"%pane.floating_pos.x result += "floaty=%d;"%pane.floating_pos.y result += "floatw=%d;"%pane.floating_size.x result += "floath=%d;"%pane.floating_size.y result += "notebookid=%d;"%pane.notebook_id result += "transparent=%d"%pane.transparent return result
[docs] def LoadPaneInfo(self, pane_part, pane): """ This method is similar to to L{LoadPerspective}, with the exception that it only loads information about a single pane. It is used in combination with L{SavePaneInfo}. :param `pane_part`: the string to analyze; :param `pane`: the L{AuiPaneInfo} structure in which to load `pane_part`. """ # replace escaped characters so we can # split up the string easily pane_part = pane_part.replace("\\|", "\a") pane_part = pane_part.replace("\\;", "\b") options = pane_part.split(";") for items in options: val_name, value = items.split("=") val_name = val_name.strip() if val_name == "name": pane.name = value elif val_name == "caption": pane.caption = value elif val_name == "state": pane.state = int(value) elif val_name == "dir": pane.dock_direction = int(value) elif val_name == "layer": pane.dock_layer = int(value) elif val_name == "row": pane.dock_row = int(value) elif val_name == "pos": pane.dock_pos = int(value) elif val_name == "prop": pane.dock_proportion = int(value) elif val_name == "bestw": pane.best_size.x = int(value) elif val_name == "besth": pane.best_size.y = int(value) pane.best_size = wx.Size(pane.best_size.x, pane.best_size.y) elif val_name == "minw": pane.min_size.x = int(value) elif val_name == "minh": pane.min_size.y = int(value) pane.min_size = wx.Size(pane.min_size.x, pane.min_size.y) elif val_name == "maxw": pane.max_size.x = int(value) elif val_name == "maxh": pane.max_size.y = int(value) pane.max_size = wx.Size(pane.max_size.x, pane.max_size.y) elif val_name == "floatx": pane.floating_pos.x = int(value) elif val_name == "floaty": pane.floating_pos.y = int(value) pane.floating_pos = wx.Point(pane.floating_pos.x, pane.floating_pos.y) elif val_name == "floatw": pane.floating_size.x = int(value) elif val_name == "floath": pane.floating_size.y = int(value) pane.floating_size = wx.Size(pane.floating_size.x, pane.floating_size.y) elif val_name == "notebookid": pane.notebook_id = int(value) elif val_name == "transparent": pane.transparent = int(value) else: raise Exception("Bad perspective string") # replace escaped characters so we can # split up the string easily pane.name = pane.name.replace("\a", "|") pane.name = pane.name.replace("\b", ";") pane.caption = pane.caption.replace("\a", "|") pane.caption = pane.caption.replace("\b", ";") pane_part = pane_part.replace("\a", "|") pane_part = pane_part.replace("\b", ";") return pane
[docs] def SavePerspective(self): """ Saves the entire user interface layout into an encoded string, which can then be stored by the application (probably using `wx.Config`). When a perspective is restored using L{LoadPerspective}, the entire user interface will return to the state it was when the perspective was saved. """ result = "layout2|" for pane in self._panes: result += self.SavePaneInfo(pane) + "|" for dock in self._docks: result = result + ("dock_size(%d,%d,%d)=%d|")%(dock.dock_direction, dock.dock_layer, dock.dock_row, dock.size) return result
[docs] def LoadPerspective(self, layout, update=True): """ Loads a layout which was saved with L{SavePerspective}. If the `update` flag parameter is ``True``, L{Update} will be automatically invoked, thus realizing the saved perspective on screen. :param `layout`: a string which contains a saved AUI layout; :param `update`: whether to update immediately the window or not. """ input = layout # check layout string version # 'layout1' = wxAUI 0.9.0 - wxAUI 0.9.2 # 'layout2' = wxAUI 0.9.2 (wxWidgets 2.8) index = input.find("|") part = input[0:index].strip() input = input[index+1:] if part != "layout2": return False # mark all panes currently managed as docked and hidden for pane in self._panes: pane.Dock().Hide() # clear out the dock array; this will be reconstructed self._docks = [] # replace escaped characters so we can # split up the string easily input = input.replace("\\|", "\a") input = input.replace("\\;", "\b") while 1: pane = AuiPaneInfo() index = input.find("|") pane_part = input[0:index].strip() input = input[index+1:] # if the string is empty, we're done parsing if pane_part == "": break if pane_part[0:9] == "dock_size": index = pane_part.find("=") val_name = pane_part[0:index] value = pane_part[index+1:] index = val_name.find("(") piece = val_name[index+1:] index = piece.find(")") piece = piece[0:index] vals = piece.split(",") dir = int(vals[0]) layer = int(vals[1]) row = int(vals[2]) size = int(value) dock = AuiDockInfo() dock.dock_direction = dir dock.dock_layer = layer dock.dock_row = row dock.size = size self._docks.append(dock) continue # Undo our escaping as LoadPaneInfo needs to take an unescaped # name so it can be called by external callers pane_part = pane_part.replace("\a", "|") pane_part = pane_part.replace("\b", ";") pane = self.LoadPaneInfo(pane_part, pane) p = self.GetPane(pane.name) if not p.IsOk(): if pane.IsNotebookControl(): # notebook controls - auto add... self._panes.append(pane) indx = self._panes.index(pane) else: # the pane window couldn't be found # in the existing layout -- skip it continue else: indx = self._panes.index(p) pane.window = p.window pane.frame = p.frame pane.buttons = p.buttons self._panes[indx] = pane if isinstance(pane.window, auibar.AuiToolBar) and (pane.IsFloatable() or pane.IsDockable()): pane.window.SetGripperVisible(True) if update: self.Update() return True
[docs] def GetPanePositionsAndSizes(self, dock): """ Returns all the panes positions and sizes in a dock. :param `dock`: a L{AuiDockInfo} instance. """ caption_size = self._art.GetMetric(AUI_DOCKART_CAPTION_SIZE) pane_border_size = self._art.GetMetric(AUI_DOCKART_PANE_BORDER_SIZE) gripper_size = self._art.GetMetric(AUI_DOCKART_GRIPPER_SIZE) positions = [] sizes = [] action_pane = -1 pane_count = len(dock.panes) # find the pane marked as our action pane for pane_i in xrange(pane_count): pane = dock.panes[pane_i] if pane.HasFlag(AuiPaneInfo.actionPane): if action_pane != -1: raise Exception("Too many action panes!") action_pane = pane_i # set up each panes default position, and # determine the size (width or height, depending # on the dock's orientation) of each pane for pane in dock.panes: positions.append(pane.dock_pos) size = 0 if pane.HasBorder(): size += pane_border_size*2 if dock.IsHorizontal(): if pane.HasGripper() and not pane.HasGripperTop(): size += gripper_size if pane.HasCaptionLeft(): size += caption_size size += pane.best_size.x else: if pane.HasGripper() and pane.HasGripperTop(): size += gripper_size if pane.HasCaption() and not pane.HasCaptionLeft(): size += caption_size size += pane.best_size.y sizes.append(size) # if there is no action pane, just return the default # positions (as specified in pane.pane_pos) if action_pane == -1: return positions, sizes offset = 0 for pane_i in xrange(action_pane-1, -1, -1): amount = positions[pane_i+1] - (positions[pane_i] + sizes[pane_i]) if amount >= 0: offset += amount else: positions[pane_i] -= -amount offset += sizes[pane_i] # if the dock mode is fixed, make sure none of the panes # overlap we will bump panes that overlap offset = 0 for pane_i in xrange(action_pane, pane_count): amount = positions[pane_i] - offset if amount >= 0: offset += amount else: positions[pane_i] += -amount offset += sizes[pane_i] return positions, sizes
[docs] def LayoutAddPane(self, cont, dock, pane, uiparts, spacer_only): """ Adds a pane into the existing layout (in an existing dock). :param `cont`: a `wx.Sizer` object; :param `dock`: the L{AuiDockInfo} structure in which to add the pane; :param `pane`: the L{AuiPaneInfo} instance to add to the dock; :param `uiparts`: a list of UI parts in the interface; :param `spacer_only`: whether to add a simple spacer or a real window. """ sizer_item = wx.SizerItem() caption_size = self._art.GetMetric(AUI_DOCKART_CAPTION_SIZE) gripper_size = self._art.GetMetric(AUI_DOCKART_GRIPPER_SIZE) pane_border_size = self._art.GetMetric(AUI_DOCKART_PANE_BORDER_SIZE) pane_button_size = self._art.GetMetric(AUI_DOCKART_PANE_BUTTON_SIZE) # find out the orientation of the item (orientation for panes # is the same as the dock's orientation) if dock.IsHorizontal(): orientation = wx.HORIZONTAL else: orientation = wx.VERTICAL # this variable will store the proportion # value that the pane will receive pane_proportion = pane.dock_proportion horz_pane_sizer = wx.BoxSizer(wx.HORIZONTAL) vert_pane_sizer = wx.BoxSizer(wx.VERTICAL) if pane.HasGripper(): part = AuiDockUIPart() if pane.HasGripperTop(): sizer_item = vert_pane_sizer.Add((1, gripper_size), 0, wx.EXPAND) else: sizer_item = horz_pane_sizer.Add((gripper_size, 1), 0, wx.EXPAND) part.type = AuiDockUIPart.typeGripper part.dock = dock part.pane = pane part.button = None part.orientation = orientation part.cont_sizer = horz_pane_sizer part.sizer_item = sizer_item uiparts.append(part) button_count = len(pane.buttons) button_width_total = button_count*pane_button_size if button_count >= 1: button_width_total += 3 caption, captionLeft = pane.HasCaption(), pane.HasCaptionLeft() button_count = len(pane.buttons) if captionLeft: caption_sizer = wx.BoxSizer(wx.VERTICAL) # add pane buttons to the caption dummy_parts = [] for btn_id in xrange(len(pane.buttons)-1, -1, -1): sizer_item = caption_sizer.Add((caption_size, pane_button_size), 0, wx.EXPAND) part = AuiDockUIPart() part.type = AuiDockUIPart.typePaneButton part.dock = dock part.pane = pane part.button = pane.buttons[btn_id] part.orientation = orientation part.cont_sizer = caption_sizer part.sizer_item = sizer_item dummy_parts.append(part) sizer_item = caption_sizer.Add((caption_size, 1), 1, wx.EXPAND) vert_pane_sizer = wx.BoxSizer(wx.HORIZONTAL) # create the caption sizer part = AuiDockUIPart() part.type = AuiDockUIPart.typeCaption part.dock = dock part.pane = pane part.button = None part.orientation = orientation part.cont_sizer = vert_pane_sizer part.sizer_item = sizer_item caption_part_idx = len(uiparts) uiparts.append(part) uiparts.extend(dummy_parts) elif caption: caption_sizer = wx.BoxSizer(wx.HORIZONTAL) sizer_item = caption_sizer.Add((1, caption_size), 1, wx.EXPAND) # create the caption sizer part = AuiDockUIPart() part.type = AuiDockUIPart.typeCaption part.dock = dock part.pane = pane part.button = None part.orientation = orientation part.cont_sizer = vert_pane_sizer part.sizer_item = sizer_item caption_part_idx = len(uiparts) uiparts.append(part) # add pane buttons to the caption for button in pane.buttons: sizer_item = caption_sizer.Add((pane_button_size, caption_size), 0, wx.EXPAND) part = AuiDockUIPart() part.type = AuiDockUIPart.typePaneButton part.dock = dock part.pane = pane part.button = button part.orientation = orientation part.cont_sizer = caption_sizer part.sizer_item = sizer_item uiparts.append(part) if caption or captionLeft: # if we have buttons, add a little space to the right # of them to ease visual crowding if button_count >= 1: if captionLeft: caption_sizer.Add((caption_size, 3), 0, wx.EXPAND) else: caption_sizer.Add((3, caption_size), 0, wx.EXPAND) # add the caption sizer sizer_item = vert_pane_sizer.Add(caption_sizer, 0, wx.EXPAND) uiparts[caption_part_idx].sizer_item = sizer_item # add the pane window itself if spacer_only or not pane.window: sizer_item = vert_pane_sizer.Add((1, 1), 1, wx.EXPAND) else: sizer_item = vert_pane_sizer.Add(pane.window, 1, wx.EXPAND) vert_pane_sizer.SetItemMinSize(pane.window, (1, 1)) part = AuiDockUIPart() part.type = AuiDockUIPart.typePane part.dock = dock part.pane = pane part.button = None part.orientation = orientation part.cont_sizer = vert_pane_sizer part.sizer_item = sizer_item uiparts.append(part) # determine if the pane should have a minimum size if the pane is # non-resizable (fixed) then we must set a minimum size. Alternatively, # if the pane.min_size is set, we must use that value as well min_size = pane.min_size if pane.IsFixed(): if min_size == wx.Size(-1, -1): min_size = pane.best_size pane_proportion = 0 if min_size != wx.Size(-1, -1): vert_pane_sizer.SetItemMinSize(len(vert_pane_sizer.GetChildren())-1, (min_size.x, min_size.y)) # add the vertical/horizontal sizer (caption, pane window) to the # horizontal sizer (gripper, vertical sizer) horz_pane_sizer.Add(vert_pane_sizer, 1, wx.EXPAND) # finally, add the pane sizer to the dock sizer if pane.HasBorder(): # allowing space for the pane's border sizer_item = cont.Add(horz_pane_sizer, pane_proportion, wx.EXPAND | wx.ALL, pane_border_size) part = AuiDockUIPart() part.type = AuiDockUIPart.typePaneBorder part.dock = dock part.pane = pane part.button = None part.orientation = orientation part.cont_sizer = cont part.sizer_item = sizer_item uiparts.append(part) else: sizer_item = cont.Add(horz_pane_sizer, pane_proportion, wx.EXPAND) return uiparts
[docs] def LayoutAddDock(self, cont, dock, uiparts, spacer_only): """ Adds a dock into the existing layout. :param `cont`: a `wx.Sizer` object; :param `dock`: the L{AuiDockInfo} structure to add to the layout; :param `uiparts`: a list of UI parts in the interface; :param `spacer_only`: whether to add a simple spacer or a real window. """ sizer_item = wx.SizerItem() part = AuiDockUIPart() sash_size = self._art.GetMetric(AUI_DOCKART_SASH_SIZE) orientation = (dock.IsHorizontal() and [wx.HORIZONTAL] or [wx.VERTICAL])[0] # resizable bottom and right docks have a sash before them if not self._has_maximized and not dock.fixed and \ dock.dock_direction in [AUI_DOCK_BOTTOM, AUI_DOCK_RIGHT]: sizer_item = cont.Add((sash_size, sash_size), 0, wx.EXPAND) part.type = AuiDockUIPart.typeDockSizer part.orientation = orientation part.dock = dock part.pane = None part.button = None part.cont_sizer = cont part.sizer_item = sizer_item uiparts.append(part) # create the sizer for the dock dock_sizer = wx.BoxSizer(orientation) # add each pane to the dock has_maximized_pane = False pane_count = len(dock.panes) if dock.fixed: # figure out the real pane positions we will # use, without modifying the each pane's pane_pos member pane_positions, pane_sizes = self.GetPanePositionsAndSizes(dock) offset = 0 for pane_i in xrange(pane_count): pane = dock.panes[pane_i] pane_pos = pane_positions[pane_i] if pane.IsMaximized(): has_maximized_pane = True amount = pane_pos - offset if amount > 0: if dock.IsVertical(): sizer_item = dock_sizer.Add((1, amount), 0, wx.EXPAND) else: sizer_item = dock_sizer.Add((amount, 1), 0, wx.EXPAND) part = AuiDockUIPart() part.type = AuiDockUIPart.typeBackground part.dock = dock part.pane = None part.button = None part.orientation = (orientation==wx.HORIZONTAL and \ [wx.VERTICAL] or [wx.HORIZONTAL])[0] part.cont_sizer = dock_sizer part.sizer_item = sizer_item uiparts.append(part) offset = offset + amount uiparts = self.LayoutAddPane(dock_sizer, dock, pane, uiparts, spacer_only) offset = offset + pane_sizes[pane_i] # at the end add a very small stretchable background area sizer_item = dock_sizer.Add((0, 0), 1, wx.EXPAND) part = AuiDockUIPart() part.type = AuiDockUIPart.typeBackground part.dock = dock part.pane = None part.button = None part.orientation = orientation part.cont_sizer = dock_sizer part.sizer_item = sizer_item uiparts.append(part) else: for pane_i in xrange(pane_count): pane = dock.panes[pane_i] if pane.IsMaximized(): has_maximized_pane = True # if this is not the first pane being added, # we need to add a pane sizer if not self._has_maximized and pane_i > 0: sizer_item = dock_sizer.Add((sash_size, sash_size), 0, wx.EXPAND) part = AuiDockUIPart() part.type = AuiDockUIPart.typePaneSizer part.dock = dock part.pane = dock.panes[pane_i-1] part.button = None part.orientation = (orientation==wx.HORIZONTAL and \ [wx.VERTICAL] or [wx.HORIZONTAL])[0] part.cont_sizer = dock_sizer part.sizer_item = sizer_item uiparts.append(part) uiparts = self.LayoutAddPane(dock_sizer, dock, pane, uiparts, spacer_only) if dock.dock_direction == AUI_DOCK_CENTER or has_maximized_pane: sizer_item = cont.Add(dock_sizer, 1, wx.EXPAND) else: sizer_item = cont.Add(dock_sizer, 0, wx.EXPAND) part = AuiDockUIPart() part.type = AuiDockUIPart.typeDock part.dock = dock part.pane = None part.button = None part.orientation = orientation part.cont_sizer = cont part.sizer_item = sizer_item uiparts.append(part) if dock.IsHorizontal(): cont.SetItemMinSize(dock_sizer, (0, dock.size)) else: cont.SetItemMinSize(dock_sizer, (dock.size, 0)) # top and left docks have a sash after them if not self._has_maximized and not dock.fixed and \ dock.dock_direction in [AUI_DOCK_TOP, AUI_DOCK_LEFT]: sizer_item = cont.Add((sash_size, sash_size), 0, wx.EXPAND) part = AuiDockUIPart() part.type = AuiDockUIPart.typeDockSizer part.dock = dock part.pane = None part.button = None part.orientation = orientation part.cont_sizer = cont part.sizer_item = sizer_item uiparts.append(part) return uiparts
[docs] def LayoutAll(self, panes, docks, uiparts, spacer_only=False, oncheck=True): """ Layouts all the UI structures in the interface. :param `panes`: a list of L{AuiPaneInfo} instances; :param `docks`: a list of L{AuiDockInfo} classes; :param `uiparts`: a list of UI parts in the interface; :param `spacer_only`: whether to add a simple spacer or a real window; :param `oncheck`: whether to store the results in a class member or not. """ container = wx.BoxSizer(wx.VERTICAL) pane_border_size = self._art.GetMetric(AUI_DOCKART_PANE_BORDER_SIZE) caption_size = self._art.GetMetric(AUI_DOCKART_CAPTION_SIZE) cli_size = self._frame.GetClientSize() # empty all docks out for dock in docks: dock.panes = [] if dock.fixed: # always reset fixed docks' sizes, because # the contained windows may have been resized dock.size = 0 dock_count = len(docks) # iterate through all known panes, filing each # of them into the appropriate dock. If the # pane does not exist in the dock, add it for p in panes: # don't layout hidden panes. if p.IsShown(): # find any docks with the same dock direction, dock layer, and # dock row as the pane we are working on arr = FindDocks(docks, p.dock_direction, p.dock_layer, p.dock_row) if arr: dock = arr[0] else: # dock was not found, so we need to create a new one d = AuiDockInfo() d.dock_direction = p.dock_direction d.dock_layer = p.dock_layer d.dock_row = p.dock_row docks.append(d) dock = docks[-1] if p.HasFlag(p.needsRestore) and not p.HasFlag(p.wasMaximized): isHor = dock.IsHorizontal() sashSize = self._art.GetMetric(AUI_DOCKART_SASH_SIZE) # get the sizes of any docks that might # overlap with our restored dock # make list of widths or heights from the size in the dock rects sizes = [d.rect[2:][isHor] for \ d in docks if d.IsOk() and \ (d.IsHorizontal() == isHor) and \ not d.toolbar and \ d.dock_direction != AUI_DOCK_CENTER] frameRect = GetInternalFrameRect(self._frame, self._docks) # set max size allowing for sashes and absolute minimum maxsize = frameRect[2:][isHor] - sum(sizes) - (len(sizes)*10) - (sashSize*len(sizes)) dock.size = min(p.previousDockSize,maxsize) else: dock.size = 0 if p.HasFlag(p.wasMaximized): self.MaximizePane(p, savesizes=False) p.SetFlag(p.wasMaximized, False) if p.HasFlag(p.needsRestore): if p.previousDockPos is not None: DoInsertPane(dock.panes, dock.dock_direction, dock.dock_layer, dock.dock_row, p.previousDockPos) p.dock_pos = p.previousDockPos p.previousDockPos = None p.SetFlag(p.needsRestore, False) if p.IsDocked(): # remove the pane from any existing docks except this one docks = RemovePaneFromDocks(docks, p, dock) # pane needs to be added to the dock, # if it doesn't already exist if not FindPaneInDock(dock, p.window): dock.panes.append(p) else: # remove the pane from any existing docks docks = RemovePaneFromDocks(docks, p) # remove any empty docks docks = [dock for dock in docks if dock.panes] dock_count = len(docks) # configure the docks further for ii, dock in enumerate(docks): # sort the dock pane array by the pane's # dock position (dock_pos), in ascending order dock.panes.sort(PaneSortFunc) dock_pane_count = len(dock.panes) # for newly created docks, set up their initial size if dock.size == 0: size = 0 for pane in dock.panes: pane_size = pane.best_size if pane_size == wx.Size(-1, -1): pane_size = pane.min_size if pane_size == wx.Size(-1, -1) and pane.window: pane_size = pane.window.GetSize() if dock.IsHorizontal(): size = max(pane_size.y, size) else: size = max(pane_size.x, size) # add space for the border (two times), but only # if at least one pane inside the dock has a pane border for pane in dock.panes: if pane.HasBorder(): size = size + pane_border_size*2 break # if pane is on the top or bottom, add the caption height, # but only if at least one pane inside the dock has a caption if dock.IsHorizontal(): for pane in dock.panes: if pane.HasCaption() and not pane.HasCaptionLeft(): size = size + caption_size break else: for pane in dock.panes: if pane.HasCaptionLeft() and not pane.HasCaption(): size = size + caption_size break # new dock's size may not be more than the dock constraint # parameter specifies. See SetDockSizeConstraint() max_dock_x_size = int(self._dock_constraint_x*float(cli_size.x)) max_dock_y_size = int(self._dock_constraint_y*float(cli_size.y)) if cli_size <= wx.Size(20, 20): max_dock_x_size = 10000 max_dock_y_size = 10000 if dock.IsHorizontal(): size = min(size, max_dock_y_size) else: size = min(size, max_dock_x_size) # absolute minimum size for a dock is 10 pixels if size < 10: size = 10 dock.size = size # determine the dock's minimum size plus_border = False plus_caption = False plus_caption_left = False dock_min_size = 0 for pane in dock.panes: if pane.min_size != wx.Size(-1, -1): if pane.HasBorder(): plus_border = True if pane.HasCaption(): plus_caption = True if pane.HasCaptionLeft(): plus_caption_left = True if dock.IsHorizontal(): if pane.min_size.y > dock_min_size: dock_min_size = pane.min_size.y else: if pane.min_size.x > dock_min_size: dock_min_size = pane.min_size.x if plus_border: dock_min_size += pane_border_size*2 if plus_caption and dock.IsHorizontal(): dock_min_size += caption_size if plus_caption_left and dock.IsVertical(): dock_min_size += caption_size dock.min_size = dock_min_size # if the pane's current size is less than it's # minimum, increase the dock's size to it's minimum if dock.size < dock.min_size: dock.size = dock.min_size # determine the dock's mode (fixed or proportional) # determine whether the dock has only toolbars action_pane_marked = False dock.fixed = True dock.toolbar = True for pane in dock.panes: if not pane.IsFixed(): dock.fixed = False if not pane.IsToolbar(): dock.toolbar = False if pane.HasFlag(AuiPaneInfo.optionDockFixed): dock.fixed = True if pane.HasFlag(AuiPaneInfo.actionPane): action_pane_marked = True # if the dock mode is proportional and not fixed-pixel, # reassign the dock_pos to the sequential 0, 1, 2, 3 # e.g. remove gaps like 1, 2, 30, 500 if not dock.fixed: for jj in xrange(dock_pane_count): pane = dock.panes[jj] pane.dock_pos = jj # if the dock mode is fixed, and none of the panes # are being moved right now, make sure the panes # do not overlap each other. If they do, we will # adjust the panes' positions if dock.fixed and not action_pane_marked: pane_positions, pane_sizes = self.GetPanePositionsAndSizes(dock) offset = 0 for jj in xrange(dock_pane_count): pane = dock.panes[jj] pane.dock_pos = pane_positions[jj] amount = pane.dock_pos - offset if amount >= 0: offset += amount else: pane.dock_pos += -amount offset += pane_sizes[jj] dock.panes[jj] = pane if oncheck: self._docks[ii] = dock # shrink docks if needed ## docks = self.SmartShrink(docks, AUI_DOCK_TOP) ## docks = self.SmartShrink(docks, AUI_DOCK_LEFT) if oncheck: self._docks = docks # discover the maximum dock layer max_layer = 0 dock_count = len(docks) for ii in xrange(dock_count): max_layer = max(max_layer, docks[ii].dock_layer) # clear out uiparts uiparts = [] # create a bunch of box sizers, # from the innermost level outwards. cont = None middle = None if oncheck: docks = self._docks for layer in xrange(max_layer+1): # find any docks in this layer arr = FindDocks(docks, -1, layer, -1) # if there aren't any, skip to the next layer if not arr: continue old_cont = cont # create a container which will hold this layer's # docks (top, bottom, left, right) cont = wx.BoxSizer(wx.VERTICAL) # find any top docks in this layer arr = FindDocks(docks, AUI_DOCK_TOP, layer, -1) for row in arr: uiparts = self.LayoutAddDock(cont, row, uiparts, spacer_only) # fill out the middle layer (which consists # of left docks, content area and right docks) middle = wx.BoxSizer(wx.HORIZONTAL) # find any left docks in this layer arr = FindDocks(docks, AUI_DOCK_LEFT, layer, -1) for row in arr: uiparts = self.LayoutAddDock(middle, row, uiparts, spacer_only) # add content dock (or previous layer's sizer # to the middle if not old_cont: # find any center docks arr = FindDocks(docks, AUI_DOCK_CENTER, -1, -1) if arr: for row in arr: uiparts = self.LayoutAddDock(middle, row, uiparts, spacer_only) elif not self._has_maximized: # there are no center docks, add a background area sizer_item = middle.Add((1, 1), 1, wx.EXPAND) part = AuiDockUIPart() part.type = AuiDockUIPart.typeBackground part.pane = None part.dock = None part.button = None part.cont_sizer = middle part.sizer_item = sizer_item uiparts.append(part) else: middle.Add(old_cont, 1, wx.EXPAND) # find any right docks in this layer arr = FindDocks(docks, AUI_DOCK_RIGHT, layer, -1, reverse=True) for row in arr: uiparts = self.LayoutAddDock(middle, row, uiparts, spacer_only) if len(middle.GetChildren()) > 0: cont.Add(middle, 1, wx.EXPAND) # find any bottom docks in this layer arr = FindDocks(docks, AUI_DOCK_BOTTOM, layer, -1, reverse=True) for row in arr: uiparts = self.LayoutAddDock(cont, row, uiparts, spacer_only) if not cont: # no sizer available, because there are no docks, # therefore we will create a simple background area cont = wx.BoxSizer(wx.VERTICAL) sizer_item = cont.Add((1, 1), 1, wx.EXPAND) part = AuiDockUIPart() part.type = AuiDockUIPart.typeBackground part.pane = None part.dock = None part.button = None part.cont_sizer = middle part.sizer_item = sizer_item uiparts.append(part) if oncheck: self._uiparts = uiparts self._docks = docks container.Add(cont, 1, wx.EXPAND) if oncheck: return container else: return container, panes, docks, uiparts
[docs] def SetDockSizeConstraint(self, width_pct, height_pct): """ When a user creates a new dock by dragging a window into a docked position, often times the large size of the window will create a dock that is unwieldly large. L{AuiManager} by default limits the size of any new dock to 1/3 of the window size. For horizontal docks, this would be 1/3 of the window height. For vertical docks, 1/3 of the width. Calling this function will adjust this constraint value. The numbers must be between 0.0 and 1.0. For instance, calling L{SetDockSizeConstraint} with (0.5, 0.5) will cause new docks to be limited to half of the size of the entire managed window. :param `width_pct`: a float number representing the x dock size constraint; :param `width_pct`: a float number representing the y dock size constraint. """ self._dock_constraint_x = max(0.0, min(1.0, width_pct)) self._dock_constraint_y = max(0.0, min(1.0, height_pct))
[docs] def GetDockSizeConstraint(self): """ Returns the current dock constraint values. :see: L{SetDockSizeConstraint} """ return self._dock_constraint_x, self._dock_constraint_y
[docs] def Update(self): """ This method is called after any number of changes are made to any of the managed panes. L{Update} must be invoked after L{AddPane} or L{InsertPane} are called in order to "realize" or "commit" the changes. In addition, any number of changes may be made to L{AuiPaneInfo} structures (retrieved with L{GetPane}), but to realize the changes, L{Update} must be called. This construction allows pane flicker to be avoided by updating the whole layout at one time. """ self._hover_button = None self._action_part = None # destroy floating panes which have been # redocked or are becoming non-floating for p in self._panes: if p.IsFloating() or not p.frame: continue # because the pane is no longer in a floating, we need to # reparent it to self._frame and destroy the floating frame # reduce flicker p.window.SetSize((1, 1)) # the following block is a workaround for bug #1531361 # (see wxWidgets sourceforge page). On wxGTK (only), when # a frame is shown/hidden, a move event unfortunately # also gets fired. Because we may be dragging around # a pane, we need to cancel that action here to prevent # a spurious crash. if self._action_window == p.frame: if self._frame.HasCapture(): self._frame.ReleaseMouse() self._action = actionNone self._action_window = None # hide the frame if p.frame.IsShown(): p.frame.Show(False) if self._action_window == p.frame: self._action_window = None # reparent to self._frame and destroy the pane p.window.Reparent(self._frame) if isinstance(p.window, auibar.AuiToolBar): p.window.SetAuiManager(self) if p.frame: p.frame.SetSizer(None) p.frame.Destroy() p.frame = None # Only the master manager should create/destroy notebooks... if not self._masterManager: self.UpdateNotebook() # delete old sizer first self._frame.SetSizer(None) # create a layout for all of the panes sizer = self.LayoutAll(self._panes, self._docks, self._uiparts, False) # hide or show panes as necessary, # and float panes as necessary pane_count = len(self._panes) for ii in xrange(pane_count): p = self._panes[ii] pFrame = p.frame if p.IsFloating(): if pFrame is None: # we need to create a frame for this # pane, which has recently been floated frame = self.CreateFloatingFrame(self._frame, p) # on MSW and Mac, if the owner desires transparent dragging, and # the dragging is happening right now, then the floating # window should have this style by default if self._action in [actionDragFloatingPane, actionDragToolbarPane] and \ self._agwFlags & AUI_MGR_TRANSPARENT_DRAG: frame.SetTransparent(150) if p.IsToolbar(): bar = p.window if isinstance(bar, auibar.AuiToolBar): bar.SetGripperVisible(False) agwStyle = bar.GetAGWWindowStyleFlag() bar.SetAGWWindowStyleFlag(agwStyle & ~AUI_TB_VERTICAL) bar.Realize() s = p.window.GetMinSize() p.BestSize(s) p.FloatingSize(wx.DefaultSize) frame.SetPaneWindow(p) p.needsTransparency = True p.frame = pFrame = frame if p.IsShown() and not frame.IsShown(): frame.Show() frame.Update() else: # frame already exists, make sure it's position # and size reflect the information in AuiPaneInfo if pFrame.GetPosition() != p.floating_pos or pFrame.GetSize() != p.floating_size: pFrame.SetDimensions(p.floating_pos.x, p.floating_pos.y, p.floating_size.x, p.floating_size.y, wx.SIZE_USE_EXISTING) # update whether the pane is resizable or not style = p.frame.GetWindowStyleFlag() if p.IsFixed(): style &= ~wx.RESIZE_BORDER else: style |= wx.RESIZE_BORDER p.frame.SetWindowStyleFlag(style) if pFrame.IsShown() != p.IsShown(): p.needsTransparency = True pFrame.Show(p.IsShown()) if pFrame.GetTitle() != p.caption: pFrame.SetTitle(p.caption) if p.icon.IsOk(): pFrame.SetIcon(wx.IconFromBitmap(p.icon)) else: if p.IsToolbar(): # self.SwitchToolBarOrientation(p) p.best_size = p.window.GetBestSize() if p.window and not p.IsNotebookPage() and p.window.IsShown() != p.IsShown(): p.window.Show(p.IsShown()) if pFrame and p.needsTransparency: if pFrame.IsShown() and pFrame._transparent != p.transparent: pFrame.SetTransparent(p.transparent) pFrame._transparent = p.transparent p.needsTransparency = False # if "active panes" are no longer allowed, clear # any optionActive values from the pane states if self._agwFlags & AUI_MGR_ALLOW_ACTIVE_PANE == 0: p.state &= ~AuiPaneInfo.optionActive self._panes[ii] = p old_pane_rects = [] pane_count = len(self._panes) for p in self._panes: r = wx.Rect() if p.window and p.IsShown() and p.IsDocked(): r = p.rect old_pane_rects.append(r) # apply the new sizer self._frame.SetSizer(sizer) self._frame.SetAutoLayout(False) self.DoFrameLayout() # now that the frame layout is done, we need to check # the new pane rectangles against the old rectangles that # we saved a few lines above here. If the rectangles have # changed, the corresponding panes must also be updated for ii in xrange(pane_count): p = self._panes[ii] if p.window and p.IsShown() and p.IsDocked(): if p.rect != old_pane_rects[ii]: p.window.Refresh() p.window.Update() if wx.Platform == "__WXMAC__": self._frame.Refresh() else: self.Repaint() if not self._masterManager: e = self.FireEvent(wxEVT_AUI_PERSPECTIVE_CHANGED, None, canVeto=False)
[docs] def UpdateNotebook(self): """ Updates the automatic L{AuiNotebook} in the layout (if any exists). """ # Workout how many notebooks we need. max_notebook = -1 # destroy floating panes which have been # redocked or are becoming non-floating for paneInfo in self._panes: if max_notebook < paneInfo.notebook_id: max_notebook = paneInfo.notebook_id # We are the master of our domain extra_notebook = len(self._notebooks) max_notebook += 1 for i in xrange(extra_notebook, max_notebook): self.CreateNotebook() # Remove pages from notebooks that no-longer belong there ... for nb, notebook in enumerate(self._notebooks): pages = notebook.GetPageCount() pageCounter, allPages = 0, pages # Check each tab ... for page in xrange(pages): if page >= allPages: break window = notebook.GetPage(pageCounter) paneInfo = self.GetPane(window) if paneInfo.IsOk() and paneInfo.notebook_id != nb: notebook.RemovePage(pageCounter) window.Hide() window.Reparent(self._frame) pageCounter -= 1 allPages -= 1 pageCounter += 1 notebook.DoSizing() # Add notebook pages that aren't there already... for paneInfo in self._panes: if paneInfo.IsNotebookPage(): title = (paneInfo.caption == "" and [paneInfo.name] or [paneInfo.caption])[0] notebook = self._notebooks[paneInfo.notebook_id] page_id = notebook.GetPageIndex(paneInfo.window) if page_id < 0: paneInfo.window.Reparent(notebook) notebook.AddPage(paneInfo.window, title, True, paneInfo.icon) # Update title and icon ... else: notebook.SetPageText(page_id, title) notebook.SetPageBitmap(page_id, paneInfo.icon) notebook.DoSizing() # Wire-up newly created notebooks elif paneInfo.IsNotebookControl() and not paneInfo.window: paneInfo.window = self._notebooks[paneInfo.notebook_id] # Delete empty notebooks, and convert notebooks with 1 page to # normal panes... remap_ids = [-1]*len(self._notebooks) nb_idx = 0 for nb, notebook in enumerate(self._notebooks): if notebook.GetPageCount() == 1: # Convert notebook page to pane... window = notebook.GetPage(0) child_pane = self.GetPane(window) notebook_pane = self.GetPane(notebook) if child_pane.IsOk() and notebook_pane.IsOk(): child_pane.SetDockPos(notebook_pane) child_pane.window.Hide() child_pane.window.Reparent(self._frame) child_pane.frame = None child_pane.notebook_id = -1 if notebook_pane.IsFloating(): child_pane.Float() self.DetachPane(notebook) notebook.RemovePage(0) notebook.Destroy() else: raise Exception("Odd notebook docking") elif notebook.GetPageCount() == 0: self.DetachPane(notebook) notebook.Destroy() else: # Correct page ordering. The original wxPython code # for this did not work properly, and would misplace # windows causing errors. notebook.Freeze() self._notebooks[nb_idx] = notebook pages = notebook.GetPageCount() selected = notebook.GetPage(notebook.GetSelection()) # Take each page out of the notebook, group it with # its current pane, and sort the list by pane.dock_pos # order pages_and_panes = [] for idx in reversed(range(pages)): page = notebook.GetPage(idx) pane = self.GetPane(page) pages_and_panes.append((page, pane)) notebook.RemovePage(idx) sorted_pnp = sorted(pages_and_panes, key=lambda tup: tup[1].dock_pos) # Grab the attributes from the panes which are ordered # correctly, and copy those attributes to the original # panes. (This avoids having to change the ordering # of self._panes) Then, add the page back into the notebook sorted_attributes = [self.GetAttributes(tup[1]) for tup in sorted_pnp] for attrs, tup in zip(sorted_attributes, pages_and_panes): pane = tup[1] self.SetAttributes(pane, attrs) notebook.AddPage(pane.window, pane.caption) notebook.SetSelection(notebook.GetPageIndex(selected), True) notebook.DoSizing() notebook.Thaw() # It's a keeper. remap_ids[nb] = nb_idx nb_idx += 1 # Apply remap... nb_count = len(self._notebooks) if nb_count != nb_idx: self._notebooks = self._notebooks[0:nb_idx] for p in self._panes: if p.notebook_id >= 0: p.notebook_id = remap_ids[p.notebook_id] if p.IsNotebookControl(): p.SetNameFromNotebookId() # Make sure buttons are correct ... for notebook in self._notebooks: want_max = True want_min = True want_close = True pages = notebook.GetPageCount() for page in xrange(pages): win = notebook.GetPage(page) pane = self.GetPane(win) if pane.IsOk(): if not pane.HasCloseButton(): want_close = False if not pane.HasMaximizeButton(): want_max = False if not pane.HasMinimizeButton(): want_min = False notebook_pane = self.GetPane(notebook) if notebook_pane.IsOk(): if notebook_pane.HasMinimizeButton() != want_min: if want_min: button = AuiPaneButton(AUI_BUTTON_MINIMIZE) notebook_pane.state |= AuiPaneInfo.buttonMinimize notebook_pane.buttons.append(button) # todo: remove min/max if notebook_pane.HasMaximizeButton() != want_max: if want_max: button = AuiPaneButton(AUI_BUTTON_MAXIMIZE_RESTORE) notebook_pane.state |= AuiPaneInfo.buttonMaximize notebook_pane.buttons.append(button) # todo: remove min/max if notebook_pane.HasCloseButton() != want_close: if want_close: button = AuiPaneButton(AUI_BUTTON_CLOSE) notebook_pane.state |= AuiPaneInfo.buttonClose notebook_pane.buttons.append(button) # todo: remove close
[docs] def SmartShrink(self, docks, direction): """ Used to intelligently shrink the docks' size (if needed). :param `docks`: a list of L{AuiDockInfo} instances; :param `direction`: the direction in which to shrink. """ sashSize = self._art.GetMetric(AUI_DOCKART_SASH_SIZE) caption_size = self._art.GetMetric(AUI_DOCKART_CAPTION_SIZE) clientSize = self._frame.GetClientSize() ourDocks = FindDocks(docks, direction, -1, -1) oppositeDocks = FindOppositeDocks(docks, direction) oppositeSize = self.GetOppositeDockTotalSize(docks, direction) ourSize = 0 for dock in ourDocks: ourSize += dock.size if not dock.toolbar: ourSize += sashSize shrinkSize = ourSize + oppositeSize if direction == AUI_DOCK_TOP or direction == AUI_DOCK_BOTTOM: shrinkSize -= clientSize.y else: shrinkSize -= clientSize.x if shrinkSize <= 0: return docks # Combine arrays for dock in oppositeDocks: ourDocks.append(dock) oppositeDocks = [] for dock in ourDocks: if dock.toolbar or not dock.resizable: continue dockRange = dock.size - dock.min_size if dock.min_size == 0: dockRange -= sashSize if direction == AUI_DOCK_TOP or direction == AUI_DOCK_BOTTOM: dockRange -= caption_size if dockRange >= shrinkSize: dock.size -= shrinkSize return docks else: dock.size -= dockRange shrinkSize -= dockRange return docks
[docs] def UpdateDockingGuides(self, paneInfo): """ Updates the docking guide windows positions and appearance. :param `paneInfo`: a L{AuiPaneInfo} instance. """ if len(self._guides) == 0: self.CreateGuideWindows() captionSize = self._art.GetMetric(AUI_DOCKART_CAPTION_SIZE) frameRect = GetInternalFrameRect(self._frame, self._docks) mousePos = wx.GetMousePosition() for indx, guide in enumerate(self._guides): pt = wx.Point() guide_size = guide.host.GetSize() if not guide.host: raise Exception("Invalid docking host") direction = guide.dock_direction if direction == AUI_DOCK_LEFT: pt.x = frameRect.x + guide_size.x / 2 + 16 pt.y = frameRect.y + frameRect.height / 2 elif direction == AUI_DOCK_TOP: pt.x = frameRect.x + frameRect.width / 2 pt.y = frameRect.y + guide_size.y / 2 + 16 elif direction == AUI_DOCK_RIGHT: pt.x = frameRect.x + frameRect.width - guide_size.x / 2 - 16 pt.y = frameRect.y + frameRect.height / 2 elif direction == AUI_DOCK_BOTTOM: pt.x = frameRect.x + frameRect.width / 2 pt.y = frameRect.y + frameRect.height - guide_size.y / 2 - 16 elif direction == AUI_DOCK_CENTER: rc = paneInfo.window.GetScreenRect() pt.x = rc.x + rc.width / 2 pt.y = rc.y + rc.height / 2 if paneInfo.HasCaption(): pt.y -= captionSize / 2 elif paneInfo.HasCaptionLeft(): pt.x -= captionSize / 2 # guide will be centered around point 'pt' targetPosition = wx.Point(pt.x - guide_size.x / 2, pt.y - guide_size.y / 2) if guide.host.GetPosition() != targetPosition: guide.host.Move(targetPosition) guide.host.AeroMove(targetPosition) if guide.dock_direction == AUI_DOCK_CENTER: guide.host.ValidateNotebookDocking(paneInfo.IsNotebookDockable()) guide.host.UpdateDockGuide(mousePos) paneInfo.window.Lower()
[docs] def DoFrameLayout(self): """ This is an internal function which invokes `wx.Sizer.Layout` on the frame's main sizer, then measures all the various UI items and updates their internal rectangles. :note: This should always be called instead of calling `self._managed_window.Layout()` directly. """ self._frame.Layout() for part in self._uiparts: # get the rectangle of the UI part # originally, this code looked like this: # part.rect = wx.Rect(part.sizer_item.GetPosition(), # part.sizer_item.GetSize()) # this worked quite well, with one exception: the mdi # client window had a "deferred" size variable # that returned the wrong size. It looks like # a bug in wx, because the former size of the window # was being returned. So, we will retrieve the part's # rectangle via other means part.rect = part.sizer_item.GetRect() flag = part.sizer_item.GetFlag() border = part.sizer_item.GetBorder() if flag & wx.TOP: part.rect.y -= border part.rect.height += border if flag & wx.LEFT: part.rect.x -= border part.rect.width += border if flag & wx.BOTTOM: part.rect.height += border if flag & wx.RIGHT: part.rect.width += border if part.type == AuiDockUIPart.typeDock: part.dock.rect = part.rect if part.type == AuiDockUIPart.typePane: part.pane.rect = part.rect
[docs] def GetPanePart(self, wnd): """ Looks up the pane border UI part of the pane specified. This allows the caller to get the exact rectangle of the pane in question, including decorations like caption and border. :param `wnd`: the window to which the pane border belongs to. """ for part in self._uiparts: if part.type == AuiDockUIPart.typePaneBorder and \ part.pane and part.pane.window == wnd: return part for part in self._uiparts: if part.type == AuiDockUIPart.typePane and \ part.pane and part.pane.window == wnd: return part return None
[docs] def GetDockPixelOffset(self, test): """ This is an internal function which returns a dock's offset in pixels from the left side of the window (for horizontal docks) or from the top of the window (for vertical docks). This value is necessary for calculating fixed-pane/toolbar offsets when they are dragged. :param `test`: a fake L{AuiPaneInfo} for testing purposes. """ # the only way to accurately calculate the dock's # offset is to actually run a theoretical layout docks, panes = CopyDocksAndPanes2(self._docks, self._panes) panes.append(test) sizer, panes, docks, uiparts = self.LayoutAll(panes, docks, [], True, False) client_size = self._frame.GetClientSize() sizer.SetDimension(0, 0, client_size.x, client_size.y) sizer.Layout() for part in uiparts: pos = part.sizer_item.GetPosition() size = part.sizer_item.GetSize() part.rect = wx.RectPS(pos, size) if part.type == AuiDockUIPart.typeDock: part.dock.rect = part.rect sizer.Destroy() for dock in docks: if test.dock_direction == dock.dock_direction and \ test.dock_layer == dock.dock_layer and \ test.dock_row == dock.dock_row: if dock.IsVertical(): return dock.rect.y else: return dock.rect.x return 0
[docs] def GetPartnerDock(self, dock): """ Returns the partner dock for the input dock. :param `dock`: a L{AuiDockInfo} instance. """ for layer in xrange(dock.dock_layer, -1, -1): bestDock = None for tmpDock in self._docks: if tmpDock.dock_layer != layer: continue if tmpDock.dock_direction != dock.dock_direction: continue if tmpDock.dock_layer < dock.dock_layer: if not bestDock or tmpDock.dock_row < bestDock.dock_row: bestDock = tmpDock elif tmpDock.dock_row > dock.dock_row: if not bestDock or tmpDock.dock_row > bestDock.dock_row: bestDock = tmpDock if bestDock: return bestDock return None
[docs] def GetPartnerPane(self, dock, pane): """ Returns the partner pane for the input pane. They both need to live in the same L{AuiDockInfo}. :param `dock`: a L{AuiDockInfo} instance; :param `pane`: a L{AuiPaneInfo} class. """ panePosition = -1 for i, tmpPane in enumerate(dock.panes): if tmpPane.window == pane.window: panePosition = i elif not tmpPane.IsFixed() and panePosition != -1: return tmpPane return None
[docs] def GetTotalPixSizeAndProportion(self, dock): """ Returns the dimensions and proportion of the input dock. :param `dock`: the L{AuiDockInfo} structure to analyze. """ totalPixsize = 0 totalProportion = 0 # determine the total proportion of all resizable panes, # and the total size of the dock minus the size of all # the fixed panes for tmpPane in dock.panes: if tmpPane.IsFixed(): continue totalProportion += tmpPane.dock_proportion if dock.IsHorizontal(): totalPixsize += tmpPane.rect.width else: totalPixsize += tmpPane.rect.height ## if tmpPane.min_size.IsFullySpecified(): ## ## if dock.IsHorizontal(): ## totalPixsize -= tmpPane.min_size.x ## else: ## totalPixsize -= tmpPane.min_size.y return totalPixsize, totalProportion
[docs] def GetOppositeDockTotalSize(self, docks, direction): """ Returns the dimensions of the dock which lives opposite of the input dock. :param `docks`: a list of L{AuiDockInfo} structures to analyze; :param `direction`: the direction in which to look for the opposite dock. """ sash_size = self._art.GetMetric(AUI_DOCKART_SASH_SIZE) caption_size = self._art.GetMetric(AUI_DOCKART_CAPTION_SIZE) pane_border_size = self._art.GetMetric(AUI_DOCKART_PANE_BORDER_SIZE) minSizeMax = 0 result = sash_size vertical = False if direction in [AUI_DOCK_TOP, AUI_DOCK_BOTTOM]: vertical = True # Get minimum size of the most inner area for tmpDock in docks: if tmpDock.dock_layer != 0: continue if tmpDock.dock_direction != AUI_DOCK_CENTER and tmpDock.IsVertical() != vertical: continue for tmpPane in tmpDock.panes: minSize = pane_border_size*2 - sash_size if vertical: minSize += tmpPane.min_size.y + caption_size else: minSize += tmpPane.min_size.x if minSize > minSizeMax: minSizeMax = minSize result += minSizeMax # Get opposite docks oppositeDocks = FindOppositeDocks(docks, direction) # Sum size of the opposite docks and their sashes for dock in oppositeDocks: result += dock.size # if it's not a toolbar add the sash_size too if not dock.toolbar: result += sash_size return result
[docs] def CalculateDockSizerLimits(self, dock): """ Calculates the minimum and maximum sizes allowed for the input dock. :param `dock`: the L{AuiDockInfo} structure to analyze. """ docks, panes = CopyDocksAndPanes2(self._docks, self._panes) sash_size = self._art.GetMetric(AUI_DOCKART_SASH_SIZE) caption_size = self._art.GetMetric(AUI_DOCKART_CAPTION_SIZE) opposite_size = self.GetOppositeDockTotalSize(docks, dock.dock_direction) for tmpDock in docks: if tmpDock.dock_direction == dock.dock_direction and \ tmpDock.dock_layer == dock.dock_layer and \ tmpDock.dock_row == dock.dock_row: tmpDock.size = 1 break sizer, panes, docks, uiparts = self.LayoutAll(panes, docks, [], True, False) client_size = self._frame.GetClientSize() sizer.SetDimension(0, 0, client_size.x, client_size.y) sizer.Layout() for part in uiparts: part.rect = wx.RectPS(part.sizer_item.GetPosition(), part.sizer_item.GetSize()) if part.type == AuiDockUIPart.typeDock: part.dock.rect = part.rect sizer.Destroy() new_dock = None for tmpDock in docks: if tmpDock.dock_direction == dock.dock_direction and \ tmpDock.dock_layer == dock.dock_layer and \ tmpDock.dock_row == dock.dock_row: new_dock = tmpDock break partnerDock = self.GetPartnerDock(dock) if partnerDock: partnerRange = partnerDock.size - partnerDock.min_size if partnerDock.min_size == 0: partnerRange -= sash_size if dock.IsHorizontal(): partnerRange -= caption_size direction = dock.dock_direction if direction == AUI_DOCK_LEFT: minPix = new_dock.rect.x + new_dock.rect.width maxPix = dock.rect.x + dock.rect.width maxPix += partnerRange elif direction == AUI_DOCK_TOP: minPix = new_dock.rect.y + new_dock.rect.height maxPix = dock.rect.y + dock.rect.height maxPix += partnerRange elif direction == AUI_DOCK_RIGHT: minPix = dock.rect.x - partnerRange - sash_size maxPix = new_dock.rect.x - sash_size elif direction == AUI_DOCK_BOTTOM: minPix = dock.rect.y - partnerRange - sash_size maxPix = new_dock.rect.y - sash_size return minPix, maxPix direction = new_dock.dock_direction if direction == AUI_DOCK_LEFT: minPix = new_dock.rect.x + new_dock.rect.width maxPix = client_size.x - opposite_size - sash_size elif direction == AUI_DOCK_TOP: minPix = new_dock.rect.y + new_dock.rect.height maxPix = client_size.y - opposite_size - sash_size elif direction == AUI_DOCK_RIGHT: minPix = opposite_size maxPix = new_dock.rect.x - sash_size elif direction == AUI_DOCK_BOTTOM: minPix = opposite_size maxPix = new_dock.rect.y - sash_size return minPix, maxPix
[docs] def CalculatePaneSizerLimits(self, dock, pane): """ Calculates the minimum and maximum sizes allowed for the input pane. :param `dock`: the L{AuiDockInfo} structure to which `pane` belongs to; :param `pane`: a L{AuiPaneInfo} class for which calculation are requested. """ if pane.IsFixed(): if dock.IsHorizontal(): minPix = maxPix = pane.rect.x + 1 + pane.rect.width else: minPix = maxPix = pane.rect.y + 1 + pane.rect.height return minPix, maxPix totalPixsize, totalProportion = self.GetTotalPixSizeAndProportion(dock) partnerPane = self.GetPartnerPane(dock, pane) if dock.IsHorizontal(): minPix = pane.rect.x + 1 maxPix = pane.rect.x + 1 + pane.rect.width if pane.min_size.IsFullySpecified(): minPix += pane.min_size.x else: minPix += 1 if partnerPane: maxPix += partnerPane.rect.width if partnerPane.min_size.IsFullySpecified(): maxPix -= partnerPane.min_size.x - 1 else: minPix = maxPix else: minPix = pane.rect.y + 1 maxPix = pane.rect.y + 1 + pane.rect.height if pane.min_size.IsFullySpecified(): minPix += pane.min_size.y else: minPix += 1 if partnerPane: maxPix += partnerPane.rect.height if partnerPane.min_size.IsFullySpecified(): maxPix -= partnerPane.min_size.y - 1 else: minPix = maxPix return minPix, maxPix
[docs] def CheckMovableSizer(self, part): """ Checks if a UI part can be actually resized. :param `part`: a UI part. """ # a dock may not be resized if it has a single # pane which is not resizable if part.type == AuiDockUIPart.typeDockSizer and part.dock and \ len(part.dock.panes) == 1 and part.dock.panes[0].IsFixed(): return False if part.pane: # panes that may not be resized should be ignored here minPix, maxPix = self.CalculatePaneSizerLimits(part.dock, part.pane) if minPix == maxPix: return False return True
[docs] def PaneFromTabEvent(self, event): """ Returns a L{AuiPaneInfo} from a L{AuiNotebookEvent} event. :param `event`: a L{AuiNotebookEvent} event. """ obj = event.GetEventObject() if obj and isinstance(obj, auibook.AuiTabCtrl): page_idx = obj.GetActivePage() if page_idx >= 0: page = obj.GetPage(page_idx) window = page.window if window: return self.GetPane(window) elif obj and isinstance(obj, auibook.AuiNotebook): page_idx = event.GetSelection() if page_idx >= 0: window = obj.GetPage(page_idx) if window: return self.GetPane(window) return NonePaneInfo
[docs] def OnTabBeginDrag(self, event): """ Handles the ``EVT_AUINOTEBOOK_BEGIN_DRAG`` event. :param `event`: a L{AuiNotebookEvent} event to be processed. """ if self._masterManager: self._masterManager.OnTabBeginDrag(event) else: paneInfo = self.PaneFromTabEvent(event) if paneInfo.IsOk(): # It's one of ours! self._action = actionDragFloatingPane mouse = wx.GetMousePosition() # set initial float position - may have to think about this # offset a bit more later ... self._action_offset = wx.Point(20, 10) self._toolbar_action_offset = wx.Point(20, 10) paneInfo.floating_pos = mouse - self._action_offset paneInfo.dock_pos = AUI_DOCK_NONE paneInfo.notebook_id = -1 tab = event.GetEventObject() if tab.HasCapture(): tab.ReleaseMouse() # float the window if paneInfo.IsMaximized(): self.RestorePane(paneInfo) paneInfo.Float() self.Update() self._action_window = paneInfo.window self._frame.CaptureMouse() event.SetDispatched(True) else: # not our window event.Skip()
[docs] def OnTabPageClose(self, event): """ Handles the ``EVT_AUINOTEBOOK_PAGE_CLOSE`` event. :param `event`: a L{AuiNotebookEvent} event to be processed. """ if self._masterManager: self._masterManager.OnTabPageClose(event) else: p = self.PaneFromTabEvent(event) if p.IsOk(): # veto it because we will call "RemovePage" ourselves event.Veto() # Now ask the app if they really want to close... # fire pane close event e = AuiManagerEvent(wxEVT_AUI_PANE_CLOSE) e.SetPane(p) e.SetCanVeto(True) self.ProcessMgrEvent(e) if e.GetVeto(): return self.ClosePane(p) self.Update() else: event.Skip()
[docs] def OnTabSelected(self, event): """ Handles the ``EVT_AUINOTEBOOK_PAGE_CHANGED`` event. :param `event`: a L{AuiNotebookEvent} event to be processed. """ if self._masterManager: self._masterManager.OnTabSelected(event) return obj = event.GetEventObject() if obj and isinstance(obj, auibook.AuiNotebook): notebook = obj page = notebook.GetPage(event.GetSelection()) paneInfo = self.GetPane(page) if paneInfo.IsOk(): notebookRoot = GetNotebookRoot(self._panes, paneInfo.notebook_id) if notebookRoot: notebookRoot.Caption(paneInfo.caption) self.RefreshCaptions() event.Skip()
[docs] def GetNotebooks(self): """ Returns all the automatic L{AuiNotebook} in the L{AuiManager}. """ if self._masterManager: return self._masterManager.GetNotebooks() return self._notebooks
[docs] def SetMasterManager(self, manager): """ Sets the master manager for an automatic L{AuiNotebook}. :param `manager`: an instance of L{AuiManager}. """ self._masterManager = manager
[docs] def ProcessDockResult(self, target, new_pos): """ This is a utility function used by L{DoDrop} - it checks if a dock operation is allowed, the new dock position is copied into the target info. If the operation was allowed, the function returns ``True``. :param `target`: the L{AuiPaneInfo} instance to be docked; :param `new_pos`: the new docking position if the docking operation is allowed. """ allowed = False direction = new_pos.dock_direction if direction == AUI_DOCK_TOP: allowed = target.IsTopDockable() elif direction == AUI_DOCK_BOTTOM: allowed = target.IsBottomDockable() elif direction == AUI_DOCK_LEFT: allowed = target.IsLeftDockable() elif direction == AUI_DOCK_RIGHT: allowed = target.IsRightDockable() if allowed: target = new_pos if target.IsToolbar(): self.SwitchToolBarOrientation(target) return allowed, target
[docs] def SwitchToolBarOrientation(self, pane): """ Switches the toolbar orientation from vertical to horizontal and vice-versa. This is especially useful for vertical docked toolbars once they float. :param `pane`: an instance of L{AuiPaneInfo}, which may have a L{AuiToolBar} window associated with it. """ if not isinstance(pane.window, auibar.AuiToolBar): return pane if pane.IsFloating(): return pane toolBar = pane.window direction = pane.dock_direction vertical = direction in [AUI_DOCK_LEFT, AUI_DOCK_RIGHT] agwStyle = toolBar.GetAGWWindowStyleFlag() new_agwStyle = agwStyle if vertical: new_agwStyle |= AUI_TB_VERTICAL else: new_agwStyle &= ~(AUI_TB_VERTICAL) if agwStyle != new_agwStyle: toolBar.SetAGWWindowStyleFlag(new_agwStyle) if not toolBar.GetGripperVisible(): toolBar.SetGripperVisible(True) s = pane.window.GetMinSize() pane.BestSize(s) if new_agwStyle != agwStyle: toolBar.Realize() return pane
[docs] def DoDrop(self, docks, panes, target, pt, offset=wx.Point(0, 0)): """ This is an important function. It basically takes a mouse position, and determines where the panes new position would be. If the pane is to be dropped, it performs the drop operation using the specified dock and pane arrays. By specifying copy dock and pane arrays when calling, a "what-if" scenario can be performed, giving precise coordinates for drop hints. :param `docks`: a list of L{AuiDockInfo} classes; :param `panes`: a list of L{AuiPaneInfo} instances; :param `pt`: a mouse position to check for a drop operation; :param `offset`: a possible offset from the input point `pt`. """ if target.IsToolbar(): return self.DoDropToolbar(docks, panes, target, pt, offset) elif target.IsFloating(): return self.DoDropFloatingPane(docks, panes, target, pt) else: return self.DoDropNonFloatingPane(docks, panes, target, pt)
[docs] def CopyTarget(self, target): """ Copies all the attributes of the input `target` into another L{AuiPaneInfo}. :param `target`: the source L{AuiPaneInfo} from where to copy attributes. """ drop = AuiPaneInfo() drop.name = target.name drop.caption = target.caption drop.window = target.window drop.frame = target.frame drop.state = target.state drop.dock_direction = target.dock_direction drop.dock_layer = target.dock_layer drop.dock_row = target.dock_row drop.dock_pos = target.dock_pos drop.best_size = wx.Size(*target.best_size) drop.min_size = wx.Size(*target.min_size) drop.max_size = wx.Size(*target.max_size) drop.floating_pos = wx.Point(*target.floating_pos) drop.floating_size = wx.Size(*target.floating_size) drop.dock_proportion = target.dock_proportion drop.buttons = target.buttons drop.rect = wx.Rect(*target.rect) drop.icon = target.icon drop.notebook_id = target.notebook_id drop.transparent = target.transparent drop.snapped = target.snapped drop.minimize_mode = target.minimize_mode drop.minimize_target = target.minimize_target return drop
[docs] def DoDropToolbar(self, docks, panes, target, pt, offset): """ Handles the situation in which the dropped pane contains a toolbar. :param `docks`: a list of L{AuiDockInfo} classes; :param `panes`: a list of L{AuiPaneInfo} instances; :param `target`: the target pane containing the toolbar; :param `pt`: a mouse position to check for a drop operation; :param `offset`: a possible offset from the input point `pt`. """ drop = self.CopyTarget(target) # The result should always be shown drop.Show() # Check to see if the toolbar has been dragged out of the window if CheckOutOfWindow(self._frame, pt): if self._agwFlags & AUI_MGR_ALLOW_FLOATING and drop.IsFloatable(): drop.Float() return self.ProcessDockResult(target, drop) # Allow directional change when the cursor leaves this rect safeRect = wx.Rect(*target.rect) if target.IsHorizontal(): safeRect.Inflate(100, 50) else: safeRect.Inflate(50, 100) # Check to see if the toolbar has been dragged to edge of the frame dropDir = CheckEdgeDrop(self._frame, docks, pt) if dropDir != -1: if dropDir == wx.LEFT: drop.Dock().Left().Layer(auiToolBarLayer).Row(0). \ Position(pt.y - self.GetDockPixelOffset(drop) - offset.y) elif dropDir == wx.RIGHT: drop.Dock().Right().Layer(auiToolBarLayer).Row(0). \ Position(pt.y - self.GetDockPixelOffset(drop) - offset.y) elif dropDir == wx.TOP: drop.Dock().Top().Layer(auiToolBarLayer).Row(0). \ Position(pt.x - self.GetDockPixelOffset(drop) - offset.x) elif dropDir == wx.BOTTOM: drop.Dock().Bottom().Layer(auiToolBarLayer).Row(0). \ Position(pt.x - self.GetDockPixelOffset(drop) - offset.x) if not target.IsFloating() and safeRect.Contains(pt) and \ target.dock_direction != drop.dock_direction: return False, target return self.ProcessDockResult(target, drop) # If the windows is floating and out of the client area, do nothing if drop.IsFloating() and not self._frame.GetClientRect().Contains(pt): return False, target # Ok, can't drop on edge - check internals ... clientSize = self._frame.GetClientSize() x = Clip(pt.x, 0, clientSize.x - 1) y = Clip(pt.y, 0, clientSize.y - 1) part = self.HitTest(x, y) if not part or not part.dock: return False, target dock = part.dock # toolbars may only be moved in and to fixed-pane docks, # otherwise we will try to float the pane. Also, the pane # should float if being dragged over center pane windows if not dock.fixed or dock.dock_direction == AUI_DOCK_CENTER: if (self._agwFlags & AUI_MGR_ALLOW_FLOATING and drop.IsFloatable()) or \ dock.dock_direction not in [AUI_DOCK_CENTER, AUI_DOCK_NONE]: if drop.IsFloatable(): drop.Float() return self.ProcessDockResult(target, drop) # calculate the offset from where the dock begins # to the point where the user dropped the pane dockDropOffset = 0 if dock.IsHorizontal(): dockDropOffset = pt.x - dock.rect.x - offset.x else: dockDropOffset = pt.y - dock.rect.y - offset.y drop.Dock().Direction(dock.dock_direction).Layer(dock.dock_layer). \ Row(dock.dock_row).Position(dockDropOffset) if (pt.y <= dock.rect.GetTop() + 2 and dock.IsHorizontal()) or \ (pt.x <= dock.rect.GetLeft() + 2 and dock.IsVertical()): if dock.dock_direction in [AUI_DOCK_TOP, AUI_DOCK_LEFT]: row = drop.dock_row panes = DoInsertDockRow(panes, dock.dock_direction, dock.dock_layer, dock.dock_row) drop.dock_row = row else: panes = DoInsertDockRow(panes, dock.dock_direction, dock.dock_layer, dock.dock_row+1) drop.dock_row = dock.dock_row + 1 if (pt.y >= dock.rect.GetBottom() - 2 and dock.IsHorizontal()) or \ (pt.x >= dock.rect.GetRight() - 2 and dock.IsVertical()): if dock.dock_direction in [AUI_DOCK_TOP, AUI_DOCK_LEFT]: panes = DoInsertDockRow(panes, dock.dock_direction, dock.dock_layer, dock.dock_row+1) drop.dock_row = dock.dock_row+1 else: row = drop.dock_row panes = DoInsertDockRow(panes, dock.dock_direction, dock.dock_layer, dock.dock_row) drop.dock_row = row if not target.IsFloating() and safeRect.Contains(pt) and \ target.dock_direction != drop.dock_direction: return False, target return self.ProcessDockResult(target, drop)
[docs] def DoDropFloatingPane(self, docks, panes, target, pt): """ Handles the situation in which the dropped pane contains a normal window. :param `docks`: a list of L{AuiDockInfo} classes; :param `panes`: a list of L{AuiPaneInfo} instances; :param `target`: the target pane containing the window; :param `pt`: a mouse position to check for a drop operation. """ screenPt = self._frame.ClientToScreen(pt) paneInfo = self.PaneHitTest(panes, pt) if paneInfo.IsMaximized(): return False, target if paneInfo.window is None: return False, target # search the dock guides. # reverse order to handle the center first. for i in xrange(len(self._guides)-1, -1, -1): guide = self._guides[i] # do hit testing on the guide dir = guide.host.HitTest(screenPt.x, screenPt.y) if dir == -1: # point was outside of the dock guide continue if dir == wx.ALL: # target is a single dock guide return self.DoDropLayer(docks, target, guide.dock_direction) elif dir == wx.CENTER: if not target.IsNotebookDockable(): continue if not paneInfo.IsNotebookDockable() and not paneInfo.IsNotebookControl(): continue if not paneInfo.HasNotebook(): # Add a new notebook pane with the original as a tab... self.CreateNotebookBase(panes, paneInfo) # Add new item to notebook target.NotebookPage(paneInfo.notebook_id) else: drop_pane = False drop_row = False insert_dir = paneInfo.dock_direction insert_layer = paneInfo.dock_layer insert_row = paneInfo.dock_row insert_pos = paneInfo.dock_pos if insert_dir == AUI_DOCK_CENTER: insert_layer = 0 if dir == wx.LEFT: insert_dir = AUI_DOCK_LEFT elif dir == wx.UP: insert_dir = AUI_DOCK_TOP elif dir == wx.RIGHT: insert_dir = AUI_DOCK_RIGHT elif dir == wx.DOWN: insert_dir = AUI_DOCK_BOTTOM if insert_dir == AUI_DOCK_LEFT: drop_pane = (dir == wx.UP or dir == wx.DOWN) drop_row = (dir == wx.LEFT or dir == wx.RIGHT) if dir == wx.RIGHT: insert_row += 1 elif dir == wx.DOWN: insert_pos += 1 elif insert_dir == AUI_DOCK_RIGHT: drop_pane = (dir == wx.UP or dir == wx.DOWN) drop_row = (dir == wx.LEFT or dir == wx.RIGHT) if dir == wx.LEFT: insert_row += 1 elif dir == wx.DOWN: insert_pos += 1 elif insert_dir == AUI_DOCK_TOP: drop_pane = (dir == wx.LEFT or dir == wx.RIGHT) drop_row = (dir == wx.UP or dir == wx.DOWN) if dir == wx.DOWN: insert_row += 1 elif dir == wx.RIGHT: insert_pos += 1 elif insert_dir == AUI_DOCK_BOTTOM: drop_pane = (dir == wx.LEFT or dir == wx.RIGHT) drop_row = (dir == wx.UP or dir == wx.DOWN) if dir == wx.UP: insert_row += 1 elif dir == wx.RIGHT: insert_pos += 1 if paneInfo.dock_direction == AUI_DOCK_CENTER: insert_row = GetMaxRow(panes, insert_dir, insert_layer) + 1 if drop_pane: return self.DoDropPane(panes, target, insert_dir, insert_layer, insert_row, insert_pos) if drop_row: return self.DoDropRow(panes, target, insert_dir, insert_layer, insert_row) return True, target return False, target
[docs] def DoDropNonFloatingPane(self, docks, panes, target, pt): """ Handles the situation in which the dropped pane is not floating. :param `docks`: a list of L{AuiDockInfo} classes; :param `panes`: a list of L{AuiPaneInfo} instances; :param `target`: the target pane containing the toolbar; :param `pt`: a mouse position to check for a drop operation. """ screenPt = self._frame.ClientToScreen(pt) clientSize = self._frame.GetClientSize() frameRect = GetInternalFrameRect(self._frame, self._docks) drop = self.CopyTarget(target) # The result should always be shown drop.Show() part = self.HitTest(pt.x, pt.y) if not part: return False, target if part.type == AuiDockUIPart.typeDockSizer: if len(part.dock.panes) != 1: return False, target part = self.GetPanePart(part.dock.panes[0].window) if not part: return False, target if not part.pane: return False, target part = self.GetPanePart(part.pane.window) if not part: return False, target insert_dock_row = False insert_row = part.pane.dock_row insert_dir = part.pane.dock_direction insert_layer = part.pane.dock_layer direction = part.pane.dock_direction if direction == AUI_DOCK_TOP: if pt.y >= part.rect.y and pt.y < part.rect.y+auiInsertRowPixels: insert_dock_row = True elif direction == AUI_DOCK_BOTTOM: if pt.y > part.rect.y+part.rect.height-auiInsertRowPixels and \ pt.y <= part.rect.y + part.rect.height: insert_dock_row = True elif direction == AUI_DOCK_LEFT: if pt.x >= part.rect.x and pt.x < part.rect.x+auiInsertRowPixels: insert_dock_row = True elif direction == AUI_DOCK_RIGHT: if pt.x > part.rect.x+part.rect.width-auiInsertRowPixels and \ pt.x <= part.rect.x+part.rect.width: insert_dock_row = True elif direction == AUI_DOCK_CENTER: # "new row pixels" will be set to the default, but # must never exceed 20% of the window size new_row_pixels_x = auiNewRowPixels new_row_pixels_y = auiNewRowPixels if new_row_pixels_x > (part.rect.width*20)/100: new_row_pixels_x = (part.rect.width*20)/100 if new_row_pixels_y > (part.rect.height*20)/100: new_row_pixels_y = (part.rect.height*20)/100 # determine if the mouse pointer is in a location that # will cause a new row to be inserted. The hot spot positions # are along the borders of the center pane insert_layer = 0 insert_dock_row = True pr = part.rect if pt.x >= pr.x and pt.x < pr.x + new_row_pixels_x: insert_dir = AUI_DOCK_LEFT elif pt.y >= pr.y and pt.y < pr.y + new_row_pixels_y: insert_dir = AUI_DOCK_TOP elif pt.x >= pr.x + pr.width - new_row_pixels_x and pt.x < pr.x + pr.width: insert_dir = AUI_DOCK_RIGHT elif pt.y >= pr.y+ pr.height - new_row_pixels_y and pt.y < pr.y + pr.height: insert_dir = AUI_DOCK_BOTTOM else: return False, target insert_row = GetMaxRow(panes, insert_dir, insert_layer) + 1 if insert_dock_row: panes = DoInsertDockRow(panes, insert_dir, insert_layer, insert_row) drop.Dock().Direction(insert_dir).Layer(insert_layer). \ Row(insert_row).Position(0) return self.ProcessDockResult(target, drop) # determine the mouse offset and the pane size, both in the # direction of the dock itself, and perpendicular to the dock if part.orientation == wx.VERTICAL: offset = pt.y - part.rect.y size = part.rect.GetHeight() else: offset = pt.x - part.rect.x size = part.rect.GetWidth() drop_position = part.pane.dock_pos # if we are in the top/left part of the pane, # insert the pane before the pane being hovered over if offset <= size/2: drop_position = part.pane.dock_pos panes = DoInsertPane(panes, part.pane.dock_direction, part.pane.dock_layer, part.pane.dock_row, part.pane.dock_pos) # if we are in the bottom/right part of the pane, # insert the pane before the pane being hovered over if offset > size/2: drop_position = part.pane.dock_pos+1 panes = DoInsertPane(panes, part.pane.dock_direction, part.pane.dock_layer, part.pane.dock_row, part.pane.dock_pos+1) drop.Dock(). \ Direction(part.dock.dock_direction). \ Layer(part.dock.dock_layer).Row(part.dock.dock_row). \ Position(drop_position) return self.ProcessDockResult(target, drop)
[docs] def DoDropLayer(self, docks, target, dock_direction): """ Handles the situation in which `target` is a single dock guide. :param `docks`: a list of L{AuiDockInfo} classes; :param `target`: the target pane; :param `dock_direction`: the docking direction. """ drop = self.CopyTarget(target) if dock_direction == AUI_DOCK_LEFT: drop.Dock().Left() drop_new_layer = max(max(GetMaxLayer(docks, AUI_DOCK_LEFT), GetMaxLayer(docks, AUI_DOCK_BOTTOM)), GetMaxLayer(docks, AUI_DOCK_TOP)) + 1 elif dock_direction == AUI_DOCK_TOP: drop.Dock().Top() drop_new_layer = max(max(GetMaxLayer(docks, AUI_DOCK_TOP), GetMaxLayer(docks, AUI_DOCK_LEFT)), GetMaxLayer(docks, AUI_DOCK_RIGHT)) + 1 elif dock_direction == AUI_DOCK_RIGHT: drop.Dock().Right() drop_new_layer = max(max(GetMaxLayer(docks, AUI_DOCK_RIGHT), GetMaxLayer(docks, AUI_DOCK_TOP)), GetMaxLayer(docks, AUI_DOCK_BOTTOM)) + 1 elif dock_direction == AUI_DOCK_BOTTOM: drop.Dock().Bottom() drop_new_layer = max(max(GetMaxLayer(docks, AUI_DOCK_BOTTOM), GetMaxLayer(docks, AUI_DOCK_LEFT)), GetMaxLayer(docks, AUI_DOCK_RIGHT)) + 1 else: return False, target drop.Dock().Layer(drop_new_layer) return self.ProcessDockResult(target, drop)
[docs] def DoDropPane(self, panes, target, dock_direction, dock_layer, dock_row, dock_pos): """ Drop a pane in the interface. :param `panes`: a list of L{AuiPaneInfo} classes; :param `target`: the target pane; :param `dock_direction`: the docking direction; :param `dock_layer`: the docking layer; :param `dock_row`: the docking row; :param `dock_pos`: the docking position. """ drop = self.CopyTarget(target) panes = DoInsertPane(panes, dock_direction, dock_layer, dock_row, dock_pos) drop.Dock().Direction(dock_direction).Layer(dock_layer).Row(dock_row).Position(dock_pos) return self.ProcessDockResult(target, drop)
[docs] def DoDropRow(self, panes, target