"""
auibar contains an implementation of 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 <andrea.gavana@gmail.com>"
__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 *
# 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 Clone(self):
"""
Returns a copy of the event.
Any event that is posted to the wxPython event system for later action (via
`wx.EvtHandler.AddPendingEvent` or `wx.PostEvent`) must implement this method.
All wxPython events fully implement this method, but any derived events
implemented by the user should also implement this method just in case they
(or some event derived from them) are ever posted.
All wxPython events implement a copy constructor, so the easiest way of
implementing the L{Clone} function is to implement a copy constructor for a new
event (call it `MyEvent`) and then define the L{Clone} function like this::
def Clone(self):
return MyEvent(self)
"""
return CommandToolBarEvent(self)
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 Clone(self):
"""
Returns a copy of the event.
Any event that is posted to the wxPython event system for later action (via
`wx.EvtHandler.AddPendingEvent` or `wx.PostEvent`) must implement this method.
All wxPython events fully implement this method, but any derived events
implemented by the user should also implement this method just in case they
(or some event derived from them) are ever posted.
All wxPython events implement a copy constructor, so the easiest way of
implementing the Clone function is to implement a copy constructor for a new
event (call it MyEvent) and then define the Clone function like this::
def Clone(self):
return MyEvent(self)
"""
return AuiToolBarEvent(self)
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. """
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(wxBrush(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.
: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. """
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 wx.GetMouseState().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.
"""
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.
"""
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.
"""
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_idx):
"""
Returns whether the tool identified by `tool_idx` fits into the toolbar or not.
:param `tool_idx`: the toolbar item identifier.
"""
if tool_idx < 0 or tool_idx >= len(self._items):
return False
if not self._items[tool_idx].sizer_item:
return False
cli_w, cli_h = self.GetClientSize()
rect = self._items[tool_idx].sizer_item.GetRect()
if self._agwStyle & AUI_TB_VERTICAL:
# take the dropdown size into account
if self._overflow_visible:
cli_h -= self._overflow_sizer_item.GetSize().y
if rect.y+rect.height < cli_h:
return True
else:
# take the dropdown size into account
if self._overflow_visible:
cli_w -= self._overflow_sizer_item.GetSize().x
if rect.x+rect.width < cli_w:
return True
return False
def GetToolFits(self, tool_id):
"""
Returns whether the tool identified by `tool_id` fits into the toolbar or not.
:param `tool_id`: the toolbar item identifier.
"""
return self.GetToolFitsByIndex(self.GetToolIndex(tool_id))
def GetToolRect(self, tool_id):
"""
Returns the toolbar item rectangle
:param `tool_id`: the toolbar item identifier.
"""
tool = self.FindTool(tool_id)
if tool and tool.sizer_item:
return tool.sizer_item.GetRect()
return wx.Rect()
def GetToolBarFits(self):
""" Returns whether the L{AuiToolBar} size fits in a specified size. """
if len(self._items) == 0:
# empty toolbar always 'fits'
return True
# entire toolbar content fits if the last tool fits
return self.GetToolFitsByIndex(len(self._items) - 1)
def Realize(self):
""" Realizes the toolbar. This function should be called after you have added tools. """
dc = wx.ClientDC(self)
if not dc.IsOk():
return False
horizontal = True
if self._agwStyle & AUI_TB_VERTICAL:
horizontal = False
# create the new sizer to add toolbar elements to
sizer = wx.BoxSizer((horizontal and [wx.HORIZONTAL] or [wx.VERTICAL])[0])
# add gripper area
separator_size = self._art.GetElementSize(AUI_TBART_SEPARATOR_SIZE)
gripper_size = self._art.GetElementSize(AUI_TBART_GRIPPER_SIZE)
if gripper_size > 0 and self._gripper_visible:
if horizontal:
self._gripper_sizer_item = sizer.Add((gripper_size, 1), 0, wx.EXPAND)
else:
self._gripper_sizer_item = sizer.Add((1, gripper_size), 0, wx.EXPAND)
else:
self._gripper_sizer_item = None
# add "left" padding
if self._left_padding > 0:
if horizontal:
sizer.Add((self._left_padding, 1))
else:
sizer.Add((1, self._left_padding))
count = len(self._items)
for i, item in enumerate(self._items):
sizer_item = None
kind = item.kind
if kind == ITEM_LABEL:
size = self._art.GetLabelSize(dc, self, item)
sizer_item = sizer.Add((size.x + (self._tool_border_padding*2),
size.y + (self._tool_border_padding*2)),
item.proportion,
item.alignment)
if i+1 < count:
sizer.AddSpacer(self._tool_packing)
elif kind in [ITEM_CHECK, ITEM_NORMAL, ITEM_RADIO]:
size = self._art.GetToolSize(dc, self, item)
sizer_item = sizer.Add((size.x + (self._tool_border_padding*2),
size.y + (self._tool_border_padding*2)),
0,
item.alignment)
# add tool packing
if i+1 < count:
sizer.AddSpacer(self._tool_packing)
elif kind == ITEM_SEPARATOR:
if horizontal:
sizer_item = sizer.Add((separator_size, 1), 0, wx.EXPAND)
else:
sizer_item = sizer.Add((1, separator_size), 0, wx.EXPAND)
# add tool packing
if i+1 < count:
sizer.AddSpacer(self._tool_packing)
elif kind == ITEM_SPACER:
if item.proportion > 0:
sizer_item = sizer.AddStretchSpacer(item.proportion)
else:
sizer_item = sizer.Add((item.spacer_pixels, 1))
elif kind == ITEM_CONTROL:
vert_sizer = wx.BoxSizer(wx.VERTICAL)
vert_sizer.AddStretchSpacer(1)
ctrl_sizer_item = vert_sizer.Add(item.window, 0, wx.EXPAND)
vert_sizer.AddStretchSpacer(1)
if self._agwStyle & AUI_TB_TEXT and \
self._tool_text_orientation == AUI_TBTOOL_TEXT_BOTTOM and \
item.GetLabel() != "":
s = self.GetLabelSize(item.GetLabel())
vert_sizer.Add((1, s.y))
sizer_item = sizer.Add(vert_sizer, item.proportion, wx.EXPAND)
min_size = item.min_size
# proportional items will disappear from the toolbar if
# their min width is not set to something really small
if item.proportion != 0:
min_size.x = 1
if min_size.IsFullySpecified():
sizer.SetItemMinSize(vert_sizer, min_size)
vert_sizer.SetItemMinSize(item.window, min_size)
# add tool packing
if i+1 < count:
sizer.AddSpacer(self._tool_packing)
item.sizer_item = sizer_item
# add "right" padding
if self._right_padding > 0:
if horizontal:
sizer.Add((self._right_padding, 1))
else:
sizer.Add((1, self._right_padding))
# add drop down area
self._overflow_sizer_item = None
if self._agwStyle & AUI_TB_OVERFLOW:
overflow_size = self._art.GetElementSize(AUI_TBART_OVERFLOW_SIZE)
if overflow_size > 0 and self._overflow_visible:
if horizontal:
self._overflow_sizer_item = sizer.Add((overflow_size, 1), 0, wx.EXPAND)
else:
self._overflow_sizer_item = sizer.Add((1, overflow_size), 0, wx.EXPAND)
else:
self._overflow_sizer_item = None
# the outside sizer helps us apply the "top" and "bottom" padding
outside_sizer = wx.BoxSizer((horizontal and [wx.VERTICAL] or [wx.HORIZONTAL])[0])
# add "top" padding
if self._top_padding > 0:
if horizontal:
outside_sizer.Add((1, self._top_padding))
else:
outside_sizer.Add((self._top_padding, 1))
# add the sizer that contains all of the toolbar elements
outside_sizer.Add(sizer, 1, self._tool_alignment)
# add "bottom" padding
if self._bottom_padding > 0:
if horizontal:
outside_sizer.Add((1, self._bottom_padding))
else:
outside_sizer.Add((self._bottom_padding, 1))
del self._sizer # remove old sizer
self._sizer = outside_sizer
self.SetSizer(outside_sizer)
# calculate the rock-bottom minimum size
for item in self._items:
if item.sizer_item and item.proportion > 0 and item.min_size.IsFullySpecified():
item.sizer_item.SetMinSize((0, 0))
self._absolute_min_size = self._sizer.GetMinSize()
# reset the min sizes to what they were
for item in self._items:
if item.sizer_item and item.proportion > 0 and item.min_size.IsFullySpecified():
item.sizer_item.SetMinSize(item.min_size)
# set control size
size = self._sizer.GetMinSize()
self.SetMinSize(size)
self._minWidth = size.x
self._minHeight = size.y
if self._agwStyle & AUI_TB_NO_AUTORESIZE == 0:
cur_size = self.GetClientSize()
new_size = self.GetMinSize()
if new_size != cur_size:
self.SetClientSize(new_size)
else:
self._sizer.SetDimension(0, 0, cur_size.x, cur_size.y)
else:
cur_size = self.GetClientSize()
self._sizer.SetDimension(0, 0, cur_size.x, cur_size.y)
self.Refresh(False)
return True
def GetOverflowState(self):
""" Returns the state of the overflow button. """
return self._overflow_state
def GetOverflowRect(self):
""" Returns the rectangle of the overflow button. """
cli_rect = wx.RectPS(wx.Point(0, 0), self.GetClientSize())
overflow_rect = wx.Rect(*self._overflow_sizer_item.GetRect())
overflow_size = self._art.GetElementSize(AUI_TBART_OVERFLOW_SIZE)
if self._agwStyle & AUI_TB_VERTICAL:
overflow_rect.y = cli_rect.height - overflow_size
overflow_rect.x = 0
overflow_rect.width = cli_rect.width
overflow_rect.height = overflow_size
else:
overflow_rect.x = cli_rect.width - overflow_size
overflow_rect.y = 0
overflow_rect.width = overflow_size
overflow_rect.height = cli_rect.height
return overflow_rect
def GetLabelSize(self, label):
"""
Returns the standard size of a toolbar item.
:param `label`: a test label.
"""
dc = wx.ClientDC(self)
dc.SetFont(self._font)
return GetLabelSize(dc, label, self._tool_orientation != AUI_TBTOOL_HORIZONTAL)
def GetAuiManager(self):
""" Returns the L{AuiManager} which manages the toolbar. """
try:
return self._auiManager
except AttributeError:
return False
def SetAuiManager(self, auiManager):
""" Sets the L{AuiManager} which manages the toolbar. """
self._auiManager = auiManager
def DoIdleUpdate(self):
""" Updates the toolbar during idle times. """
handler = self.GetEventHandler()
if not handler:
return
need_refresh = False
for item in self._items:
if item.id == -1:
continue
evt = wx.UpdateUIEvent(item.id)
evt.SetEventObject(self)
if handler.ProcessEvent(evt):
if evt.GetSetEnabled():
if item.window:
is_enabled = item.window.IsEnabled()
else:
is_enabled = (item.state & AUI_BUTTON_STATE_DISABLED and [False] or [True])[0]
new_enabled = evt.GetEnabled()
if new_enabled != is_enabled:
if item.window:
item.window.Enable(new_enabled)
else:
if new_enabled:
item.state &= ~AUI_BUTTON_STATE_DISABLED
else:
item.state |= AUI_BUTTON_STATE_DISABLED
need_refresh = True
if evt.GetSetChecked():
# make sure we aren't checking an item that can't be
if item.kind != ITEM_CHECK and item.kind != ITEM_RADIO:
continue
is_checked = (item.state & AUI_BUTTON_STATE_CHECKED and [True] or [False])[0]
new_checked = evt.GetChecked()
if new_checked != is_checked:
if new_checked:
item.state |= AUI_BUTTON_STATE_CHECKED
else:
item.state &= ~AUI_BUTTON_STATE_CHECKED
need_refresh = True
if need_refresh:
self.Refresh(False)
def OnSize(self, event):
"""
Handles the ``wx.EVT_SIZE`` event for L{AuiToolBar}.
:param `event`: a `wx.SizeEvent` event to be processed.
"""
x, y = self.GetClientSize()
realize = False
if x > y:
self.SetOrientation(wx.HORIZONTAL)
else:
self.SetOrientation(wx.VERTICAL)
if (x >= y and self._absolute_min_size.x > x) or (y > x and self._absolute_min_size.y > y):
# hide all flexible items
for item in self._items:
if item.sizer_item and item.proportion > 0 and item.sizer_item.IsShown():
item.sizer_item.Show(False)
item.sizer_item.SetProportion(0)
if self._originalStyle & AUI_TB_OVERFLOW:
if not self.GetOverflowVisible():
self.SetOverflowVisible(True)
realize = True
else:
if self._originalStyle & AUI_TB_OVERFLOW and not self._custom_overflow_append and \
not self._custom_overflow_prepend:
if self.GetOverflowVisible():
self.SetOverflowVisible(False)
realize = True
# show all flexible items
for item in self._items:
if item.sizer_item and item.proportion > 0 and not item.sizer_item.IsShown():
item.sizer_item.Show(True)
item.sizer_item.SetProportion(item.proportion)
self._sizer.SetDimension(0, 0, x, y)
if realize:
self.Realize()
else:
self.Refresh(False)
self.Update()
def DoSetSize(self, x, y, width, height, sizeFlags=wx.SIZE_AUTO):
"""
Sets the position and size of the window in pixels. The `sizeFlags`
parameter indicates the interpretation of the other params if they are
equal to -1.
:param `x`: the window `x` position;
:param `y`: the window `y` position;
:param `width`: the window width;
:param `height`: the window height;
:param `sizeFlags`: may have one of this bit set:
=================================== ======================================
Size Flags Description
=================================== ======================================
``wx.SIZE_AUTO`` A -1 indicates that a class-specific default should be used.
``wx.SIZE_AUTO_WIDTH`` A -1 indicates that a class-specific default should be used for the width.
``wx.SIZE_AUTO_HEIGHT`` A -1 indicates that a class-specific default should be used for the height.
``wx.SIZE_USE_EXISTING`` Existing dimensions should be used if -1 values are supplied.
``wx.SIZE_ALLOW_MINUS_ONE`` Allow dimensions of -1 and less to be interpreted as real dimensions, not default values.
``wx.SIZE_FORCE`` Normally, if the position and the size of the window are already the same as the parameters of this function, nothing is done. but with this flag a window resize may be forced even in this case (supported in wx 2.6.2 and later and only implemented for MSW and ignored elsewhere currently)
=================================== ======================================
:note: Overridden from `wx.PyControl`.
"""
parent_size = self.GetParent().GetClientSize()
if x + width > parent_size.x:
width = max(0, parent_size.x - x)
if y + height > parent_size.y:
height = max(0, parent_size.y - y)
wx.PyControl.DoSetSize(self, x, y, width, height, sizeFlags)
def OnIdle(self, event):
"""
Handles the ``wx.EVT_IDLE`` event for L{AuiToolBar}.
:param `event`: a `wx.IdleEvent` event to be processed.
"""
self.DoIdleUpdate()
event.Skip()
def DoGetBestSize(self):
"""
Gets the size which best suits the window: for a control, it would be the
minimal size which doesn't truncate the control, for a panel - the same
size as it would have after a call to `Fit()`.
:note: Overridden from `wx.PyControl`.
"""
return self._absolute_min_size
def OnPaint(self, event):
"""
Handles the ``wx.EVT_PAINT`` event for L{AuiToolBar}.
:param `event`: a `wx.PaintEvent` event to be processed.
"""
dc = wx.AutoBufferedPaintDC(self)
cli_rect = wx.RectPS(wx.Point(0, 0), self.GetClientSize())
horizontal = True
if self._agwStyle & AUI_TB_VERTICAL:
horizontal = False
if self._agwStyle & AUI_TB_PLAIN_BACKGROUND:
self._art.DrawPlainBackground(dc, self, cli_rect)
else:
self._art.DrawBackground(dc, self, cli_rect, horizontal)
gripper_size = self._art.GetElementSize(AUI_TBART_GRIPPER_SIZE)
dropdown_size = self._art.GetElementSize(AUI_TBART_OVERFLOW_SIZE)
# paint the gripper
if gripper_size > 0 and self._gripper_sizer_item:
gripper_rect = wx.Rect(*self._gripper_sizer_item.GetRect())
if horizontal:
gripper_rect.width = gripper_size
else:
gripper_rect.height = gripper_size
self._art.DrawGripper(dc, self, gripper_rect)
# calculated how far we can draw items
if horizontal:
last_extent = cli_rect.width
else:
last_extent = cli_rect.height
if self._overflow_visible:
last_extent -= dropdown_size
# paint each individual tool
for item in self._items:
if not item.sizer_item:
continue
item_rect = wx.Rect(*item.sizer_item.GetRect())
if (horizontal and item_rect.x + item_rect.width >= last_extent) or \
(not horizontal and item_rect.y + item_rect.height >= last_extent):
break
if item.kind == ITEM_SEPARATOR:
# draw a separator
self._art.DrawSeparator(dc, self, item_rect)
elif item.kind == ITEM_LABEL:
# draw a text label only
self._art.DrawLabel(dc, self, item, item_rect)
elif item.kind == ITEM_NORMAL:
# draw a regular button or dropdown button
if not item.dropdown:
self._art.DrawButton(dc, self, item, item_rect)
else:
self._art.DrawDropDownButton(dc, self, item, item_rect)
elif item.kind == ITEM_CHECK:
# draw a regular toggle button or a dropdown one
if not item.dropdown:
self._art.DrawButton(dc, self, item, item_rect)
else:
self._art.DrawDropDownButton(dc, self, item, item_rect)
elif item.kind == ITEM_RADIO:
# draw a toggle button
self._art.DrawButton(dc, self, item, item_rect)
elif item.kind == ITEM_CONTROL:
# draw the control's label
self._art.DrawControlLabel(dc, self, item, item_rect)
# fire a signal to see if the item wants to be custom-rendered
self.OnCustomRender(dc, item, item_rect)
# paint the overflow button
if dropdown_size > 0 and self._overflow_sizer_item:
dropdown_rect = self.GetOverflowRect()
self._art.DrawOverflowButton(dc, self, dropdown_rect, self._overflow_state)
def OnEraseBackground(self, event):
"""
Handles the ``wx.EVT_ERASE_BACKGROUND`` event for L{AuiToolBar}.
:param `event`: a `wx.EraseEvent` event to be processed.
:note: This is intentionally empty, to reduce flicker.
"""
pass
def OnLeftDown(self, event):
"""
Handles the ``wx.EVT_LEFT_DOWN`` event for L{AuiToolBar}.
:param `event`: a `wx.MouseEvent` event to be processed.
"""
cli_rect = wx.RectPS(wx.Point(0, 0), self.GetClientSize())
self.StopPreviewTimer()
if self._gripper_sizer_item:
gripper_rect = wx.Rect(*self._gripper_sizer_item.GetRect())
if gripper_rect.Contains(event.GetPosition()):
# find aui manager
manager = self.GetAuiManager()
if not manager:
return
x_drag_offset = event.GetX() - gripper_rect.GetX()
y_drag_offset = event.GetY() - gripper_rect.GetY()
clientPt = wx.Point(*event.GetPosition())
screenPt = self.ClientToScreen(clientPt)
managedWindow = manager.GetManagedWindow()
managerClientPt = managedWindow.ScreenToClient(screenPt)
# gripper was clicked
manager.OnGripperClicked(self, managerClientPt, wx.Point(x_drag_offset, y_drag_offset))
return
if self._overflow_sizer_item:
overflow_rect = self.GetOverflowRect()
if self._art and self._overflow_visible and overflow_rect.Contains(event.GetPosition()):
e = AuiToolBarEvent(wxEVT_COMMAND_AUITOOLBAR_OVERFLOW_CLICK, -1)
e.SetEventObject(self)
e.SetToolId(-1)
e.SetClickPoint(event.GetPosition())
processed = self.ProcessEvent(e)
if processed:
self.DoIdleUpdate()
else:
overflow_items = []
# add custom overflow prepend items, if any
count = len(self._custom_overflow_prepend)
for i in xrange(count):
overflow_items.append(self._custom_overflow_prepend[i])
# only show items that don't fit in the dropdown
count = len(self._items)
for i in xrange(count):
if not self.GetToolFitsByIndex(i):
overflow_items.append(self._items[i])
# add custom overflow append items, if any
count = len(self._custom_overflow_append)
for i in xrange(count):
overflow_items.append(self._custom_overflow_append[i])
res = self._art.ShowDropDown(self, overflow_items)
self._overflow_state = 0
self.Refresh(False)
if res != -1:
e = wx.CommandEvent(wx.wxEVT_COMMAND_MENU_SELECTED, res)
e.SetEventObject(self)
if not self.GetParent().ProcessEvent(e):
tool = self.FindTool(res)
if tool:
state = (tool.state & AUI_BUTTON_STATE_CHECKED and [True] or [False])[0]
self.ToggleTool(res, not state)
return
self._dragging = False
self._action_pos = wx.Point(*event.GetPosition())
self._action_item = self.FindToolForPosition(*event.GetPosition())
if self._action_item:
if self._action_item.state & AUI_BUTTON_STATE_DISABLED:
self._action_pos = wx.Point(-1, -1)
self._action_item = None
return
self.SetPressedItem(self._action_item)
# fire the tool dropdown event
e = AuiToolBarEvent(wxEVT_COMMAND_AUITOOLBAR_TOOL_DROPDOWN, self._action_item.id)
e.SetEventObject(self)
e.SetToolId(self._action_item.id)
e.SetDropDownClicked(False)
mouse_x, mouse_y = event.GetX(), event.GetY()
rect = wx.Rect(*self._action_item.sizer_item.GetRect())
if self._action_item.dropdown:
if (self._action_item.orientation == AUI_TBTOOL_HORIZONTAL and \
mouse_x >= (rect.x+rect.width-BUTTON_DROPDOWN_WIDTH-1) and \
mouse_x < (rect.x+rect.width)) or \
(self._action_item.orientation != AUI_TBTOOL_HORIZONTAL and \
mouse_y >= (rect.y+rect.height-BUTTON_DROPDOWN_WIDTH-1) and \
mouse_y < (rect.y+rect.height)):
e.SetDropDownClicked(True)
e.SetClickPoint(event.GetPosition())
e.SetItemRect(rect)
self.ProcessEvent(e)
self.DoIdleUpdate()
def OnLeftUp(self, event):
"""
Handles the ``wx.EVT_LEFT_UP`` event for L{AuiToolBar}.
:param `event`: a `wx.MouseEvent` event to be processed.
"""
self.SetPressedItem(None)
hit_item = self.FindToolForPosition(*event.GetPosition())
if hit_item and not hit_item.state & AUI_BUTTON_STATE_DISABLED:
self.SetHoverItem(hit_item)
if self._dragging:
# reset drag and drop member variables
self._dragging = False
self._action_pos = wx.Point(-1, -1)
self._action_item = None
else:
if self._action_item and hit_item == self._action_item:
self.SetToolTipString("")
if hit_item.kind in [ITEM_CHECK, ITEM_RADIO]:
toggle = not (self._action_item.state & AUI_BUTTON_STATE_CHECKED)
self.ToggleTool(self._action_item.id, toggle)
# repaint immediately
self.Refresh(False)
self.Update()
e = wx.CommandEvent(wx.wxEVT_COMMAND_MENU_SELECTED, self._action_item.id)
e.SetEventObject(self)
e.SetInt(toggle)
self._action_pos = wx.Point(-1, -1)
self._action_item = None
self.ProcessEvent(e)
self.DoIdleUpdate()
else:
if self._action_item.id == ID_RESTORE_FRAME:
# find aui manager
manager = self.GetAuiManager()
if not manager:
return
pane = manager.GetPane(self)
e = framemanager.AuiManagerEvent(framemanager.wxEVT_AUI_PANE_MIN_RESTORE)
e.SetManager(manager)
e.SetPane(pane)
manager.ProcessEvent(e)
self.DoIdleUpdate()
else:
e = wx.CommandEvent(wx.wxEVT_COMMAND_MENU_SELECTED, self._action_item.id)
e.SetEventObject(self)
self.ProcessEvent(e)
self.DoIdleUpdate()
# reset drag and drop member variables
self._dragging = False
self._action_pos = wx.Point(-1, -1)
self._action_item = None
def OnRightDown(self, event):
"""
Handles the ``wx.EVT_RIGHT_DOWN`` event for L{AuiToolBar}.
:param `event`: a `wx.MouseEvent` event to be processed.
"""
cli_rect = wx.RectPS(wx.Point(0, 0), self.GetClientSize())
if self._gripper_sizer_item:
gripper_rect = self._gripper_sizer_item.GetRect()
if gripper_rect.Contains(event.GetPosition()):
return
if self._overflow_sizer_item:
dropdown_size = self._art.GetElementSize(AUI_TBART_OVERFLOW_SIZE)
if dropdown_size > 0 and event.m_x > cli_rect.width - dropdown_size and \
event.m_y >= 0 and event.m_y < cli_rect.height and self._art:
return
self._action_pos = wx.Point(*event.GetPosition())
self._action_item = self.FindToolForPosition(*event.GetPosition())
if self._action_item:
if self._action_item.state & AUI_BUTTON_STATE_DISABLED:
self._action_pos = wx.Point(-1, -1)
self._action_item = None
return
def OnRightUp(self, event):
"""
Handles the ``wx.EVT_RIGHT_UP`` event for L{AuiToolBar}.
:param `event`: a `wx.MouseEvent` event to be processed.
"""
hit_item = self.FindToolForPosition(*event.GetPosition())
if self._action_item and hit_item == self._action_item:
e = AuiToolBarEvent(wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK, self._action_item.id)
e.SetEventObject(self)
e.SetToolId(self._action_item.id)
e.SetClickPoint(self._action_pos)
self.ProcessEvent(e)
self.DoIdleUpdate()
else:
# right-clicked on the invalid area of the toolbar
e = AuiToolBarEvent(wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK, -1)
e.SetEventObject(self)
e.SetToolId(-1)
e.SetClickPoint(self._action_pos)
self.ProcessEvent(e)
self.DoIdleUpdate()
# reset member variables
self._action_pos = wx.Point(-1, -1)
self._action_item = None
def OnMiddleDown(self, event):
"""
Handles the ``wx.EVT_MIDDLE_DOWN`` event for L{AuiToolBar}.
:param `event`: a `wx.MouseEvent` event to be processed.
"""
cli_rect = wx.RectPS(wx.Point(0, 0), self.GetClientSize())
if self._gripper_sizer_item:
gripper_rect = self._gripper_sizer_item.GetRect()
if gripper_rect.Contains(event.GetPosition()):
return
if self._overflow_sizer_item:
dropdown_size = self._art.GetElementSize(AUI_TBART_OVERFLOW_SIZE)
if dropdown_size > 0 and event.m_x > cli_rect.width - dropdown_size and \
event.m_y >= 0 and event.m_y < cli_rect.height and self._art:
return
self._action_pos = wx.Point(*event.GetPosition())
self._action_item = self.FindToolForPosition(*event.GetPosition())
if self._action_item:
if self._action_item.state & AUI_BUTTON_STATE_DISABLED:
self._action_pos = wx.Point(-1, -1)
self._action_item = None
return
def OnMiddleUp(self, event):
"""
Handles the ``wx.EVT_MIDDLE_UP`` event for L{AuiToolBar}.
:param `event`: a `wx.MouseEvent` event to be processed.
"""
hit_item = self.FindToolForPosition(*event.GetPosition())
if self._action_item and hit_item == self._action_item:
if hit_item.kind == ITEM_NORMAL:
e = AuiToolBarEvent(wxEVT_COMMAND_AUITOOLBAR_MIDDLE_CLICK, self._action_item.id)
e.SetEventObject(self)
e.SetToolId(self._action_item.id)
e.SetClickPoint(self._action_pos)
self.ProcessEvent(e)
self.DoIdleUpdate()
# reset member variables
self._action_pos = wx.Point(-1, -1)
self._action_item = None
def OnMotion(self, event):
"""
Handles the ``wx.EVT_MOTION`` event for L{AuiToolBar}.
:param `event`: a `wx.MouseEvent` event to be processed.
"""
# start a drag event
if not self._dragging and self._action_item != None and self._action_pos != wx.Point(-1, -1) and \
abs(event.m_x - self._action_pos.x) + abs(event.m_y - self._action_pos.y) > 5:
self.SetToolTipString("")
self._dragging = True
e = AuiToolBarEvent(wxEVT_COMMAND_AUITOOLBAR_BEGIN_DRAG, self.GetId())
e.SetEventObject(self)
e.SetToolId(self._action_item.id)
self.ProcessEvent(e)
self.DoIdleUpdate()
return
hit_item = self.FindToolForPosition(*event.GetPosition())
if hit_item:
if not hit_item.state & AUI_BUTTON_STATE_DISABLED:
self.SetHoverItem(hit_item)
else:
self.SetHoverItem(None)
else:
# no hit item, remove any hit item
self.SetHoverItem(hit_item)
# figure out tooltips
packing_hit_item = self.FindToolForPositionWithPacking(*event.GetPosition())
if packing_hit_item:
if packing_hit_item != self._tip_item:
self._tip_item = packing_hit_item
if packing_hit_item.short_help != "":
self.StartPreviewTimer()
self.SetToolTipString(packing_hit_item.short_help)
else:
self.SetToolTipString("")
self.StopPreviewTimer()
else:
self.SetToolTipString("")
self._tip_item = None
self.StopPreviewTimer()
# if we've pressed down an item and we're hovering
# over it, make sure it's state is set to pressed
if self._action_item:
if self._action_item == hit_item:
self.SetPressedItem(self._action_item)
else:
self.SetPressedItem(None)
# figure out the dropdown button state (are we hovering or pressing it?)
self.RefreshOverflowState()
def OnLeaveWindow(self, event):
"""
Handles the ``wx.EVT_LEAVE_WINDOW`` event for L{AuiToolBar}.
:param `event`: a `wx.MouseEvent` event to be processed.
"""
self.RefreshOverflowState()
self.SetHoverItem(None)
self.SetPressedItem(None)
self._tip_item = None
self.StopPreviewTimer()
def OnSetCursor(self, event):
"""
Handles the ``wx.EVT_SET_CURSOR`` event for L{AuiToolBar}.
:param `event`: a `wx.SetCursorEvent` event to be processed.
"""
cursor = wx.NullCursor
if self._gripper_sizer_item:
gripper_rect = self._gripper_sizer_item.GetRect()
if gripper_rect.Contains((event.GetX(), event.GetY())):
cursor = wx.StockCursor(wx.CURSOR_SIZING)
event.SetCursor(cursor)
def OnCustomRender(self, dc, item, rect):
"""
Handles custom render for single L{AuiToolBar} items.
:param `dc`: a `wx.DC` device context;
:param `item`: an instance of L{AuiToolBarItem};
:param `rect`: the toolbar item rect.
:note: This method must be overridden to provide custom rendering of items.
"""
pass
def IsPaneMinimized(self):
""" Returns whether this L{AuiToolBar} contains a minimized pane tool. """
manager = self.GetAuiManager()
if not manager:
return False
if manager.GetAGWFlags() & AUI_MGR_PREVIEW_MINIMIZED_PANES == 0:
# No previews here
return False
self_name = manager.GetPane(self).name
if not self_name.endswith("_min"):
# Wrong tool name
return False
return self_name[0:-4]
def StartPreviewTimer(self):
""" Starts a timer in L{AuiManager} to slide-in/slide-out the minimized pane. """
self_name = self.IsPaneMinimized()
if not self_name:
return
manager = self.GetAuiManager()
manager.StartPreviewTimer(self)
def StopPreviewTimer(self):
""" Stops a timer in {AuiManager} to slide-in/slide-out the minimized pane. """
self_name = self.IsPaneMinimized()
if not self_name:
return
manager = self.GetAuiManager()
manager.StopPreviewTimer()
|