wxPython/wx/lib/buttons.py

   1 #----------------------------------------------------------------------
   2 # Name:        wx.lib.buttons
   3 # Purpose:     Various kinds of generic buttons, (not native controls but
   4 #              self-drawn.)
   5 #
   6 # Author:      Robin Dunn
   7 #
   8 # Created:     9-Dec-1999
   9 # RCS-ID:      $Id$
  10 # Copyright:   (c) 1999 by Total Control Software
  11 # Licence:     wxWindows license
  12 #----------------------------------------------------------------------
  13 # 11/30/2003 - Jeff Grimmett (grimmtooth@softhome.net)
  14 #
  15 # o Updated for wx namespace
  16 # o Tested with updated demo
  17 #
  18
  19 """
  20 This module implements various forms of generic buttons, meaning that
  21 they are not built on native controls but are self-drawn.  They act
  22 like normal buttons but you are able to better control how they look,
  23 bevel width, colours, etc.
  24 """
  25
  26 import wx
  27 import imageutils
  28
  29
  30 #----------------------------------------------------------------------
  31
  32 class GenButtonEvent(wx.PyCommandEvent):
  33     """Event sent from the generic buttons when the button is activated. """
  34     def __init__(self, eventType, ID):
  35         wx.PyCommandEvent.__init__(self, eventType, ID)
  36         self.isDown = False
  37         self.theButton = None
  38
  39     def SetIsDown(self, isDown):
  40         self.isDown = isDown
  41
  42     def GetIsDown(self):
  43         return self.isDown
  44
  45     def SetButtonObj(self, btn):
  46         self.theButton = btn
  47
  48     def GetButtonObj(self):
  49         return self.theButton
  50
  51
  52 #----------------------------------------------------------------------
  53
  54 class GenButton(wx.PyControl):
  55     """A generic button, and base class for the other generic buttons."""
  56
  57     labelDelta = 1
  58
  59     def __init__(self, parent, ID, label,
  60                  pos = wx.DefaultPosition, size = wx.DefaultSize,
  61                  style = 0, validator = wx.DefaultValidator,
  62                  name = "genbutton"):
  63         cstyle = style
  64         if cstyle == 0:
  65             cstyle = wx.NO_BORDER
  66         wx.PyControl.__init__(self, parent, ID, pos, size, cstyle, validator, name)
  67
  68         self.up = True
  69         self.hasFocus = False
  70         if style & wx.NO_BORDER:
  71             self.bezelWidth = 0
  72             self.useFocusInd = False
  73         else:
  74             self.bezelWidth = 2
  75             self.useFocusInd = True
  76
  77         self.SetLabel(label)
  78         self.InheritAttributes()
  79         self.SetBestFittingSize(size)
  80         self.InitColours()
  81
  82         self.Bind(wx.EVT_LEFT_DOWN,        self.OnLeftDown)
  83         self.Bind(wx.EVT_LEFT_UP,          self.OnLeftUp)
  84         if wx.Platform == '__WXMSW__':
  85             self.Bind(wx.EVT_LEFT_DCLICK,  self.OnLeftDown)
  86         self.Bind(wx.EVT_MOTION,           self.OnMotion)
  87         self.Bind(wx.EVT_SET_FOCUS,        self.OnGainFocus)
  88         self.Bind(wx.EVT_KILL_FOCUS,       self.OnLoseFocus)
  89         self.Bind(wx.EVT_KEY_DOWN,         self.OnKeyDown)
  90         self.Bind(wx.EVT_KEY_UP,           self.OnKeyUp)
  91         self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)
  92         self.Bind(wx.EVT_PAINT,            self.OnPaint)
  93
  94
  95     def SetBestSize(self, size=None):
  96         """
  97         Given the current font and bezel width settings, calculate
  98         and set a good size.
  99         """
 100         if size is None:
 101             size = wx.DefaultSize
 102         wx.PyControl.SetBestFittingSize(self, size)
 103
 104
 105     def DoGetBestSize(self):
 106         """
 107         Overridden base class virtual.  Determines the best size of the
 108         button based on the label and bezel size.
 109         """
 110         w, h, useMin = self._GetLabelSize()
 111         defSize = wx.Button.GetDefaultSize()
 112         width = 12 + w
 113         if useMin and width < defSize.width:
 114            width = defSize.width
 115         height = 11 + h
 116         if useMin and height < defSize.height:
 117             height = defSize.height
 118         width = width + self.bezelWidth - 1
 119         height = height + self.bezelWidth - 1
 120         return (width, height)
 121
 122
 123     def AcceptsFocus(self):
 124         """Overridden base class virtual."""
 125         return self.IsShown() and self.IsEnabled()
 126
 127
 128     def GetDefaultAttributes(self):
 129         """
 130         Overridden base class virtual.  By default we should use
 131         the same font/colour attributes as the native Button.
 132         """
 133         return wx.Button.GetClassDefaultAttributes()
 134
 135
 136     def ShouldInheritColours(self):
 137         """
 138         Overridden base class virtual.  Buttons usually don't inherit
 139         the parent's colours.
 140         """
 141         return False
 142
 143
 144     def Enable(self, enable=True):
 145         wx.PyControl.Enable(self, enable)
 146         self.Refresh()
 147
 148
 149     def SetBezelWidth(self, width):
 150         """Set the width of the 3D effect"""
 151         self.bezelWidth = width
 152
 153     def GetBezelWidth(self):
 154         """Return the width of the 3D effect"""
 155         return self.bezelWidth
 156
 157     def SetUseFocusIndicator(self, flag):
 158         """Specifiy if a focus indicator (dotted line) should be used"""
 159         self.useFocusInd = flag
 160
 161     def GetUseFocusIndicator(self):
 162         """Return focus indicator flag"""
 163         return self.useFocusInd
 164
 165
 166     def InitColours(self):
 167         """
 168         Calculate a new set of highlight and shadow colours based on
 169         the background colour.  Works okay if the colour is dark...
 170         """
 171         faceClr = self.GetBackgroundColour()
 172         r, g, b = faceClr.Get()
 173         fr, fg, fb = min(255,r+32), min(255,g+32), min(255,b+32)
 174         self.faceDnClr = wx.Colour(fr, fg, fb)
 175         sr, sg, sb = max(0,r-32), max(0,g-32), max(0,b-32)
 176         self.shadowPen = wx.Pen(wx.Colour(sr,sg,sb), 1, wx.SOLID)
 177         hr, hg, hb = min(255,r+64), min(255,g+64), min(255,b+64)
 178         self.highlightPen = wx.Pen(wx.Colour(hr,hg,hb), 1, wx.SOLID)
 179         self.focusClr = wx.Colour(hr, hg, hb)
 180
 181         textClr = self.GetForegroundColour()
 182         if wx.Platform == "__WXMAC__":
 183             self.focusIndPen = wx.Pen(textClr, 1, wx.SOLID)
 184         else:
 185             self.focusIndPen  = wx.Pen(textClr, 1, wx.USER_DASH)
 186             self.focusIndPen.SetDashes([1,1])
 187             self.focusIndPen.SetCap(wx.CAP_BUTT)
 188
 189
 190     def SetBackgroundColour(self, colour):
 191         wx.PyControl.SetBackgroundColour(self, colour)
 192         self.InitColours()
 193
 194
 195     def SetForegroundColour(self, colour):
 196         wx.PyControl.SetForegroundColour(self, colour)
 197         self.InitColours()
 198
 199     def SetDefault(self):
 200         self.GetParent().SetDefaultItem(self)
 201
 202     def _GetLabelSize(self):
 203         """ used internally """
 204         w, h = self.GetTextExtent(self.GetLabel())
 205         return w, h, True
 206
 207
 208     def Notify(self):
 209         evt = GenButtonEvent(wx.wxEVT_COMMAND_BUTTON_CLICKED, self.GetId())
 210         evt.SetIsDown(not self.up)
 211         evt.SetButtonObj(self)
 212         evt.SetEventObject(self)
 213         self.GetEventHandler().ProcessEvent(evt)
 214
 215
 216     def DrawBezel(self, dc, x1, y1, x2, y2):
 217         # draw the upper left sides
 218         if self.up:
 219             dc.SetPen(self.highlightPen)
 220         else:
 221             dc.SetPen(self.shadowPen)
 222         for i in range(self.bezelWidth):
 223             dc.DrawLine(x1+i, y1, x1+i, y2-i)
 224             dc.DrawLine(x1, y1+i, x2-i, y1+i)
 225
 226         # draw the lower right sides
 227         if self.up:
 228             dc.SetPen(self.shadowPen)
 229         else:
 230             dc.SetPen(self.highlightPen)
 231         for i in range(self.bezelWidth):
 232             dc.DrawLine(x1+i, y2-i, x2+1, y2-i)
 233             dc.DrawLine(x2-i, y1+i, x2-i, y2)
 234
 235
 236     def DrawLabel(self, dc, width, height, dw=0, dy=0):
 237         dc.SetFont(self.GetFont())
 238         if self.IsEnabled():
 239             dc.SetTextForeground(self.GetForegroundColour())
 240         else:
 241             dc.SetTextForeground(wx.SystemSettings.GetColour(wx.SYS_COLOUR_GRAYTEXT))
 242         label = self.GetLabel()
 243         tw, th = dc.GetTextExtent(label)
 244         if not self.up:
 245             dw = dy = self.labelDelta
 246         dc.DrawText(label, (width-tw)/2+dw, (height-th)/2+dy)
 247
 248
 249     def DrawFocusIndicator(self, dc, w, h):
 250         bw = self.bezelWidth
 251         self.focusIndPen.SetColour(self.focusClr)
 252         dc.SetLogicalFunction(wx.INVERT)
 253         dc.SetPen(self.focusIndPen)
 254         dc.SetBrush(wx.TRANSPARENT_BRUSH)
 255         dc.DrawRectangle(bw+2,bw+2,  w-bw*2-4, h-bw*2-4)
 256         dc.SetLogicalFunction(wx.COPY)
 257
 258
 259     def OnPaint(self, event):
 260         (width, height) = self.GetClientSizeTuple()
 261         x1 = y1 = 0
 262         x2 = width-1
 263         y2 = height-1
 264         dc = wx.BufferedPaintDC(self)
 265         if self.up:
 266             dc.SetBackground(wx.Brush(self.GetBackgroundColour(), wx.SOLID))
 267         else:
 268             dc.SetBackground(wx.Brush(self.faceDnClr, wx.SOLID))
 269         dc.Clear()
 270         self.DrawBezel(dc, x1, y1, x2, y2)
 271         self.DrawLabel(dc, width, height)
 272         if self.hasFocus and self.useFocusInd:
 273             self.DrawFocusIndicator(dc, width, height)
 274
 275
 276     def OnEraseBackground(self, event):
 277         pass
 278
 279
 280     def OnLeftDown(self, event):
 281         if not self.IsEnabled():
 282             return
 283         self.up = False
 284         self.CaptureMouse()
 285         self.SetFocus()
 286         self.Refresh()
 287         event.Skip()
 288
 289
 290     def OnLeftUp(self, event):
 291         if not self.IsEnabled() or not self.HasCapture():
 292             return
 293         if self.HasCapture():
 294             self.ReleaseMouse()
 295             if not self.up:    # if the button was down when the mouse was released...
 296                 self.Notify()
 297             self.up = True
 298             self.Refresh()
 299             event.Skip()
 300
 301
 302     def OnMotion(self, event):
 303         if not self.IsEnabled() or not self.HasCapture():
 304             return
 305         if event.LeftIsDown() and self.HasCapture():
 306             x,y = event.GetPositionTuple()
 307             w,h = self.GetClientSizeTuple()
 308             if self.up and x<w and x>=0 and y<h and y>=0:
 309                 self.up = False
 310                 self.Refresh()
 311                 return
 312             if not self.up and (x<0 or y<0 or x>=w or y>=h):
 313                 self.up = True
 314                 self.Refresh()
 315                 return
 316         event.Skip()
 317
 318
 319     def OnGainFocus(self, event):
 320         self.hasFocus = True
 321         dc = wx.ClientDC(self)
 322         w, h = self.GetClientSizeTuple()
 323         if self.useFocusInd:
 324             self.DrawFocusIndicator(dc, w, h)
 325
 326
 327     def OnLoseFocus(self, event):
 328         self.hasFocus = False
 329         dc = wx.ClientDC(self)
 330         w, h = self.GetClientSizeTuple()
 331         if self.useFocusInd:
 332             self.DrawFocusIndicator(dc, w, h)
 333
 334
 335     def OnKeyDown(self, event):
 336         if self.hasFocus and event.KeyCode() == ord(" "):
 337             self.up = False
 338             self.Refresh()
 339         event.Skip()
 340
 341
 342     def OnKeyUp(self, event):
 343         if self.hasFocus and event.KeyCode() == ord(" "):
 344             self.up = True
 345             self.Notify()
 346             self.Refresh()
 347         event.Skip()
 348
 349
 350 #----------------------------------------------------------------------
 351
 352 class GenBitmapButton(GenButton):
 353     """A generic bitmap button."""
 354
 355     def __init__(self, parent, ID, bitmap,
 356                  pos = wx.DefaultPosition, size = wx.DefaultSize,
 357                  style = 0, validator = wx.DefaultValidator,
 358                  name = "genbutton"):
 359         self.bmpDisabled = None
 360         self.bmpFocus = None
 361         self.bmpSelected = None
 362         self.SetBitmapLabel(bitmap)
 363         GenButton.__init__(self, parent, ID, "", pos, size, style, validator, name)
 364
 365
 366     def GetBitmapLabel(self):
 367         return self.bmpLabel
 368     def GetBitmapDisabled(self):
 369         return self.bmpDisabled
 370     def GetBitmapFocus(self):
 371         return self.bmpFocus
 372     def GetBitmapSelected(self):
 373         return self.bmpSelected
 374
 375
 376     def SetBitmapDisabled(self, bitmap):
 377         """Set bitmap to display when the button is disabled"""
 378         self.bmpDisabled = bitmap
 379
 380     def SetBitmapFocus(self, bitmap):
 381         """Set bitmap to display when the button has the focus"""
 382         self.bmpFocus = bitmap
 383         self.SetUseFocusIndicator(False)
 384
 385     def SetBitmapSelected(self, bitmap):
 386         """Set bitmap to display when the button is selected (pressed down)"""
 387         self.bmpSelected = bitmap
 388
 389     def SetBitmapLabel(self, bitmap, createOthers=True):
 390         """
 391         Set the bitmap to display normally.
 392         This is the only one that is required. If
 393         createOthers is True, then the other bitmaps
 394         will be generated on the fly.  Currently,
 395         only the disabled bitmap is generated.
 396         """
 397         self.bmpLabel = bitmap
 398         if bitmap is not None and createOthers:
 399             image = wx.ImageFromBitmap(bitmap)
 400             imageutils.grayOut(image)
 401             self.SetBitmapDisabled(wx.BitmapFromImage(image))
 402
 403
 404     def _GetLabelSize(self):
 405         """ used internally """
 406         if not self.bmpLabel:
 407             return -1, -1, False
 408         return self.bmpLabel.GetWidth()+2, self.bmpLabel.GetHeight()+2, False
 409
 410     def DrawLabel(self, dc, width, height, dw=0, dy=0):
 411         bmp = self.bmpLabel
 412         if self.bmpDisabled and not self.IsEnabled():
 413             bmp = self.bmpDisabled
 414         if self.bmpFocus and self.hasFocus:
 415             bmp = self.bmpFocus
 416         if self.bmpSelected and not self.up:
 417             bmp = self.bmpSelected
 418         bw,bh = bmp.GetWidth(), bmp.GetHeight()
 419         if not self.up:
 420             dw = dy = self.labelDelta
 421         hasMask = bmp.GetMask() != None
 422         dc.DrawBitmap(bmp, (width-bw)/2+dw, (height-bh)/2+dy, hasMask)
 423
 424
 425 #----------------------------------------------------------------------
 426
 427
 428 class GenBitmapTextButton(GenBitmapButton):
 429     """A generic bitmapped button with text label"""
 430     def __init__(self, parent, ID, bitmap, label,
 431                  pos = wx.DefaultPosition, size = wx.DefaultSize,
 432                  style = 0, validator = wx.DefaultValidator,
 433                  name = "genbutton"):
 434         GenBitmapButton.__init__(self, parent, ID, bitmap, pos, size, style, validator, name)
 435         self.SetLabel(label)
 436
 437
 438     def _GetLabelSize(self):
 439         """ used internally """
 440         w, h = self.GetTextExtent(self.GetLabel())
 441         if not self.bmpLabel:
 442             return w, h, True       # if there isn't a bitmap use the size of the text
 443
 444         w_bmp = self.bmpLabel.GetWidth()+2
 445         h_bmp = self.bmpLabel.GetHeight()+2
 446         width = w + w_bmp
 447         if h_bmp > h:
 448             height = h_bmp
 449         else:
 450             height = h
 451         return width, height, True
 452
 453
 454     def DrawLabel(self, dc, width, height, dw=0, dy=0):
 455         bmp = self.bmpLabel
 456         if bmp != None:     # if the bitmap is used
 457             if self.bmpDisabled and not self.IsEnabled():
 458                 bmp = self.bmpDisabled
 459             if self.bmpFocus and self.hasFocus:
 460                 bmp = self.bmpFocus
 461             if self.bmpSelected and not self.up:
 462                 bmp = self.bmpSelected
 463             bw,bh = bmp.GetWidth(), bmp.GetHeight()
 464             if not self.up:
 465                 dw = dy = self.labelDelta
 466             hasMask = bmp.GetMask() != None
 467         else:
 468             bw = bh = 0     # no bitmap -> size is zero
 469
 470         dc.SetFont(self.GetFont())
 471         if self.IsEnabled():
 472             dc.SetTextForeground(self.GetForegroundColour())
 473         else:
 474             dc.SetTextForeground(wx.SystemSettings.GetColour(wx.SYS_COLOUR_GRAYTEXT))
 475
 476         label = self.GetLabel()
 477         tw, th = dc.GetTextExtent(label)        # size of text
 478         if not self.up:
 479             dw = dy = self.labelDelta
 480
 481         pos_x = (width-bw-tw)/2+dw      # adjust for bitmap and text to centre
 482         if bmp !=None:
 483             dc.DrawBitmap(bmp, pos_x, (height-bh)/2+dy, hasMask) # draw bitmap if available
 484             pos_x = pos_x + 2   # extra spacing from bitmap
 485
 486         dc.DrawText(label, pos_x + dw+bw, (height-th)/2+dy)      # draw the text
 487
 488
 489 #----------------------------------------------------------------------
 490
 491
 492 class __ToggleMixin:
 493     def SetToggle(self, flag):
 494         self.up = not flag
 495         self.Refresh()
 496     SetValue = SetToggle
 497
 498     def GetToggle(self):
 499         return not self.up
 500     GetValue = GetToggle
 501
 502     def OnLeftDown(self, event):
 503         if not self.IsEnabled():
 504             return
 505         self.saveUp = self.up
 506         self.up = not self.up
 507         self.CaptureMouse()
 508         self.SetFocus()
 509         self.Refresh()
 510
 511     def OnLeftUp(self, event):
 512         if not self.IsEnabled() or not self.HasCapture():
 513             return
 514         if self.HasCapture():
 515             if self.up != self.saveUp:
 516                 self.Notify()
 517             self.ReleaseMouse()
 518             self.Refresh()
 519
 520     def OnKeyDown(self, event):
 521         event.Skip()
 522
 523     def OnMotion(self, event):
 524         if not self.IsEnabled():
 525             return
 526         if event.LeftIsDown() and self.HasCapture():
 527             x,y = event.GetPositionTuple()
 528             w,h = self.GetClientSizeTuple()
 529             if x<w and x>=0 and y<h and y>=0:
 530                 self.up = not self.saveUp
 531                 self.Refresh()
 532                 return
 533             if (x<0 or y<0 or x>=w or y>=h):
 534                 self.up = self.saveUp
 535                 self.Refresh()
 536                 return
 537         event.Skip()
 538
 539     def OnKeyUp(self, event):
 540         if self.hasFocus and event.KeyCode() == ord(" "):
 541             self.up = not self.up
 542             self.Notify()
 543             self.Refresh()
 544         event.Skip()
 545
 546
 547
 548
 549 class GenToggleButton(__ToggleMixin, GenButton):
 550     """A generic toggle button"""
 551     pass
 552
 553 class GenBitmapToggleButton(__ToggleMixin, GenBitmapButton):
 554     """A generic toggle bitmap button"""
 555     pass
 556
 557 class GenBitmapTextToggleButton(__ToggleMixin, GenBitmapTextButton):
 558     """A generic toggle bitmap button with text label"""
 559     pass
 560
 561 #----------------------------------------------------------------------
 562
 563