""" 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.GetX() > cli_rect.width - dropdown_size and \ event.GetY() >= 0 and event.GetY() < 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.GetX() > cli_rect.width - dropdown_size and \ event.GetY() >= 0 and event.GetY() < 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.GetX() - self._action_pos.x) + abs(event.GetY() - 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()