mirror of
https://github.com/Sneed-Group/Poodletooth-iLand
synced 2024-12-29 06:32:40 -06:00
1112 lines
33 KiB
Python
1112 lines
33 KiB
Python
#----------------------------------------------------------------------
|
|
# Name: wx.lib.buttons
|
|
# Purpose: Various kinds of generic buttons, (not native controls but
|
|
# self-drawn.)
|
|
#
|
|
# Author: Robin Dunn
|
|
#
|
|
# Created: 9-Dec-1999
|
|
# Copyright: (c) 1999 by Total Control Software
|
|
# Licence: wxWindows license
|
|
# Tags: phoenix-port, unittest, documented
|
|
#----------------------------------------------------------------------
|
|
# 11/30/2003 - Jeff Grimmett (grimmtooth@softhome.net)
|
|
#
|
|
# o Updated for wx namespace
|
|
# o Tested with updated demo
|
|
#
|
|
|
|
"""
|
|
This module implements various forms of generic buttons, meaning that
|
|
they are not built on native controls but are self-drawn.
|
|
|
|
|
|
Description
|
|
===========
|
|
|
|
This module implements various forms of generic buttons, meaning that
|
|
they are not built on native controls but are self-drawn.
|
|
They act like normal buttons but you are able to better control how they look,
|
|
bevel width, colours, etc...
|
|
|
|
|
|
Usage
|
|
=====
|
|
|
|
Sample usage::
|
|
|
|
import wx
|
|
import wx.lib.buttons as buttons
|
|
|
|
class MyFrame(wx.Frame):
|
|
def __init__(self, parent, title):
|
|
|
|
wx.Frame.__init__(self, parent, wx.ID_ANY, title, size=(400, 300))
|
|
panel = wx.Panel(self)
|
|
|
|
# Build a bitmap button and a normal one
|
|
bmp = wx.ArtProvider.GetBitmap(wx.ART_INFORMATION, wx.ART_OTHER, (16, 16))
|
|
btn1 = buttons.ThemedGenBitmapButton(panel, -1, bmp, pos=(50, 50))
|
|
|
|
btn2 = buttons.GenButton(panel, -1, "Hello World!", pos=(50, 100))
|
|
|
|
|
|
app = wx.App()
|
|
frame = MyFrame(None, 'wx.lib.buttons Test')
|
|
frame.Show()
|
|
app.MainLoop()
|
|
|
|
"""
|
|
|
|
import wx
|
|
import wx.lib.imageutils as imageutils
|
|
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
class GenButtonEvent(wx.CommandEvent):
|
|
""" Event sent from the generic buttons when the button is activated. """
|
|
|
|
def __init__(self, eventType, id):
|
|
"""
|
|
Default class constructor.
|
|
|
|
:param integer `eventType`: the event type;
|
|
:param integer `id`: the event identifier.
|
|
"""
|
|
|
|
wx.CommandEvent.__init__(self, eventType, id)
|
|
self.isDown = False
|
|
self.theButton = None
|
|
|
|
|
|
def SetIsDown(self, isDown):
|
|
"""
|
|
Set the button toggle status as 'down' or 'up'.
|
|
|
|
:param bool `isDown`: ``True`` if the button is clicked, ``False`` otherwise.
|
|
"""
|
|
|
|
self.isDown = isDown
|
|
|
|
|
|
def GetIsDown(self):
|
|
"""
|
|
Returns the button toggle status as ``True`` if the button is down, ``False``
|
|
otherwise.
|
|
|
|
:rtype: bool
|
|
"""
|
|
|
|
return self.isDown
|
|
|
|
|
|
def SetButtonObj(self, btn):
|
|
"""
|
|
Sets the event object for the event.
|
|
|
|
:param `btn`: the button object, an instance of :class:`GenButton`.
|
|
"""
|
|
|
|
self.theButton = btn
|
|
|
|
|
|
def GetButtonObj(self):
|
|
"""
|
|
Returns the object associated with this event.
|
|
|
|
:return: An instance of :class:`GenButton`.
|
|
"""
|
|
|
|
return self.theButton
|
|
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
class GenButton(wx.Control):
|
|
""" A generic button, and base class for the other generic buttons. """
|
|
|
|
labelDelta = 1
|
|
|
|
def __init__(self, parent, id=-1, label='',
|
|
pos = wx.DefaultPosition, size = wx.DefaultSize,
|
|
style = 0, validator = wx.DefaultValidator,
|
|
name = "genbutton"):
|
|
"""
|
|
Default class constructor.
|
|
|
|
:param Window `parent`: parent window. Must not be ``None``;
|
|
:param integer `id`: window identifier. A value of -1 indicates a default value;
|
|
:param string `label`: the button text label;
|
|
: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;
|
|
:type `pos`: tuple or :class:`Point`
|
|
: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 :class:`Size`
|
|
:param integer `style`: the button style;
|
|
:param Validator `validator`: the validator associated with the button;
|
|
:param string `name`: the button name.
|
|
|
|
.. seealso:: :class:`Button` for a list of valid window styles.
|
|
"""
|
|
|
|
cstyle = style
|
|
if cstyle & wx.BORDER_MASK == 0:
|
|
cstyle |= wx.BORDER_NONE
|
|
|
|
wx.Control.__init__(self, parent, id, pos, size, cstyle, validator, name)
|
|
|
|
self.up = True
|
|
self.hasFocus = False
|
|
self.style = style
|
|
|
|
if style & wx.BORDER_NONE:
|
|
self.bezelWidth = 0
|
|
self.useFocusInd = False
|
|
else:
|
|
self.bezelWidth = 2
|
|
self.useFocusInd = True
|
|
|
|
self.SetLabel(label)
|
|
self.InheritAttributes()
|
|
self.SetInitialSize(size)
|
|
self.InitColours()
|
|
|
|
self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
|
|
self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)
|
|
self.Bind(wx.EVT_LEFT_DCLICK, self.OnLeftDown)
|
|
self.Bind(wx.EVT_MOTION, self.OnMotion)
|
|
self.Bind(wx.EVT_SET_FOCUS, self.OnGainFocus)
|
|
self.Bind(wx.EVT_KILL_FOCUS, self.OnLoseFocus)
|
|
self.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
|
|
self.Bind(wx.EVT_KEY_UP, self.OnKeyUp)
|
|
self.Bind(wx.EVT_PAINT, self.OnPaint)
|
|
self.Bind(wx.EVT_ERASE_BACKGROUND, lambda evt: None)
|
|
self.Bind(wx.EVT_SIZE, self.OnSize)
|
|
self.InitOtherEvents()
|
|
|
|
|
|
def InitOtherEvents(self):
|
|
"""
|
|
Override this method in a subclass to initialize any other events that
|
|
need to be bound. Added so :meth:`__init__` doesn't need to be
|
|
overriden, which is complicated with multiple inheritance.
|
|
"""
|
|
|
|
pass
|
|
|
|
|
|
def SetInitialSize(self, size=None):
|
|
"""
|
|
Given the current font and bezel width settings, calculate
|
|
and set a good size.
|
|
|
|
:param `size`: an instance of :class:`Size` or ``None``, in which case the wxPython
|
|
``DefaultSize`` is used instead.
|
|
"""
|
|
|
|
if size is None:
|
|
size = wx.DefaultSize
|
|
|
|
wx.Control.SetInitialSize(self, size)
|
|
|
|
SetBestSize = SetInitialSize
|
|
|
|
|
|
def DoGetBestSize(self):
|
|
"""
|
|
Overridden base class virtual. Determines the best size of the
|
|
button based on the label and bezel size.
|
|
|
|
:return: An instance of :class:`Size`.
|
|
|
|
.. note:: Overridden from :class:`Control`.
|
|
"""
|
|
|
|
w, h, useMin = self._GetLabelSize()
|
|
if self.style & wx.BU_EXACTFIT:
|
|
width = w + 2 + 2 * self.bezelWidth + 4 * int(self.useFocusInd)
|
|
height = h + 2 + 2 * self.bezelWidth + 4 * int(self.useFocusInd)
|
|
else:
|
|
defSize = wx.Button.GetDefaultSize()
|
|
width = 12 + w
|
|
if useMin and width < defSize.width:
|
|
width = defSize.width
|
|
height = 11 + h
|
|
if useMin and height < defSize.height:
|
|
height = defSize.height
|
|
width = width + self.bezelWidth - 1
|
|
height = height + self.bezelWidth - 1
|
|
|
|
return wx.Size(width, height)
|
|
|
|
|
|
def AcceptsFocus(self):
|
|
"""
|
|
Can this window be given focus by mouse click?
|
|
|
|
.. note:: Overridden from :class:`Control`.
|
|
"""
|
|
|
|
return self.IsShown() and self.IsEnabled()
|
|
|
|
|
|
def GetDefaultAttributes(self):
|
|
"""
|
|
Overridden base class virtual. By default we should use
|
|
the same font/colour attributes as the native :class:`Button`.
|
|
|
|
:return: an instance of :class:`VisualAttributes`.
|
|
|
|
.. note:: Overridden from :class:`Control`.
|
|
"""
|
|
|
|
return wx.Button.GetClassDefaultAttributes()
|
|
|
|
|
|
def ShouldInheritColours(self):
|
|
"""
|
|
Overridden base class virtual. Buttons usually don't inherit
|
|
the parent's colours.
|
|
|
|
.. note:: Overridden from :class:`Control`.
|
|
"""
|
|
|
|
return False
|
|
|
|
|
|
def Enable(self, enable=True):
|
|
"""
|
|
Enables/disables the button.
|
|
|
|
:param bool `enable`: ``True`` to enable the button, ``False`` to disable it.
|
|
|
|
.. note:: Overridden from :class:`Control`.
|
|
"""
|
|
|
|
if enable != self.IsEnabled():
|
|
wx.Control.Enable(self, enable)
|
|
self.Refresh()
|
|
|
|
|
|
def SetBezelWidth(self, width):
|
|
"""
|
|
Sets the width of the 3D effect.
|
|
|
|
:param integer `width`: the 3D border width, in pixels.
|
|
"""
|
|
|
|
self.bezelWidth = width
|
|
|
|
|
|
def GetBezelWidth(self):
|
|
"""
|
|
Returns the width of the 3D effect, in pixels.
|
|
|
|
:rtype: integer
|
|
"""
|
|
|
|
return self.bezelWidth
|
|
|
|
|
|
def SetUseFocusIndicator(self, flag):
|
|
"""
|
|
Specifies if a focus indicator (dotted line) should be used.
|
|
|
|
:param bool `flag`: ``True`` to draw a focus ring, ``False`` otherwise.
|
|
"""
|
|
|
|
self.useFocusInd = flag
|
|
|
|
|
|
def GetUseFocusIndicator(self):
|
|
"""
|
|
Returns the focus indicator flag, specifying if a focus indicator
|
|
(dotted line) is being used.
|
|
|
|
:rtype: bool
|
|
"""
|
|
|
|
return self.useFocusInd
|
|
|
|
|
|
def InitColours(self):
|
|
"""
|
|
Calculate a new set of highlight and shadow colours based on
|
|
the background colour. Works okay if the colour is dark...
|
|
"""
|
|
|
|
faceClr = self.GetBackgroundColour()
|
|
r, g, b, a = faceClr
|
|
fr, fg, fb = min(255,r+32), min(255,g+32), min(255,b+32)
|
|
self.faceDnClr = wx.Colour(fr, fg, fb)
|
|
sr, sg, sb = max(0,r-32), max(0,g-32), max(0,b-32)
|
|
self.shadowPenClr = wx.Colour(sr,sg,sb)
|
|
hr, hg, hb = min(255,r+64), min(255,g+64), min(255,b+64)
|
|
self.highlightPenClr = wx.Colour(hr,hg,hb)
|
|
self.focusClr = wx.Colour(hr, hg, hb)
|
|
|
|
|
|
def SetBackgroundColour(self, colour):
|
|
"""
|
|
Sets the :class:`GenButton` background colour.
|
|
|
|
:param `colour`: a valid :class:`Colour` object.
|
|
|
|
.. note:: Overridden from :class:`Control`.
|
|
"""
|
|
|
|
wx.Control.SetBackgroundColour(self, colour)
|
|
self.InitColours()
|
|
|
|
|
|
def SetForegroundColour(self, colour):
|
|
"""
|
|
Sets the :class:`GenButton` foreground colour.
|
|
|
|
:param `colour`: a valid :class:`Colour` object.
|
|
|
|
.. note:: Overridden from :class:`Control`.
|
|
"""
|
|
|
|
wx.Control.SetForegroundColour(self, colour)
|
|
self.InitColours()
|
|
|
|
|
|
def SetDefault(self):
|
|
"""
|
|
This sets the :class:`GenButton` to be the default item for the panel or dialog box.
|
|
|
|
.. note:: Under Windows, only dialog box buttons respond to this function. As normal
|
|
under Windows and Motif, pressing return causes the default button to be depressed
|
|
when the return key is pressed. See also :meth:`Window.SetFocus` which sets the
|
|
keyboard focus for windows and text panel items, and :meth:`TopLevelWindow.SetDefaultItem`.
|
|
|
|
.. note:: Note that under Motif, calling this function immediately after creation of a button
|
|
and before the creation of other buttons will cause misalignment of the row of buttons,
|
|
since default buttons are larger. To get around this, call :meth:`SetDefault` after you
|
|
have created a row of buttons: wxPython will then set the size of all buttons currently
|
|
on the panel to the same size.
|
|
"""
|
|
|
|
tlw = wx.GetTopLevelParent(self)
|
|
if hasattr(tlw, 'SetDefaultItem'):
|
|
tlw.SetDefaultItem(self)
|
|
|
|
|
|
def _GetLabelSize(self):
|
|
""" Used internally. """
|
|
|
|
w, h = self.GetTextExtent(self.GetLabel())
|
|
return w, h, True
|
|
|
|
|
|
def Notify(self):
|
|
""" Actually sends a ``wx.EVT_BUTTON`` event to the listener (if any). """
|
|
|
|
evt = GenButtonEvent(wx.wxEVT_COMMAND_BUTTON_CLICKED, self.GetId())
|
|
evt.SetIsDown(not self.up)
|
|
evt.SetButtonObj(self)
|
|
evt.SetEventObject(self)
|
|
self.GetEventHandler().ProcessEvent(evt)
|
|
|
|
|
|
def DrawBezel(self, dc, x1, y1, x2, y2):
|
|
# draw the upper left sides
|
|
if self.up:
|
|
dc.SetPen(wx.Pen(self.highlightPenClr, 1))
|
|
else:
|
|
dc.SetPen(wx.Pen(self.shadowPenClr, 1))
|
|
for i in range(self.bezelWidth):
|
|
dc.DrawLine(x1+i, y1, x1+i, y2-i)
|
|
dc.DrawLine(x1, y1+i, x2-i, y1+i)
|
|
|
|
# draw the lower right sides
|
|
if self.up:
|
|
dc.SetPen(wx.Pen(self.shadowPenClr, 1))
|
|
else:
|
|
dc.SetPen(wx.Pen(self.highlightPenClr, 1))
|
|
for i in range(self.bezelWidth):
|
|
dc.DrawLine(x1+i, y2-i, x2+1, y2-i)
|
|
dc.DrawLine(x2-i, y1+i, x2-i, y2)
|
|
|
|
|
|
def DrawLabel(self, dc, width, height, dx=0, dy=0):
|
|
dc.SetFont(self.GetFont())
|
|
if self.IsEnabled():
|
|
dc.SetTextForeground(self.GetForegroundColour())
|
|
else:
|
|
dc.SetTextForeground(wx.SystemSettings.GetColour(wx.SYS_COLOUR_GRAYTEXT))
|
|
label = self.GetLabel()
|
|
tw, th = dc.GetTextExtent(label)
|
|
if not self.up:
|
|
dx = dy = self.labelDelta
|
|
dc.DrawText(label, (width-tw)/2+dx, (height-th)/2+dy)
|
|
|
|
|
|
def DrawFocusIndicator(self, dc, w, h):
|
|
bw = self.bezelWidth
|
|
textClr = self.GetForegroundColour()
|
|
focusIndPen = wx.Pen(textClr, 1, wx.PENSTYLE_USER_DASH)
|
|
focusIndPen.SetDashes([1,1])
|
|
focusIndPen.SetCap(wx.CAP_BUTT)
|
|
|
|
if wx.Platform == "__WXMAC__":
|
|
dc.SetLogicalFunction(wx.XOR)
|
|
else:
|
|
focusIndPen.SetColour(self.focusClr)
|
|
dc.SetLogicalFunction(wx.INVERT)
|
|
dc.SetPen(focusIndPen)
|
|
dc.SetBrush(wx.TRANSPARENT_BRUSH)
|
|
dc.DrawRectangle(bw+2,bw+2, w-bw*2-4, h-bw*2-4)
|
|
dc.SetLogicalFunction(wx.COPY)
|
|
|
|
|
|
def OnPaint(self, event):
|
|
"""
|
|
Handles the ``wx.EVT_PAINT`` event for :class:`GenButton`.
|
|
|
|
:param `event`: a :class:`PaintEvent` event to be processed.
|
|
"""
|
|
|
|
(width, height) = self.GetClientSize()
|
|
x1 = y1 = 0
|
|
x2 = width-1
|
|
y2 = height-1
|
|
|
|
dc = wx.PaintDC(self)
|
|
brush = self.GetBackgroundBrush(dc)
|
|
if brush is not None:
|
|
dc.SetBackground(brush)
|
|
dc.Clear()
|
|
|
|
self.DrawBezel(dc, x1, y1, x2, y2)
|
|
self.DrawLabel(dc, width, height)
|
|
if self.hasFocus and self.useFocusInd:
|
|
self.DrawFocusIndicator(dc, width, height)
|
|
|
|
|
|
def OnSize(self, event):
|
|
"""
|
|
Handles the ``wx.EVT_SIZE`` event for :class:`GenButton`.
|
|
|
|
:param `event`: a :class:`SizeEvent` event to be processed.
|
|
"""
|
|
|
|
self.Refresh()
|
|
event.Skip()
|
|
|
|
|
|
def GetBackgroundBrush(self, dc):
|
|
"""
|
|
Returns the current :class:`Brush` to be used to draw the button background.
|
|
|
|
:param DC `dc`: the device context used to draw the button background.
|
|
"""
|
|
|
|
if self.up:
|
|
colBg = self.GetBackgroundColour()
|
|
brush = wx.Brush(colBg)
|
|
if self.style & wx.BORDER_NONE:
|
|
myAttr = self.GetDefaultAttributes()
|
|
parAttr = self.GetParent().GetDefaultAttributes()
|
|
myDef = colBg == myAttr.colBg
|
|
parDef = self.GetParent().GetBackgroundColour() == parAttr.colBg
|
|
if myDef and parDef:
|
|
if wx.Platform == "__WXMAC__":
|
|
c = wx.MacThemeColour(1) # 1 == kThemeBrushDialogBackgroundActive
|
|
brush = wx.Brush(c)
|
|
elif wx.Platform == "__WXMSW__":
|
|
if hasattr(self, 'DoEraseBackground') and self.DoEraseBackground(dc):
|
|
brush = None
|
|
elif myDef and not parDef:
|
|
colBg = self.GetParent().GetBackgroundColour()
|
|
brush = wx.Brush(colBg)
|
|
else:
|
|
# this line assumes that a pressed button should be hilighted with
|
|
# a solid colour even if the background is supposed to be transparent
|
|
brush = wx.Brush(self.faceDnClr)
|
|
return brush
|
|
|
|
|
|
def OnLeftDown(self, event):
|
|
"""
|
|
Handles the ``wx.EVT_LEFT_DOWN`` event for :class:`GenButton`.
|
|
|
|
:param `event`: a :class:`MouseEvent` event to be processed.
|
|
"""
|
|
|
|
if not self.IsEnabled():
|
|
return
|
|
|
|
self.up = False
|
|
self.CaptureMouse()
|
|
self.SetFocus()
|
|
self.Refresh()
|
|
event.Skip()
|
|
|
|
|
|
def OnLeftUp(self, event):
|
|
"""
|
|
Handles the ``wx.EVT_LEFT_UP`` event for :class:`GenButton`.
|
|
|
|
:param `event`: a :class:`MouseEvent` event to be processed.
|
|
"""
|
|
|
|
if not self.IsEnabled() or not self.HasCapture():
|
|
return
|
|
|
|
if self.HasCapture():
|
|
self.ReleaseMouse()
|
|
if not self.up: # if the button was down when the mouse was released...
|
|
self.Notify()
|
|
self.up = True
|
|
if self: # in case the button was destroyed in the eventhandler
|
|
self.Refresh()
|
|
event.Skip()
|
|
|
|
|
|
def OnMotion(self, event):
|
|
"""
|
|
Handles the ``wx.EVT_MOTION`` event for :class:`GenButton`.
|
|
|
|
:param `event`: a :class:`MouseEvent` event to be processed.
|
|
"""
|
|
|
|
if not self.IsEnabled() or not self.HasCapture():
|
|
return
|
|
|
|
if event.LeftIsDown() and self.HasCapture():
|
|
x,y = event.GetPosition()
|
|
w,h = self.GetClientSize()
|
|
|
|
if self.up and x<w and x>=0 and y<h and y>=0:
|
|
self.up = False
|
|
self.Refresh()
|
|
return
|
|
|
|
if not self.up and (x<0 or y<0 or x>=w or y>=h):
|
|
self.up = True
|
|
self.Refresh()
|
|
return
|
|
|
|
event.Skip()
|
|
|
|
|
|
def OnGainFocus(self, event):
|
|
"""
|
|
Handles the ``wx.EVT_SET_FOCUS`` event for :class:`GenButton`.
|
|
|
|
:param `event`: a :class:`FocusEvent` event to be processed.
|
|
"""
|
|
|
|
self.hasFocus = True
|
|
self.Refresh()
|
|
self.Update()
|
|
|
|
|
|
def OnLoseFocus(self, event):
|
|
"""
|
|
Handles the ``wx.EVT_KILL_FOCUS`` event for :class:`GenButton`.
|
|
|
|
:param `event`: a :class:`FocusEvent` event to be processed.
|
|
"""
|
|
|
|
self.hasFocus = False
|
|
self.Refresh()
|
|
self.Update()
|
|
|
|
|
|
def OnKeyDown(self, event):
|
|
"""
|
|
Handles the ``wx.EVT_KEY_DOWN`` event for :class:`GenButton`.
|
|
|
|
:param `event`: a :class:`KeyEvent` event to be processed.
|
|
"""
|
|
|
|
if self.hasFocus and event.GetKeyCode() == ord(" "):
|
|
self.up = False
|
|
self.Refresh()
|
|
|
|
event.Skip()
|
|
|
|
|
|
def OnKeyUp(self, event):
|
|
"""
|
|
Handles the ``wx.EVT_KEY_UP`` event for :class:`GenButton`.
|
|
|
|
:param `event`: a :class:`KeyEvent` event to be processed.
|
|
"""
|
|
|
|
if self.hasFocus and event.GetKeyCode() == ord(" "):
|
|
self.up = True
|
|
self.Notify()
|
|
self.Refresh()
|
|
|
|
event.Skip()
|
|
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
class GenBitmapButton(GenButton):
|
|
""" A generic bitmap button. """
|
|
|
|
def __init__(self, parent, id=-1, bitmap=wx.NullBitmap,
|
|
pos = wx.DefaultPosition, size = wx.DefaultSize,
|
|
style = 0, validator = wx.DefaultValidator,
|
|
name = "genbutton"):
|
|
"""
|
|
Default class constructor.
|
|
|
|
:param Window `parent`: parent window. Must not be ``None``;
|
|
:param integer `id`: window identifier. A value of -1 indicates a default value;
|
|
:param Bitmap `bitmap`: the button bitmap;
|
|
: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;
|
|
:type `pos`: tuple or :class:`Point`
|
|
: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 :class:`Size`
|
|
:param integer `style`: the button style;
|
|
:param Validator `validator`: the validator associated to the button;
|
|
:param string `name`: the button name.
|
|
|
|
.. seealso:: :class:`Button` for a list of valid window styles.
|
|
"""
|
|
|
|
self.bmpDisabled = None
|
|
self.bmpFocus = None
|
|
self.bmpSelected = None
|
|
self.SetBitmapLabel(bitmap)
|
|
GenButton.__init__(self, parent, id, "", pos, size, style, validator, name)
|
|
|
|
|
|
def GetBitmapLabel(self):
|
|
"""
|
|
Returns the bitmap for the button's normal state.
|
|
|
|
:rtype: :class:`Bitmap`
|
|
|
|
.. seealso:: :meth:`SetBitmapLabel`
|
|
"""
|
|
|
|
return self.bmpLabel
|
|
|
|
|
|
def GetBitmapDisabled(self):
|
|
"""
|
|
Returns the bitmap for the button's disabled state, which may be invalid.
|
|
|
|
:rtype: :class:`Bitmap`
|
|
|
|
.. seealso:: :meth:`SetBitmapDisabled`
|
|
"""
|
|
|
|
return self.bmpDisabled
|
|
|
|
|
|
def GetBitmapFocus(self):
|
|
"""
|
|
Returns the bitmap for the button's focused state, which may be invalid.
|
|
|
|
:rtype: :class:`Bitmap`
|
|
|
|
.. seealso:: :meth:`SetBitmapFocus`
|
|
"""
|
|
|
|
return self.bmpFocus
|
|
|
|
|
|
def GetBitmapSelected(self):
|
|
"""
|
|
Returns the bitmap for the button's pressed state, which may be invalid.
|
|
|
|
:rtype: :class:`Bitmap`
|
|
|
|
.. seealso:: :meth:`SetBitmapSelected`
|
|
"""
|
|
|
|
return self.bmpSelected
|
|
|
|
|
|
def SetBitmapDisabled(self, bitmap):
|
|
"""
|
|
Sets the bitmap for the disabled button appearance.
|
|
|
|
:param Bitmap `bitmap`: the bitmap for the disabled button appearance.
|
|
|
|
.. seealso::
|
|
|
|
:meth:`GetBitmapDisabled`, :meth:`SetBitmapLabel`,
|
|
:meth:`SetBitmapSelected`, :meth:`SetBitmapFocus`
|
|
|
|
"""
|
|
|
|
self.bmpDisabled = bitmap
|
|
|
|
|
|
def SetBitmapFocus(self, bitmap):
|
|
"""
|
|
Sets the bitmap for the focused button appearance.
|
|
|
|
:param Bitmap `bitmap`: the bitmap for the focused button appearance.
|
|
|
|
.. seealso::
|
|
|
|
:meth:`GetBitmapFocus`, :meth:`SetBitmapLabel`,
|
|
:meth:`SetBitmapSelected`, :meth:`SetBitmapDisabled`
|
|
|
|
"""
|
|
|
|
self.bmpFocus = bitmap
|
|
self.SetUseFocusIndicator(False)
|
|
|
|
|
|
def SetBitmapSelected(self, bitmap):
|
|
"""
|
|
Sets the bitmap for the selected (depressed) button appearance.
|
|
|
|
:param Bitmap `bitmap`: the bitmap for the selected (depressed) button appearance.
|
|
|
|
.. seealso::
|
|
|
|
:meth:`GetBitmapSelected`, :meth:`SetBitmapLabel`,
|
|
:meth:`SetBitmapDisabled`, :meth:`SetBitmapFocus`
|
|
|
|
"""
|
|
|
|
self.bmpSelected = bitmap
|
|
|
|
|
|
def SetBitmapLabel(self, bitmap, createOthers=True):
|
|
"""
|
|
Set the bitmap to display normally.
|
|
This is the only one that is required.
|
|
|
|
If `createOthers` is ``True``, then the other bitmaps will be generated
|
|
on the fly. Currently, only the disabled bitmap is generated.
|
|
|
|
:param Bitmap `bitmap`: the bitmap for the normal button appearance.
|
|
|
|
.. note:: This is the bitmap used for the unselected state, and for all other
|
|
states if no other bitmaps are provided.
|
|
"""
|
|
|
|
self.bmpLabel = bitmap
|
|
if bitmap is not None and createOthers:
|
|
image = bitmap.ConvertToImage()
|
|
imageutils.grayOut(image)
|
|
self.SetBitmapDisabled(wx.Bitmap(image))
|
|
|
|
|
|
def _GetLabelSize(self):
|
|
""" Used internally. """
|
|
|
|
if not self.bmpLabel:
|
|
return -1, -1, False
|
|
|
|
return self.bmpLabel.GetWidth()+2, self.bmpLabel.GetHeight()+2, False
|
|
|
|
|
|
def DrawLabel(self, dc, width, height, dx=0, dy=0):
|
|
bmp = self.bmpLabel
|
|
if self.bmpDisabled and not self.IsEnabled():
|
|
bmp = self.bmpDisabled
|
|
if self.bmpFocus and self.hasFocus:
|
|
bmp = self.bmpFocus
|
|
if self.bmpSelected and not self.up:
|
|
bmp = self.bmpSelected
|
|
bw,bh = bmp.GetWidth(), bmp.GetHeight()
|
|
if not self.up:
|
|
dx = dy = self.labelDelta
|
|
hasMask = bmp.GetMask() != None
|
|
dc.DrawBitmap(bmp, (width-bw)/2+dx, (height-bh)/2+dy, hasMask)
|
|
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
|
|
class GenBitmapTextButton(GenBitmapButton):
|
|
""" A generic bitmapped button with text label. """
|
|
|
|
def __init__(self, parent, id=-1, bitmap=wx.NullBitmap, label='',
|
|
pos = wx.DefaultPosition, size = wx.DefaultSize,
|
|
style = 0, validator = wx.DefaultValidator,
|
|
name = "genbutton"):
|
|
"""
|
|
Default class constructor.
|
|
|
|
:param Window `parent`: parent window. Must not be ``None``;
|
|
:param integer `id`: window identifier. A value of -1 indicates a default value;
|
|
:param Bitmap `bitmap`: the button bitmap;
|
|
:param string `label`: the button text label;
|
|
: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;
|
|
:type `pos`: tuple or :class:`Point`
|
|
: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 :class:`Size`
|
|
:param integer `style`: the button style;
|
|
:param Validator `validator`: the validator associated to the button;
|
|
:param string `name`: the button name.
|
|
|
|
.. seealso:: :class:`Button` for a list of valid window styles.
|
|
"""
|
|
|
|
GenBitmapButton.__init__(self, parent, id, bitmap, pos, size, style, validator, name)
|
|
self.SetLabel(label)
|
|
|
|
|
|
def _GetLabelSize(self):
|
|
""" Used internally. """
|
|
|
|
w, h = self.GetTextExtent(self.GetLabel())
|
|
if not self.bmpLabel:
|
|
return w, h, True # if there isn't a bitmap use the size of the text
|
|
|
|
w_bmp = self.bmpLabel.GetWidth()+2
|
|
h_bmp = self.bmpLabel.GetHeight()+2
|
|
width = w + w_bmp
|
|
if h_bmp > h:
|
|
height = h_bmp
|
|
else:
|
|
height = h
|
|
return width, height, True
|
|
|
|
|
|
def DrawLabel(self, dc, width, height, dx=0, dy=0):
|
|
bmp = self.bmpLabel
|
|
if bmp is not None: # if the bitmap is used
|
|
if self.bmpDisabled and not self.IsEnabled():
|
|
bmp = self.bmpDisabled
|
|
if self.bmpFocus and self.hasFocus:
|
|
bmp = self.bmpFocus
|
|
if self.bmpSelected and not self.up:
|
|
bmp = self.bmpSelected
|
|
bw,bh = bmp.GetWidth(), bmp.GetHeight()
|
|
if not self.up:
|
|
dx = dy = self.labelDelta
|
|
hasMask = bmp.GetMask() is not None
|
|
else:
|
|
bw = bh = 0 # no bitmap -> size is zero
|
|
|
|
dc.SetFont(self.GetFont())
|
|
if self.IsEnabled():
|
|
dc.SetTextForeground(self.GetForegroundColour())
|
|
else:
|
|
dc.SetTextForeground(wx.SystemSettings.GetColour(wx.SYS_COLOUR_GRAYTEXT))
|
|
|
|
label = self.GetLabel()
|
|
tw, th = dc.GetTextExtent(label) # size of text
|
|
if not self.up:
|
|
dx = dy = self.labelDelta
|
|
|
|
pos_x = (width-bw-tw)/2+dx # adjust for bitmap and text to centre
|
|
if bmp is not None:
|
|
dc.DrawBitmap(bmp, pos_x, (height-bh)/2+dy, hasMask) # draw bitmap if available
|
|
pos_x = pos_x + 2 # extra spacing from bitmap
|
|
|
|
dc.DrawText(label, pos_x + dx+bw, (height-th)/2+dy) # draw the text
|
|
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
|
|
class __ToggleMixin(object):
|
|
"""
|
|
A mixin that allows to transform :class:`GenButton` in the corresponding toggle button.
|
|
"""
|
|
|
|
def SetToggle(self, flag):
|
|
"""
|
|
Sets the button as toggled/not toggled.
|
|
|
|
:param bool `flag`: ``True`` to set the button as toggled, ``False`` otherwise.
|
|
"""
|
|
|
|
self.up = not flag
|
|
self.Refresh()
|
|
|
|
SetValue = SetToggle
|
|
|
|
|
|
def GetToggle(self):
|
|
"""
|
|
Returns the toggled state of a button.
|
|
|
|
:return: ``True`` is the button is toggled, ``False`` if it is not toggled.
|
|
"""
|
|
|
|
return not self.up
|
|
|
|
GetValue = GetToggle
|
|
|
|
|
|
def OnLeftDown(self, event):
|
|
"""
|
|
Handles the ``wx.EVT_LEFT_DOWN`` event for :class:`GenButton` when used as toggle button.
|
|
|
|
:param `event`: a :class:`MouseEvent` event to be processed.
|
|
"""
|
|
|
|
if not self.IsEnabled():
|
|
return
|
|
|
|
self.saveUp = self.up
|
|
self.up = not self.up
|
|
self.CaptureMouse()
|
|
self.SetFocus()
|
|
self.Refresh()
|
|
|
|
|
|
def OnLeftUp(self, event):
|
|
"""
|
|
Handles the ``wx.EVT_LEFT_UP`` event for :class:`GenButton` when used as toggle button.
|
|
|
|
:param `event`: a :class:`MouseEvent` event to be processed.
|
|
"""
|
|
|
|
if not self.IsEnabled() or not self.HasCapture():
|
|
return
|
|
|
|
if self.HasCapture():
|
|
self.ReleaseMouse()
|
|
self.Refresh()
|
|
if self.up != self.saveUp:
|
|
self.Notify()
|
|
|
|
|
|
def OnKeyDown(self, event):
|
|
"""
|
|
Handles the ``wx.EVT_KEY_DOWN`` event for :class:`GenButton` when used as toggle button.
|
|
|
|
:param `event`: a :class:`KeyEvent` event to be processed.
|
|
"""
|
|
|
|
event.Skip()
|
|
|
|
|
|
def OnMotion(self, event):
|
|
"""
|
|
Handles the ``wx.EVT_MOTION`` event for :class:`GenButton` when used as toggle button.
|
|
|
|
:param `event`: a :class:`MouseEvent` event to be processed.
|
|
"""
|
|
|
|
if not self.IsEnabled():
|
|
return
|
|
|
|
if event.LeftIsDown() and self.HasCapture():
|
|
x,y = event.GetPosition()
|
|
w,h = self.GetClientSize()
|
|
|
|
if x<w and x>=0 and y<h and y>=0:
|
|
self.up = not self.saveUp
|
|
self.Refresh()
|
|
return
|
|
|
|
if (x<0 or y<0 or x>=w or y>=h):
|
|
self.up = self.saveUp
|
|
self.Refresh()
|
|
return
|
|
|
|
event.Skip()
|
|
|
|
|
|
def OnKeyUp(self, event):
|
|
"""
|
|
Handles the ``wx.EVT_KEY_UP`` event for :class:`GenButton` when used as toggle button.
|
|
|
|
:param `event`: a :class:`KeyEvent` event to be processed.
|
|
"""
|
|
|
|
if self.hasFocus and event.GetKeyCode() == ord(" "):
|
|
self.up = not self.up
|
|
self.Notify()
|
|
self.Refresh()
|
|
event.Skip()
|
|
|
|
|
|
|
|
|
|
class GenToggleButton(__ToggleMixin, GenButton):
|
|
""" A generic toggle button. """
|
|
pass
|
|
|
|
class GenBitmapToggleButton(__ToggleMixin, GenBitmapButton):
|
|
""" A generic toggle bitmap button. """
|
|
pass
|
|
|
|
class GenBitmapTextToggleButton(__ToggleMixin, GenBitmapTextButton):
|
|
""" A generic toggle bitmap button with text label. """
|
|
pass
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
|
|
class __ThemedMixin(object):
|
|
""" Uses the native renderer to draw the bezel, also handle mouse-overs. """
|
|
|
|
|
|
def InitOtherEvents(self):
|
|
""" Initializes other events needed for themed buttons. """
|
|
|
|
self.Bind(wx.EVT_ENTER_WINDOW, self.OnMouse)
|
|
self.Bind(wx.EVT_LEAVE_WINDOW, self.OnMouse)
|
|
|
|
|
|
def OnMouse(self, event):
|
|
"""
|
|
Handles the ``wx.EVT_ENTER_WINDOW`` and ``wx.EVT_LEAVE_WINDOW`` events for
|
|
:class:`GenButton` when used as a themed button.
|
|
|
|
:param `event`: a :class:`MouseEvent` event to be processed.
|
|
"""
|
|
|
|
self.Refresh()
|
|
event.Skip()
|
|
|
|
|
|
def DrawBezel(self, dc, x1, y1, x2, y2):
|
|
|
|
rect = wx.Rect(x1, y1, x2, y2)
|
|
if self.up:
|
|
state = 0
|
|
else:
|
|
state = wx.CONTROL_PRESSED | wx.CONTROL_SELECTED
|
|
if not self.IsEnabled():
|
|
state = wx.CONTROL_DISABLED
|
|
pt = self.ScreenToClient(wx.GetMousePosition())
|
|
if self.GetClientRect().Contains(pt):
|
|
state |= wx.CONTROL_CURRENT
|
|
wx.RendererNative.Get().DrawPushButton(self, dc, rect, state)
|
|
|
|
|
|
|
|
class ThemedGenButton(__ThemedMixin, GenButton):
|
|
""" A themed generic button. """
|
|
pass
|
|
|
|
class ThemedGenBitmapButton(__ThemedMixin, GenBitmapButton):
|
|
""" A themed generic bitmap button. """
|
|
pass
|
|
|
|
class ThemedGenBitmapTextButton(__ThemedMixin, GenBitmapTextButton):
|
|
""" A themed generic bitmapped button with text label. """
|
|
pass
|
|
|
|
class ThemedGenToggleButton(__ThemedMixin, GenToggleButton):
|
|
""" A themed generic toggle button. """
|
|
pass
|
|
|
|
class ThemedGenBitmapToggleButton(__ThemedMixin, GenBitmapToggleButton):
|
|
""" A themed generic toggle bitmap button. """
|
|
pass
|
|
|
|
class ThemedGenBitmapTextToggleButton(__ThemedMixin, GenBitmapTextToggleButton):
|
|
""" A themed generic toggle bitmap button with text label. """
|
|
pass
|
|
|
|
|
|
#----------------------------------------------------------------------
|