#---------------------------------------------------------------------- # 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-2020 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 wx.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:`wx.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:`wx.Size` :param integer `style`: the button style; :param wx.Validator `validator`: the validator associated with the button; :param string `name`: the button name. .. seealso:: :class:`wx.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) face = wx.SystemSettings.GetColour(wx.SYS_COLOUR_BTNFACE) if 'wxMac' in wx.PlatformInfo and face.alpha == 0: face = wx.SystemSettings.GetColour(wx.SYS_COLOUR_3DLIGHT) assert face.alpha != 0, "a different default system colour is needed!" self.SetBackgroundColour(face) 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_MOUSE_CAPTURE_LOST, self.OnLoseCapture) 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 overridden, 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:`wx.Size` or ``None``, in which case the wxPython ``wx.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:`wx.Size`. .. note:: Overridden from :class:`wx.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:`wx.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:`wx.Button`. :return: an instance of :class:`wx.VisualAttributes`. .. note:: Overridden from :class:`wx.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:`wx.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:`wx.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:`wx.Colour` object. .. note:: Overridden from :class:`wx.Control`. """ wx.Control.SetBackgroundColour(self, colour) self.InitColours() def SetForegroundColour(self, colour): """ Sets the :class:`wx.GenButton` foreground colour. :param `colour`: a valid :class:`wx.Colour` object. .. note:: Overridden from :class:`wx.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:`wx.Window.SetFocus` which sets the keyboard focus for windows and text panel items, and :meth:`wx.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:`wx.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:`wx.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:`wx.SizeEvent` event to be processed. """ self.Refresh() event.Skip() def GetBackgroundBrush(self, dc): """ Returns the current :class:`wx.Brush` to be used to draw the button background. :param wx.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 highlighted 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:`wx.MouseEvent` event to be processed. """ if (not self.IsEnabled()) or self.HasCapture(): 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:`wx.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:`wx.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=0 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:`wx.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:`wx.FocusEvent` event to be processed. """ self.hasFocus = False self.Refresh() self.Update() def OnLoseCapture(self, event): """ Handles the ``wx.EVT_MOUSE_CAPTURE_LOST`` event for :class:`GenButton`. :param `event`: a :class:`wx.MouseCaptureLostEvent` event to be processed. """ self.up = True self.Refresh() self.Update() def OnKeyDown(self, event): """ Handles the ``wx.EVT_KEY_DOWN`` event for :class:`GenButton`. :param `event`: a :class:`wx.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:`wx.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 wx.Window `parent`: parent window. Must not be ``None``; :param integer `id`: window identifier. A value of -1 indicates a default value; :param wx.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:`wx.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:`wx.Size` :param integer `style`: the button style; :param wx.Validator `validator`: the validator associated to the button; :param string `name`: the button name. .. seealso:: :class:`wx.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:`wx.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:`wx.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:`wx.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:`wx.Bitmap` .. seealso:: :meth:`SetBitmapSelected` """ return self.bmpSelected def SetBitmapDisabled(self, bitmap): """ Sets the bitmap for the disabled button appearance. :param wx.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 wx.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 wx.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 wx.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() is not 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 wx.Window `parent`: parent window. Must not be ``None``; :param integer `id`: window identifier. A value of -1 indicates a default value; :param wx.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:`wx.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:`wx.Size` :param integer `style`: the button style; :param wx.Validator `validator`: the validator associated to the button; :param string `name`: the button name. .. seealso:: :class:`wx.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 hasMask = False 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:`wx.MouseEvent` event to be processed. """ if not self.IsEnabled(): return self.saveUp = self.up if self.HasCapture(): return 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:`wx.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:`wx.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:`wx.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=0 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:`wx.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:`wx.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 #----------------------------------------------------------------------