1 # --------------------------------------------------------------------------- #
2 # FANCYBUTTONPANEL Widget wxPython IMPLEMENTATION
4 # Original C++ Code From Eran. You Can Find It At:
6 # http://wxforum.shadonet.com/viewtopic.php?t=6619
8 # License: wxWidgets license
13 # Andrea Gavana, @ 02 Oct 2006
14 # Latest Revision: 17 Oct 2006, 17.00 GMT
17 # For All Kind Of Problems, Requests Of Enhancements And Bug Reports, Please
20 # andrea.gavana@gmail.com
23 # Or, Obviously, To The wxPython Mailing List!!!
27 # --------------------------------------------------------------------------- #
30 With `ButtonPanel` class you have a panel with gradient coloring
31 on it and with the possibility to place some buttons on it. Using a
32 standard panel with normal wx.Buttons leads to an ugly result: the
33 buttons are placed correctly on the panel - but with grey area around
34 them. Gradient coloring is kept behind the images - this was achieved
35 due to the PNG format and the transparency of the bitmaps.
37 The image are functioning like a buttons and can be caught in your
38 code using the usual self.Bind(wx.EVT_BUTTON, self.OnButton) method.
40 The control is generic, and support theming (well, I tested it under
41 Windows with the three defauls themes: grey, blue, silver and the
48 ButtonPanel supports 4 alignments: left, right, top, bottom, which have a
49 different meaning and behavior wrt wx.Toolbar. The easiest thing is to try
50 the demo to understand, but I'll try to explain how it works.
52 CASE 1: ButtonPanel has a main caption text
54 Left alignment means ButtonPanel is horizontal, with the text aligned to the
55 left. When you shrink the demo frame, if there is not enough room for all
56 the controls to be shown, the controls closest to the text are hidden;
58 Right alignment means ButtonPanel is horizontal, with the text aligned to the
59 right. Item layout as above;
61 Top alignment means ButtonPanel is vertical, with the text aligned to the top.
64 Bottom alignment means ButtonPanel is vertical, with the text aligned to the
65 bottom. Item layout as above.
68 CASE 2: ButtonPanel has *no* main caption text
69 In this case, left and right alignment are the same (as top and bottom are the same),
70 but the layout strategy changes: now if there is not enough room for all the controls
71 to be shown, the last added items are hidden ("last" means on the far right for
72 horizontal ButtonPanels and far bottom for vertical ButtonPanels).
75 The following example shows a simple implementation that uses ButtonPanel
76 inside a very simple frame::
78 class MyFrame(wx.Frame):
80 def __init__(self, parent, id=-1, title="ButtonPanel", pos=wx.DefaultPosition,
81 size=(800, 600), style=wx.DEFAULT_FRAME_STYLE):
83 wx.Frame.__init__(self, parent, id, title, pos, size, style)
85 mainPanel = wx.Panel(self, -1)
86 self.logtext = wx.TextCtrl(mainPanel, -1, "", style=wx.TE_MULTILINE)
88 vSizer = wx.BoxSizer(wx.VERTICAL)
89 mainPanel.SetSizer(vSizer)
91 alignment = BP_ALIGN_RIGHT
93 titleBar = ButtonPanel(mainPanel, -1, "A Simple Test & Demo")
95 btn1 = ButtonInfo(wx.NewId(), wx.Bitmap("png4.png", wx.BITMAP_TYPE_PNG))
96 titleBar.AddButton(btn1)
97 self.Bind(wx.EVT_BUTTON, self.OnButton, btn1)
99 btn2 = ButtonInfo(wx.NewId(), wx.Bitmap("png3.png", wx.BITMAP_TYPE_PNG))
100 titleBar.AddButton(btn2)
101 self.Bind(wx.EVT_BUTTON, self.OnButton, btn2)
103 btn3 = ButtonInfo(wx.NewId(), wx.Bitmap("png2.png", wx.BITMAP_TYPE_PNG))
104 titleBar.AddButton(btn3)
105 self.Bind(wx.EVT_BUTTON, self.OnButton, btn3)
107 btn4 = ButtonInfo(wx.NewId(), wx.Bitmap("png1.png", wx.BITMAP_TYPE_PNG))
108 titleBar.AddButton(btn4)
109 self.Bind(wx.EVT_BUTTON, self.OnButton, btn4)
111 vSizer.Add(titleBar, 0, wx.EXPAND)
113 vSizer.Add(self.logtext, 1, wx.EXPAND|wx.ALL, 5)
117 # our normal wxApp-derived class, as usual
119 app = wx.PySimpleApp()
121 frame = MyFrame(None)
122 app.SetTopWindow(frame)
130 ButtonPanel Is Freeware And Distributed Under The wxPython License.
132 Latest Revision: Andrea Gavana @ 12 Oct 2006, 17.00 GMT
140 # Some constants to tune the BPArt class
141 BP_BACKGROUND_COLOR
= 0
142 """ Background brush colour when no gradient shading exists. """
143 BP_GRADIENT_COLOR_FROM
= 1
144 """ Starting gradient colour, used only when BP_USE_GRADIENT style is applied. """
145 BP_GRADIENT_COLOR_TO
= 2
146 """ Ending gradient colour, used only when BP_USE_GRADIENT style is applied. """
148 """ Pen colour to paint the border of ButtonPanel. """
150 """ Main ButtonPanel caption colour. """
151 BP_BUTTONTEXT_COLOR
= 5
152 """ Text colour for buttons with text. """
153 BP_BUTTONTEXT_INACTIVE_COLOR
= 6
154 """ Text colour for inactive buttons with text. """
155 BP_SELECTION_BRUSH_COLOR
= 7
156 """ Brush colour to be used when hovering or selecting a button. """
157 BP_SELECTION_PEN_COLOR
= 8
158 """ Pen colour to be used when hovering or selecting a button. """
159 BP_SEPARATOR_COLOR
= 9
160 """ Pen colour used to paint the separators. """
162 """ Font of the ButtonPanel main caption. """
163 BP_BUTTONTEXT_FONT
= 11
164 """ Text font for the buttons with text. """
166 BP_BUTTONTEXT_ALIGN_BOTTOM
= 12
167 """ Flag that indicates the image and text in buttons is stacked. """
168 BP_BUTTONTEXT_ALIGN_RIGHT
= 13
169 """ Flag that indicates the text is shown alongside the image in buttons with text. """
171 BP_SEPARATOR_SIZE
= 14
173 Separator size. NB: This is not the line width, but the sum of the space before
174 and after the separator line plus the width of the line.
178 Size of the left/right margins in ButtonPanel (top/bottom for vertically
179 aligned ButtonPanels).
182 """ Size of the border. """
184 """ Inter-tool separator size. """
186 # Caption Gradient Type
188 """ No gradient shading should be used to paint the background. """
189 BP_GRADIENT_VERTICAL
= 1
190 """ Vertical gradient shading should be used to paint the background. """
191 BP_GRADIENT_HORIZONTAL
= 2
192 """ Horizontal gradient shading should be used to paint the background. """
194 # Flags for HitTest() method
198 # Alignment of buttons in the panel
208 # Delay used to cancel the longHelp in the statusbar field
212 # Check for the new method in 2.7 (not present in 2.6.3.3)
213 if wx
.VERSION_STRING
< "2.7":
214 wx
.Rect
.Contains
= lambda self
, point
: wx
.Rect
.Inside(self
, point
)
217 def BrightenColour(color
, factor
):
218 """ Bright the input colour by a factor."""
220 val
= color
.Red()*factor
226 val
= color
.Green()*factor
232 val
= color
.Blue()*factor
238 return wx
.Color(red
, green
, blue
)
241 def GrayOut(anImage
):
243 Convert the given image (in place) to a grayed-out version,
244 appropriate for a 'Disabled' appearance.
247 factor
= 0.7 # 0 < f < 1. Higher Is Grayer
249 anImage
= anImage
.ConvertToImage()
250 if anImage
.HasAlpha():
251 anImage
.ConvertAlphaToMask(1)
253 if anImage
.HasMask():
254 maskColor
= (anImage
.GetMaskRed(), anImage
.GetMaskGreen(), anImage
.GetMaskBlue())
258 data
= map(ord, list(anImage
.GetData()))
260 for i
in range(0, len(data
), 3):
262 pixel
= (data
[i
], data
[i
+1], data
[i
+2])
263 pixel
= MakeGray(pixel
, factor
, maskColor
)
268 anImage
.SetData(''.join(map(chr, data
)))
270 anImage
= anImage
.ConvertToBitmap()
275 def MakeGray((r
,g
,b
), factor
, maskColor
):
277 Make a pixel grayed-out. If the pixel matches the maskColor, it won't be
281 if (r
,g
,b
) != maskColor
:
282 return map(lambda x
: int((230 - x
) * factor
) + x
, (r
,g
,b
))
287 # ---------------------------------------------------------------------------- #
289 # Handles all the drawings for buttons, separators and text and allows the
290 # programmer to set colours, sizes and gradient shadings for ButtonPanel
291 # ---------------------------------------------------------------------------- #
295 BPArt is an art provider class which does all of the drawing for ButtonPanel.
296 This allows the library caller to customize the BPArt or to completely replace
297 all drawing with custom BPArts.
300 def __init__(self
, parentStyle
):
301 """ Default class constructor. """
303 base_color
= wx
.SystemSettings_GetColour(wx
.SYS_COLOUR_3DFACE
)
305 self
._background
_brush
= wx
.Brush(base_color
, wx
.SOLID
)
306 self
._gradient
_color
_to
= wx
.WHITE
307 self
._gradient
_color
_from
= wx
.SystemSettings_GetColour(wx
.SYS_COLOUR_ACTIVECAPTION
)
309 if parentStyle
& BP_USE_GRADIENT
:
310 self
._border
_pen
= wx
.Pen(wx
.WHITE
, 3)
311 self
._caption
_text
_color
= wx
.WHITE
312 self
._buttontext
_color
= wx
.Colour(70, 143, 255)
313 self
._separator
_pen
= wx
.Pen(BrightenColour(self
._gradient
_color
_from
, 1.4))
314 self
._gradient
_type
= BP_GRADIENT_VERTICAL
316 self
._border
_pen
= wx
.Pen(BrightenColour(base_color
, 0.9), 3)
317 self
._caption
_text
_color
= wx
.BLACK
318 self
._buttontext
_color
= wx
.SystemSettings_GetColour(wx
.SYS_COLOUR_BTNTEXT
)
319 self
._separator
_pen
= wx
.Pen(BrightenColour(base_color
, 0.9))
320 self
._gradient
_type
= BP_GRADIENT_NONE
322 self
._buttontext
_inactive
_color
= wx
.SystemSettings_GetColour(wx
.SYS_COLOUR_GRAYTEXT
)
323 self
._selection
_brush
= wx
.Brush(wx
.Color(225, 225, 255))
324 self
._selection
_pen
= wx
.Pen(wx
.SystemSettings_GetColour(wx
.SYS_COLOUR_ACTIVECAPTION
))
326 sysfont
= wx
.SystemSettings
.GetFont(wx
.SYS_DEFAULT_GUI_FONT
)
327 self
._caption
_font
= wx
.Font(sysfont
.GetPointSize(), wx
.DEFAULT
, wx
.NORMAL
, wx
.BOLD
,
328 False, sysfont
.GetFaceName())
329 self
._buttontext
_font
= wx
.Font(sysfont
.GetPointSize(), wx
.DEFAULT
, wx
.NORMAL
, wx
.NORMAL
,
330 False, sysfont
.GetFaceName())
332 self
._separator
_size
= 7
333 self
._margins
_size
= wx
.Size(6, 6)
334 self
._caption
_border
_size
= 3
335 self
._padding
_size
= wx
.Size(6, 6)
338 def GetMetric(self
, id):
339 """ Returns sizes of customizable options. """
341 if id == BP_SEPARATOR_SIZE
:
342 return self
._separator
_size
343 elif id == BP_MARGINS_SIZE
:
344 return self
._margins
_size
345 elif id == BP_BORDER_SIZE
:
346 return self
._caption
_border
_size
347 elif id == BP_PADDING_SIZE
:
348 return self
._padding
_size
350 raise "\nERROR: Invalid Metric Ordinal. "
353 def SetMetric(self
, id, new_val
):
354 """ Sets sizes for customizable options. """
356 if id == BP_SEPARATOR_SIZE
:
357 self
._separator
_size
= new_val
358 elif id == BP_MARGINS_SIZE
:
359 self
._margins
_size
= new_val
360 elif id == BP_BORDER_SIZE
:
361 self
._caption
_border
_size
= new_val
362 self
._border
_pen
.SetWidth(new_val
)
363 elif id == BP_PADDING_SIZE
:
364 self
._padding
_size
= new_val
366 raise "\nERROR: Invalid Metric Ordinal. "
369 def GetColor(self
, id):
370 """ Returns colours of customizable options. """
372 if id == BP_BACKGROUND_COLOR
:
373 return self
._background
_brush
.GetColour()
374 elif id == BP_GRADIENT_COLOR_FROM
:
375 return self
._gradient
_color
_from
376 elif id == BP_GRADIENT_COLOR_TO
:
377 return self
._gradient
_color
_to
378 elif id == BP_BORDER_COLOR
:
379 return self
._border
_pen
.GetColour()
380 elif id == BP_TEXT_COLOR
:
381 return self
._caption
_text
_color
382 elif id == BP_BUTTONTEXT_COLOR
:
383 return self
._buttontext
_color
384 elif id == BP_BUTTONTEXT_INACTIVE_COLOR
:
385 return self
._buttontext
_inactive
_color
386 elif id == BP_SELECTION_BRUSH_COLOR
:
387 return self
._selection
_brush
.GetColour()
388 elif id == BP_SELECTION_PEN_COLOR
:
389 return self
._selection
_pen
.GetColour()
390 elif id == BP_SEPARATOR_COLOR
:
391 return self
._separator
_pen
.GetColour()
393 raise "\nERROR: Invalid Colour Ordinal. "
396 def SetColor(self
, id, colour
):
397 """ Sets colours for customizable options. """
399 if id == BP_BACKGROUND_COLOR
:
400 self
._background
_brush
.SetColour(colour
)
401 elif id == BP_GRADIENT_COLOR_FROM
:
402 self
._gradient
_color
_from
= colour
403 elif id == BP_GRADIENT_COLOR_TO
:
404 self
._gradient
_color
_to
= colour
405 elif id == BP_BORDER_COLOR
:
406 self
._border
_pen
.SetColour(colour
)
407 elif id == BP_TEXT_COLOR
:
408 self
._caption
_text
_color
= colour
409 elif id == BP_BUTTONTEXT_COLOR
:
410 self
._buttontext
_color
= colour
411 elif id == BP_BUTTONTEXT_INACTIVE_COLOR
:
412 self
._buttontext
_inactive
_color
= colour
413 elif id == BP_SELECTION_BRUSH_COLOR
:
414 self
._selection
_brush
.SetColour(colour
)
415 elif id == BP_SELECTION_PEN_COLOR
:
416 self
._selection
_pen
.SetColour(colour
)
417 elif id == BP_SEPARATOR_COLOR
:
418 self
._separator
_pen
.SetColour(colour
)
420 raise "\nERROR: Invalid Colour Ordinal. "
427 def SetFont(self
, id, font
):
428 """ Sets font for customizable options. """
430 if id == BP_TEXT_FONT
:
431 self
._caption
_font
= font
432 elif id == BP_BUTTONTEXT_FONT
:
433 self
._buttontext
_font
= font
436 def GetFont(self
, id):
437 """ Returns font of customizable options. """
439 if id == BP_TEXT_FONT
:
440 return self
._caption
_font
441 elif id == BP_BUTTONTEXT_FONT
:
442 return self
._buttontext
_font
447 def SetGradientType(self
, gradient
):
448 """ Sets the gradient type for BPArt drawings. """
450 self
._gradient
_type
= gradient
453 def GetGradientType(self
):
454 """ Returns the gradient type for BPArt drawings. """
456 return self
._gradient
_type
459 def DrawSeparator(self
, dc
, rect
, isVertical
):
460 """ Draws a separator in ButtonPanel. """
462 dc
.SetPen(self
._separator
_pen
)
465 ystart
= yend
= rect
.y
+ rect
.height
/2
466 xstart
= int(rect
.x
+ 1.5*self
._caption
_border
_size
)
467 xend
= int(rect
.x
+ rect
.width
- 1.5*self
._caption
_border
_size
)
468 dc
.DrawLine(xstart
, ystart
, xend
, yend
)
470 xstart
= xend
= rect
.x
+ rect
.width
/2
471 ystart
= int(rect
.y
+ 1.5*self
._caption
_border
_size
)
472 yend
= int(rect
.y
+ rect
.height
- 1.5*self
._caption
_border
_size
)
473 dc
.DrawLine(xstart
, ystart
, xend
, yend
)
476 def DrawCaption(self
, dc
, rect
, captionText
):
477 """ Draws the main caption text in ButtonPanel. """
479 textColour
= self
._caption
_text
_color
480 textFont
= self
._caption
_font
481 padding
= self
._padding
_size
483 dc
.SetTextForeground(textColour
)
486 dc
.DrawText(captionText
, rect
.x
+ padding
.x
, rect
.y
+padding
.y
)
489 def DrawButton(self
, dc
, rect
, parentSize
, buttonBitmap
, isVertical
,
490 buttonStatus
, isToggled
, textAlignment
, text
=""):
491 """ Draws a button in ButtonPanel, together with its text (if any). """
493 bmpxsize
, bmpysize
= buttonBitmap
.GetWidth(), buttonBitmap
.GetHeight()
496 borderw
= self
._caption
_border
_size
497 padding
= self
._padding
_size
499 buttonFont
= self
._buttontext
_font
500 dc
.SetFont(buttonFont
)
504 rect
= wx
.Rect(borderw
, rect
.y
, rect
.width
-2*borderw
, rect
.height
)
508 textW
, textH
= dc
.GetTextExtent(text
)
510 if textAlignment
== BP_BUTTONTEXT_ALIGN_RIGHT
:
511 fullExtent
= bmpxsize
+ padding
.x
/2 + textW
512 bmpypos
= rect
.y
+ (rect
.height
- bmpysize
)/2
513 bmpxpos
= rect
.x
+ (rect
.width
- fullExtent
)/2
514 textxpos
= bmpxpos
+ padding
.x
/2 + bmpxsize
515 textypos
= bmpypos
+ (bmpysize
- textH
)/2
517 bmpxpos
= rect
.x
+ (rect
.width
- bmpxsize
)/2
518 bmpypos
= rect
.y
+ padding
.y
519 textxpos
= rect
.x
+ (rect
.width
- textW
)/2
520 textypos
= bmpypos
+ bmpysize
+ padding
.y
/2
522 bmpxpos
= rect
.x
+ (rect
.width
- bmpxsize
)/2
523 bmpypos
= rect
.y
+ (rect
.height
- bmpysize
)/2
528 rect
= wx
.Rect(rect
.x
, borderw
, rect
.width
, rect
.height
-2*borderw
)
532 textW
, textH
= dc
.GetTextExtent(text
)
534 if textAlignment
== BP_BUTTONTEXT_ALIGN_RIGHT
:
535 fullExtent
= bmpxsize
+ padding
.x
/2 + textW
536 bmpypos
= rect
.y
+ (rect
.height
- bmpysize
)/2
537 bmpxpos
= rect
.x
+ (rect
.width
- fullExtent
)/2
538 textxpos
= bmpxpos
+ padding
.x
/2 + bmpxsize
539 textypos
= bmpypos
+ (bmpysize
- textH
)/2
541 fullExtent
= bmpysize
+ padding
.y
/2 + textH
542 bmpxpos
= rect
.x
+ (rect
.width
- bmpxsize
)/2
543 bmpypos
= rect
.y
+ (rect
.height
- fullExtent
)/2
544 textxpos
= rect
.x
+ (rect
.width
- textW
)/2
545 textypos
= bmpypos
+ bmpysize
+ padding
.y
/2
547 bmpxpos
= rect
.x
+ (rect
.width
- bmpxsize
)/2
548 bmpypos
= rect
.y
+ (rect
.height
- bmpysize
)/2
551 # [ Padding | Text | .. Buttons .. | Padding ]
553 if buttonStatus
in ["Pressed", "Toggled", "Hover"]:
554 dc
.SetBrush(self
._selection
_brush
)
555 dc
.SetPen(self
._selection
_pen
)
556 dc
.DrawRoundedRectangleRect(rect
, 4)
558 if buttonStatus
== "Pressed" or isToggled
:
561 dc
.DrawBitmap(buttonBitmap
, bmpxpos
+dx
, bmpypos
+dy
, True)
564 isEnabled
= buttonStatus
!= "Disabled"
565 self
.DrawLabel(dc
, text
, isEnabled
, textxpos
+dx
, textypos
+dy
)
568 def DrawLabel(self
, dc
, text
, isEnabled
, xpos
, ypos
):
569 """ Draws the label for a button. """
572 dc
.SetTextForeground(self
._buttontext
_inactive
_color
)
574 dc
.SetTextForeground(self
._buttontext
_color
)
576 dc
.DrawText(text
, xpos
, ypos
)
579 def DrawButtonPanel(self
, dc
, rect
, style
):
580 """ Paint the ButtonPanel's background. """
582 if style
& BP_USE_GRADIENT
:
583 # Draw gradient color in the backgroud of the panel
584 self
.FillGradientColor(dc
, rect
)
586 # Draw a rectangle around the panel
587 backBrush
= (style
& BP_USE_GRADIENT
and [wx
.TRANSPARENT_BRUSH
] or \
588 [self
._background
_brush
])[0]
590 dc
.SetBrush(backBrush
)
591 dc
.SetPen(self
._border
_pen
)
592 dc
.DrawRectangleRect(rect
)
595 def FillGradientColor(self
, dc
, rect
):
596 """ Gradient fill from colour 1 to colour 2 with top to bottom or left to right. """
598 if rect
.height
< 1 or rect
.width
< 1:
601 isVertical
= self
._gradient
_type
== BP_GRADIENT_VERTICAL
602 size
= (isVertical
and [rect
.height
] or [rect
.width
])[0]
603 start
= (isVertical
and [rect
.y
] or [rect
.x
])[0]
605 # calculate gradient coefficients
607 col2
= self
._gradient
_color
_from
608 col1
= self
._gradient
_color
_to
611 rstep
= float((col2
.Red() - col1
.Red()))/float(size
)
612 gstep
= float((col2
.Green() - col1
.Green()))/float(size
)
613 bstep
= float((col2
.Blue() - col1
.Blue()))/float(size
)
615 for coord
in xrange(start
, start
+ size
):
617 currCol
= wx
.Colour(col1
.Red() + rf
, col1
.Green() + gf
, col1
.Blue() + bf
)
618 dc
.SetBrush(wx
.Brush(currCol
, wx
.SOLID
))
619 dc
.SetPen(wx
.Pen(currCol
))
621 dc
.DrawLine(rect
.x
, coord
, rect
.x
+ rect
.width
, coord
)
623 dc
.DrawLine(coord
, rect
.y
, coord
, rect
.y
+ rect
.height
)
630 class StatusBarTimer(wx
.Timer
):
631 """Timer used for deleting StatusBar long help after _DELAY seconds."""
633 def __init__(self
, owner
):
635 Default class constructor.
636 For internal use: do not call it in your code!
639 wx
.Timer
.__init
__(self
)
644 """The timer has expired."""
646 self
._owner
.OnStatusBarTimer()
649 class Control(wx
.EvtHandler
):
651 def __init__(self
, parent
, size
=wx
.Size(-1, -1)):
653 Default class constructor.
655 Base class for all pseudo controls
656 parent = parent object
657 size = (width, height)
660 wx
.EvtHandler
.__init
__(self
)
662 self
._parent
= parent
663 self
._id
= wx
.NewId()
669 def Show(self
, show
=True):
670 """ Shows or hide the control. """
676 """ Hides the control. """
682 """ Returns whether the control is shown or not. """
688 """ Returns the control id. """
693 def GetBestSize(self
):
694 """ Returns the control best size. """
700 """ Disables the control. """
705 def Enable(self
, value
=True):
706 """ Enables or disables the control. """
708 self
.disabled
= not value
711 def SetFocus(self
, focus
=True):
712 """ Sets or kills the focus on the control. """
718 """ Returns whether the control has the focus or not. """
723 def OnMouseEvent(self
, x
, y
, event
):
726 def Draw(self
, rect
):
735 This is a mix-in class to add pseudo support to a wx sizer. Just create
736 a new class that derives from this class and the wx sizer and intercepts
737 any methods that add to the wx sizer.
740 self
.children
= [] # list of child Pseudo Controls
742 # Sizer doesn't use the x1,y1,x2,y2 so allow it to
743 # be called with or without the coordinates
744 def Draw(self
, dc
, x1
=0, y1
=0, x2
=0, y2
=0):
745 for item
in self
.children
:
746 # use sizer coordinates rather than
748 c
= item
.GetUserData()
749 c
.Draw(dc
, item
.GetRect())
751 def GetBestSize(self
):
752 # this should be handled by the wx.Sizer based class
753 return self
.GetMinSize()
757 class BoxSizer(Sizer
, wx
.BoxSizer
):
758 def __init__(self
, orient
=wx
.HORIZONTAL
):
759 wx
.BoxSizer
.__init
__(self
, orient
)
762 #-------------------------------------------
763 # sizer overrides (only called from Python)
764 #-------------------------------------------
765 # no support for user data if it's a pseudocontrol
766 # since that is already used
767 def Add(self
, item
, proportion
=0, flag
=0, border
=0, userData
=None):
768 # check to see if it's a pseudo object or sizer
769 if isinstance(item
, Sizer
):
770 szitem
= wx
.BoxSizer
.Add(self
, item
, proportion
, flag
, border
, item
)
771 self
.children
.append(szitem
)
772 elif isinstance(item
, Control
): # Control should be what ever class your controls come from
773 sz
= item
.GetBestSize()
774 # add a spacer to track this object
775 szitem
= wx
.BoxSizer
.Add(self
, sz
, proportion
, flag
, border
, item
)
776 self
.children
.append(szitem
)
778 wx
.BoxSizer
.Add(self
, item
, proportion
, flag
, border
, userData
)
780 def Prepend(self
, item
, proportion
=0, flag
=0, border
=0, userData
=None):
781 # check to see if it's a pseudo object or sizer
782 if isinstance(item
, Sizer
):
783 szitem
= wx
.BoxSizer
.Prepend(self
, item
, proportion
, flag
, border
, item
)
784 self
.children
.append(szitem
)
785 elif isinstance(item
, Control
): # Control should be what ever class your controls come from
786 sz
= item
.GetBestSize()
787 # add a spacer to track this object
788 szitem
= wx
.BoxSizer
.Prepend(self
, sz
, proportion
, flag
, border
, item
)
789 self
.children
.insert(0,szitem
)
791 wx
.BoxSizer
.Prepend(self
, item
, proportion
, flag
, border
, userData
)
793 def Insert(self
, before
, item
, proportion
=0, flag
=0, border
=0, userData
=None, realIndex
=None):
794 # check to see if it's a pseudo object or sizer
795 if isinstance(item
, Sizer
):
796 szitem
= wx
.BoxSizer
.Insert(self
, before
, item
, proportion
, flag
, border
, item
)
797 self
.children
.append(szitem
)
798 elif isinstance(item
, Control
): # Control should be what ever class your controls come from
799 sz
= item
.GetBestSize()
800 # add a spacer to track this object
801 szitem
= wx
.BoxSizer
.Insert(self
, before
, sz
, proportion
, flag
, border
, item
)
802 if realIndex
is not None:
803 self
.children
.insert(realIndex
,szitem
)
805 self
.children
.insert(before
,szitem
)
808 wx
.BoxSizer
.Insert(self
, before
, item
, proportion
, flag
, border
, userData
)
811 def Remove(self
, indx
, pop
=-1):
814 self
.children
.pop(pop
)
816 wx
.BoxSizer
.Remove(self
, indx
)
821 for ii
, child
in enumerate(self
.GetChildren()):
822 item
= child
.GetUserData()
823 if item
and child
.IsShown():
824 self
.SetItemMinSize(ii
, *item
.GetBestSize())
826 wx
.BoxSizer
.Layout(self
)
829 def Show(self
, item
, show
=True):
831 child
= self
.GetChildren()[item
]
832 if child
and child
.GetUserData():
833 child
.GetUserData().Show(show
)
835 wx
.BoxSizer
.Show(self
, item
, show
)
838 # ---------------------------------------------------------------------------- #
840 # This class holds all the information to size and draw a separator inside
842 # ---------------------------------------------------------------------------- #
844 class Separator(Control
):
846 def __init__(self
, parent
):
847 """ Default class constructor. """
850 self
._parent
= parent
851 Control
.__init
__(self
, parent
)
854 def GetBestSize(self
):
855 """ Returns the separator best size. """
857 # 10 is completely arbitrary, but it works anyhow
858 if self
._parent
.IsVertical():
859 return wx
.Size(10, self
._parent
._art
.GetMetric(BP_SEPARATOR_SIZE
))
861 return wx
.Size(self
._parent
._art
.GetMetric(BP_SEPARATOR_SIZE
), 10)
864 def Draw(self
, dc
, rect
):
865 """ Draws the separator. Actually the drawing is done in BPArt. """
867 if not self
.IsShown():
870 isVertical
= self
._parent
.IsVertical()
871 self
._parent
._art
.DrawSeparator(dc
, rect
, isVertical
)
874 # ---------------------------------------------------------------------------- #
875 # Class ButtonPanelText
876 # This class is used to hold data about the main caption in ButtonPanel
877 # ---------------------------------------------------------------------------- #
879 class ButtonPanelText(Control
):
881 def __init__(self
, parent
, text
=""):
882 """ Default class constructor. """
886 self
._parent
= parent
888 Control
.__init
__(self
, parent
)
892 """ Returns the caption text. """
897 def SetText(self
, text
=""):
898 """ Sets the caption text. """
904 """ Convenience function to create a DC. """
906 dc
= wx
.ClientDC(self
._parent
)
907 textFont
= self
._parent
._art
.GetFont(BP_TEXT_FONT
)
913 def GetBestSize(self
):
914 """ Returns the best size for the main caption in ButtonPanel. """
920 rect
= self
._parent
.GetClientRect()
922 tw
, th
= dc
.GetTextExtent(self
._text
)
923 padding
= self
._parent
._art
.GetMetric(BP_PADDING_SIZE
)
924 self
._size
= wx
.Size(tw
+2*padding
.x
, th
+2*padding
.y
)
929 def Draw(self
, dc
, rect
):
930 """ Draws the main caption. Actually the drawing is done in BPArt. """
932 if not self
.IsShown():
935 captionText
= self
.GetText()
936 self
._parent
._art
.DrawCaption(dc
, rect
, captionText
)
939 # -- ButtonInfo class implementation ----------------------------------------
940 # This class holds information about every button that is added to
941 # ButtonPanel. It is an auxiliary class that you should use
942 # every time you add a button.
944 class ButtonInfo(Control
):
946 def __init__(self
, parent
, id=wx
.ID_ANY
, bmp
=wx
.NullBitmap
,
947 status
="Normal", text
="", kind
=wx
.ITEM_NORMAL
,
948 shortHelp
="", longHelp
=""):
950 Default class constructor.
953 - parent: the parent window (ButtonPanel);
955 - bmp: the associated bitmap;
956 - status: button status (pressed, hovered, normal).
957 - text: text to be displayed either below of to the right of the button
958 - kind: button kind, may be wx.ITEM_NORMAL for standard buttons or
959 wx.ITEM_CHECK for toggle buttons;
960 - shortHelp: a short help to be shown in the button tooltip;
961 - longHelp: this string is shown in the statusbar (if any) of the parent
962 frame when the mouse pointer is inside the button.
968 self
._status
= status
969 self
._rect
= wx
.Rect()
973 self
._textAlignment
= BP_BUTTONTEXT_ALIGN_BOTTOM
974 self
._shortHelp
= shortHelp
975 self
._longHelp
= longHelp
977 disabledbmp
= GrayOut(bmp
)
979 self
._bitmaps
= {"Normal": bmp
, "Toggled": None, "Disabled": disabledbmp
,
980 "Hover": None, "Pressed": None}
982 Control
.__init
__(self
, parent
)
985 def GetBestSize(self
):
986 """ Returns the best size for the button. """
988 xsize
= self
.GetBitmap().GetWidth()
989 ysize
= self
.GetBitmap().GetHeight()
992 # We have text in the button
993 dc
= wx
.ClientDC(self
._parent
)
994 normalFont
= self
._parent
._art
.GetFont(BP_BUTTONTEXT_FONT
)
995 dc
.SetFont(normalFont
)
996 tw
, th
= dc
.GetTextExtent(self
.GetText())
998 if self
.GetTextAlignment() == BP_BUTTONTEXT_ALIGN_BOTTOM
:
999 xsize
= max(xsize
, tw
)
1003 ysize
= max(ysize
, th
)
1005 border
= self
._parent
._art
.GetMetric(BP_BORDER_SIZE
)
1006 padding
= self
._parent
._art
.GetMetric(BP_PADDING_SIZE
)
1008 if self
._parent
.IsVertical():
1009 xsize
= xsize
+ 2*border
1011 ysize
= ysize
+ 2*border
1013 self
._size
= wx
.Size(xsize
+2*padding
.x
, ysize
+2*padding
.y
)
1018 def Draw(self
, dc
, rect
):
1019 """ Draws the button on ButtonPanel. Actually the drawing is done in BPArt. """
1021 if not self
.IsShown():
1024 buttonBitmap
= self
.GetBitmap()
1025 isVertical
= self
._parent
.IsVertical()
1026 text
= self
.GetText()
1027 parentSize
= self
._parent
.GetSize()[not isVertical
]
1028 buttonStatus
= self
.GetStatus()
1029 isToggled
= self
.GetToggled()
1030 textAlignment
= self
.GetTextAlignment()
1032 self
._parent
._art
.DrawButton(dc
, rect
, parentSize
, buttonBitmap
, isVertical
,
1033 buttonStatus
, isToggled
, textAlignment
, text
)
1038 def CheckRefresh(self
, status
):
1039 """ Checks whether a ButtonPanel repaint is needed or not. Convenience function. """
1041 if status
== self
._status
:
1042 self
._parent
.RefreshRect(self
.GetRect())
1045 def SetBitmap(self
, bmp
, status
="Normal"):
1046 """ Sets the associated bitmap. """
1048 self
._bitmaps
[status
] = bmp
1049 self
.CheckRefresh(status
)
1052 def GetBitmap(self
, status
=None):
1053 """ Returns the associated bitmap. """
1056 status
= self
._status
1058 if not self
.IsEnabled():
1061 if self
._bitmaps
[status
] is None:
1062 return self
._bitmaps
["Normal"]
1064 return self
._bitmaps
[status
]
1068 """ Returns the button rect. """
1073 def GetStatus(self
):
1074 """ Returns the button status. """
1080 """ Returns the button id. """
1085 def SetRect(self
, rect
):
1086 """ Sets the button rect. """
1091 def SetStatus(self
, status
):
1092 """ Sets the button status. """
1094 if status
== self
._status
:
1097 if self
.GetToggled() and status
== "Normal":
1100 self
._status
= status
1101 self
._parent
.RefreshRect(self
.GetRect())
1104 def GetTextAlignment(self
):
1105 """ Returns the text alignment in the button (bottom or right). """
1107 return self
._textAlignment
1110 def SetTextAlignment(self
, alignment
):
1111 """ Sets the text alignment in the button (bottom or right). """
1113 if alignment
== self
._textAlignment
:
1116 self
._textAlignment
= alignment
1119 def GetToggled(self
):
1120 """ Returns whether a wx.ITEM_CHECK button is toggled or not. """
1122 if self
._kind
== wx
.ITEM_NORMAL
:
1128 def SetToggled(self
, toggle
=True):
1129 """ Sets a wx.ITEM_CHECK button toggled/not toggled. """
1131 if self
._kind
== wx
.ITEM_NORMAL
:
1134 self
._toggle
= toggle
1137 def SetId(self
, id):
1138 """ Sets the button id. """
1143 def AddStatus(self
, name
="Custom", bmp
=wx
.NullBitmap
):
1145 Add a programmer-defined status in addition to the 5 default status:
1153 self
._bitmaps
.update({name: bmp}
)
1156 def Enable(self
, enable
=True):
1159 self
._status
= "Normal"
1161 self
._status
= "Disabled"
1164 def IsEnabled(self
):
1166 return self
._status
!= "Disabled"
1169 def SetText(self
, text
=""):
1170 """ Sets the text of the button. """
1176 """ Returns the text associated to the button. """
1182 """ Returns whether the button has text or not. """
1184 return self
._text
!= ""
1187 def SetKind(self
, kind
=wx
.ITEM_NORMAL
):
1188 """ Sets the button type (standard or toggle). """
1194 """ Returns the button type (standard or toggle). """
1199 def SetShortHelp(self
, help=""):
1200 """ Sets the help string to be shown in a tootip. """
1202 self
._shortHelp
= help
1205 def GetShortHelp(self
):
1206 """ Returns the help string shown in a tootip. """
1208 return self
._shortHelp
1211 def SetLongHelp(self
, help=""):
1212 """ Sets the help string to be shown in the statusbar. """
1214 self
._longHelp
= help
1217 def GetLongHelp(self
):
1218 """ Returns the help string shown in the statusbar. """
1220 return self
._longHelp
1223 Bitmap
= property(GetBitmap
, SetBitmap
)
1224 Id
= property(GetId
, SetId
)
1225 Rect
= property(GetRect
, SetRect
)
1226 Status
= property(GetStatus
, SetStatus
)
1229 # -- ButtonPanel class implementation ----------------------------------
1230 # This is the main class.
1232 class ButtonPanel(wx
.PyPanel
):
1234 def __init__(self
, parent
, id=wx
.ID_ANY
, text
="", style
=BP_DEFAULT_STYLE
,
1235 alignment
=BP_ALIGN_LEFT
, name
="buttonPanel"):
1237 Default class constructor.
1239 - parent: parent window
1241 - text: text to draw
1242 - style: window style
1243 - alignment: alignment of buttons (left or right)
1244 - name: window class name
1247 wx
.PyPanel
.__init
__(self
, parent
, id, wx
.DefaultPosition
, wx
.DefaultSize
,
1248 wx
.NO_BORDER
, name
=name
)
1251 self
._vSeparators
= []
1253 self
._nStyle
= style
1254 self
._alignment
= alignment
1255 self
._statusTimer
= None
1256 self
._useHelp
= True
1257 self
._freezeCount
= 0
1258 self
._currentButton
= -1
1259 self
._haveTip
= False
1261 self
._art
= BPArt(style
)
1263 self
._controlCreated
= False
1265 direction
= (self
.IsVertical() and [wx
.VERTICAL
] or [wx
.HORIZONTAL
])[0]
1266 self
._mainsizer
= BoxSizer(direction
)
1267 self
.SetSizer(self
._mainsizer
)
1269 margins
= self
._art
.GetMetric(BP_MARGINS_SIZE
)
1271 # First spacer to create some room before the first text/button/control
1272 self
._mainsizer
.Add((margins
.x
, margins
.y
), 0)
1274 # Last spacer to create some room before the last text/button/control
1275 self
._mainsizer
.Add((margins
.x
, margins
.y
), 0)
1277 self
.Bind(wx
.EVT_SIZE
, self
.OnSize
)
1278 self
.Bind(wx
.EVT_PAINT
, self
.OnPaint
)
1279 self
.Bind(wx
.EVT_ERASE_BACKGROUND
, self
.OnEraseBackground
)
1280 self
.Bind(wx
.EVT_MOTION
, self
.OnMouseMove
)
1281 self
.Bind(wx
.EVT_LEFT_DOWN
, self
.OnLeftDown
)
1282 self
.Bind(wx
.EVT_LEFT_UP
, self
.OnLeftUp
)
1283 self
.Bind(wx
.EVT_LEAVE_WINDOW
, self
.OnMouseLeave
)
1284 self
.Bind(wx
.EVT_ENTER_WINDOW
, self
.OnMouseEnterWindow
)
1286 self
.SetBarText(text
)
1290 def SetBarText(self
, text
):
1291 """ Sets the main caption text (leave text="" for no text). """
1297 if self
._controlCreated
:
1300 self
._text
= ButtonPanelText(self
, text
)
1301 lenChildren
= len(self
._mainsizer
.GetChildren())
1304 # Even if we have no text, we insert it an empty spacer anyway
1305 # it is easier to handle if you have to recreate the sizer after.
1306 if self
.IsStandard():
1307 self
._mainsizer
.Insert(1, self
._text
, 0, wx
.ALIGN_CENTER
,
1308 userData
=self
._text
, realIndex
=0)
1310 self
._mainsizer
.Insert(lenChildren
-1, self
._text
, 0, wx
.ALIGN_CENTER
,
1311 userData
=self
._text
, realIndex
=lenChildren
)
1315 # We have text, so insert the text and an expandable spacer
1316 # alongside it. "Standard" ButtonPanel are left or top aligned.
1317 if self
.IsStandard():
1318 self
._mainsizer
.Insert(1, self
._text
, 0, wx
.ALIGN_CENTER
,
1319 userData
=self
._text
, realIndex
=0)
1320 self
._mainsizer
.Insert(2, (0, 0), 1, wx
.EXPAND
)
1323 self
._mainsizer
.Insert(lenChildren
-1, self
._text
, 0, wx
.ALIGN_CENTER
,
1324 userData
=self
._text
, realIndex
=lenChildren
)
1325 self
._mainsizer
.Insert(lenChildren
-1, (0, 0), 1, wx
.EXPAND
)
1328 def RemoveText(self
):
1329 """ Removes the main caption text. """
1331 lenChildren
= len(self
._mainsizer
.GetChildren())
1332 lenCustom
= len(self
._vButtons
) + len(self
._vSeparators
) + 1
1334 if self
.IsStandard():
1336 self
._mainsizer
.Remove(1, 0)
1337 if self
.HasBarText():
1338 # Detach the expandable spacer
1339 self
._mainsizer
.Remove(1, -1)
1342 self
._mainsizer
.Remove(lenChildren
-2, lenCustom
-1)
1343 if self
.HasBarText():
1344 # Detach the expandable spacer
1345 self
._mainsizer
.Remove(lenChildren
-3, -1)
1348 def GetBarText(self
):
1349 """ Returns the main caption text. """
1351 return self
._text
.GetText()
1354 def HasBarText(self
):
1355 """ Returns whether ButtonPanel has a main caption text or not. """
1357 return hasattr(self
, "_text") and self
._text
.GetText() != ""
1360 def AddButton(self
, btnInfo
):
1362 Adds a button to ButtonPanel. Remember to pass a ButtonInfo instance to
1363 this method. See the demo for details.
1366 lenChildren
= len(self
._mainsizer
.GetChildren())
1367 self
._mainsizer
.Insert(lenChildren
-1, btnInfo
, 0, wx
.ALIGN_CENTER|wx
.EXPAND
, userData
=btnInfo
)
1369 self
._vButtons
.append(btnInfo
)
1372 def AddSpacer(self
, size
=(0, 0), proportion
=1, flag
=wx
.EXPAND
):
1373 """ Adds a spacer (stretchable or fixed-size) to ButtonPanel. """
1375 lenChildren
= len(self
._mainsizer
.GetChildren())
1376 self
._mainsizer
.Insert(lenChildren
-1, size
, proportion
, flag
)
1379 def AddControl(self
, control
, proportion
=0, flag
=wx
.ALIGN_CENTER|wx
.ALL
, border
=None):
1380 """ Adds a wxPython control to ButtonPanel. """
1382 lenChildren
= len(self
._mainsizer
.GetChildren())
1385 border
= self
._art
.GetMetric(BP_PADDING_SIZE
)
1386 border
= max(border
.x
, border
.y
)
1388 self
._mainsizer
.Insert(lenChildren
-1, control
, proportion
, flag
, border
)
1391 def AddSeparator(self
):
1392 """ Adds a separator line to ButtonPanel. """
1394 lenChildren
= len(self
._mainsizer
.GetChildren())
1395 separator
= Separator(self
)
1397 self
._mainsizer
.Insert(lenChildren
-1, separator
, 0, wx
.EXPAND
)
1398 self
._vSeparators
.append(separator
)
1401 def RemoveAllButtons(self
):
1402 """ Remove all the buttons from ButtonPanel. """
1407 def RemoveAllSeparators(self
):
1408 """ Remove all the separators from ButtonPanel. """
1410 self
._vSeparators
= []
1413 def GetAlignment(self
):
1414 """ Returns the button alignment (left, right, top, bottom). """
1416 return self
._alignment
1419 def SetAlignment(self
, alignment
):
1420 """ Sets the button alignment (left, right, top, bottom). """
1422 if alignment
== self
._alignment
:
1427 text
= self
.GetBarText()
1429 # Remove the text in any case
1432 # Remove the first and last spacers
1433 self
._mainsizer
.Remove(0, -1)
1434 self
._mainsizer
.Remove(len(self
._mainsizer
.GetChildren())-1, -1)
1436 self
._alignment
= alignment
1438 # Recreate the sizer accordingly to the new alignment
1439 self
.ReCreateSizer(text
)
1442 def IsVertical(self
):
1443 """ Returns whether ButtonPanel is vertically aligned or not. """
1445 return self
._alignment
not in [BP_ALIGN_RIGHT
, BP_ALIGN_LEFT
]
1448 def IsStandard(self
):
1449 """ Returns whether ButtonPanel is aligned "Standard" (left/top) or not. """
1451 return self
._alignment
in [BP_ALIGN_LEFT
, BP_ALIGN_TOP
]
1456 Do the Layout for ButtonPanel.
1457 NB: Call this method every time you make a modification to the layout
1458 or to the customizable sizes of the pseudo controls.
1461 margins
= self
._art
.GetMetric(BP_MARGINS_SIZE
)
1462 lenChildren
= len(self
._mainsizer
.GetChildren())
1464 self
._mainsizer
.SetItemMinSize(0, (margins
.x
, margins
.y
))
1465 self
._mainsizer
.SetItemMinSize(lenChildren
-1, (margins
.x
, margins
.y
))
1467 self
._controlCreated
= True
1470 # *VERY* WEIRD: the sizer seems not to respond to any layout until I
1471 # change the ButtonPanel size and restore it back
1472 size
= self
.GetSize()
1473 self
.SetSize((size
.x
+1, size
.y
+1))
1474 self
.SetSize((size
.x
, size
.y
))
1480 def ReCreateSizer(self
, text
):
1481 """ Recreates the ButtonPanel sizer accordingly to the alignment specified. """
1483 children
= self
._mainsizer
.GetChildren()
1484 self
.RemoveAllButtons()
1485 self
.RemoveAllSeparators()
1487 # Create a new sizer depending on the alignment chosen
1488 direction
= (self
.IsVertical() and [wx
.VERTICAL
] or [wx
.HORIZONTAL
])[0]
1489 self
._mainsizer
= BoxSizer(direction
)
1491 margins
= self
._art
.GetMetric(BP_MARGINS_SIZE
)
1492 # First spacer to create some room before the first text/button/control
1493 self
._mainsizer
.Add((margins
.x
, margins
.y
), 0)
1495 # Last spacer to create some room before the last text/button/control
1496 self
._mainsizer
.Add((margins
.x
, margins
.y
), 0)
1498 # This is needed otherwise SetBarText goes mad
1499 self
._controlCreated
= False
1501 for child
in children
:
1502 userData
= child
.GetUserData()
1504 if isinstance(userData
, ButtonInfo
):
1505 # It is a ButtonInfo, can't be anything else
1506 self
.AddButton(child
.GetUserData())
1507 elif isinstance(userData
, Separator
):
1511 if child
.IsSpacer():
1512 # This is a spacer, expandable or not
1513 self
.AddSpacer(child
.GetSize(), child
.GetProportion(),
1516 # This is a wxPython control
1517 self
.AddControl(child
.GetWindow(), child
.GetProportion(),
1518 child
.GetFlag(), child
.GetBorder())
1520 self
.SetSizer(self
._mainsizer
)
1522 # Now add the text. It doesn't matter if there is no text
1523 self
.SetBarText(text
)
1530 def DoGetBestSize(self
):
1531 """ Returns the best size of ButtonPanel. """
1533 w
= h
= btnWidth
= btnHeight
= 0
1534 isVertical
= self
.IsVertical()
1536 padding
= self
._art
.GetMetric(BP_PADDING_SIZE
)
1537 border
= self
._art
.GetMetric(BP_BORDER_SIZE
)
1538 margins
= self
._art
.GetMetric(BP_MARGINS_SIZE
)
1539 separator_size
= self
._art
.GetMetric(BP_SEPARATOR_SIZE
)
1541 # Add the space required for the main caption
1542 if self
.HasBarText():
1543 w
, h
= self
._text
.GetBestSize()
1551 # Add the button's sizes
1552 for btn
in self
._vButtons
:
1554 bw
, bh
= btn
.GetBestSize()
1555 btnWidth
= max(btnWidth
, bw
)
1556 btnHeight
= max(btnHeight
, bh
)
1559 w
= max(w
, btnWidth
)
1562 h
= max(h
, btnHeight
)
1565 # Add the control's sizes
1566 for control
in self
.GetControls():
1567 cw
, ch
= control
.GetSize()
1575 # Add the separator's sizes and the 2 SizerItems at the beginning
1577 if self
.IsVertical():
1578 h
+= 2*margins
.y
+ len(self
._vSeparators
)*separator_size
1580 w
+= 2*margins
.x
+ len(self
._vSeparators
)*separator_size
1582 return wx
.Size(w
, h
)
1585 def OnPaint(self
, event
):
1586 """ Handles the wx.EVT_PAINT event for ButtonPanel. """
1588 dc
= wx
.BufferedPaintDC(self
)
1589 rect
= self
.GetClientRect()
1591 self
._art
.DrawButtonPanel(dc
, rect
, self
._nStyle
)
1592 self
._mainsizer
.Draw(dc
)
1595 def OnEraseBackground(self
, event
):
1596 """ Handles the wx.EVT_ERASE_BACKGROUND event for ButtonPanel (does nothing). """
1601 def OnSize(self
, event
):
1602 """ Handles the wx.EVT_SIZE event for ButtonPanel. """
1604 # NOTE: It seems like LayoutItems number of calls can be optimized in some way.
1605 # Currently every DoLayout (or every parent Layout()) calls about 3 times
1606 # the LayoutItems method. Any idea on how to improve it?
1613 def LayoutItems(self
):
1615 Layout the items using a different algorithm depending on the existance
1616 of the main caption.
1619 nonspacers
, allchildren
= self
.GetNonFlexibleChildren()
1621 if self
.HasBarText():
1622 self
.FlexibleLayout(nonspacers
, allchildren
)
1624 self
.SizeLayout(nonspacers
, allchildren
)
1626 self
._mainsizer
.Layout()
1629 def SizeLayout(self
, nonspacers
, children
):
1630 """ Layout the items when no main caption exists. """
1632 size
= self
.GetSize()
1633 isVertical
= self
.IsVertical()
1636 indx1
= len(nonspacers
)
1638 for item
in nonspacers
:
1639 corner
+= self
.GetItemSize(item
, isVertical
)
1640 if corner
> size
[isVertical
]:
1641 indx1
= nonspacers
.index(item
)
1644 # Leave out the last spacer, it has to be there always
1645 for ii
in xrange(len(nonspacers
)-1):
1646 indx
= children
.index(nonspacers
[ii
])
1647 self
._mainsizer
.Show(indx
, ii
< indx1
)
1650 def GetItemSize(self
, item
, isVertical
):
1651 """ Returns the size of an item in the main ButtonPanel sizer. """
1653 if item
.GetUserData():
1654 return item
.GetUserData().GetBestSize()[isVertical
]
1656 return item
.GetSize()[isVertical
]
1659 def FlexibleLayout(self
, nonspacers
, allchildren
):
1660 """ Layout the items when the main caption exists. """
1662 if len(nonspacers
) < 2:
1665 isVertical
= self
.IsVertical()
1666 isStandard
= self
.IsStandard()
1668 size
= self
.GetSize()[isVertical
]
1669 padding
= self
._art
.GetMetric(BP_PADDING_SIZE
)
1671 fixed
= (isStandard
and [nonspacers
[1]] or [nonspacers
[-2]])[0]
1674 nonspacers
.reverse()
1675 leftendx
= fixed
.GetSize()[isVertical
] + padding
.x
1677 rightstartx
= size
- fixed
.GetSize()[isVertical
]
1680 count
= lennonspacers
= len(nonspacers
)
1682 for item
in nonspacers
:
1684 size
-= self
.GetItemSize(item
, isVertical
)
1688 size
+= self
.GetItemSize(item
, isVertical
)
1689 if size
> rightstartx
:
1694 nonspacers
.reverse()
1696 for jj
in xrange(2, lennonspacers
):
1697 indx
= allchildren
.index(nonspacers
[jj
])
1698 self
._mainsizer
.Show(indx
, jj
>= count
)
1701 def GetNonFlexibleChildren(self
):
1703 Returns all the ButtonPanel main sizer's children that are not
1708 children2
= self
._mainsizer
.GetChildren()
1710 for child
in children2
:
1711 if child
.IsSpacer():
1712 if child
.GetUserData() or child
.GetProportion() == 0:
1713 children1
.append(child
)
1715 children1
.append(child
)
1717 return children1
, children2
1720 def GetControls(self
):
1721 """ Returns the wxPython controls that belongs to ButtonPanel. """
1723 children2
= self
._mainsizer
.GetChildren()
1724 children1
= [child
for child
in children2
if not child
.IsSpacer()]
1729 def SetStyle(self
, style
):
1730 """ Sets ButtonPanel style. """
1732 if style
== self
._nStyle
:
1735 self
._nStyle
= style
1740 """ Returns the ButtonPanel style. """
1745 def OnMouseMove(self
, event
):
1746 """ Handles the wx.EVT_MOTION event for ButtonPanel. """
1748 # Check to see if we are hovering a button
1749 tabId
, flags
= self
.HitTest(event
.GetPosition())
1751 if flags
!= BP_HT_BUTTON
:
1753 self
.RepaintOldSelection()
1754 self
._currentButton
= -1
1757 btn
= self
._vButtons
[tabId
]
1759 if not btn
.IsEnabled():
1761 self
.RepaintOldSelection()
1764 if tabId
!= self
._currentButton
:
1765 self
.RepaintOldSelection()
1767 if btn
.GetRect().Contains(event
.GetPosition()):
1768 if btn
.GetStatus() != "Pressed":
1769 btn
.SetStatus("Hover")
1771 btn
.SetStatus("Normal")
1773 if tabId
!= self
._currentButton
:
1775 self
.DoGiveHelp(btn
)
1777 self
._currentButton
= tabId
1782 def OnLeftDown(self
, event
):
1783 """ Handles the wx.EVT_LEFT_DOWN event for ButtonPanel. """
1785 tabId
, hit
= self
.HitTest(event
.GetPosition())
1787 if hit
== BP_HT_BUTTON
:
1788 btn
= self
._vButtons
[tabId
]
1790 btn
.SetStatus("Pressed")
1791 self
._currentButton
= tabId
1794 def OnLeftUp(self
, event
):
1795 """ Handles the wx.EVT_LEFT_UP event for ButtonPanel. """
1797 tabId
, flags
= self
.HitTest(event
.GetPosition())
1799 if flags
!= BP_HT_BUTTON
:
1802 hit
= self
._vButtons
[tabId
]
1804 if hit
.GetStatus() == "Disabled":
1807 for btn
in self
._vButtons
:
1811 if hit
.GetStatus() == "Pressed":
1812 hit
.SetToggled(not hit
.GetToggled())
1814 # Update the button status to be hovered
1815 hit
.SetStatus("Hover")
1817 self
._currentButton
= tabId
1819 # Fire a button click event
1820 btnEvent
= wx
.CommandEvent(wx
.wxEVT_COMMAND_BUTTON_CLICKED
, hit
.GetId())
1821 self
.GetEventHandler().ProcessEvent(btnEvent
)
1824 def OnMouseLeave(self
, event
):
1825 """ Handles the wx.EVT_LEAVE_WINDOW event for ButtonPanel. """
1827 # Reset all buttons statuses
1828 for btn
in self
._vButtons
:
1829 if not btn
.IsEnabled():
1831 btn
.SetStatus("Normal")
1838 def OnMouseEnterWindow(self
, event
):
1839 """ Handles the wx.EVT_ENTER_WINDOW event for ButtonPanel. """
1841 tabId
, flags
= self
.HitTest(event
.GetPosition())
1843 if flags
== BP_HT_BUTTON
:
1845 hit
= self
._vButtons
[tabId
]
1847 if hit
.GetStatus() == "Disabled":
1851 self
.DoGiveHelp(hit
)
1852 self
._currentButton
= tabId
1857 def DoGiveHelp(self
, hit
):
1858 """ Gives tooltips and help in StatusBar. """
1860 if not self
.GetUseHelp():
1863 shortHelp
= hit
.GetShortHelp()
1865 self
.SetToolTipString(shortHelp
)
1866 self
._haveTip
= True
1868 longHelp
= hit
.GetLongHelp()
1872 topLevel
= wx
.GetTopLevelParent(self
)
1874 if isinstance(topLevel
, wx
.Frame
) and topLevel
.GetStatusBar():
1875 statusBar
= topLevel
.GetStatusBar()
1877 if self
._statusTimer
and self
._statusTimer
.IsRunning():
1878 self
._statusTimer
.Stop()
1879 statusBar
.PopStatusText(0)
1881 statusBar
.PushStatusText(longHelp
, 0)
1882 self
._statusTimer
= StatusBarTimer(self
)
1883 self
._statusTimer
.Start(_DELAY
, wx
.TIMER_ONE_SHOT
)
1886 def RemoveHelp(self
):
1887 """ Removes the tooltips and statusbar help (if any) for a button. """
1889 if not self
.GetUseHelp():
1893 self
.SetToolTipString("")
1894 self
._haveTip
= False
1896 if self
._statusTimer
and self
._statusTimer
.IsRunning():
1897 topLevel
= wx
.GetTopLevelParent(self
)
1898 statusBar
= topLevel
.GetStatusBar()
1899 self
._statusTimer
.Stop()
1900 statusBar
.PopStatusText(0)
1901 self
._statusTimer
= None
1904 def RepaintOldSelection(self
):
1905 """ Repaints the old selected/hovered button. """
1907 current
= self
._currentButton
1912 btn
= self
._vButtons
[current
]
1913 if not btn
.IsEnabled():
1916 btn
.SetStatus("Normal")
1919 def OnStatusBarTimer(self
):
1920 """ Handles the timer expiring to delete the longHelp in the StatusBar. """
1922 topLevel
= wx
.GetTopLevelParent(self
)
1923 statusBar
= topLevel
.GetStatusBar()
1924 statusBar
.PopStatusText(0)
1927 def SetUseHelp(self
, useHelp
=True):
1928 """ Sets whether or not shortHelp and longHelp should be displayed. """
1930 self
._useHelp
= useHelp
1933 def GetUseHelp(self
):
1934 """ Returns whether or not shortHelp and longHelp should be displayed. """
1936 return self
._useHelp
1939 def HitTest(self
, pt
):
1941 HitTest method for ButtonPanel. Returns the button (if any) and
1945 for ii
in xrange(len(self
._vButtons
)):
1946 if not self
._vButtons
[ii
].IsEnabled():
1948 if self
._vButtons
[ii
].GetRect().Contains(pt
):
1949 return ii
, BP_HT_BUTTON
1951 return -1, BP_HT_NONE
1955 """ Returns the associated BPArt art provider. """
1960 def SetBPArt(self
, art
):
1961 """ Sets a new BPArt to ButtonPanel. Useful only if another BPArt class is used. """
1966 if wx
.VERSION
< (2,7,1,1):
1968 """Freeze ButtonPanel."""
1970 self
._freezeCount
= self
._freezeCount
+ 1
1971 wx
.PyPanel
.Freeze(self
)
1975 """Thaw ButtonPanel."""
1977 if self
._freezeCount
== 0:
1978 raise "\nERROR: Thawing Unfrozen ButtonPanel?"
1980 self
._freezeCount
= self
._freezeCount
- 1
1981 wx
.PyPanel
.Thaw(self
)
1985 """ Returns whether a call to Freeze() has been done. """
1987 return self
._freezeCount
!= 0