+# --------------------------------------------------------------------------- #
+# 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: 10 Mar 2011, 15.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
+
+# wxPython version string
+_VERSION_STRING = wx.VERSION_STRING
+
+# AUI Events
+wxEVT_AUI_PANE_BUTTON = wx.NewEventType()
+wxEVT_AUI_PANE_CLOSE = wx.NewEventType()
+wxEVT_AUI_PANE_MAXIMIZE = wx.NewEventType()
+wxEVT_AUI_PANE_RESTORE = wx.NewEventType()
+wxEVT_AUI_RENDER = wx.NewEventType()
+wxEVT_AUI_FIND_MANAGER = wx.NewEventType()
+wxEVT_AUI_PANE_MINIMIZE = wx.NewEventType()
+wxEVT_AUI_PANE_MIN_RESTORE = wx.NewEventType()
+wxEVT_AUI_PANE_FLOATING = wx.NewEventType()
+wxEVT_AUI_PANE_FLOATED = wx.NewEventType()
+wxEVT_AUI_PANE_DOCKING = wx.NewEventType()
+wxEVT_AUI_PANE_DOCKED = wx.NewEventType()
+wxEVT_AUI_PANE_ACTIVATED = wx.NewEventType()
+wxEVT_AUI_PERSPECTIVE_CHANGED = wx.NewEventType()
+
+EVT_AUI_PANE_BUTTON = wx.PyEventBinder(wxEVT_AUI_PANE_BUTTON, 0)
+""" Fires an event when the user left-clicks on a pane button. """
+EVT_AUI_PANE_CLOSE = wx.PyEventBinder(wxEVT_AUI_PANE_CLOSE, 0)
+""" A pane in `AuiManager` has been closed. """
+EVT_AUI_PANE_MAXIMIZE = wx.PyEventBinder(wxEVT_AUI_PANE_MAXIMIZE, 0)
+""" A pane in `AuiManager` has been maximized. """
+EVT_AUI_PANE_RESTORE = wx.PyEventBinder(wxEVT_AUI_PANE_RESTORE, 0)
+""" A pane in `AuiManager` has been restored from a maximized state. """
+EVT_AUI_RENDER = wx.PyEventBinder(wxEVT_AUI_RENDER, 0)
+""" Fires an event every time the AUI frame is being repainted. """
+EVT_AUI_FIND_MANAGER = wx.PyEventBinder(wxEVT_AUI_FIND_MANAGER, 0)
+""" Used to find which AUI manager is controlling a certain pane. """
+EVT_AUI_PANE_MINIMIZE = wx.PyEventBinder(wxEVT_AUI_PANE_MINIMIZE, 0)
+""" A pane in `AuiManager` has been minimized. """
+EVT_AUI_PANE_MIN_RESTORE = wx.PyEventBinder(wxEVT_AUI_PANE_MIN_RESTORE, 0)
+""" A pane in `AuiManager` has been restored from a minimized state. """
+EVT_AUI_PANE_FLOATING = wx.PyEventBinder(wxEVT_AUI_PANE_FLOATING, 0)
+""" A pane in `AuiManager` is about to be floated. """
+EVT_AUI_PANE_FLOATED = wx.PyEventBinder(wxEVT_AUI_PANE_FLOATED, 0)
+""" A pane in `AuiManager` has been floated. """
+EVT_AUI_PANE_DOCKING = wx.PyEventBinder(wxEVT_AUI_PANE_DOCKING, 0)
+""" A pane in `AuiManager` is about to be docked. """
+EVT_AUI_PANE_DOCKED = wx.PyEventBinder(wxEVT_AUI_PANE_DOCKED, 0)
+""" A pane in `AuiManager` has been docked. """
+EVT_AUI_PANE_ACTIVATED = wx.PyEventBinder(wxEVT_AUI_PANE_ACTIVATED, 0)
+""" A pane in `AuiManager` has been activated. """
+EVT_AUI_PERSPECTIVE_CHANGED = wx.PyEventBinder(wxEVT_AUI_PERSPECTIVE_CHANGED, 0)
+""" The layout in `AuiManager` has been changed. """
+
+# ---------------------------------------------------------------------------- #
+
+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 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 intentionally 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 intentionally 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 (an instance of `wx.Region`).
+
+ :note: Overridden for wxMac.
+ """
+
+ if wx.Platform == '__WXMAC__':
+ # HACK so we don't crash when SetShape is called
+ return
+ else:
+ super(AuiDockingHintWindow, self).SetShape(region)
+
+
+ def Show(self, show=True):
+ """
+ Show the hint window.
+
+ :param `show`: whether to show or hide the hint docking window.
+ """
+
+ super(AuiDockingHintWindow, self).Show(show)
+ if wx.Platform == '__WXMAC__':
+ # Need to manually do layout since its a borderless frame.
+ self.Layout()
+
+
+ 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())
+ self._mgr.SetAGWFlags(owner_mgr.GetAGWFlags())
+
+
+ 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):
+ self._pane_window.SetAuiManager(self._owner_mgr)
+
+ # if we do not do this, then we can crash...
+ if self._owner_mgr and self._owner_mgr._action_window == self:
+ self._owner_mgr._action_window = None
+
+ self.Destroy()
+
+
+ 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 _VERSION_STRING < "2.9":
+ leftDown = wx.GetMouseState().LeftDown()
+ else:
+ leftDown = wx.GetMouseState().LeftIsDown()
+
+ if not leftDown:
+ return
+
+ if not self._moving:
+ self.OnMoveStart(event)
+ self._moving = True
+
+ if self._last3_rect.IsEmpty():
+ return
+
+ self.OnMoving(event)
+
+
+ def OnIdle(self, event):
+ """
+ Handles the ``wx.EVT_IDLE`` event for L{AuiFloatingFrame}.
+
+ :param `event`: a `wx.IdleEvent` event to be processed.
+
+ :note: This event is only processed on wxMAC or if L{AuiManager} is using the
+ ``AUI_MGR_USE_NATIVE_MINIFRAMES`` style.
+ """
+
+ if self._moving:
+ if _VERSION_STRING < "2.9":
+ leftDown = wx.GetMouseState().LeftDown()
+ else:
+ leftDown = wx.GetMouseState().LeftIsDown()
+
+ if not leftDown:
+ self._moving = False
+ self.OnMoveFinished()
+ else:
+ event.RequestMore()
+
+
+ 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 _VERSION_STRING < "2.9":
+ leftDown = wx.GetMouseState().LeftDown()
+ else:
+ leftDown = wx.GetMouseState().LeftIsDown()
+
+ if leftDown:
+ return
+
+ rect = wx.Rect(*self.GetScreenRect())
+ rect.Inflate(10, 10)
+
+ if rect.Contains(wx.GetMousePosition()):
+ if not self._fly:
+ return
+ self._send_size = False
+ self._fly_timer.Start(5)
+ else:
+ if self._fly:
+ return
+ self._send_size = False
+ self._fly_timer.Start(5)
+
+
+ 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{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, an instance of L{AuiManagerEvent}.
+ """
+
+ # first, give the owner frame a chance to override
+ if self._frame:
+ if self._frame.GetEventHandler().ProcessEvent(event):
+ return
+
+ self.ProcessEvent(event)
+
+
+ def FireEvent(self, evtType, pane, canVeto=False):
+ """
+ Fires one of the ``EVT_AUI_PANE_FLOATED``/``FLOATING``/``DOCKING``/``DOCKED``/``ACTIVATED`` event.
+
+ :param `evtType`: one of the aforementioned events;
+ :param `pane`: the L{AuiPaneInfo} instance associated to this event;
+ :param `canVeto`: whether the event can be vetoed or not.
+ """
+
+ event = AuiManagerEvent(evtType)
+ event.SetPane(pane)
+ event.SetCanVeto(canVeto)
+ self.ProcessMgrEvent(event)
+
+ return event
+
+
+ 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. (additionally, target can be any pane in
+ an existing notebook)
+ """
+
+ if target in self._panes:
+ return self.AddPane4(window, arg1, target)
+
+ if type(arg1) == type(1):
+ # This Is Addpane2
+ if arg1 is None:
+ arg1 = wx.LEFT
+ if arg2 is None:
+ arg2 = ""
+ return self.AddPane2(window, arg1, arg2)
+ else:
+ if isinstance(arg2, wx.Point):
+ return self.AddPane3(window, arg1, arg2)
+ else:
+ return self.AddPane1(window, arg1)
+
+
+ def AddPane1(self, window, pane_info):
+ """ See comments on L{AddPane}. """
+
+ # check if the pane has a valid window
+ if not window:
+ return False
+
+ # check if the pane already exists
+ if self.GetPane(pane_info.window).IsOk():
+ return False
+
+ # check if the pane name already exists, this could reveal a
+ # bug in the library user's application
+ already_exists = False
+ if pane_info.name != "" and self.GetPane(pane_info.name).IsOk():
+ warnings.warn("A pane with the name '%s' already exists in the manager!"%pane_info.name)
+ already_exists = True
+
+ # if the new pane is docked then we should undo maximize
+ if pane_info.IsDocked():
+ self.RestoreMaximizedPane()
+
+ self._panes.append(pane_info)
+ pinfo = self._panes[-1]
+
+ # set the pane window
+ pinfo.window = window
+
+ # if the pane's name identifier is blank, create a random string
+ if pinfo.name == "" or already_exists:
+ pinfo.name = ("%s%08x%08x%08x")%(pinfo.window.GetName(), time.time(),
+ time.clock(), len(self._panes))
+
+ # set initial proportion (if not already set)
+ if pinfo.dock_proportion == 0:
+ pinfo.dock_proportion = 100000
+
+ floating = isinstance(self._frame, AuiFloatingFrame)
+
+ pinfo.buttons = []
+
+ if not floating and pinfo.HasMinimizeButton():
+ button = AuiPaneButton(AUI_BUTTON_MINIMIZE)
+ pinfo.buttons.append(button)
+
+ if not floating and pinfo.HasMaximizeButton():
+ button = AuiPaneButton(AUI_BUTTON_MAXIMIZE_RESTORE)
+ pinfo.buttons.append(button)
+
+ if not floating and pinfo.HasPinButton():
+ button = AuiPaneButton(AUI_BUTTON_PIN)
+ pinfo.buttons.append(button)
+
+ if pinfo.HasCloseButton():
+ button = AuiPaneButton(AUI_BUTTON_CLOSE)
+ pinfo.buttons.append(button)
+
+ if pinfo.HasGripper():
+ if isinstance(pinfo.window, auibar.AuiToolBar):
+ # prevent duplicate gripper -- both AuiManager and AuiToolBar
+ # have a gripper control. The toolbar's built-in gripper
+ # meshes better with the look and feel of the control than ours,
+ # so turn AuiManager's gripper off, and the toolbar's on.
+
+ tb = pinfo.window
+ pinfo.SetFlag(AuiPaneInfo.optionGripper, False)
+ tb.SetGripperVisible(True)
+
+ if pinfo.window:
+ if pinfo.best_size == wx.Size(-1, -1):
+ pinfo.best_size = pinfo.window.GetClientSize()
+
+ if isinstance(pinfo.window, wx.ToolBar):
+ # GetClientSize() doesn't get the best size for
+ # a toolbar under some newer versions of wxWidgets,
+ # so use GetBestSize()
+ pinfo.best_size = pinfo.window.GetBestSize()
+
+ # this is needed for Win2000 to correctly fill toolbar backround
+ # it should probably be repeated once system colour change happens
+ if wx.Platform == "__WXMSW__" and pinfo.window.UseBgCol():
+ pinfo.window.SetBackgroundColour(self.GetArtProvider().GetColour(AUI_DOCKART_BACKGROUND_COLOUR))
+
+ if pinfo.min_size != wx.Size(-1, -1):
+ if pinfo.best_size.x < pinfo.min_size.x:
+ pinfo.best_size.x = pinfo.min_size.x
+ if pinfo.best_size.y < pinfo.min_size.y:
+ pinfo.best_size.y = pinfo.min_size.y
+
+ self._panes[-1] = pinfo
+ if isinstance(window, auibar.AuiToolBar):
+ window.SetAuiManager(self)
+
+ return True
+
+
+ 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 paneInfo.IsNotebookDockable():
+ return self.AddPane1(window, pane_info)
+ if not target.IsNotebookDockable() and not target.IsNotebookControl():
+ return self.AddPane1(window, pane_info)
+
+ if not target.HasNotebook():
+ self.CreateNotebookBase(self._panes, target)
+
+ # Add new item to notebook
+ paneInfo.NotebookPage(target.notebook_id)
+
+ # we also want to remove our captions sometimes
+ self.RemoveAutoNBCaption(paneInfo)
+ self.UpdateNotebook()
+
+ return True
+
+
+ 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...
+ # the code would index out of bounds
+ # if the last page of a sub-notebook was closed
+ # because the notebook would be deleted, before this
+ # code is executed.
+ # This code just prevents an out-of bounds error.
+ if self._notebooks:
+ nid = pane_info.notebook_id
+ if nid >= 0 and nid < len(self._notebooks):
+ notebook = self._notebooks[nid]
+ page_idx = notebook.GetPageIndex(pane_info.window)
+ if page_idx >= 0:
+ notebook.RemovePage(page_idx)
+
+ # now we need to either destroy or hide the pane
+ to_destroy = 0
+ if pane_info.IsDestroyOnClose():
+ to_destroy = pane_info.window
+ self.DetachPane(to_destroy)
+ else:
+ if isinstance(pane_info.window, auibar.AuiToolBar) and pane_info.IsFloating():
+ tb = pane_info.window
+ if pane_info.dock_direction in [AUI_DOCK_LEFT, AUI_DOCK_RIGHT]:
+ tb.SetAGWWindowStyleFlag(tb.GetAGWWindowStyleFlag() | AUI_TB_VERTICAL)
+
+ pane_info.Dock().Hide()
+
+ if pane_info.IsNotebookControl():
+
+ notebook = self._notebooks[pane_info.notebook_id]
+ while notebook.GetPageCount():
+ window = notebook.GetPage(0)
+ notebook.RemovePage(0)
+ info = self.GetPane(window)
+ if info.IsOk():
+ info.notebook_id = -1
+ info.dock_direction = AUI_DOCK_NONE
+ # Note: this could change our paneInfo reference ...
+ self.ClosePane(info)
+
+ if to_destroy:
+ to_destroy.Destroy()
+
+
+ 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):
+ """
+ Stores the previous dock sizes, to be used in a "restore" action later.
+
+ :param `pane_info`: a L{AuiPaneInfo} instance.
+ """
+
+ for d in self._docks:
+ if not d.toolbar:
+ for p in d.panes:
+ p.previousDockSize = d.size
+ if pane_info is not p:
+ p.SetFlag(p.needsRestore, True)
+
+
+ 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()
+ self.FireEvent(wxEVT_AUI_PANE_ACTIVATED, window, canVeto=False)
+
+
+ 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 L{AuiNotebook} tabs by mouse middle button click
+ ``AUI_NB_SUB_NOTEBOOK`` This style is used by {AuiManager} to create automatic AuiNotebooks
+ ``AUI_NB_HIDE_ON_SINGLE_TAB`` Hides the tab window if only one tab is present
+ ``AUI_NB_SMART_TABS`` Use Smart Tabbing, like ``Alt`` + ``Tab`` on Windows
+ ``AUI_NB_USE_IMAGES_DROPDOWN`` Uses images on dropdown window list menu instead of check items
+ ``AUI_NB_CLOSE_ON_TAB_LEFT`` Draws the tab close button on the left instead of on the right (a la Camino browser)
+ ``AUI_NB_TAB_FLOAT`` Allows the floating of single tabs. Known limitation: when the notebook is more or less full screen, tabs cannot be dragged far enough outside of the notebook to become floating pages
+ ``AUI_NB_DRAW_DND_TAB`` Draws an image representation of a tab while dragging (on by default)
+ ==================================== ==================================
+
+ """
+
+ for nb in self._notebooks:
+ nb.SetAGWWindowStyleFlag(agwStyle)
+ nb.Refresh()
+ nb.Update()
+
+ self._autoNBStyle = agwStyle
+
+
+ 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{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{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{Update} will be
+ automatically invoked, thus realizing the saved perspective on screen.
+
+ :param `layout`: a string which contains a saved AUI layout;
+ :param `update`: whether to update immediately the window or not.
+ """
+
+ input = layout
+
+ # check layout string version
+ # 'layout1' = wxAUI 0.9.0 - wxAUI 0.9.2
+ # 'layout2' = wxAUI 0.9.2 (wxWidgets 2.8)
+ index = input.find("|")
+ part = input[0:index].strip()
+ input = input[index+1:]
+
+ if part != "layout2":
+ return False
+
+ # mark all panes currently managed as docked and hidden
+ for pane in self._panes:
+ pane.Dock().Hide()
+
+ # clear out the dock array; this will be reconstructed
+ self._docks = []
+
+ # replace escaped characters so we can
+ # split up the string easily
+ input = input.replace("\\|", "\a")
+ input = input.replace("\\;", "\b")
+
+ while 1:
+
+ pane = AuiPaneInfo()
+ index = input.find("|")
+ pane_part = input[0:index].strip()
+ input = input[index+1:]
+
+ # if the string is empty, we're done parsing
+ if pane_part == "":
+ break
+
+ if pane_part[0:9] == "dock_size":
+ index = pane_part.find("=")
+ val_name = pane_part[0:index]
+ value = pane_part[index+1:]
+
+ index = val_name.find("(")
+ piece = val_name[index+1:]
+ index = piece.find(")")
+ piece = piece[0:index]
+
+ vals = piece.split(",")
+ dir = int(vals[0])
+ layer = int(vals[1])
+ row = int(vals[2])
+ size = int(value)
+
+ dock = AuiDockInfo()
+ dock.dock_direction = dir
+ dock.dock_layer = layer
+ dock.dock_row = row
+ dock.size = size
+ self._docks.append(dock)
+
+ continue
+
+ # Undo our escaping as LoadPaneInfo needs to take an unescaped
+ # name so it can be called by external callers
+ pane_part = pane_part.replace("\a", "|")
+ pane_part = pane_part.replace("\b", ";")
+
+ pane = self.LoadPaneInfo(pane_part, pane)
+
+ p = self.GetPane(pane.name)
+
+ if not p.IsOk():
+ if pane.IsNotebookControl():
+ # notebook controls - auto add...
+ self._panes.append(pane)
+ indx = self._panes.index(pane)
+ else:
+ # the pane window couldn't be found
+ # in the existing layout -- skip it
+ continue
+
+ else:
+ indx = self._panes.index(p)
+ pane.window = p.window
+ pane.frame = p.frame
+ pane.buttons = p.buttons
+ self._panes[indx] = pane
+
+ if isinstance(pane.window, auibar.AuiToolBar) and (pane.IsFloatable() or pane.IsDockable()):
+ pane.window.SetGripperVisible(True)
+
+ if update:
+ self.Update()
+
+ return True
+
+
+ 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)
+
+ if p.frame:
+ p.frame.SetSizer(None)
+ p.frame.Destroy()
+ p.frame = None
+
+ # Only the master manager should create/destroy notebooks...
+ if not self._masterManager:
+ self.UpdateNotebook()
+
+ # delete old sizer first
+ self._frame.SetSizer(None)
+
+ # create a layout for all of the panes
+ sizer = self.LayoutAll(self._panes, self._docks, self._uiparts, False)
+
+ # hide or show panes as necessary,
+ # and float panes as necessary
+
+ pane_count = len(self._panes)
+
+ for ii in xrange(pane_count):
+ p = self._panes[ii]
+ pFrame = p.frame
+
+ if p.IsFloating():
+ if pFrame is None:
+ # we need to create a frame for this
+ # pane, which has recently been floated
+ frame = self.CreateFloatingFrame(self._frame, p)
+
+ # on MSW and Mac, if the owner desires transparent dragging, and
+ # the dragging is happening right now, then the floating
+ # window should have this style by default
+ if self._action in [actionDragFloatingPane, actionDragToolbarPane] and \
+ self._agwFlags & AUI_MGR_TRANSPARENT_DRAG:
+ frame.SetTransparent(150)
+
+ if p.IsToolbar():
+ bar = p.window
+ if isinstance(bar, auibar.AuiToolBar):
+ bar.SetGripperVisible(False)
+ agwStyle = bar.GetAGWWindowStyleFlag()
+ bar.SetAGWWindowStyleFlag(agwStyle & ~AUI_TB_VERTICAL)
+ bar.Realize()
+
+ s = p.window.GetMinSize()
+ p.BestSize(s)
+ p.FloatingSize(wx.DefaultSize)
+
+ frame.SetPaneWindow(p)
+ p.needsTransparency = True
+ p.frame = pFrame = frame
+ if p.IsShown() and not frame.IsShown():
+ frame.Show()
+ frame.Update()
+ else:
+
+ # frame already exists, make sure it's position
+ # and size reflect the information in AuiPaneInfo
+ if pFrame.GetPosition() != p.floating_pos or pFrame.GetSize() != p.floating_size:
+ pFrame.SetDimensions(p.floating_pos.x, p.floating_pos.y,
+ p.floating_size.x, p.floating_size.y, wx.SIZE_USE_EXISTING)
+
+ # update whether the pane is resizable or not
+ style = p.frame.GetWindowStyleFlag()
+ if p.IsFixed():
+ style &= ~wx.RESIZE_BORDER
+ else:
+ style |= wx.RESIZE_BORDER
+
+ p.frame.SetWindowStyleFlag(style)
+
+ if pFrame.IsShown() != p.IsShown():
+ p.needsTransparency = True
+ pFrame.Show(p.IsShown())
+
+ if pFrame.GetTitle() != p.caption:
+ pFrame.SetTitle(p.caption)
+ if p.icon.IsOk():
+ pFrame.SetIcon(wx.IconFromBitmap(p.icon))
+
+ else:
+
+ if p.IsToolbar():
+# self.SwitchToolBarOrientation(p)
+ p.best_size = p.window.GetBestSize()
+
+ if p.window and not p.IsNotebookPage() and p.window.IsShown() != p.IsShown():
+ p.window.Show(p.IsShown())
+
+ if pFrame and p.needsTransparency:
+ if pFrame.IsShown() and pFrame._transparent != p.transparent:
+ pFrame.SetTransparent(p.transparent)
+ pFrame._transparent = p.transparent
+
+ p.needsTransparency = False
+
+ # if "active panes" are no longer allowed, clear
+ # any optionActive values from the pane states
+ if self._agwFlags & AUI_MGR_ALLOW_ACTIVE_PANE == 0:
+ p.state &= ~AuiPaneInfo.optionActive
+
+ self._panes[ii] = p
+
+ old_pane_rects = []
+ pane_count = len(self._panes)
+
+ for p in self._panes:
+ r = wx.Rect()
+ if p.window and p.IsShown() and p.IsDocked():
+ r = p.rect
+
+ old_pane_rects.append(r)
+
+ # apply the new sizer
+ self._frame.SetSizer(sizer)
+ self._frame.SetAutoLayout(False)
+ self.DoFrameLayout()
+
+ # now that the frame layout is done, we need to check
+ # the new pane rectangles against the old rectangles that
+ # we saved a few lines above here. If the rectangles have
+ # changed, the corresponding panes must also be updated
+ for ii in xrange(pane_count):
+ p = self._panes[ii]
+ if p.window and p.IsShown() and p.IsDocked():
+ if p.rect != old_pane_rects[ii]:
+ p.window.Refresh()
+ p.window.Update()
+
+ if wx.Platform == "__WXMAC__":
+ self._frame.Refresh()
+ else:
+ self.Repaint()
+
+ if not self._masterManager:
+ e = self.FireEvent(wxEVT_AUI_PERSPECTIVE_CHANGED, None, canVeto=False)
+
+
+ def UpdateNotebook(self):
+ """ Updates the automatic L{AuiNotebook} in the layout (if any exists). """
+
+ # Workout how many notebooks we need.
+ max_notebook = -1
+
+ # destroy floating panes which have been
+ # redocked or are becoming non-floating
+ for paneInfo in self._panes:
+ if max_notebook < paneInfo.notebook_id:
+ max_notebook = paneInfo.notebook_id
+
+ # We are the master of our domain
+ extra_notebook = len(self._notebooks)
+ max_notebook += 1
+
+ for i in xrange(extra_notebook, max_notebook):
+ self.CreateNotebook()
+
+ # Remove pages from notebooks that no-longer belong there ...
+ for nb, notebook in enumerate(self._notebooks):
+ pages = notebook.GetPageCount()
+ pageCounter, allPages = 0, pages
+
+ # Check each tab ...
+ for page in xrange(pages):
+
+ if page >= allPages:
+ break
+
+ window = notebook.GetPage(pageCounter)
+ paneInfo = self.GetPane(window)
+ if paneInfo.IsOk() and paneInfo.notebook_id != nb:
+ notebook.RemovePage(pageCounter)
+ window.Hide()
+ window.Reparent(self._frame)
+ pageCounter -= 1
+ allPages -= 1
+
+ pageCounter += 1
+
+ notebook.DoSizing()
+
+ # Add notebook pages that aren't there already...
+ for paneInfo in self._panes:
+ if paneInfo.IsNotebookPage():
+
+ title = (paneInfo.caption == "" and [paneInfo.name] or [paneInfo.caption])[0]
+
+ notebook = self._notebooks[paneInfo.notebook_id]
+ page_id = notebook.GetPageIndex(paneInfo.window)
+
+ if page_id < 0:
+
+ paneInfo.window.Reparent(notebook)
+ notebook.AddPage(paneInfo.window, title, True, paneInfo.icon)
+
+ # Update title and icon ...
+ else:
+
+ notebook.SetPageText(page_id, title)
+ notebook.SetPageBitmap(page_id, paneInfo.icon)
+
+ notebook.DoSizing()
+
+ # Wire-up newly created notebooks
+ elif paneInfo.IsNotebookControl() and not paneInfo.window:
+ paneInfo.window = self._notebooks[paneInfo.notebook_id]
+
+ # Delete empty notebooks, and convert notebooks with 1 page to
+ # normal panes...
+ remap_ids = [-1]*len(self._notebooks)
+ nb_idx = 0
+
+ for nb, notebook in enumerate(self._notebooks):
+ if notebook.GetPageCount() == 1:
+
+ # Convert notebook page to pane...
+ window = notebook.GetPage(0)
+ child_pane = self.GetPane(window)
+ notebook_pane = self.GetPane(notebook)
+ if child_pane.IsOk() and notebook_pane.IsOk():
+
+ child_pane.SetDockPos(notebook_pane)
+ child_pane.window.Hide()
+ child_pane.window.Reparent(self._frame)
+ child_pane.frame = None
+ child_pane.notebook_id = -1
+ if notebook_pane.IsFloating():
+ child_pane.Float()
+
+ self.DetachPane(notebook)
+
+ notebook.RemovePage(0)
+ notebook.Destroy()
+
+ else:
+
+ raise Exception("Odd notebook docking")
+
+ elif notebook.GetPageCount() == 0:
+
+ self.DetachPane(notebook)
+ notebook.Destroy()
+
+ else:
+
+ # Correct page ordering. The original wxPython code
+ # for this did not work properly, and would misplace
+ # windows causing errors.
+ notebook.Freeze()
+ self._notebooks[nb_idx] = notebook
+ pages = notebook.GetPageCount()
+ selected = notebook.GetPage(notebook.GetSelection())
+
+ # Take each page out of the notebook, group it with
+ # its current pane, and sort the list by pane.dock_pos
+ # order
+ pages_and_panes = []
+ for idx in reversed(range(pages)):
+ page = notebook.GetPage(idx)
+ pane = self.GetPane(page)
+ pages_and_panes.append((page, pane))
+ notebook.RemovePage(idx)
+ sorted_pnp = sorted(pages_and_panes, key=lambda tup: tup[1].dock_pos)
+
+ # Grab the attributes from the panes which are ordered
+ # correctly, and copy those attributes to the original
+ # panes. (This avoids having to change the ordering
+ # of self._panes) Then, add the page back into the notebook
+ sorted_attributes = [self.GetAttributes(tup[1])
+ for tup in sorted_pnp]
+ for attrs, tup in zip(sorted_attributes, pages_and_panes):
+ pane = tup[1]
+ self.SetAttributes(pane, attrs)
+ notebook.AddPage(pane.window, pane.caption)
+
+ notebook.SetSelection(notebook.GetPageIndex(selected), True)
+ notebook.DoSizing()
+ notebook.Thaw()
+
+ # It's a keeper.
+ remap_ids[nb] = nb_idx
+ nb_idx += 1
+
+ # Apply remap...
+ nb_count = len(self._notebooks)
+
+ if nb_count != nb_idx:
+
+ self._notebooks = self._notebooks[0:nb_idx]
+ for p in self._panes:
+ if p.notebook_id >= 0:
+ p.notebook_id = remap_ids[p.notebook_id]
+ if p.IsNotebookControl():
+ p.SetNameFromNotebookId()
+
+ # Make sure buttons are correct ...
+ for notebook in self._notebooks:
+ want_max = True
+ want_min = True
+ want_close = True
+
+ pages = notebook.GetPageCount()
+ for page in xrange(pages):
+
+ win = notebook.GetPage(page)
+ pane = self.GetPane(win)
+ if pane.IsOk():
+
+ if not pane.HasCloseButton():
+ want_close = False
+ if not pane.HasMaximizeButton():
+ want_max = False
+ if not pane.HasMinimizeButton():
+ want_min = False
+
+ notebook_pane = self.GetPane(notebook)
+ if notebook_pane.IsOk():
+ if notebook_pane.HasMinimizeButton() != want_min:
+ if want_min:
+ button = AuiPaneButton(AUI_BUTTON_MINIMIZE)
+ notebook_pane.state |= AuiPaneInfo.buttonMinimize
+ notebook_pane.buttons.append(button)
+
+ # todo: remove min/max
+
+ if notebook_pane.HasMaximizeButton() != want_max:
+ if want_max:
+ button = AuiPaneButton(AUI_BUTTON_MAXIMIZE_RESTORE)
+ notebook_pane.state |= AuiPaneInfo.buttonMaximize
+ notebook_pane.buttons.append(button)
+
+ # todo: remove min/max
+
+ if notebook_pane.HasCloseButton() != want_close:
+ if want_close:
+ button = AuiPaneButton(AUI_BUTTON_CLOSE)
+ notebook_pane.state |= AuiPaneInfo.buttonClose
+ notebook_pane.buttons.append(button)
+
+ # todo: remove close
+
+
+ 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 with the original as a tab...
+ self.CreateNotebookBase(panes, paneInfo)
+
+ # Add new item to notebook
+ target.NotebookPage(paneInfo.notebook_id)
+
+ else:
+
+ drop_pane = False
+ drop_row = False
+
+ insert_dir = paneInfo.dock_direction
+ insert_layer = paneInfo.dock_layer
+ insert_row = paneInfo.dock_row
+ insert_pos = paneInfo.dock_pos
+
+ if insert_dir == AUI_DOCK_CENTER:
+
+ insert_layer = 0
+ if dir == wx.LEFT:
+ insert_dir = AUI_DOCK_LEFT
+ elif dir == wx.UP:
+ insert_dir = AUI_DOCK_TOP
+ elif dir == wx.RIGHT:
+ insert_dir = AUI_DOCK_RIGHT
+ elif dir == wx.DOWN:
+ insert_dir = AUI_DOCK_BOTTOM
+
+ if insert_dir == AUI_DOCK_LEFT:
+
+ drop_pane = (dir == wx.UP or dir == wx.DOWN)
+ drop_row = (dir == wx.LEFT or dir == wx.RIGHT)
+ if dir == wx.RIGHT:
+ insert_row += 1
+ elif dir == wx.DOWN:
+ insert_pos += 1
+
+ elif insert_dir == AUI_DOCK_RIGHT:
+
+ drop_pane = (dir == wx.UP or dir == wx.DOWN)
+ drop_row = (dir == wx.LEFT or dir == wx.RIGHT)
+ if dir == wx.LEFT:
+ insert_row += 1
+ elif dir == wx.DOWN:
+ insert_pos += 1
+
+ elif insert_dir == AUI_DOCK_TOP:
+
+ drop_pane = (dir == wx.LEFT or dir == wx.RIGHT)
+ drop_row = (dir == wx.UP or dir == wx.DOWN)
+ if dir == wx.DOWN:
+ insert_row += 1
+ elif dir == wx.RIGHT:
+ insert_pos += 1
+
+ elif insert_dir == AUI_DOCK_BOTTOM:
+
+ drop_pane = (dir == wx.LEFT or dir == wx.RIGHT)
+ drop_row = (dir == wx.UP or dir == wx.DOWN)
+ if dir == wx.UP:
+ insert_row += 1
+ elif dir == wx.RIGHT:
+ insert_pos += 1
+
+ if paneInfo.dock_direction == AUI_DOCK_CENTER:
+ insert_row = GetMaxRow(panes, insert_dir, insert_layer) + 1
+
+ if drop_pane:
+ return self.DoDropPane(panes, target, insert_dir, insert_layer, insert_row, insert_pos)
+
+ if drop_row:
+ return self.DoDropRow(panes, target, insert_dir, insert_layer, insert_row)
+
+ return True, target
+
+ return False, target
+
+
+ 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 _VERSION_STRING < "2.9":
+ leftDown = wx.GetMouseState().LeftDown()
+ else:
+ leftDown = wx.GetMouseState().LeftIsDown()
+
+ if 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()
+ self.FireEvent(wxEVT_AUI_PANE_ACTIVATED, wnd, canVeto=False)
+
+
+ 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 `eventOrPt`: a `wx.MoveEvent` to be processed or an instance of `wx.Point`.
+ """
+
+ 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.FireEvent(wxEVT_AUI_PANE_ACTIVATED, pane_window, canVeto=False)
+
+ 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. It binds the ``EVT_AUI_RENDER`` event.
+
+ :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 L{AuiManagerEvent} 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 event is not None:
+ event.Skip()
+
+ if isinstance(self._frame, AuiFloatingFrame) and self._frame.IsShownOnScreen():
+ 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 _VERSION_STRING < "2.9":
+ leftDown = wx.GetMouseState().LeftDown()
+ else:
+ leftDown = wx.GetMouseState().LeftIsDown()
+
+ if not 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 L{AuiManagerEvent} event 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 CreateNotebookBase(self, panes, paneInfo):
+ """
+ Creates an auto-notebook base from a pane, and then add that pane as a page.
+
+ :param `panes`: Set of panes to append new notebook base pane to
+ :param `paneInfo`: L{AuiPaneInfo} instance to convert to new notebook.
+ """
+
+ # Create base notebook pane ...
+ nbid = len(self._notebooks)
+
+ baseInfo = AuiPaneInfo()
+ baseInfo.SetDockPos(paneInfo).NotebookControl(nbid). \
+ CloseButton(False).SetNameFromNotebookId(). \
+ NotebookDockable(False).Floatable(paneInfo.IsFloatable())
+ baseInfo.best_size = paneInfo.best_size
+ panes.append(baseInfo)
+
+ # add original pane as tab ...
+ paneInfo.NotebookPage(nbid)
+
+ 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.
+
+ :note: This functionality is not available on wxMAC as this platform doesn't have
+ the ability to use `wx.ScreenDC` to draw on-screen and on Windows > Vista.
+ """
+
+ 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.
+
+ :note: This is used solely for sliding in and out minimized panes.
+ """
+
+ 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
+
+
+class AuiManager_DCP(AuiManager):
+ """
+ A class similar to L{AuiManager} but with a Dummy Center Pane (**DCP**).
+ The code for this class is still flickery due to the call to `wx.CallAfter`
+ and the double-update call.
+ """
+
+ def __init__(self, *args, **keys):
+
+ AuiManager.__init__(self, *args, **keys)
+ self.hasDummyPane = False
+
+
+ def _createDummyPane(self):
+ """ Creates a Dummy Center Pane (**DCP**). """
+
+ if self.hasDummyPane:
+ return
+
+ self.hasDummyPane = True
+ dummy = wx.Panel(self.GetManagedWindow())
+ info = AuiPaneInfo().CenterPane().NotebookDockable(True).Name('dummyCenterPane').DestroyOnClose(True)
+ self.AddPane(dummy, info)
+
+
+ def _destroyDummyPane(self):
+ """ Destroys the Dummy Center Pane (**DCP**). """
+
+ if not self.hasDummyPane:
+ return
+
+ self.hasDummyPane = False
+ self.ClosePane(self.GetPane('dummyCenterPane'))
+
+
+ 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{AuiManager.AddPane} or L{AuiManager.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{AuiManager.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.
+ """
+
+ AuiManager.Update(self)
+
+ # check if there's already a center pane (except our dummy pane)
+ dummyCenterPane = self.GetPane('dummyCenterPane')
+ haveCenterPane = any((pane != dummyCenterPane) and (pane.dock_direction == AUI_DOCK_CENTER) and
+ not pane.IsFloating() and pane.IsShown() for pane in self.GetAllPanes())
+ if haveCenterPane:
+ if self.hasDummyPane:
+ # there's our dummy pane and also another center pane, therefor let's remove our dummy
+ def do():
+ self._destroyDummyPane()
+ self.Update()
+ wx.CallAfter(do)
+ else:
+ # if we get here, there's no center pane, create our dummy
+ if not self.hasDummyPane:
+ self._createDummyPane()
+
+
projects / iramuteq / commitdiff