X-Git-Url: http://iramuteq.org/git?p=iramuteq;a=blobdiff_plain;f=agw%2Faui%2Fauibar.py;fp=agw%2Faui%2Fauibar.py;h=0000000000000000000000000000000000000000;hp=4d348b74ff440ba105fbcad5ca8b2de870a4151e;hb=22f93a602f3584ddc6ba68114556212c90307a50;hpb=d1d24d86422c9e9805516190ea17a379201f9300 diff --git a/agw/aui/auibar.py b/agw/aui/auibar.py deleted file mode 100644 index 4d348b7..0000000 --- a/agw/aui/auibar.py +++ /dev/null @@ -1,3926 +0,0 @@ -""" -auibar contains an implementation of L{AuiToolBar}, which is a completely owner-drawn -toolbar perfectly integrated with the AUI layout system. This allows drag and drop of -toolbars, docking/floating behaviour and the possibility to define "overflow" items -in the toolbar itself. - -The default theme that is used is L{AuiDefaultToolBarArt}, which provides a modern, -glossy look and feel. The theme can be changed by calling L{AuiToolBar.SetArtProvider}. -""" - -__author__ = "Andrea Gavana " -__date__ = "31 March 2009" - - -import wx -import types - -from aui_utilities import BitmapFromBits, StepColour, GetLabelSize -from aui_utilities import GetBaseColour, MakeDisabledBitmap - -import framemanager -from aui_constants import * - -# wxPython version string -_VERSION_STRING = wx.VERSION_STRING - -# AuiToolBar events -wxEVT_COMMAND_AUITOOLBAR_TOOL_DROPDOWN = wx.NewEventType() -wxEVT_COMMAND_AUITOOLBAR_OVERFLOW_CLICK = wx.NewEventType() -wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK = wx.NewEventType() -wxEVT_COMMAND_AUITOOLBAR_MIDDLE_CLICK = wx.NewEventType() -wxEVT_COMMAND_AUITOOLBAR_BEGIN_DRAG = wx.NewEventType() - -EVT_AUITOOLBAR_TOOL_DROPDOWN = wx.PyEventBinder(wxEVT_COMMAND_AUITOOLBAR_TOOL_DROPDOWN, 1) -""" A dropdown `AuiToolBarItem` is being shown. """ -EVT_AUITOOLBAR_OVERFLOW_CLICK = wx.PyEventBinder(wxEVT_COMMAND_AUITOOLBAR_OVERFLOW_CLICK, 1) -""" The user left-clicked on the overflow button in `AuiToolBar`. """ -EVT_AUITOOLBAR_RIGHT_CLICK = wx.PyEventBinder(wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK, 1) -""" Fires an event when the user right-clicks on a `AuiToolBarItem`. """ -EVT_AUITOOLBAR_MIDDLE_CLICK = wx.PyEventBinder(wxEVT_COMMAND_AUITOOLBAR_MIDDLE_CLICK, 1) -""" Fires an event when the user middle-clicks on a `AuiToolBarItem`. """ -EVT_AUITOOLBAR_BEGIN_DRAG = wx.PyEventBinder(wxEVT_COMMAND_AUITOOLBAR_BEGIN_DRAG, 1) -""" A drag operation involving a toolbar item has started. """ - -# ---------------------------------------------------------------------- - -class CommandToolBarEvent(wx.PyCommandEvent): - """ A specialized command event class for events sent by L{AuiToolBar}. """ - - def __init__(self, command_type, win_id): - """ - Default class constructor. - - :param `command_type`: the event kind or an instance of `wx.PyCommandEvent`. - :param `win_id`: the window identification number. - """ - - if type(command_type) == types.IntType: - wx.PyCommandEvent.__init__(self, command_type, win_id) - else: - wx.PyCommandEvent.__init__(self, command_type.GetEventType(), command_type.GetId()) - - self.is_dropdown_clicked = False - self.click_pt = wx.Point(-1, -1) - self.rect = wx.Rect(-1, -1, 0, 0) - self.tool_id = -1 - - - def IsDropDownClicked(self): - """ Returns whether the drop down menu has been clicked. """ - - return self.is_dropdown_clicked - - - def SetDropDownClicked(self, c): - """ - Sets whether the drop down menu has been clicked. - - :param `c`: ``True`` to set the drop down as clicked, ``False`` otherwise. - """ - - self.is_dropdown_clicked = c - - - def GetClickPoint(self): - """ Returns the point where the user clicked with the mouse. """ - - return self.click_pt - - - def SetClickPoint(self, p): - """ - Sets the clicking point. - - :param `p`: a `wx.Point` object. - """ - - self.click_pt = p - - - def GetItemRect(self): - """ Returns the L{AuiToolBarItem} rectangle. """ - - return self.rect - - - def SetItemRect(self, r): - """ - Sets the L{AuiToolBarItem} rectangle. - - :param `r`: an instance of `wx.Rect`. - """ - - self.rect = r - - - def GetToolId(self): - """ Returns the L{AuiToolBarItem} identifier. """ - - return self.tool_id - - - def SetToolId(self, id): - """ - Sets the L{AuiToolBarItem} identifier. - - :param `id`: the toolbar item identifier. - """ - - self.tool_id = id - - -# ---------------------------------------------------------------------- - -class AuiToolBarEvent(CommandToolBarEvent): - """ A specialized command event class for events sent by L{AuiToolBar}. """ - - def __init__(self, command_type=None, win_id=0): - """ - Default class constructor. - - :param `command_type`: the event kind or an instance of `wx.PyCommandEvent`. - :param `win_id`: the window identification number. - """ - - CommandToolBarEvent.__init__(self, command_type, win_id) - - if type(command_type) == types.IntType: - self.notify = wx.NotifyEvent(command_type, win_id) - else: - self.notify = wx.NotifyEvent(command_type.GetEventType(), command_type.GetId()) - - - def GetNotifyEvent(self): - """ Returns the actual `wx.NotifyEvent`. """ - - return self.notify - - - def IsAllowed(self): - """ Returns whether the event is allowed or not. """ - - return self.notify.IsAllowed() - - - def Veto(self): - """ - 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. - """ - - self.notify.Veto() - - - def Allow(self): - """ - This is the opposite of L{Veto}: it explicitly allows the event to be - processed. For most events it is not necessary to call this method as the - events are allowed anyhow but some are forbidden by default (this will - be mentioned in the corresponding event description). - """ - - self.notify.Allow() - - -# ---------------------------------------------------------------------- - -class ToolbarCommandCapture(wx.PyEvtHandler): - """ A class to handle the dropdown window menu. """ - - def __init__(self): - """ Default class constructor. """ - - wx.PyEvtHandler.__init__(self) - self._last_id = 0 - - - def GetCommandId(self): - """ Returns the event command identifier. """ - - return self._last_id - - - def ProcessEvent(self, event): - """ - Processes an event, searching event tables and calling zero or more suitable - event handler function(s). - - :param `event`: the event to process. - - :note: Normally, your application would not call this function: it is called - in the wxPython implementation to dispatch incoming user interface events - to the framework (and application). - However, you might need to call it if implementing new functionality (such as - a new control) where you define new event types, as opposed to allowing the - user to override functions. - - An instance where you might actually override the L{ProcessEvent} function is where - you want to direct event processing to event handlers not normally noticed by - wxPython. For example, in the document/view architecture, documents and views - are potential event handlers. When an event reaches a frame, L{ProcessEvent} will - need to be called on the associated document and view in case event handler - functions are associated with these objects. - - The normal order of event table searching is as follows: - - 1. If the object is disabled (via a call to `SetEvtHandlerEnabled`) the function - skips to step (6). - 2. If the object is a `wx.Window`, L{ProcessEvent} is recursively called on the window's - `wx.Validator`. If this returns ``True``, the function exits. - 3. wxWidgets `SearchEventTable` is called for this event handler. If this fails, the - base class table is tried, and so on until no more tables exist or an appropriate - function was found, in which case the function exits. - 4. The search is applied down the entire chain of event handlers (usually the chain - has a length of one). If this succeeds, the function exits. - 5. If the object is a `wx.Window` and the event is a `wx.CommandEvent`, L{ProcessEvent} is - recursively applied to the parent window's event handler. If this returns ``True``, - the function exits. - 6. Finally, L{ProcessEvent} is called on the `wx.App` object. - """ - - if event.GetEventType() == wx.wxEVT_COMMAND_MENU_SELECTED: - self._last_id = event.GetId() - return True - - if self.GetNextHandler(): - return self.GetNextHandler().ProcessEvent(event) - - return False - - -# ---------------------------------------------------------------------- - -class AuiToolBarItem(object): - """ - AuiToolBarItem is a toolbar element. - - It has a unique id (except for the separators which always have id = -1), the - style (telling whether it is a normal button, separator or a control), the - state (toggled or not, enabled or not) and short and long help strings. The - default implementations use the short help string for the tooltip text which - is popped up when the mouse pointer enters the tool and the long help string - for the applications status bar. - """ - - def __init__(self, item=None): - """ - Default class constructor. - - :param `item`: another instance of L{AuiToolBarItem}. - """ - - if item: - self.Assign(item) - return - - self.window = None - self.clockwisebmp = wx.NullBitmap - self.counterclockwisebmp = wx.NullBitmap - self.clockwisedisbmp = wx.NullBitmap - self.counterclockwisedisbmp = wx.NullBitmap - self.sizer_item = None - self.spacer_pixels = 0 - self.id = 0 - self.kind = ITEM_NORMAL - self.state = 0 # normal, enabled - self.proportion = 0 - self.active = True - self.dropdown = True - self.sticky = True - self.user_data = 0 - - self.label = "" - self.bitmap = wx.NullBitmap - self.disabled_bitmap = wx.NullBitmap - self.hover_bitmap = wx.NullBitmap - self.short_help = "" - self.long_help = "" - self.min_size = wx.Size(-1, -1) - self.alignment = wx.ALIGN_CENTER - self.orientation = AUI_TBTOOL_HORIZONTAL - - - def Assign(self, c): - """ - Assigns the properties of the L{AuiToolBarItem} `c` to `self`. - - :param `c`: another instance of L{AuiToolBarItem}. - """ - - self.window = c.window - self.label = c.label - self.bitmap = c.bitmap - self.disabled_bitmap = c.disabled_bitmap - self.hover_bitmap = c.hover_bitmap - self.short_help = c.short_help - self.long_help = c.long_help - self.sizer_item = c.sizer_item - self.min_size = c.min_size - self.spacer_pixels = c.spacer_pixels - self.id = c.id - self.kind = c.kind - self.state = c.state - self.proportion = c.proportion - self.active = c.active - self.dropdown = c.dropdown - self.sticky = c.sticky - self.user_data = c.user_data - self.alignment = c.alignment - self.orientation = c.orientation - - - def SetWindow(self, w): - """ - Assigns a window to the toolbar item. - - :param `w`: an instance of `wx.Window`. - """ - - self.window = w - - - def GetWindow(self): - """ Returns window associated to the toolbar item. """ - - return self.window - - - def SetId(self, new_id): - """ - Sets the toolbar item identifier. - - :param `new_id`: the new tool id. - """ - - self.id = new_id - - - def GetId(self): - """ Returns the toolbar item identifier. """ - - return self.id - - - def SetKind(self, new_kind): - """ - Sets the L{AuiToolBarItem} kind. - - :param `new_kind`: can be one of the following items: - - ======================== ============================= - Item Kind Description - ======================== ============================= - ``ITEM_CONTROL`` The item in the `AuiToolBar` is a control - ``ITEM_LABEL`` The item in the `AuiToolBar` is a text label - ``ITEM_SPACER`` The item in the `AuiToolBar` is a spacer - ``ITEM_SEPARATOR`` The item in the `AuiToolBar` is a separator - ``ITEM_CHECK`` The item in the `AuiToolBar` is a toolbar check item - ``ITEM_NORMAL`` The item in the `AuiToolBar` is a standard toolbar item - ``ITEM_RADIO`` The item in the `AuiToolBar` is a toolbar radio item - ======================== ============================= - """ - - self.kind = new_kind - - - def GetKind(self): - """ Returns the toolbar item kind. See L{SetKind} for more details. """ - - return self.kind - - - def SetState(self, new_state): - """ - Sets the toolbar item state. - - :param `new_state`: can be one of the following states: - - ============================================ ====================================== - Button State Constant Description - ============================================ ====================================== - ``AUI_BUTTON_STATE_NORMAL`` Normal button state - ``AUI_BUTTON_STATE_HOVER`` Hovered button state - ``AUI_BUTTON_STATE_PRESSED`` Pressed button state - ``AUI_BUTTON_STATE_DISABLED`` Disabled button state - ``AUI_BUTTON_STATE_HIDDEN`` Hidden button state - ``AUI_BUTTON_STATE_CHECKED`` Checked button state - ============================================ ====================================== - - """ - - self.state = new_state - - - def GetState(self): - """ - Returns the toolbar item state. See L{SetState} for more details. - - :see: L{SetState} - """ - - return self.state - - - def SetSizerItem(self, s): - """ - Associates a sizer item to this toolbar item. - - :param `s`: an instance of `wx.SizerItem`. - """ - - self.sizer_item = s - - - def GetSizerItem(self): - """ Returns the associated sizer item. """ - - return self.sizer_item - - - def SetLabel(self, s): - """ - Sets the toolbar item label. - - :param `s`: a string specifying the toolbar item label. - """ - - self.label = s - - - def GetLabel(self): - """ Returns the toolbar item label. """ - - return self.label - - - def SetBitmap(self, bmp): - """ - Sets the toolbar item bitmap. - - :param `bmp`: an instance of `wx.Bitmap`. - """ - - self.bitmap = bmp - - - def GetBitmap(self): - """ Returns the toolbar item bitmap. """ - - return self.GetRotatedBitmap(False) - - - def SetDisabledBitmap(self, bmp): - """ - Sets the toolbar item disabled bitmap. - - :param `bmp`: an instance of `wx.Bitmap`. - """ - - self.disabled_bitmap = bmp - - - def GetDisabledBitmap(self): - """ Returns the toolbar item disabled bitmap. """ - - return self.GetRotatedBitmap(True) - - - def SetHoverBitmap(self, bmp): - """ - Sets the toolbar item hover bitmap. - - :param `bmp`: an instance of `wx.Bitmap`. - """ - - self.hover_bitmap = bmp - - - def SetOrientation(self, a): - """ - Sets the toolbar tool orientation. - - :param `a`: one of ``AUI_TBTOOL_HORIZONTAL``, ``AUI_TBTOOL_VERT_CLOCKWISE`` or - ``AUI_TBTOOL_VERT_COUNTERCLOCKWISE``. - """ - - self.orientation = a - - - def GetOrientation(self): - """ Returns the toolbar tool orientation. """ - - return self.orientation - - - def GetHoverBitmap(self): - """ Returns the toolbar item hover bitmap. """ - - return self.hover_bitmap - - - def GetRotatedBitmap(self, disabled): - """ - Returns the correct bitmap depending on the tool orientation. - - :param `disabled`: whether to return the disabled bitmap or not. - """ - - bitmap_to_rotate = (disabled and [self.disabled_bitmap] or [self.bitmap])[0] - if not bitmap_to_rotate.IsOk() or self.orientation == AUI_TBTOOL_HORIZONTAL: - return bitmap_to_rotate - - rotated_bitmap = wx.NullBitmap - clockwise = True - if self.orientation == AUI_TBTOOL_VERT_CLOCKWISE: - rotated_bitmap = (disabled and [self.clockwisedisbmp] or [self.clockwisebmp])[0] - - elif self.orientation == AUI_TBTOOL_VERT_COUNTERCLOCKWISE: - rotated_bitmap = (disabled and [self.counterclockwisedisbmp] or [self.counterclockwisebmp])[0] - clockwise = False - - if not rotated_bitmap.IsOk(): - rotated_bitmap = wx.BitmapFromImage(bitmap_to_rotate.ConvertToImage().Rotate90(clockwise)) - - return rotated_bitmap - - - def SetShortHelp(self, s): - """ - Sets the short help string for the L{AuiToolBarItem}, to be displayed in a - `wx.ToolTip` when the mouse hover over the toolbar item. - - :param `s`: the tool short help string. - """ - - self.short_help = s - - - def GetShortHelp(self): - """ Returns the short help string for the L{AuiToolBarItem}. """ - - return self.short_help - - - def SetLongHelp(self, s): - """ - Sets the long help string for the toolbar item. This string is shown in the - statusbar (if any) of the parent frame when the mouse pointer is inside the - tool. - - :param `s`: the tool long help string. - """ - - self.long_help = s - - - def GetLongHelp(self): - """ Returns the long help string for the L{AuiToolBarItem}. """ - - return self.long_help - - - def SetMinSize(self, s): - """ - Sets the toolbar item minimum size. - - :param `s`: an instance of `wx.Size`. - """ - - self.min_size = wx.Size(*s) - - - def GetMinSize(self): - """ Returns the toolbar item minimum size. """ - - return self.min_size - - - def SetSpacerPixels(self, s): - """ - Sets the number of pixels for a toolbar item with kind = ``ITEM_SEPARATOR``. - - :param `s`: number of pixels. - """ - - self.spacer_pixels = s - - - def GetSpacerPixels(self): - """ Returns the number of pixels for a toolbar item with kind = ``ITEM_SEPARATOR``. """ - - return self.spacer_pixels - - - def SetProportion(self, p): - """ - Sets the L{AuiToolBarItem} proportion in the toolbar. - - :param `p`: the item proportion. - """ - - self.proportion = p - - - def GetProportion(self): - """ Returns the L{AuiToolBarItem} proportion in the toolbar. """ - - return self.proportion - - - def SetActive(self, b): - """ - Activates/deactivates the toolbar item. - - :param `b`: ``True`` to activate the item, ``False`` to deactivate it. - """ - - self.active = b - - - def IsActive(self): - """ Returns whether the toolbar item is active or not. """ - - return self.active - - - def SetHasDropDown(self, b): - """ - Sets whether the toolbar item has an associated dropdown menu. - - :param `b`: ``True`` to set a dropdown menu, ``False`` otherwise. - """ - - self.dropdown = b - - - def HasDropDown(self): - """ Returns whether the toolbar item has an associated dropdown menu or not. """ - - return self.dropdown - - - def SetSticky(self, b): - """ - Sets whether the toolbar item is sticky (permanent highlight after mouse enter) - or not. - - :param `b`: ``True`` to set the item as sticky, ``False`` otherwise. - """ - - self.sticky = b - - - def IsSticky(self): - """ Returns whether the toolbar item has a sticky behaviour or not. """ - - return self.sticky - - - def SetUserData(self, l): - """ - Associates some kind of user data to the toolbar item. - - :param `l`: a Python object. - - :note: The user data can be any Python object. - """ - - self.user_data = l - - - def GetUserData(self): - """ Returns the associated user data. """ - - return self.user_data - - - def SetAlignment(self, l): - """ - Sets the toolbar item alignment. - - :param `l`: the item alignment, which can be one of the available `wx.Sizer` - alignments. - """ - - self.alignment = l - - - def GetAlignment(self): - """ Returns the toolbar item alignment. """ - - return self.alignment - - -# ---------------------------------------------------------------------- - -class AuiDefaultToolBarArt(object): - """ - Toolbar art provider code - a tab provider provides all drawing functionality to - the L{AuiToolBar}. This allows the L{AuiToolBar} to have a plugable look-and-feel. - - By default, a L{AuiToolBar} uses an instance of this class called L{AuiDefaultToolBarArt} - which provides bitmap art and a colour scheme that is adapted to the major platforms' - look. You can either derive from that class to alter its behaviour or write a - completely new tab art class. Call L{AuiToolBar.SetArtProvider} to make use this - new tab art. - """ - - def __init__(self): - """ Default class constructor. """ - - self._base_colour = GetBaseColour() - - self._agwFlags = 0 - self._text_orientation = AUI_TBTOOL_TEXT_BOTTOM - self._highlight_colour = wx.SystemSettings.GetColour(wx.SYS_COLOUR_HIGHLIGHT) - - self._separator_size = 7 - self._orientation = AUI_TBTOOL_HORIZONTAL - self._gripper_size = 7 - self._overflow_size = 16 - - darker1_colour = StepColour(self._base_colour, 85) - darker2_colour = StepColour(self._base_colour, 75) - darker3_colour = StepColour(self._base_colour, 60) - darker4_colour = StepColour(self._base_colour, 50) - darker5_colour = StepColour(self._base_colour, 40) - - self._gripper_pen1 = wx.Pen(darker5_colour) - self._gripper_pen2 = wx.Pen(darker3_colour) - self._gripper_pen3 = wx.WHITE_PEN - - button_dropdown_bits = "\xe0\xf1\xfb" - overflow_bits = "\x80\xff\x80\xc1\xe3\xf7" - - self._button_dropdown_bmp = BitmapFromBits(button_dropdown_bits, 5, 3, wx.BLACK) - self._disabled_button_dropdown_bmp = BitmapFromBits(button_dropdown_bits, 5, 3, - wx.Colour(128, 128, 128)) - self._overflow_bmp = BitmapFromBits(overflow_bits, 7, 6, wx.BLACK) - self._disabled_overflow_bmp = BitmapFromBits(overflow_bits, 7, 6, wx.Colour(128, 128, 128)) - - self._font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT) - - - def Clone(self): - """ Clones the L{AuiToolBar} art. """ - - return AuiDefaultToolBarArt() - - - def SetAGWFlags(self, agwFlags): - """ - Sets the toolbar art flags. - - :param `agwFlags`: a combination of the following values: - - ==================================== ================================== - Flag name Description - ==================================== ================================== - ``AUI_TB_TEXT`` Shows the text in the toolbar buttons; by default only icons are shown - ``AUI_TB_NO_TOOLTIPS`` Don't show tooltips on `AuiToolBar` items - ``AUI_TB_NO_AUTORESIZE`` Do not auto-resize the `AuiToolBar` - ``AUI_TB_GRIPPER`` Shows a gripper on the `AuiToolBar` - ``AUI_TB_OVERFLOW`` The `AuiToolBar` can contain overflow items - ``AUI_TB_VERTICAL`` The `AuiToolBar` is vertical - ``AUI_TB_HORZ_LAYOUT`` Shows the text and the icons alongside, not vertically stacked. This style must be used with ``AUI_TB_TEXT`` - ``AUI_TB_PLAIN_BACKGROUND`` Don't draw a gradient background on the toolbar - ``AUI_TB_HORZ_TEXT`` Combination of ``AUI_TB_HORZ_LAYOUT`` and ``AUI_TB_TEXT`` - ==================================== ================================== - - """ - - self._agwFlags = agwFlags - - - def GetAGWFlags(self): - """ - Returns the L{AuiDefaultToolBarArt} flags. See L{SetAGWFlags} for more - details. - - :see: L{SetAGWFlags} - """ - - return self._agwFlags - - - def SetFont(self, font): - """ - Sets the L{AuiDefaultToolBarArt} font. - - :param `font`: a `wx.Font` object. - """ - - self._font = font - - - def SetTextOrientation(self, orientation): - """ - Sets the text orientation. - - :param `orientation`: can be one of the following constants: - - ==================================== ================================== - Orientation Switches Description - ==================================== ================================== - ``AUI_TBTOOL_TEXT_LEFT`` Text in `AuiToolBar` items is aligned left - ``AUI_TBTOOL_TEXT_RIGHT`` Text in `AuiToolBar` items is aligned right - ``AUI_TBTOOL_TEXT_TOP`` Text in `AuiToolBar` items is aligned top - ``AUI_TBTOOL_TEXT_BOTTOM`` Text in `AuiToolBar` items is aligned bottom - ==================================== ================================== - - """ - - self._text_orientation = orientation - - - def GetFont(self): - """ Returns the L{AuiDefaultToolBarArt} font. """ - - return self._font - - - def GetTextOrientation(self): - """ - Returns the L{AuiDefaultToolBarArt} text orientation. See - L{SetTextOrientation} for more details. - - :see: L{SetTextOrientation} - """ - - return self._text_orientation - - - def SetOrientation(self, orientation): - """ - Sets the toolbar tool orientation. - - :param `orientation`: one of ``AUI_TBTOOL_HORIZONTAL``, ``AUI_TBTOOL_VERT_CLOCKWISE`` or - ``AUI_TBTOOL_VERT_COUNTERCLOCKWISE``. - """ - - self._orientation = orientation - - - def GetOrientation(self): - """ Returns the toolbar orientation. """ - - return self._orientation - - - def DrawBackground(self, dc, wnd, _rect, horizontal=True): - """ - Draws a toolbar background with a gradient shading. - - :param `dc`: a `wx.DC` device context; - :param `wnd`: a `wx.Window` derived window; - :param `_rect`: the L{AuiToolBar} rectangle; - :param `horizontal`: ``True`` if the toolbar is horizontal, ``False`` if it is vertical. - """ - - rect = wx.Rect(*_rect) - - start_colour = StepColour(self._base_colour, 180) - end_colour = StepColour(self._base_colour, 85) - reflex_colour = StepColour(self._base_colour, 95) - - dc.GradientFillLinear(rect, start_colour, end_colour, - (horizontal and [wx.SOUTH] or [wx.EAST])[0]) - - left = rect.GetLeft() - right = rect.GetRight() - top = rect.GetTop() - bottom = rect.GetBottom() - - dc.SetPen(wx.Pen(reflex_colour)) - if horizontal: - dc.DrawLine(left, bottom, right+1, bottom) - else: - dc.DrawLine(right, top, right, bottom+1) - - - def DrawPlainBackground(self, dc, wnd, _rect): - """ - Draws a toolbar background with a plain colour. - - This method contrasts with the default behaviour of the L{AuiToolBar} that - draws a background gradient and this break the window design when putting - it within a control that has margin between the borders and the toolbar - (example: put L{AuiToolBar} within a `wx.StaticBoxSizer` that has a plain background). - - :param `dc`: a `wx.DC` device context; - :param `wnd`: a `wx.Window` derived window; - :param `_rect`: the L{AuiToolBar} rectangle. - """ - - rect = wx.Rect(*_rect) - rect.height += 1 - - dc.SetBrush(wx.Brush(wx.SystemSettings.GetColour(wx.SYS_COLOUR_3DFACE))) - dc.DrawRectangle(rect.x - 1, rect.y - 1, rect.width + 2, rect.height + 1) - - - def DrawLabel(self, dc, wnd, item, rect): - """ - Draws a toolbar item label. - - :param `dc`: a `wx.DC` device context; - :param `wnd`: a `wx.Window` derived window; - :param `item`: an instance of L{AuiToolBarItem}; - :param `rect`: the L{AuiToolBarItem} rectangle. - """ - - dc.SetFont(self._font) - dc.SetTextForeground(wx.BLACK) - orient = item.GetOrientation() - - horizontal = orient == AUI_TBTOOL_HORIZONTAL - # we only care about the text height here since the text - # will get cropped based on the width of the item - label_size = GetLabelSize(dc, item.GetLabel(), not horizontal) - text_width = label_size.GetWidth() - text_height = label_size.GetHeight() - - if orient == AUI_TBTOOL_HORIZONTAL: - text_x = rect.x - text_y = rect.y + (rect.height-text_height)/2 - dc.DrawText(item.GetLabel(), text_x, text_y) - - elif orient == AUI_TBTOOL_VERT_CLOCKWISE: - text_x = rect.x + (rect.width+text_width)/2 - text_y = rect.y - dc.DrawRotatedText(item.GetLabel(), text_x, text_y, 270) - - elif AUI_TBTOOL_VERT_COUNTERCLOCKWISE: - text_x = rect.x + (rect.width-text_width)/2 - text_y = rect.y + text_height - dc.DrawRotatedText(item.GetLabel(), text_x, text_y, 90) - - - def DrawButton(self, dc, wnd, item, rect): - """ - Draws a toolbar item button. - - :param `dc`: a `wx.DC` device context; - :param `wnd`: a `wx.Window` derived window; - :param `item`: an instance of L{AuiToolBarItem}; - :param `rect`: the L{AuiToolBarItem} rectangle. - """ - - bmp_rect, text_rect = self.GetToolsPosition(dc, item, rect) - - if not item.GetState() & AUI_BUTTON_STATE_DISABLED: - - if item.GetState() & AUI_BUTTON_STATE_PRESSED: - - dc.SetPen(wx.Pen(self._highlight_colour)) - dc.SetBrush(wx.Brush(StepColour(self._highlight_colour, 150))) - dc.DrawRectangleRect(rect) - - elif item.GetState() & AUI_BUTTON_STATE_HOVER or item.IsSticky(): - - dc.SetPen(wx.Pen(self._highlight_colour)) - dc.SetBrush(wx.Brush(StepColour(self._highlight_colour, 170))) - - # draw an even lighter background for checked item hovers (since - # the hover background is the same colour as the check background) - if item.GetState() & AUI_BUTTON_STATE_CHECKED: - dc.SetBrush(wx.Brush(StepColour(self._highlight_colour, 180))) - - dc.DrawRectangleRect(rect) - - elif item.GetState() & AUI_BUTTON_STATE_CHECKED: - - # it's important to put this code in an else statment after the - # hover, otherwise hovers won't draw properly for checked items - dc.SetPen(wx.Pen(self._highlight_colour)) - dc.SetBrush(wx.Brush(StepColour(self._highlight_colour, 170))) - dc.DrawRectangleRect(rect) - - if item.GetState() & AUI_BUTTON_STATE_DISABLED: - bmp = item.GetDisabledBitmap() - else: - bmp = item.GetBitmap() - - if bmp.IsOk(): - dc.DrawBitmap(bmp, bmp_rect.x, bmp_rect.y, True) - - # set the item's text colour based on if it is disabled - dc.SetTextForeground(wx.BLACK) - if item.GetState() & AUI_BUTTON_STATE_DISABLED: - dc.SetTextForeground(DISABLED_TEXT_COLOUR) - - if self._agwFlags & AUI_TB_TEXT and item.GetLabel() != "": - self.DrawLabel(dc, wnd, item, text_rect) - - - def DrawDropDownButton(self, dc, wnd, item, rect): - """ - Draws a toolbar dropdown button. - - :param `dc`: a `wx.DC` device context; - :param `wnd`: a `wx.Window` derived window; - :param `item`: an instance of L{AuiToolBarItem}; - :param `rect`: the L{AuiToolBarItem} rectangle. - """ - - dropbmp_x = dropbmp_y = 0 - - button_rect = wx.Rect(rect.x, rect.y, rect.width-BUTTON_DROPDOWN_WIDTH, rect.height) - dropdown_rect = wx.Rect(rect.x+rect.width-BUTTON_DROPDOWN_WIDTH-1, rect.y, BUTTON_DROPDOWN_WIDTH+1, rect.height) - - horizontal = item.GetOrientation() == AUI_TBTOOL_HORIZONTAL - - if horizontal: - button_rect = wx.Rect(rect.x, rect.y, rect.width-BUTTON_DROPDOWN_WIDTH, rect.height) - dropdown_rect = wx.Rect(rect.x+rect.width-BUTTON_DROPDOWN_WIDTH-1, rect.y, BUTTON_DROPDOWN_WIDTH+1, rect.height) - else: - button_rect = wx.Rect(rect.x, rect.y, rect.width, rect.height-BUTTON_DROPDOWN_WIDTH) - dropdown_rect = wx.Rect(rect.x, rect.y+rect.height-BUTTON_DROPDOWN_WIDTH-1, rect.width, BUTTON_DROPDOWN_WIDTH+1) - - dropbmp_width = self._button_dropdown_bmp.GetWidth() - dropbmp_height = self._button_dropdown_bmp.GetHeight() - if not horizontal: - tmp = dropbmp_width - dropbmp_width = dropbmp_height - dropbmp_height = tmp - - dropbmp_x = dropdown_rect.x + (dropdown_rect.width/2) - dropbmp_width/2 - dropbmp_y = dropdown_rect.y + (dropdown_rect.height/2) - dropbmp_height/2 - - bmp_rect, text_rect = self.GetToolsPosition(dc, item, button_rect) - - if item.GetState() & AUI_BUTTON_STATE_PRESSED: - - dc.SetPen(wx.Pen(self._highlight_colour)) - dc.SetBrush(wx.Brush(StepColour(self._highlight_colour, 140))) - dc.DrawRectangleRect(button_rect) - dc.DrawRectangleRect(dropdown_rect) - - elif item.GetState() & AUI_BUTTON_STATE_HOVER or item.IsSticky(): - - dc.SetPen(wx.Pen(self._highlight_colour)) - dc.SetBrush(wx.Brush(StepColour(self._highlight_colour, 170))) - dc.DrawRectangleRect(button_rect) - dc.DrawRectangleRect(dropdown_rect) - - elif item.GetState() & AUI_BUTTON_STATE_CHECKED: - # it's important to put this code in an else statment after the - # hover, otherwise hovers won't draw properly for checked items - dc.SetPen(wx.Pen(self._highlight_colour)) - dc.SetBrush(wx.Brush(StepColour(self._highlight_colour, 170))) - dc.DrawRectangle(button_rect) - dc.DrawRectangle(dropdown_rect) - - if item.GetState() & AUI_BUTTON_STATE_DISABLED: - - bmp = item.GetDisabledBitmap() - dropbmp = self._disabled_button_dropdown_bmp - - else: - - bmp = item.GetBitmap() - dropbmp = self._button_dropdown_bmp - - if not bmp.IsOk(): - return - - dc.DrawBitmap(bmp, bmp_rect.x, bmp_rect.y, True) - if horizontal: - dc.DrawBitmap(dropbmp, dropbmp_x, dropbmp_y, True) - else: - dc.DrawBitmap(wx.BitmapFromImage(dropbmp.ConvertToImage().Rotate90(item.GetOrientation() == AUI_TBTOOL_VERT_CLOCKWISE)), - dropbmp_x, dropbmp_y, True) - - # set the item's text colour based on if it is disabled - dc.SetTextForeground(wx.BLACK) - if item.GetState() & AUI_BUTTON_STATE_DISABLED: - dc.SetTextForeground(DISABLED_TEXT_COLOUR) - - if self._agwFlags & AUI_TB_TEXT and item.GetLabel() != "": - self.DrawLabel(dc, wnd, item, text_rect) - - - def DrawControlLabel(self, dc, wnd, item, rect): - """ - Draws a label for a toolbar control. - - :param `dc`: a `wx.DC` device context; - :param `wnd`: a `wx.Window` derived window; - :param `item`: an instance of L{AuiToolBarItem}; - :param `rect`: the L{AuiToolBarItem} rectangle. - """ - - label_size = GetLabelSize(dc, item.GetLabel(), item.GetOrientation() != AUI_TBTOOL_HORIZONTAL) - text_height = label_size.GetHeight() - text_width = label_size.GetWidth() - - dc.SetFont(self._font) - - if self._agwFlags & AUI_TB_TEXT: - - tx, text_height = dc.GetTextExtent("ABCDHgj") - - text_width, ty = dc.GetTextExtent(item.GetLabel()) - - # don't draw the label if it is wider than the item width - if text_width > rect.width: - return - - # set the label's text colour - dc.SetTextForeground(wx.BLACK) - - text_x = rect.x + (rect.width/2) - (text_width/2) + 1 - text_y = rect.y + rect.height - text_height - 1 - - if self._agwFlags & AUI_TB_TEXT and item.GetLabel() != "": - dc.DrawText(item.GetLabel(), text_x, text_y) - - - def GetLabelSize(self, dc, wnd, item): - """ - Returns the label size for a toolbar item. - - :param `dc`: a `wx.DC` device context; - :param `wnd`: a `wx.Window` derived window; - :param `item`: an instance of L{AuiToolBarItem}. - """ - - dc.SetFont(self._font) - label_size = GetLabelSize(dc, item.GetLabel(), self._orientation != AUI_TBTOOL_HORIZONTAL) - - return wx.Size(item.GetMinSize().GetWidth(), label_size.GetHeight()) - - - def GetToolSize(self, dc, wnd, item): - """ - Returns the toolbar item size. - - :param `dc`: a `wx.DC` device context; - :param `wnd`: a `wx.Window` derived window; - :param `item`: an instance of L{AuiToolBarItem}. - """ - - if not item.GetBitmap().IsOk() and not self._agwFlags & AUI_TB_TEXT: - return wx.Size(16, 16) - - width = item.GetBitmap().GetWidth() - height = item.GetBitmap().GetHeight() - - if self._agwFlags & AUI_TB_TEXT: - - dc.SetFont(self._font) - label_size = GetLabelSize(dc, item.GetLabel(), self.GetOrientation() != AUI_TBTOOL_HORIZONTAL) - padding = 6 - - if self._text_orientation == AUI_TBTOOL_TEXT_BOTTOM: - - if self.GetOrientation() != AUI_TBTOOL_HORIZONTAL: - height += 3 # space between top border and bitmap - height += 3 # space between bitmap and text - padding = 0 - - height += label_size.GetHeight() - - if item.GetLabel() != "": - width = max(width, label_size.GetWidth()+padding) - - elif self._text_orientation == AUI_TBTOOL_TEXT_RIGHT and item.GetLabel() != "": - - if self.GetOrientation() == AUI_TBTOOL_HORIZONTAL: - - width += 3 # space between left border and bitmap - width += 3 # space between bitmap and text - padding = 0 - - width += label_size.GetWidth() - height = max(height, label_size.GetHeight()+padding) - - # if the tool has a dropdown button, add it to the width - if item.HasDropDown(): - if item.GetOrientation() == AUI_TBTOOL_HORIZONTAL: - width += BUTTON_DROPDOWN_WIDTH+4 - else: - height += BUTTON_DROPDOWN_WIDTH+4 - - return wx.Size(width, height) - - - def DrawSeparator(self, dc, wnd, _rect): - """ - Draws a toolbar separator. - - :param `dc`: a `wx.DC` device context; - :param `wnd`: a `wx.Window` derived window; - :param `_rect`: the L{AuiToolBarItem} rectangle. - """ - - horizontal = True - if self._agwFlags & AUI_TB_VERTICAL: - horizontal = False - - rect = wx.Rect(*_rect) - - if horizontal: - - rect.x += (rect.width/2) - rect.width = 1 - new_height = (rect.height*3)/4 - rect.y += (rect.height/2) - (new_height/2) - rect.height = new_height - - else: - - rect.y += (rect.height/2) - rect.height = 1 - new_width = (rect.width*3)/4 - rect.x += (rect.width/2) - (new_width/2) - rect.width = new_width - - start_colour = StepColour(self._base_colour, 80) - end_colour = StepColour(self._base_colour, 80) - dc.GradientFillLinear(rect, start_colour, end_colour, (horizontal and [wx.SOUTH] or [wx.EAST])[0]) - - - def DrawGripper(self, dc, wnd, rect): - """ - Draws the toolbar gripper. - - :param `dc`: a `wx.DC` device context; - :param `wnd`: a `wx.Window` derived window; - :param `rect`: the L{AuiToolBar} rectangle. - """ - - i = 0 - while 1: - - if self._agwFlags & AUI_TB_VERTICAL: - - x = rect.x + (i*4) + 4 - y = rect.y + 3 - if x > rect.GetWidth() - 4: - break - - else: - - x = rect.x + 3 - y = rect.y + (i*4) + 4 - if y > rect.GetHeight() - 4: - break - - dc.SetPen(self._gripper_pen1) - dc.DrawPoint(x, y) - dc.SetPen(self._gripper_pen2) - dc.DrawPoint(x, y+1) - dc.DrawPoint(x+1, y) - dc.SetPen(self._gripper_pen3) - dc.DrawPoint(x+2, y+1) - dc.DrawPoint(x+2, y+2) - dc.DrawPoint(x+1, y+2) - - i += 1 - - - def DrawOverflowButton(self, dc, wnd, rect, state): - """ - Draws the overflow button for the L{AuiToolBar}. - - :param `dc`: a `wx.DC` device context; - :param `wnd`: a `wx.Window` derived window; - :param `rect`: the L{AuiToolBar} rectangle; - :param `state`: the overflow button state. - """ - - if state & AUI_BUTTON_STATE_HOVER or state & AUI_BUTTON_STATE_PRESSED: - - cli_rect = wnd.GetClientRect() - light_gray_bg = StepColour(self._highlight_colour, 170) - - if self._agwFlags & AUI_TB_VERTICAL: - - dc.SetPen(wx.Pen(self._highlight_colour)) - dc.DrawLine(rect.x, rect.y, rect.x+rect.width, rect.y) - dc.SetPen(wx.Pen(light_gray_bg)) - dc.SetBrush(wx.Brush(light_gray_bg)) - dc.DrawRectangle(rect.x, rect.y+1, rect.width, rect.height) - - else: - - dc.SetPen(wx.Pen(self._highlight_colour)) - dc.DrawLine(rect.x, rect.y, rect.x, rect.y+rect.height) - dc.SetPen(wx.Pen(light_gray_bg)) - dc.SetBrush(wx.Brush(light_gray_bg)) - dc.DrawRectangle(rect.x+1, rect.y, rect.width, rect.height) - - x = rect.x + 1 + (rect.width-self._overflow_bmp.GetWidth())/2 - y = rect.y + 1 + (rect.height-self._overflow_bmp.GetHeight())/2 - dc.DrawBitmap(self._overflow_bmp, x, y, True) - - - def GetElementSize(self, element_id): - """ - Returns the size of a UI element in the L{AuiToolBar}. - - :param `element_id`: can be one of the following: - - ==================================== ================================== - Element Identifier Description - ==================================== ================================== - ``AUI_TBART_SEPARATOR_SIZE`` Separator size in `AuiToolBar` - ``AUI_TBART_GRIPPER_SIZE`` Gripper size in `AuiToolBar` - ``AUI_TBART_OVERFLOW_SIZE`` Overflow button size in `AuiToolBar` - ==================================== ================================== - """ - - if element_id == AUI_TBART_SEPARATOR_SIZE: - return self._separator_size - elif element_id == AUI_TBART_GRIPPER_SIZE: - return self._gripper_size - elif element_id == AUI_TBART_OVERFLOW_SIZE: - return self._overflow_size - - return 0 - - - def SetElementSize(self, element_id, size): - """ - Sets the size of a UI element in the L{AuiToolBar}. - - :param `element_id`: can be one of the following: - - ==================================== ================================== - Element Identifier Description - ==================================== ================================== - ``AUI_TBART_SEPARATOR_SIZE`` Separator size in `AuiToolBar` - ``AUI_TBART_GRIPPER_SIZE`` Gripper size in `AuiToolBar` - ``AUI_TBART_OVERFLOW_SIZE`` Overflow button size in `AuiToolBar` - ==================================== ================================== - - :param `size`: the new size of the UI element. - """ - - if element_id == AUI_TBART_SEPARATOR_SIZE: - self._separator_size = size - elif element_id == AUI_TBART_GRIPPER_SIZE: - self._gripper_size = size - elif element_id == AUI_TBART_OVERFLOW_SIZE: - self._overflow_size = size - - - def ShowDropDown(self, wnd, items): - """ - Shows the drop down window menu for overflow items. - - :param `wnd`: an instance of `wx.Window`; - :param `items`: the overflow toolbar items (a Python list). - """ - - menuPopup = wx.Menu() - items_added = 0 - - for item in items: - - if item.GetKind() not in [ITEM_SEPARATOR, ITEM_SPACER, ITEM_CONTROL]: - - text = item.GetShortHelp() - if text == "": - text = item.GetLabel() - if text == "": - text = " " - - kind = item.GetKind() - m = wx.MenuItem(menuPopup, item.GetId(), text, item.GetShortHelp(), kind) - orientation = item.GetOrientation() - item.SetOrientation(AUI_TBTOOL_HORIZONTAL) - - if kind not in [ITEM_CHECK, ITEM_RADIO]: - m.SetBitmap(item.GetBitmap()) - - item.SetOrientation(orientation) - - menuPopup.AppendItem(m) - if kind in [ITEM_CHECK, ITEM_RADIO]: - state = (item.state & AUI_BUTTON_STATE_CHECKED and [True] or [False])[0] - m.Check(state) - - items_added += 1 - - else: - - if items_added > 0 and item.GetKind() == ITEM_SEPARATOR: - menuPopup.AppendSeparator() - - # find out where to put the popup menu of window items - pt = wx.GetMousePosition() - pt = wnd.ScreenToClient(pt) - - # find out the screen coordinate at the bottom of the tab ctrl - cli_rect = wnd.GetClientRect() - pt.y = cli_rect.y + cli_rect.height - - cc = ToolbarCommandCapture() - wnd.PushEventHandler(cc) - - # Adjustments to get slightly better menu placement - if wx.Platform == "__WXMAC__": - pt.y += 5 - pt.x -= 5 - - wnd.PopupMenu(menuPopup, pt) - command = cc.GetCommandId() - wnd.PopEventHandler(True) - - return command - - - def GetToolsPosition(self, dc, item, rect): - """ - Returns the bitmap and text rectangles for a toolbar item. - - :param `dc`: a `wx.DC` device context; - :param `item`: an instance of L{AuiToolBarItem}; - :param `rect`: the tool rect. - """ - - text_width = text_height = 0 - horizontal = self._orientation == AUI_TBTOOL_HORIZONTAL - text_bottom = self._text_orientation == AUI_TBTOOL_TEXT_BOTTOM - text_right = self._text_orientation == AUI_TBTOOL_TEXT_RIGHT - bmp_width = item.GetBitmap().GetWidth() - bmp_height = item.GetBitmap().GetHeight() - - if self._agwFlags & AUI_TB_TEXT: - dc.SetFont(self._font) - label_size = GetLabelSize(dc, item.GetLabel(), not horizontal) - text_height = label_size.GetHeight() - text_width = label_size.GetWidth() - - bmp_x = bmp_y = text_x = text_y = 0 - - if horizontal and text_bottom: - bmp_x = rect.x + (rect.width/2) - (bmp_width/2) - bmp_y = rect.y + 3 - text_x = rect.x + (rect.width/2) - (text_width/2) - text_y = rect.y + ((bmp_y - rect.y) * 2) + bmp_height - - elif horizontal and text_right: - bmp_x = rect.x + 3 - bmp_y = rect.y + (rect.height/2) - (bmp_height / 2) - text_x = rect.x + ((bmp_x - rect.x) * 2) + bmp_width - text_y = rect.y + (rect.height/2) - (text_height/2) - - elif not horizontal and text_bottom: - bmp_x = rect.x + (rect.width / 2) - (bmp_width / 2) - bmp_y = rect.y + 3 - text_x = rect.x + (rect.width / 2) - (text_width / 2) - text_y = rect.y + ((bmp_y - rect.y) * 2) + bmp_height - - bmp_rect = wx.Rect(bmp_x, bmp_y, bmp_width, bmp_height) - text_rect = wx.Rect(text_x, text_y, text_width, text_height) - - return bmp_rect, text_rect - - -class AuiToolBar(wx.PyControl): - """ - AuiToolBar is a completely owner-drawn toolbar perfectly integrated with the - AUI layout system. This allows drag and drop of toolbars, docking/floating - behaviour and the possibility to define "overflow" items in the toolbar itself. - - The default theme that is used is L{AuiDefaultToolBarArt}, which provides a modern, - glossy look and feel. The theme can be changed by calling L{AuiToolBar.SetArtProvider}. - """ - - def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition, - size=wx.DefaultSize, style=0, agwStyle=AUI_TB_DEFAULT_STYLE): - """ - Default class constructor. - - :param `parent`: the L{AuiToolBar} parent; - :param `id`: an identifier for the control: a value of -1 is taken to mean a default; - :param `pos`: the control position. A value of (-1, -1) indicates a default position, - chosen by either the windowing system or wxPython, depending on platform; - :param `size`: the control size. A value of (-1, -1) indicates a default size, - chosen by either the windowing system or wxPython, depending on platform; - :param `style`: the control window style; - :param `agwStyle`: the AGW-specific window style. This can be a combination of the - following bits: - - ==================================== ================================== - Flag name Description - ==================================== ================================== - ``AUI_TB_TEXT`` Shows the text in the toolbar buttons; by default only icons are shown - ``AUI_TB_NO_TOOLTIPS`` Don't show tooltips on `AuiToolBar` items - ``AUI_TB_NO_AUTORESIZE`` Do not auto-resize the `AuiToolBar` - ``AUI_TB_GRIPPER`` Shows a gripper on the `AuiToolBar` - ``AUI_TB_OVERFLOW`` The `AuiToolBar` can contain overflow items - ``AUI_TB_VERTICAL`` The `AuiToolBar` is vertical - ``AUI_TB_HORZ_LAYOUT`` Shows the text and the icons alongside, not vertically stacked. This style must be used with ``AUI_TB_TEXT`` - ``AUI_TB_PLAIN_BACKGROUND`` Don't draw a gradient background on the toolbar - ``AUI_TB_HORZ_TEXT`` Combination of ``AUI_TB_HORZ_LAYOUT`` and ``AUI_TB_TEXT`` - ==================================== ================================== - - The default value for `agwStyle` is: ``AUI_TB_DEFAULT_STYLE`` = 0 - - """ - - wx.PyControl.__init__(self, parent, id, pos, size, style|wx.BORDER_NONE) - - self._sizer = wx.BoxSizer(wx.HORIZONTAL) - self.SetSizer(self._sizer) - self._button_width = -1 - self._button_height = -1 - self._sizer_element_count = 0 - self._action_pos = wx.Point(-1, -1) - self._action_item = None - self._tip_item = None - self._art = AuiDefaultToolBarArt() - self._tool_packing = 2 - self._tool_border_padding = 3 - self._tool_text_orientation = AUI_TBTOOL_TEXT_BOTTOM - self._tool_orientation = AUI_TBTOOL_HORIZONTAL - self._tool_alignment = wx.EXPAND - self._gripper_sizer_item = None - self._overflow_sizer_item = None - self._dragging = False - - self._agwStyle = self._originalStyle = agwStyle - - self._gripper_visible = (self._agwStyle & AUI_TB_GRIPPER and [True] or [False])[0] - self._overflow_visible = (self._agwStyle & AUI_TB_OVERFLOW and [True] or [False])[0] - self._overflow_state = 0 - self._custom_overflow_prepend = [] - self._custom_overflow_append = [] - - self._items = [] - - self.SetMargins(5, 5, 2, 2) - self.SetFont(wx.NORMAL_FONT) - self._art.SetAGWFlags(self._agwStyle) - self.SetExtraStyle(wx.WS_EX_PROCESS_IDLE) - - if agwStyle & AUI_TB_HORZ_LAYOUT: - self.SetToolTextOrientation(AUI_TBTOOL_TEXT_RIGHT) - elif agwStyle & AUI_TB_VERTICAL: - if agwStyle & AUI_TB_CLOCKWISE: - self.SetToolOrientation(AUI_TBTOOL_VERT_CLOCKWISE) - elif agwStyle & AUI_TB_COUNTERCLOCKWISE: - self.SetToolOrientation(AUI_TBTOOL_VERT_COUNTERCLOCKWISE) - - self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM) - - self.Bind(wx.EVT_SIZE, self.OnSize) - self.Bind(wx.EVT_IDLE, self.OnIdle) - self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground) - self.Bind(wx.EVT_PAINT, self.OnPaint) - self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown) - self.Bind(wx.EVT_LEFT_DCLICK, self.OnLeftDown) - self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp) - self.Bind(wx.EVT_RIGHT_DOWN, self.OnRightDown) - self.Bind(wx.EVT_RIGHT_DCLICK, self.OnRightDown) - self.Bind(wx.EVT_RIGHT_UP, self.OnRightUp) - self.Bind(wx.EVT_MIDDLE_DOWN, self.OnMiddleDown) - self.Bind(wx.EVT_MIDDLE_DCLICK, self.OnMiddleDown) - self.Bind(wx.EVT_MIDDLE_UP, self.OnMiddleUp) - self.Bind(wx.EVT_MOTION, self.OnMotion) - self.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeaveWindow) - self.Bind(wx.EVT_SET_CURSOR, self.OnSetCursor) - - - def SetWindowStyleFlag(self, style): - """ - Sets the style of the window. - - :param `style`: the new window style. - - :note: Please note that some styles cannot be changed after the window - creation and that `Refresh` might need to be be called after changing the - others for the change to take place immediately. - - :note: Overridden from `wx.PyControl`. - """ - - wx.PyControl.SetWindowStyleFlag(self, style|wx.BORDER_NONE) - - - def SetAGWWindowStyleFlag(self, agwStyle): - """ - Sets the AGW-specific style of the window. - - :param `agwStyle`: the new window style. This can be a combination of the - following bits: - - ==================================== ================================== - Flag name Description - ==================================== ================================== - ``AUI_TB_TEXT`` Shows the text in the toolbar buttons; by default only icons are shown - ``AUI_TB_NO_TOOLTIPS`` Don't show tooltips on `AuiToolBar` items - ``AUI_TB_NO_AUTORESIZE`` Do not auto-resize the `AuiToolBar` - ``AUI_TB_GRIPPER`` Shows a gripper on the `AuiToolBar` - ``AUI_TB_OVERFLOW`` The `AuiToolBar` can contain overflow items - ``AUI_TB_VERTICAL`` The `AuiToolBar` is vertical - ``AUI_TB_HORZ_LAYOUT`` Shows the text and the icons alongside, not vertically stacked. This style must be used with ``AUI_TB_TEXT`` - ``AUI_TB_PLAIN_BACKGROUND`` Don't draw a gradient background on the toolbar - ``AUI_TB_HORZ_TEXT`` Combination of ``AUI_TB_HORZ_LAYOUT`` and ``AUI_TB_TEXT`` - ==================================== ================================== - - :note: Please note that some styles cannot be changed after the window - creation and that `Refresh` might need to be be called after changing the - others for the change to take place immediately. - """ - - self._agwStyle = self._originalStyle = agwStyle - - if self._art: - self._art.SetAGWFlags(self._agwStyle) - - if agwStyle & AUI_TB_GRIPPER: - self._gripper_visible = True - else: - self._gripper_visible = False - - if agwStyle & AUI_TB_OVERFLOW: - self._overflow_visible = True - else: - self._overflow_visible = False - - if agwStyle & AUI_TB_HORZ_LAYOUT: - self.SetToolTextOrientation(AUI_TBTOOL_TEXT_RIGHT) - else: - self.SetToolTextOrientation(AUI_TBTOOL_TEXT_BOTTOM) - - if agwStyle & AUI_TB_VERTICAL: - if agwStyle & AUI_TB_CLOCKWISE: - self.SetToolOrientation(AUI_TBTOOL_VERT_CLOCKWISE) - elif agwStyle & AUI_TB_COUNTERCLOCKWISE: - self.SetToolOrientation(AUI_TBTOOL_VERT_COUNTERCLOCKWISE) - - - def GetAGWWindowStyleFlag(self): - """ - Returns the AGW-specific window style flag. - - :see: L{SetAGWWindowStyleFlag} for an explanation of various AGW-specific style. - """ - - return self._agwStyle - - - def SetArtProvider(self, art): - """ - Instructs L{AuiToolBar} to use art provider specified by parameter `art` - for all drawing calls. This allows plugable look-and-feel features. - - :param `art`: an art provider. - - :note: The previous art provider object, if any, will be deleted by L{AuiToolBar}. - """ - - del self._art - self._art = art - - if self._art: - self._art.SetAGWFlags(self._agwStyle) - self._art.SetTextOrientation(self._tool_text_orientation) - self._art.SetOrientation(self._tool_orientation) - - - def GetArtProvider(self): - """ Returns the current art provider being used. """ - - return self._art - - - def AddSimpleTool(self, tool_id, label, bitmap, short_help_string="", kind=ITEM_NORMAL): - """ - Adds a tool to the toolbar. This is the simplest method you can use to - ass an item to the L{AuiToolBar}. - - :param `tool_id`: an integer by which the tool may be identified in subsequent operations; - :param `label`: the toolbar tool label; - :param `bitmap`: the primary tool bitmap; - :param `short_help_string`: this string is used for the tools tooltip; - :param `kind`: the item kind. Can be one of the following: - - ======================== ============================= - Item Kind Description - ======================== ============================= - ``ITEM_CONTROL`` The item in the `AuiToolBar` is a control - ``ITEM_LABEL`` The item in the `AuiToolBar` is a text label - ``ITEM_SPACER`` The item in the `AuiToolBar` is a spacer - ``ITEM_SEPARATOR`` The item in the `AuiToolBar` is a separator - ``ITEM_CHECK`` The item in the `AuiToolBar` is a toolbar check item - ``ITEM_NORMAL`` The item in the `AuiToolBar` is a standard toolbar item - ``ITEM_RADIO`` The item in the `AuiToolBar` is a toolbar radio item - ======================== ============================= - """ - - return self.AddTool(tool_id, label, bitmap, wx.NullBitmap, kind, short_help_string, "", None) - - - def AddToggleTool(self, tool_id, bitmap, disabled_bitmap, toggle=False, client_data=None, short_help_string="", long_help_string=""): - """ - Adds a toggle tool to the toolbar. - - :param `tool_id`: an integer by which the tool may be identified in subsequent operations; - :param `bitmap`: the primary tool bitmap; - :param `disabled_bitmap`: the bitmap to use when the tool is disabled. If it is equal to - `wx.NullBitmap`, the disabled bitmap is automatically generated by greing the normal one; - :param `client_data`: whatever Python object to associate with the toolbar item; - :param `short_help_string`: this string is used for the tools tooltip; - :param `long_help_string`: this string is shown in the statusbar (if any) of the parent - frame when the mouse pointer is inside the tool. - """ - - kind = (toggle and [ITEM_CHECK] or [ITEM_NORMAL])[0] - return self.AddTool(tool_id, "", bitmap, disabled_bitmap, kind, short_help_string, long_help_string, client_data) - - - def AddTool(self, tool_id, label, bitmap, disabled_bitmap, kind, short_help_string, long_help_string, client_data): - """ - Adds a tool to the toolbar. This is the full feature version of L{AddTool}. - - :param `tool_id`: an integer by which the tool may be identified in subsequent operations; - :param `label`: the toolbar tool label; - :param `bitmap`: the primary tool bitmap; - :param `disabled_bitmap`: the bitmap to use when the tool is disabled. If it is equal to - `wx.NullBitmap`, the disabled bitmap is automatically generated by greing the normal one; - :param `kind`: the item kind. Can be one of the following: - - ======================== ============================= - Item Kind Description - ======================== ============================= - ``ITEM_CONTROL`` The item in the `AuiToolBar` is a control - ``ITEM_LABEL`` The item in the `AuiToolBar` is a text label - ``ITEM_SPACER`` The item in the `AuiToolBar` is a spacer - ``ITEM_SEPARATOR`` The item in the `AuiToolBar` is a separator - ``ITEM_CHECK`` The item in the `AuiToolBar` is a toolbar check item - ``ITEM_NORMAL`` The item in the `AuiToolBar` is a standard toolbar item - ``ITEM_RADIO`` The item in the `AuiToolBar` is a toolbar radio item - ======================== ============================= - - :param `short_help_string`: this string is used for the tools tooltip; - :param `long_help_string`: this string is shown in the statusbar (if any) of the parent - frame when the mouse pointer is inside the tool. - :param `client_data`: whatever Python object to associate with the toolbar item. - """ - - item = AuiToolBarItem() - item.window = None - item.label = label - item.bitmap = bitmap - item.disabled_bitmap = disabled_bitmap - item.short_help = short_help_string - item.long_help = long_help_string - item.active = True - item.dropdown = False - item.spacer_pixels = 0 - - if tool_id == wx.ID_ANY: - tool_id = wx.NewId() - - item.id = tool_id - item.state = 0 - item.proportion = 0 - item.kind = kind - item.sizer_item = None - item.min_size = wx.Size(-1, -1) - item.user_data = 0 - item.sticky = False - item.orientation = self._tool_orientation - - if not item.disabled_bitmap.IsOk(): - # no disabled bitmap specified, we need to make one - if item.bitmap.IsOk(): - item.disabled_bitmap = MakeDisabledBitmap(item.bitmap) - - self._items.append(item) - return self._items[-1] - - - def AddCheckTool(self, tool_id, label, bitmap, disabled_bitmap, short_help_string="", long_help_string="", client_data=None): - """ - Adds a new check (or toggle) tool to the L{AuiToolBar}. - - :see: L{AddTool}. - """ - - return self.AddTool(tool_id, label, bitmap, disabled_bitmap, ITEM_CHECK, short_help_string, long_help_string, client_data) - - - def AddRadioTool(self, tool_id, label, bitmap, disabled_bitmap, short_help_string="", long_help_string="", client_data=None): - """ - Adds a new radio tool to the toolbar. - - Consecutive radio tools form a radio group such that exactly one button - in the group is pressed at any moment, in other words whenever a button - in the group is pressed the previously pressed button is automatically - released. You should avoid having the radio groups of only one element - as it would be impossible for the user to use such button. - - :note: By default, the first button in the radio group is initially pressed, - the others are not. - - :see: L{AddTool}. - """ - - return self.AddTool(tool_id, label, bitmap, disabled_bitmap, ITEM_RADIO, short_help_string, long_help_string, client_data) - - - def AddControl(self, control, label=""): - """ - Adds any control to the toolbar, typically e.g. a combobox. - - :param `control`: the control to be added; - :param `label`: the label which appears if the control goes into the - overflow items in the toolbar. - """ - - item = AuiToolBarItem() - item.window = control - item.label = label - item.bitmap = wx.NullBitmap - item.disabled_bitmap = wx.NullBitmap - item.active = True - item.dropdown = False - item.spacer_pixels = 0 - item.id = control.GetId() - item.state = 0 - item.proportion = 0 - item.kind = ITEM_CONTROL - item.sizer_item = None - item.min_size = control.GetEffectiveMinSize() - item.user_data = 0 - item.sticky = False - item.orientation = self._tool_orientation - - self._items.append(item) - return self._items[-1] - - - def AddLabel(self, tool_id, label="", width=0): - """ - Adds a label tool to the L{AuiToolBar}. - - :param `tool_id`: an integer by which the tool may be identified in subsequent operations; - :param `label`: the toolbar tool label; - :param `width`: the tool width. - """ - - min_size = wx.Size(-1, -1) - - if width != -1: - min_size.x = width - - item = AuiToolBarItem() - item.window = None - item.label = label - item.bitmap = wx.NullBitmap - item.disabled_bitmap = wx.NullBitmap - item.active = True - item.dropdown = False - item.spacer_pixels = 0 - - if tool_id == wx.ID_ANY: - tool_id = wx.NewId() - - item.id = tool_id - item.state = 0 - item.proportion = 0 - item.kind = ITEM_LABEL - item.sizer_item = None - item.min_size = min_size - item.user_data = 0 - item.sticky = False - item.orientation = self._tool_orientation - - self._items.append(item) - return self._items[-1] - - - def AddSeparator(self): - """ Adds a separator for spacing groups of tools. """ - - item = AuiToolBarItem() - item.window = None - item.label = "" - item.bitmap = wx.NullBitmap - item.disabled_bitmap = wx.NullBitmap - item.active = True - item.dropdown = False - item.id = -1 - item.state = 0 - item.proportion = 0 - item.kind = ITEM_SEPARATOR - item.sizer_item = None - item.min_size = wx.Size(-1, -1) - item.user_data = 0 - item.sticky = False - item.orientation = self._tool_orientation - - self._items.append(item) - return self._items[-1] - - - def AddSpacer(self, pixels): - """ - Adds a spacer for spacing groups of tools. - - :param `pixels`: the width of the spacer. - """ - - item = AuiToolBarItem() - item.window = None - item.label = "" - item.bitmap = wx.NullBitmap - item.disabled_bitmap = wx.NullBitmap - item.active = True - item.dropdown = False - item.spacer_pixels = pixels - item.id = -1 - item.state = 0 - item.proportion = 0 - item.kind = ITEM_SPACER - item.sizer_item = None - item.min_size = wx.Size(-1, -1) - item.user_data = 0 - item.sticky = False - item.orientation = self._tool_orientation - - self._items.append(item) - return self._items[-1] - - - def AddStretchSpacer(self, proportion=1): - """ - Adds a stretchable spacer for spacing groups of tools. - - :param `proportion`: the stretchable spacer proportion. - """ - - item = AuiToolBarItem() - item.window = None - item.label = "" - item.bitmap = wx.NullBitmap - item.disabled_bitmap = wx.NullBitmap - item.active = True - item.dropdown = False - item.spacer_pixels = 0 - item.id = -1 - item.state = 0 - item.proportion = proportion - item.kind = ITEM_SPACER - item.sizer_item = None - item.min_size = wx.Size(-1, -1) - item.user_data = 0 - item.sticky = False - item.orientation = self._tool_orientation - - self._items.append(item) - return self._items[-1] - - - def Clear(self): - """ Deletes all the tools in the L{AuiToolBar}. """ - - self._items = [] - self._sizer_element_count = 0 - - - def ClearTools(self): - """ Deletes all the tools in the L{AuiToolBar}. """ - - self.Clear() - - - def DeleteTool(self, tool_id): - """ - Removes the specified tool from the toolbar and deletes it. - - :param `tool_id`: the L{AuiToolBarItem} identifier. - - :returns: ``True`` if the tool was deleted, ``False`` otherwise. - - :note: Note that it is unnecessary to call L{Realize} for the change to - take place, it will happen immediately. - """ - - idx = self.GetToolIndex(tool_id) - - if idx >= 0 and idx < len(self._items): - self._items.pop(idx) - self.Realize() - return True - - return False - - - def DeleteToolByPos(self, pos): - """ - This function behaves like L{DeleteTool} but it deletes the tool at the - specified position and not the one with the given id. - - :param `pos`: the tool position. - - :see: L{DeleteTool} - """ - - if pos >= 0 and pos < len(self._items): - - self._items.pop(pos) - self.Realize() - return True - - return False - - - def FindControl(self, id): - """ - Returns a pointer to the control identified by `id` or ``None`` if no corresponding - control is found. - - :param `id`: the control identifier. - """ - - wnd = self.FindWindow(id) - return wnd - - - def FindTool(self, tool_id): - """ - Finds a tool for the given tool id. - - :param `tool_id`: the L{AuiToolBarItem} identifier. - """ - - for item in self._items: - if item.id == tool_id: - return item - - return None - - - def FindToolForPosition(self, x, y): - """ - Finds a tool for the given mouse position. - - :param `x`: mouse `x` position; - :param `y`: mouse `y` position. - - :returns: a pointer to a L{AuiToolBarItem} if a tool is found, or ``None`` otherwise. - """ - - for i, item in enumerate(self._items): - if not item.sizer_item: - continue - - rect = item.sizer_item.GetRect() - if rect.Contains((x,y)): - - # if the item doesn't fit on the toolbar, return None - if not self.GetToolFitsByIndex(i): - return None - - return item - - return None - - - def FindToolForPositionWithPacking(self, x, y): - """ - Finds a tool for the given mouse position, taking into account also the - tool packing. - - :param `x`: mouse `x` position; - :param `y`: mouse `y` position. - - :returns: a pointer to a L{AuiToolBarItem} if a tool is found, or ``None`` otherwise. - """ - - count = len(self._items) - - for i, item in enumerate(self._items): - if not item.sizer_item: - continue - - rect = item.sizer_item.GetRect() - - # apply tool packing - if i+1 < count: - rect.width += self._tool_packing - - if rect.Contains((x,y)): - - # if the item doesn't fit on the toolbar, return None - if not self.GetToolFitsByIndex(i): - return None - - return item - - return None - - - def FindToolByIndex(self, pos): - """ - Finds a tool for the given tool position in the L{AuiToolBar}. - - :param `pos`: the tool position in the toolbar. - - :returns: a pointer to a L{AuiToolBarItem} if a tool is found, or ``None`` otherwise. - """ - - if pos < 0 or pos >= len(self._items): - return None - - return self._items[pos] - - - def SetToolBitmapSize(self, size): - """ - Sets the default size of each tool bitmap. The default bitmap size is - 16 by 15 pixels. - - :param `size`: the size of the bitmaps in the toolbar. - - :note: This should be called to tell the toolbar what the tool bitmap - size is. Call it before you add tools. - - :note: Note that this is the size of the bitmap you pass to L{AddTool}, - and not the eventual size of the tool button. - - :todo: Add `wx.ToolBar` compatibility, actually implementing this method. - """ - - # TODO: wx.ToolBar compatibility - pass - - - def GetToolBitmapSize(self): - """ - Returns the size of bitmap that the toolbar expects to have. The default - bitmap size is 16 by 15 pixels. - - :note: Note that this is the size of the bitmap you pass to L{AddTool}, - and not the eventual size of the tool button. - - :todo: Add `wx.ToolBar` compatibility, actually implementing this method. - """ - - # TODO: wx.ToolBar compatibility - return wx.Size(16, 15) - - - def SetToolProportion(self, tool_id, proportion): - """ - Sets the tool proportion in the toolbar. - - :param `tool_id`: the L{AuiToolBarItem} identifier; - :param `proportion`: the tool proportion in the toolbar. - """ - - item = self.FindTool(tool_id) - if not item: - return - - item.proportion = proportion - - - def GetToolProportion(self, tool_id): - """ - Returns the tool proportion in the toolbar. - - :param `tool_id`: the L{AuiToolBarItem} identifier. - """ - - item = self.FindTool(tool_id) - if not item: - return - - return item.proportion - - - def SetToolSeparation(self, separation): - """ - Sets the separator size for the toolbar. - - :param `separation`: the separator size in pixels. - """ - - if self._art: - self._art.SetElementSize(AUI_TBART_SEPARATOR_SIZE, separation) - - - def GetToolSeparation(self): - """ Returns the separator size for the toolbar, in pixels. """ - - if self._art: - return self._art.GetElementSize(AUI_TBART_SEPARATOR_SIZE) - - return 5 - - - def SetToolDropDown(self, tool_id, dropdown): - """ - Assigns a drop down window menu to the toolbar item. - - :param `tool_id`: the L{AuiToolBarItem} identifier; - :param `dropdown`: whether to assign a drop down menu or not. - """ - - item = self.FindTool(tool_id) - if not item: - return - - item.dropdown = dropdown - - - def GetToolDropDown(self, tool_id): - """ - Returns whether the toolbar item identified by `tool_id` has an associated - drop down window menu or not. - - :param `tool_id`: the L{AuiToolBarItem} identifier. - """ - - item = self.FindTool(tool_id) - if not item: - return - - return item.dropdown - - - def SetToolSticky(self, tool_id, sticky): - """ - Sets the toolbar item as sticky or non-sticky. - - :param `tool_id`: the L{AuiToolBarItem} identifier; - :param `sticky`: whether the tool should be sticky or not. - """ - - # ignore separators - if tool_id == -1: - return - - item = self.FindTool(tool_id) - if not item: - return - - if item.sticky == sticky: - return - - item.sticky = sticky - - self.Refresh(False) - self.Update() - - - def GetToolSticky(self, tool_id): - """ - Returns whether the toolbar item identified by `tool_id` has a sticky - behaviour or not. - - :param `tool_id`: the L{AuiToolBarItem} identifier. - """ - - item = self.FindTool(tool_id) - if not item: - return - - return item.sticky - - - def SetToolBorderPadding(self, padding): - """ - Sets the padding between the tool border and the label. - - :param `padding`: the padding in pixels. - """ - - self._tool_border_padding = padding - - - def GetToolBorderPadding(self): - """ Returns the padding between the tool border and the label, in pixels. """ - - return self._tool_border_padding - - - def SetToolTextOrientation(self, orientation): - """ - Sets the label orientation for the toolbar items. - - :param `orientation`: the L{AuiToolBarItem} label orientation. - """ - - self._tool_text_orientation = orientation - - if self._art: - self._art.SetTextOrientation(orientation) - - - def GetToolTextOrientation(self): - """ Returns the label orientation for the toolbar items. """ - - return self._tool_text_orientation - - - def SetToolOrientation(self, orientation): - """ - Sets the tool orientation for the toolbar items. - - :param `orientation`: the L{AuiToolBarItem} orientation. - """ - - self._tool_orientation = orientation - if self._art: - self._art.SetOrientation(orientation) - - - def GetToolOrientation(self): - """ Returns the orientation for the toolbar items. """ - - return self._tool_orientation - - - def SetToolPacking(self, packing): - """ - Sets the value used for spacing tools. The default value is 1 pixel. - - :param `packing`: the value for packing. - """ - - self._tool_packing = packing - - - def GetToolPacking(self): - """ Returns the value used for spacing tools. The default value is 1 pixel. """ - - return self._tool_packing - - - def SetOrientation(self, orientation): - """ - Sets the toolbar orientation. - - :param `orientation`: either ``wx.VERTICAL`` or ``wx.HORIZONTAL``. - - :note: This can be temporarily overridden by L{AuiManager} when floating and - docking a L{AuiToolBar}. - """ - - pass - - - def SetMargins(self, left=-1, right=-1, top=-1, bottom=-1): - """ - Set the values to be used as margins for the toolbar. - - :param `left`: the left toolbar margin; - :param `right`: the right toolbar margin; - :param `top`: the top toolbar margin; - :param `bottom`: the bottom toolbar margin. - """ - - if left != -1: - self._left_padding = left - if right != -1: - self._right_padding = right - if top != -1: - self._top_padding = top - if bottom != -1: - self._bottom_padding = bottom - - - def SetMarginsSize(self, size): - """ - Set the values to be used as margins for the toolbar. - - :param `size`: the margin size (an instance of `wx.Size`). - """ - - self.SetMargins(size.x, size.x, size.y, size.y) - - - def SetMarginsXY(self, x, y): - """ - Set the values to be used as margins for the toolbar. - - :param `x`: left margin, right margin and inter-tool separation value; - :param `y`: top margin, bottom margin and inter-tool separation value. - """ - - self.SetMargins(x, x, y, y) - - - def GetGripperVisible(self): - """ Returns whether the toolbar gripper is visible or not. """ - - return self._gripper_visible - - - def SetGripperVisible(self, visible): - """ - Sets whether the toolbar gripper is visible or not. - - :param `visible`: ``True`` for a visible gripper, ``False`` otherwise. - """ - - self._gripper_visible = visible - if visible: - self._agwStyle |= AUI_TB_GRIPPER - else: - self._agwStyle &= ~AUI_TB_GRIPPER - - self.Realize() - self.Refresh(False) - - - def GetOverflowVisible(self): - """ Returns whether the overflow button is visible or not. """ - - return self._overflow_visible - - - def SetOverflowVisible(self, visible): - """ - Sets whether the overflow button is visible or not. - - :param `visible`: ``True`` for a visible overflow button, ``False`` otherwise. - """ - - self._overflow_visible = visible - if visible: - self._agwStyle |= AUI_TB_OVERFLOW - else: - self._agwStyle &= ~AUI_TB_OVERFLOW - - self.Refresh(False) - - - def SetFont(self, font): - """ - Sets the L{AuiToolBar} font. - - :param `font`: a `wx.Font` object. - - :note: Overridden from `wx.PyControl`. - """ - - res = wx.PyControl.SetFont(self, font) - - if self._art: - self._art.SetFont(font) - - return res - - - def SetHoverItem(self, pitem): - """ - Sets a toolbar item to be currently hovered by the mouse. - - :param `pitem`: an instance of L{AuiToolBarItem}. - """ - - former_hover = None - - for item in self._items: - - if item.state & AUI_BUTTON_STATE_HOVER: - former_hover = item - - item.state &= ~AUI_BUTTON_STATE_HOVER - - if pitem: - pitem.state |= AUI_BUTTON_STATE_HOVER - - if former_hover != pitem: - self.Refresh(False) - self.Update() - - - def SetPressedItem(self, pitem): - """ - Sets a toolbar item to be currently in a "pressed" state. - - :param `pitem`: an instance of L{AuiToolBarItem}. - """ - - former_item = None - - for item in self._items: - - if item.state & AUI_BUTTON_STATE_PRESSED: - former_item = item - - item.state &= ~AUI_BUTTON_STATE_PRESSED - - if pitem: - pitem.state &= ~AUI_BUTTON_STATE_HOVER - pitem.state |= AUI_BUTTON_STATE_PRESSED - - if former_item != pitem: - self.Refresh(False) - self.Update() - - - def RefreshOverflowState(self): - """ Refreshes the overflow button. """ - - if not self._overflow_sizer_item: - self._overflow_state = 0 - return - - overflow_state = 0 - overflow_rect = self.GetOverflowRect() - - # find out the mouse's current position - pt = wx.GetMousePosition() - pt = self.ScreenToClient(pt) - - # find out if the mouse cursor is inside the dropdown rectangle - if overflow_rect.Contains((pt.x, pt.y)): - - if _VERSION_STRING < "2.9": - leftDown = wx.GetMouseState().LeftDown() - else: - leftDown = wx.GetMouseState().LeftIsDown() - - if leftDown: - overflow_state = AUI_BUTTON_STATE_PRESSED - else: - overflow_state = AUI_BUTTON_STATE_HOVER - - if overflow_state != self._overflow_state: - self._overflow_state = overflow_state - self.Refresh(False) - self.Update() - - self._overflow_state = overflow_state - - - def ToggleTool(self, tool_id, state): - """ - Toggles a tool on or off. This does not cause any event to get emitted. - - :param `tool_id`: tool in question. - :param `state`: if ``True``, toggles the tool on, otherwise toggles it off. - - :note: This only applies to a tool that has been specified as a toggle tool. - """ - - tool = self.FindTool(tool_id) - - if tool: - if tool.kind not in [ITEM_CHECK, ITEM_RADIO]: - return - - if tool.kind == ITEM_RADIO: - idx = self.GetToolIndex(tool_id) - if idx >= 0 and idx < len(self._items): - for i in xrange(idx, len(self._items)): - tool = self.FindToolByIndex(i) - if tool.kind != ITEM_RADIO: - break - tool.state &= ~AUI_BUTTON_STATE_CHECKED - - for i in xrange(idx, -1, -1): - tool = self.FindToolByIndex(i) - if tool.kind != ITEM_RADIO: - break - tool.state &= ~AUI_BUTTON_STATE_CHECKED - - tool = self.FindTool(tool_id) - tool.state |= AUI_BUTTON_STATE_CHECKED - else: - if state == True: - tool.state |= AUI_BUTTON_STATE_CHECKED - else: - tool.state &= ~AUI_BUTTON_STATE_CHECKED - - - def GetToolToggled(self, tool_id): - """ - Returns whether a tool is toggled or not. - - :param `tool_id`: the toolbar item identifier. - - :note: This only applies to a tool that has been specified as a toggle tool. - """ - - tool = self.FindTool(tool_id) - - if tool: - if tool.kind not in [ITEM_CHECK, ITEM_RADIO]: - return False - - return (tool.state & AUI_BUTTON_STATE_CHECKED and [True] or [False])[0] - - return False - - - def EnableTool(self, tool_id, state): - """ - Enables or disables the tool. - - :param `tool_id`: identifier for the tool to enable or disable. - :param `state`: if ``True``, enables the tool, otherwise disables it. - """ - - tool = self.FindTool(tool_id) - - if tool: - - if state == True: - tool.state &= ~AUI_BUTTON_STATE_DISABLED - else: - tool.state |= AUI_BUTTON_STATE_DISABLED - - - def GetToolEnabled(self, tool_id): - """ - Returns whether the tool identified by `tool_id` is enabled or not. - - :param `tool_id`: the tool identifier. - """ - - tool = self.FindTool(tool_id) - - if tool: - return (tool.state & AUI_BUTTON_STATE_DISABLED and [False] or [True])[0] - - return False - - - def GetToolLabel(self, tool_id): - """ - Returns the tool label for the tool identified by `tool_id`. - - :param `tool_id`: the tool identifier. - """ - - tool = self.FindTool(tool_id) - if not tool: - return "" - - return tool.label - - - def SetToolLabel(self, tool_id, label): - """ - Sets the tool label for the tool identified by `tool_id`. - - :param `tool_id`: the tool identifier; - :param `label`: the new toolbar item label. - """ - - tool = self.FindTool(tool_id) - if tool: - tool.label = label - - - def GetToolBitmap(self, tool_id): - """ - Returns the tool bitmap for the tool identified by `tool_id`. - - :param `tool_id`: the tool identifier. - """ - - tool = self.FindTool(tool_id) - if not tool: - return wx.NullBitmap - - return tool.bitmap - - - def SetToolBitmap(self, tool_id, bitmap): - """ - Sets the tool bitmap for the tool identified by `tool_id`. - - :param `tool_id`: the tool identifier; - :param `bitmap`: the new bitmap for the toolbar item (an instance of `wx.Bitmap`). - """ - - tool = self.FindTool(tool_id) - if tool: - tool.bitmap = bitmap - - - def SetToolNormalBitmap(self, tool_id, bitmap): - """ - Sets the tool bitmap for the tool identified by `tool_id`. - - :param `tool_id`: the tool identifier; - :param `bitmap`: the new bitmap for the toolbar item (an instance of `wx.Bitmap`). - """ - - self.SetToolBitmap(tool_id, bitmap) - - - def SetToolDisabledBitmap(self, tool_id, bitmap): - """ - Sets the tool disabled bitmap for the tool identified by `tool_id`. - - :param `tool_id`: the tool identifier; - :param `bitmap`: the new disabled bitmap for the toolbar item (an instance of `wx.Bitmap`). - """ - - tool = self.FindTool(tool_id) - if tool: - tool.disabled_bitmap = bitmap - - - def GetToolShortHelp(self, tool_id): - """ - Returns the short help for the given tool. - - :param `tool_id`: the tool identifier. - """ - - tool = self.FindTool(tool_id) - if not tool: - return "" - - return tool.short_help - - - def SetToolShortHelp(self, tool_id, help_string): - """ - Sets the short help for the given tool. - - :param `tool_id`: the tool identifier; - :param `help_string`: the string for the short help. - """ - - tool = self.FindTool(tool_id) - if tool: - tool.short_help = help_string - - - def GetToolLongHelp(self, tool_id): - """ - Returns the long help for the given tool. - - :param `tool_id`: the tool identifier. - """ - - tool = self.FindTool(tool_id) - if not tool: - return "" - - return tool.long_help - - - def SetToolAlignment(self, alignment=wx.EXPAND): - """ - This sets the alignment for all of the tools within the - toolbar (only has an effect when the toolbar is expanded). - - :param `alignment`: `wx.Sizer` alignment value - (``wx.ALIGN_CENTER_HORIZONTAL`` or ``wx.ALIGN_CENTER_VERTICAL``). - """ - - self._tool_alignment = alignment - - - - def SetToolLongHelp(self, tool_id, help_string): - """ - Sets the long help for the given tool. - - :param `tool_id`: the tool identifier; - :param `help_string`: the string for the long help. - """ - - tool = self.FindTool(tool_id) - if tool: - tool.long_help = help_string - - - def SetCustomOverflowItems(self, prepend, append): - """ - Sets the two lists `prepend` and `append` as custom overflow items. - - :param `prepend`: a list of L{AuiToolBarItem} to be prepended; - :param `append`: a list of L{AuiToolBarItem} to be appended. - """ - - self._custom_overflow_prepend = prepend - self._custom_overflow_append = append - - - def GetToolCount(self): - """ Returns the number of tools in the L{AuiToolBar}. """ - - return len(self._items) - - - def GetToolIndex(self, tool_id): - """ - Returns the position of the tool in the toolbar given its identifier. - - :param `tool_id`: the toolbar item identifier. - """ - - # this will prevent us from returning the index of the - # first separator in the toolbar since its id is equal to -1 - if tool_id == -1: - return wx.NOT_FOUND - - for i, item in enumerate(self._items): - if item.id == tool_id: - return i - - return wx.NOT_FOUND - - - def GetToolPos(self, tool_id): - """ - Returns the position of the tool in the toolbar given its identifier. - - :param `tool_id`: the toolbar item identifier. - """ - - return self.GetToolIndex(tool_id) - - - def GetToolFitsByIndex(self, tool_id): - """ - Returns whether the tool identified by `tool_id` fits into the toolbar or not. - - :param `tool_id`: the toolbar item identifier. - """ - - if tool_id < 0 or tool_id >= len(self._items): - return False - - if not self._items[tool_id].sizer_item: - return False - - cli_w, cli_h = self.GetClientSize() - rect = self._items[tool_id].sizer_item.GetRect() - - if self._agwStyle & AUI_TB_VERTICAL: - # take the dropdown size into account - if self._overflow_visible: - cli_h -= self._overflow_sizer_item.GetSize().y - - if rect.y+rect.height < cli_h: - return True - - else: - - # take the dropdown size into account - if self._overflow_visible: - cli_w -= self._overflow_sizer_item.GetSize().x - - if rect.x+rect.width < cli_w: - return True - - return False - - - def GetToolFits(self, tool_id): - """ - Returns whether the tool identified by `tool_id` fits into the toolbar or not. - - :param `tool_id`: the toolbar item identifier. - """ - - return self.GetToolFitsByIndex(self.GetToolIndex(tool_id)) - - - def GetToolRect(self, tool_id): - """ - Returns the toolbar item rectangle - - :param `tool_id`: the toolbar item identifier. - """ - - tool = self.FindTool(tool_id) - if tool and tool.sizer_item: - return tool.sizer_item.GetRect() - - return wx.Rect() - - - def GetToolBarFits(self): - """ Returns whether the L{AuiToolBar} size fits in a specified size. """ - - if len(self._items) == 0: - # empty toolbar always 'fits' - return True - - # entire toolbar content fits if the last tool fits - return self.GetToolFitsByIndex(len(self._items) - 1) - - - def Realize(self): - """ Realizes the toolbar. This function should be called after you have added tools. """ - - dc = wx.ClientDC(self) - - if not dc.IsOk(): - return False - - horizontal = True - if self._agwStyle & AUI_TB_VERTICAL: - horizontal = False - - # create the new sizer to add toolbar elements to - sizer = wx.BoxSizer((horizontal and [wx.HORIZONTAL] or [wx.VERTICAL])[0]) - - # add gripper area - separator_size = self._art.GetElementSize(AUI_TBART_SEPARATOR_SIZE) - gripper_size = self._art.GetElementSize(AUI_TBART_GRIPPER_SIZE) - - if gripper_size > 0 and self._gripper_visible: - if horizontal: - self._gripper_sizer_item = sizer.Add((gripper_size, 1), 0, wx.EXPAND) - else: - self._gripper_sizer_item = sizer.Add((1, gripper_size), 0, wx.EXPAND) - else: - self._gripper_sizer_item = None - - # add "left" padding - if self._left_padding > 0: - if horizontal: - sizer.Add((self._left_padding, 1)) - else: - sizer.Add((1, self._left_padding)) - - count = len(self._items) - for i, item in enumerate(self._items): - - sizer_item = None - kind = item.kind - - if kind == ITEM_LABEL: - - size = self._art.GetLabelSize(dc, self, item) - sizer_item = sizer.Add((size.x + (self._tool_border_padding*2), - size.y + (self._tool_border_padding*2)), - item.proportion, - item.alignment) - if i+1 < count: - sizer.AddSpacer(self._tool_packing) - - - elif kind in [ITEM_CHECK, ITEM_NORMAL, ITEM_RADIO]: - - size = self._art.GetToolSize(dc, self, item) - sizer_item = sizer.Add((size.x + (self._tool_border_padding*2), - size.y + (self._tool_border_padding*2)), - 0, - item.alignment) - # add tool packing - if i+1 < count: - sizer.AddSpacer(self._tool_packing) - - elif kind == ITEM_SEPARATOR: - - if horizontal: - sizer_item = sizer.Add((separator_size, 1), 0, wx.EXPAND) - else: - sizer_item = sizer.Add((1, separator_size), 0, wx.EXPAND) - - # add tool packing - if i+1 < count: - sizer.AddSpacer(self._tool_packing) - - elif kind == ITEM_SPACER: - - if item.proportion > 0: - sizer_item = sizer.AddStretchSpacer(item.proportion) - else: - sizer_item = sizer.Add((item.spacer_pixels, 1)) - - elif kind == ITEM_CONTROL: - - vert_sizer = wx.BoxSizer(wx.VERTICAL) - vert_sizer.AddStretchSpacer(1) - ctrl_sizer_item = vert_sizer.Add(item.window, 0, wx.EXPAND) - vert_sizer.AddStretchSpacer(1) - - if self._agwStyle & AUI_TB_TEXT and \ - self._tool_text_orientation == AUI_TBTOOL_TEXT_BOTTOM and \ - item.GetLabel() != "": - - s = self.GetLabelSize(item.GetLabel()) - vert_sizer.Add((1, s.y)) - - sizer_item = sizer.Add(vert_sizer, item.proportion, wx.EXPAND) - min_size = item.min_size - - # proportional items will disappear from the toolbar if - # their min width is not set to something really small - if item.proportion != 0: - min_size.x = 1 - - if min_size.IsFullySpecified(): - sizer.SetItemMinSize(vert_sizer, min_size) - vert_sizer.SetItemMinSize(item.window, min_size) - - # add tool packing - if i+1 < count: - sizer.AddSpacer(self._tool_packing) - - item.sizer_item = sizer_item - - - # add "right" padding - if self._right_padding > 0: - if horizontal: - sizer.Add((self._right_padding, 1)) - else: - sizer.Add((1, self._right_padding)) - - # add drop down area - self._overflow_sizer_item = None - - if self._agwStyle & AUI_TB_OVERFLOW: - - overflow_size = self._art.GetElementSize(AUI_TBART_OVERFLOW_SIZE) - if overflow_size > 0 and self._overflow_visible: - - if horizontal: - self._overflow_sizer_item = sizer.Add((overflow_size, 1), 0, wx.EXPAND) - else: - self._overflow_sizer_item = sizer.Add((1, overflow_size), 0, wx.EXPAND) - - else: - - self._overflow_sizer_item = None - - # the outside sizer helps us apply the "top" and "bottom" padding - outside_sizer = wx.BoxSizer((horizontal and [wx.VERTICAL] or [wx.HORIZONTAL])[0]) - - # add "top" padding - if self._top_padding > 0: - - if horizontal: - outside_sizer.Add((1, self._top_padding)) - else: - outside_sizer.Add((self._top_padding, 1)) - - # add the sizer that contains all of the toolbar elements - outside_sizer.Add(sizer, 1, self._tool_alignment) - - # add "bottom" padding - if self._bottom_padding > 0: - - if horizontal: - outside_sizer.Add((1, self._bottom_padding)) - else: - outside_sizer.Add((self._bottom_padding, 1)) - - del self._sizer # remove old sizer - self._sizer = outside_sizer - self.SetSizer(outside_sizer) - - # calculate the rock-bottom minimum size - for item in self._items: - - if item.sizer_item and item.proportion > 0 and item.min_size.IsFullySpecified(): - item.sizer_item.SetMinSize((0, 0)) - - self._absolute_min_size = self._sizer.GetMinSize() - - # reset the min sizes to what they were - for item in self._items: - - if item.sizer_item and item.proportion > 0 and item.min_size.IsFullySpecified(): - item.sizer_item.SetMinSize(item.min_size) - - # set control size - size = self._sizer.GetMinSize() - self.SetMinSize(size) - self._minWidth = size.x - self._minHeight = size.y - - if self._agwStyle & AUI_TB_NO_AUTORESIZE == 0: - - cur_size = self.GetClientSize() - new_size = self.GetMinSize() - - if new_size != cur_size: - - self.SetClientSize(new_size) - - else: - - self._sizer.SetDimension(0, 0, cur_size.x, cur_size.y) - - else: - - cur_size = self.GetClientSize() - self._sizer.SetDimension(0, 0, cur_size.x, cur_size.y) - - self.Refresh(False) - return True - - - def GetOverflowState(self): - """ Returns the state of the overflow button. """ - - return self._overflow_state - - - def GetOverflowRect(self): - """ Returns the rectangle of the overflow button. """ - - cli_rect = wx.RectPS(wx.Point(0, 0), self.GetClientSize()) - overflow_rect = wx.Rect(*self._overflow_sizer_item.GetRect()) - overflow_size = self._art.GetElementSize(AUI_TBART_OVERFLOW_SIZE) - - if self._agwStyle & AUI_TB_VERTICAL: - - overflow_rect.y = cli_rect.height - overflow_size - overflow_rect.x = 0 - overflow_rect.width = cli_rect.width - overflow_rect.height = overflow_size - - else: - - overflow_rect.x = cli_rect.width - overflow_size - overflow_rect.y = 0 - overflow_rect.width = overflow_size - overflow_rect.height = cli_rect.height - - return overflow_rect - - - def GetLabelSize(self, label): - """ - Returns the standard size of a toolbar item. - - :param `label`: a test label. - """ - - dc = wx.ClientDC(self) - dc.SetFont(self._font) - - return GetLabelSize(dc, label, self._tool_orientation != AUI_TBTOOL_HORIZONTAL) - - - def GetAuiManager(self): - """ Returns the L{AuiManager} which manages the toolbar. """ - - try: - return self._auiManager - except AttributeError: - return False - - - def SetAuiManager(self, auiManager): - """ Sets the L{AuiManager} which manages the toolbar. """ - - self._auiManager = auiManager - - - def DoIdleUpdate(self): - """ Updates the toolbar during idle times. """ - - handler = self.GetEventHandler() - if not handler: - return - - need_refresh = False - - for item in self._items: - - if item.id == -1: - continue - - evt = wx.UpdateUIEvent(item.id) - evt.SetEventObject(self) - - if handler.ProcessEvent(evt): - - if evt.GetSetEnabled(): - - if item.window: - is_enabled = item.window.IsEnabled() - else: - is_enabled = (item.state & AUI_BUTTON_STATE_DISABLED and [False] or [True])[0] - - new_enabled = evt.GetEnabled() - if new_enabled != is_enabled: - - if item.window: - item.window.Enable(new_enabled) - else: - if new_enabled: - item.state &= ~AUI_BUTTON_STATE_DISABLED - else: - item.state |= AUI_BUTTON_STATE_DISABLED - - need_refresh = True - - if evt.GetSetChecked(): - - # make sure we aren't checking an item that can't be - if item.kind != ITEM_CHECK and item.kind != ITEM_RADIO: - continue - - is_checked = (item.state & AUI_BUTTON_STATE_CHECKED and [True] or [False])[0] - new_checked = evt.GetChecked() - - if new_checked != is_checked: - - if new_checked: - item.state |= AUI_BUTTON_STATE_CHECKED - else: - item.state &= ~AUI_BUTTON_STATE_CHECKED - - need_refresh = True - - if need_refresh: - self.Refresh(False) - - - def OnSize(self, event): - """ - Handles the ``wx.EVT_SIZE`` event for L{AuiToolBar}. - - :param `event`: a `wx.SizeEvent` event to be processed. - """ - - x, y = self.GetClientSize() - realize = False - - if x > y: - self.SetOrientation(wx.HORIZONTAL) - else: - self.SetOrientation(wx.VERTICAL) - - if (x >= y and self._absolute_min_size.x > x) or (y > x and self._absolute_min_size.y > y): - - # hide all flexible items - for item in self._items: - if item.sizer_item and item.proportion > 0 and item.sizer_item.IsShown(): - item.sizer_item.Show(False) - item.sizer_item.SetProportion(0) - - if self._originalStyle & AUI_TB_OVERFLOW: - if not self.GetOverflowVisible(): - self.SetOverflowVisible(True) - realize = True - - else: - - if self._originalStyle & AUI_TB_OVERFLOW and not self._custom_overflow_append and \ - not self._custom_overflow_prepend: - if self.GetOverflowVisible(): - self.SetOverflowVisible(False) - realize = True - - # show all flexible items - for item in self._items: - if item.sizer_item and item.proportion > 0 and not item.sizer_item.IsShown(): - item.sizer_item.Show(True) - item.sizer_item.SetProportion(item.proportion) - - self._sizer.SetDimension(0, 0, x, y) - - if realize: - self.Realize() - else: - self.Refresh(False) - - self.Update() - - - def DoSetSize(self, x, y, width, height, sizeFlags=wx.SIZE_AUTO): - """ - Sets the position and size of the window in pixels. The `sizeFlags` - parameter indicates the interpretation of the other params if they are - equal to -1. - - :param `x`: the window `x` position; - :param `y`: the window `y` position; - :param `width`: the window width; - :param `height`: the window height; - :param `sizeFlags`: may have one of this bit set: - - =================================== ====================================== - Size Flags Description - =================================== ====================================== - ``wx.SIZE_AUTO`` A -1 indicates that a class-specific default should be used. - ``wx.SIZE_AUTO_WIDTH`` A -1 indicates that a class-specific default should be used for the width. - ``wx.SIZE_AUTO_HEIGHT`` A -1 indicates that a class-specific default should be used for the height. - ``wx.SIZE_USE_EXISTING`` Existing dimensions should be used if -1 values are supplied. - ``wx.SIZE_ALLOW_MINUS_ONE`` Allow dimensions of -1 and less to be interpreted as real dimensions, not default values. - ``wx.SIZE_FORCE`` Normally, if the position and the size of the window are already the same as the parameters of this function, nothing is done. but with this flag a window resize may be forced even in this case (supported in wx 2.6.2 and later and only implemented for MSW and ignored elsewhere currently) - =================================== ====================================== - - :note: Overridden from `wx.PyControl`. - """ - - parent_size = self.GetParent().GetClientSize() - if x + width > parent_size.x: - width = max(0, parent_size.x - x) - if y + height > parent_size.y: - height = max(0, parent_size.y - y) - - wx.PyControl.DoSetSize(self, x, y, width, height, sizeFlags) - - - def OnIdle(self, event): - """ - Handles the ``wx.EVT_IDLE`` event for L{AuiToolBar}. - - :param `event`: a `wx.IdleEvent` event to be processed. - """ - - self.DoIdleUpdate() - event.Skip() - - - def DoGetBestSize(self): - """ - Gets the size which best suits the window: for a control, it would be the - minimal size which doesn't truncate the control, for a panel - the same - size as it would have after a call to `Fit()`. - - :note: Overridden from `wx.PyControl`. - """ - - return self._absolute_min_size - - - def OnPaint(self, event): - """ - Handles the ``wx.EVT_PAINT`` event for L{AuiToolBar}. - - :param `event`: a `wx.PaintEvent` event to be processed. - """ - - dc = wx.AutoBufferedPaintDC(self) - cli_rect = wx.RectPS(wx.Point(0, 0), self.GetClientSize()) - - horizontal = True - if self._agwStyle & AUI_TB_VERTICAL: - horizontal = False - - if self._agwStyle & AUI_TB_PLAIN_BACKGROUND: - self._art.DrawPlainBackground(dc, self, cli_rect) - else: - self._art.DrawBackground(dc, self, cli_rect, horizontal) - - gripper_size = self._art.GetElementSize(AUI_TBART_GRIPPER_SIZE) - dropdown_size = self._art.GetElementSize(AUI_TBART_OVERFLOW_SIZE) - - # paint the gripper - if gripper_size > 0 and self._gripper_sizer_item: - gripper_rect = wx.Rect(*self._gripper_sizer_item.GetRect()) - if horizontal: - gripper_rect.width = gripper_size - else: - gripper_rect.height = gripper_size - - self._art.DrawGripper(dc, self, gripper_rect) - - # calculated how far we can draw items - if horizontal: - last_extent = cli_rect.width - else: - last_extent = cli_rect.height - - if self._overflow_visible: - last_extent -= dropdown_size - - # paint each individual tool - for item in self._items: - - if not item.sizer_item: - continue - - item_rect = wx.Rect(*item.sizer_item.GetRect()) - - if (horizontal and item_rect.x + item_rect.width >= last_extent) or \ - (not horizontal and item_rect.y + item_rect.height >= last_extent): - - break - - if item.kind == ITEM_SEPARATOR: - # draw a separator - self._art.DrawSeparator(dc, self, item_rect) - - elif item.kind == ITEM_LABEL: - # draw a text label only - self._art.DrawLabel(dc, self, item, item_rect) - - elif item.kind == ITEM_NORMAL: - # draw a regular button or dropdown button - if not item.dropdown: - self._art.DrawButton(dc, self, item, item_rect) - else: - self._art.DrawDropDownButton(dc, self, item, item_rect) - - elif item.kind == ITEM_CHECK: - # draw a regular toggle button or a dropdown one - if not item.dropdown: - self._art.DrawButton(dc, self, item, item_rect) - else: - self._art.DrawDropDownButton(dc, self, item, item_rect) - - elif item.kind == ITEM_RADIO: - # draw a toggle button - self._art.DrawButton(dc, self, item, item_rect) - - elif item.kind == ITEM_CONTROL: - # draw the control's label - self._art.DrawControlLabel(dc, self, item, item_rect) - - # fire a signal to see if the item wants to be custom-rendered - self.OnCustomRender(dc, item, item_rect) - - # paint the overflow button - if dropdown_size > 0 and self._overflow_sizer_item: - dropdown_rect = self.GetOverflowRect() - self._art.DrawOverflowButton(dc, self, dropdown_rect, self._overflow_state) - - - def OnEraseBackground(self, event): - """ - Handles the ``wx.EVT_ERASE_BACKGROUND`` event for L{AuiToolBar}. - - :param `event`: a `wx.EraseEvent` event to be processed. - - :note: This is intentionally empty, to reduce flicker. - """ - - pass - - - def OnLeftDown(self, event): - """ - Handles the ``wx.EVT_LEFT_DOWN`` event for L{AuiToolBar}. - - :param `event`: a `wx.MouseEvent` event to be processed. - """ - - cli_rect = wx.RectPS(wx.Point(0, 0), self.GetClientSize()) - self.StopPreviewTimer() - - if self._gripper_sizer_item: - - gripper_rect = wx.Rect(*self._gripper_sizer_item.GetRect()) - if gripper_rect.Contains(event.GetPosition()): - - # find aui manager - manager = self.GetAuiManager() - if not manager: - return - - x_drag_offset = event.GetX() - gripper_rect.GetX() - y_drag_offset = event.GetY() - gripper_rect.GetY() - - clientPt = wx.Point(*event.GetPosition()) - screenPt = self.ClientToScreen(clientPt) - managedWindow = manager.GetManagedWindow() - managerClientPt = managedWindow.ScreenToClient(screenPt) - - # gripper was clicked - manager.OnGripperClicked(self, managerClientPt, wx.Point(x_drag_offset, y_drag_offset)) - return - - if self._overflow_sizer_item: - overflow_rect = self.GetOverflowRect() - - if self._art and self._overflow_visible and overflow_rect.Contains(event.GetPosition()): - - e = AuiToolBarEvent(wxEVT_COMMAND_AUITOOLBAR_OVERFLOW_CLICK, -1) - e.SetEventObject(self) - e.SetToolId(-1) - e.SetClickPoint(event.GetPosition()) - processed = self.ProcessEvent(e) - - if processed: - self.DoIdleUpdate() - else: - overflow_items = [] - - # add custom overflow prepend items, if any - count = len(self._custom_overflow_prepend) - for i in xrange(count): - overflow_items.append(self._custom_overflow_prepend[i]) - - # only show items that don't fit in the dropdown - count = len(self._items) - for i in xrange(count): - - if not self.GetToolFitsByIndex(i): - overflow_items.append(self._items[i]) - - # add custom overflow append items, if any - count = len(self._custom_overflow_append) - for i in xrange(count): - overflow_items.append(self._custom_overflow_append[i]) - - res = self._art.ShowDropDown(self, overflow_items) - self._overflow_state = 0 - self.Refresh(False) - if res != -1: - e = wx.CommandEvent(wx.wxEVT_COMMAND_MENU_SELECTED, res) - e.SetEventObject(self) - if not self.GetParent().ProcessEvent(e): - tool = self.FindTool(res) - if tool: - state = (tool.state & AUI_BUTTON_STATE_CHECKED and [True] or [False])[0] - self.ToggleTool(res, not state) - - return - - self._dragging = False - self._action_pos = wx.Point(*event.GetPosition()) - self._action_item = self.FindToolForPosition(*event.GetPosition()) - - if self._action_item: - - if self._action_item.state & AUI_BUTTON_STATE_DISABLED: - - self._action_pos = wx.Point(-1, -1) - self._action_item = None - return - - self.SetPressedItem(self._action_item) - - # fire the tool dropdown event - e = AuiToolBarEvent(wxEVT_COMMAND_AUITOOLBAR_TOOL_DROPDOWN, self._action_item.id) - e.SetEventObject(self) - e.SetToolId(self._action_item.id) - e.SetDropDownClicked(False) - - mouse_x, mouse_y = event.GetX(), event.GetY() - rect = wx.Rect(*self._action_item.sizer_item.GetRect()) - - if self._action_item.dropdown: - if (self._action_item.orientation == AUI_TBTOOL_HORIZONTAL and \ - mouse_x >= (rect.x+rect.width-BUTTON_DROPDOWN_WIDTH-1) and \ - mouse_x < (rect.x+rect.width)) or \ - (self._action_item.orientation != AUI_TBTOOL_HORIZONTAL and \ - mouse_y >= (rect.y+rect.height-BUTTON_DROPDOWN_WIDTH-1) and \ - mouse_y < (rect.y+rect.height)): - - e.SetDropDownClicked(True) - - e.SetClickPoint(event.GetPosition()) - e.SetItemRect(rect) - self.ProcessEvent(e) - self.DoIdleUpdate() - - - def OnLeftUp(self, event): - """ - Handles the ``wx.EVT_LEFT_UP`` event for L{AuiToolBar}. - - :param `event`: a `wx.MouseEvent` event to be processed. - """ - - self.SetPressedItem(None) - - hit_item = self.FindToolForPosition(*event.GetPosition()) - - if hit_item and not hit_item.state & AUI_BUTTON_STATE_DISABLED: - self.SetHoverItem(hit_item) - - if self._dragging: - # reset drag and drop member variables - self._dragging = False - self._action_pos = wx.Point(-1, -1) - self._action_item = None - - else: - - if self._action_item and hit_item == self._action_item: - self.SetToolTipString("") - - if hit_item.kind in [ITEM_CHECK, ITEM_RADIO]: - toggle = not (self._action_item.state & AUI_BUTTON_STATE_CHECKED) - self.ToggleTool(self._action_item.id, toggle) - - # repaint immediately - self.Refresh(False) - self.Update() - - e = wx.CommandEvent(wx.wxEVT_COMMAND_MENU_SELECTED, self._action_item.id) - e.SetEventObject(self) - e.SetInt(toggle) - self._action_pos = wx.Point(-1, -1) - self._action_item = None - - self.ProcessEvent(e) - self.DoIdleUpdate() - - else: - - if self._action_item.id == ID_RESTORE_FRAME: - # find aui manager - manager = self.GetAuiManager() - - if not manager: - return - - pane = manager.GetPane(self) - e = framemanager.AuiManagerEvent(framemanager.wxEVT_AUI_PANE_MIN_RESTORE) - - e.SetManager(manager) - e.SetPane(pane) - - manager.ProcessEvent(e) - self.DoIdleUpdate() - - else: - - e = wx.CommandEvent(wx.wxEVT_COMMAND_MENU_SELECTED, self._action_item.id) - e.SetEventObject(self) - self.ProcessEvent(e) - self.DoIdleUpdate() - - # reset drag and drop member variables - self._dragging = False - self._action_pos = wx.Point(-1, -1) - self._action_item = None - - - def OnRightDown(self, event): - """ - Handles the ``wx.EVT_RIGHT_DOWN`` event for L{AuiToolBar}. - - :param `event`: a `wx.MouseEvent` event to be processed. - """ - - cli_rect = wx.RectPS(wx.Point(0, 0), self.GetClientSize()) - - if self._gripper_sizer_item: - gripper_rect = self._gripper_sizer_item.GetRect() - if gripper_rect.Contains(event.GetPosition()): - return - - if self._overflow_sizer_item: - - dropdown_size = self._art.GetElementSize(AUI_TBART_OVERFLOW_SIZE) - if dropdown_size > 0 and event.m_x > cli_rect.width - dropdown_size and \ - event.m_y >= 0 and event.m_y < cli_rect.height and self._art: - return - - self._action_pos = wx.Point(*event.GetPosition()) - self._action_item = self.FindToolForPosition(*event.GetPosition()) - - if self._action_item: - if self._action_item.state & AUI_BUTTON_STATE_DISABLED: - - self._action_pos = wx.Point(-1, -1) - self._action_item = None - return - - - def OnRightUp(self, event): - """ - Handles the ``wx.EVT_RIGHT_UP`` event for L{AuiToolBar}. - - :param `event`: a `wx.MouseEvent` event to be processed. - """ - - hit_item = self.FindToolForPosition(*event.GetPosition()) - - if self._action_item and hit_item == self._action_item: - - e = AuiToolBarEvent(wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK, self._action_item.id) - e.SetEventObject(self) - e.SetToolId(self._action_item.id) - e.SetClickPoint(self._action_pos) - self.ProcessEvent(e) - self.DoIdleUpdate() - - else: - - # right-clicked on the invalid area of the toolbar - e = AuiToolBarEvent(wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK, -1) - e.SetEventObject(self) - e.SetToolId(-1) - e.SetClickPoint(self._action_pos) - self.ProcessEvent(e) - self.DoIdleUpdate() - - # reset member variables - self._action_pos = wx.Point(-1, -1) - self._action_item = None - - - def OnMiddleDown(self, event): - """ - Handles the ``wx.EVT_MIDDLE_DOWN`` event for L{AuiToolBar}. - - :param `event`: a `wx.MouseEvent` event to be processed. - """ - - cli_rect = wx.RectPS(wx.Point(0, 0), self.GetClientSize()) - - if self._gripper_sizer_item: - - gripper_rect = self._gripper_sizer_item.GetRect() - if gripper_rect.Contains(event.GetPosition()): - return - - if self._overflow_sizer_item: - - dropdown_size = self._art.GetElementSize(AUI_TBART_OVERFLOW_SIZE) - if dropdown_size > 0 and event.m_x > cli_rect.width - dropdown_size and \ - event.m_y >= 0 and event.m_y < cli_rect.height and self._art: - return - - self._action_pos = wx.Point(*event.GetPosition()) - self._action_item = self.FindToolForPosition(*event.GetPosition()) - - if self._action_item: - if self._action_item.state & AUI_BUTTON_STATE_DISABLED: - - self._action_pos = wx.Point(-1, -1) - self._action_item = None - return - - - def OnMiddleUp(self, event): - """ - Handles the ``wx.EVT_MIDDLE_UP`` event for L{AuiToolBar}. - - :param `event`: a `wx.MouseEvent` event to be processed. - """ - - hit_item = self.FindToolForPosition(*event.GetPosition()) - - if self._action_item and hit_item == self._action_item: - if hit_item.kind == ITEM_NORMAL: - - e = AuiToolBarEvent(wxEVT_COMMAND_AUITOOLBAR_MIDDLE_CLICK, self._action_item.id) - e.SetEventObject(self) - e.SetToolId(self._action_item.id) - e.SetClickPoint(self._action_pos) - self.ProcessEvent(e) - self.DoIdleUpdate() - - # reset member variables - self._action_pos = wx.Point(-1, -1) - self._action_item = None - - - def OnMotion(self, event): - """ - Handles the ``wx.EVT_MOTION`` event for L{AuiToolBar}. - - :param `event`: a `wx.MouseEvent` event to be processed. - """ - - # start a drag event - if not self._dragging and self._action_item != None and self._action_pos != wx.Point(-1, -1) and \ - abs(event.m_x - self._action_pos.x) + abs(event.m_y - self._action_pos.y) > 5: - - self.SetToolTipString("") - self._dragging = True - - e = AuiToolBarEvent(wxEVT_COMMAND_AUITOOLBAR_BEGIN_DRAG, self.GetId()) - e.SetEventObject(self) - e.SetToolId(self._action_item.id) - self.ProcessEvent(e) - self.DoIdleUpdate() - return - - hit_item = self.FindToolForPosition(*event.GetPosition()) - - if hit_item: - if not hit_item.state & AUI_BUTTON_STATE_DISABLED: - self.SetHoverItem(hit_item) - else: - self.SetHoverItem(None) - - else: - # no hit item, remove any hit item - self.SetHoverItem(hit_item) - - # figure out tooltips - packing_hit_item = self.FindToolForPositionWithPacking(*event.GetPosition()) - - if packing_hit_item: - - if packing_hit_item != self._tip_item: - self._tip_item = packing_hit_item - - if packing_hit_item.short_help != "": - self.StartPreviewTimer() - self.SetToolTipString(packing_hit_item.short_help) - else: - self.SetToolTipString("") - self.StopPreviewTimer() - - else: - - self.SetToolTipString("") - self._tip_item = None - self.StopPreviewTimer() - - # if we've pressed down an item and we're hovering - # over it, make sure it's state is set to pressed - if self._action_item: - - if self._action_item == hit_item: - self.SetPressedItem(self._action_item) - else: - self.SetPressedItem(None) - - # figure out the dropdown button state (are we hovering or pressing it?) - self.RefreshOverflowState() - - - def OnLeaveWindow(self, event): - """ - Handles the ``wx.EVT_LEAVE_WINDOW`` event for L{AuiToolBar}. - - :param `event`: a `wx.MouseEvent` event to be processed. - """ - - self.RefreshOverflowState() - self.SetHoverItem(None) - self.SetPressedItem(None) - - self._tip_item = None - self.StopPreviewTimer() - - - def OnSetCursor(self, event): - """ - Handles the ``wx.EVT_SET_CURSOR`` event for L{AuiToolBar}. - - :param `event`: a `wx.SetCursorEvent` event to be processed. - """ - - cursor = wx.NullCursor - - if self._gripper_sizer_item: - - gripper_rect = self._gripper_sizer_item.GetRect() - if gripper_rect.Contains((event.GetX(), event.GetY())): - cursor = wx.StockCursor(wx.CURSOR_SIZING) - - event.SetCursor(cursor) - - - def OnCustomRender(self, dc, item, rect): - """ - Handles custom render for single L{AuiToolBar} items. - - :param `dc`: a `wx.DC` device context; - :param `item`: an instance of L{AuiToolBarItem}; - :param `rect`: the toolbar item rect. - - :note: This method must be overridden to provide custom rendering of items. - """ - - pass - - - def IsPaneMinimized(self): - """ Returns whether this L{AuiToolBar} contains a minimized pane tool. """ - - manager = self.GetAuiManager() - if not manager: - return False - - if manager.GetAGWFlags() & AUI_MGR_PREVIEW_MINIMIZED_PANES == 0: - # No previews here - return False - - self_name = manager.GetPane(self).name - - if not self_name.endswith("_min"): - # Wrong tool name - return False - - return self_name[0:-4] - - - def StartPreviewTimer(self): - """ Starts a timer in L{AuiManager} to slide-in/slide-out the minimized pane. """ - - self_name = self.IsPaneMinimized() - if not self_name: - return - - manager = self.GetAuiManager() - manager.StartPreviewTimer(self) - - - def StopPreviewTimer(self): - """ Stops a timer in L{AuiManager} to slide-in/slide-out the minimized pane. """ - - self_name = self.IsPaneMinimized() - if not self_name: - return - - manager = self.GetAuiManager() - manager.StopPreviewTimer() -