# This file was created automatically by SWIG 1.3.29. # Don't modify this file, modify the SWIG interface instead. """ The wx.aui moduleis an Advanced User Interface library that aims to implement "cutting-edge" interface usability and design features so developers can quickly and easily create beautiful and usable application interfaces. **Vision and Design Principles** wx.aui attempts to encapsulate the following aspects of the user interface: * Frame Management: Frame management provides the means to open, move and hide common controls that are needed to interact with the document, and allow these configurations to be saved into different perspectives and loaded at a later time. * Toolbars: Toolbars are a specialized subset of the frame management system and should behave similarly to other docked components. However, they also require additional functionality, such as "spring-loaded" rebar support, "chevron" buttons and end-user customizability. * Modeless Controls: Modeless controls expose a tool palette or set of options that float above the application content while allowing it to be accessed. Usually accessed by the toolbar, these controls disappear when an option is selected, but may also be "torn off" the toolbar into a floating frame of their own. * Look and Feel: Look and feel encompasses the way controls are drawn, both when shown statically as well as when they are being moved. This aspect of user interface design incorporates "special effects" such as transparent window dragging as well as frame animation. **PyAUI adheres to the following principles** - Use native floating frames to obtain a native look and feel for all platforms; - Use existing wxPython code where possible, such as sizer implementation for frame management; - Use standard wxPython coding conventions. **Usage** The following example shows a simple implementation that utilizes `wx.aui.FrameManager` to manage three text controls in a frame window:: import wx import wx.aui class MyFrame(wx.Frame): def __init__(self, parent, id=-1, title='wx.aui Test', size=(800, 600), style=wx.DEFAULT_FRAME_STYLE): wx.Frame.__init__(self, parent, id, title, pos, size, style) self._mgr = wx.aui.FrameManager(self) # create several text controls text1 = wx.TextCtrl(self, -1, 'Pane 1 - sample text', wx.DefaultPosition, wx.Size(200,150), wx.NO_BORDER | wx.TE_MULTILINE) text2 = wx.TextCtrl(self, -1, 'Pane 2 - sample text', wx.DefaultPosition, wx.Size(200,150), wx.NO_BORDER | wx.TE_MULTILINE) text3 = wx.TextCtrl(self, -1, 'Main content window', wx.DefaultPosition, wx.Size(200,150), wx.NO_BORDER | wx.TE_MULTILINE) # add the panes to the manager self._mgr.AddPane(text1, wx.LEFT, 'Pane Number One') self._mgr.AddPane(text2, wx.BOTTOM, 'Pane Number Two') self._mgr.AddPane(text3, wx.CENTER) # tell the manager to 'commit' all the changes just made self._mgr.Update() self.Bind(wx.EVT_CLOSE, self.OnClose) def OnClose(self, event): # deinitialize the frame manager self._mgr.UnInit() # delete the frame self.Destroy() app = wx.App() frame = MyFrame(None) frame.Show() app.MainLoop() """ import _aui import new new_instancemethod = new.instancemethod def _swig_setattr_nondynamic(self,class_type,name,value,static=1): if (name == "thisown"): return self.this.own(value) if (name == "this"): if type(value).__name__ == 'PySwigObject': self.__dict__[name] = value return method = class_type.__swig_setmethods__.get(name,None) if method: return method(self,value) if (not static) or hasattr(self,name): self.__dict__[name] = value else: raise AttributeError("You cannot add attributes to %s" % self) def _swig_setattr(self,class_type,name,value): return _swig_setattr_nondynamic(self,class_type,name,value,0) def _swig_getattr(self,class_type,name): if (name == "thisown"): return self.this.own() method = class_type.__swig_getmethods__.get(name,None) if method: return method(self) raise AttributeError,name def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() except: strthis = "" return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) import types try: _object = types.ObjectType _newclass = 1 except AttributeError: class _object : pass _newclass = 0 del types def _swig_setattr_nondynamic_method(set): def set_attr(self,name,value): if (name == "thisown"): return self.this.own(value) if hasattr(self,name) or (name == "this"): set(self,name,value) else: raise AttributeError("You cannot add attributes to %s" % self) return set_attr import _core import _windows wx = _core __docfilter__ = wx.__DocFilter(globals()) USE_AUI = _aui.USE_AUI AUI_DOCK_NONE = _aui.AUI_DOCK_NONE AUI_DOCK_TOP = _aui.AUI_DOCK_TOP AUI_DOCK_RIGHT = _aui.AUI_DOCK_RIGHT AUI_DOCK_BOTTOM = _aui.AUI_DOCK_BOTTOM AUI_DOCK_LEFT = _aui.AUI_DOCK_LEFT AUI_DOCK_CENTER = _aui.AUI_DOCK_CENTER AUI_DOCK_CENTRE = _aui.AUI_DOCK_CENTRE AUI_MGR_ALLOW_FLOATING = _aui.AUI_MGR_ALLOW_FLOATING AUI_MGR_ALLOW_ACTIVE_PANE = _aui.AUI_MGR_ALLOW_ACTIVE_PANE AUI_MGR_TRANSPARENT_DRAG = _aui.AUI_MGR_TRANSPARENT_DRAG AUI_MGR_TRANSPARENT_HINT = _aui.AUI_MGR_TRANSPARENT_HINT AUI_MGR_TRANSPARENT_HINT_FADE = _aui.AUI_MGR_TRANSPARENT_HINT_FADE AUI_MGR_DISABLE_VENETIAN_BLINDS = _aui.AUI_MGR_DISABLE_VENETIAN_BLINDS AUI_MGR_DISABLE_VENETIAN_BLINDS_FADE = _aui.AUI_MGR_DISABLE_VENETIAN_BLINDS_FADE AUI_MGR_DEFAULT = _aui.AUI_MGR_DEFAULT AUI_ART_SASH_SIZE = _aui.AUI_ART_SASH_SIZE AUI_ART_CAPTION_SIZE = _aui.AUI_ART_CAPTION_SIZE AUI_ART_GRIPPER_SIZE = _aui.AUI_ART_GRIPPER_SIZE AUI_ART_PANE_BORDER_SIZE = _aui.AUI_ART_PANE_BORDER_SIZE AUI_ART_PANE_BUTTON_SIZE = _aui.AUI_ART_PANE_BUTTON_SIZE AUI_ART_BACKGROUND_COLOUR = _aui.AUI_ART_BACKGROUND_COLOUR AUI_ART_SASH_COLOUR = _aui.AUI_ART_SASH_COLOUR AUI_ART_ACTIVE_CAPTION_COLOUR = _aui.AUI_ART_ACTIVE_CAPTION_COLOUR AUI_ART_ACTIVE_CAPTION_GRADIENT_COLOUR = _aui.AUI_ART_ACTIVE_CAPTION_GRADIENT_COLOUR AUI_ART_INACTIVE_CAPTION_COLOUR = _aui.AUI_ART_INACTIVE_CAPTION_COLOUR AUI_ART_INACTIVE_CAPTION_GRADIENT_COLOUR = _aui.AUI_ART_INACTIVE_CAPTION_GRADIENT_COLOUR AUI_ART_ACTIVE_CAPTION_TEXT_COLOUR = _aui.AUI_ART_ACTIVE_CAPTION_TEXT_COLOUR AUI_ART_INACTIVE_CAPTION_TEXT_COLOUR = _aui.AUI_ART_INACTIVE_CAPTION_TEXT_COLOUR AUI_ART_BORDER_COLOUR = _aui.AUI_ART_BORDER_COLOUR AUI_ART_GRIPPER_COLOUR = _aui.AUI_ART_GRIPPER_COLOUR AUI_ART_CAPTION_FONT = _aui.AUI_ART_CAPTION_FONT AUI_ART_GRADIENT_TYPE = _aui.AUI_ART_GRADIENT_TYPE AUI_GRADIENT_NONE = _aui.AUI_GRADIENT_NONE AUI_GRADIENT_VERTICAL = _aui.AUI_GRADIENT_VERTICAL AUI_GRADIENT_HORIZONTAL = _aui.AUI_GRADIENT_HORIZONTAL AUI_BUTTON_STATE_NORMAL = _aui.AUI_BUTTON_STATE_NORMAL AUI_BUTTON_STATE_HOVER = _aui.AUI_BUTTON_STATE_HOVER AUI_BUTTON_STATE_PRESSED = _aui.AUI_BUTTON_STATE_PRESSED AUI_INSERT_PANE = _aui.AUI_INSERT_PANE AUI_INSERT_ROW = _aui.AUI_INSERT_ROW AUI_INSERT_DOCK = _aui.AUI_INSERT_DOCK class PaneInfo(object): """ PaneInfo specifies all the parameters for a pane for the `FrameManager`. 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. """ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def __init__(self, *args, **kwargs): """ __init__(self) -> PaneInfo PaneInfo specifies all the parameters for a pane for the `FrameManager`. 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. """ _aui.PaneInfo_swiginit(self,_aui.new_PaneInfo(*args, **kwargs)) __swig_destroy__ = _aui.delete_PaneInfo __del__ = lambda self : None; def SafeSet(*args, **kwargs): """SafeSet(self, PaneInfo source)""" return _aui.PaneInfo_SafeSet(*args, **kwargs) def IsOk(*args, **kwargs): """ IsOk(self) -> bool IsOk returns ``True`` if the PaneInfo structure is valid. """ return _aui.PaneInfo_IsOk(*args, **kwargs) def IsFixed(*args, **kwargs): """ IsFixed(self) -> bool IsFixed returns ``True`` if the pane cannot be resized. """ return _aui.PaneInfo_IsFixed(*args, **kwargs) def IsResizable(*args, **kwargs): """ IsResizable(self) -> bool IsResizeable returns ``True`` if the pane can be resized. """ return _aui.PaneInfo_IsResizable(*args, **kwargs) def IsShown(*args, **kwargs): """ IsShown(self) -> bool IsShown returns ``True`` if the pane should be drawn on the screen. """ return _aui.PaneInfo_IsShown(*args, **kwargs) def IsFloating(*args, **kwargs): """ IsFloating(self) -> bool IsFloating returns ``True`` if the pane is floating. """ return _aui.PaneInfo_IsFloating(*args, **kwargs) def IsDocked(*args, **kwargs): """ IsDocked(self) -> bool IsDocked returns ``True`` if the pane is docked. """ return _aui.PaneInfo_IsDocked(*args, **kwargs) def IsToolbar(*args, **kwargs): """ IsToolbar(self) -> bool IsToolbar returns ``True`` if the pane contains a toolbar. """ return _aui.PaneInfo_IsToolbar(*args, **kwargs) def IsTopDockable(*args, **kwargs): """ IsTopDockable(self) -> bool IsTopDockable returns ``True`` if the pane can be docked at the top of the managed frame. """ return _aui.PaneInfo_IsTopDockable(*args, **kwargs) def IsBottomDockable(*args, **kwargs): """ IsBottomDockable(self) -> bool IsBottomDockable returns ``True`` if the pane can be docked at the bottom of the managed frame. """ return _aui.PaneInfo_IsBottomDockable(*args, **kwargs) def IsLeftDockable(*args, **kwargs): """ IsLeftDockable(self) -> bool IsLeftDockable returns ``True`` if the pane can be docked on the left of the managed frame. """ return _aui.PaneInfo_IsLeftDockable(*args, **kwargs) def IsRightDockable(*args, **kwargs): """ IsRightDockable(self) -> bool IsRightDockable returns ``True`` if the pane can be docked on the right of the managed frame. """ return _aui.PaneInfo_IsRightDockable(*args, **kwargs) def IsFloatable(*args, **kwargs): """ IsFloatable(self) -> bool IsFloatable returns ``True`` if the pane can be undocked and displayed as a floating window. """ return _aui.PaneInfo_IsFloatable(*args, **kwargs) def IsMovable(*args, **kwargs): """ IsMovable(self) -> bool IsMoveable returns ``True`` if the docked frame can be undocked or moved to another dock position. """ return _aui.PaneInfo_IsMovable(*args, **kwargs) def IsDestroyOnClose(*args, **kwargs): """IsDestroyOnClose(self) -> bool""" return _aui.PaneInfo_IsDestroyOnClose(*args, **kwargs) def HasCaption(*args, **kwargs): """ HasCaption(self) -> bool HasCaption returns ``True`` if the pane displays a caption. """ return _aui.PaneInfo_HasCaption(*args, **kwargs) def HasGripper(*args, **kwargs): """ HasGripper(self) -> bool HasGripper returns ``True`` if the pane displays a gripper. """ return _aui.PaneInfo_HasGripper(*args, **kwargs) def HasBorder(*args, **kwargs): """ HasBorder(self) -> bool HasBorder returns ``True`` if the pane displays a border. """ return _aui.PaneInfo_HasBorder(*args, **kwargs) def HasCloseButton(*args, **kwargs): """ HasCloseButton(self) -> bool HasCloseButton returns ``True`` if the pane displays a button to close the pane. """ return _aui.PaneInfo_HasCloseButton(*args, **kwargs) def HasMaximizeButton(*args, **kwargs): """ HasMaximizeButton(self) -> bool HasMaximizeButton returns ``True`` if the pane displays a button to maximize the pane. """ return _aui.PaneInfo_HasMaximizeButton(*args, **kwargs) def HasMinimizeButton(*args, **kwargs): """ HasMinimizeButton(self) -> bool HasMinimizeButton returns ``True`` if the pane displays a button to minimize the pane. """ return _aui.PaneInfo_HasMinimizeButton(*args, **kwargs) def HasPinButton(*args, **kwargs): """ HasPinButton(self) -> bool HasPinButton returns ``True`` if the pane displays a button to float the pane. """ return _aui.PaneInfo_HasPinButton(*args, **kwargs) def HasGripperTop(*args, **kwargs): """HasGripperTop(self) -> bool""" return _aui.PaneInfo_HasGripperTop(*args, **kwargs) def Window(*args, **kwargs): """Window(self, Window w) -> PaneInfo""" return _aui.PaneInfo_Window(*args, **kwargs) def Name(*args, **kwargs): """ Name(self, String n) -> PaneInfo Name sets the name of the pane so it can be referenced in lookup functions. """ return _aui.PaneInfo_Name(*args, **kwargs) def Caption(*args, **kwargs): """ Caption(self, String c) -> PaneInfo Caption sets the caption of the pane. """ return _aui.PaneInfo_Caption(*args, **kwargs) def Left(*args, **kwargs): """ Left(self) -> PaneInfo Left sets the pane dock position to the left side of the frame. """ return _aui.PaneInfo_Left(*args, **kwargs) def Right(*args, **kwargs): """ Right(self) -> PaneInfo Right sets the pane dock position to the right side of the frame. """ return _aui.PaneInfo_Right(*args, **kwargs) def Top(*args, **kwargs): """ Top(self) -> PaneInfo Top sets the pane dock position to the top of the frame. """ return _aui.PaneInfo_Top(*args, **kwargs) def Bottom(*args, **kwargs): """ Bottom(self) -> PaneInfo Bottom sets the pane dock position to the bottom of the frame. """ return _aui.PaneInfo_Bottom(*args, **kwargs) def Center(*args, **kwargs): """ Center(self) -> PaneInfo Center sets the pane to the center position of the frame. """ return _aui.PaneInfo_Center(*args, **kwargs) def Centre(*args, **kwargs): """ Centre(self) -> PaneInfo Centre sets the pane to the center position of the frame. """ return _aui.PaneInfo_Centre(*args, **kwargs) def Direction(*args, **kwargs): """ Direction(self, int direction) -> PaneInfo Direction determines the direction of the docked pane. """ return _aui.PaneInfo_Direction(*args, **kwargs) def Layer(*args, **kwargs): """ Layer(self, int layer) -> PaneInfo Layer determines the layer of the docked pane. """ return _aui.PaneInfo_Layer(*args, **kwargs) def Row(*args, **kwargs): """ Row(self, int row) -> PaneInfo Row determines the row of the docked pane. """ return _aui.PaneInfo_Row(*args, **kwargs) def Position(*args, **kwargs): """ Position(self, int pos) -> PaneInfo Position determines the position of the docked pane. """ return _aui.PaneInfo_Position(*args, **kwargs) def BestSize(*args, **kwargs): """ BestSize(self, Size size) -> PaneInfo BestSize sets the ideal size for the pane. """ return _aui.PaneInfo_BestSize(*args, **kwargs) def MinSize(*args, **kwargs): """ MinSize(self, Size size) -> PaneInfo MinSize sets the minimum size of the pane. """ return _aui.PaneInfo_MinSize(*args, **kwargs) def MaxSize(*args, **kwargs): """ MaxSize(self, Size size) -> PaneInfo MaxSize sets the maximum size of the pane. """ return _aui.PaneInfo_MaxSize(*args, **kwargs) def FloatingPosition(*args, **kwargs): """ FloatingPosition(self, Point pos) -> PaneInfo FloatingPosition sets the position of the floating pane. """ return _aui.PaneInfo_FloatingPosition(*args, **kwargs) def FloatingSize(*args, **kwargs): """ FloatingSize(self, Size size) -> PaneInfo FloatingSize sets the size of the floating pane. """ return _aui.PaneInfo_FloatingSize(*args, **kwargs) def Fixed(*args, **kwargs): """ Fixed(self) -> PaneInfo Fixed forces a pane to be fixed size so that it cannot be resized. """ return _aui.PaneInfo_Fixed(*args, **kwargs) def Resizable(*args, **kwargs): """ Resizable(self, bool resizable=True) -> PaneInfo Resized allows a pane to be resized if resizable is true, and forces it to be a fixed size if resizeable is false. """ return _aui.PaneInfo_Resizable(*args, **kwargs) def Dock(*args, **kwargs): """ Dock(self) -> PaneInfo Dock indicates that a pane should be docked. """ return _aui.PaneInfo_Dock(*args, **kwargs) def Float(*args, **kwargs): """ Float(self) -> PaneInfo Float indicates that a pane should be floated. """ return _aui.PaneInfo_Float(*args, **kwargs) def Hide(*args, **kwargs): """ Hide(self) -> PaneInfo Hide indicates that a pane should be hidden. """ return _aui.PaneInfo_Hide(*args, **kwargs) def Show(*args, **kwargs): """ Show(self, bool show=True) -> PaneInfo Show indicates that a pane should be shown. """ return _aui.PaneInfo_Show(*args, **kwargs) def CaptionVisible(*args, **kwargs): """ CaptionVisible(self, bool visible=True) -> PaneInfo CaptionVisible indicates that a pane caption should be visible. """ return _aui.PaneInfo_CaptionVisible(*args, **kwargs) def PaneBorder(*args, **kwargs): """ PaneBorder(self, bool visible=True) -> PaneInfo PaneBorder indicates that a border should be drawn for the pane. """ return _aui.PaneInfo_PaneBorder(*args, **kwargs) def Gripper(*args, **kwargs): """ Gripper(self, bool visible=True) -> PaneInfo Gripper indicates that a gripper should be drawn for the pane.. """ return _aui.PaneInfo_Gripper(*args, **kwargs) def GripperTop(*args, **kwargs): """GripperTop(self, bool attop=True) -> PaneInfo""" return _aui.PaneInfo_GripperTop(*args, **kwargs) def CloseButton(*args, **kwargs): """ CloseButton(self, bool visible=True) -> PaneInfo CloseButton indicates that a close button should be drawn for the pane. """ return _aui.PaneInfo_CloseButton(*args, **kwargs) def MaximizeButton(*args, **kwargs): """ MaximizeButton(self, bool visible=True) -> PaneInfo MaximizeButton indicates that a maximize button should be drawn for the pane. """ return _aui.PaneInfo_MaximizeButton(*args, **kwargs) def MinimizeButton(*args, **kwargs): """ MinimizeButton(self, bool visible=True) -> PaneInfo MinimizeButton indicates that a minimize button should be drawn for the pane. """ return _aui.PaneInfo_MinimizeButton(*args, **kwargs) def PinButton(*args, **kwargs): """ PinButton(self, bool visible=True) -> PaneInfo PinButton indicates that a pin button should be drawn for the pane. """ return _aui.PaneInfo_PinButton(*args, **kwargs) def DestroyOnClose(*args, **kwargs): """ DestroyOnClose(self, bool b=True) -> PaneInfo DestroyOnClose indicates whether a pane should be detroyed when it is closed. """ return _aui.PaneInfo_DestroyOnClose(*args, **kwargs) def TopDockable(*args, **kwargs): """ TopDockable(self, bool b=True) -> PaneInfo TopDockable indicates whether a pane can be docked at the top of the frame. """ return _aui.PaneInfo_TopDockable(*args, **kwargs) def BottomDockable(*args, **kwargs): """ BottomDockable(self, bool b=True) -> PaneInfo BottomDockable indicates whether a pane can be docked at the bottom of the frame. """ return _aui.PaneInfo_BottomDockable(*args, **kwargs) def LeftDockable(*args, **kwargs): """ LeftDockable(self, bool b=True) -> PaneInfo LeftDockable indicates whether a pane can be docked on the left of the frame. """ return _aui.PaneInfo_LeftDockable(*args, **kwargs) def RightDockable(*args, **kwargs): """ RightDockable(self, bool b=True) -> PaneInfo RightDockable indicates whether a pane can be docked on the right of the frame. """ return _aui.PaneInfo_RightDockable(*args, **kwargs) def Floatable(*args, **kwargs): """ Floatable(self, bool b=True) -> PaneInfo Floatable indicates whether a frame can be floated. """ return _aui.PaneInfo_Floatable(*args, **kwargs) def Movable(*args, **kwargs): """ Movable(self, bool b=True) -> PaneInfo Movable indicates whether a frame can be moved. """ return _aui.PaneInfo_Movable(*args, **kwargs) def Dockable(*args, **kwargs): """ Dockable(self, bool b=True) -> PaneInfo Dockable indicates whether a pane can be docked at any position of the frame. """ return _aui.PaneInfo_Dockable(*args, **kwargs) def DefaultPane(*args, **kwargs): """ DefaultPane(self) -> PaneInfo DefaultPane specifies that the pane should adopt the default pane settings. """ return _aui.PaneInfo_DefaultPane(*args, **kwargs) def CentrePane(*args, **kwargs): """ CentrePane(self) -> PaneInfo CentrePane specifies that the pane should adopt the default center pane settings. """ return _aui.PaneInfo_CentrePane(*args, **kwargs) def CenterPane(*args, **kwargs): """ CenterPane(self) -> PaneInfo CenterPane specifies that the pane should adopt the default center pane settings. """ return _aui.PaneInfo_CenterPane(*args, **kwargs) def ToolbarPane(*args, **kwargs): """ ToolbarPane(self) -> PaneInfo ToolbarPane specifies that the pane should adopt the default toolbar pane settings. """ return _aui.PaneInfo_ToolbarPane(*args, **kwargs) def SetFlag(*args, **kwargs): """ SetFlag(self, int flag, bool option_state) -> PaneInfo SetFlag turns the property given by flag on or off with the option_state parameter. """ return _aui.PaneInfo_SetFlag(*args, **kwargs) def HasFlag(*args, **kwargs): """ HasFlag(self, int flag) -> bool HasFlag returns ``True`` if the the property specified by flag is active for the pane. """ return _aui.PaneInfo_HasFlag(*args, **kwargs) optionFloating = _aui.PaneInfo_optionFloating optionHidden = _aui.PaneInfo_optionHidden optionLeftDockable = _aui.PaneInfo_optionLeftDockable optionRightDockable = _aui.PaneInfo_optionRightDockable optionTopDockable = _aui.PaneInfo_optionTopDockable optionBottomDockable = _aui.PaneInfo_optionBottomDockable optionFloatable = _aui.PaneInfo_optionFloatable optionMovable = _aui.PaneInfo_optionMovable optionResizable = _aui.PaneInfo_optionResizable optionPaneBorder = _aui.PaneInfo_optionPaneBorder optionCaption = _aui.PaneInfo_optionCaption optionGripper = _aui.PaneInfo_optionGripper optionDestroyOnClose = _aui.PaneInfo_optionDestroyOnClose optionToolbar = _aui.PaneInfo_optionToolbar optionActive = _aui.PaneInfo_optionActive optionGripperTop = _aui.PaneInfo_optionGripperTop buttonClose = _aui.PaneInfo_buttonClose buttonMaximize = _aui.PaneInfo_buttonMaximize buttonMinimize = _aui.PaneInfo_buttonMinimize buttonPin = _aui.PaneInfo_buttonPin buttonCustom1 = _aui.PaneInfo_buttonCustom1 buttonCustom2 = _aui.PaneInfo_buttonCustom2 buttonCustom3 = _aui.PaneInfo_buttonCustom3 actionPane = _aui.PaneInfo_actionPane name = property(_aui.PaneInfo_name_get, _aui.PaneInfo_name_set) caption = property(_aui.PaneInfo_caption_get, _aui.PaneInfo_caption_set) window = property(_aui.PaneInfo_window_get, _aui.PaneInfo_window_set) frame = property(_aui.PaneInfo_frame_get, _aui.PaneInfo_frame_set) state = property(_aui.PaneInfo_state_get, _aui.PaneInfo_state_set) dock_direction = property(_aui.PaneInfo_dock_direction_get, _aui.PaneInfo_dock_direction_set) dock_layer = property(_aui.PaneInfo_dock_layer_get, _aui.PaneInfo_dock_layer_set) dock_row = property(_aui.PaneInfo_dock_row_get, _aui.PaneInfo_dock_row_set) dock_pos = property(_aui.PaneInfo_dock_pos_get, _aui.PaneInfo_dock_pos_set) best_size = property(_aui.PaneInfo_best_size_get, _aui.PaneInfo_best_size_set) min_size = property(_aui.PaneInfo_min_size_get, _aui.PaneInfo_min_size_set) max_size = property(_aui.PaneInfo_max_size_get, _aui.PaneInfo_max_size_set) floating_pos = property(_aui.PaneInfo_floating_pos_get, _aui.PaneInfo_floating_pos_set) floating_size = property(_aui.PaneInfo_floating_size_get, _aui.PaneInfo_floating_size_set) dock_proportion = property(_aui.PaneInfo_dock_proportion_get, _aui.PaneInfo_dock_proportion_set) buttons = property(_aui.PaneInfo_buttons_get, _aui.PaneInfo_buttons_set) rect = property(_aui.PaneInfo_rect_get, _aui.PaneInfo_rect_set) _aui.PaneInfo_swigregister(PaneInfo) cvar = _aui.cvar class FrameManager(_core.EvtHandler): """ FrameManager manages the panes associated with it for a particular `wx.Frame`, using a pane's `PaneInfo` information to determine each pane's docking and floating behavior. FrameManager uses wxWidgets' sizer mechanism to plan the layout of each frame. It uses a replaceable `DockArt` class to do all drawing, so all drawing is localized in one area, and may be customized depending on an application's specific needs. """ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def __init__(self, *args, **kwargs): """ __init__(self, Window managed_wnd=None, int flags=AUI_MGR_DEFAULT) -> FrameManager Constructor. :param managed_wnd: Specifies the `wx.Window` which should be managed. If not set in the call to this constructor then `SetManagedWindow` should be called later. :param flags: Specifies options which allow the frame management behavior to be modified. """ _aui.FrameManager_swiginit(self,_aui.new_FrameManager(*args, **kwargs)) __swig_destroy__ = _aui.delete_FrameManager __del__ = lambda self : None; def UnInit(*args, **kwargs): """ UnInit(self) UnInit uninitializes the framework and should be called before a managed frame is destroyed. UnInit is usually called in the managed window's destructor. """ return _aui.FrameManager_UnInit(*args, **kwargs) def SetFlags(*args, **kwargs): """ SetFlags(self, int flags) SetFlags is used to specify the FrameManager's behavioral settings. The flags parameter is described in the docs for `__init__` """ return _aui.FrameManager_SetFlags(*args, **kwargs) def GetFlags(*args, **kwargs): """ GetFlags(self) -> int GetFlags returns the current FrameManager's flags. """ return _aui.FrameManager_GetFlags(*args, **kwargs) def SetManagedWindow(*args, **kwargs): """ SetManagedWindow(self, Window managed_wnd) SetManagedWindow is called to specify the window which is to be managed by the FrameManager. It is normally a `wx.Frame` but it is possible to also allow docking within any container window. This only needs to be called if the window was not given to the manager in the constructor. """ return _aui.FrameManager_SetManagedWindow(*args, **kwargs) def GetManagedWindow(*args, **kwargs): """ GetManagedWindow(self) -> Window GetManagedWindow returns the window currently being managed by the FrameManager. """ return _aui.FrameManager_GetManagedWindow(*args, **kwargs) def SetArtProvider(*args, **kwargs): """ SetArtProvider(self, DockArt art_provider) SetArtProvider instructs FrameManager to use the art provider specified for all drawing calls. This allows plugable look-and-feel features. The previous art provider object, if any, will be destroyed by FrameManager. :note: If you wish to use a custom `DockArt` class to override drawing or metrics then you shoudl derive your class from the `PyDockArt` class, which has been instrumented for reflecting virtual calls to Python methods. """ return _aui.FrameManager_SetArtProvider(*args, **kwargs) def GetArtProvider(*args, **kwargs): """ GetArtProvider(self) -> DockArt GetArtProvider returns the current art provider being used. """ return _aui.FrameManager_GetArtProvider(*args, **kwargs) def _GetPaneByWidget(*args, **kwargs): """_GetPaneByWidget(self, Window window) -> PaneInfo""" return _aui.FrameManager__GetPaneByWidget(*args, **kwargs) def _GetPaneByName(*args, **kwargs): """_GetPaneByName(self, String name) -> PaneInfo""" return _aui.FrameManager__GetPaneByName(*args, **kwargs) def GetAllPanes(*args, **kwargs): """ GetAllPanes(self) -> list GetAllPanes returns a list of `PaneInfo` objects for all panes managed by the frame manager. """ return _aui.FrameManager_GetAllPanes(*args, **kwargs) def _AddPane1(*args, **kwargs): """_AddPane1(self, Window window, PaneInfo pane_info) -> bool""" return _aui.FrameManager__AddPane1(*args, **kwargs) def AddPaneAtPos(*args, **kwargs): """AddPaneAtPos(self, Window window, PaneInfo pane_info, Point drop_pos) -> bool""" return _aui.FrameManager_AddPaneAtPos(*args, **kwargs) def _AddPane2(*args, **kwargs): """_AddPane2(self, Window window, int direction=LEFT, String caption=wxEmptyString) -> bool""" return _aui.FrameManager__AddPane2(*args, **kwargs) def InsertPane(*args, **kwargs): """ InsertPane(self, Window window, PaneInfo insert_location, int insert_level=AUI_INSERT_PANE) -> bool InsertPane is used to insert either a previously unmanaged pane window into the frame manager, or to insert a currently managed pane somewhere else. InsertPane will push all panes, rows, or docks aside and insert the window into the position specified by ``insert_location``. Because ``insert_location`` 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``. """ return _aui.FrameManager_InsertPane(*args, **kwargs) def DetachPane(*args, **kwargs): """ DetachPane(self, Window window) -> bool DetachPane tells the FrameManager to stop managing the pane specified by window. The window, if in a floated frame, is reparented to the frame managed by FrameManager. """ return _aui.FrameManager_DetachPane(*args, **kwargs) def ClosePane(*args, **kwargs): """ClosePane(self, PaneInfo pane_info)""" return _aui.FrameManager_ClosePane(*args, **kwargs) def SavePaneInfo(*args, **kwargs): """SavePaneInfo(self, PaneInfo pane) -> String""" return _aui.FrameManager_SavePaneInfo(*args, **kwargs) def LoadPaneInfo(*args, **kwargs): """LoadPaneInfo(self, String pane_part, PaneInfo pane)""" return _aui.FrameManager_LoadPaneInfo(*args, **kwargs) def SavePerspective(*args, **kwargs): """ SavePerspective(self) -> String SavePerspective saves the entire user interface layout into an encoded string, which can then be stored someplace by the application. When a perspective is restored using `LoadPerspective`, the entire user interface will return to the state it was when the perspective was saved. """ return _aui.FrameManager_SavePerspective(*args, **kwargs) def LoadPerspective(*args, **kwargs): """ LoadPerspective(self, String perspective, bool update=True) -> bool LoadPerspective loads a saved perspective. If ``update`` is ``True``, `Update` is automatically invoked, thus realizing the saved perspective on screen. """ return _aui.FrameManager_LoadPerspective(*args, **kwargs) def Update(*args, **kwargs): """ Update(self) Update shoudl be called called after any number of changes are made to any of the managed panes. Update must be invoked after `AddPane` or `InsertPane` are called in order to "realize" or "commit" the changes. In addition, any number of changes may be made to `PaneInfo` structures (retrieved with `GetPane` or `GetAllPanes`), but to realize the changes, Update must be called. This construction allows pane flicker to be avoided by updating the whole layout at one time. """ return _aui.FrameManager_Update(*args, **kwargs) def CreateFloatingFrame(*args, **kwargs): """CreateFloatingFrame(self, Window parent, PaneInfo p) -> FloatingPane""" return _aui.FrameManager_CreateFloatingFrame(*args, **kwargs) def DrawHintRect(*args, **kwargs): """DrawHintRect(self, Window pane_window, Point pt, Point offset)""" return _aui.FrameManager_DrawHintRect(*args, **kwargs) def ShowHint(*args, **kwargs): """ShowHint(self, Rect rect)""" return _aui.FrameManager_ShowHint(*args, **kwargs) def HideHint(*args, **kwargs): """HideHint(self)""" return _aui.FrameManager_HideHint(*args, **kwargs) def OnRender(*args, **kwargs): """OnRender(self, FrameManagerEvent evt)""" return _aui.FrameManager_OnRender(*args, **kwargs) def OnPaneButton(*args, **kwargs): """OnPaneButton(self, FrameManagerEvent evt)""" return _aui.FrameManager_OnPaneButton(*args, **kwargs) def GetPane(self, item): """ GetPane(self, window_or_info item) -> PaneInfo GetPane is used to search for a `PaneInfo` object either by widget reference or by pane name, which acts as a unique id for a window pane. The returned `PaneInfo` object may then be modified to change a pane's look, state or position. After one or more modifications to the `PaneInfo`, `FrameManager.Update` should be called to realize the changes to the user interface. If the lookup failed (meaning the pane could not be found in the manager) GetPane returns an empty `PaneInfo`, a condition which can be checked by calling `PaneInfo.IsOk`. """ if isinstance(item, wx.Window): return self._GetPaneByWidget(item) else: return self._GetPaneByName(item) def AddPane(self, window, info=None, caption=None): """ AddPane(self, window, info=None, caption=None) -> bool AddPane tells the frame manager to start managing a child window. There are two versions of this function. The first verison accepts a `PaneInfo` object for the ``info`` parameter and allows the full spectrum of pane parameter possibilities. (Say that 3 times fast!) The second version is used for simpler user interfaces which do not require as much configuration. In this case the ``info`` parameter specifies the direction property of the pane info, and defaults to ``wx.LEFT``. The pane caption may also be specified as an extra parameter in this form. """ if type(info) == PaneInfo: return self._AddPane1(window, info) else: if info is None: info = wx.LEFT if caption is None: caption = "" return self._AddPane2(window, info, caption) SetFrame = wx._deprecated(SetManagedWindow, "SetFrame is deprecated, use `SetManagedWindow` instead.") GetFrame = wx._deprecated(GetManagedWindow, "GetFrame is deprecated, use `GetManagedWindow` instead.") AllPanes = property(GetAllPanes,doc="See `GetAllPanes`") ArtProvider = property(GetArtProvider,SetArtProvider,doc="See `GetArtProvider` and `SetArtProvider`") Flags = property(GetFlags,SetFlags,doc="See `GetFlags` and `SetFlags`") ManagedWindow = property(GetManagedWindow,SetManagedWindow,doc="See `GetManagedWindow` and `SetManagedWindow`") _aui.FrameManager_swigregister(FrameManager) class FrameManagerEvent(_core.Event): """Proxy of C++ FrameManagerEvent class""" thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def __init__(self, *args, **kwargs): """__init__(self, EventType type=wxEVT_NULL) -> FrameManagerEvent""" _aui.FrameManagerEvent_swiginit(self,_aui.new_FrameManagerEvent(*args, **kwargs)) def Clone(*args, **kwargs): """Clone(self) -> Event""" return _aui.FrameManagerEvent_Clone(*args, **kwargs) def SetPane(*args, **kwargs): """SetPane(self, PaneInfo p)""" return _aui.FrameManagerEvent_SetPane(*args, **kwargs) def SetButton(*args, **kwargs): """SetButton(self, int b)""" return _aui.FrameManagerEvent_SetButton(*args, **kwargs) def SetDC(*args, **kwargs): """SetDC(self, DC pdc)""" return _aui.FrameManagerEvent_SetDC(*args, **kwargs) def GetPane(*args, **kwargs): """GetPane(self) -> PaneInfo""" return _aui.FrameManagerEvent_GetPane(*args, **kwargs) def GetButton(*args, **kwargs): """GetButton(self) -> int""" return _aui.FrameManagerEvent_GetButton(*args, **kwargs) def GetDC(*args, **kwargs): """GetDC(self) -> DC""" return _aui.FrameManagerEvent_GetDC(*args, **kwargs) def Veto(*args, **kwargs): """Veto(self, bool veto=True)""" return _aui.FrameManagerEvent_Veto(*args, **kwargs) def GetVeto(*args, **kwargs): """GetVeto(self) -> bool""" return _aui.FrameManagerEvent_GetVeto(*args, **kwargs) def SetCanVeto(*args, **kwargs): """SetCanVeto(self, bool can_veto)""" return _aui.FrameManagerEvent_SetCanVeto(*args, **kwargs) def CanVeto(*args, **kwargs): """CanVeto(self) -> bool""" return _aui.FrameManagerEvent_CanVeto(*args, **kwargs) pane = property(_aui.FrameManagerEvent_pane_get, _aui.FrameManagerEvent_pane_set) button = property(_aui.FrameManagerEvent_button_get, _aui.FrameManagerEvent_button_set) veto_flag = property(_aui.FrameManagerEvent_veto_flag_get, _aui.FrameManagerEvent_veto_flag_set) canveto_flag = property(_aui.FrameManagerEvent_canveto_flag_get, _aui.FrameManagerEvent_canveto_flag_set) dc = property(_aui.FrameManagerEvent_dc_get, _aui.FrameManagerEvent_dc_set) Button = property(GetButton,SetButton,doc="See `GetButton` and `SetButton`") DC = property(GetDC,SetDC,doc="See `GetDC` and `SetDC`") Pane = property(GetPane,SetPane,doc="See `GetPane` and `SetPane`") _aui.FrameManagerEvent_swigregister(FrameManagerEvent) class DockInfo(object): """Proxy of C++ DockInfo class""" thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def __init__(self, *args, **kwargs): """__init__(self) -> DockInfo""" _aui.DockInfo_swiginit(self,_aui.new_DockInfo(*args, **kwargs)) def IsOk(*args, **kwargs): """IsOk(self) -> bool""" return _aui.DockInfo_IsOk(*args, **kwargs) def IsHorizontal(*args, **kwargs): """IsHorizontal(self) -> bool""" return _aui.DockInfo_IsHorizontal(*args, **kwargs) def IsVertical(*args, **kwargs): """IsVertical(self) -> bool""" return _aui.DockInfo_IsVertical(*args, **kwargs) panes = property(_aui.DockInfo_panes_get, _aui.DockInfo_panes_set) rect = property(_aui.DockInfo_rect_get, _aui.DockInfo_rect_set) dock_direction = property(_aui.DockInfo_dock_direction_get, _aui.DockInfo_dock_direction_set) dock_layer = property(_aui.DockInfo_dock_layer_get, _aui.DockInfo_dock_layer_set) dock_row = property(_aui.DockInfo_dock_row_get, _aui.DockInfo_dock_row_set) size = property(_aui.DockInfo_size_get, _aui.DockInfo_size_set) min_size = property(_aui.DockInfo_min_size_get, _aui.DockInfo_min_size_set) resizable = property(_aui.DockInfo_resizable_get, _aui.DockInfo_resizable_set) toolbar = property(_aui.DockInfo_toolbar_get, _aui.DockInfo_toolbar_set) fixed = property(_aui.DockInfo_fixed_get, _aui.DockInfo_fixed_set) __swig_destroy__ = _aui.delete_DockInfo __del__ = lambda self : None; _aui.DockInfo_swigregister(DockInfo) class DockUIPart(object): """Proxy of C++ DockUIPart class""" thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self): raise AttributeError, "No constructor defined" __repr__ = _swig_repr typeCaption = _aui.DockUIPart_typeCaption typeGripper = _aui.DockUIPart_typeGripper typeDock = _aui.DockUIPart_typeDock typeDockSizer = _aui.DockUIPart_typeDockSizer typePane = _aui.DockUIPart_typePane typePaneSizer = _aui.DockUIPart_typePaneSizer typeBackground = _aui.DockUIPart_typeBackground typePaneBorder = _aui.DockUIPart_typePaneBorder typePaneButton = _aui.DockUIPart_typePaneButton type = property(_aui.DockUIPart_type_get, _aui.DockUIPart_type_set) orientation = property(_aui.DockUIPart_orientation_get, _aui.DockUIPart_orientation_set) dock = property(_aui.DockUIPart_dock_get, _aui.DockUIPart_dock_set) pane = property(_aui.DockUIPart_pane_get, _aui.DockUIPart_pane_set) button = property(_aui.DockUIPart_button_get, _aui.DockUIPart_button_set) cont_sizer = property(_aui.DockUIPart_cont_sizer_get, _aui.DockUIPart_cont_sizer_set) sizer_item = property(_aui.DockUIPart_sizer_item_get, _aui.DockUIPart_sizer_item_set) rect = property(_aui.DockUIPart_rect_get, _aui.DockUIPart_rect_set) __swig_destroy__ = _aui.delete_DockUIPart __del__ = lambda self : None; _aui.DockUIPart_swigregister(DockUIPart) class PaneButton(object): """Proxy of C++ PaneButton class""" thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self): raise AttributeError, "No constructor defined" __repr__ = _swig_repr button_id = property(_aui.PaneButton_button_id_get, _aui.PaneButton_button_id_set) __swig_destroy__ = _aui.delete_PaneButton __del__ = lambda self : None; _aui.PaneButton_swigregister(PaneButton) wxEVT_AUI_PANEBUTTON = _aui.wxEVT_AUI_PANEBUTTON wxEVT_AUI_PANECLOSE = _aui.wxEVT_AUI_PANECLOSE wxEVT_AUI_RENDER = _aui.wxEVT_AUI_RENDER EVT_AUI_PANEBUTTON = wx.PyEventBinder( wxEVT_AUI_PANEBUTTON ) EVT_AUI_PANECLOSE = wx.PyEventBinder( wxEVT_AUI_PANECLOSE ) EVT_AUI_RENDER = wx.PyEventBinder( wxEVT_AUI_RENDER ) class DockArt(object): """ DockArt is an art provider class which does all of the drawing for `FrameManager`. This allows the library caller to customize or replace the dock art and drawing routines by deriving a new class from `PyDockArt`. The active dock art class can be set via `FrameManager.SetArtProvider`. """ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self): raise AttributeError, "No constructor defined" __repr__ = _swig_repr __swig_destroy__ = _aui.delete_DockArt __del__ = lambda self : None; def GetMetric(*args, **kwargs): """GetMetric(self, int id) -> int""" return _aui.DockArt_GetMetric(*args, **kwargs) def SetMetric(*args, **kwargs): """SetMetric(self, int id, int new_val)""" return _aui.DockArt_SetMetric(*args, **kwargs) def SetFont(*args, **kwargs): """SetFont(self, int id, Font font)""" return _aui.DockArt_SetFont(*args, **kwargs) def GetFont(*args, **kwargs): """GetFont(self, int id) -> Font""" return _aui.DockArt_GetFont(*args, **kwargs) def GetColour(*args, **kwargs): """GetColour(self, int id) -> Colour""" return _aui.DockArt_GetColour(*args, **kwargs) def SetColour(*args, **kwargs): """SetColour(self, int id, wxColor colour)""" return _aui.DockArt_SetColour(*args, **kwargs) def GetColor(*args, **kwargs): """GetColor(self, int id) -> Colour""" return _aui.DockArt_GetColor(*args, **kwargs) def SetColor(*args, **kwargs): """SetColor(self, int id, Colour color)""" return _aui.DockArt_SetColor(*args, **kwargs) def DrawSash(*args, **kwargs): """DrawSash(self, DC dc, Window window, int orientation, Rect rect)""" return _aui.DockArt_DrawSash(*args, **kwargs) def DrawBackground(*args, **kwargs): """DrawBackground(self, DC dc, Window window, int orientation, Rect rect)""" return _aui.DockArt_DrawBackground(*args, **kwargs) def DrawCaption(*args, **kwargs): """DrawCaption(self, DC dc, Window window, String text, Rect rect, PaneInfo pane)""" return _aui.DockArt_DrawCaption(*args, **kwargs) def DrawGripper(*args, **kwargs): """DrawGripper(self, DC dc, Window window, Rect rect, PaneInfo pane)""" return _aui.DockArt_DrawGripper(*args, **kwargs) def DrawBorder(*args, **kwargs): """DrawBorder(self, DC dc, Window window, Rect rect, PaneInfo pane)""" return _aui.DockArt_DrawBorder(*args, **kwargs) def DrawPaneButton(*args, **kwargs): """ DrawPaneButton(self, DC dc, Window window, int button, int button_state, Rect rect, PaneInfo pane) """ return _aui.DockArt_DrawPaneButton(*args, **kwargs) _aui.DockArt_swigregister(DockArt) class DefaultDockArt(DockArt): """ DefaultDockArt is the type of art class constructed by default for the `FrameManager`. """ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def __init__(self, *args, **kwargs): """ __init__(self) -> DefaultDockArt DefaultDockArt is the type of art class constructed by default for the `FrameManager`. """ _aui.DefaultDockArt_swiginit(self,_aui.new_DefaultDockArt(*args, **kwargs)) _aui.DefaultDockArt_swigregister(DefaultDockArt) class FloatingPane(_windows.MiniFrame): """Proxy of C++ FloatingPane class""" thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def __init__(self, *args, **kwargs): """ __init__(self, Window parent, FrameManager owner_mgr, PaneInfo pane, int id=ID_ANY, long style=wxRESIZE_BORDER|wxSYSTEM_MENU|wxCAPTION|wxFRAME_NO_TASKBAR|wxFRAME_FLOAT_ON_PARENT|wxCLIP_CHILDREN) -> FloatingPane """ _aui.FloatingPane_swiginit(self,_aui.new_FloatingPane(*args, **kwargs)) __swig_destroy__ = _aui.delete_FloatingPane __del__ = lambda self : None; def SetPaneWindow(*args, **kwargs): """SetPaneWindow(self, PaneInfo pane)""" return _aui.FloatingPane_SetPaneWindow(*args, **kwargs) _aui.FloatingPane_swigregister(FloatingPane) class AuiNotebookEvent(_core.NotifyEvent): """Proxy of C++ AuiNotebookEvent class""" thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def __init__(self, *args, **kwargs): """__init__(self, EventType command_type=wxEVT_NULL, int win_id=0) -> AuiNotebookEvent""" _aui.AuiNotebookEvent_swiginit(self,_aui.new_AuiNotebookEvent(*args, **kwargs)) def SetSelection(*args, **kwargs): """SetSelection(self, int s)""" return _aui.AuiNotebookEvent_SetSelection(*args, **kwargs) def SetOldSelection(*args, **kwargs): """SetOldSelection(self, int s)""" return _aui.AuiNotebookEvent_SetOldSelection(*args, **kwargs) def GetSelection(*args, **kwargs): """ GetSelection(self) -> int Returns item index for a listbox or choice selection event (not valid for a deselection). """ return _aui.AuiNotebookEvent_GetSelection(*args, **kwargs) def GetOldSelection(*args, **kwargs): """GetOldSelection(self) -> int""" return _aui.AuiNotebookEvent_GetOldSelection(*args, **kwargs) old_selection = property(_aui.AuiNotebookEvent_old_selection_get, _aui.AuiNotebookEvent_old_selection_set) selection = property(_aui.AuiNotebookEvent_selection_get, _aui.AuiNotebookEvent_selection_set) OldSelection = property(GetOldSelection,SetOldSelection,doc="See `GetOldSelection` and `SetOldSelection`") Selection = property(GetSelection,SetSelection,doc="See `GetSelection` and `SetSelection`") _aui.AuiNotebookEvent_swigregister(AuiNotebookEvent) class AuiNotebookPage(object): """Proxy of C++ AuiNotebookPage class""" thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self): raise AttributeError, "No constructor defined" __repr__ = _swig_repr window = property(_aui.AuiNotebookPage_window_get, _aui.AuiNotebookPage_window_set) caption = property(_aui.AuiNotebookPage_caption_get, _aui.AuiNotebookPage_caption_set) bitmap = property(_aui.AuiNotebookPage_bitmap_get, _aui.AuiNotebookPage_bitmap_set) rect = property(_aui.AuiNotebookPage_rect_get, _aui.AuiNotebookPage_rect_set) active = property(_aui.AuiNotebookPage_active_get, _aui.AuiNotebookPage_active_set) _aui.AuiNotebookPage_swigregister(AuiNotebookPage) class AuiTabContainerButton(object): """Proxy of C++ AuiTabContainerButton class""" thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self): raise AttributeError, "No constructor defined" __repr__ = _swig_repr id = property(_aui.AuiTabContainerButton_id_get, _aui.AuiTabContainerButton_id_set) cur_state = property(_aui.AuiTabContainerButton_cur_state_get, _aui.AuiTabContainerButton_cur_state_set) bitmap = property(_aui.AuiTabContainerButton_bitmap_get, _aui.AuiTabContainerButton_bitmap_set) rect = property(_aui.AuiTabContainerButton_rect_get, _aui.AuiTabContainerButton_rect_set) _aui.AuiTabContainerButton_swigregister(AuiTabContainerButton) class AuiTabContainer(object): """Proxy of C++ AuiTabContainer class""" thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def __init__(self, *args, **kwargs): """__init__(self) -> AuiTabContainer""" _aui.AuiTabContainer_swiginit(self,_aui.new_AuiTabContainer(*args, **kwargs)) __swig_destroy__ = _aui.delete_AuiTabContainer __del__ = lambda self : None; def AddPage(*args, **kwargs): """AddPage(self, Window page, AuiNotebookPage info) -> bool""" return _aui.AuiTabContainer_AddPage(*args, **kwargs) def InsertPage(*args, **kwargs): """InsertPage(self, Window page, AuiNotebookPage info, size_t idx) -> bool""" return _aui.AuiTabContainer_InsertPage(*args, **kwargs) def RemovePage(*args, **kwargs): """RemovePage(self, Window page) -> bool""" return _aui.AuiTabContainer_RemovePage(*args, **kwargs) def SetActivePage(*args): """ SetActivePage(self, Window page) -> bool SetActivePage(self, size_t page) -> bool """ return _aui.AuiTabContainer_SetActivePage(*args) def SetNoneActive(*args, **kwargs): """SetNoneActive(self)""" return _aui.AuiTabContainer_SetNoneActive(*args, **kwargs) def GetActivePage(*args, **kwargs): """GetActivePage(self) -> int""" return _aui.AuiTabContainer_GetActivePage(*args, **kwargs) def TabHitTest(*args, **kwargs): """TabHitTest(self, int x, int y, Window hit) -> bool""" return _aui.AuiTabContainer_TabHitTest(*args, **kwargs) def ButtonHitTest(*args, **kwargs): """ButtonHitTest(self, int x, int y, AuiTabContainerButton hit) -> bool""" return _aui.AuiTabContainer_ButtonHitTest(*args, **kwargs) def GetWindowFromIdx(*args, **kwargs): """GetWindowFromIdx(self, size_t idx) -> Window""" return _aui.AuiTabContainer_GetWindowFromIdx(*args, **kwargs) def GetIdxFromWindow(*args, **kwargs): """GetIdxFromWindow(self, Window page) -> int""" return _aui.AuiTabContainer_GetIdxFromWindow(*args, **kwargs) def GetPageCount(*args, **kwargs): """GetPageCount(self) -> size_t""" return _aui.AuiTabContainer_GetPageCount(*args, **kwargs) def GetPage(*args, **kwargs): """GetPage(self, size_t idx) -> AuiNotebookPage""" return _aui.AuiTabContainer_GetPage(*args, **kwargs) def GetPages(*args, **kwargs): """GetPages(self) -> wxAuiNotebookPageArray""" return _aui.AuiTabContainer_GetPages(*args, **kwargs) def SetNormalFont(*args, **kwargs): """SetNormalFont(self, Font normal_font)""" return _aui.AuiTabContainer_SetNormalFont(*args, **kwargs) def SetSelectedFont(*args, **kwargs): """SetSelectedFont(self, Font selected_font)""" return _aui.AuiTabContainer_SetSelectedFont(*args, **kwargs) def SetMeasuringFont(*args, **kwargs): """SetMeasuringFont(self, Font measuring_font)""" return _aui.AuiTabContainer_SetMeasuringFont(*args, **kwargs) def DoShowHide(*args, **kwargs): """DoShowHide(self)""" return _aui.AuiTabContainer_DoShowHide(*args, **kwargs) def SetRect(*args, **kwargs): """SetRect(self, Rect rect)""" return _aui.AuiTabContainer_SetRect(*args, **kwargs) def AddButton(*args, **kwargs): """AddButton(self, int id, Bitmap bmp)""" return _aui.AuiTabContainer_AddButton(*args, **kwargs) ActivePage = property(GetActivePage,SetActivePage,doc="See `GetActivePage` and `SetActivePage`") PageCount = property(GetPageCount,doc="See `GetPageCount`") Pages = property(GetPages,doc="See `GetPages`") _aui.AuiTabContainer_swigregister(AuiTabContainer) class AuiTabCtrl(_core.Control,AuiTabContainer): """Proxy of C++ AuiTabCtrl class""" thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def __init__(self, *args, **kwargs): """ __init__(self, Window parent, int id=ID_ANY, Point pos=DefaultPosition, Size size=DefaultSize, long style=0) -> AuiTabCtrl """ _aui.AuiTabCtrl_swiginit(self,_aui.new_AuiTabCtrl(*args, **kwargs)) self._setOORInfo(self) _aui.AuiTabCtrl_swigregister(AuiTabCtrl) class AuiMultiNotebook(_core.Control): """Proxy of C++ AuiMultiNotebook class""" thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def __init__(self, *args, **kwargs): """ __init__(self, Window parent, int id=ID_ANY, Point pos=DefaultPosition, Size size=DefaultSize, long style=0) -> AuiMultiNotebook """ _aui.AuiMultiNotebook_swiginit(self,_aui.new_AuiMultiNotebook(*args, **kwargs)) self._setOORInfo(self) def Create(*args, **kwargs): """ Create(self, Window parent, int id=ID_ANY, Point pos=DefaultPosition, Size size=DefaultSize, long style=0) -> bool Do the 2nd phase and create the GUI control. """ return _aui.AuiMultiNotebook_Create(*args, **kwargs) def AddPage(*args, **kwargs): """AddPage(self, Window page, String caption, bool select=False, Bitmap bitmap=wxNullBitmap) -> bool""" return _aui.AuiMultiNotebook_AddPage(*args, **kwargs) def InsertPage(*args, **kwargs): """ InsertPage(self, size_t page_idx, Window page, String caption, bool select=False, Bitmap bitmap=wxNullBitmap) -> bool """ return _aui.AuiMultiNotebook_InsertPage(*args, **kwargs) def DeletePage(*args, **kwargs): """DeletePage(self, size_t page) -> bool""" return _aui.AuiMultiNotebook_DeletePage(*args, **kwargs) def RemovePage(*args, **kwargs): """RemovePage(self, size_t page) -> bool""" return _aui.AuiMultiNotebook_RemovePage(*args, **kwargs) def SetPageText(*args, **kwargs): """SetPageText(self, size_t page, String text) -> bool""" return _aui.AuiMultiNotebook_SetPageText(*args, **kwargs) def SetSelection(*args, **kwargs): """SetSelection(self, size_t new_page) -> size_t""" return _aui.AuiMultiNotebook_SetSelection(*args, **kwargs) def GetSelection(*args, **kwargs): """GetSelection(self) -> int""" return _aui.AuiMultiNotebook_GetSelection(*args, **kwargs) def GetPageCount(*args, **kwargs): """GetPageCount(self) -> size_t""" return _aui.AuiMultiNotebook_GetPageCount(*args, **kwargs) def GetPage(*args, **kwargs): """GetPage(self, size_t page_idx) -> Window""" return _aui.AuiMultiNotebook_GetPage(*args, **kwargs) PageCount = property(GetPageCount,doc="See `GetPageCount`") Selection = property(GetSelection,SetSelection,doc="See `GetSelection` and `SetSelection`") _aui.AuiMultiNotebook_swigregister(AuiMultiNotebook) def PreAuiMultiNotebook(*args, **kwargs): """PreAuiMultiNotebook() -> AuiMultiNotebook""" val = _aui.new_PreAuiMultiNotebook(*args, **kwargs) self._setOORInfo(self) return val wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED = _aui.wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING = _aui.wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING wxEVT_COMMAND_AUINOTEBOOK_BUTTON = _aui.wxEVT_COMMAND_AUINOTEBOOK_BUTTON wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG = _aui.wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG wxEVT_COMMAND_AUINOTEBOOK_END_DRAG = _aui.wxEVT_COMMAND_AUINOTEBOOK_END_DRAG wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION = _aui.wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION EVT_AUINOTEBOOK_PAGE_CHANGED = wx.PyEventBinder( wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED, 1 ) EVT_AUINOTEBOOK_PAGE_CHANGING = wx.PyEventBinder( wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, 1 ) EVT_AUINOTEBOOK_BUTTON = wx.PyEventBinder( wxEVT_COMMAND_AUINOTEBOOK_BUTTON, 1 ) EVT_AUINOTEBOOK_BEGIN_DRAG = wx.PyEventBinder( wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG, 1 ) EVT_AUINOTEBOOK_END_DRAG = wx.PyEventBinder( wxEVT_COMMAND_AUINOTEBOOK_END_DRAG, 1 ) EVT_AUINOTEBOOK_DRAG_MOTION = wx.PyEventBinder( wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION, 1 ) class PyDockArt(DefaultDockArt): """ This version of the `DockArt` class has been instrumented to be subclassable in Python and to reflect all calls to the C++ base class methods to the Python methods implemented in the derived class. """ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self): raise AttributeError, "No constructor defined" __repr__ = _swig_repr _aui.PyDockArt_swigregister(PyDockArt)