# --------------------------------------------------------------------------- #
# 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: 28 Apr 2010, 14.00 GMT
#
# For All Kind Of Problems, Requests Of Enhancements And Bug Reports, Please
# Write To Me At:
#
# andrea.gavana@gmail.com
# gavana@kpo.kz
#
# Or, Obviously, To The wxPython Mailing List!!!
#
# End Of Comments
# --------------------------------------------------------------------------- #
"""
Description
===========
framemanager 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
# 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_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_PERSPECTIVE_CHANGED = wx.PyEventBinder(wxEVT_AUI_PERSPECTIVE_CHANGED, 0)
""" The layout in `AuiManager` has been changed. """
# ---------------------------------------------------------------------------- #
class AuiDockInfo(object):
""" A class to store all properties of a dock. """
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 = []
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
def IsHorizontal(self):
""" Returns whether the dock is horizontal or not. """
return self.dock_direction in [AUI_DOCK_TOP, AUI_DOCK_BOTTOM]
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]
# ---------------------------------------------------------------------------- #
class AuiDockingGuideInfo(object):
""" A class which holds information about VS2005 docking guide windows. """
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
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
def Host(self, h):
"""
Hosts a docking guide window.
:param `h`: an instance of L{AuiSingleDockingGuide} or L{AuiCenterDockingGuide}.
"""
self.host = h
return self
def Left(self):
""" Sets the guide window to left docking. """
self.dock_direction = AUI_DOCK_LEFT
return self
def Right(self):
""" Sets the guide window to right docking. """
self.dock_direction = AUI_DOCK_RIGHT
return self
def Top(self):
""" Sets the guide window to top docking. """
self.dock_direction = AUI_DOCK_TOP
return self
def Bottom(self):
""" Sets the guide window to bottom docking. """
self.dock_direction = AUI_DOCK_BOTTOM
return self
def Center(self):
""" Sets the guide window to center docking. """
self.dock_direction = AUI_DOCK_CENTER
return self
def Centre(self):
""" Sets the guide window to centre docking. """
self.dock_direction = AUI_DOCK_CENTRE
return self
# ---------------------------------------------------------------------------- #
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
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()
# ---------------------------------------------------------------------------- #
class AuiPaneButton(object):
""" A simple class which describes the caption pane button attributes. """
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
class AuiManagerEvent(wx.PyCommandEvent):
""" A specialized command event class for events sent by L{AuiManager}. """
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
def Clone(self):
"""
Returns a copy of the event.
Any event that is posted to the wxPython event system for later action (via
`wx.EvtHandler.AddPendingEvent` or `wx.PostEvent`) must implement this method.
All wxPython events fully implement this method, but any derived events
implemented by the user should also implement this method just in case they
(or some event derived from them) are ever posted.
All wxPython events implement a copy constructor, so the easiest way of
implementing the L{Clone} function is to implement a copy constructor for a new
event (call it `MyEvent`) and then define the L{Clone} function like this::
def Clone(self):
return MyEvent(self)
"""
return AuiManagerEvent(self)
def SetManager(self, mgr):
"""
Associates a L{AuiManager} to the current event.
:param `mgr`: an instance of L{AuiManager}.
"""
self.manager = mgr
def SetDC(self, pdc):
"""
Associates a `wx.DC` device context to this event.
:param `pdc`: a `wx.DC` device context object.
"""
self.dc = pdc
def SetPane(self, p):
"""
Associates a L{AuiPaneInfo} instance to this event.
:param `p`: a L{AuiPaneInfo} instance.
"""
self.pane = p
def SetButton(self, b):
"""
Associates a L{AuiPaneButton} instance to this event.
:param `b`: a L{AuiPaneButton} instance.
"""
self.button = b
def GetManager(self):
""" Returns the associated L{AuiManager} (if any). """
return self.manager
def GetDC(self):
""" Returns the associated `wx.DC` device context (if any). """
return self.dc
def GetPane(self):
""" Returns the associated L{AuiPaneInfo} structure (if any). """
return self.pane
def GetButton(self):
""" Returns the associated L{AuiPaneButton} instance (if any). """
return self.button
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
def GetVeto(self):
""" Returns whether the event has been vetoed or not. """
return self.veto_flag
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
def CanVeto(self):
""" Returns whether the event can be vetoed and has been vetoed. """
return self.canveto_flag and self.veto_flag
# ---------------------------------------------------------------------------- #
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
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.DefaultPane()
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
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)
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
def IsMaximized(self):
""" Returns ``True`` if the pane is maximized. """
return self.HasFlag(self.optionMaximized)
def IsMinimized(self):
""" Returns ``True`` if the pane is minimized. """
return self.HasFlag(self.optionMinimized)
def IsFixed(self):
""" Returns ``True`` if the pane cannot be resized. """
return not self.HasFlag(self.optionResizable)
def IsResizeable(self):
""" Returns ``True`` if the pane can be resized. """
return self.HasFlag(self.optionResizable)
def IsShown(self):
""" Returns ``True`` if the pane is currently shown. """
return not self.HasFlag(self.optionHidden)
def IsFloating(self):
""" Returns ``True`` if the pane is floating. """
return self.HasFlag(self.optionFloating)
def IsDocked(self):
""" Returns ``True`` if the pane is docked. """
return not self.HasFlag(self.optionFloating)
def IsToolbar(self):
""" Returns ``True`` if the pane contains a toolbar. """
return self.HasFlag(self.optionToolbar)
def IsTopDockable(self):
"""
Returns ``True`` if the pane can be docked at the top
of the managed frame.
"""
return self.HasFlag(self.optionTopDockable)
def IsBottomDockable(self):
"""
Returns ``True`` if the pane can be docked at the bottom
of the managed frame.
"""
return self.HasFlag(self.optionBottomDockable)
def IsLeftDockable(self):
"""
Returns ``True`` if the pane can be docked at the left
of the managed frame.
"""
return self.HasFlag(self.optionLeftDockable)
def IsRightDockable(self):
"""
Returns ``True`` if the pane can be docked at the right
of the managed frame.
"""
return self.HasFlag(self.optionRightDockable)
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()
def IsFloatable(self):
"""
Returns ``True`` if the pane can be undocked and displayed as a
floating window.
"""
return self.HasFlag(self.optionFloatable)
def IsMovable(self):
"""
Returns ``True`` if the docked frame can be undocked or moved to
another dock position.
"""
return self.HasFlag(self.optionMovable)
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)
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)
def IsTopSnappable(self):
""" Returns ``True`` if the pane can be snapped at the top of the managed frame. """
return self.HasFlag(self.optionTopSnapped)
def IsBottomSnappable(self):
""" Returns ``True`` if the pane can be snapped at the bottom of the managed frame. """
return self.HasFlag(self.optionBottomSnapped)
def IsLeftSnappable(self):
""" Returns ``True`` if the pane can be snapped on the left of the managed frame. """
return self.HasFlag(self.optionLeftSnapped)
def IsRightSnappable(self):
""" Returns ``True`` if the pane can be snapped on the right of the managed frame. """
return self.HasFlag(self.optionRightSnapped)
def IsSnappable(self):
""" Returns ``True`` if the pane can be snapped. """
return self.IsTopSnappable() or self.IsBottomSnappable() or self.IsLeftSnappable() or \
self.IsRightSnappable()
def IsFlyOut(self):
""" Returns ``True`` if the floating pane has a "fly-out" effect. """
return self.HasFlag(self.optionFlyOut)
def HasCaption(self):
""" Returns ``True`` if the pane displays a caption. """
return self.HasFlag(self.optionCaption)
def HasCaptionLeft(self):
""" Returns ``True`` if the pane displays a caption on the left (rotated by 90 degrees). """
return self.HasFlag(self.optionCaptionLeft)
def HasGripper(self):
""" Returns ``True`` if the pane displays a gripper. """
return self.HasFlag(self.optionGripper)
def HasBorder(self):
""" Returns ``True`` if the pane displays a border. """
return self.HasFlag(self.optionPaneBorder)
def HasCloseButton(self):
""" Returns ``True`` if the pane displays a button to close the pane. """
return self.HasFlag(self.buttonClose)
def HasMaximizeButton(self):
""" Returns ``True`` if the pane displays a button to maximize the pane. """
return self.HasFlag(self.buttonMaximize)
def HasMinimizeButton(self):
""" Returns ``True`` if the pane displays a button to minimize the pane. """
return self.HasFlag(self.buttonMinimize)
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_MASK`` 0x07 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`` 0x07 Filters the position flags
``AUI_MINIMIZE_CAPT_MASK`` 0x18 Filters the caption flags
============================== ========= ==============================
"""
return self.minimize_mode
def HasPinButton(self):
""" Returns ``True`` if the pane displays a button to float the pane. """
return self.HasFlag(self.buttonPin)
def HasGripperTop(self):
""" Returns ``True`` if the pane displays a gripper at the top. """
return self.HasFlag(self.optionGripperTop)
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
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
def Caption(self, caption):
"""
Sets the caption of the pane.
:param `caption`: a string specifying the pane caption.
"""
self.caption = caption
return self
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
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
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
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
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
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
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
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
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
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
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))
else:
ret = self.MinSize2(arg1, arg2)
return ret
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
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
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))
else:
ret = self.MaxSize2(arg1, arg2)
return ret
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
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
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))
else:
ret = self.BestSize2(arg1, arg2)
return ret
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
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
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
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
def Maximize(self):
""" Makes the pane take up the full area."""
return self.SetFlag(self.optionMaximized, True)
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)
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
============================== ========= ==============================
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
============================== ========= ==============================
"""
self.minimize_mode = mode
return self
def Restore(self):
""" Is the reverse of L{Maximize} and L{Minimize}."""
return self.SetFlag(self.optionMaximized or self.optionMinimized, False)
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)
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)
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
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)
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)
def Hide(self):
"""
Indicates that a pane should be hidden.
Calling L{Show} (``False``) achieve the same effect.
"""
return self.SetFlag(self.optionHidden, True)
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
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
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
def HasNotebook(self):
""" Returns whether a pane has a L{AuiNotebook} or not. """
return self.notebook_id >= 0
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
def IsNotebookControl(self):
""" Returns whether the pane is a notebook control (L{AuiNotebook}). """
return not self.IsNotebookPage() and self.HasNotebook()
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
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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
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
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
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()
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()
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
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
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
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]
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)
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
def IsHorizontal(self):
""" Returns ``True`` if the pane `dock_direction` is horizontal. """
return self.dock_direction in [AUI_DOCK_TOP, AUI_DOCK_BOTTOM]
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()
# ---------------------------------------------------------------------------- #
class AuiDockingGuide(wx.Frame):
""" Base class for L{AuiCenterDockingGuide} and L{AuiSingleDockingGuide}."""
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)
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
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
# ---------------------------------------------------------------------------
class AuiDockingGuideWindow(wx.Window):
""" Target class for L{AuiSingleDockingGuide} and L{AuiCenterDockingGuide}. """
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)
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
def IsValid(self):
""" Returns whether the docking direction is valid. """
return self._valid
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 intentiobnally empty to reduce flickering while drawing.
"""
pass
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)
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
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)
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
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)
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)
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
# ---------------------------------------------------------------------------
class AuiSingleDockingGuide(AuiDockingGuide):
""" A docking guide window for single docking hint (not diamond-shaped HUD). """
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)
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
def AeroMove(self, pos):
"""
Moves the docking window to the new position. Overridden in children classes.
:param `pos`: the new docking guide position.
"""
pass
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)
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)
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
def IsValid(self):
""" Returns whether the docking direction is valid. """
return self._valid
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)
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
# ---------------------------------------------------------------------------
class AuiCenterDockingGuide(AuiDockingGuide):
""" A docking guide window for multiple docking hint (diamond-shaped HUD). """
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)
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
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)
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()
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
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()
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))
def OnEraseBackground(self, event):
"""
Handles the ``wx.EVT_ERASE_BACKGROUND`` event for L{AuiCenterDockingGuide}.
:param `event`: `wx.EraseEvent` to be processed.
:note: This is intentiobnally empty to reduce flickering while drawing.
"""
pass
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
# ----------------------------------------------------------------------------
class AuiDockingHintWindow(wx.Frame):
""" The original wxAUI docking window hint. """
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)
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)
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)
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(AuiDockingHintWindow, self).SetShape(region)
def Show(self, show=True):
"""
Show the hint window.
:param `show`: whether to show or hide the frame.
"""
super(AuiDockingHintWindow, self).Show(show)
if wx.Platform == '__WXMAC__':
# Need to manually do layout since its a borderless frame.
self.Layout()
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 --
class AuiFloatingFrame(wx.MiniFrame):
""" AuiFloatingFrame is the frame class that holds floating panes. """
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())
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
return contained_pane
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)
def GetOwnerManager(self):
""" Returns the L{AuiManager} that manages the pane. """
return self._owner_mgr
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())
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):
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()
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)
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)
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 not wx.GetMouseState().LeftDown():
return
if not self._moving:
self.OnMoveStart(event)
self._moving = True
if self._last3_rect.IsEmpty():
return
self.OnMoving(event)
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 not wx.GetMouseState().LeftDown():
self._moving = False
self.OnMoveFinished()
else:
event.RequestMore()
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)
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)
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)
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()
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)
def FlyOut(self):
""" Starts the flying in and out of a floating pane. """
if self._fly_timer.IsRunning():
return
if wx.GetMouseState().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)
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()
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 --
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)
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
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
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
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
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
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
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
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
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
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
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
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
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
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)
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
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
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
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
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()
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()
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]
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
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
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
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
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
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()
# ---------------------------------------------------------------------------- #
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`).
"""
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)
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)
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))
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
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
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{AuiManager.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)
def GetAllPanes(self):
""" Returns a reference to all the pane info structures. """
return self._panes
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()
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
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
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()
def GetAGWFlags(self):
"""
Returns the current manager's flags.
:see: L{SetAGWFlags} for a list of possible L{AuiManager} flags.
"""
return self._agwFlags
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))
def GetManagedWindow(self):
""" Returns the window being managed by L{AuiManager}. """
return self._frame
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)
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
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)))
def DestroyGuideWindows(self):
""" Destroys the VS2005 HUD guide windows. """
for guide in self._guides:
if guide.host:
guide.host.Destroy()
self._guides = []
def CreateHintWindow(self):
""" Creates the standard wxAUI hint window. """
self.DestroyHintWindow()
self._hint_window = AuiDockingHintWindow(self._frame)
self._hint_window.SetBlindMode(self._agwFlags)
def DestroyHintWindow(self):
""" Destroys the standard wxAUI hint window. """
if self._hint_window:
self._hint_window.Destroy()
self._hint_window = None
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 self._frame:
self._frame.RemoveEventHandler(self)
def GetArtProvider(self):
""" Returns the current art provider being used. """
return self._art
def ProcessMgrEvent(self, event):
"""
Process the AUI events sent to the manager.
:param `event`: the event to process.
"""
# first, give the owner frame a chance to override
if self._frame:
if self._frame.GetEventHandler().ProcessEvent(event):
return
self.ProcessEvent(event)
def FireEvent(self, evtType, pane, canVeto=False):
"""
Fires one of the ``EVT_AUI_PANE_FLOATED``/``FLOATING``/``DOCKING``/``DOCKED`` event.
:param `evtType`: one of the aforementioned events;
:param `pane`: the `AuiPaneInfo` instance;
:param `canVeto`: whether the event can be vetoed or not.
"""
event = AuiManagerEvent(evtType)
event.SetPane(pane)
event.SetCanVeto(canVeto)
self.ProcessMgrEvent(event)
return event
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
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()
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.
"""
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)
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 that name already exists in the manager!")
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
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)
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
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 target.IsNotebookDockable():
return self.AddPane1(window, pane_info)
if not paneInfo.IsNotebookDockable() and not paneInfo.IsNotebookControl():
return self.AddPane1(window, pane_info)
if not paneInfo.HasNotebook():
# Add a new notebook pane ...
id = len(self._notebooks)
bookBasePaneInfo = AuiPaneInfo()
bookBasePaneInfo.SetDockPos(target).NotebookControl(id). \
CloseButton(False).SetNameFromNotebookId(). \
NotebookDockable(False)
bookBasePaneInfo.best_size = paneInfo.best_size
self._panes.append(bookBasePaneInfo)
# add original pane as tab ...
paneInfo.NotebookPage(id)
# Add new item to notebook
target.NotebookPage(paneInfo.notebook_id)
# we also want to remove our captions sometimes
if not self.RemoveAutoNBCaption(target):
# Update for position and _notebooks in case we have another target
self.Update()
return True
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
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
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...
notebook = self._notebooks[pane_info.notebook_id]
id = notebook.GetPageIndex(pane_info.window)
notebook.RemovePage(id)
# 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:
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()
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)
def SavePreviousDockSizes(self, pane_info):
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)
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)
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
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()
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
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
def GetAutoNotebookTabArt(self):
""" Returns the default tab art provider for automatic notebooks. """
return self._autoNBTabArt
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 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
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
def SavePaneInfo(self, pane):
"""
This method is similar to L{AuiManager.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
def LoadPaneInfo(self, pane_part, pane):
"""
This method is similar to to L{AuiManager.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
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
def LoadPerspective(self, layout, update=True):
"""
Loads a layout which was saved with L{SavePerspective}.
If the `update` flag parameter is ``True``, L{AuiManager.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 update:
self.Update()
return True
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
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
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
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
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))
def GetDockSizeConstraint(self):
"""
Returns the current dock constraint values.
:see: L{SetDockSizeConstraint}
"""
return self._dock_constraint_x, self._dock_constraint_y
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)
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)
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
# 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)
# 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:
# Check page-ordering...
self._notebooks[nb_idx] = notebook
pages = notebook.GetPageCount()
selected = notebook.GetPage(notebook.GetSelection())
reordered = False
for page in xrange(pages):
win = notebook.GetPage(page)
pane = self.GetPane(win)
if pane.IsOk():
lowest = pane.dock_pos
where = -1
# Now look for panes with lower dock_poss
for look in xrange(page + 1, pages):
w = notebook.GetPage(look)
other = self.GetPane(w)
if other.IsOk():
if other.dock_pos < lowest:
where = look
lowest = other.dock_pos
pane = self.SetAttributes(pane, self.GetAttributes(other))
if where > 0:
# We need to move a new pane into slot "page"
notebook.RemovePage(where)
title = (pane.caption == "" and [pane.name] or [pane.caption])[0]
notebook.InsertPage(page, pane.window, title)
reordered = True
# Now that we've move it, we can "normalise" the value.
pane.dock_pos = page
if reordered:
notebook.SetSelection(notebook.GetPageIndex(selected), True)
# 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
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
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()
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
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
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
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
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
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
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
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
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
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
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
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()
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()
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()
def GetNotebooks(self):
""" Returns all the automatic L{AuiNotebook} in the L{AuiManager}. """
if self._masterManager:
return self._masterManager.GetNotebooks()
return self._notebooks
def SetMasterManager(self, manager):
"""
Sets the master manager for an automatic L{AuiNotebook}.
:param `manager`: an instance of L{AuiManager}.
"""
self._masterManager = manager
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
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
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)
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
return drop
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)
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 ...
id = len(self._notebooks)
bookBasePaneInfo = AuiPaneInfo()
bookBasePaneInfo.SetDockPos(paneInfo).NotebookControl(id). \
CloseButton(False).SetNameFromNotebookId(). \
NotebookDockable(False).Floatable(paneInfo.IsFloatable())
bookBasePaneInfo.best_size = paneInfo.best_size
panes.append(bookBasePaneInfo)
# add original pane as tab ...
paneInfo.NotebookPage(id)
# 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
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)
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)
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)
def DoDropRow(self, panes, target, dock_direction, dock_layer, dock_row):
"""
Insert a row in the interface before dropping.
: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.
"""
drop = self.CopyTarget(target)
panes = DoInsertDockRow(panes, dock_direction, dock_layer, dock_row)
drop.Dock().Direction(dock_direction).Layer(dock_layer).Row(dock_row).Position(0)
return self.ProcessDockResult(target, drop)
def ShowHint(self, rect):
"""
Shows the AUI hint window.
:param `rect`: the hint rect calculated in advance.
"""
if rect == self._last_hint:
return
if self._agwFlags & AUI_MGR_RECTANGLE_HINT and wx.Platform != "__WXMAC__":
if self._last_hint != rect:
# remove the last hint rectangle
self._last_hint = wx.Rect(*rect)
self._frame.Refresh()
self._frame.Update()
screendc = wx.ScreenDC()
clip = wx.Region(1, 1, 10000, 10000)
# clip all floating windows, so we don't draw over them
for pane in self._panes:
if pane.IsFloating() and pane.frame.IsShown():
rect2 = wx.Rect(*pane.frame.GetRect())
if wx.Platform == "__WXGTK__":
# wxGTK returns the client size, not the whole frame size
rect2.width += 15
rect2.height += 35
rect2.Inflate(5, 5)
clip.SubtractRect(rect2)
# As we can only hide the hint by redrawing the managed window, we
# need to clip the region to the managed window too or we get
# nasty redrawn problems.
clip.IntersectRect(self._frame.GetRect())
screendc.SetClippingRegionAsRegion(clip)
stipple = PaneCreateStippleBitmap()
brush = wx.BrushFromBitmap(stipple)
screendc.SetBrush(brush)
screendc.SetPen(wx.TRANSPARENT_PEN)
screendc.DrawRectangle(rect.x, rect.y, 5, rect.height)
screendc.DrawRectangle(rect.x+5, rect.y, rect.width-10, 5)
screendc.DrawRectangle(rect.x+rect.width-5, rect.y, 5, rect.height)
screendc.DrawRectangle(rect.x+5, rect.y+rect.height-5, rect.width-10, 5)
RefreshDockingGuides(self._guides)
return
if not self._hint_window:
self.CreateHintWindow()
if self._hint_window:
self._hint_window.SetRect(rect)
self._hint_window.Show()
self._hint_fadeamt = self._hint_fademax
if self._agwFlags & AUI_MGR_HINT_FADE:
self._hint_fadeamt = 0
self._hint_window.SetTransparent(self._hint_fadeamt)
if self._action == actionDragFloatingPane and self._action_window:
self._action_window.SetFocus()
if self._hint_fadeamt != self._hint_fademax: # Only fade if we need to
# start fade in timer
self._hint_fadetimer.Start(5)
self._last_hint = wx.Rect(*rect)
def HideHint(self):
""" Hides a transparent window hint if there is one. """
# hides a transparent window hint if there is one
if self._hint_window:
self._hint_window.Hide()
self._hint_fadetimer.Stop()
self._last_hint = wx.Rect()
def IsPaneButtonVisible(self, part):
"""
Returns whether a pane button in the pane caption is visible.
:param `part`: the UI part to analyze.
"""
captionRect = wx.Rect()
for temp_part in self._uiparts:
if temp_part.pane == part.pane and \
temp_part.type == AuiDockUIPart.typeCaption:
captionRect = temp_part.rect
break
return captionRect.ContainsRect(part.rect)
def DrawPaneButton(self, dc, part, pt):
"""
Draws a pane button in the caption (convenience function).
:param `dc`: a `wx.DC` device context object;
:param `part`: the UI part to analyze;
:param `pt`: a `wx.Point` object, specifying the mouse location.
"""
if not self.IsPaneButtonVisible(part):
return
state = AUI_BUTTON_STATE_NORMAL
if part.rect.Contains(pt):
if wx.GetMouseState().LeftDown():
state = AUI_BUTTON_STATE_PRESSED
else:
state = AUI_BUTTON_STATE_HOVER
self._art.DrawPaneButton(dc, self._frame, part.button.button_id,
state, part.rect, part.pane)
def RefreshButton(self, part):
"""
Refreshes a pane button in the caption.
:param `part`: the UI part to analyze.
"""
rect = wx.Rect(*part.rect)
rect.Inflate(2, 2)
self._frame.Refresh(True, rect)
self._frame.Update()
def RefreshCaptions(self):
""" Refreshes all pane captions. """
for part in self._uiparts:
if part.type == AuiDockUIPart.typeCaption:
self._frame.Refresh(True, part.rect)
self._frame.Update()
def CalculateHintRect(self, pane_window, pt, offset):
"""
Calculates the drop hint rectangle.
The method first calls L{DoDrop} to determine the exact position the pane would
be at were if dropped. If the pane would indeed become docked at the
specified drop point, the the rectangle hint will be returned in
screen coordinates. Otherwise, an empty rectangle is returned.
:param `pane_window`: it is the window pointer of the pane being dragged;
:param `pt`: is the mouse position, in client coordinates;
:param `offset`: describes the offset that the mouse is from the upper-left
corner of the item being dragged.
"""
# we need to paint a hint rectangle to find out the exact hint rectangle,
# we will create a new temporary layout and then measure the resulting
# rectangle we will create a copy of the docking structures (self._docks)
# so that we don't modify the real thing on screen
rect = wx.Rect()
pane = self.GetPane(pane_window)
attrs = self.GetAttributes(pane)
hint = AuiPaneInfo()
hint = self.SetAttributes(hint, attrs)
if hint.name != "__HINT__":
self._oldname = hint.name
hint.name = "__HINT__"
hint.PaneBorder(True)
hint.Show()
if not hint.IsOk():
hint.name = self._oldname
return rect
docks, panes = CopyDocksAndPanes2(self._docks, self._panes)
# remove any pane already there which bears the same window
# this happens when you are moving a pane around in a dock
for ii in xrange(len(panes)):
if panes[ii].window == pane_window:
docks = RemovePaneFromDocks(docks, panes[ii])
panes.pop(ii)
break
# find out where the new pane would be
allow, hint = self.DoDrop(docks, panes, hint, pt, offset)
if not allow:
return rect
panes.append(hint)
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()
sought = "__HINT__"
# For a notebook page, actually look for the noteboot itself.
if hint.IsNotebookPage():
id = hint.notebook_id
for pane in panes:
if pane.IsNotebookControl() and pane.notebook_id==id:
sought = pane.name
break
for part in uiparts:
if part.pane and part.pane.name == sought:
rect.Union(wx.RectPS(part.sizer_item.GetPosition(),
part.sizer_item.GetSize()))
sizer.Destroy()
# check for floating frame ...
if rect.IsEmpty():
for p in panes:
if p.name == sought and p.IsFloating():
return wx.RectPS(p.floating_pos, p.floating_size)
if rect.IsEmpty():
return rect
# actually show the hint rectangle on the screen
rect.x, rect.y = self._frame.ClientToScreen((rect.x, rect.y))
if self._frame.GetLayoutDirection() == wx.Layout_RightToLeft:
# Mirror rectangle in RTL mode
rect.x -= rect.GetWidth()
return rect
def DrawHintRect(self, pane_window, pt, offset):
"""
Calculates the hint rectangle by calling
L{CalculateHintRect}. If there is a rectangle, it shows it
by calling L{ShowHint}, otherwise it hides any hint
rectangle currently shown.
:param `pane_window`: it is the window pointer of the pane being dragged;
:param `pt`: is the mouse position, in client coordinates;
:param `offset`: describes the offset that the mouse is from the upper-left
corner of the item being dragged.
"""
rect = self.CalculateHintRect(pane_window, pt, offset)
if rect.IsEmpty():
self.HideHint()
self._hint_rect = wx.Rect()
else:
self.ShowHint(rect)
self._hint_rect = wx.Rect(*rect)
def GetPartSizerRect(self, uiparts):
"""
Returns the rectangle surrounding the specified UI parts.
:param `uiparts`: UI parts.
"""
rect = wx.Rect()
for part in self._uiparts:
if part.pane and part.pane.name == "__HINT__":
rect.Union(wx.RectPS(part.sizer_item.GetPosition(),
part.sizer_item.GetSize()))
return rect
def GetAttributes(self, pane):
"""
Returns all the attributes of a L{AuiPaneInfo}.
:param `pane`: a L{AuiPaneInfo} instance.
"""
attrs = []
attrs.extend([pane.window, pane.frame, pane.state, pane.dock_direction,
pane.dock_layer, pane.dock_pos, pane.dock_row, pane.dock_proportion,
pane.floating_pos, pane.floating_size, pane.best_size,
pane.min_size, pane.max_size, pane.caption, pane.name,
pane.buttons, pane.rect, pane.icon, pane.notebook_id,
pane.transparent, pane.snapped, pane.minimize_mode])
return attrs
def SetAttributes(self, pane, attrs):
"""
Sets all the attributes contained in `attrs` to a L{AuiPaneInfo}.
:param `pane`: a L{AuiPaneInfo} instance;
:param `attrs`: a list of attributes.
"""
pane.window = attrs[0]
pane.frame = attrs[1]
pane.state = attrs[2]
pane.dock_direction = attrs[3]
pane.dock_layer = attrs[4]
pane.dock_pos = attrs[5]
pane.dock_row = attrs[6]
pane.dock_proportion = attrs[7]
pane.floating_pos = attrs[8]
pane.floating_size = attrs[9]
pane.best_size = attrs[10]
pane.min_size = attrs[11]
pane.max_size = attrs[12]
pane.caption = attrs[13]
pane.name = attrs[14]
pane.buttons = attrs[15]
pane.rect = attrs[16]
pane.icon = attrs[17]
pane.notebook_id = attrs[18]
pane.transparent = attrs[19]
pane.snapped = attrs[20]
pane.minimize_mode = attrs[21]
return pane
def OnFloatingPaneResized(self, wnd, size):
"""
Handles the resizing of a floating pane.
:param `wnd` a `wx.Window` derived window, managed by the pane;
:param `size`: a `wx.Size` object, specifying the new pane floating size.
"""
# try to find the pane
pane = self.GetPane(wnd)
if not pane.IsOk():
raise Exception("Pane window not found")
if pane.frame:
indx = self._panes.index(pane)
pane.floating_pos = pane.frame.GetPosition()
pane.floating_size = size
self._panes[indx] = pane
if pane.IsSnappable():
self.SnapPane(pane, pane.floating_pos, pane.floating_size, True)
def OnFloatingPaneClosed(self, wnd, event):
"""
Handles the close event of a floating pane.
:param `wnd` a `wx.Window` derived window, managed by the pane;
:param `event`: a `wx.CloseEvent` to be processed.
"""
# try to find the pane
pane = self.GetPane(wnd)
if not pane.IsOk():
raise Exception("Pane window not found")
# fire pane close event
e = AuiManagerEvent(wxEVT_AUI_PANE_CLOSE)
e.SetPane(pane)
e.SetCanVeto(event.CanVeto())
self.ProcessMgrEvent(e)
if e.GetVeto():
event.Veto()
return
else:
# close the pane, but check that it
# still exists in our pane array first
# (the event handler above might have removed it)
check = self.GetPane(wnd)
if check.IsOk():
self.ClosePane(pane)
def OnFloatingPaneActivated(self, wnd):
"""
Handles the activation event of a floating pane.
:param `wnd`: a `wx.Window` derived window, managed by the pane.
"""
pane = self.GetPane(wnd)
if not pane.IsOk():
raise Exception("Pane window not found")
if self.GetAGWFlags() & AUI_MGR_ALLOW_ACTIVE_PANE:
ret, self._panes = SetActivePane(self._panes, wnd)
self.RefreshCaptions()
def OnFloatingPaneMoved(self, wnd, eventOrPt):
"""
Handles the move event of a floating pane.
:param `wnd`: a `wx.Window` derived window, managed by the pane;
:param `event`: a `wx.MoveEvent` to be processed.
"""
pane = self.GetPane(wnd)
if not pane.IsOk():
raise Exception("Pane window not found")
if not pane.IsSnappable():
return
if isinstance(eventOrPt, wx.Point):
pane_pos = wx.Point(*eventOrPt)
else:
pane_pos = eventOrPt.GetPosition()
pane_size = pane.floating_size
self.SnapPane(pane, pane_pos, pane_size, False)
def SnapPane(self, pane, pane_pos, pane_size, toSnap=False):
"""
Snaps a floating pane to one of the main frame sides.
:param `pane`: a L{AuiPaneInfo} instance;
:param `pane_pos`: the new pane floating position;
:param `pane_size`: the new pane floating size;
:param `toSnap`: a bool variable to check if L{SnapPane} was called from
a move event.
"""
if self._from_move:
return
managed_window = self.GetManagedWindow()
wnd_pos = managed_window.GetPosition()
wnd_size = managed_window.GetSize()
snapX, snapY = self._snap_limits
if not toSnap:
pane.snapped = 0
if pane.IsLeftSnappable():
# Check if we can snap to the left
diff = wnd_pos.x - (pane_pos.x + pane_size.x)
if -snapX <= diff <= snapX:
pane.snapped = wx.LEFT
pane.floating_pos = wx.Point(wnd_pos.x-pane_size.x, pane_pos.y)
elif pane.IsTopSnappable():
# Check if we can snap to the top
diff = wnd_pos.y - (pane_pos.y + pane_size.y)
if -snapY <= diff <= snapY:
pane.snapped = wx.TOP
pane.floating_pos = wx.Point(pane_pos.x, wnd_pos.y-pane_size.y)
elif pane.IsRightSnappable():
# Check if we can snap to the right
diff = pane_pos.x - (wnd_pos.x + wnd_size.x)
if -snapX <= diff <= snapX:
pane.snapped = wx.RIGHT
pane.floating_pos = wx.Point(wnd_pos.x + wnd_size.x, pane_pos.y)
elif pane.IsBottomSnappable():
# Check if we can snap to the bottom
diff = pane_pos.y - (wnd_pos.y + wnd_size.y)
if -snapY <= diff <= snapY:
pane.snapped = wx.BOTTOM
pane.floating_pos = wx.Point(pane_pos.x, wnd_pos.y + wnd_size.y)
self.RepositionPane(pane, wnd_pos, wnd_size)
def RepositionPane(self, pane, wnd_pos, wnd_size):
"""
Repositions a pane after the main frame has been moved/resized.
:param `pane`: a L{AuiPaneInfo} instance;
:param `wnd_pos`: the main frame position;
:param `wnd_size`: the main frame size.
"""
pane_pos = pane.floating_pos
pane_size = pane.floating_size
snap = pane.snapped
if snap == wx.LEFT:
floating_pos = wx.Point(wnd_pos.x - pane_size.x, pane_pos.y)
elif snap == wx.TOP:
floating_pos = wx.Point(pane_pos.x, wnd_pos.y - pane_size.y)
elif snap == wx.RIGHT:
floating_pos = wx.Point(wnd_pos.x + wnd_size.x, pane_pos.y)
elif snap == wx.BOTTOM:
floating_pos = wx.Point(pane_pos.x, wnd_pos.y + wnd_size.y)
if snap:
if pane_pos != floating_pos:
pane.floating_pos = floating_pos
self._from_move = True
pane.frame.SetPosition(pane.floating_pos)
self._from_move = False
def OnGripperClicked(self, pane_window, start, offset):
"""
Handles the mouse click on the pane gripper.
:param `pane_window`: a `wx.Window` derived window, managed by the pane;
:param `start`: a `wx.Point` object, specifying the clicking position;
:param `offset`: an offset point from the `start` position.
"""
# try to find the pane
paneInfo = self.GetPane(pane_window)
if not paneInfo.IsOk():
raise Exception("Pane window not found")
if self.GetAGWFlags() & AUI_MGR_ALLOW_ACTIVE_PANE:
# set the caption as active
ret, self._panes = SetActivePane(self._panes, pane_window)
self.RefreshCaptions()
self._action_part = None
self._action_pane = paneInfo
self._action_window = pane_window
self._action_start = start
self._action_offset = offset
self._toolbar_action_offset = wx.Point(*self._action_offset)
self._frame.CaptureMouse()
if paneInfo.IsDocked():
self._action = actionClickCaption
else:
if paneInfo.IsToolbar():
self._action = actionDragToolbarPane
else:
self._action = actionDragFloatingPane
if paneInfo.frame:
windowPt = paneInfo.frame.GetRect().GetTopLeft()
originPt = paneInfo.frame.ClientToScreen(wx.Point())
self._action_offset += originPt - windowPt
self._toolbar_action_offset = wx.Point(*self._action_offset)
if self._agwFlags & AUI_MGR_TRANSPARENT_DRAG:
paneInfo.frame.SetTransparent(150)
if paneInfo.IsToolbar():
self._frame.SetCursor(wx.StockCursor(wx.CURSOR_SIZING))
def OnRender(self, event):
"""
Draws all of the pane captions, sashes,
backgrounds, captions, grippers, pane borders and buttons.
It renders the entire user interface.
:param `event`: an instance of L{AuiManagerEvent}.
"""
# if the frame is about to be deleted, don't bother
if not self._frame or self._frame.IsBeingDeleted():
return
if not self._frame.GetSizer():
return
mouse = wx.GetMouseState()
mousePos = wx.Point(mouse.GetX(), mouse.GetY())
point = self._frame.ScreenToClient(mousePos)
art = self._art
dc = event.GetDC()
for part in self._uiparts:
# don't draw hidden pane items or items that aren't windows
if part.sizer_item and ((not part.sizer_item.IsWindow() and \
not part.sizer_item.IsSpacer() and \
not part.sizer_item.IsSizer()) or \
not part.sizer_item.IsShown()):
continue
ptype = part.type
if ptype in [AuiDockUIPart.typeDockSizer, AuiDockUIPart.typePaneSizer]:
art.DrawSash(dc, self._frame, part.orientation, part.rect)
elif ptype == AuiDockUIPart.typeBackground:
art.DrawBackground(dc, self._frame, part.orientation, part.rect)
elif ptype == AuiDockUIPart.typeCaption:
art.DrawCaption(dc, self._frame, part.pane.caption, part.rect, part.pane)
elif ptype == AuiDockUIPart.typeGripper:
art.DrawGripper(dc, self._frame, part.rect, part.pane)
elif ptype == AuiDockUIPart.typePaneBorder:
art.DrawBorder(dc, self._frame, part.rect, part.pane)
elif ptype == AuiDockUIPart.typePaneButton:
self.DrawPaneButton(dc, part, point)
def Repaint(self, dc=None):
"""
Repaints the entire frame decorations (sashes, borders, buttons and so on).
It renders the entire user interface.
:param `dc`: if not ``None``, an instance of `wx.PaintDC`.
"""
w, h = self._frame.GetClientSize()
# Figure out which dc to use; if one
# has been specified, use it, otherwise
# make a client dc
if dc is None:
client_dc = wx.ClientDC(self._frame)
dc = client_dc
# If the frame has a toolbar, the client area
# origin will not be (0, 0).
pt = self._frame.GetClientAreaOrigin()
if pt.x != 0 or pt.y != 0:
dc.SetDeviceOrigin(pt.x, pt.y)
# Render all the items
self.Render(dc)
def Render(self, dc):
"""
Fires a render event, which is normally handled by
L{OnRender}. This allows the render function to
be overridden via the render event.
This can be useful for painting custom graphics in the main window.
Default behavior can be invoked in the overridden function by calling
L{OnRender}.
:param `dc`: a `wx.DC` device context object.
"""
e = AuiManagerEvent(wxEVT_AUI_RENDER)
e.SetManager(self)
e.SetDC(dc)
self.ProcessMgrEvent(e)
def OnCaptionDoubleClicked(self, pane_window):
"""
Handles the mouse double click on the pane caption.
:param `pane_window`: a `wx.Window` derived window, managed by the pane.
"""
# try to find the pane
paneInfo = self.GetPane(pane_window)
if not paneInfo.IsOk():
raise Exception("Pane window not found")
if not paneInfo.IsFloatable() or not paneInfo.IsDockable() or \
self._agwFlags & AUI_MGR_ALLOW_FLOATING == 0:
return
indx = self._panes.index(paneInfo)
win_rect = None
if paneInfo.IsFloating():
if paneInfo.name.startswith("__floating__"):
# It's a floating tab from a AuiNotebook
notebook = paneInfo.window.__aui_notebook__
notebook.ReDockPage(paneInfo)
self.Update()
return
else:
e = self.FireEvent(wxEVT_AUI_PANE_DOCKING, paneInfo, canVeto=True)
if e.GetVeto():
self.HideHint()
ShowDockingGuides(self._guides, False)
return
win_rect = paneInfo.frame.GetRect()
paneInfo.Dock()
if paneInfo.IsToolbar():
paneInfo = self.SwitchToolBarOrientation(paneInfo)
e = self.FireEvent(wxEVT_AUI_PANE_DOCKED, paneInfo, canVeto=False)
else:
e = self.FireEvent(wxEVT_AUI_PANE_FLOATING, paneInfo, canVeto=True)
if e.GetVeto():
return
# float the window
if paneInfo.IsMaximized():
self.RestorePane(paneInfo)
if paneInfo.floating_pos == wx.Point(-1, -1):
captionSize = self._art.GetMetric(AUI_DOCKART_CAPTION_SIZE)
paneInfo.floating_pos = pane_window.GetScreenPosition()
paneInfo.floating_pos.y -= captionSize
paneInfo.Float()
e = self.FireEvent(wxEVT_AUI_PANE_FLOATED, paneInfo, canVeto=False)
self._panes[indx] = paneInfo
self.Update()
if win_rect and self._agwFlags & AUI_MGR_ANIMATE_FRAMES:
paneInfo = self.GetPane(pane_window)
pane_rect = paneInfo.window.GetScreenRect()
self.AnimateDocking(win_rect, pane_rect)
def OnPaint(self, event):
"""
Handles the ``wx.EVT_PAINT`` event for L{AuiManager}.
:param `event`: an instance of `wx.PaintEvent` to be processed.
"""
dc = wx.PaintDC(self._frame)
self.Repaint(dc)
def OnEraseBackground(self, event):
"""
Handles the ``wx.EVT_ERASE_BACKGROUND`` event for L{AuiManager}.
:param `event`: `wx.EraseEvent` to be processed.
:note: This is intentionally empty (excluding wxMAC) to reduce
flickering while drawing.
"""
if wx.Platform == "__WXMAC__":
event.Skip()
def OnSize(self, event):
"""
Handles the ``wx.EVT_SIZE`` event for L{AuiManager}.
:param `event`: a `wx.SizeEvent` to be processed.
"""
skipped = False
if isinstance(self._frame, AuiFloatingFrame) and self._frame.IsShownOnScreen():
skipped = True
event.Skip()
if self._frame:
self.DoFrameLayout()
if wx.Platform == "__WXMAC__":
self._frame.Refresh()
else:
self.Repaint()
if isinstance(self._frame, wx.MDIParentFrame) or isinstance(self._frame, tabmdi.AuiMDIClientWindow) \
or isinstance(self._frame, tabmdi.AuiMDIParentFrame):
# for MDI parent frames, this event must not
# be "skipped". In other words, the parent frame
# must not be allowed to resize the client window
# after we are finished processing sizing changes
return
if not skipped:
event.Skip()
# For the snap to screen...
self.OnMove(None)
def OnFindManager(self, event):
"""
Handles the ``EVT_AUI_FIND_MANAGER`` event for L{AuiManager}.
:param `event`: a `EVT_AUI_FIND_MANAGER` event to be processed.
"""
# Initialize to None
event.SetManager(None)
if not self._frame:
return
# See it this window wants to overwrite
self._frame.ProcessEvent(event)
# if no, it must be us
if not event.GetManager():
event.SetManager(self)
def OnSetCursor(self, event):
"""
Handles the ``wx.EVT_SET_CURSOR`` event for L{AuiManager}.
:param `event`: a `wx.SetCursorEvent` to be processed.
"""
# determine cursor
part = self.HitTest(event.GetX(), event.GetY())
cursor = wx.NullCursor
if part:
if part.type in [AuiDockUIPart.typeDockSizer, AuiDockUIPart.typePaneSizer]:
if not self.CheckMovableSizer(part):
return
if part.orientation == wx.VERTICAL:
cursor = wx.StockCursor(wx.CURSOR_SIZEWE)
else:
cursor = wx.StockCursor(wx.CURSOR_SIZENS)
elif part.type == AuiDockUIPart.typeGripper:
cursor = wx.StockCursor(wx.CURSOR_SIZING)
event.SetCursor(cursor)
def UpdateButtonOnScreen(self, button_ui_part, event):
"""
Updates/redraws the UI part containing a pane button.
:param `button_ui_part`: the UI part the button belongs to;
:param `event`: a `wx.MouseEvent` to be processed.
"""
hit_test = self.HitTest(*event.GetPosition())
if not hit_test or not button_ui_part:
return
state = AUI_BUTTON_STATE_NORMAL
if hit_test == button_ui_part:
if event.LeftDown():
state = AUI_BUTTON_STATE_PRESSED
else:
state = AUI_BUTTON_STATE_HOVER
else:
if event.LeftDown():
state = AUI_BUTTON_STATE_HOVER
# now repaint the button with hover state
cdc = wx.ClientDC(self._frame)
# if the frame has a toolbar, the client area
# origin will not be (0,0).
pt = self._frame.GetClientAreaOrigin()
if pt.x != 0 or pt.y != 0:
cdc.SetDeviceOrigin(pt.x, pt.y)
if hit_test.pane:
self._art.DrawPaneButton(cdc, self._frame,
button_ui_part.button.button_id,
state,
button_ui_part.rect, hit_test.pane)
def OnLeftDown(self, event):
"""
Handles the ``wx.EVT_LEFT_DOWN`` event for L{AuiManager}.
:param `event`: a `wx.MouseEvent` to be processed.
"""
part = self.HitTest(*event.GetPosition())
if not part:
event.Skip()
return
self._currentDragItem = -1
if part.type in [AuiDockUIPart.typeDockSizer, AuiDockUIPart.typePaneSizer]:
if not self.CheckMovableSizer(part):
return
self._action = actionResize
self._action_part = part
self._action_pane = None
self._action_rect = wx.Rect()
self._action_start = wx.Point(event.GetX(), event.GetY())
self._action_offset = wx.Point(event.GetX() - part.rect.x,
event.GetY() - part.rect.y)
# draw the resize hint
rect = wx.RectPS(self._frame.ClientToScreen(part.rect.GetPosition()),
part.rect.GetSize())
self._action_rect = wx.Rect(*rect)
if not AuiManager_HasLiveResize(self):
if wx.Platform == "__WXMAC__":
dc = wx.ClientDC(self._frame)
else:
dc = wx.ScreenDC()
DrawResizeHint(dc, rect)
self._frame.CaptureMouse()
elif part.type == AuiDockUIPart.typePaneButton:
if self.IsPaneButtonVisible(part):
self._action = actionClickButton
self._action_part = part
self._action_pane = None
self._action_start = wx.Point(*event.GetPosition())
self._frame.CaptureMouse()
self.RefreshButton(part)
elif part.type in [AuiDockUIPart.typeCaption, AuiDockUIPart.typeGripper]:
# if we are managing a AuiFloatingFrame window, then
# we are an embedded AuiManager inside the AuiFloatingFrame.
# We want to initiate a toolbar drag in our owner manager
if isinstance(part.pane.window.GetParent(), AuiFloatingFrame):
rootManager = GetManager(part.pane.window)
else:
rootManager = self
offset = wx.Point(event.GetX() - part.rect.x, event.GetY() - part.rect.y)
rootManager.OnGripperClicked(part.pane.window, event.GetPosition(), offset)
if wx.Platform != "__WXMAC__":
event.Skip()
def OnLeftDClick(self, event):
"""
Handles the ``wx.EVT_LEFT_DCLICK`` event for L{AuiManager}.
:param `event`: a `wx.MouseEvent` to be processed.
"""
part = self.HitTest(event.GetX(), event.GetY())
if part and part.type == AuiDockUIPart.typeCaption:
if isinstance(part.pane.window.GetParent(), AuiFloatingFrame):
rootManager = GetManager(part.pane.window)
else:
rootManager = self
rootManager.OnCaptionDoubleClicked(part.pane.window)
elif part and part.type in [AuiDockUIPart.typeDockSizer, AuiDockUIPart.typePaneSizer]:
# Handles double click on AuiNotebook sashes to unsplit
sash_size = self._art.GetMetric(AUI_DOCKART_SASH_SIZE)
for child in part.cont_sizer.GetChildren():
if child.IsSizer():
win = child.GetSizer().GetContainingWindow()
if isinstance(win, auibook.AuiNotebook):
win.UnsplitDClick(part, sash_size, event.GetPosition())
break
event.Skip()
def DoEndResizeAction(self, event):
"""
Ends a resize action, or for live update, resizes the sash.
:param `event`: a `wx.MouseEvent` to be processed.
"""
clientPt = event.GetPosition()
screenPt = self._frame.ClientToScreen(clientPt)
return self.RestrictResize(clientPt, screenPt, createDC=False)
def RestrictResize(self, clientPt, screenPt, createDC):
""" Common method between L{DoEndResizeAction} and L{OnLeftUp_Resize}. """
dock = self._action_part.dock
pane = self._action_part.pane
if createDC:
if wx.Platform == "__WXMAC__":
dc = wx.ClientDC(self._frame)
else:
dc = wx.ScreenDC()
DrawResizeHint(dc, self._action_rect)
self._action_rect = wx.Rect()
newPos = clientPt - self._action_offset
if self._action_part.type == AuiDockUIPart.typeDockSizer:
minPix, maxPix = self.CalculateDockSizerLimits(dock)
else:
if not self._action_part.pane:
return
minPix, maxPix = self.CalculatePaneSizerLimits(dock, pane)
if self._action_part.orientation == wx.HORIZONTAL:
newPos.y = Clip(newPos.y, minPix, maxPix)
else:
newPos.x = Clip(newPos.x, minPix, maxPix)
if self._action_part.type == AuiDockUIPart.typeDockSizer:
partnerDock = self.GetPartnerDock(dock)
sash_size = self._art.GetMetric(AUI_DOCKART_SASH_SIZE)
new_dock_size = 0
direction = dock.dock_direction
if direction == AUI_DOCK_LEFT:
new_dock_size = newPos.x - dock.rect.x
elif direction == AUI_DOCK_TOP:
new_dock_size = newPos.y - dock.rect.y
elif direction == AUI_DOCK_RIGHT:
new_dock_size = dock.rect.x + dock.rect.width - newPos.x - sash_size
elif direction == AUI_DOCK_BOTTOM:
new_dock_size = dock.rect.y + dock.rect.height - newPos.y - sash_size
deltaDockSize = new_dock_size - dock.size
if partnerDock:
if deltaDockSize > partnerDock.size - sash_size:
deltaDockSize = partnerDock.size - sash_size
partnerDock.size -= deltaDockSize
dock.size += deltaDockSize
self.Update()
else:
# determine the new pixel size that the user wants
# this will help us recalculate the pane's proportion
if dock.IsHorizontal():
oldPixsize = pane.rect.width
newPixsize = oldPixsize + newPos.x - self._action_part.rect.x
else:
oldPixsize = pane.rect.height
newPixsize = oldPixsize + newPos.y - self._action_part.rect.y
totalPixsize, totalProportion = self.GetTotalPixsizeAndProportion(dock)
partnerPane = self.GetPartnerPane(dock, pane)
# prevent division by zero
if totalPixsize <= 0 or totalProportion <= 0 or not partnerPane:
return
# adjust for the surplus
while (oldPixsize > 0 and totalPixsize > 10 and \
oldPixsize*totalProportion/totalPixsize < pane.dock_proportion):
totalPixsize -= 1
# calculate the new proportion of the pane
newProportion = newPixsize*totalProportion/totalPixsize
newProportion = Clip(newProportion, 1, totalProportion)
deltaProp = newProportion - pane.dock_proportion
if partnerPane.dock_proportion - deltaProp < 1:
deltaProp = partnerPane.dock_proportion - 1
newProportion = pane.dock_proportion + deltaProp
# borrow the space from our neighbor pane to the
# right or bottom (depending on orientation)
partnerPane.dock_proportion -= deltaProp
pane.dock_proportion = newProportion
self.Update()
return True
def OnLeftUp(self, event):
"""
Handles the ``wx.EVT_LEFT_UP`` event for L{AuiManager}.
:param `event`: a `wx.MouseEvent` to be processed.
"""
if self._action == actionResize:
## self._frame.Freeze()
self.OnLeftUp_Resize(event)
## self._frame.Thaw()
elif self._action == actionClickButton:
self.OnLeftUp_ClickButton(event)
elif self._action == actionDragFloatingPane:
self.OnLeftUp_DragFloatingPane(event)
elif self._action == actionDragToolbarPane:
self.OnLeftUp_DragToolbarPane(event)
else:
event.Skip()
if self._frame.HasCapture():
self._frame.ReleaseMouse()
self._action = actionNone
def OnMotion(self, event):
"""
Handles the ``wx.EVT_MOTION`` event for L{AuiManager}.
:param `event`: a `wx.MouseEvent` to be processed.
"""
if self._action == actionResize:
self.OnMotion_Resize(event)
elif self._action == actionClickCaption:
self.OnMotion_ClickCaption(event)
elif self._action == actionDragFloatingPane:
self.OnMotion_DragFloatingPane(event)
elif self._action == actionDragToolbarPane:
self.OnMotion_DragToolbarPane(event)
else:
self.OnMotion_Other(event)
def OnLeaveWindow(self, event):
"""
Handles the ``wx.EVT_LEAVE_WINDOW`` event for L{AuiManager}.
:param `event`: a `wx.MouseEvent` to be processed.
"""
if self._hover_button:
self.RefreshButton(self._hover_button)
self._hover_button = None
def OnCaptureLost(self, event):
"""
Handles the ``wx.EVT_MOUSE_CAPTURE_LOST`` event for L{AuiManager}.
:param `event`: a `wx.MouseCaptureLostEvent` to be processed.
"""
# cancel the operation in progress, if any
if self._action != actionNone:
self._action = actionNone
self.HideHint()
def OnHintFadeTimer(self, event):
"""
Handles the ``wx.EVT_TIMER`` event for L{AuiManager}.
:param `event`: a `wx.TimerEvent` to be processed.
"""
if not self._hint_window or self._hint_fadeamt >= self._hint_fademax:
self._hint_fadetimer.Stop()
return
self._hint_fadeamt += 4
self._hint_window.SetTransparent(self._hint_fadeamt)
def OnMove(self, event):
"""
Handles the ``wx.EVT_MOVE`` event for L{AuiManager}.
:param `event`: a `wx.MoveEvent` to be processed.
"""
if isinstance(self._frame, AuiFloatingFrame) and self._frame.IsShownOnScreen():
if event is not None:
event.Skip()
return
docked, hAlign, vAlign, monitor = self._is_docked
if docked:
self.Snap()
for pane in self._panes:
if pane.IsSnappable():
if pane.IsFloating() and pane.IsShown():
self.SnapPane(pane, pane.floating_pos, pane.floating_size, True)
def OnSysColourChanged(self, event):
"""
Handles the ``wx.EVT_SYS_COLOUR_CHANGED`` event for L{AuiManager}.
:param `event`: a `wx.SysColourChangedEvent` to be processed.
"""
# This event is probably triggered by a theme change
# so we have to re-init the art provider.
if self._art:
self._art.Init()
if self._frame:
self.Update()
self._frame.Refresh()
def OnChildFocus(self, event):
"""
Handles the ``wx.EVT_CHILD_FOCUS`` event for L{AuiManager}.
:param `event`: a `wx.ChildFocusEvent` to be processed.
"""
# when a child pane has it's focus set, we should change the
# pane's active state to reflect this. (this is only true if
# active panes are allowed by the owner)
window = event.GetWindow()
if isinstance(window, wx.Dialog):
# Ignore EVT_CHILD_FOCUS events originating from dialogs not
# managed by AUI
rootManager = None
elif isinstance(window.GetParent(), AuiFloatingFrame):
rootManager = GetManager(window)
else:
rootManager = self
if rootManager:
rootManager.ActivatePane(window)
event.Skip()
def OnMotion_ClickCaption(self, event):
"""
Sub-handler for the L{OnMotion} event.
:param `event`: a `wx.MouseEvent` to be processed.
"""
clientPt = event.GetPosition()
screenPt = self._frame.ClientToScreen(clientPt)
drag_x_threshold = wx.SystemSettings.GetMetric(wx.SYS_DRAG_X)
drag_y_threshold = wx.SystemSettings.GetMetric(wx.SYS_DRAG_Y)
if not self._action_pane:
return
# we need to check if the mouse is now being dragged
if not (abs(clientPt.x - self._action_start.x) > drag_x_threshold or \
abs(clientPt.y - self._action_start.y) > drag_y_threshold):
return
# dragged -- we need to change the mouse action to 'drag'
if self._action_pane.IsToolbar():
self._action = actionDragToolbarPane
self._action_window = self._action_pane.window
elif self._action_pane.IsFloatable() and self._agwFlags & AUI_MGR_ALLOW_FLOATING:
e = self.FireEvent(wxEVT_AUI_PANE_FLOATING, self._action_pane, canVeto=True)
if e.GetVeto():
return
self._action = actionDragFloatingPane
# set initial float position
self._action_pane.floating_pos = screenPt - self._action_offset
# float the window
if self._action_pane.IsMaximized():
self.RestorePane(self._action_pane)
self._action_pane.Hide()
self._action_pane.Float()
if wx.Platform == "__WXGTK__":
self._action_pane.Show()
e = self.FireEvent(wxEVT_AUI_PANE_FLOATED, self._action_pane, canVeto=False)
if not self._action_pane.frame:
self.Update()
self._action_window = self._action_pane.window
# adjust action offset for window frame
windowPt = self._action_pane.frame.GetRect().GetTopLeft()
originPt = self._action_pane.frame.ClientToScreen(wx.Point())
self._toolbar_action_offset = originPt - windowPt
if self._agwFlags & AUI_MGR_USE_NATIVE_MINIFRAMES:
originPt = windowPt + wx.Point(3, 3)
self._action_offset += originPt - windowPt
# action offset is used here to make it feel "natural" to the user
# to drag a docked pane and suddenly have it become a floating frame.
# Sometimes, however, the offset where the user clicked on the docked
# caption is bigger than the width of the floating frame itself, so
# in that case we need to set the action offset to a sensible value
frame_size = self._action_pane.frame.GetSize()
if self._action_offset.x > frame_size.x * 2 / 3:
self._action_offset.x = frame_size.x / 2
if self._action_offset.y > frame_size.y * 2 / 3:
self._action_offset.y = frame_size.y / 2
self.OnMotion_DragFloatingPane(event)
if wx.Platform != "__WXGTK__":
self._action_pane.Show()
self.Update()
def OnMotion_Resize(self, event):
"""
Sub-handler for the L{OnMotion} event.
:param `event`: a `wx.MouseEvent` to be processed.
"""
if AuiManager_HasLiveResize(self):
if self._currentDragItem != -1:
self._action_part = self._uiparts[self._currentDragItem]
else:
self._currentDragItem = self._uiparts.index(self._action_part)
if self._frame.HasCapture():
self._frame.ReleaseMouse()
self.DoEndResizeAction(event)
self._frame.CaptureMouse()
return
if not self._action_part or not self._action_part.dock or not self._action_part.orientation:
return
clientPt = event.GetPosition()
screenPt = self._frame.ClientToScreen(clientPt)
dock = self._action_part.dock
pos = self._action_part.rect.GetPosition()
if self._action_part.type == AuiDockUIPart.typeDockSizer:
minPix, maxPix = self.CalculateDockSizerLimits(dock)
else:
if not self._action_part.pane:
return
pane = self._action_part.pane
minPix, maxPix = self.CalculatePaneSizerLimits(dock, pane)
if self._action_part.orientation == wx.HORIZONTAL:
pos.y = Clip(clientPt.y - self._action_offset.y, minPix, maxPix)
else:
pos.x = Clip(clientPt.x - self._action_offset.x, minPix, maxPix)
hintrect = wx.RectPS(self._frame.ClientToScreen(pos), self._action_part.rect.GetSize())
if hintrect != self._action_rect:
if wx.Platform == "__WXMAC__":
dc = wx.ClientDC(self._frame)
else:
dc = wx.ScreenDC()
DrawResizeHint(dc, self._action_rect)
DrawResizeHint(dc, hintrect)
self._action_rect = wx.Rect(*hintrect)
def OnLeftUp_Resize(self, event):
"""
Sub-handler for the L{OnLeftUp} event.
:param `event`: a `wx.MouseEvent` to be processed.
"""
if self._currentDragItem != -1 and AuiManager_HasLiveResize(self):
self._action_part = self._uiparts[self._currentDragItem]
if self._frame.HasCapture():
self._frame.ReleaseMouse()
self.DoEndResizeAction(event)
self._currentDragItem = -1
return
if not self._action_part or not self._action_part.dock:
return
clientPt = event.GetPosition()
screenPt = self._frame.ClientToScreen(clientPt)
return self.RestrictResize(clientPt, screenPt, createDC=True)
def OnLeftUp_ClickButton(self, event):
"""
Sub-handler for the L{OnLeftUp} event.
:param `event`: a `wx.MouseEvent` to be processed.
"""
self._hover_button = None
if self._action_part:
self.RefreshButton(self._action_part)
# make sure we're still over the item that was originally clicked
if self._action_part == self.HitTest(*event.GetPosition()):
# fire button-click event
e = AuiManagerEvent(wxEVT_AUI_PANE_BUTTON)
e.SetManager(self)
e.SetPane(self._action_part.pane)
e.SetButton(self._action_part.button.button_id)
self.ProcessMgrEvent(e)
def CheckPaneMove(self, pane):
"""
Checks if a pane has moved by a visible amount.
:param `pane`: an instance of L{AuiPaneInfo}.
"""
win_rect = pane.frame.GetRect()
win_rect.x, win_rect.y = pane.floating_pos
if win_rect == self._last_rect:
return False
# skip the first move event
if self._last_rect.IsEmpty():
self._last_rect = wx.Rect(*win_rect)
return False
# skip if moving too fast to avoid massive redraws and
# jumping hint windows
if abs(win_rect.x - self._last_rect.x) > 10 or \
abs(win_rect.y - self._last_rect.y) > 10:
self._last_rect = wx.Rect(*win_rect)
return False
return True
def OnMotion_DragFloatingPane(self, eventOrPt):
"""
Sub-handler for the L{OnMotion} event.
:param `event`: a `wx.MouseEvent` to be processed.
"""
isPoint = False
if isinstance(eventOrPt, wx.Point):
clientPt = self._frame.ScreenToClient(eventOrPt)
screenPt = wx.Point(*eventOrPt)
isPoint = True
else:
clientPt = eventOrPt.GetPosition()
screenPt = self._frame.ClientToScreen(clientPt)
framePos = wx.Point()
# try to find the pane
pane = self.GetPane(self._action_window)
if not pane.IsOk():
raise Exception("Pane window not found")
# update floating position
if pane.IsFloating():
diff = pane.floating_pos - (screenPt - self._action_offset)
pane.floating_pos = screenPt - self._action_offset
framePos = pane.floating_pos
# Move the pane window
if pane.frame:
if diff.x != 0 or diff.y != 0:
if wx.Platform == "__WXMSW__" and (self._agwFlags & AUI_MGR_TRANSPARENT_DRAG) == 0: # and not self.CheckPaneMove(pane):
# return
# HACK: Terrible hack on wxMSW (!)
pane.frame.SetTransparent(254)
self._from_move = True
pane.frame.Move(pane.floating_pos)
self._from_move = False
if self._agwFlags & AUI_MGR_TRANSPARENT_DRAG:
pane.frame.SetTransparent(150)
# calculate the offset from the upper left-hand corner
# of the frame to the mouse pointer
action_offset = screenPt - framePos
# is the pane dockable?
if not self.CanDockPanel(pane):
self.HideHint()
ShowDockingGuides(self._guides, False)
return
for paneInfo in self._panes:
if not paneInfo.IsDocked() or not paneInfo.IsShown():
continue
if paneInfo.IsToolbar() or paneInfo.IsNotebookControl():
continue
if paneInfo.IsMaximized():
continue
if paneInfo.IsNotebookPage():
notebookRoot = GetNotebookRoot(self._panes, paneInfo.notebook_id)
if not notebookRoot or not notebookRoot.IsDocked():
continue
rc = paneInfo.window.GetScreenRect()
if rc.Contains(screenPt):
if rc.height < 20 or rc.width < 20:
return
self.UpdateDockingGuides(paneInfo)
ShowDockingGuides(self._guides, True)
break
self.DrawHintRect(pane.window, clientPt, action_offset)
def OnLeftUp_DragFloatingPane(self, eventOrPt):
"""
Sub-handler for the L{OnLeftUp} event.
:param `event`: a `wx.MouseEvent` to be processed.
"""
if isinstance(eventOrPt, wx.Point):
clientPt = self._frame.ScreenToClient(eventOrPt)
screenPt = wx.Point(*eventOrPt)
else:
clientPt = eventOrPt.GetPosition()
screenPt = self._frame.ClientToScreen(clientPt)
# try to find the pane
paneInfo = self.GetPane(self._action_window)
if not paneInfo.IsOk():
raise Exception("Pane window not found")
ret = False
if paneInfo.frame:
# calculate the offset from the upper left-hand corner
# of the frame to the mouse pointer
framePos = paneInfo.frame.GetPosition()
action_offset = screenPt - framePos
# is the pane dockable?
if self.CanDockPanel(paneInfo):
# do the drop calculation
indx = self._panes.index(paneInfo)
ret, paneInfo = self.DoDrop(self._docks, self._panes, paneInfo, clientPt, action_offset)
if ret:
e = self.FireEvent(wxEVT_AUI_PANE_DOCKING, paneInfo, canVeto=True)
if e.GetVeto():
self.HideHint()
ShowDockingGuides(self._guides, False)
return
e = self.FireEvent(wxEVT_AUI_PANE_DOCKED, paneInfo, canVeto=False)
if self._agwFlags & AUI_MGR_SMOOTH_DOCKING:
self.SmoothDock(paneInfo)
self._panes[indx] = paneInfo
# if the pane is still floating, update it's floating
# position (that we store)
if paneInfo.IsFloating():
paneInfo.floating_pos = paneInfo.frame.GetPosition()
if paneInfo.frame._transparent != paneInfo.transparent or self._agwFlags & AUI_MGR_TRANSPARENT_DRAG:
paneInfo.frame.SetTransparent(paneInfo.transparent)
paneInfo.frame._transparent = paneInfo.transparent
elif self._has_maximized:
self.RestoreMaximizedPane()
# reorder for dropping to a new notebook
# (caution: this code breaks the reference!)
tempPaneInfo = self.CopyTarget(paneInfo)
self._panes.remove(paneInfo)
self._panes.append(tempPaneInfo)
if ret:
self.Update()
self.HideHint()
ShowDockingGuides(self._guides, False)
def OnMotion_DragToolbarPane(self, eventOrPt):
"""
Sub-handler for the L{OnMotion} event.
:param `event`: a `wx.MouseEvent` to be processed.
"""
isPoint = False
if isinstance(eventOrPt, wx.Point):
clientPt = self._frame.ScreenToClient(eventOrPt)
screenPt = wx.Point(*eventOrPt)
isPoint = True
else:
clientPt = eventOrPt.GetPosition()
screenPt = self._frame.ClientToScreen(clientPt)
pane = self.GetPane(self._action_window)
if not pane.IsOk():
raise Exception("Pane window not found")
pane.state |= AuiPaneInfo.actionPane
indx = self._panes.index(pane)
ret = False
wasFloating = pane.IsFloating()
# is the pane dockable?
if self.CanDockPanel(pane):
# do the drop calculation
ret, pane = self.DoDrop(self._docks, self._panes, pane, clientPt, self._action_offset)
# update floating position
if pane.IsFloating():
pane.floating_pos = screenPt - self._toolbar_action_offset
# move the pane window
if pane.frame:
if wx.Platform == "__WXMSW__" and (self._agwFlags & AUI_MGR_TRANSPARENT_DRAG) == 0: # and not self.CheckPaneMove(pane):
# return
# HACK: Terrible hack on wxMSW (!)
pane.frame.SetTransparent(254)
self._from_move = True
pane.frame.Move(pane.floating_pos)
self._from_move = False
if self._agwFlags & AUI_MGR_TRANSPARENT_DRAG:
pane.frame.SetTransparent(150)
self._panes[indx] = pane
if ret and wasFloating != pane.IsFloating() or (ret and not wasFloating):
wx.CallAfter(self.Update)
# when release the button out of the window.
# TODO: a better fix is needed.
if not wx.GetMouseState().LeftDown():
self._action = actionNone
self.OnLeftUp_DragToolbarPane(eventOrPt)
def OnMotion_Other(self, event):
"""
Sub-handler for the L{OnMotion} event.
:param `event`: a `wx.MouseEvent` to be processed.
"""
part = self.HitTest(*event.GetPosition())
if part and part.type == AuiDockUIPart.typePaneButton \
and self.IsPaneButtonVisible(part):
if part != self._hover_button:
if self._hover_button:
self.RefreshButton(self._hover_button)
self._hover_button = part
self.RefreshButton(part)
else:
if self._hover_button:
self.RefreshButton(self._hover_button)
else:
event.Skip()
self._hover_button = None
def OnLeftUp_DragToolbarPane(self, eventOrPt):
"""
Sub-handler for the L{OnLeftUp} event.
:param `event`: a `wx.MouseEvent` to be processed.
"""
isPoint = False
if isinstance(eventOrPt, wx.Point):
clientPt = self._frame.ScreenToClient(eventOrPt)
screenPt = wx.Point(*eventOrPt)
isPoint = True
else:
clientPt = eventOrPt.GetPosition()
screenPt = self._frame.ClientToScreen(clientPt)
# try to find the pane
pane = self.GetPane(self._action_window)
if not pane.IsOk():
raise Exception("Pane window not found")
if pane.IsFloating():
pane.floating_pos = pane.frame.GetPosition()
if pane.frame._transparent != pane.transparent or self._agwFlags & AUI_MGR_TRANSPARENT_DRAG:
pane.frame.SetTransparent(pane.transparent)
pane.frame._transparent = pane.transparent
# save the new positions
docks = FindDocks(self._docks, pane.dock_direction, pane.dock_layer, pane.dock_row)
if len(docks) == 1:
dock = docks[0]
pane_positions, pane_sizes = self.GetPanePositionsAndSizes(dock)
for i in xrange(len(dock.panes)):
dock.panes[i].dock_pos = pane_positions[i]
pane.state &= ~AuiPaneInfo.actionPane
self.Update()
def OnPaneButton(self, event):
"""
Handles the ``EVT_AUI_PANE_BUTTON`` event for L{AuiManager}.
:param `event`: a `EVT_AUI_PANE_BUTTON` to be processed.
"""
if not event.pane:
raise Exception("Pane Info passed to AuiManager.OnPaneButton must be non-null")
pane = event.pane
if event.button == AUI_BUTTON_CLOSE:
if isinstance(pane.window.GetParent(), AuiFloatingFrame):
rootManager = GetManager(pane.window)
else:
rootManager = self
if rootManager != self:
self._frame.Close()
return
# fire pane close event
e = AuiManagerEvent(wxEVT_AUI_PANE_CLOSE)
e.SetManager(self)
e.SetPane(event.pane)
self.ProcessMgrEvent(e)
if not e.GetVeto():
# close the pane, but check that it
# still exists in our pane array first
# (the event handler above might have removed it)
check = self.GetPane(pane.window)
if check.IsOk():
self.ClosePane(pane)
self.Update()
# mn this performs the minimizing of a pane
elif event.button == AUI_BUTTON_MINIMIZE:
e = AuiManagerEvent(wxEVT_AUI_PANE_MINIMIZE)
e.SetManager(self)
e.SetPane(event.pane)
self.ProcessMgrEvent(e)
if not e.GetVeto():
self.MinimizePane(pane)
elif event.button == AUI_BUTTON_MAXIMIZE_RESTORE and not pane.IsMaximized():
# fire pane close event
e = AuiManagerEvent(wxEVT_AUI_PANE_MAXIMIZE)
e.SetManager(self)
e.SetPane(event.pane)
self.ProcessMgrEvent(e)
if not e.GetVeto():
self.MaximizePane(pane)
self.Update()
elif event.button == AUI_BUTTON_MAXIMIZE_RESTORE and pane.IsMaximized():
# fire pane close event
e = AuiManagerEvent(wxEVT_AUI_PANE_RESTORE)
e.SetManager(self)
e.SetPane(event.pane)
self.ProcessMgrEvent(e)
if not e.GetVeto():
self.RestorePane(pane)
self.Update()
elif event.button == AUI_BUTTON_PIN:
if self._agwFlags & AUI_MGR_ALLOW_FLOATING and pane.IsFloatable():
e = self.FireEvent(wxEVT_AUI_PANE_FLOATING, pane, canVeto=True)
if e.GetVeto():
return
pane.Float()
e = self.FireEvent(wxEVT_AUI_PANE_FLOATED, pane, canVeto=False)
self.Update()
def MinimizePane(self, paneInfo):
"""
Minimizes a pane in a newly and automatically created 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.
:param `paneInfo`: a L{AuiPaneInfo} instance for the pane to be minimized.
"""
if not paneInfo.IsToolbar():
if paneInfo.IsMinimized():
# We are already minimized
return
# Basically the idea is this.
#
# 1) create a toolbar, with a restore button
#
# 2) place the new toolbar in the toolbar area representative of the location of the pane
# (NORTH/SOUTH/EAST/WEST, central area always to the right)
#
# 3) Hide the minimizing pane
# personalize the toolbar style
tbStyle = AUI_TB_DEFAULT_STYLE
posMask = paneInfo.minimize_mode & AUI_MINIMIZE_POS_MASK
captMask = paneInfo.minimize_mode & AUI_MINIMIZE_CAPT_MASK
dockDirection = paneInfo.dock_direction
if captMask != 0:
tbStyle |= AUI_TB_TEXT
if posMask == AUI_MINIMIZE_POS_SMART:
if paneInfo.dock_direction in [AUI_DOCK_TOP, AUI_DOCK_BOTTOM]:
tbStyle |= AUI_TB_HORZ_LAYOUT
elif paneInfo.dock_direction in [AUI_DOCK_LEFT, AUI_DOCK_RIGHT, AUI_DOCK_CENTER]:
tbStyle |= AUI_TB_VERTICAL
if captMask == AUI_MINIMIZE_CAPT_SMART:
tbStyle |= AUI_TB_CLOCKWISE
elif posMask in [AUI_MINIMIZE_POS_TOP, AUI_MINIMIZE_POS_BOTTOM]:
tbStyle |= AUI_TB_HORZ_LAYOUT
if posMask == AUI_MINIMIZE_POS_TOP:
dockDirection = AUI_DOCK_TOP
else:
dockDirection = AUI_DOCK_BOTTOM
else:
tbStyle |= AUI_TB_VERTICAL
if captMask == AUI_MINIMIZE_CAPT_SMART:
tbStyle |= AUI_TB_CLOCKWISE
if posMask == AUI_MINIMIZE_POS_LEFT:
dockDirection = AUI_DOCK_LEFT
elif posMask == AUI_MINIMIZE_POS_RIGHT:
dockDirection = AUI_DOCK_RIGHT
elif posMask == AUI_MINIMIZE_POS_BOTTOM:
dockDirection = AUI_DOCK_BOTTOM
# Create a new toolbar
# give it the same name as the minimized pane with _min appended
win_rect = paneInfo.window.GetScreenRect()
minimize_toolbar = auibar.AuiToolBar(self.GetManagedWindow(), agwStyle=tbStyle)
minimize_toolbar.Hide()
minimize_toolbar.SetToolBitmapSize(wx.Size(16, 16))
if paneInfo.icon and paneInfo.icon.IsOk():
restore_bitmap = paneInfo.icon
else:
restore_bitmap = self._art._restore_bitmap
minimize_toolbar.AddSimpleTool(ID_RESTORE_FRAME, paneInfo.caption, restore_bitmap, "Restore " + paneInfo.caption)
minimize_toolbar.SetAuiManager(self)
minimize_toolbar.Realize()
toolpanelname = paneInfo.name + "_min"
if paneInfo.IsMaximized():
paneInfo.SetFlag(paneInfo.wasMaximized, True)
if dockDirection == AUI_DOCK_TOP:
self.AddPane(minimize_toolbar, AuiPaneInfo(). \
Name(toolpanelname).Caption(paneInfo.caption). \
ToolbarPane().Top().BottomDockable(False). \
LeftDockable(False).RightDockable(False).DestroyOnClose())
elif dockDirection == AUI_DOCK_BOTTOM:
self.AddPane(minimize_toolbar, AuiPaneInfo(). \
Name(toolpanelname).Caption(paneInfo.caption). \
ToolbarPane().Bottom().TopDockable(False). \
LeftDockable(False).RightDockable(False).DestroyOnClose())
elif dockDirection == AUI_DOCK_LEFT:
self.AddPane(minimize_toolbar, AuiPaneInfo(). \
Name(toolpanelname).Caption(paneInfo.caption). \
ToolbarPane().Left().TopDockable(False). \
BottomDockable(False).RightDockable(False).DestroyOnClose())
elif dockDirection in [AUI_DOCK_RIGHT, AUI_DOCK_CENTER]:
self.AddPane(minimize_toolbar, AuiPaneInfo(). \
Name(toolpanelname).Caption(paneInfo.caption). \
ToolbarPane().Right().TopDockable(False). \
LeftDockable(False).BottomDockable(False).DestroyOnClose())
arr = FindDocks(self._docks, paneInfo.dock_direction, paneInfo.dock_layer, paneInfo.dock_row)
if arr:
dock = arr[0]
paneInfo.previousDockSize = dock.size
paneInfo.previousDockPos = paneInfo.dock_pos
# mark ourselves minimized
paneInfo.Minimize()
paneInfo.Show(False)
self._has_minimized = True
# last, hide the window
if paneInfo.window and paneInfo.window.IsShown():
paneInfo.window.Show(False)
minimize_toolbar.Show()
self.Update()
if self._agwFlags & AUI_MGR_ANIMATE_FRAMES:
self.AnimateDocking(win_rect, minimize_toolbar.GetScreenRect())
def OnRestoreMinimizedPane(self, event):
"""
Handles the ``EVT_AUI_PANE_MIN_RESTORE`` event for L{AuiManager}.
:param `event`: an instance of L{AuiManagerEvent} to be processed.
"""
self.RestoreMinimizedPane(event.pane)
def OnPaneDocked(self, event):
"""
Handles the ``EVT_AUI_PANE_DOCKED`` event for L{AuiManager}.
:param `event`: an instance of L{AuiManagerEvent} to be processed.
"""
event.Skip()
self.RemoveAutoNBCaption(event.GetPane())
def RemoveAutoNBCaption(self, pane):
"""
Removes the caption on newly created automatic notebooks.
:param `pane`: an instance of L{AuiPaneInfo} (the target notebook).
"""
if self._agwFlags & AUI_MGR_AUTONB_NO_CAPTION == 0:
return False
def RemoveCaption():
""" Sub-function used to remove the pane caption on automatic notebooks. """
if pane.HasNotebook():
notebook = self._notebooks[pane.notebook_id]
self.GetPane(notebook).CaptionVisible(False).PaneBorder(False)
self.Update()
# it seems the notebook isnt created by this stage, so remove
# the caption a moment later
wx.CallAfter(RemoveCaption)
return True
def RestoreMinimizedPane(self, paneInfo):
"""
Restores a previously minimized pane.
:param `paneInfo`: a L{AuiPaneInfo} instance for the pane to be restored.
"""
panename = paneInfo.name
panename = panename[0:-4]
pane = self.GetPane(panename)
pane.SetFlag(pane.needsRestore, True)
if not pane.IsOk():
panename = paneInfo.name
pane = self.GetPane(panename)
paneInfo = self.GetPane(panename + "_min")
if not paneInfo.IsOk():
# Already minimized
return
if pane.IsOk():
if not pane.IsMinimized():
return
if pane.HasFlag(pane.wasMaximized):
self.SavePreviousDockSizes(pane)
self.ShowPane(pane.window, True)
pane.Show(True)
self._has_minimized = False
pane.SetFlag(pane.optionMinimized, False)
paneInfo.window.Show(False)
self.DetachPane(paneInfo.window)
paneInfo.Show(False)
paneInfo.Hide()
self.Update()
def AnimateDocking(self, win_rect, pane_rect):
"""
Animates the minimization/docking of a pane a la Eclipse, using a `wx.ScreenDC`
to draw a "moving docking rectangle" on the screen.
:param `win_rect`: the original pane screen rectangle;
:param `pane_rect`: the newly created toolbar/pane screen rectangle.
"""
if wx.Platform == "__WXMAC__":
# No wx.ScreenDC on the Mac...
return
if wx.Platform == "__WXMSW__" and wx.GetOsVersion()[1] > 5:
# No easy way to handle this on Vista...
return
xstart, ystart = win_rect.x, win_rect.y
xend, yend = pane_rect.x, pane_rect.y
step = self.GetAnimationStep()
wstep = int(abs(win_rect.width - pane_rect.width)/step)
hstep = int(abs(win_rect.height - pane_rect.height)/step)
xstep = int(win_rect.x - pane_rect.x)/step
ystep = int(win_rect.y - pane_rect.y)/step
dc = wx.ScreenDC()
dc.SetLogicalFunction(wx.INVERT)
dc.SetBrush(wx.TRANSPARENT_BRUSH)
dc.SetPen(wx.LIGHT_GREY_PEN)
for i in xrange(int(step)):
width, height = win_rect.width - i*wstep, win_rect.height - i*hstep
x, y = xstart - i*xstep, ystart - i*ystep
new_rect = wx.Rect(x, y, width, height)
dc.DrawRoundedRectangleRect(new_rect, 3)
wx.SafeYield()
wx.MilliSleep(10)
dc.DrawRoundedRectangleRect(new_rect, 3)
def SmoothDock(self, paneInfo):
"""
This method implements a smooth docking effect for floating panes, similar to
what the PyQT library does with its floating windows.
:param `paneInfo`: an instance of L{AuiPaneInfo}.
:note: The smooth docking effect can only be used if you set the ``AUI_MGR_SMOOTH_DOCKING``
style to L{AuiManager}.
"""
if paneInfo.IsToolbar():
return
if not paneInfo.frame or self._hint_rect.IsEmpty():
return
hint_rect = self._hint_rect
win_rect = paneInfo.frame.GetScreenRect()
xstart, ystart = win_rect.x, win_rect.y
xend, yend = hint_rect.x, hint_rect.y
step = self.GetAnimationStep()/3
wstep = int((win_rect.width - hint_rect.width)/step)
hstep = int((win_rect.height - hint_rect.height)/step)
xstep = int((win_rect.x - hint_rect.x))/step
ystep = int((win_rect.y - hint_rect.y))/step
for i in xrange(int(step)):
width, height = win_rect.width - i*wstep, win_rect.height - i*hstep
x, y = xstart - i*xstep, ystart - i*ystep
new_rect = wx.Rect(x, y, width, height)
paneInfo.frame.SetRect(new_rect)
wx.MilliSleep(10)
def SetSnapLimits(self, x, y):
"""
Modifies the snap limits used when snapping the `managed_window` to the screen
(using L{SnapToScreen}) or when snapping the floating panes to one side of the
`managed_window` (using L{SnapPane}).
To change the limit after which the `managed_window` or the floating panes are
automatically stickled to the screen border (or to the `managed_window` side),
set these two variables. Default values are 15 pixels.
:param `x`: the minimum horizontal distance below which the snap occurs;
:param `y`: the minimum vertical distance below which the snap occurs.
"""
self._snap_limits = (x, y)
self.Snap()
def Snap(self):
"""
Snaps the main frame to specified position on the screen.
:see: L{SnapToScreen}
"""
snap, hAlign, vAlign, monitor = self._is_docked
if not snap:
return
managed_window = self.GetManagedWindow()
snap_pos = self.GetSnapPosition()
wnd_pos = managed_window.GetPosition()
snapX, snapY = self._snap_limits
if abs(snap_pos.x - wnd_pos.x) < snapX and abs(snap_pos.y - wnd_pos.y) < snapY:
managed_window.SetPosition(snap_pos)
def SnapToScreen(self, snap=True, monitor=0, hAlign=wx.RIGHT, vAlign=wx.TOP):
"""
Snaps the main frame to specified position on the screen.
:param `snap`: whether to snap the main frame or not;
:param `monitor`: the monitor display in which snapping the window;
:param `hAlign`: the horizontal alignment of the snapping position;
:param `vAlign`: the vertical alignment of the snapping position.
"""
if not snap:
self._is_docked = (False, wx.RIGHT, wx.TOP, 0)
return
displayCount = wx.Display.GetCount()
if monitor > displayCount:
raise Exception("Invalid monitor selected: you only have %d monitors"%displayCount)
self._is_docked = (True, hAlign, vAlign, monitor)
self.GetManagedWindow().SetPosition(self.GetSnapPosition())
def GetSnapPosition(self):
""" Returns the main frame snapping position. """
snap, hAlign, vAlign, monitor = self._is_docked
display = wx.Display(monitor)
area = display.GetClientArea()
size = self.GetManagedWindow().GetSize()
pos = wx.Point()
if hAlign == wx.LEFT:
pos.x = area.x
elif hAlign == wx.CENTER:
pos.x = area.x + (area.width - size.x)/2
else:
pos.x = area.x + area.width - size.x
if vAlign == wx.TOP:
pos.y = area.y
elif vAlign == wx.CENTER:
pos.y = area.y + (area.height - size.y)/2
else:
pos.y = area.y + area.height - size.y
return pos
def GetAnimationStep(self):
""" Returns the animation step speed (a float) to use in L{AnimateDocking}. """
return self._animation_step
def SetAnimationStep(self, step):
"""
Sets the animation step speed (a float) to use in L{AnimateDocking}.
:param `step`: a floating point value for the animation speed.
"""
self._animation_step = float(step)
def RequestUserAttention(self, pane_window):
"""
Requests the user attention by intermittently highlighting the pane caption.
:param `pane_window`: a `wx.Window` derived window, managed by the pane.
"""
# try to find the pane
paneInfo = self.GetPane(pane_window)
if not paneInfo.IsOk():
raise Exception("Pane window not found")
dc = wx.ClientDC(self._frame)
# if the frame is about to be deleted, don't bother
if not self._frame or self._frame.IsBeingDeleted():
return
if not self._frame.GetSizer():
return
for part in self._uiparts:
if part.pane == paneInfo:
self._art.RequestUserAttention(dc, self._frame, part.pane.caption, part.rect, part.pane)
self._frame.RefreshRect(part.rect, True)
break
def StartPreviewTimer(self, toolbar):
"""
Starts a timer for sliding in and out a minimized pane.
:param `toolbar`: the L{AuiToolBar} containing the minimized pane tool.
"""
toolbar_pane = self.GetPane(toolbar)
toolbar_name = toolbar_pane.name
pane_name = toolbar_name[0:-4]
self._sliding_pane = self.GetPane(pane_name)
self._sliding_rect = toolbar.GetScreenRect()
self._sliding_direction = toolbar_pane.dock_direction
self._sliding_frame = None
self._preview_timer.Start(1000, wx.TIMER_ONE_SHOT)
def StopPreviewTimer(self):
""" Stops a timer for sliding in and out a minimized pane. """
if self._preview_timer.IsRunning():
self._preview_timer.Stop()
self.SlideOut()
self._sliding_pane = None
def SlideIn(self, event):
"""
Handles the ``wx.EVT_TIMER`` event for L{AuiManager}.
:param `event`: a `wx.TimerEvent` to be processed.
:note: This is used solely for sliding in and out minimized panes.
"""
window = self._sliding_pane.window
self._sliding_frame = wx.MiniFrame(None, -1, title=_("Pane Preview"),
style=wx.FRAME_TOOL_WINDOW | wx.STAY_ON_TOP |
wx.FRAME_NO_TASKBAR | wx.CAPTION)
window.Reparent(self._sliding_frame)
self._sliding_frame.SetSize((0, 0))
window.Show()
self._sliding_frame.Show()
size = window.GetBestSize()
startX, startY, stopX, stopY = GetSlidingPoints(self._sliding_rect, size, self._sliding_direction)
step = stopX/10
window_size = 0
for i in xrange(0, stopX, step):
window_size = i
self._sliding_frame.SetDimensions(startX, startY, window_size, stopY)
self._sliding_frame.Refresh()
self._sliding_frame.Update()
wx.MilliSleep(10)
self._sliding_frame.SetDimensions(startX, startY, stopX, stopY)
self._sliding_frame.Refresh()
self._sliding_frame.Update()
def SlideOut(self):
""" Slides out a preview of a minimized pane. """
if not self._sliding_frame:
return
window = self._sliding_frame.GetChildren()[0]
size = window.GetBestSize()
startX, startY, stopX, stopY = GetSlidingPoints(self._sliding_rect, size, self._sliding_direction)
step = stopX/10
window_size = 0
for i in xrange(stopX, 0, -step):
window_size = i
self._sliding_frame.SetDimensions(startX, startY, window_size, stopY)
self._sliding_frame.Refresh()
self._sliding_frame.Update()
self._frame.RefreshRect(wx.Rect(startX+window_size, startY, step, stopY))
self._frame.Update()
wx.MilliSleep(10)
self._sliding_frame.SetDimensions(startX, startY, 0, stopY)
window.Hide()
window.Reparent(self._frame)
self._sliding_frame.Hide()
self._sliding_frame.Destroy()
self._sliding_frame = None
self._sliding_pane = None
|