]> git.saurik.com Git - wxWidgets.git/blame - wxPython/wx/lib/foldpanelbar.py
added missing button state
[wxWidgets.git] / wxPython / wx / lib / foldpanelbar.py
CommitLineData
42f5333f
RD
1# --------------------------------------------------------------------------- #
2# FOLDPANELBAR wxPython IMPLEMENTATION
3# Ported From Jorgen Bodde & Julian Smart (Extended Demo) C++ Code By:
4#
5# Andrea Gavana, @ 23 Mar 2005
02b800ce 6# Latest Revision: 05 Nov 2005, 23.30 CET
42f5333f
RD
7#
8#
9# TODO List
10#
11# All The C++ TODOs Are Still Alive. I Am Not Able to Read Jorges's Mind
12# So I Don't Really Know What Will Be The New Features/Additions He Will
13# Make On His Code. At The Moment They Are:
14#
15# 1. OnPaint Function In CaptionBar Class:
16# TODO: Maybe First A Memory Dc Should Draw All, And Then Paint It On The
17# Caption. This Way A Flickering Arrow During Resize Is Not Visible.
18#
19# 2. OnChar Function In CaptionBar Class:
20# TODO: This Is Easy To Do But I Don't Have Any Useful Idea On Which Kind
21# Of Features To Add. Does Anyone Have An Intelligent Idea?
22#
23# 3. AddFoldPanelWindow Function In FoldPanelBar Class:
24# TODO: Take Old And New Heights, And If Difference, Reposition All The
25# Lower Panels. This Is Because The User Can Add New wxWindow Controls
26# Somewhere In Between When Other Panels Are Already Present.
27# Don't Know What It Means. Probably Is My Poor English...
28#
29# 4. OnSizePanel Function In FoldPanelBar Class:
30# TODO: A Smart Way To Check Wether The Old - New Width Of The
31# Panel Changed, If So No Need To Resize The Fold Panel Items
32#
02b800ce
RD
33#
34# DONE List:
35#
36# 1. Implemented Styles Like FPB_SINGLE_FOLD and FPB_EXCLUSIVE_FOLD
37# Thanks To E. A. Tacao For His Nice Suggestions.
38#
39# 2. Added Some Maquillage To FoldPanelBar: When The Mouse Enters The Icon
40# Region, It Is Changed To wx.CURSOR_HAND.
42f5333f
RD
41#
42#
43# For The Original TODO List From Jorgen, Please Refer To:
44# http://www.solidsteel.nl/jorg/components/foldpanel/wxFoldPanelBar.php#todo_list
45#
46#
47#
48# For All Kind Of Problems, Requests Of Enhancements And Bug Reports, Please
49# Write To Me At:
50#
51# andrea.gavana@agip.it
52# andrea_gavan@tin.it
53#
54# Or, Obviously, To The wxPython Mailing List!!!
55#
56#
57# End Of Comments
58# --------------------------------------------------------------------------- #
59
60
4e5d278c
RD
61"""
62The `FoldPanelBar` is a control that contains multiple panels (of type
63`FoldPanelItem`) that can be expanded or collapsed. The captionbar of
64the FoldPanel can be customized by setting it to a horizontal gradient
65style, vertical gradient style, a single color, a rectangle or filled
66rectangle. The FoldPanel items can be collapsed in place or to the
67bottom of the control. `wx.Window` derived controls can be added
68dynamically, and separated by separator lines. FoldPanelBar is
69freeware and distributed under the wxPython license.
42f5333f
RD
70
71
4e5d278c
RD
72How does it work
73----------------
42f5333f
RD
74
75The internals of the FoldPanelBar is a list of FoldPanelItem objects. Through
76the reference of FoldPanel these panels can be controlled by adding new controls
77to a FoldPanel or adding new FoldPanels to the FoldPanelBar.
78The CaptionBar fires events to the parent (container of all panel items) when a
79sub-panel needs resizing (either folding or expanding). The fold or expand process
80is simply a resize of the panel so it looks like all controls on it are gone. All
81controls are still child of the FoldPanel they are located on. If they don't
82handle the event (and they won't) then the owner of the FoldPanelBar gets the
83events. This is what you need to handle the controls. There isn't much to it just
84a lot of calculations to see what panel belongs where. There are no sizers
85involved in the panels, everything is purely x-y positioning.
86
87
4e5d278c
RD
88What can it do and what not?
89----------------------------
42f5333f
RD
90
91 a) What it can do:
4e5d278c
RD
92 * Run-time addition of panels (no deletion just yet)
93 * Run time addition of controls to the panel (it will be resized accordingly)
94 * Creating panels in collapsed mode or expanded mode
95 * Various modes of caption behaviour and filling to make it more appealing
96 * Panels can be folded and collapsed (or all of them) to allow more space
42f5333f
RD
97
98 b) What it cannot do:
99
4e5d278c
RD
100 * Selection of a panel like in a list ctrl
101 * Dragging and dropping the panels
102 * Re-ordering the panels (not yet)
42f5333f
RD
103
104
4e5d278c
RD
105Supported platforms
106-------------------
42f5333f
RD
107
108FoldPanelBar is supported on the following platforms:
4e5d278c
RD
109 * Windows (Verified on Windows XP, 2000)
110 * Linux/Unix (GTK2) (Thanks To Toni Brkic And Robin Dunn)
111 * Mac OSX (Thanks To Robin Dunn For The CaptionBar Size Patch)
42f5333f
RD
112
113
df75c66c 114FoldPanelBar is based upon Jorgen Bodde's C++ implementation.
02b800ce 115Latest Revision: Andrea Gavana @ 05 Nov 2005, 23.30 CET
42f5333f
RD
116
117"""
118
119import wx
120
121#----------------------------------------------------------------------
122# Collapsed And Expanded Bitmap Images
123# Created With img2py.py
124#----------------------------------------------------------------------
125
126def GetCollapsedIconData():
127 return \
128'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\
129\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\
130\x00\x007IDAT8\x8dcddbf\xa0\x040Q\xa4{\xf0\x1b\xf0\xff\xdf\xdf\xff\x03\xe7\
131\x02\x98\xed\x84\\A\x1b\x17\xa0\xdb\x8a\xcf\x15\xd4w\x01.\xdbp\x89S\xec\x02\
132\xc6\xd1\xbc\xc0\x00\x00\x9a\xf5\x1b\xfa\xf9m$?\x00\x00\x00\x00IEND\xaeB`\
133\x82'
134
135def GetCollapsedIconBitmap():
136 return wx.BitmapFromImage(GetCollapsedIconImage())
137
138def GetCollapsedIconImage():
139 import cStringIO
140 stream = cStringIO.StringIO(GetCollapsedIconData())
141 return wx.ImageFromStream(stream)
142
143#----------------------------------------------------------------------
144def GetExpandedIconData():
145 return \
146'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\
147\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\
148\x00\x00BIDAT8\x8dcddbf\xa0\x040Q\xa4{P\x18\xc0\x82.\xf0\xff\xdf\xdf\xff\xb8\
149\x143213R\xdd\x05\x18\x06`\xb3\x05\x9f8m\x02\x11\xdd6\\\xb6\xd3\xce\x05\xc8\
150\xb6\xe2\xb3\x9d*.`\x1c\xcd\x0b\x0c\x00\x9e\xbc\x04W\x19\xcfa\xb5\x00\x00\
151\x00\x00IEND\xaeB`\x82'
152
153def GetExpandedIconBitmap():
154 return wx.BitmapFromImage(GetExpandedIconImage())
155
156def GetExpandedIconImage():
157 import cStringIO
158 stream = cStringIO.StringIO(GetExpandedIconData())
159 return wx.ImageFromStream(stream)
160
161#----------------------------------------------------------------------
162
163#----------------------------------------------------------------------
164# FOLDPANELBAR Starts Here
165#----------------------------------------------------------------------
166
167# CAPTIONBAR STYLES
168#
169#- CAPTIONBAR_GRADIENT_V: Draws a vertical gradient from top to bottom
170#- CAPTIONBAR_GRADIENT_H: Draws a horizontal gradient from left to right
171#- CAPTIONBAR_SINGLE: Draws a single filled rectangle to draw the caption
172#- CAPTIONBAR_RECTANGLE: Draws a single colour with a rectangle around the caption
173#- CAPTIONBAR_FILLED_RECTANGLE: Draws a filled rectangle and a border around it
174
175CAPTIONBAR_NOSTYLE = 0
176CAPTIONBAR_GRADIENT_V = 1
177CAPTIONBAR_GRADIENT_H = 2
178CAPTIONBAR_SINGLE = 3
179CAPTIONBAR_RECTANGLE = 4
180CAPTIONBAR_FILLED_RECTANGLE = 5
181
182FPB_EXTRA_X = 10
183FPB_EXTRA_Y = 4
184
185# pixels of the bmp to be aligned from the right filled with space
186FPB_BMP_RIGHTSPACE = 2
187
02b800ce 188# Now supported! Single fold forces
42f5333f
RD
189# other panels to close when they are open, and only opens the current panel.
190# This will allow the open panel to gain the full size left in the client area
191FPB_SINGLE_FOLD = 0x0001
192
193# All panels are stacked to the bottom. When they are expanded again they
194# show up at the top
195FPB_COLLAPSE_TO_BOTTOM = 0x0002
196
02b800ce 197# Now supported! Single fold plus panels
42f5333f 198# will be stacked at the bottom
02b800ce 199FPB_EXCLUSIVE_FOLD = 0x0004
42f5333f
RD
200
201# Orientation Flag
202FPB_HORIZONTAL = wx.HORIZONTAL
203FPB_VERTICAL = wx.VERTICAL
204
205# Default Extrastyle of the FoldPanelBar
206FPB_DEFAULT_EXTRASTYLE = 0
207# Default style of the FoldPanelBar
208FPB_DEFAULT_STYLE = wx.TAB_TRAVERSAL | wx.NO_BORDER
209
210# FoldPanelItem default settings
211FPB_ALIGN_LEFT = 0
212FPB_ALIGN_WIDTH = 1
213
214FPB_DEFAULT_LEFTSPACING = 5
215FPB_DEFAULT_RIGHTSPACING = 10
216FPB_DEFAULT_SPACING = 8
217
218FPB_DEFAULT_LEFTLINESPACING = 2
219FPB_DEFAULT_RIGHTLINESPACING = 2
220
221
222# ------------------------------------------------------------------------------ #
223# class CaptionBarStyle
42f5333f
RD
224# ------------------------------------------------------------------------------ #
225
226class CaptionBarStyle:
4e5d278c
RD
227 """
228 This class encapsulates the styles you wish to set for the
229 `CaptionBar` (this is the part of the FoldPanel where the caption
230 is displayed). It can either be applied at creation time be
231 reapplied when styles need to be changed.
232
233 At construction time, all styles are set to their default
234 transparency. This means none of the styles will be applied to
235 the `CaptionBar` in question, meaning it will be created using the
236 default internals. When setting i.e the color, font or panel
237 style, these styles become active to be used.
238
239 """
42f5333f
RD
240
241 def __init__(self):
242 """ Default constructor for this class."""
243
244 self.ResetDefaults()
245
246
247 def ResetDefaults(self):
4e5d278c 248 """ Resets default CaptionBarStyle."""
42f5333f
RD
249 self._firstColourUsed = False
250 self._secondColourUsed = False
251 self._textColourUsed = False
252 self._captionFontUsed = False
253 self._captionStyleUsed = False
254 self._captionStyle = CAPTIONBAR_GRADIENT_V
255
256
257 # ------- CaptionBar Font -------
258
259 def SetCaptionFont(self, font):
260 """
261 Sets font for the caption bar.
262
4e5d278c
RD
263 If this is not set, the font property is undefined and will
264 not be used. Use `CaptionFontUsed` to check if this style is
265 used.
266 """
42f5333f
RD
267 self._captionFont = font
268 self._captionFontUsed = True
269
270
271 def CaptionFontUsed(self):
4e5d278c 272 """ Checks if the caption bar font is set. """
42f5333f
RD
273 return self._captionFontUsed
274
275
276 def GetCaptionFont(self):
277 """
278 Returns the font for the caption bar.
279
280 Please be warned this will result in an assertion failure when
281 this property is not previously set.
42f5333f 282
4e5d278c
RD
283 :see: `SetCaptionFont`, `CaptionFontUsed`
284 """
42f5333f
RD
285 return self._captionFont
286
287
288 # ------- First Colour -------
289
290 def SetFirstColour(self, colour):
291 """
292 Sets first colour for the caption bar.
293
4e5d278c
RD
294 If this is not set, the colour property is undefined and will
295 not be used. Use `FirstColourUsed` to check if this style is
296 used.
297 """
42f5333f
RD
298 self._firstColour = colour
299 self._firstColourUsed = True
300
301
302 def FirstColourUsed(self):
4e5d278c 303 """ Checks if the first colour of the caption bar is set."""
42f5333f
RD
304 return self._firstColourUsed
305
306
307 def GetFirstColour(self):
308 """
309 Returns the first colour for the caption bar.
310
4e5d278c
RD
311 Please be warned this will result in an assertion failure when
312 this property is not previously set.
42f5333f 313
4e5d278c
RD
314 :see: `SetFirstColour`, `FirstColourUsed`
315 """
42f5333f
RD
316 return self._firstColour
317
318
319 # ------- Second Colour -------
320
321 def SetSecondColour(self, colour):
322 """
323 Sets second colour for the caption bar.
324
4e5d278c
RD
325 If this is not set, the colour property is undefined and will
326 not be used. Use `SecondColourUsed` to check if this style is
327 used.
328 """
42f5333f
RD
329 self._secondColour = colour
330 self._secondColourUsed = True
331
332
333 def SecondColourUsed(self):
4e5d278c 334 """ Checks if the second colour of the caption bar is set."""
42f5333f
RD
335 return self._secondColourUsed
336
4e5d278c 337
42f5333f
RD
338 def GetSecondColour(self):
339 """
340 Returns the second colour for the caption bar.
341
4e5d278c
RD
342 Please be warned this will result in an assertion failure when
343 this property is not previously set.
42f5333f 344
4e5d278c
RD
345 :see: `SetSecondColour`, `SecondColourUsed`
346 """
42f5333f
RD
347 return self._secondColour
348
349
350 # ------- Caption Text Colour -------
351
352 def SetCaptionColour(self, colour):
353 """
354 Sets caption colour for the caption bar.
355
4e5d278c
RD
356 If this is not set, the colour property is undefined and will
357 not be used. Use `CaptionColourUsed` to check if this style is
358 used.
359 """
42f5333f
RD
360 self._textColour = colour
361 self._textColourUsed = True
362
363
364 def CaptionColourUsed(self):
4e5d278c 365 """ Checks if the caption colour of the caption bar is set."""
42f5333f
RD
366 return self._textColourUsed
367
368
369 def GetCaptionColour(self):
370 """
371 Returns the caption colour for the caption bar.
372
373 Please be warned this will result in an assertion failure
374 when this property is not previously set.
375 See also SetCaptionColour(), CaptionColourUsed()
4e5d278c 376 """
42f5333f
RD
377 return self._textColour
378
379
380 # ------- CaptionStyle -------
381
382 def SetCaptionStyle(self, style):
383 """
384 Sets caption style for the caption bar.
385
4e5d278c
RD
386 If this is not set, the property is undefined and will not be
387 used. Use CaptionStyleUsed() to check if this style is used.
42f5333f 388 The following styles can be applied:
4e5d278c
RD
389
390 * CAPTIONBAR_GRADIENT_V: Draws a vertical gradient from top to bottom
391
392 * CAPTIONBAR_GRADIENT_H: Draws a horizontal gradient from
393 left to right
394
395 * CAPTIONBAR_SINGLE: Draws a single filled rectangle to
396 draw the caption
397
398 * CAPTIONBAR_RECTANGLE: Draws a single colour with a
399 rectangle around the caption
400
401 * CAPTIONBAR_FILLED_RECTANGLE: Draws a filled rectangle
402 and a border around it
403
404 """
42f5333f
RD
405 self._captionStyle = style
406 self._captionStyleUsed = True
407
408
409 def CaptionStyleUsed(self):
4e5d278c 410 """ Checks if the caption style of the caption bar is set."""
42f5333f
RD
411 return self._captionStyleUsed
412
413
414 def GetCaptionStyle(self):
415 """
416 Returns the caption style for the caption bar.
417
418 Please be warned this will result in an assertion failure
419 when this property is not previously set.
42f5333f 420
4e5d278c
RD
421 :see: `SetCaptionStyle`, `CaptionStyleUsed`
422 """
42f5333f
RD
423 return self._captionStyle
424
425
426#-----------------------------------#
427# CaptionBarEvent
428#-----------------------------------#
429wxEVT_CAPTIONBAR = wx.NewEventType()
430EVT_CAPTIONBAR = wx.PyEventBinder(wxEVT_CAPTIONBAR, 0)
431
432
433# ---------------------------------------------------------------------------- #
434# class CaptionBarEvent
42f5333f
RD
435# ---------------------------------------------------------------------------- #
436
437class CaptionBarEvent(wx.PyCommandEvent):
4e5d278c
RD
438 """
439 This event will be sent when a EVT_CAPTIONBAR is mapped in the parent.
440 It is to notify the parent that the bar is now in collapsed or expanded
441 state. The parent should re-arrange the associated windows accordingly
442 """
42f5333f 443 def __init__(self, evtType):
4e5d278c 444 """ Default Constructor For This Class."""
42f5333f
RD
445 wx.PyCommandEvent.__init__(self, evtType)
446
447
448 def GetFoldStatus(self):
4e5d278c
RD
449 """
450 Returns whether the bar is expanded or collapsed. True means
451 expanded.
452 """
42f5333f
RD
453 return not self._bar.IsCollapsed()
454
455
456 def GetBar(self):
4e5d278c 457 """ Returns The CaptionBar Selected."""
42f5333f
RD
458 return self._bar
459
460
461 def SetTag(self, tag):
4e5d278c 462 """ Assign A Tag To The Selected CaptionBar."""
42f5333f
RD
463 self._tag = tag
464
465
466 def GetTag(self):
4e5d278c 467 """ Returns The Tag Assigned To The Selected CaptionBar."""
42f5333f
RD
468 return self._tag
469
470
471 def SetBar(self, bar):
472 """
4e5d278c 473 Sets the bar associated with this event.
42f5333f 474
4e5d278c
RD
475 Should not used by any other then the originator of the event.
476 """
42f5333f
RD
477 self._bar = bar
478
479
480# -------------------------------------------------------------------------------- #
481# class CaptionBar
42f5333f
RD
482# -------------------------------------------------------------------------------- #
483
484class CaptionBar(wx.Window):
4e5d278c
RD
485 """
486 This class is a graphical caption component that consists of a
487 caption and a clickable arrow.
488
489 The CaptionBar fires an event EVT_CAPTIONBAR which is a
490 `CaptionBarEvent`. This event can be caught and the parent window
491 can act upon the collapsed or expanded state of the bar (which is
492 actually just the icon which changed). The parent panel can
493 reduce size or expand again.
494 """
495
42f5333f
RD
496 # Define Empty CaptionBar Style
497 EmptyCaptionBarStyle = CaptionBarStyle()
498
499 def __init__(self, parent, id, pos, size, caption="",
500 foldIcons=None, cbstyle=EmptyCaptionBarStyle,
501 rightIndent=FPB_BMP_RIGHTSPACE,
502 iconWidth=16, iconHeight=16, collapsed=False):
503 """ Default Class Constructor."""
504
0159bfd0 505 wx.Window.__init__(self, parent, wx.ID_ANY, pos=pos,
42f5333f
RD
506 size=(20,20), style=wx.NO_BORDER)
507
508 self._controlCreated = False
509 self._collapsed = collapsed
510 self.ApplyCaptionStyle(cbstyle, True)
511
512 if foldIcons is None:
513 foldIcons = wx.ImageList(16, 16)
514
515 bmp = GetExpandedIconBitmap()
516 foldIcons.Add(bmp)
517 bmp = GetCollapsedIconBitmap()
518 foldIcons.Add(bmp)
519
520 # set initial size
521 if foldIcons:
522 assert foldIcons.GetImageCount() > 1
523 iconWidth, iconHeight = foldIcons.GetSize(0)
524
525 self._caption = caption
526 self._foldIcons = foldIcons
527 self._style = cbstyle
528 self._rightIndent = rightIndent
529 self._iconWidth = iconWidth
530 self._iconHeight = iconHeight
531 self._oldSize = wx.Size(20,20)
532
533 self._controlCreated = True
534
535 self.Bind(wx.EVT_PAINT, self.OnPaint)
536 self.Bind(wx.EVT_SIZE, self.OnSize)
537 self.Bind(wx.EVT_MOUSE_EVENTS, self.OnMouseEvent)
538 self.Bind(wx.EVT_CHAR, self.OnChar)
539
540
541 def ApplyCaptionStyle(self, cbstyle=EmptyCaptionBarStyle, applyDefault=True):
542 """ Applies the style defined in cbstyle to the CaptionBar."""
543
544 newstyle = cbstyle
545
546 if applyDefault:
547
548 # get first colour from style or make it default
549 if not newstyle.FirstColourUsed():
550 newstyle.SetFirstColour(wx.WHITE)
551
552 # get second colour from style or make it default
553 if not newstyle.SecondColourUsed():
554 # make the second colour slightly darker then the background
555 color = self.GetParent().GetBackgroundColour()
556 r, g, b = int(color.Red()), int(color.Green()), int(color.Blue())
557 color = ((r >> 1) + 20, (g >> 1) + 20, (b >> 1) + 20)
558 newstyle.SetSecondColour(wx.Colour(color[0], color[1], color[2]))
559
560 # get text colour
561 if not newstyle.CaptionColourUsed():
562 newstyle.SetCaptionColour(wx.BLACK)
563
564 # get font colour
565 if not newstyle.CaptionFontUsed():
566 newstyle.SetCaptionFont(self.GetParent().GetFont())
567
568 # apply caption style
569 if not newstyle.CaptionStyleUsed():
570 newstyle.SetCaptionStyle(CAPTIONBAR_GRADIENT_V)
571
572 self._style = newstyle
573
574
575 def SetCaptionStyle(self, cbstyle=EmptyCaptionBarStyle, applyDefault=True):
576 """
577 Sets CaptionBar styles with CapionBarStyle class.
578
4e5d278c
RD
579 All styles that are actually set, are applied. If you set
580 applyDefault to True, all other (not defined) styles will be
581 set to default. If it is False, the styles which are not set
582 in the CaptionBarStyle will be ignored.
583 """
42f5333f
RD
584 self.ApplyCaptionStyle(cbstyle, applyDefault)
585 self.Refresh()
586
587
588 def GetCaptionStyle(self):
589 """
4e5d278c
RD
590 Returns the current style of the captionbar in a
591 `CaptionBarStyle` class.
42f5333f
RD
592
593 This can be used to change and set back the changes.
4e5d278c 594 """
42f5333f
RD
595 return self._style
596
597
598 def IsCollapsed(self):
599 """
4e5d278c
RD
600 Returns wether the status of the bar is expanded or collapsed.
601 """
42f5333f
RD
602 return self._collapsed
603
604
605 def SetRightIndent(self, pixels):
606 """
4e5d278c
RD
607 Sets the amount of pixels on the right from which the bitmap
608 is trailing.
42f5333f 609
4e5d278c
RD
610 If this is 0, it will be drawn all the way to the right,
611 default is equal to FPB_BMP_RIGHTSPACE. Assign this before
612 assigning an image list to prevent a redraw.
42f5333f 613 """
42f5333f
RD
614 assert pixels >= 0
615 self._rightIndent = pixels
616 if self._foldIcons:
617 self.Refresh()
618
619
620 def Collapse(self):
621 """
622 This sets the internal state / representation to collapsed.
623
4e5d278c
RD
624 This does not trigger a `CaptionBarEvent` to be sent to the
625 parent.
626 """
42f5333f
RD
627 self._collapsed = True
628 self.RedrawIconBitmap()
629
630
631 def Expand(self):
632 """
633 This sets the internal state / representation to expanded.
634
4e5d278c
RD
635 This does not trigger a `CaptionBarEvent` to be sent to the
636 parent.
637 """
42f5333f
RD
638 self._collapsed = False
639 self.RedrawIconBitmap()
640
641
642 def SetBoldFont(self):
643 """ Sets the CaptionBarFont weight to BOLD."""
644
645 self.GetFont().SetWeight(wx.BOLD)
646
647
648 def SetNormalFont(self):
649 """ Sets the CaptionBarFont weight to NORMAL."""
650
651 self.GetFont().SetWeight(wx.NORMAL)
652
653
654 def IsVertical(self):
655 """
656 Returns wether the CaptionBar Has Default Orientation Or Not.
657
658 Default is vertical.
659 """
660
661 fld = self.GetParent().GetGrandParent()
662 if isinstance(fld, FoldPanelBar):
663 return self.GetParent().GetGrandParent().IsVertical()
664 else:
665 raise "ERROR: Wrong Parent " + repr(fld)
666
667
668 def OnPaint(self, event):
669 """ The paint event for flat or gradient fill. """
670
671 if not self._controlCreated:
672 event.Skip()
673 return
674
675 dc = wx.PaintDC(self)
676 wndRect = self.GetRect()
677 vertical = self.IsVertical()
02b800ce 678
42f5333f
RD
679 # TODO: Maybe first a memory DC should draw all, and then paint it on
680 # the caption. This way a flickering arrow during resize is not visible
681
682 self.FillCaptionBackground(dc)
683 dc.SetFont(self._style.GetCaptionFont())
02b800ce 684 dc.SetTextForeground(self._style.GetCaptionColour())
42f5333f
RD
685
686 if vertical:
687 dc.DrawText(self._caption, 4, FPB_EXTRA_Y/2)
688 else:
689 dc.DrawRotatedText(self._caption, FPB_EXTRA_Y/2,
690 wndRect.GetBottom() - 4, 90)
691
692 # draw small icon, either collapsed or expanded
693 # based on the state of the bar. If we have any bmp's
694
695 if self._foldIcons:
696
697 index = self._collapsed
698
699 if vertical:
700 drw = wndRect.GetRight() - self._iconWidth - self._rightIndent
701 self._foldIcons.Draw(index, dc, drw,
702 (wndRect.GetHeight() - self._iconHeight)/2,
703 wx.IMAGELIST_DRAW_TRANSPARENT)
704 else:
705 self._foldIcons.Draw(index, dc,
706 (wndRect.GetWidth() - self._iconWidth)/2,
707 self._rightIndent, wx.IMAGELIST_DRAW_TRANSPARENT)
708
709## event.Skip()
710
711
712 def FillCaptionBackground(self, dc):
4e5d278c
RD
713 """
714 Fills the background of the caption with either a gradient or
715 a solid color.
716 """
42f5333f
RD
717
718 style = self._style.GetCaptionStyle()
719
720 if style == CAPTIONBAR_GRADIENT_V:
721 if self.IsVertical():
722 self.DrawVerticalGradient(dc, self.GetRect())
723 else:
724 self.DrawHorizontalGradient(dc, self.GetRect())
725
726 elif style == CAPTIONBAR_GRADIENT_H:
727 if self.IsVertical():
728 self.DrawHorizontalGradient(dc, self.GetRect())
729 else:
730 self.DrawVerticalGradient(dc, self.GetRect())
731
732 elif style == CAPTIONBAR_SINGLE:
733 self.DrawSingleColour(dc, self.GetRect())
734 elif style == CAPTIONBAR_RECTANGLE or style == CAPTIONBAR_FILLED_RECTANGLE:
735 self.DrawSingleRectangle(dc, self.GetRect())
736 else:
737 raise "STYLE Error: Undefined Style Selected: " + repr(style)
738
739
740 def OnMouseEvent(self, event):
741 """
742 Catches the mouse click-double click.
743
02b800ce
RD
744 If clicked on the arrow (single) or double on the caption we change state
745 and an event must be fired to let this panel collapse or expand.
42f5333f 746 """
42f5333f 747
02b800ce
RD
748 send_event = False
749 vertical = self.IsVertical()
750
42f5333f
RD
751 if event.LeftDown() and self._foldIcons:
752
753 pt = event.GetPosition()
754 rect = self.GetRect()
02b800ce 755
42f5333f
RD
756 drw = (rect.GetWidth() - self._iconWidth - self._rightIndent)
757 if vertical and pt.x > drw or not vertical and \
758 pt.y < (self._iconHeight + self._rightIndent):
759 send_event = True
760
761 elif event.LeftDClick():
02b800ce 762 self.SetCursor(wx.StockCursor(wx.CURSOR_ARROW))
42f5333f
RD
763 send_event = True
764
02b800ce
RD
765 elif event.Entering() and self._foldIcons:
766 pt = event.GetPosition()
767 rect = self.GetRect()
768
769 drw = (rect.GetWidth() - self._iconWidth - self._rightIndent)
770 if vertical and pt.x > drw or not vertical and \
771 pt.y < (self._iconHeight + self._rightIndent):
772 self.SetCursor(wx.StockCursor(wx.CURSOR_HAND))
773 else:
774 self.SetCursor(wx.StockCursor(wx.CURSOR_ARROW))
775
776 elif event.Leaving():
777 self.SetCursor(wx.StockCursor(wx.CURSOR_ARROW))
778
779 elif event.Moving():
780 pt = event.GetPosition()
781 rect = self.GetRect()
782
783 drw = (rect.GetWidth() - self._iconWidth - self._rightIndent)
784 if vertical and pt.x > drw or not vertical and \
785 pt.y < (self._iconHeight + self._rightIndent):
786 self.SetCursor(wx.StockCursor(wx.CURSOR_HAND))
787 else:
788 self.SetCursor(wx.StockCursor(wx.CURSOR_ARROW))
789
42f5333f
RD
790 # send the collapse, expand event to the parent
791
792 if send_event:
793 event = CaptionBarEvent(wxEVT_CAPTIONBAR)
7c2c2e07
RD
794 event.SetId(self.GetId())
795 event.SetEventObject(self)
42f5333f
RD
796 event.SetBar(self)
797 self.GetEventHandler().ProcessEvent(event)
42f5333f
RD
798
799
800 def OnChar(self, event):
801 """ Unused Methods. Any Ideas?!?"""
42f5333f
RD
802 # TODO: Anything here?
803 event.Skip()
804
805
806 def DoGetBestSize(self):
4e5d278c
RD
807 """
808 Returns the best size for this panel, based upon the font
809 assigned to this window, and the caption string
810 """
42f5333f
RD
811
812 if self.IsVertical():
813 x, y = self.GetTextExtent(self._caption)
814 else:
815 y, x = self.GetTextExtent(self._caption)
816
817 if x < self._iconWidth:
818 x = self._iconWidth
819
820 if y < self._iconHeight:
821 y = self._iconHeight
822
823 # TODO: The extra FPB_EXTRA_X constants should be adjustable as well
824
825 return wx.Size(x + FPB_EXTRA_X, y + FPB_EXTRA_Y)
826
827
828 def DrawVerticalGradient(self, dc, rect):
829 """ Gradient fill from colour 1 to colour 2 with top to bottom. """
830
831 if rect.height < 1 or rect.width < 1:
832 return
833
834 dc.SetPen(wx.TRANSPARENT_PEN)
835
836 # calculate gradient coefficients
837 col2 = self._style.GetSecondColour()
838 col1 = self._style.GetFirstColour()
839
840 r1, g1, b1 = int(col1.Red()), int(col1.Green()), int(col1.Blue())
841 r2, g2, b2 = int(col2.Red()), int(col2.Green()), int(col2.Blue())
842
843 flrect = float(rect.height)
844
845 rstep = float((r2 - r1)) / flrect
846 gstep = float((g2 - g1)) / flrect
847 bstep = float((b2 - b1)) / flrect
848
849 rf, gf, bf = 0, 0, 0
850
851 for y in range(rect.y, rect.y + rect.height):
852 currCol = (r1 + rf, g1 + gf, b1 + bf)
853
854 dc.SetBrush(wx.Brush(currCol, wx.SOLID))
855 dc.DrawRectangle(rect.x, rect.y + (y - rect.y), rect.width, rect.height)
856 rf = rf + rstep
857 gf = gf + gstep
858 bf = bf + bstep
859
860
861 def DrawHorizontalGradient(self, dc, rect):
862 """ Gradient fill from colour 1 to colour 2 with left to right. """
863
864 if rect.height < 1 or rect.width < 1:
865 return
866
867 dc.SetPen(wx.TRANSPARENT_PEN)
868
869 # calculate gradient coefficients
870 col2 = self._style.GetSecondColour()
871 col1 = self._style.GetFirstColour()
872
873 r1, g1, b1 = int(col1.Red()), int(col1.Green()), int(col1.Blue())
874 r2, g2, b2 = int(col2.Red()), int(col2.Green()), int(col2.Blue())
875
876 flrect = float(rect.width)
877
878 rstep = float((r2 - r1)) / flrect
879 gstep = float((g2 - g1)) / flrect
880 bstep = float((b2 - b1)) / flrect
881
882 rf, gf, bf = 0, 0, 0
883
884 for x in range(rect.x, rect.x + rect.width):
885 currCol = (r1 + rf, g1 + gf, b1 + bf)
886
887 dc.SetBrush(wx.Brush(currCol, wx.SOLID))
888 dc.DrawRectangle(rect.x + (x - rect.x), rect.y, 1, rect.height)
889 rf = rf + rstep
890 gf = gf + gstep
891 bf = bf + bstep
892
893
894 def DrawSingleColour(self, dc, rect):
895 """ Single colour fill. This is the most easy one to find. """
896
897 if rect.height < 1 or rect.width < 1:
898 return
899
900 dc.SetPen(wx.TRANSPARENT_PEN)
901
902 # draw simple rectangle
903 dc.SetBrush(wx.Brush(self._style.GetFirstColour(), wx.SOLID))
904 dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height)
905
906
907 def DrawSingleRectangle(self, dc, rect):
908 """ Single rectangle. This is the most easy one to find. """
909
910 if rect.height < 2 or rect.width < 1:
911 return
912
913 # single frame, set up internal fill colour
914
915 if self._style.GetCaptionStyle() == CAPTIONBAR_RECTANGLE:
916 color = self.GetParent().GetBackgroundColour()
917 br = wx.Brush(color, wx.SOLID)
918 else:
919 color = self._style.GetFirstColour()
920 br = wx.Brush(color, wx.SOLID)
921
922 # setup the pen frame
923
924 pen = wx.Pen(self._style.GetSecondColour())
925 dc.SetPen(pen)
926 dc.SetBrush(br)
927 dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height - 1)
928
929 bgpen = wx.Pen(self.GetParent().GetBackgroundColour())
930 dc.SetPen(bgpen)
931 dc.DrawLine(rect.x, rect.y + rect.height - 1, rect.x + rect.width,
932 rect.y + rect.height - 1)
933
934
935 def OnSize(self, event):
936 """ Handles the size events for the CaptionBar."""
937
938 if not self._controlCreated:
939 event.Skip()
940 return
941
942 size = event.GetSize()
943
944 if self._foldIcons:
945
946 # What I am doing here is simply invalidating the part of the window
947 # exposed. So when I make a rect with as width the newly exposed part,
948 # and the x,y of the old window size origin, I don't need a bitmap
949 # calculation in it, or do I ? The bitmap needs redrawing anyway.
950 # Leave it like this until I figured it out.
951
952 # set rect to redraw as old bitmap area which is entitled to redraw
953
954 rect = wx.Rect(size.GetWidth() - self._iconWidth - self._rightIndent, 0,
955 self._iconWidth + self._rightIndent,
956 self._iconWidth + self._rightIndent)
957
958 # adjust rectangle when more is slided so we need to redraw all
959 # the old stuff but not all (ugly flickering)
960
961 diffX = size.GetWidth() - self._oldSize.GetWidth()
962
963 if diffX > 1:
964
965 # adjust the rect with all the crap to redraw
966
967 rect.SetWidth(rect.GetWidth() + diffX + 10)
968 rect.SetX(rect.GetX() - diffX - 10)
969
970 self.RefreshRect(rect)
971
972 else:
973
974 rect = self.GetRect()
975 self.RefreshRect(rect)
976
977 self._oldSize = size
978
979
980 def RedrawIconBitmap(self):
981 """ Redraws the icons (if they exists). """
982
983 if self._foldIcons:
984
985 # invalidate the bitmap area and force a redraw
986
987 rect = self.GetRect()
988
989 rect.SetX(rect.GetWidth() - self._iconWidth - self._rightIndent)
990 rect.SetWidth(self._iconWidth + self._rightIndent)
991 self.RefreshRect(rect)
992
993
994# ---------------------------------------------------------------------------------- #
995# class FoldPanelBar
42f5333f
RD
996# ---------------------------------------------------------------------------------- #
997
998class FoldPanelBar(wx.Panel):
4e5d278c
RD
999 """
1000 The FoldPanelBar is a class which can maintain a list of
1001 collapsable panels. Once a panel is collapsed, only it's caption
1002 bar is visible to the user. This will provide more space for the
1003 other panels, or allow the user to close panels which are not used
1004 often to get the most out of the work area.
1005
1006 This control is easy to use. Simply create it as a child for a
1007 panel or sash window, and populate panels with
9f4cc34f 1008 `AddFoldPanel`. Then use the `AddFoldPanelWindow` to add
4e5d278c
RD
1009 `wx.Window` derived controls to the current fold panel. Use
1010 `AddFoldPanelSeparator` to put separators between the groups of
1011 controls that need a visual separator to group them
1012 together. After all is constructed, the user can fold the panels
1013 by doubleclicking on the bar or single click on the arrow, which
1014 will indicate the collapsed or expanded state.
1015 """
42f5333f
RD
1016 # Define Empty CaptionBar Style
1017 EmptyCaptionBarStyle = CaptionBarStyle()
1018
1019 def __init__(self, parent, id=-1, pos=wx.DefaultPosition, size=wx.DefaultSize,
1020 style=FPB_DEFAULT_STYLE, extraStyle=FPB_DEFAULT_EXTRASTYLE):
1021 """ Default Class Constructor. """
1022
1023 self._controlCreated = False
1024 self._extraStyle = extraStyle
1025
1026 # make sure there is any orientation
1027 if style & FPB_HORIZONTAL != FPB_HORIZONTAL:
1028 style = style | FPB_VERTICAL
1029
1030 if style & FPB_HORIZONTAL == 4:
1031 self._isVertical = False
1032 else:
1033 self._isVertical = True
1034
1035
1036 # create the panel (duh!). This causes a size event, which we are going
1037 # to skip when we are not initialised
1038
1039 wx.Panel.__init__(self, parent, id, pos, size, style)
1040
1041 # the fold panel area
1042
1043 self._foldPanel = wx.Panel(self, wx.ID_ANY, pos, size,
1044 wx.NO_BORDER | wx.TAB_TRAVERSAL)
1045
1046 self._controlCreated = True
1047 self._panels = []
1048
1049 self.Bind(EVT_CAPTIONBAR, self.OnPressCaption)
1050 self.Bind(wx.EVT_SIZE, self.OnSizePanel)
1051
1052
1053 def AddFoldPanel(self, caption="", collapsed=False, foldIcons=None,
1054 cbstyle=EmptyCaptionBarStyle):
1055 """
1056 Adds a fold panel to the list of panels.
1057
4e5d278c
RD
1058 If the flag collapsed is set to True, the panel is collapsed
1059 initially. The FoldPanel item which is returned, can be used
1060 as a reference to perform actions upon the fold panel like
1061 collapsing it, expanding it, or deleting it from the list.
42f5333f
RD
1062
1063 Use this foldpanel to add windows to it. Please consult
4e5d278c
RD
1064 `AddFoldPanelWindow` and `AddFoldPanelSeparator` to know how
1065 to add items derived from `wx.Window` to the panels.
42f5333f
RD
1066 """
1067
1068 # create a fold panel item, which is first only the caption.
1069 # the user can now add a panel area which will be folded in
1070 # when pressed.
1071
1072 if foldIcons is None:
1073 foldIcons = wx.ImageList(16, 16)
1074
1075 bmp = GetExpandedIconBitmap()
1076 foldIcons.Add(bmp)
1077 bmp = GetCollapsedIconBitmap()
1078 foldIcons.Add(bmp)
1079
1080 item = FoldPanelItem(self._foldPanel, -1, caption=caption,
1081 foldIcons=foldIcons,
1082 collapsed=collapsed, cbstyle=cbstyle)
1083
1084 pos = 0
1085 if len(self._panels) > 0:
1086 pos = self._panels[-1].GetItemPos() + self._panels[-1].GetPanelLength()
1087
1088 item.Reposition(pos)
1089 self._panels.append(item)
1090
1091 return item
1092
1093
1094 def AddFoldPanelWindow(self, panel, window, flags=FPB_ALIGN_WIDTH,
1095 Spacing=FPB_DEFAULT_SPACING,
1096 leftSpacing=FPB_DEFAULT_LEFTLINESPACING,
1097 rightSpacing=FPB_DEFAULT_RIGHTLINESPACING):
1098 """
4e5d278c
RD
1099 Adds a `wx.Window` derived instance to the referenced
1100 FoldPanel.
42f5333f 1101
4e5d278c 1102 IMPORTANT: Make the window be a child of the FoldPanel. See
42f5333f 1103 example that follows. The flags to be used are:
4e5d278c
RD
1104
1105 * FPB_ALIGN_WIDTH: Which means the wxWindow to be added
1106 will be aligned to fit the width of the FoldPanel when
1107 it is resized. Very handy for sizer items, buttons and
1108 text boxes.
42f5333f 1109
d6922577 1110 * FPB_ALIGN_LEFT: Aligns left instead of fitting the
4e5d278c
RD
1111 width of the child window to be added. Use either this
1112 one or FPB_ALIGN_WIDTH.
42f5333f 1113
4e5d278c
RD
1114 The wx.Window to be added can be slightly indented from left
1115 and right so it is more visibly placed in the FoldPanel. Use
1116 Spacing > 0 to give the control an y offset from the previous
1117 wx.Window added, use leftSpacing to give it a slight indent
1118 from the left, and rightSpacing also reserves a little space
1119 on the right so the wxWindow can be properly placed in the
1120 FoldPanel.
42f5333f 1121
4e5d278c
RD
1122 The following example adds a FoldPanel to the FoldPanelBar and
1123 adds two wx.Window derived controls to the FoldPanel::
42f5333f
RD
1124
1125 # create the FoldPanelBar
1126 >>> m_pnl = FoldPanelBar(self, wx.ID_ANY, wx.DefaultPosition,
1127 wx.DefaultSize, FPB_DEFAULT_STYLE,
1128 FPB_COLLAPSE_TO_BOTTOM)
1129
1130 # add a foldpanel to the control. "Test me" is the caption and it is
1131 # initially not collapsed.
1132 >>> item = m_pnl.AddFoldPanel("Test me", False)
1133
1134 # now add a button to the fold panel. Mind that the button should be
1135 # made child of the FoldPanel and not of the main form.
1136 >>> m_pnl.AddFoldPanelWindow(item, wx.Button(item, ID_COLLAPSEME,
1137 "Collapse Me"))
1138
1139 # add a separator between the two controls. This is purely a visual
1140 # line that can have a certain color and also the indents and width
1141 # aligning like a control.
1142 >>> m_pnl.AddFoldPanelSeparator(item)
1143
1144 # now add a text ctrl. Also very easy. Align this on width so that
1145 # when the control gets wider the text control also sizes along.
1146 >>> m_pnl.AddFoldPanelWindow(item, wx.TextCtrl(item, wx.ID_ANY, "Comment"),
1147 FPB_ALIGN_WIDTH, FPB_DEFAULT_SPACING, 20)
1148
42f5333f
RD
1149 """
1150
1151 try:
1152 item = self._panels.index(panel)
1153 except:
1154 raise "ERROR: Invalid Panel Passed To AddFoldPanelWindow: " + repr(panel)
1155
1156 panel.AddWindow(window, flags, Spacing, leftSpacing, rightSpacing)
1157
1158 # TODO: Take old and new height, and if difference, reposition all the lower
1159 # panels this is because the user can add new wxWindow controls somewhere in
1160 # between when other panels are already present.
1161
1162 return 0
1163
1164
1165 def AddFoldPanelSeparator(self, panel, colour=wx.BLACK,
1166 Spacing=FPB_DEFAULT_SPACING,
1167 leftSpacing=FPB_DEFAULT_LEFTLINESPACING,
1168 rightSpacing=FPB_DEFAULT_RIGHTLINESPACING):
1169 """
1170 Adds a separator line to the current FoldPanel.
1171
4e5d278c
RD
1172 The seperator is a simple line which is drawn and is no real
1173 component. It can be used to separate groups of controls
1174 which belong to each other. The colour is adjustable, and it
1175 takes the same Spacing, leftSpacing and rightSpacing as
1176 `AddFoldPanelWindow`.
42f5333f
RD
1177 """
1178
1179 try:
1180 item = self._panels.index(panel)
1181 except:
1182 raise "ERROR: Invalid Panel Passed To AddFoldPanelSeparator: " + repr(panel)
1183
1184 panel.AddSeparator(colour, Spacing, leftSpacing, rightSpacing)
1185 return 0
1186
1187
1188 def OnSizePanel(self, event):
4e5d278c 1189 """ Handles the EVT_SIZE event for the FoldPanelBar. """
42f5333f
RD
1190
1191 # skip all stuff when we are not initialised yet
1192
1193 if not self._controlCreated:
1194 event.Skip()
1195 return
1196
1197 foldrect = self.GetRect()
1198
1199 # fold panel itself. If too little space,
1200 # don't show it
1201
1202 foldrect.SetX(0)
1203 foldrect.SetY(0)
1204
1205 self._foldPanel.SetSize(foldrect[2:])
1206
02b800ce 1207 if self._extraStyle & FPB_COLLAPSE_TO_BOTTOM or self._extraStyle & FPB_EXCLUSIVE_FOLD:
42f5333f
RD
1208 rect = self.RepositionCollapsedToBottom()
1209 vertical = self.IsVertical()
1210 if vertical and rect.GetHeight() > 0 or not vertical and rect.GetWidth() > 0:
1211 self.RefreshRect(rect)
1212
1213 # TODO: A smart way to check wether the old - new width of the
1214 # panel changed, if so no need to resize the fold panel items
1215
1216 self.RedisplayFoldPanelItems()
1217
1218
1219 def OnPressCaption(self, event):
1220 """ Handles the EVT_CAPTIONBAR event in the FoldPanelBar. """
1221
1222 # act upon the folding or expanding status of the bar
1223 # to expand or collapse the panel(s)
1224
1225 if event.GetFoldStatus():
1226 self.Collapse(event.GetTag())
1227 else:
1228 self.Expand(event.GetTag())
1229
1230 event.Skip()
1231
1232
1233 def RefreshPanelsFrom(self, item):
1234 """ Refreshes all the panels from given index down to last one. """
1235
1236 try:
1237 i = self._panels.index(item)
1238 except:
1239 raise "ERROR: Invalid Panel Passed To RefreshPanelsFrom: " + repr(item)
1240
1241 self.Freeze()
1242
1243 # if collapse to bottom is on, the panels that are not expanded
1244 # should be drawn at the bottom. All panels that are expanded
1245 # are drawn on top. The last expanded panel gets all the extra space
1246
02b800ce 1247 if self._extraStyle & FPB_COLLAPSE_TO_BOTTOM or self._extraStyle & FPB_EXCLUSIVE_FOLD:
42f5333f
RD
1248
1249 offset = 0
1250
1251 for panels in self._panels:
1252
1253 if panels.IsExpanded():
1254 offset = offset + panels.Reposition(offset)
1255
1256 # put all non collapsed panels at the bottom where there is space,
1257 # else put them right behind the expanded ones
1258
1259 self.RepositionCollapsedToBottom()
1260
1261 else:
1262
1263 pos = self._panels[i].GetItemPos() + self._panels[i].GetPanelLength()
1264 for j in range(i+1, len(self._panels)):
1265 pos = pos + self._panels[j].Reposition(pos)
42f5333f
RD
1266
1267 self.Thaw()
42f5333f
RD
1268
1269
1270 def RedisplayFoldPanelItems(self):
1271 """ Resizes the fold panels so they match the width. """
42f5333f 1272 # resize them all. No need to reposition
42f5333f
RD
1273 for panels in self._panels:
1274 panels.ResizePanel()
1275 panels.Refresh()
1276
1277
1278 def RepositionCollapsedToBottom(self):
1279 """
1280 Repositions all the collapsed panels to the bottom.
1281
4e5d278c
RD
1282 When it is not possible to align them to the bottom, stick
1283 them behind the visible panels. The Rect holds the slack area
1284 left between last repositioned panel and the bottom
1285 panels. This needs to get a refresh.
42f5333f
RD
1286 """
1287
1288 value = wx.Rect(0,0,0,0)
1289 vertical = self.IsVertical()
1290
1291 # determine wether the number of panels left
1292 # times the size of their captions is enough
1293 # to be placed in the left over space
1294
1295 expanded = 0
1296 collapsed = 0
1297 collapsed, expanded, values = self.GetPanelsLength(collapsed, expanded)
1298
1299 # if no room stick them behind the normal ones, else
1300 # at the bottom
1301
1302 if (vertical and [self.GetSize().GetHeight()] or \
1303 [self.GetSize().GetWidth()])[0] - expanded - collapsed < 0:
1304 offset = expanded
1305 else:
1306
1307 # value is the region which is left unpainted
1308 # I will send it back as 'slack' so it does not need to
1309 # be recalculated.
1310
1311 value.SetHeight(self.GetSize().GetHeight())
1312 value.SetWidth(self.GetSize().GetWidth())
1313
1314 if vertical:
1315 value.SetY(expanded)
1316 value.SetHeight(value.GetHeight() - expanded)
1317 else:
1318 value.SetX(expanded)
1319 value.SetWidth(value.GetWidth() - expanded)
1320
1321 offset = (vertical and [self.GetSize().GetHeight()] or \
1322 [self.GetSize().GetWidth()])[0] - collapsed
1323
1324
1325 # go reposition
1326
1327 for panels in self._panels:
1328 if not panels.IsExpanded():
1329 offset = offset + panels.Reposition(offset)
1330
1331 return value
1332
1333
1334 def GetPanelsLength(self, collapsed, expanded):
1335 """
4e5d278c
RD
1336 Returns the length of the panels that are expanded and
1337 collapsed.
42f5333f 1338
4e5d278c
RD
1339 This is useful to determine quickly what size is used to
1340 display, and what is left at the bottom (right) to align the
1341 collapsed panels.
42f5333f
RD
1342 """
1343
1344 value = 0
1345
1346 # assumed here that all the panels that are expanded
1347 # are positioned after each other from 0,0 to end.
1348
1349 for j in range(0, len(self._panels)):
1350 offset = self._panels[j].GetPanelLength()
1351 value = value + offset
1352 if self._panels[j].IsExpanded():
1353 expanded = expanded + offset
1354 else:
1355 collapsed = collapsed + offset
1356
1357 return collapsed, expanded, value
1358
1359
1360 def Collapse(self, foldpanel):
1361 """
4e5d278c
RD
1362 Collapses the given FoldPanel reference, and updates the
1363 foldpanel bar.
42f5333f 1364
4e5d278c
RD
1365 In the FPB_COLLAPSE_TO_BOTTOM style, all collapsed captions
1366 are put at the bottom of the control. In the normal mode, they
1367 stay where they are.
42f5333f
RD
1368 """
1369
1370 try:
1371 item = self._panels.index(foldpanel)
1372 except:
1373 raise "ERROR: Invalid Panel Passed To Collapse: " + repr(foldpanel)
1374
1375 foldpanel.Collapse()
1376 self.RefreshPanelsFrom(foldpanel)
1377
1378
1379 def Expand(self, foldpanel):
1380 """
4e5d278c
RD
1381 Expands the given FoldPanel reference, and updates the
1382 foldpanel bar.
42f5333f 1383
4e5d278c
RD
1384 In the FPB_COLLAPSE_TO_BOTTOM style, they will be removed from
1385 the bottom and the order where the panel originally was placed
1386 is restored.
42f5333f 1387 """
02b800ce
RD
1388
1389 fpbextrastyle = 0
42f5333f 1390
02b800ce
RD
1391 if self._extraStyle & FPB_SINGLE_FOLD or self._extraStyle & FPB_EXCLUSIVE_FOLD:
1392 fpbextrastyle = 1
1393 for panel in self._panels:
1394 panel.Collapse()
1395
42f5333f 1396 foldpanel.Expand()
02b800ce
RD
1397
1398 if fpbextrastyle:
1399 if self._extraStyle & FPB_EXCLUSIVE_FOLD:
1400 self.RepositionCollapsedToBottom()
1401 self.RefreshPanelsFrom(self._panels[0])
1402 else:
1403 self.RefreshPanelsFrom(foldpanel)
42f5333f
RD
1404
1405
1406 def ApplyCaptionStyle(self, foldpanel, cbstyle):
1407 """
4e5d278c
RD
1408 Sets the style of the caption bar (`CaptionBar`) of the
1409 FoldPanel.
42f5333f 1410
4e5d278c
RD
1411 The changes are applied immediately. All styles not set in the
1412 CaptionBarStyle class are not applied. Use the CaptionBar
1413 reference to indicate what captionbar you want to apply the
1414 style to. To apply one style to all CaptionBar items, use
1415 `ApplyCaptionStyleAll`
1416 """
42f5333f
RD
1417 foldpanel.ApplyCaptionStyle(cbstyle)
1418
1419
1420 def ApplyCaptionStyleAll(self, cbstyle):
4e5d278c
RD
1421 """
1422 Sets the style of all the caption bars of the FoldPanel.
42f5333f 1423
4e5d278c
RD
1424 The changes are applied immediately.
1425 """
42f5333f
RD
1426 for panels in self._panels:
1427 self.ApplyCaptionStyle(panels, cbstyle)
1428
1429
1430 def GetCaptionStyle(self, foldpanel):
1431 """
1432 Returns the currently used caption style for the FoldPanel.
1433
4e5d278c
RD
1434 It is returned as a CaptionBarStyle class. After modifying it,
1435 it can be set again.
1436 """
42f5333f
RD
1437 return foldpanel.GetCaptionStyle()
1438
1439
1440 def IsVertical(self):
1441 """
4e5d278c 1442 Returns whether the CaptionBar has default orientation or not.
42f5333f
RD
1443
1444 Default is vertical.
4e5d278c 1445 """
42f5333f
RD
1446 return self._isVertical
1447
1448
1449 def GetFoldPanel(self, item):
1450 """
1451 Returns the panel associated with the index "item".
1452
1453 See the example at the bottom of the module, especially the events
1454 for the "Collapse Me" and "Expand Me" buttons.
1455 """
42f5333f
RD
1456 try:
1457 ind = self._panels[item]
1458 return self._panels[item]
1459 except:
1460 raise "ERROR: List Index Out Of Range Or Bad Item Passed: " + repr(item) + \
1461 ". Item Should Be An Integer Between " + repr(0) + " And " + \
1462 repr(len(self._panels))
1463
1464
1465 def GetCount(self):
1466 """ Returns the number of panels in the FoldPanelBar. """
1467
1468 try:
1469 return len(self._panels)
1470 except:
1471 raise "ERROR: No Panels Have Been Added To FoldPanelBar"
1472
1473
1474
1475# --------------------------------------------------------------------------------- #
1476# class FoldPanelItem
42f5333f
RD
1477# --------------------------------------------------------------------------------- #
1478
1479class FoldPanelItem(wx.Panel):
4e5d278c
RD
1480 """
1481 This class is a child sibling of the `FoldPanelBar` class. It will
1482 contain a `CaptionBar` class for receiving of events, and a the
1483 rest of the area can be populated by a `wx.Panel` derived class.
1484 """
42f5333f
RD
1485 # Define Empty CaptionBar Style
1486 EmptyCaptionBarStyle = CaptionBarStyle()
1487
1488 def __init__(self, parent, id=wx.ID_ANY, caption="", foldIcons=None,
1489 collapsed=False, cbstyle=EmptyCaptionBarStyle):
1490 """ Default Class Constructor. """
1491
0159bfd0 1492 wx.Panel.__init__(self, parent, id, wx.Point(0,0), style=wx.CLIP_CHILDREN)
42f5333f
RD
1493 self._controlCreated = False
1494 self._UserSize = 0
1495 self._PanelSize = 0
1496 self._LastInsertPos = 0
1497 self._itemPos = 0
1498 self._userSized = False
1499
1500 if foldIcons is None:
1501 foldIcons = wx.ImageList(16, 16)
1502
1503 bmp = GetExpandedIconBitmap()
1504 foldIcons.Add(bmp)
1505 bmp = GetCollapsedIconBitmap()
1506 foldIcons.Add(bmp)
1507
1508 self._foldIcons = foldIcons
1509
1510 # create the caption bar, in collapsed or expanded state
1511
1512 self._captionBar = CaptionBar(self, wx.ID_ANY, wx.Point(0,0),
1513 size=wx.DefaultSize, caption=caption,
1514 foldIcons=foldIcons, cbstyle=cbstyle)
1515
1516 if collapsed:
1517 self._captionBar.Collapse()
1518
1519 self._controlCreated = True
1520
1521 # make initial size for component, if collapsed, the
1522 # size is determined on the panel height and won't change
1523
1524 size = self._captionBar.GetSize()
1525
1526 self._PanelSize = (self.IsVertical() and [size.GetHeight()] or \
1527 [size.GetWidth()])[0]
1528
1529 self._LastInsertPos = self._PanelSize
1530 self._items = []
1531
1532 self.Bind(EVT_CAPTIONBAR, self.OnPressCaption)
1533 self.Bind(wx.EVT_PAINT, self.OnPaint)
1534
1535
1536 def AddWindow(self, window, flags=FPB_ALIGN_WIDTH, Spacing=FPB_DEFAULT_SPACING,
1537 leftSpacing=FPB_DEFAULT_LEFTLINESPACING,
1538 rightSpacing=FPB_DEFAULT_RIGHTLINESPACING):
1539 """
1540 Adds a window item to the list of items on this panel.
1541
4e5d278c
RD
1542 The flags are FPB_ALIGN_LEFT for a non sizing window element,
1543 and FPB_ALIGN_WIDTH for a width aligned item. The Spacing
1544 parameter reserves a number of pixels before the window
1545 element, and leftSpacing is an indent. rightSpacing is only
1546 relevant when the style FPB_ALIGN_WIDTH is chosen.
42f5333f
RD
1547 """
1548
1549 wi = FoldWindowItem(self, window, Type="WINDOW", flags=flags, Spacing=Spacing,
1550 leftSpacing=leftSpacing, rightSpacing=rightSpacing)
1551
1552 self._items.append(wi)
1553
1554 vertical = self.IsVertical()
1555
1556 self._Spacing = Spacing
1557 self._leftSpacing = leftSpacing
1558 self._rightSpacing = rightSpacing
1559
1560 xpos = (vertical and [leftSpacing] or [self._LastInsertPos + Spacing])[0]
1561 ypos = (vertical and [self._LastInsertPos + Spacing] or [leftSpacing])[0]
1562
1563 window.SetDimensions(xpos, ypos, -1, -1, wx.SIZE_USE_EXISTING)
1564
1565 self._LastInsertPos = self._LastInsertPos + wi.GetWindowLength(vertical)
1566 self.ResizePanel()
1567
1568
1569 def AddSeparator(self, colour=wx.BLACK, Spacing=FPB_DEFAULT_SPACING,
1570 leftSpacing=FPB_DEFAULT_LEFTSPACING,
1571 rightSpacing=FPB_DEFAULT_RIGHTSPACING):
1572 """
1573 Adds a separator item to the list of items on this panel. """
1574
1575 wi = FoldWindowItem(self, window=None, Type="SEPARATOR",
1576 flags=FPB_ALIGN_WIDTH, y=self._LastInsertPos,
1577 colour=colour, Spacing=Spacing, leftSpacing=leftSpacing,
1578 rightSpacing=rightSpacing)
1579
1580 self._items.append(wi)
1581 self._LastInsertPos = self._LastInsertPos + \
1582 wi.GetWindowLength(self.IsVertical())
1583
1584 self.ResizePanel()
1585
1586
1587 def Reposition(self, pos):
4e5d278c
RD
1588 """
1589 Repositions this FoldPanelBar and reports the length occupied
1590 for the next FoldPanelBar in the list.
1591 """
42f5333f
RD
1592 # NOTE: Call Resize before Reposition when an item is added, because the new
1593 # size needed will be calculated by Resize. Of course the relative position
1594 # of the controls have to be correct in respect to the caption bar
1595
1596 self.Freeze()
1597
1598 vertical = self.IsVertical()
1599 xpos = (vertical and [-1] or [pos])[0]
1600 ypos = (vertical and [pos] or [-1])[0]
1601
1602 self.SetDimensions(xpos, ypos, -1, -1, wx.SIZE_USE_EXISTING)
1603 self._itemPos = pos
1604
1605 self.Thaw()
42f5333f
RD
1606
1607 return self.GetPanelLength()
1608
1609
1610 def OnPressCaption(self, event):
1611 """ Handles the EVT_CAPTIONBAR event in the FoldPanelItem. """
1612
1613 # tell the upper container we are responsible
1614 # for this event, so it can fold the panel item
1615 # and do a refresh
1616
1617 event.SetTag(self)
1618 event.Skip()
1619
1620
1621 def ResizePanel(self):
1622 """ Resizes the panel. """
1623
1624 # prevent unnecessary updates by blocking repaints for a sec
1625
1626 self.Freeze()
1627
1628 vertical = self.IsVertical()
1629 # force this panel to take the width of the parent panel and the y of the
1630 # user or calculated width (which will be recalculated by the contents here)
1631
1632
1633 if self._captionBar.IsCollapsed():
1634 size = self._captionBar.GetSize()
1635 self._PanelSize = (vertical and [size.GetHeight()] or [size.GetWidth()])[0]
1636 else:
1637 size = self.GetBestSize()
1638 self._PanelSize = (vertical and [size.GetHeight()] or [size.GetWidth()])[0]
1639
1640 if self._UserSize:
1641 if vertical:
1642 size.SetHeight(self._UserSize)
1643 else:
1644 size.SetWidth(self._UserSize)
1645
1646 pnlsize = self.GetParent().GetSize()
1647
1648 if vertical:
1649 size.SetWidth(pnlsize.GetWidth())
1650 else:
1651 size.SetHeight(pnlsize.GetHeight())
1652
1653 # resize caption bar
1654 xsize = (vertical and [size.GetWidth()] or [-1])[0]
1655 ysize = (vertical and [-1] or [size.GetHeight()])[0]
1656
1657 self._captionBar.SetSize((xsize, ysize))
1658
1659 # resize the panel
1660 self.SetSize(size)
1661
1662 # go by all the controls and call Layout
1663
1664 for items in self._items:
1665 items.ResizeItem((vertical and [size.GetWidth()] or \
1666 [size.GetHeight()])[0], vertical)
1667
1668 self.Thaw()
42f5333f
RD
1669
1670
1671 def OnPaint(self, event):
1672 """ Handles the EVT_PAINT event in the FoldPanelItem. """
1673
1674 # draw all the items that are lines
1675
1676 dc = wx.PaintDC(self)
1677 vertical = self.IsVertical()
1678
1679 for item in self._items:
1680
1681 if item.GetType() == "SEPARATOR":
1682 pen = wx.Pen(item.GetLineColour(), 1, wx.SOLID)
1683 dc.SetPen(pen)
1684 a = item.GetLeftSpacing()
1685 b = item.GetLineY() + item.GetSpacing()
1686 c = item.GetLineLength()
1687 d = a + c
1688
1689 if vertical:
1690 dc.DrawLine(a, b, d, b)
1691 else:
1692 dc.DrawLine(b, a, b, d)
1693
1694 event.Skip()
1695
1696
1697 def IsVertical(self):
1698 """
1699 Returns wether the CaptionBar Has Default Orientation Or Not.
1700
1701 Default is vertical.
1702 """
1703
1704 # grandparent of FoldPanelItem is FoldPanelBar
1705 # default is vertical
1706
1707 if isinstance(self.GetGrandParent(), FoldPanelBar):
1708 return self.GetGrandParent().IsVertical()
1709 else:
1710 raise "ERROR: Wrong Parent " + repr(self.GetGrandParent())
1711
1712
1713 def IsExpanded(self):
4e5d278c
RD
1714 """
1715 Returns expanded or collapsed status. If the panel is
1716 expanded, True is returned.
1717 """
42f5333f
RD
1718
1719 return not self._captionBar.IsCollapsed()
1720
1721
1722 def GetItemPos(self):
1723 """ Returns item's position. """
1724
1725 return self._itemPos
1726
1727
1728 def Collapse(self):
1729 # this should not be called by the user, because it doesn't trigger the
1730 # parent to tell it that we are collapsed or expanded, it only changes
1731 # visual state
1732
1733 self._captionBar.Collapse()
1734 self.ResizePanel()
1735
1736
1737 def Expand(self):
1738 # this should not be called by the user, because it doesn't trigger the
1739 # parent to tell it that we are collapsed or expanded, it only changes
1740 # visual state
1741
1742 self._captionBar.Expand()
1743 self.ResizePanel()
1744
1745
1746 def GetPanelLength(self):
1747 """ Returns size of panel. """
1748
1749 if self._captionBar.IsCollapsed():
1750 return self.GetCaptionLength()
1751 elif self._userSized:
1752 return self._UserSize
1753
1754 return self._PanelSize
1755
1756
1757 def GetCaptionLength(self):
4e5d278c
RD
1758 """
1759 Returns height of caption only. This is for folding
1760 calculation purposes.
1761 """
42f5333f
RD
1762
1763 size = self._captionBar.GetSize()
1764 return (self.IsVertical() and [size.GetHeight()] or [size.GetWidth()])[0]
1765
1766
1767 def ApplyCaptionStyle(self, cbstyle):
1768 """ Applies the style defined in cbstyle to the CaptionBar."""
1769
1770 self._captionBar.SetCaptionStyle(cbstyle)
1771
1772
1773 def GetCaptionStyle(self):
1774 """
4e5d278c
RD
1775 Returns the current style of the captionbar in a
1776 CaptionBarStyle class.
42f5333f
RD
1777
1778 This can be used to change and set back the changes.
1779 """
1780
1781 return self._captionBar.GetCaptionStyle()
1782
1783
1784# ----------------------------------------------------------------------------------- #
1785# class FoldWindowItem
42f5333f
RD
1786# ----------------------------------------------------------------------------------- #
1787
1788class FoldWindowItem:
4e5d278c
RD
1789 """
1790 This class is a child sibling of the `FoldPanelItem` class. It
1791 will contain wx.Window that can be either a separator (a colored
1792 line simulated by a wx.Window) or a wxPython controls (such as a
1793 wx.Button, a wx.ListCtrl etc...).
1794 """
42f5333f
RD
1795 def __init__(self, parent, window=None, **kw):
1796 """
1797 Default Class Constructor
1798
4e5d278c 1799 Initialize with::
42f5333f
RD
1800
1801 Type = "WINDOW", flags = FPB_ALIGN_WIDTH,
1802 Spacing = FPB_DEFAULT_SPACING,
1803 leftSpacing = FPB_DEFAULT_LEFTSPACING,
1804 rightSpacing = FPB_DEFAULT_RIGHTSPACING
1805
4e5d278c 1806 or::
42f5333f
RD
1807
1808 Type = "SEPARATOR"
1809 y, lineColor = wx.BLACK,
1810 flags = FPB_ALIGN_WIDTH,
1811 Spacing = FPB_DEFAULT_SPACING,
1812 leftSpacing = FPB_DEFAULT_LEFTLINESPACING,
1813 rightSpacing = FPB_DEFAULT_RIGHTLINESPACING
1814 """
1815
1816
1817 if not kw.has_key("Type"):
1818 raise 'ERROR: Missing Window Type Information. This Should Be "WINDOW" Or "SEPARATOR"'
1819
1820 if kw.get("Type") == "WINDOW":
1821 # Window constructor. This initialises the class as a wx.Window Type
1822
1823 if kw.has_key("flags"):
1824 self._flags = kw.get("flags")
1825 else:
1826 self._flags = FPB_ALIGN_WIDTH
1827 if kw.has_key("Spacing"):
1828 self._Spacing = kw.get("Spacing")
1829 else:
1830 self._Spacing = FPB_DEFAULT_SPACING
1831 if kw.has_key("leftSpacing"):
1832 self._leftSpacing = kw.get("leftSpacing")
1833 else:
1834 self._leftSpacing = FPB_DEFAULT_LEFTSPACING
1835 if kw.has_key("rightSpacing"):
1836 self._rightSpacing = kw.get("rightSpacing")
1837 else:
1838 self._rightSpacing = FPB_DEFAULT_RIGHTSPACING
1839
1840 self._lineY = 0
1841 self._sepLineColour = None
1842 self._wnd = window
1843
1844
1845 elif kw.get("Type") == "SEPARATOR":
1846 # separator constructor. This initialises the class as a separator type
1847
1848 if kw.has_key("y"):
1849 self._lineY = kw.get("y")
1850 else:
1851 raise "ERROR: Undefined Y Position For The Separator"
1852 if kw.has_key("lineColour"):
1853 self._sepLineColour = kw.get("lineColour")
1854 else:
1855 self._sepLineColour = wx.BLACK
1856 if kw.has_key("flags"):
1857 self._flags = kw.get("flags")
1858 else:
1859 self._flags = FPB_ALIGN_WIDTH
1860 if kw.has_key("Spacing"):
1861 self._Spacing = kw.get("Spacing")
1862 else:
1863 self._Spacing = FPB_DEFAULT_SPACING
1864 if kw.has_key("leftSpacing"):
1865 self._leftSpacing = kw.get("leftSpacing")
1866 else:
1867 self._leftSpacing = FPB_DEFAULT_LEFTSPACING
1868 if kw.has_key("rightSpacing"):
1869 self._rightSpacing = kw.get("rightSpacing")
1870 else:
1871 self._rightSpacing = FPB_DEFAULT_RIGHTSPACING
1872
1873 self._wnd = window
1874
1875 else:
1876 raise "ERROR: Undefined Window Type Selected: " + repr(kw.get("Type"))
1877
1878 self._type = kw.get("Type")
1879 self._lineLength = 0
1880
1881
1882 def GetType(self):
1883 return self._type
1884
1885 def GetLineY(self):
1886 return self._lineY
1887
1888 def GetLineLength(self):
1889 return self._lineLength
1890
1891 def GetLineColour(self):
1892 return self._sepLineColour
1893
1894 def GetLeftSpacing(self):
1895 return self._leftSpacing
1896
1897 def GetRightSpacing(self):
1898 return self._rightSpacing
1899
1900 def GetSpacing(self):
1901 return self._Spacing
1902
1903
1904 def GetWindowLength(self, vertical=True):
4e5d278c
RD
1905 """
1906 Returns space needed by the window if type is FoldWindowItem
1907 "WINDOW" and returns the total size plus the extra spacing.
1908 """
42f5333f
RD
1909
1910 value = 0
1911 if self._type == "WINDOW":
1912 size = self._wnd.GetSize()
1913 value = (vertical and [size.GetHeight()] or [size.GetWidth()])[0] + \
1914 self._Spacing
1915
1916 elif self._type == "SEPARATOR":
1917 value = 1 + self._Spacing
1918
1919 return value
1920
1921
1922 def ResizeItem(self, size, vertical=True):
1923 """
1924 Resizes the element, whatever it is.
1925
1926 A separator or line will be always aligned by width or height
1927 depending on orientation of the whole panel.
1928 """
1929
1930 if self._flags & FPB_ALIGN_WIDTH:
1931 # align by taking full width
1932 mySize = size - self._leftSpacing - self._rightSpacing
1933
1934 if mySize < 0:
1935 mySize = 10 # can't have negative width
1936
1937 if self._type == "SEPARATOR":
1938 self._lineLength = mySize
1939 else:
1940 xsize = (vertical and [mySize] or [-1])[0]
1941 ysize = (vertical and [-1] or [mySize])[0]
1942
1943 self._wnd.SetSize((xsize, ysize))
1944