# --------------------------------------------------------------------------- #
# BUTTONPANEL Widget wxPython IMPLEMENTATION
#
# Original C++ Code From Eran. You Can Find It At:
#
# http://wxforum.shadonet.com/viewtopic.php?t=6619
#
# License: wxWidgets license
#
#
# Python Code By:
#
# Andrea Gavana, @ 02 Oct 2006
# Latest Revision: 17 Aug 2011, 15.00 GMT
#
#
# For All Kind Of Problems, Requests Of Enhancements And Bug Reports, Please
# Write To Me At:
#
# andrea.gavana@gmail.com
# andrea.gavana@maerskoil.com
#
# Or, Obviously, To The wxPython Mailing List!!!
#
#
# End Of Comments
# --------------------------------------------------------------------------- #
"""
A custom panel class with gradient background shading with the possibility to
add buttons and controls still respecting the gradient background.
Description
===========
With L{ButtonPanel} class you have a panel with gradient colouring
on it and with the possibility to place some buttons on it. Using a
standard panel with normal `wx.Buttons` leads to an ugly result: the
buttons are placed correctly on the panel - but with grey area around
them. Gradient colouring is kept behind the images - this was achieved
due to the PNG format and the transparency of the bitmaps.
The image are functioning like a buttons and can be caught in your
code using the usual::
self.Bind(wx.EVT_BUTTON, self.OnButton)
method.
The control is generic, and support theming (well, I tested it under
Windows with the three defauls themes: grey, blue, silver and the
classic look).
Usage
=====
L{ButtonPanel} supports 4 alignments: left, right, top, bottom, which have a
different meaning and behavior with respect to `wx.Toolbar`. The easiest
thing is to try the demo to understand, but I'll try to explain how it works.
**CASE 1**: L{ButtonPanel} has a main caption text.
- Left alignment means L{ButtonPanel} is horizontal, with the text aligned to the
left. When you shrink the demo frame, if there is not enough room for all
the controls to be shown, the controls closest to the text are hidden;
- Right alignment means L{ButtonPanel} is horizontal, with the text aligned to the
right. Item layout as above;
- Top alignment means L{ButtonPanel} is vertical, with the text aligned to the top.
Item layout as above;
- Bottom alignment means L{ButtonPanel} is vertical, with the text aligned to the
bottom. Item layout as above.
**CASE 2**: L{ButtonPanel} has **no** main caption text.
- In this case, left and right alignment are the same (as top and bottom are the same),
but the layout strategy changes: now if there is not enough room for all the controls
to be shown, the last added items are hidden ("last" means on the far right for an
horizontal L{ButtonPanel} and far bottom for a vertical L{ButtonPanel}).
Usage example::
import wx
import wx.lib.agw.buttonpanel as BP
class MyFrame(wx.Frame):
def __init__(self, parent, id=-1, title="ButtonPanel", pos=wx.DefaultPosition,
size=(800, 600), style=wx.DEFAULT_FRAME_STYLE):
wx.Frame.__init__(self, parent, id, title, pos, size, style)
mainPanel = wx.Panel(self, -1)
self.logtext = wx.TextCtrl(mainPanel, -1, "", style=wx.TE_MULTILINE)
vSizer = wx.BoxSizer(wx.VERTICAL)
mainPanel.SetSizer(vSizer)
titleBar = BP.ButtonPanel(mainPanel, -1, "A Simple Test & Demo")
btn1 = BP.ButtonInfo(titleBar, wx.NewId(), wx.Bitmap("png4.png", wx.BITMAP_TYPE_PNG))
titleBar.AddButton(btn1)
self.Bind(wx.EVT_BUTTON, self.OnButton, btn1)
btn2 = BP.ButtonInfo(titleBar, wx.NewId(), wx.Bitmap("png3.png", wx.BITMAP_TYPE_PNG))
titleBar.AddButton(btn2)
self.Bind(wx.EVT_BUTTON, self.OnButton, btn2)
btn3 = BP.ButtonInfo(titleBar, wx.NewId(), wx.Bitmap("png2.png", wx.BITMAP_TYPE_PNG))
titleBar.AddButton(btn3)
self.Bind(wx.EVT_BUTTON, self.OnButton, btn3)
btn4 = BP.ButtonInfo(titleBar, wx.NewId(), wx.Bitmap("png1.png", wx.BITMAP_TYPE_PNG))
titleBar.AddButton(btn4)
self.Bind(wx.EVT_BUTTON, self.OnButton, btn4)
vSizer.Add(titleBar, 0, wx.EXPAND)
vSizer.Add((20, 20))
vSizer.Add(self.logtext, 1, wx.EXPAND|wx.ALL, 5)
titleBar.DoLayout()
vSizer.Layout()
def OnButton(self, event):
''' Handler for the ``wx.EVT_BUTTON`` event. '''
obj = event.GetEventObject()
# This will print the button label
print obj.GetText()
# our normal wxApp-derived class, as usual
app = wx.PySimpleApp()
frame = MyFrame(None)
app.SetTopWindow(frame)
frame.Show()
app.MainLoop()
Window Styles
=============
This class supports the following window styles:
==================== =========== ==================================================
Window Styles Hex Value Description
==================== =========== ==================================================
``BP_DEFAULT_STYLE`` 0x1 L{ButtonPanel} has a plain solid background.
``BP_USE_GRADIENT`` 0x2 L{ButtonPanel} has a gradient shading background.
==================== =========== ==================================================
Events Processing
=================
This class processes the following events:
================= ==================================================
Event Name Description
================= ==================================================
``wx.EVT_BUTTON`` Process a `wx.wxEVT_COMMAND_BUTTON_CLICKED` event, when a button is clicked.
================= ==================================================
License And Version
===================
L{ButtonPanel} is distributed under the wxPython license.
Latest Revision: Andrea Gavana @ 17 Aug 2011, 15.00 GMT
Version 0.6.
"""
import wx
# Some constants to tune the BPArt class
BP_BACKGROUND_COLOUR = 0
""" Background brush colour when no gradient shading exists. """
BP_GRADIENT_COLOUR_FROM = 1
""" Starting gradient colour, used only when ``BP_USE_GRADIENT`` style is applied. """
BP_GRADIENT_COLOUR_TO = 2
""" Ending gradient colour, used only when ``BP_USE_GRADIENT`` style is applied. """
BP_BORDER_COLOUR = 3
""" Pen colour to paint the border of L{ButtonPanel}. """
BP_TEXT_COLOUR = 4
""" Main L{ButtonPanel} caption colour. """
BP_BUTTONTEXT_COLOUR = 5
""" Text colour for buttons with text. """
BP_BUTTONTEXT_INACTIVE_COLOUR = 6
""" Text colour for inactive buttons with text. """
BP_SELECTION_BRUSH_COLOUR = 7
""" Brush colour to be used when hovering or selecting a button. """
BP_SELECTION_PEN_COLOUR = 8
""" Pen colour to be used when hovering or selecting a button. """
BP_SEPARATOR_COLOUR = 9
""" Pen colour used to paint the separators. """
BP_TEXT_FONT = 10
""" Font of the L{ButtonPanel} main caption. """
BP_BUTTONTEXT_FONT = 11
""" Text font for the buttons with text. """
BP_BUTTONTEXT_ALIGN_BOTTOM = 12
""" Flag that indicates the image and text in buttons is stacked. """
BP_BUTTONTEXT_ALIGN_RIGHT = 13
""" Flag that indicates the text is shown alongside the image in buttons with text. """
BP_SEPARATOR_SIZE = 14
""" Separator size. NB: This is not the line width, but the sum of the space before and after the separator line plus the width of the line. """
BP_MARGINS_SIZE = 15
""" Size of the left/right margins in L{ButtonPanel} (top/bottom for vertically aligned L{ButtonPanel})."""
BP_BORDER_SIZE = 16
""" Size of the border. """
BP_PADDING_SIZE = 17
""" Inter-tool separator size. """
# Caption Gradient Type
BP_GRADIENT_NONE = 0
""" No gradient shading should be used to paint the background. """
BP_GRADIENT_VERTICAL = 1
""" Vertical gradient shading should be used to paint the background. """
BP_GRADIENT_HORIZONTAL = 2
""" Horizontal gradient shading should be used to paint the background. """
# Flags for HitTest() method
BP_HT_BUTTON = 200
""" This flag indicates that the user has hit a button inside L{ButtonPanel}. """
BP_HT_NONE = 201
""" This flag indicates that no buttons were hit inside L{ButtonPanel}. """
# Alignment of buttons in the panel
BP_ALIGN_RIGHT = 1
""" Aligns the buttons to the right (for an horizontal L{ButtonPanel}). """
BP_ALIGN_LEFT = 2
""" Aligns the buttons to the left (for an horizontal L{ButtonPanel}). """
BP_ALIGN_TOP = 4
""" Aligns the buttons at the top (for a vertical L{ButtonPanel}). """
BP_ALIGN_BOTTOM = 8
""" Aligns the buttons at the bottom (for a vertical L{ButtonPanel}). """
# ButtonPanel styles
BP_DEFAULT_STYLE = 1
""" L{ButtonPanel} has a plain solid background. """
BP_USE_GRADIENT = 2
""" L{ButtonPanel} has a gradient shading background. """
# Delay used to cancel the longHelp in the statusbar field
_DELAY = 3000
# Check for the new method in 2.7 (not present in 2.6.3.3)
if wx.VERSION_STRING < "2.7":
wx.Rect.Contains = lambda self, point: wx.Rect.Inside(self, point)
[docs]def BrightenColour(colour, factor):
"""
Brighten the input colour by a factor.
:param `colour`: a valid `wx.Colour` instance;
:param integer `factor`: the factor by which the input colour should be brightened.
:return: An instance of `wx.Colour`, a brightened version of the input `colour`.
"""
val = colour.Red()*factor
if val > 255:
red = 255
else:
red = val
val = colour.Green()*factor
if val > 255:
green = 255
else:
green = val
val = colour.Blue()*factor
if val > 255:
blue = 255
else:
blue = val
return wx.Colour(red, green, blue)
# ----------------------------------------------------------------------------
[docs]def MakeDisabledBitmap(original):
"""
Creates a disabled-looking bitmap starting from the input one.
:param `original`: an instance of `wx.Bitmap` to be greyed-out.
:return: A greyed-out representation of the input bitmap, an instance of `wx.Bitmap`.
"""
img = original.ConvertToImage()
return wx.BitmapFromImage(img.ConvertToGreyscale())
# ---------------------------------------------------------------------------- #
# Class BPArt
# Handles all the drawings for buttons, separators and text and allows the
# programmer to set colours, sizes and gradient shadings for ButtonPanel
# ---------------------------------------------------------------------------- #
[docs]class BPArt(object):
"""
L{BPArt} is an art provider class which does all of the drawing for L{ButtonPanel}.
This allows the library caller to customize the L{BPArt} or to completely replace
all drawing with custom BPArts.
"""
[docs] def __init__(self, parentStyle):
"""
Default class constructor.
:param integer `parentStyle`: the window style for L{ButtonPanel}.
"""
base_colour = wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DFACE)
self._background_brush = wx.Brush(base_colour, wx.SOLID)
self._gradient_colour_to = wx.WHITE
self._gradient_colour_from = wx.SystemSettings_GetColour(wx.SYS_COLOUR_ACTIVECAPTION)
if parentStyle & BP_USE_GRADIENT:
self._border_pen = wx.Pen(wx.WHITE, 3)
self._caption_text_colour = wx.WHITE
self._buttontext_colour = wx.Colour(70, 143, 255)
self._separator_pen = wx.Pen(BrightenColour(self._gradient_colour_from, 1.4))
self._gradient_type = BP_GRADIENT_VERTICAL
else:
self._border_pen = wx.Pen(BrightenColour(base_colour, 0.9), 3)
self._caption_text_colour = wx.BLACK
self._buttontext_colour = wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNTEXT)
self._separator_pen = wx.Pen(BrightenColour(base_colour, 0.9))
self._gradient_type = BP_GRADIENT_NONE
self._buttontext_inactive_colour = wx.SystemSettings_GetColour(wx.SYS_COLOUR_GRAYTEXT)
self._selection_brush = wx.Brush(wx.Colour(225, 225, 255))
self._selection_pen = wx.Pen(wx.SystemSettings_GetColour(wx.SYS_COLOUR_ACTIVECAPTION))
sysfont = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT)
self._caption_font = wx.Font(sysfont.GetPointSize(), wx.DEFAULT, wx.NORMAL, wx.BOLD,
False, sysfont.GetFaceName())
self._buttontext_font = wx.Font(sysfont.GetPointSize(), wx.DEFAULT, wx.NORMAL, wx.NORMAL,
False, sysfont.GetFaceName())
self._separator_size = 7
self._margins_size = wx.Size(6, 6)
self._caption_border_size = 3
self._padding_size = wx.Size(6, 6)
[docs] def GetMetric(self, id):
"""
Returns the option value for the specified size `id`.
:param integer `id`: the identification bit for the size value. This can be one of the
following bits:
============================== ======= =====================================
Size Id Value Description
============================== ======= =====================================
``BP_SEPARATOR_SIZE`` 14 Separator size. Note: This is not the line width, but the sum of the space before and after the separator line plus the width of the line
``BP_MARGINS_SIZE`` 15 Size of the left/right margins in L{ButtonPanel} (top/bottom for vertically aligned L{ButtonPanel})
``BP_BORDER_SIZE`` 16 Size of the border
``BP_PADDING_SIZE`` 17 Inter-tool separator size
============================== ======= =====================================
:return: An integer representing the option value for the input `id`.
:raise: `Exception` if the `id` is not recognized.
"""
if id == BP_SEPARATOR_SIZE:
return self._separator_size
elif id == BP_MARGINS_SIZE:
return self._margins_size
elif id == BP_BORDER_SIZE:
return self._caption_border_size
elif id == BP_PADDING_SIZE:
return self._padding_size
else:
raise Exception("\nERROR: Invalid Metric Ordinal. ")
[docs] def SetMetric(self, id, new_val):
"""
Sets the option value for the specified size `id`.
:param integer `id`: the identification bit for the size value;
:param input`new_val`: the new value for the size.
:raise: `Exception` if the `id` is not recognized.
:see: L{GetMetric} for a list of meaningful size ids.
"""
if id == BP_SEPARATOR_SIZE:
self._separator_size = new_val
elif id == BP_MARGINS_SIZE:
self._margins_size = new_val
elif id == BP_BORDER_SIZE:
self._caption_border_size = new_val
self._border_pen.SetWidth(new_val)
elif id == BP_PADDING_SIZE:
self._padding_size = new_val
else:
raise Exception("\nERROR: Invalid Metric Ordinal. ")
[docs] def GetColour(self, id):
"""
Returns the option value for the specified colour `id`.
:param internal`id`: the identification bit for the colour value. This can be one of the
following bits:
================================== ======= =====================================
Colour Id Value Description
================================== ======= =====================================
``BP_BACKGROUND_COLOUR`` 0 Background brush colour when no gradient shading exists
``BP_GRADIENT_COLOUR_FROM`` 1 Starting gradient colour, used only when ``BP_USE_GRADIENT`` style is applied
``BP_GRADIENT_COLOUR_TO`` 2 Ending gradient colour, used only when ``BP_USE_GRADIENT`` style is applied
``BP_BORDER_COLOUR`` 3 Pen colour to paint the border of L{ButtonPanel}
``BP_TEXT_COLOUR`` 4 Main L{ButtonPanel} caption colour
``BP_BUTTONTEXT_COLOUR`` 5 Text colour for buttons with text
``BP_BUTTONTEXT_INACTIVE_COLOUR`` 6 Text colour for inactive buttons with text
``BP_SELECTION_BRUSH_COLOUR`` 7 Brush colour to be used when hovering or selecting a button
``BP_SELECTION_PEN_COLOUR`` 8 Pen colour to be used when hovering or selecting a button
``BP_SEPARATOR_COLOUR`` 9 Pen colour used to paint the separators
================================== ======= =====================================
:return: An instance of `wx.Colour` for the input `id`.
:raise: `Exception` if the `id` is not recognized.
"""
if id == BP_BACKGROUND_COLOUR:
return self._background_brush.GetColour()
elif id == BP_GRADIENT_COLOUR_FROM:
return self._gradient_colour_from
elif id == BP_GRADIENT_COLOUR_TO:
return self._gradient_colour_to
elif id == BP_BORDER_COLOUR:
return self._border_pen.GetColour()
elif id == BP_TEXT_COLOUR:
return self._caption_text_colour
elif id == BP_BUTTONTEXT_COLOUR:
return self._buttontext_colour
elif id == BP_BUTTONTEXT_INACTIVE_COLOUR:
return self._buttontext_inactive_colour
elif id == BP_SELECTION_BRUSH_COLOUR:
return self._selection_brush.GetColour()
elif id == BP_SELECTION_PEN_COLOUR:
return self._selection_pen.GetColour()
elif id == BP_SEPARATOR_COLOUR:
return self._separator_pen.GetColour()
else:
raise Exception("\nERROR: Invalid Colour Ordinal. ")
[docs] def SetColour(self, id, colour):
"""
Sets the option value for the specified colour `id`.
:param integer `id`: the identification bit for the colour value;
:param `colour`: the new value for the colour (a valid `wx.Colour` instance).
:raise: `Exception` if the `id` is not recognized.
:see: L{GetColour} for a list of meaningful colour ids.
"""
if id == BP_BACKGROUND_COLOUR:
self._background_brush.SetColour(colour)
elif id == BP_GRADIENT_COLOUR_FROM:
self._gradient_colour_from = colour
elif id == BP_GRADIENT_COLOUR_TO:
self._gradient_colour_to = colour
elif id == BP_BORDER_COLOUR:
self._border_pen.SetColour(colour)
elif id == BP_TEXT_COLOUR:
self._caption_text_colour = colour
elif id == BP_BUTTONTEXT_COLOUR:
self._buttontext_colour = colour
elif id == BP_BUTTONTEXT_INACTIVE_COLOUR:
self._buttontext_inactive_colour = colour
elif id == BP_SELECTION_BRUSH_COLOUR:
self._selection_brush.SetColour(colour)
elif id == BP_SELECTION_PEN_COLOUR:
self._selection_pen.SetColour(colour)
elif id == BP_SEPARATOR_COLOUR:
self._separator_pen.SetColour(colour)
else:
raise Exception("\nERROR: Invalid Colour Ordinal. ")
GetColor = GetColour
SetColor = SetColour
[docs] def GetFont(self, id):
"""
Returns the option value for the specified font `id`.
:param integer `id`: the identification bit for the font value. This can be one of the
following bits:
============================== ======= =====================================
Size Id Value Description
============================== ======= =====================================
``BP_TEXT_FONT`` 10 Font of the L{ButtonPanel} main caption
``BP_BUTTONTEXT_FONT`` 11 Text font for the buttons with text
============================== ======= =====================================
:return: An instance of `wx.Font` for the input `id`.
:raise: `Exception` if the `id` is not recognized.
"""
if id == BP_TEXT_FONT:
return self._caption_font
elif id == BP_BUTTONTEXT_FONT:
return self._buttontext_font
return wx.NoneFont
[docs] def SetFont(self, id, font):
"""
Sets the option value for the specified font `id`.
:param integer `id`: the identification bit for the font value;
:param `colour`: the new value for the font (a valid `wx.Font` instance).
:raise: `Exception` if the `id` is not recognized.
:see: L{GetFont} for a list of meaningful font ids.
"""
if id == BP_TEXT_FONT:
self._caption_font = font
elif id == BP_BUTTONTEXT_FONT:
self._buttontext_font = font
[docs] def SetGradientType(self, gradient):
"""
Sets the gradient type for L{BPArt} drawings.
:param integer `gradient`: can be one of the following bits:
============================ ======= ============================
Gradient Type Value Description
============================ ======= ============================
``BP_GRADIENT_NONE`` 0 No gradient shading should be used to paint the background
``BP_GRADIENT_VERTICAL`` 1 Vertical gradient shading should be used to paint the background
``BP_GRADIENT_HORIZONTAL`` 2 Horizontal gradient shading should be used to paint the background
============================ ======= ============================
"""
self._gradient_type = gradient
[docs] def GetGradientType(self):
"""
Returns the gradient type for L{BPArt} drawings.
:return: An integer representing the gradient type.
:see: L{SetGradientType} for a list of possible gradient types.
"""
return self._gradient_type
[docs] def DrawSeparator(self, dc, rect, isVertical):
"""
Draws a separator in L{ButtonPanel}.
:param `dc`: an instance of `wx.DC`;
:param `wx.Rect` `rect`: the separator client rectangle;
:param bool `isVertical`: ``True`` if L{ButtonPanel} is in vertical orientation,
``False`` otherwise.
"""
dc.SetPen(self._separator_pen)
if isVertical:
ystart = yend = rect.y + rect.height/2
xstart = int(rect.x + 1.5*self._caption_border_size)
xend = int(rect.x + rect.width - 1.5*self._caption_border_size)
dc.DrawLine(xstart, ystart, xend, yend)
else:
xstart = xend = rect.x + rect.width/2
ystart = int(rect.y + 1.5*self._caption_border_size)
yend = int(rect.y + rect.height - 1.5*self._caption_border_size)
dc.DrawLine(xstart, ystart, xend, yend)
[docs] def DrawCaption(self, dc, rect, captionText):
"""
Draws the main caption text in L{ButtonPanel}.
:param `dc`: an instance of `wx.DC`;
:param `wx.Rect` `rect`: the main caption text rectangle;
:param string `captionText`: the caption text string.
"""
textColour = self._caption_text_colour
textFont = self._caption_font
padding = self._padding_size
dc.SetTextForeground(textColour)
dc.SetFont(textFont)
dc.DrawText(captionText, rect.x + padding.x, rect.y+padding.y)
[docs] def DrawButton(self, dc, rect, buttonBitmap, isVertical, buttonStatus,
isToggled, textAlignment, text=""):
"""
Draws a button in L{ButtonPanel}, together with its text (if any).
:param `dc`: an instance of `wx.DC`;
:param `wx.Rect` `rect`: the button client rectangle;
:param `wx.Bitmap` `buttonBitmap`: the bitmap associated with the button;
:param bool `isVertical`: ``True`` if L{ButtonPanel} is in vertical orientation,
``False`` otherwise;
:param string `buttonStatus`: one of "Normal", "Toggled", "Pressed", "Disabled" or "Hover";
:param bool `isToggled`: whether the button is toggled or not;
:param integer `textAlignment`: the text alignment inside the button;
:param string `text`: the button label.
"""
bmpxsize, bmpysize = buttonBitmap.GetWidth(), buttonBitmap.GetHeight()
dx = dy = focus = 0
borderw = self._caption_border_size
padding = self._padding_size
buttonFont = self._buttontext_font
dc.SetFont(buttonFont)
if isVertical:
rect = wx.Rect(borderw, rect.y, rect.width-2*borderw, rect.height)
if text != "":
textW, textH = dc.GetTextExtent(text)
if textAlignment == BP_BUTTONTEXT_ALIGN_RIGHT:
fullExtent = bmpxsize + padding.x/2 + textW
bmpypos = rect.y + (rect.height - bmpysize)/2
bmpxpos = rect.x + (rect.width - fullExtent)/2
textxpos = bmpxpos + padding.x/2 + bmpxsize
textypos = bmpypos + (bmpysize - textH)/2
else:
bmpxpos = rect.x + (rect.width - bmpxsize)/2
bmpypos = rect.y + padding.y
textxpos = rect.x + (rect.width - textW)/2
textypos = bmpypos + bmpysize + padding.y/2
else:
bmpxpos = rect.x + (rect.width - bmpxsize)/2
bmpypos = rect.y + (rect.height - bmpysize)/2
else:
rect = wx.Rect(rect.x, borderw, rect.width, rect.height-2*borderw)
if text != "":
textW, textH = dc.GetTextExtent(text)
if textAlignment == BP_BUTTONTEXT_ALIGN_RIGHT:
fullExtent = bmpxsize + padding.x/2 + textW
bmpypos = rect.y + (rect.height - bmpysize)/2
bmpxpos = rect.x + (rect.width - fullExtent)/2
textxpos = bmpxpos + padding.x/2 + bmpxsize
textypos = bmpypos + (bmpysize - textH)/2
else:
fullExtent = bmpysize + padding.y/2 + textH
bmpxpos = rect.x + (rect.width - bmpxsize)/2
bmpypos = rect.y + (rect.height - fullExtent)/2
textxpos = rect.x + (rect.width - textW)/2
textypos = bmpypos + bmpysize + padding.y/2
else:
bmpxpos = rect.x + (rect.width - bmpxsize)/2
bmpypos = rect.y + (rect.height - bmpysize)/2
# Draw a button
# [ Padding | Text | .. Buttons .. | Padding ]
if buttonStatus in ["Pressed", "Toggled", "Hover"]:
dc.SetBrush(self._selection_brush)
dc.SetPen(self._selection_pen)
dc.DrawRoundedRectangleRect(rect, 4)
if buttonStatus == "Pressed" or isToggled:
dx = dy = 1
if buttonBitmap:
dc.DrawBitmap(buttonBitmap, bmpxpos+dx, bmpypos+dy, True)
if text != "":
isEnabled = buttonStatus != "Disabled"
self.DrawLabel(dc, text, isEnabled, textxpos+dx, textypos+dy)
[docs] def DrawLabel(self, dc, text, isEnabled, xpos, ypos):
"""
Draws the label for a button.
:param `dc`: an instance of `wx.DC`;
:param string `text`: the button label;
:param bool `isEnabled`: ``True`` if the button is enabled, ``False`` otherwise;
:param integer `xpos`: the text `x` position inside the button;
:param integer `ypos`: the text `y` position inside the button.
"""
if not isEnabled:
dc.SetTextForeground(self._buttontext_inactive_colour)
else:
dc.SetTextForeground(self._buttontext_colour)
dc.DrawText(text, xpos, ypos)
[docs] def DrawButtonPanel(self, dc, rect, style):
"""
Paint the L{ButtonPanel}'s background.
:param `dc`: an instance of `wx.DC`;
:param `wx.Rect` `rect`: the L{ButtonPanel} client rectangle;
:param integer `style`: the L{ButtonPanel} window style.
"""
if style & BP_USE_GRADIENT:
# Draw gradient colour in the backgroud of the panel
self.FillGradientColour(dc, rect)
# Draw a rectangle around the panel
backBrush = (style & BP_USE_GRADIENT and [wx.TRANSPARENT_BRUSH] or \
[self._background_brush])[0]
dc.SetBrush(backBrush)
dc.SetPen(self._border_pen)
dc.DrawRectangleRect(rect)
[docs] def FillGradientColour(self, dc, rect):
"""
Gradient fill from colour 1 to colour 2 with top to bottom or left to right.
:param `dc`: an instance of `wx.DC`;
:param `wx.Rect` `rect`: the L{ButtonPanel} client rectangle.
"""
if rect.height < 1 or rect.width < 1:
return
isVertical = self._gradient_type == BP_GRADIENT_VERTICAL
size = (isVertical and [rect.height] or [rect.width])[0]
start = (isVertical and [rect.y] or [rect.x])[0]
# calculate gradient coefficients
col2 = self._gradient_colour_from
col1 = self._gradient_colour_to
rf, gf, bf = 0, 0, 0
rstep = float((col2.Red() - col1.Red()))/float(size)
gstep = float((col2.Green() - col1.Green()))/float(size)
bstep = float((col2.Blue() - col1.Blue()))/float(size)
for coord in xrange(start, start + size):
currCol = wx.Colour(col1.Red() + rf, col1.Green() + gf, col1.Blue() + bf)
dc.SetBrush(wx.Brush(currCol, wx.SOLID))
dc.SetPen(wx.Pen(currCol))
if isVertical:
dc.DrawLine(rect.x, coord, rect.x + rect.width, coord)
else:
dc.DrawLine(coord, rect.y, coord, rect.y + rect.height)
rf += rstep
gf += gstep
bf += bstep
[docs]class StatusBarTimer(wx.Timer):
""" Timer used for deleting `wx.StatusBar` long help after ``_DELAY`` seconds."""
[docs] def __init__(self, owner):
"""
Default class constructor.
For internal use: do not call it in your code!
:param `owner`: an instance of L{ButtonPanel}.
"""
wx.Timer.__init__(self)
self._owner = owner
[docs]class Control(wx.EvtHandler):
"""
This class represents a base class for all pseudo controls used in
L{ButtonPanel}.
"""
[docs] def __init__(self, parent, size=wx.Size(-1, -1), id=wx.ID_ANY):
"""
Default class constructor.
:param `wx.Window` `parent`: the control parent object. Must not be ``None``;
: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;
:type `size`: tuple or `wx.Size`
:param integer `id`: window identifier. A value of -1 indicates a default value.
"""
wx.EvtHandler.__init__(self)
self._parent = parent
if id == wx.ID_ANY:
self._id = wx.NewId()
else:
self._id = id
self._size = size
self._isshown = True
self._focus = False
[docs] def Show(self, show=True):
"""
Shows or hide the control.
:param bool `show`: If ``True`` displays the window. Otherwise, it hides it.
"""
self._isshown = show
[docs] def Hide(self):
"""
Hides the control.
:note: This is functionally equivalent of calling L{Show} with a ``False`` input.
"""
self.Show(False)
[docs] def IsShown(self):
""" Returns ``True`` if the window is shown, ``False`` if it has been hidden. """
return self._isshown
[docs] def GetId(self):
"""
Returns the identifier of the window.
:return: An integer representing the identifier of the window.
:note: Each window has an integer identifier. If the application has not provided
one (or the default ``wx.ID_ANY``) an unique identifier with a negative value will
be generated.
"""
return self._id
[docs] def GetBestSize(self):
"""
This functions returns the best acceptable minimal size for the window. For
example, for a static control, it will be the minimal size such that the control
label is not truncated. For windows containing subwindows (typically `wx.Panel`),
the size returned by this function will be the same as the size the window would
have had after calling `Fit()`.
:return: An instance of `wx.Size`.
"""
return self._size
[docs] def Disable(self):
"""
Disables the control.
:returns: ``True`` if the window has been disabled, ``False`` if it had been
already disabled before the call to this function.
:note: This is functionally equivalent of calling L{Enable} with a ``False`` flag.
"""
return self.Enable(False)
[docs] def Enable(self, value=True):
"""
Enable or disable the window for user input.
:param bool `enable`: If ``True``, enables the window for input. If ``False``, disables the window.
:returns: ``True`` if the window has been enabled or disabled, ``False`` if nothing was
done, i.e. if the window had already been in the specified state.
:note: Note that when a parent window is disabled, all of its children are disabled as
well and they are reenabled again when the parent is.
"""
self.disabled = not value
return True
[docs] def SetFocus(self, focus=True):
"""
Sets or kills the focus on the control.
:param bool `focus`: whether the control can receive keyboard inputs or not.
"""
self._focus = focus
[docs] def HasFocus(self):
"""
Returns whether the control has the focus or not.
:return: ``True`` if the control has the focus, ``False`` otherwise.
"""
return self._focus
[docs] def OnMouseEvent(self, x, y, event):
"""
Handles the ``wx.EVT_MOUSE_EVENTS`` events for the control.
:param integer `x`: the mouse `x` position;
:param integer `y`: the mouse `y` position;
:param `event`: the `wx.MouseEvent` event to be processed.
"""
pass
[docs] def Draw(self, rect):
"""
Handles the drawing of the control.
:param `wx.Rect` `rect`: the control client rectangle.
"""
pass
[docs]class Sizer(object):
"""
This is a mix-in class to add pseudo support to `wx.Sizer`. Just create
a new class that derives from this class and `wx.Sizer` and intercepts
any methods that add to the wx sizer.
"""
[docs] def __init__(self):
"""
Default class constructor.
For internal use: do not call it in your code!
"""
self.children = [] # list of child Pseudo Controls
# Sizer doesn't use the x1,y1,x2,y2 so allow it to
# be called with or without the coordinates
[docs] def Draw(self, dc, x1=0, y1=0, x2=0, y2=0):
""" Draws all the children of the sizer. """
for item in self.children:
# use sizer coordinates rather than
# what is passed in
c = item.GetUserData()
c.Draw(dc, item.GetRect())
[docs] def GetBestSize(self):
"""
This functions returns the best acceptable minimal size for the sizer object.
:return: An instance of `wx.Size`.
"""
# this should be handled by the wx.Sizer based class
return self.GetMinSize()
# Pseudo BoxSizer
[docs]class BoxSizer(Sizer, wx.BoxSizer):
""" Pseudo-class that imitates `wx.BoxSizer`. """
[docs] def __init__(self, orient=wx.HORIZONTAL):
"""
Constructor for L{BoxSizer}.
:param integer `orient`: may be one of ``wx.VERTICAL`` or ``wx.HORIZONTAL`` for creating
either a column sizer or a row sizer.
"""
wx.BoxSizer.__init__(self, orient)
Sizer.__init__(self)
#-------------------------------------------
# sizer overrides (only called from Python)
#-------------------------------------------
# no support for user data if it's a pseudocontrol
# since that is already used
[docs] def Add(self, item, proportion=0, flag=0, border=0, userData=None):
"""
Appends a child item to the sizer.
:param `item`: the item to be added to L{BoxSizer}. Can be an instance of `wx.Window`,
`wx.Sizer` or a spacer;
:param integer `proportion`: this parameter is used in L{BoxSizer} to indicate if a child of
a sizer can change its size in the main orientation of the L{BoxSizer} - where 0
stands for not changeable and a value of more than zero is interpreted relative
to the value of other children of the same L{BoxSizer}. For example, you might have
a horizontal L{BoxSizer} with three children, two of which are supposed to change their
size with the sizer. Then the two stretchable windows would get a value of 1 each to
make them grow and shrink equally with the sizer's horizontal dimension.
:param integer `flag`: this parameter can be used to set a number of flags which can be combined using the binary OR operator ``|``.
Two main behaviours are defined using these flags. One is the border around a window: the border parameter determines the border
width whereas the flags given here determine which side(s) of the item that the border will be added. The other flags determine
how the sizer item behaves when the space allotted to the sizer changes, and is somewhat dependent on the specific kind of sizer used:
+---------------------------------------------------------------------+-----------------------------------------------------------------------------+
| Sizer Flag | Description |
+=====================================================================+=============================================================================+
| ``wx.TOP`` | These flags are used to specify which side(s) of the sizer |
+---------------------------------------------------------------------+ item the border width will apply to. |
| ``wx.BOTTOM`` | |
+---------------------------------------------------------------------+ |
| ``wx.LEFT`` | |
+---------------------------------------------------------------------+ |
| ``wx.RIGHT`` | |
+---------------------------------------------------------------------+ |
| ``wx.ALL`` | |
+---------------------------------------------------------------------+-----------------------------------------------------------------------------+
| ``wx.EXPAND`` | The item will be expanded to fill the space assigned to |
| | the item. |
+---------------------------------------------------------------------+-----------------------------------------------------------------------------+
| ``wx.SHAPED`` | The item will be expanded as much as possible while also |
| | maintaining its aspect ratio |
+---------------------------------------------------------------------+-----------------------------------------------------------------------------+
| ``wx.FIXED_MINSIZE`` | Normally `wx.Sizers` will use |
| | ``wx.Window.GetAdjustedBestSize`` to |
| | determine what the minimal size of window items should be, and will use that|
| | size to calculate the layout. This allows layouts to adjust when an item |
| | changes and its best size becomes different. If you would rather have a |
| | window item stay the size it started with then use ``wx.FIXED_MINSIZE``. |
+---------------------------------------------------------------------+-----------------------------------------------------------------------------+
| ``wx.RESERVE_SPACE_EVEN_IF_HIDDEN`` | Normally `wx.Sizers` don't allocate space for hidden windows or other items.|
| | This flag overrides this behavior so that sufficient space is allocated for |
| | the window even if it isn't visible. This makes it possible to dynamically |
| | show and hide controls without resizing parent dialog, for example. This |
| | function is new since wxWidgets version 2.8.8 |
+---------------------------------------------------------------------+-----------------------------------------------------------------------------+
| ``wx.ALIGN_CENTER`` **or** ``wx.ALIGN_CENTRE`` | The ``wx.ALIGN*`` flags allow you to specify the alignment of the item |
+---------------------------------------------------------------------+ within the space allotted to it by the sizer, adjusted for the border if |
| ``wx.ALIGN_LEFT`` | any. |
+---------------------------------------------------------------------+ |
| ``wx.ALIGN_RIGHT`` | |
+---------------------------------------------------------------------+ |
| ``wx.ALIGN_TOP`` | |
+---------------------------------------------------------------------+ |
| ``wx.ALIGN_BOTTOM`` | |
+---------------------------------------------------------------------+ |
| ``wx.ALIGN_CENTER_VERTICAL`` **or** ``wx.ALIGN_CENTRE_VERTICAL`` | |
+---------------------------------------------------------------------+ |
| ``wx.ALIGN_CENTER_HORIZONTAL`` **or** ``wx.ALIGN_CENTRE_HORIZONTAL``| |
+---------------------------------------------------------------------+-----------------------------------------------------------------------------+
:param integer `border`: determines the border width, if the flag parameter is set
to include any border flag.
:param object `userData`: Allows an extra object to be attached to the sizer item,
for use in derived classes when sizing information is more complex than the
proportion and flag will allow for.
:note: there is no support for `userData` parameter if `item` is a pseudocontrol,
since that is already used.
"""
# check to see if it's a pseudo object or sizer
if isinstance(item, Sizer):
szitem = wx.BoxSizer.Add(self, item, proportion, flag, border, item)
self.children.append(szitem)
elif isinstance(item, Control): # Control should be what ever class your controls come from
sz = item.GetBestSize()
# add a spacer to track this object
szitem = wx.BoxSizer.Add(self, sz, proportion, flag, border, item)
self.children.append(szitem)
else:
wx.BoxSizer.Add(self, item, proportion, flag, border, userData)
[docs] def Prepend(self, item, proportion=0, flag=0, border=0, userData=None):
"""
Prepends a child item to the sizer.
:see: L{Add} method for an explanation of the input parameters.
"""
# check to see if it's a pseudo object or sizer
if isinstance(item, Sizer):
szitem = wx.BoxSizer.Prepend(self, item, proportion, flag, border, item)
self.children.append(szitem)
elif isinstance(item, Control): # Control should be what ever class your controls come from
sz = item.GetBestSize()
# add a spacer to track this object
szitem = wx.BoxSizer.Prepend(self, sz, proportion, flag, border, item)
self.children.insert(0,szitem)
else:
wx.BoxSizer.Prepend(self, item, proportion, flag, border, userData)
[docs] def Insert(self, before, item, proportion=0, flag=0, border=0, userData=None, realIndex=None):
"""
Inserts a child item into the sizer.
:see: L{Add} method for an explanation of the input parameters.
"""
# check to see if it's a pseudo object or sizer
if isinstance(item, Sizer):
szitem = wx.BoxSizer.Insert(self, before, item, proportion, flag, border, item)
self.children.append(szitem)
elif isinstance(item, Control): # Control should be what ever class your controls come from
sz = item.GetBestSize()
# add a spacer to track this object
szitem = wx.BoxSizer.Insert(self, before, sz, proportion, flag, border, item)
if realIndex is not None:
self.children.insert(realIndex,szitem)
else:
self.children.insert(before,szitem)
else:
wx.BoxSizer.Insert(self, before, item, proportion, flag, border, userData)
[docs] def Remove(self, indx, pop=-1):
"""
Removes an item from the sizer and destroys it.
This method does not cause any layout or resizing to take place, call
L{BoxSizer.Layout} to update the layout on screen after removing a child from
the sizer.
:param integer `indx`: the zero-based index of an item to remove;
:param bool `pop`: whether to remove the sizer item from the list of children.
"""
if pop >= 0:
self.children.pop(pop)
wx.BoxSizer.Remove(self, indx)
[docs] def Layout(self):
"""
Call this to force layout of the children anew, e.g. after having added a
child to or removed a child (window, other sizer or space) from the sizer
while keeping the current dimension.
"""
for ii, child in enumerate(self.GetChildren()):
item = child.GetUserData()
if item and child.IsShown():
self.SetItemMinSize(ii, *item.GetBestSize())
wx.BoxSizer.Layout(self)
[docs] def Show(self, item, show=True):
"""
Shows or hides the sizer item.
:param `item`: the sizer item we want to show/hide;
:param bool `show`: ``True`` to show the item, ``False`` to hide it.
"""
child = self.GetChildren()[item]
if child and child.GetUserData():
child.GetUserData().Show(show)
wx.BoxSizer.Show(self, item, show)
# ---------------------------------------------------------------------------- #
# Class Separator
# This class holds all the information to size and draw a separator inside
# ButtonPanel
# ---------------------------------------------------------------------------- #
[docs]class Separator(Control):
"""
This class holds all the information to size and draw a separator inside
L{ButtonPanel}.
"""
[docs] def __init__(self, parent):
"""
Default class constructor.
:param `parent`: the separator parent object, an instance of L{ButtonPanel}.
"""
self._isshown = True
self._parent = parent
Control.__init__(self, parent)
[docs] def GetBestSize(self):
"""
Returns the separator best size.
:return: An instance of `wx.Size`.
"""
# 10 is completely arbitrary, but it works anyhow
if self._parent.IsVertical():
return wx.Size(10, self._parent._art.GetMetric(BP_SEPARATOR_SIZE))
else:
return wx.Size(self._parent._art.GetMetric(BP_SEPARATOR_SIZE), 10)
[docs] def Draw(self, dc, rect):
"""
Draws the separator. Actually the drawing is done in L{BPArt}.
:param `dc`: an instance of `wx.DC`;
:param `wx.Rect` `rect`: the separator client rectangle.
"""
if not self.IsShown():
return
isVertical = self._parent.IsVertical()
self._parent._art.DrawSeparator(dc, rect, isVertical)
# ---------------------------------------------------------------------------- #
# Class ButtonPanelText
# This class is used to hold data about the main caption in ButtonPanel
# ---------------------------------------------------------------------------- #
[docs]class ButtonPanelText(Control):
""" This class is used to hold data about the main caption in L{ButtonPanel}. """
[docs] def __init__(self, parent, text=""):
"""
Default class constructor.
:param `parent`: the text parent object, an instance of L{ButtonPanel};
:param string `text`: the actual main caption string.
"""
self._text = text
self._isshown = True
self._parent = parent
Control.__init__(self, parent)
[docs] def GetText(self):
"""
Returns the caption text.
:return: A string representing the caption text.
"""
return self._text
[docs] def SetText(self, text=""):
"""
Sets the caption text.
:param string `text`: the main caption string.
"""
self._text = text
[docs] def CreateDC(self):
""" Convenience function to create a `wx.DC`. """
dc = wx.ClientDC(self._parent)
textFont = self._parent._art.GetFont(BP_TEXT_FONT)
dc.SetFont(textFont)
return dc
[docs] def GetBestSize(self):
"""
Returns the best size for the main caption in L{ButtonPanel}.
:return: An instance of `wx.Size`.
"""
if self._text == "":
return wx.Size(0, 0)
dc = self.CreateDC()
rect = self._parent.GetClientRect()
tw, th = dc.GetTextExtent(self._text)
padding = self._parent._art.GetMetric(BP_PADDING_SIZE)
self._size = wx.Size(tw+2*padding.x, th+2*padding.y)
return self._size
[docs] def Draw(self, dc, rect):
"""
Draws the main caption. Actually the drawing is done in L{BPArt}.
:param `dc`: an instance of `wx.DC`;
:param `wx.Rect` `rect`: the main caption text client rectangle.
"""
if not self.IsShown():
return
captionText = self.GetText()
self._parent._art.DrawCaption(dc, rect, captionText)
# -- ButtonInfo class implementation ----------------------------------------
# This class holds information about every button that is added to
# ButtonPanel. It is an auxiliary class that you should use
# every time you add a button.
[docs]class ButtonInfo(Control):
"""
This class holds information about every button that is added to
L{ButtonPanel}. It is an auxiliary class that you should use
every time you add a button.
"""
[docs] def __init__(self, parent, id=wx.ID_ANY, bmp=wx.NullBitmap,
status="Normal", text="", kind=wx.ITEM_NORMAL,
shortHelp="", longHelp=""):
"""
Default class constructor.
:param `parent`: the parent window (L{ButtonPanel});
:param integer `id`: the button id;
:param `wx.Bitmap` `bmp`: the associated bitmap;
:param string `status`: button status ("Pressed", "Hover", "Normal", "Toggled", "Disabled");
:param string `text`: text to be displayed either below of to the right of the button;
:param integer `kind`: button kind, may be ``wx.ITEM_NORMAL`` for standard buttons or
``wx.ITEM_CHECK`` for toggle buttons;
:param string `shortHelp`: a short help to be shown in the button tooltip;
:param string `longHelp`: this string is shown in the statusbar (if any) of the parent
frame when the mouse pointer is inside the button.
"""
if id == wx.ID_ANY:
id = wx.NewId()
self._status = status
self._rect = wx.Rect()
self._text = text
self._kind = kind
self._toggle = False
self._textAlignment = BP_BUTTONTEXT_ALIGN_BOTTOM
self._shortHelp = shortHelp
self._longHelp = longHelp
if bmp and bmp.IsOk():
disabledbmp = MakeDisabledBitmap(bmp)
else:
disabledbmp = wx.NullBitmap
self._bitmaps = {"Normal": bmp, "Toggled": None, "Disabled": disabledbmp,
"Hover": None, "Pressed": None}
Control.__init__(self, parent, id=id)
[docs] def GetBestSize(self):
"""
Returns the best size for the button.
:return: An instance of `wx.Size`.
"""
xsize = self.GetBitmap().GetWidth()
ysize = self.GetBitmap().GetHeight()
if self.HasText():
# We have text in the button
dc = wx.ClientDC(self._parent)
normalFont = self._parent._art.GetFont(BP_BUTTONTEXT_FONT)
dc.SetFont(normalFont)
tw, th = dc.GetTextExtent(self.GetText())
if self.GetTextAlignment() == BP_BUTTONTEXT_ALIGN_BOTTOM:
xsize = max(xsize, tw)
ysize = ysize + th
else:
xsize = xsize + tw
ysize = max(ysize, th)
border = self._parent._art.GetMetric(BP_BORDER_SIZE)
padding = self._parent._art.GetMetric(BP_PADDING_SIZE)
if self._parent.IsVertical():
xsize = xsize + 2*border
else:
ysize = ysize + 2*border
self._size = wx.Size(xsize+2*padding.x, ysize+2*padding.y)
return self._size
[docs] def Draw(self, dc, rect):
"""
Draws the button on L{ButtonPanel}. Actually the drawing is done in L{BPArt}.
:param `dc`: an instance of `wx.DC`;
:param `wx.Rect` `rect`: the main caption text client rectangle.
"""
if not self.IsShown():
return
buttonBitmap = self.GetBitmap()
isVertical = self._parent.IsVertical()
text = self.GetText()
buttonStatus = self.GetStatus()
isToggled = self.GetToggled()
textAlignment = self.GetTextAlignment()
self._parent._art.DrawButton(dc, rect, buttonBitmap, isVertical,
buttonStatus, isToggled, textAlignment, text)
self.SetRect(rect)
[docs] def CheckRefresh(self, status):
"""
Checks whether a L{ButtonPanel} repaint is needed or not. This is a convenience function.
:param bool `status`: the status of a newly added L{ButtonInfo} or a change in the
L{ButtonInfo} status.
"""
if status == self._status:
self._parent.RefreshRect(self.GetRect())
[docs] def SetBitmap(self, bmp, status="Normal"):
"""
Sets the bitmap associated with this instance of L{ButtonInfo}.
:param `bmp`: a valid `wx.Bitmap` object;
:param string `status`: the L{ButtonInfo} status ("Pressed", "Hover", "Normal",
"Toggled", "Disabled").
"""
self._bitmaps[status] = bmp
self.CheckRefresh(status)
[docs] def GetBitmap(self, status=None):
"""
Returns the bitmap associated with this instance of L{ButtonInfo}.
:param string `status`: the L{ButtonInfo} status ("Pressed", "Hover", "Normal",
"Toggled", "Disabled").
:return: An instance of `wx.Bitmap`.
"""
if status is None:
status = self._status
if not self.IsEnabled():
status = "Disabled"
if self._bitmaps[status] is None:
if self.GetToggled():
if self._bitmaps["Toggled"] is not None:
return self._bitmaps["Toggled"]
return self._bitmaps["Normal"]
return self._bitmaps[status]
[docs] def GetRect(self):
"""
Returns the L{ButtonInfo} client rectangle.
:return: An instance of `wx.Rect`.
"""
return self._rect
[docs] def GetStatus(self):
"""
Returns the L{ButtonInfo} status.
:return: A string containing the L{ButtonInfo} status (one of "Pressed", "Hover", "Normal",
"Toggled", "Disabled").
"""
return self._status
[docs] def GetId(self):
"""
Returns the L{ButtonInfo} id.
:return: An integer representing the button id.
"""
return self._id
[docs] def SetRect(self, rect):
"""
Sets the L{ButtonInfo} client rectangle.
:param `rect`: an instance of `wx.Rect`.
"""
self._rect = rect
[docs] def SetStatus(self, status):
"""
Sets the L{ButtonInfo} status.
:param string `status`: one of "Pressed", "Hover", "Normal", "Toggled", "Disabled".
"""
if status == self._status:
return
if self.GetToggled() and status == "Normal":
status = "Toggled"
self._status = status
self._parent.RefreshRect(self.GetRect())
[docs] def GetTextAlignment(self):
"""
Returns the text alignment in the button (bottom or right).
:return: An integer representing the L{ButtonInfo} text alignment.
"""
return self._textAlignment
[docs] def SetTextAlignment(self, alignment):
"""
Sets the text alignment in the button (bottom or right).
:param integer `alignment`: the text alignment in this L{ButtonInfo} instance.
"""
if alignment == self._textAlignment:
return
self._textAlignment = alignment
[docs] def GetToggled(self):
"""
Returns whether a ``wx.ITEM_CHECK`` button is toggled or not.
:return: ``True`` if the button is toggled, ``False`` otherwise.
"""
if self._kind == wx.ITEM_NORMAL:
return False
return self._toggle
[docs] def SetToggled(self, toggle=True):
"""
Sets a ``wx.ITEM_CHECK`` button toggled/not toggled.
:param bool `toggle`: ``True`` to toggle the button, ``False`` otherwise.
"""
if self._kind == wx.ITEM_NORMAL:
return
self._toggle = toggle
[docs] def SetId(self, id):
"""
Sets the L{ButtonInfo} identifier.
:param integer `id`: the identifier of the window.
"""
self._id = id
[docs] def AddStatus(self, name="Custom", bmp=wx.NullBitmap):
"""
Add a programmer-defined status in addition to the 5 default status:
- Normal;
- Disabled;
- Hover;
- Pressed;
- Toggled.
:param string `name`: the new status name;
:param `wx.Bitmap` `bmp`: the bitmap associated with the new status.
"""
self._bitmaps.update({name: bmp})
[docs] def Enable(self, enable=True):
"""
Enables/disables this instance of L{ButtonInfo}.
:param bool `enable`: ``True`` to enable the button, ``False`` otherwise.
"""
if enable:
self._status = "Normal"
else:
self._status = "Disabled"
[docs] def IsEnabled(self):
"""
Returns ``True`` if this instance of L{ButtonInfo} is enabled for input,
``False`` otherwise.
"""
return self._status != "Disabled"
[docs] def SetText(self, text=""):
"""
Sets the button label text.
:param string `text`: the button label string.
"""
self._text = text
[docs] def GetText(self):
"""
Returns the text associated to the button.
:return: A string containing the L{ButtonInfo} text.
"""
return self._text
[docs] def HasText(self):
"""
Returns whether the button has text or not.
:return: ``True`` if this L{ButtonInfo} instance has a label, ``False`` otherwise.
"""
return self._text != ""
[docs] def SetKind(self, kind=wx.ITEM_NORMAL):
"""
Sets the button type (standard or toggle).
:param integer `kind`: one of ``wx.ITEM_NORMAL``, ``wx.ITEM_CHECK``.
"""
self._kind = kind
[docs] def GetKind(self):
"""
Returns the button type (standard or toggle).
:return: An integer representing the button type, one of ``wx.ITEM_NORMAL``, ``wx.ITEM_CHECK``.
"""
return self._kind
[docs] def SetShortHelp(self, help=""):
"""
Sets the help string to be shown in a tooltip.
:param string `help`: the string for the short help.
"""
self._shortHelp = help
[docs] def GetShortHelp(self):
"""
Returns the help string shown in a tooltip.
:return: A string containing the L{ButtonInfo} short help string.
"""
return self._shortHelp
[docs] def SetLongHelp(self, help=""):
"""
Sets the help string to be shown in the statusbar.
:param string `help`: the string for the long help.
"""
self._longHelp = help
[docs] def GetLongHelp(self):
"""
Returns the help string shown in the statusbar.
:return: A string containing the L{ButtonInfo} long help string.
"""
return self._longHelp
Bitmap = property(GetBitmap, SetBitmap)
Id = property(GetId, SetId)
Rect = property(GetRect, SetRect)
Status = property(GetStatus, SetStatus)
# -- ButtonPanel class implementation ----------------------------------
# This is the main class.
[docs]class ButtonPanel(wx.PyPanel):
"""
A custom panel class with gradient background shading with the possibility to
add buttons and controls still respecting the gradient background.
"""
[docs] def __init__(self, parent, id=wx.ID_ANY, text="", agwStyle=BP_DEFAULT_STYLE,
alignment=BP_ALIGN_LEFT, name="buttonPanel"):
"""
Default class constructor.
:param `wx.Window` `parent`: the parent window. Must not be ``None``;
:param integer `id`: window identifier. If ``wx.ID_ANY``, will automatically create an identifier;
:param string `text`: the main caption text for L{ButtonPanel};
:param integer `agwStyle`: the AGW-specific window style (one of ``BP_DEFAULT_STYLE``, ``BP_USE_GRADIENT``);
:param integer `alignment`: alignment of buttons (left or right);
:param string `name`: window class name.
"""
wx.PyPanel.__init__(self, parent, id, wx.DefaultPosition, wx.DefaultSize,
wx.NO_BORDER, name=name)
self._vButtons = []
self._vSeparators = []
self._agwStyle = agwStyle
self._alignment = alignment
self._statusTimer = None
self._useHelp = True
self._freezeCount = 0
self._currentButton = -1
self._haveTip = False
self._art = BPArt(agwStyle)
self._controlCreated = False
direction = (self.IsVertical() and [wx.VERTICAL] or [wx.HORIZONTAL])[0]
self._mainsizer = BoxSizer(direction)
self.SetSizer(self._mainsizer)
margins = self._art.GetMetric(BP_MARGINS_SIZE)
# First spacer to create some room before the first text/button/control
self._mainsizer.Add((margins.x, margins.y), 0)
# Last spacer to create some room before the last text/button/control
self._mainsizer.Add((margins.x, margins.y), 0)
self.Bind(wx.EVT_SIZE, self.OnSize)
self.Bind(wx.EVT_PAINT, self.OnPaint)
self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)
self.Bind(wx.EVT_MOTION, self.OnMouseMove)
self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)
self.Bind(wx.EVT_LEAVE_WINDOW, self.OnMouseLeave)
self.Bind(wx.EVT_ENTER_WINDOW, self.OnMouseEnterWindow)
self.SetBarText(text)
self.LayoutItems()
[docs] def SetBarText(self, text):
"""
Sets the main caption text.
:param string `text`: the main caption text label. An empty string erases the
main caption text.
"""
self.Freeze()
text = text.strip()
if self._controlCreated:
self.RemoveText()
self._text = ButtonPanelText(self, text)
lenChildren = len(self._mainsizer.GetChildren())
if text == "":
# Even if we have no text, we insert it an empty spacer anyway
# it is easier to handle if you have to recreate the sizer after.
if self.IsStandard():
self._mainsizer.Insert(1, self._text, 0, wx.ALIGN_CENTER,
userData=self._text, realIndex=0)
else:
self._mainsizer.Insert(lenChildren-1, self._text, 0, wx.ALIGN_CENTER,
userData=self._text, realIndex=lenChildren)
return
# We have text, so insert the text and an expandable spacer
# alongside it. "Standard" ButtonPanel are left or top aligned.
if self.IsStandard():
self._mainsizer.Insert(1, self._text, 0, wx.ALIGN_CENTER,
userData=self._text, realIndex=0)
self._mainsizer.Insert(2, (0, 0), 1, wx.EXPAND)
else:
self._mainsizer.Insert(lenChildren-1, self._text, 0, wx.ALIGN_CENTER,
userData=self._text, realIndex=lenChildren)
self._mainsizer.Insert(lenChildren-1, (0, 0), 1, wx.EXPAND)
[docs] def RemoveText(self):
""" Removes the main caption text. """
lenChildren = len(self._mainsizer.GetChildren())
lenCustom = len(self._vButtons) + len(self._vSeparators) + 1
if self.IsStandard():
# Detach the text
self._mainsizer.Remove(1, 0)
if self.HasBarText():
# Detach the expandable spacer
self._mainsizer.Remove(1, -1)
else:
# Detach the text
self._mainsizer.Remove(lenChildren-2, lenCustom-1)
if self.HasBarText():
# Detach the expandable spacer
self._mainsizer.Remove(lenChildren-3, -1)
[docs] def GetBarText(self):
"""
Returns the main caption text.
:return: A string representing the caption text.
"""
return self._text.GetText()
[docs] def HasBarText(self):
"""
Returns whether L{ButtonPanel} has a main caption text or not.
:return: ``True`` if L{ButtonPanel} has a main caption text, ``False`` otherwise.
"""
return hasattr(self, "_text") and self._text.GetText() != ""
[docs] def AddButton(self, btnInfo):
"""
Adds a button to L{ButtonPanel}.
:param `btnInfo`: an instance of L{ButtonInfo}.
:note: Remember to pass a L{ButtonInfo} instance to this method, and not a
standard `wx.Button` or a `wx.ToolBar` tool.
"""
lenChildren = len(self._mainsizer.GetChildren())
self._mainsizer.Insert(lenChildren-1, btnInfo, 0, wx.ALIGN_CENTER|wx.EXPAND, userData=btnInfo)
self._vButtons.append(btnInfo)
[docs] def AddSpacer(self, size=(0, 0), proportion=1, flag=wx.EXPAND):
"""
Adds a spacer (stretchable or fixed-size) to L{ButtonPanel}.
:param tuple `size`: the spacer size as a tuple;
:param integer `proportion`: the spacer proportion (0 for fixed-size, 1 or more for a
stretchable one);
:param integer `flag`: one of the `wx.BoxSizer` flags.
"""
lenChildren = len(self._mainsizer.GetChildren())
self._mainsizer.Insert(lenChildren-1, size, proportion, flag)
[docs] def AddControl(self, control, proportion=0, flag=wx.ALIGN_CENTER|wx.ALL, border=None):
"""
Adds a wxPython control to L{ButtonPanel}.
:param `control`: an instance of `wx.Window`;
:param integer `proportion`: the control proportion (0 for fixed-size, 1 or more for a
stretchable one);
:param integer `flag`: one of the `wx.BoxSizer` flags;
:param integer `border`: the control border width (in pixels), if the `flag` parameter
is set to include any border flag.
"""
lenChildren = len(self._mainsizer.GetChildren())
if border is None:
border = self._art.GetMetric(BP_PADDING_SIZE)
border = max(border.x, border.y)
self._mainsizer.Insert(lenChildren-1, control, proportion, flag, border)
[docs] def AddSeparator(self):
""" Adds a separator line to L{ButtonPanel}. """
lenChildren = len(self._mainsizer.GetChildren())
separator = Separator(self)
self._mainsizer.Insert(lenChildren-1, separator, 0, wx.EXPAND)
self._vSeparators.append(separator)
[docs] def RemoveAllButtons(self):
"""
Remove all the buttons from L{ButtonPanel}.
:note: This function is for internal use only. If you are interested in
manipulating a L{ButtonPanel} in real time (ie. removing things on it)
have a look at the L{Clear} method.
"""
self._vButtons = []
[docs] def RemoveAllSeparators(self):
"""
Remove all the separators from L{ButtonPanel}.
:note: This function is for internal use only. If you are interested in
manipulating a L{ButtonPanel} in real time (ie. removing things on it)
have a look at the L{Clear} method.
"""
self._vSeparators = []
[docs] def Clear(self):
"""
Clears the L{ButtonPanel}.
Can be used to reset the L{ButtonPanel} if you'd like have a new set of
buttons on the panel.
"""
if self.HasBarText():
bartext = self.GetBarText()
else:
bartext = None
self.Freeze()
self._currentButton = -1
self._mainsizer.Clear()
self.ReCreateSizer(bartext)
[docs] def GetAlignment(self):
"""
Returns the buttons alignment.
:return: An integer specifying the buttons alignment.
:see: L{SetAlignment} for a set of valid alignment bits.
"""
return self._alignment
[docs] def SetAlignment(self, alignment):
"""
Sets the buttons alignment.
:param integer `alignment`: can be one of the following bits:
====================== ======= ==========================
Alignment Flag Value Description
====================== ======= ==========================
``BP_ALIGN_RIGHT`` 1 Buttons are aligned on the right
``BP_ALIGN_LEFT`` 2 Buttons are aligned on the left
``BP_ALIGN_TOP`` 4 Buttons are aligned at the top
``BP_ALIGN_BOTTOM`` 8 Buttons are aligned at the bottom
====================== ======= ==========================
"""
if alignment == self._alignment:
return
self.Freeze()
text = self.GetBarText()
# Remove the text in any case
self.RemoveText()
# Remove the first and last spacers
self._mainsizer.Remove(0, -1)
self._mainsizer.Remove(len(self._mainsizer.GetChildren())-1, -1)
self._alignment = alignment
# Recreate the sizer accordingly to the new alignment
self.ReCreateSizer(text)
[docs] def IsVertical(self):
"""
Returns whether L{ButtonPanel} is vertically aligned or not.
:return: ``True`` if L{ButtonPanel} is vertically aligned, ``False`` otherwise.
"""
return self._alignment not in [BP_ALIGN_RIGHT, BP_ALIGN_LEFT]
[docs] def IsStandard(self):
"""
Returns whether L{ButtonPanel} is aligned "Standard" (left/top) or not.
:return: ``True`` if L{ButtonPanel} is aligned "standard", ``False`` otherwise.
"""
return self._alignment in [BP_ALIGN_LEFT, BP_ALIGN_TOP]
[docs] def DoLayout(self):
"""
Do the Layout for L{ButtonPanel}.
:note: Call this method every time you make a modification to the layout
or to the customizable sizes of the pseudo controls.
"""
margins = self._art.GetMetric(BP_MARGINS_SIZE)
lenChildren = len(self._mainsizer.GetChildren())
self._mainsizer.SetItemMinSize(0, (margins.x, margins.y))
self._mainsizer.SetItemMinSize(lenChildren-1, (margins.x, margins.y))
self._controlCreated = True
self.LayoutItems()
# *VERY* WEIRD: the sizer seems not to respond to any layout until I
# change the ButtonPanel size and restore it back
size = self.GetSize()
self.SetSize((size.x+1, size.y+1))
self.SetSize((size.x, size.y))
if self.IsFrozen():
self.Thaw()
[docs] def ReCreateSizer(self, text=None):
"""
Recreates the L{ButtonPanel} sizer accordingly to the alignment specified.
:param string `text`: the text to display as main caption. If `text` is set to ``None``,
the main caption will not be displayed.
"""
children = self._mainsizer.GetChildren()
self.RemoveAllButtons()
self.RemoveAllSeparators()
# Create a new sizer depending on the alignment chosen
direction = (self.IsVertical() and [wx.VERTICAL] or [wx.HORIZONTAL])[0]
self._mainsizer = BoxSizer(direction)
margins = self._art.GetMetric(BP_MARGINS_SIZE)
# First spacer to create some room before the first text/button/control
self._mainsizer.Add((margins.x, margins.y), 0)
# Last spacer to create some room before the last text/button/control
self._mainsizer.Add((margins.x, margins.y), 0)
# This is needed otherwise SetBarText goes mad
self._controlCreated = False
for child in children:
userData = child.GetUserData()
if userData:
if isinstance(userData, ButtonInfo):
# It is a ButtonInfo, can't be anything else
self.AddButton(child.GetUserData())
elif isinstance(userData, Separator):
self.AddSeparator()
else:
if child.IsSpacer():
# This is a spacer, expandable or not
self.AddSpacer(child.GetSize(), child.GetProportion(),
child.GetFlag())
else:
# This is a wxPython control
self.AddControl(child.GetWindow(), child.GetProportion(),
child.GetFlag(), child.GetBorder())
self.SetSizer(self._mainsizer)
if text is not None:
self.SetBarText(text)
self.DoLayout()
self.Thaw()
[docs] def DoGetBestSize(self):
"""
Gets the size which best suits L{ButtonPanel}: 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()`.
:return: An instance of `wx.Size`.
:note: Overridden from `wx.PyPanel`.
"""
w = h = btnWidth = btnHeight = 0
isVertical = self.IsVertical()
padding = self._art.GetMetric(BP_PADDING_SIZE)
border = self._art.GetMetric(BP_BORDER_SIZE)
margins = self._art.GetMetric(BP_MARGINS_SIZE)
separator_size = self._art.GetMetric(BP_SEPARATOR_SIZE)
# Add the space required for the main caption
if self.HasBarText():
w, h = self._text.GetBestSize()
if isVertical:
h += padding.y
else:
w += padding.x
else:
w = h = border
# Add the button's sizes
for btn in self._vButtons:
bw, bh = btn.GetBestSize()
btnWidth = max(btnWidth, bw)
btnHeight = max(btnHeight, bh)
if isVertical:
w = max(w, btnWidth)
h += bh
else:
h = max(h, btnHeight)
w += bw
# Add the control's sizes
for control in self.GetControls():
cw, ch = control.GetSize()
if isVertical:
h += ch
w = max(w, cw)
else:
w += cw
h = max(h, ch)
# Add the separator's sizes and the 2 SizerItems at the beginning
# and at the end
if self.IsVertical():
h += 2*margins.y + len(self._vSeparators)*separator_size
else:
w += 2*margins.x + len(self._vSeparators)*separator_size
return wx.Size(w, h)
[docs] def OnPaint(self, event):
"""
Handles the ``wx.EVT_PAINT`` event for L{ButtonPanel}.
:param `event`: a `wx.PaintEvent` event to be processed.
"""
dc = wx.BufferedPaintDC(self)
rect = self.GetClientRect()
self._art.DrawButtonPanel(dc, rect, self._agwStyle)
self._mainsizer.Draw(dc)
[docs] def OnEraseBackground(self, event):
"""
Handles the ``wx.EVT_ERASE_BACKGROUND`` event for L{ButtonPanel}.
:param `event`: a `wx.EraseEvent` event to be processed.
:note: This is intentionally empty to reduce flicker.
"""
pass
[docs] def OnSize(self, event):
"""
Handles the ``wx.EVT_SIZE`` event for L{ButtonPanel}.
:param `event`: a `wx.SizeEvent` event to be processed.
:todo: Improve the chain of methods L{OnSize} ==> L{DoLayout} ==> L{LayoutItems}
to avoid multiple calls to L{LayoutItems}.
"""
# NOTE: It seems like LayoutItems number of calls can be optimized in some way.
# Currently every DoLayout (or every parent Layout()) calls about 3 times
# the LayoutItems method. Any idea on how to improve it?
self.LayoutItems()
self.Refresh()
event.Skip()
[docs] def LayoutItems(self):
"""
Layout the items using a different algorithms depending on the existance
of the main caption.
"""
nonspacers, allchildren = self.GetNonFlexibleChildren()
if self.HasBarText():
self.FlexibleLayout(nonspacers, allchildren)
else:
self.SizeLayout(nonspacers, allchildren)
self._mainsizer.Layout()
[docs] def SizeLayout(self, nonspacers, children):
"""
Layout the items when no main caption exists.
:param list `nonspacers`: a list of items which are not spacers;
:param list `children`: a list of all the children of L{ButtonPanel}.
"""
size = self.GetSize()
isVertical = self.IsVertical()
corner = 0
indx1 = len(nonspacers)
for item in nonspacers:
corner += self.GetItemSize(item, isVertical)
if corner > size[isVertical]:
indx1 = nonspacers.index(item)
break
# Leave out the last spacer, it has to be there always
for ii in xrange(len(nonspacers)-1):
indx = children.index(nonspacers[ii])
self._mainsizer.Show(indx, ii < indx1)
[docs] def GetItemSize(self, item, isVertical):
"""
Returns the size of an item in the main L{ButtonPanel} sizer.
:param `item`: an instance of L{ButtonInfo};
:param bool `isVertical`: ``True`` if L{ButtonPanel} is in vertical orientation,
``False`` otherwise.
:return: An instance of `wx.Size`.
"""
if item.GetUserData():
return item.GetUserData().GetBestSize()[isVertical]
else:
return item.GetSize()[isVertical]
[docs] def FlexibleLayout(self, nonspacers, allchildren):
"""
Layout the items when the main caption exists.
:param list `nonspacers`: a list of items which are not spacers;
:param list `allchildren`: a list of all the children of L{ButtonPanel}.
"""
if len(nonspacers) < 2:
return
isVertical = self.IsVertical()
isStandard = self.IsStandard()
size = self.GetSize()[isVertical]
padding = self._art.GetMetric(BP_PADDING_SIZE)
fixed = (isStandard and [nonspacers[1]] or [nonspacers[-2]])[0]
if isStandard:
nonspacers.reverse()
leftendx = fixed.GetSize()[isVertical] + padding.x
else:
rightstartx = size - fixed.GetSize()[isVertical]
size = 0
count = lennonspacers = len(nonspacers)
for item in nonspacers:
if isStandard:
size -= self.GetItemSize(item, isVertical)
if size < leftendx:
break
else:
size += self.GetItemSize(item, isVertical)
if size > rightstartx:
break
count = count - 1
nonspacers.reverse()
for jj in xrange(2, lennonspacers):
indx = allchildren.index(nonspacers[jj])
self._mainsizer.Show(indx, jj >= count)
[docs] def GetNonFlexibleChildren(self):
"""
Returns all the L{ButtonPanel} main sizer's children that are not
flexible spacers.
:return: A list of items inside L{ButtonPanel} that are not flexible spacers.
"""
children1 = []
children2 = list(self._mainsizer.GetChildren())
for child in children2:
if child.IsSpacer():
if child.GetUserData() or child.GetProportion() == 0:
children1.append(child)
else:
children1.append(child)
return children1, children2
[docs] def GetControls(self):
"""
Returns the wxPython controls that belongs to L{ButtonPanel}.
:return: A list of items inside L{ButtonPanel} that are wxPython controls.
"""
children2 = self._mainsizer.GetChildren()
children1 = [child for child in children2 if not child.IsSpacer()]
return children1
[docs] def SetStyle(self, agwStyle):
"""
Sets the L{ButtonPanel} window style.
:param integer `agwStyle`: one of the following bits:
==================== =========== ==================================================
Window Styles Hex Value Description
==================== =========== ==================================================
``BP_DEFAULT_STYLE`` 0x1 L{ButtonPanel} has a plain solid background.
``BP_USE_GRADIENT`` 0x2 L{ButtonPanel} has a gradient shading background.
==================== =========== ==================================================
"""
if agwStyle == self._agwStyle:
return
self._agwStyle = agwStyle
self.Refresh()
[docs] def GetStyle(self):
"""
Returns the L{ButtonPanel} window style.
:see: L{SetStyle} for a list of valid window styles.
"""
return self._agwStyle
[docs] def OnMouseMove(self, event):
"""
Handles the ``wx.EVT_MOTION`` event for L{ButtonPanel}.
:param `event`: a `wx.MouseEvent` event to be processed.
"""
# Check to see if we are hovering a button
tabId, flags = self.HitTest(event.GetPosition())
if flags != BP_HT_BUTTON:
self.RemoveHelp()
self.RepaintOldSelection()
self._currentButton = -1
return
btn = self._vButtons[tabId]
if not btn.IsEnabled():
self.RemoveHelp()
self.RepaintOldSelection()
return
if tabId != self._currentButton:
self.RepaintOldSelection()
if btn.GetRect().Contains(event.GetPosition()):
if btn.GetStatus() != "Pressed":
btn.SetStatus("Hover")
else:
btn.SetStatus("Normal")
if tabId != self._currentButton:
self.RemoveHelp()
self.DoGiveHelp(btn)
self._currentButton = tabId
event.Skip()
[docs] def OnLeftDown(self, event):
"""
Handles the ``wx.EVT_LEFT_DOWN`` event for L{ButtonPanel}.
:param `event`: a `wx.MouseEvent` event to be processed.
"""
tabId, hit = self.HitTest(event.GetPosition())
if hit == BP_HT_BUTTON:
btn = self._vButtons[tabId]
if btn.IsEnabled():
btn.SetStatus("Pressed")
self._currentButton = tabId
[docs] def OnLeftUp(self, event):
"""
Handles the ``wx.EVT_LEFT_UP`` event for L{ButtonPanel}.
:param `event`: a `wx.MouseEvent` event to be processed.
"""
tabId, flags = self.HitTest(event.GetPosition())
if flags != BP_HT_BUTTON:
return
hit = self._vButtons[tabId]
if hit.GetStatus() == "Disabled":
return
for btn in self._vButtons:
if btn != hit:
btn.SetFocus(False)
if hit.GetStatus() == "Pressed":
hit.SetToggled(not hit.GetToggled())
# Update the button status to be hovered
hit.SetStatus("Hover")
hit.SetFocus()
self._currentButton = tabId
# Fire a button click event
btnEvent = wx.CommandEvent(wx.wxEVT_COMMAND_BUTTON_CLICKED, hit.GetId())
btnEvent.SetEventObject(hit)
self.GetEventHandler().ProcessEvent(btnEvent)
[docs] def OnMouseLeave(self, event):
"""
Handles the ``wx.EVT_LEAVE_WINDOW`` event for L{ButtonPanel}.
:param `event`: a `wx.MouseEvent` event to be processed.
"""
# Reset all buttons statuses
for btn in self._vButtons:
if not btn.IsEnabled():
continue
btn.SetStatus("Normal")
self.RemoveHelp()
event.Skip()
[docs] def OnMouseEnterWindow(self, event):
"""
Handles the ``wx.EVT_ENTER_WINDOW`` event for L{ButtonPanel}.
:param `event`: a `wx.MouseEvent` event to be processed.
"""
tabId, flags = self.HitTest(event.GetPosition())
if flags == BP_HT_BUTTON:
hit = self._vButtons[tabId]
if hit.GetStatus() == "Disabled":
event.Skip()
return
self.DoGiveHelp(hit)
self._currentButton = tabId
event.Skip()
[docs] def DoGiveHelp(self, hit):
"""
Shows tooltips and long help strings in `wx.StatusBar`.
:param `hit`: an instance of L{ButtonInfo} where the mouse is hovering.
"""
if not self.GetUseHelp():
return
shortHelp = hit.GetShortHelp()
if shortHelp:
self.SetToolTipString(shortHelp)
self._haveTip = True
longHelp = hit.GetLongHelp()
if not longHelp:
return
topLevel = wx.GetTopLevelParent(self)
if isinstance(topLevel, wx.Frame) and topLevel.GetStatusBar():
statusBar = topLevel.GetStatusBar()
if self._statusTimer and self._statusTimer.IsRunning():
self._statusTimer.Stop()
statusBar.PopStatusText(0)
statusBar.PushStatusText(longHelp, 0)
self._statusTimer = StatusBarTimer(self)
self._statusTimer.Start(_DELAY, wx.TIMER_ONE_SHOT)
[docs] def RemoveHelp(self):
""" Removes the tooltips and statusbar help (if any) for a button. """
if not self.GetUseHelp():
return
if self._haveTip:
self.SetToolTipString("")
self._haveTip = False
if self._statusTimer and self._statusTimer.IsRunning():
topLevel = wx.GetTopLevelParent(self)
statusBar = topLevel.GetStatusBar()
self._statusTimer.Stop()
statusBar.PopStatusText(0)
self._statusTimer = None
[docs] def RepaintOldSelection(self):
""" Repaints the old selected/hovered button. """
current = self._currentButton
if current == -1:
return
btn = self._vButtons[current]
if not btn.IsEnabled():
return
btn.SetStatus("Normal")
[docs] def OnStatusBarTimer(self):
""" Handles the timer expiring to delete the long help string in `wx.StatusBar`. """
topLevel = wx.GetTopLevelParent(self)
statusBar = topLevel.GetStatusBar()
statusBar.PopStatusText(0)
[docs] def SetUseHelp(self, useHelp=True):
"""
Sets whether or not short and long help strings should be displayed as tooltips
and `wx.StatusBar` items respectively.
:param bool `useHelp`: ``True`` to display short and long help strings as tooltips
and `wx.StatusBar` items respectively, ``False`` otherwise.
"""
self._useHelp = useHelp
[docs] def GetUseHelp(self):
"""
Returns whether or not short and long help strings should be displayed as tooltips
and `wx.StatusBar` items respectively.
:return: ``True`` if the short and long help strings should be displayed as tooltips
and `wx.StatusBar` items respectively, ``False`` otherwise.
"""
return self._useHelp
[docs] def HitTest(self, pt):
"""
HitTest method for L{ButtonPanel}.
:param `pt`: the mouse position, an instance of `wx.Point`.
:returns: an instance of L{ButtonInfo} and the hit flag ``BP_HT_BUTTON`` if a button
client rectangle contains the input point `pt`, or ``wx.NOT_FOUND`` and ``BP_HT_NONE``.
"""
for ii in xrange(len(self._vButtons)):
if not self._vButtons[ii].IsEnabled():
continue
if self._vButtons[ii].GetRect().Contains(pt):
return ii, BP_HT_BUTTON
return wx.NOT_FOUND, BP_HT_NONE
[docs] def SetBPArt(self, art):
"""
Sets a new L{BPArt} art provider to L{ButtonPanel}.
:param `art`: an instance of L{BPArt}.
"""
self._art = art
self.Refresh()
if wx.VERSION < (2,7,1,1):
def Freeze(self):
"""
Freezes the window or, in other words, prevents any updates from taking place
on screen, the window is not redrawn at all. L{Thaw} must be called to reenable
window redrawing. Calls to these two functions may be nested.
:note: This method is useful for visual appearance optimization.
"""
self._freezeCount = self._freezeCount + 1
wx.PyPanel.Freeze(self)
def Thaw(self):
"""
Reenables window updating after a previous call to L{Freeze}. To really thaw the
control, it must be called exactly the same number of times as L{Freeze}.
"""
if self._freezeCount == 0:
raise Exception("\nERROR: Thawing Unfrozen ButtonPanel?")
self._freezeCount = self._freezeCount - 1
wx.PyPanel.Thaw(self)
def IsFrozen(self):
""" Returns ``True`` if the window is currently frozen by a call to L{Freeze}. """
return self._freezeCount != 0
