1 # --------------------------------------------------------------------------- #
2 # FLATNOTEBOOK Widget wxPython IMPLEMENTATION
4 # Original C++ Code From Eran. You Can Find It At:
6 # http://wxforum.shadonet.com/viewtopic.php?t=5761&start=0
8 # License: wxWidgets license
13 # Andrea Gavana, @ 02 Oct 2006
14 # Latest Revision: 04 Oct 2006, 20.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 The FlatNotebook is a full implementation of the wx.Notebook, and designed to be
31 a drop-in replacement for wx.Notebook. The API functions are similar so one can
32 expect the function to behave in the same way.
35 - The buttons are highlighted a la Firefox style
36 - The scrolling is done for bulks of tabs (so, the scrolling is faster and better)
37 - The buttons area is never overdrawn by tabs (unlike many other implementations I saw)
38 - It is a generic control
39 - Currently there are 4 differnt styles - VC8, VC 71, Standard and Fancy.
40 - Mouse middle click can be used to close tabs
41 - A function to add right click menu for tabs (simple as SetRightClickMenu)
42 - All styles has bottom style as well (they can be drawn in the bottom of screen)
43 - An option to hide 'X' button or navigation buttons (separately)
44 - Gradient coloring of the selected tabs and border
45 - Support for drag 'n' drop of tabs, both in the same notebook or to another notebook
46 - Possibility to have closing button on the active tab directly
47 - Support for disabled tabs
48 - Colours for active/inactive tabs, and captions
49 - Background of tab area can be painted in gradient (VC8 style only)
50 - Colourful tabs - a random gentle colour is generated for each new tab (very cool,
58 The following example shows a simple implementation that uses FlatNotebook inside
62 import wx.lib.flatnotebook as FNB
64 class MyFrame(wx.Frame):
66 def __init__(self, parent, id=wx.ID_ANY, title="", pos=wx.DefaultPosition, size=(800, 600),
67 style=wx.DEFAULT_FRAME_STYLE | wx.MAXIMIZE |wx.NO_FULL_REPAINT_ON_RESIZE):
69 wx.Frame.__init__(self, parent, id, title, pos, size, style)
71 mainSizer = wx.BoxSizer(wx.VERTICAL)
72 self.SetSizer(mainSizer)
74 bookStyle = FNB.FNB_TABS_BORDER_SIMPLE
76 self.book = FNB.StyledNotebook(self, wx.ID_ANY, style=bookStyle)
77 mainSizer.Add(self.book, 1, wx.EXPAND)
79 # Add some pages to the notebook
82 text = wx.TextCtrl(self.book, -1, "Book Page 1", style=wx.TE_MULTILINE)
83 self.book.AddPage(text, "Book Page 1")
85 text = wx.TextCtrl(self.book, -1, "Book Page 2", style=wx.TE_MULTILINE)
86 self.book.AddPage(text, "Book Page 2")
93 # our normal wxApp-derived class, as usual
95 app = wx.PySimpleApp()
98 app.SetTopWindow(frame)
106 FlatNotebook Is Freeware And Distributed Under The wxPython License.
108 Latest Revision: Andrea Gavana @ 04 Oct 2006, 20.00 GMT
119 # Check for the new method in 2.7 (not present in 2.6.3.3)
120 if wx
.VERSION_STRING
< "2.7":
121 wx
.Rect
.Contains
= lambda self
, point
: wx
.Rect
.Inside(self
, point
)
123 FNB_HEIGHT_SPACER
= 10
125 # Use Visual Studio 2003 (VC7.1) Style for tabs
128 # Use fancy style - square tabs filled with gradient coloring
131 # Draw thin border around the page
132 FNB_TABS_BORDER_SIMPLE
= 4
134 # Do not display the 'X' button
137 # Do not display the Right / Left arrows
138 FNB_NO_NAV_BUTTONS
= 16
140 # Use the mouse middle button for cloing tabs
141 FNB_MOUSE_MIDDLE_CLOSES_TABS
= 32
143 # Place tabs at bottom - the default is to place them
147 # Disable dragging of tabs
150 # Use Visual Studio 2005 (VC8) Style for tabs
154 # Note: This style is not supported on VC8 style
157 FNB_BACKGROUND_GRADIENT
= 1024
159 FNB_COLORFUL_TABS
= 2048
161 # Style to close tab using double click - styles 1024, 2048 are reserved
162 FNB_DCLICK_CLOSES_TABS
= 4096
164 VERTICAL_BORDER_PADDING
= 4
166 # Button size is a 16x16 xpm bitmap
171 MASK_COLOR
= wx
.Color(0, 128, 128)
180 FNB_TAB
= 1 # On a tab
181 FNB_X
= 2 # On the X button
182 FNB_TAB_X
= 3 # On the 'X' button (tab's X button)
183 FNB_LEFT_ARROW
= 4 # On the rotate left arrow button
184 FNB_RIGHT_ARROW
= 5 # On the rotate right arrow button
185 FNB_NOWHERE
= 0 # Anywhere else
187 FNB_DEFAULT_STYLE
= FNB_MOUSE_MIDDLE_CLOSES_TABS
189 # FlatNotebook Events:
190 # wxEVT_FLATNOTEBOOK_PAGE_CHANGED: Event Fired When You Switch Page;
191 # wxEVT_FLATNOTEBOOK_PAGE_CHANGING: Event Fired When You Are About To Switch
192 # Pages, But You Can Still "Veto" The Page Changing By Avoiding To Call
193 # event.Skip() In Your Event Handler;
194 # wxEVT_FLATNOTEBOOK_PAGE_CLOSING: Event Fired When A Page Is Closing, But
195 # You Can Still "Veto" The Page Changing By Avoiding To Call event.Skip()
196 # In Your Event Handler;
197 # wxEVT_FLATNOTEBOOK_PAGE_CLOSED: Event Fired When A Page Is Closed.
198 # wxEVT_FLATNOTEBOOK_PAGE_CONTEXT_MENU: Event Fired When A Menu Pops-up In A Tab.
200 wxEVT_FLATNOTEBOOK_PAGE_CHANGED
= wx
.NewEventType()
201 wxEVT_FLATNOTEBOOK_PAGE_CHANGING
= wx
.NewEventType()
202 wxEVT_FLATNOTEBOOK_PAGE_CLOSING
= wx
.NewEventType()
203 wxEVT_FLATNOTEBOOK_PAGE_CLOSED
= wx
.NewEventType()
204 wxEVT_FLATNOTEBOOK_PAGE_CONTEXT_MENU
= wx
.NewEventType()
206 #-----------------------------------#
208 #-----------------------------------#
210 EVT_FLATNOTEBOOK_PAGE_CHANGED
= wx
.PyEventBinder(wxEVT_FLATNOTEBOOK_PAGE_CHANGED
, 1)
211 EVT_FLATNOTEBOOK_PAGE_CHANGING
= wx
.PyEventBinder(wxEVT_FLATNOTEBOOK_PAGE_CHANGING
, 1)
212 EVT_FLATNOTEBOOK_PAGE_CLOSING
= wx
.PyEventBinder(wxEVT_FLATNOTEBOOK_PAGE_CLOSING
, 1)
213 EVT_FLATNOTEBOOK_PAGE_CLOSED
= wx
.PyEventBinder(wxEVT_FLATNOTEBOOK_PAGE_CLOSED
, 1)
214 EVT_FLATNOTEBOOK_PAGE_CONTEXT_MENU
= wx
.PyEventBinder(wxEVT_FLATNOTEBOOK_PAGE_CONTEXT_MENU
, 1)
216 # Some icons in XPM format
218 left_arrow_disabled_xpm
= [
246 x_button_pressed_xpm
= [
303 x_button_hilite_xpm
= [
359 left_arrow_pressed_xpm
= [
387 left_arrow_hilite_xpm
= [
415 right_arrow_disabled_xpm
= [
443 right_arrow_hilite_xpm
= [
471 right_arrow_pressed_xpm
= [
530 def LightColour(color
, percent
):
531 """ Brighten input colour by percent. """
535 rd
= end_color
.Red() - color
.Red()
536 gd
= end_color
.Green() - color
.Green()
537 bd
= end_color
.Blue() - color
.Blue()
541 # We take the percent way of the color from color -. white
543 r
= color
.Red() + ((i
*rd
*100)/high
)/100
544 g
= color
.Green() + ((i
*gd
*100)/high
)/100
545 b
= color
.Blue() + ((i
*bd
*100)/high
)/100
546 return wx
.Color(r
, g
, b
)
549 def PaintStraightGradientBox(dc
, rect
, startColor
, endColor
, vertical
=True):
550 """ Draws a gradient colored box from startColor to endColor. """
552 rd
= endColor
.Red() - startColor
.Red()
553 gd
= endColor
.Green() - startColor
.Green()
554 bd
= endColor
.Blue() - startColor
.Blue()
556 # Save the current pen and brush
557 savedPen
= dc
.GetPen()
558 savedBrush
= dc
.GetBrush()
561 high
= rect
.GetHeight()-1
563 high
= rect
.GetWidth()-1
568 for i
in xrange(high
+1):
570 r
= startColor
.Red() + ((i
*rd
*100)/high
)/100
571 g
= startColor
.Green() + ((i
*gd
*100)/high
)/100
572 b
= startColor
.Blue() + ((i
*bd
*100)/high
)/100
574 p
= wx
.Pen(wx
.Color(r
, g
, b
))
578 dc
.DrawLine(rect
.x
, rect
.y
+i
, rect
.x
+rect
.width
, rect
.y
+i
)
580 dc
.DrawLine(rect
.x
+i
, rect
.y
, rect
.x
+i
, rect
.y
+rect
.height
)
582 # Restore the pen and brush
584 dc
.SetBrush(savedBrush
)
588 """ Creates a random colour. """
590 r
= random
.randint(0, 255) # Random value betweem 0-255
591 g
= random
.randint(0, 255) # Random value betweem 0-255
592 b
= random
.randint(0, 255) # Random value betweem 0-255
594 return wx
.Color(r
, g
, b
)
597 # ---------------------------------------------------------------------------- #
599 # Stores All The Information To Allow Drag And Drop Between Different
601 # ---------------------------------------------------------------------------- #
605 _map
= weakref
.WeakValueDictionary()
607 def __init__(self
, container
, pageindex
):
608 """ Default class constructor. """
610 self
._id
= id(container
)
611 FNBDragInfo
._map
[self
._id
] = container
612 self
._pageindex
= pageindex
615 def GetContainer(self
):
616 """ Returns the FlatNotebook page (usually a panel). """
618 return FNBDragInfo
._map
.get(self
._id
, None)
621 def GetPageIndex(self
):
622 """ Returns the page index associated with a page. """
624 return self
._pageindex
627 # ---------------------------------------------------------------------------- #
628 # Class FNBDropTarget
629 # Simply Used To Handle The OnDrop() Method When Dragging And Dropping Between
630 # Different FlatNotebooks.
631 # ---------------------------------------------------------------------------- #
633 class FNBDropTarget(wx
.DropTarget
):
635 def __init__(self
, parent
):
636 """ Default class constructor. """
638 wx
.DropTarget
.__init
__(self
)
640 self
._parent
= parent
641 self
._dataobject
= wx
.CustomDataObject(wx
.CustomDataFormat("FlatNotebook"))
642 self
.SetDataObject(self
._dataobject
)
645 def OnData(self
, x
, y
, dragres
):
646 """ Handles the OnData() method to call the real DnD routine. """
648 if not self
.GetData():
651 draginfo
= self
._dataobject
.GetData()
652 drginfo
= cPickle
.loads(draginfo
)
654 return self
._parent
.OnDropTarget(x
, y
, drginfo
.GetPageIndex(), drginfo
.GetContainer())
657 # ---------------------------------------------------------------------------- #
659 # Contains parameters for every FlatNotebook page
660 # ---------------------------------------------------------------------------- #
664 def __init__(self
, caption
="", imageindex
=-1, tabangle
=0, enabled
=True):
666 Default Class Constructor.
669 - caption: the tab caption;
670 - imageindex: the tab image index based on the assigned (set) wx.ImageList (if any);
671 - tabangle: the tab angle (only on standard tabs, from 0 to 15 degrees);
672 - enabled: sets enabled or disabled the tab.
675 self
._strCaption
= caption
676 self
._TabAngle
= tabangle
677 self
._ImageIndex
= imageindex
678 self
._bEnabled
= enabled
679 self
._pos
= wx
.Point(-1, -1)
680 self
._size
= wx
.Size(-1, -1)
681 self
._region
= wx
.Region()
682 self
._xRect
= wx
.Rect()
686 def SetCaption(self
, value
):
687 """ Sets the tab caption. """
689 self
._strCaption
= value
692 def GetCaption(self
):
693 """ Returns the tab caption. """
695 return self
._strCaption
698 def SetPosition(self
, value
):
699 """ Sets the tab position. """
704 def GetPosition(self
):
705 """ Returns the tab position. """
710 def SetSize(self
, value
):
711 """ Sets the tab size. """
717 """ Returns the tab size. """
722 def SetTabAngle(self
, value
):
723 """ Sets the tab header angle (0 <= tab <= 15 degrees). """
725 self
._TabAngle
= min(45, value
)
728 def GetTabAngle(self
):
729 """ Returns the tab angle. """
731 return self
._TabAngle
734 def SetImageIndex(self
, value
):
735 """ Sets the tab image index. """
737 self
._ImageIndex
= value
740 def GetImageIndex(self
):
741 """ Returns the tab umage index. """
743 return self
._ImageIndex
746 def GetEnabled(self
):
747 """ Returns whether the tab is enabled or not. """
749 return self
._bEnabled
752 def Enable(self
, enabled
):
753 """ Sets the tab enabled or disabled. """
755 self
._bEnabled
= enabled
758 def SetRegion(self
, points
=[]):
759 """ Sets the tab region. """
761 self
._region
= wx
.RegionFromPoints(points
)
765 """ Returns the tab region. """
770 def SetXRect(self
, xrect
):
771 """ Sets the button 'X' area rect. """
777 """ Returns the button 'X' area rect. """
783 """ Returns the tab colour. """
788 def SetColor(self
, color
):
789 """ Sets the tab colour. """
794 # ---------------------------------------------------------------------------- #
795 # Class FlatNotebookEvent
796 # ---------------------------------------------------------------------------- #
798 class FlatNotebookEvent(wx
.PyCommandEvent
):
800 This events will be sent when a EVT_FLATNOTEBOOK_PAGE_CHANGED,
801 EVT_FLATNOTEBOOK_PAGE_CHANGING And EVT_FLATNOTEBOOK_PAGE_CLOSING is mapped in
805 def __init__(self
, eventType
, id=1, nSel
=-1, nOldSel
=-1):
806 """ Default class constructor. """
808 wx
.PyCommandEvent
.__init
__(self
, eventType
, id)
809 self
._eventType
= eventType
811 self
.notify
= wx
.NotifyEvent(eventType
, id)
814 def GetNotifyEvent(self
):
815 """Returns the actual wx.NotifyEvent."""
821 """Returns whether the event is allowed or not."""
823 return self
.notify
.IsAllowed()
827 """Vetos the event."""
833 """The event is allowed."""
838 def SetSelection(self
, nSel
):
839 """ Sets event selection. """
841 self
._selection
= nSel
844 def SetOldSelection(self
, nOldSel
):
845 """ Sets old event selection. """
847 self
._oldselection
= nOldSel
850 def GetSelection(self
):
851 """ Returns event selection. """
853 return self
._selection
856 def GetOldSelection(self
):
857 """ Returns old event selection """
859 return self
._oldselection
862 # ---------------------------------------------------------------------------- #
863 # Class FlatNotebookBase
864 # ---------------------------------------------------------------------------- #
866 class FlatNotebookBase(wx
.Panel
):
868 def __init__(self
, parent
, id=wx
.ID_ANY
, pos
=wx
.DefaultPosition
, size
=wx
.DefaultSize
,
869 style
=0, name
="FlatNotebook"):
871 Default class constructor.
873 All the parameters are as in wxPython class construction, except the
874 'style': this can be assigned to whatever combination of FNB_* styles.
877 self
._bForceSelection
= False
880 style |
= wx
.TAB_TRAVERSAL
884 wx
.Panel
.__init
__(self
, parent
, id, pos
, size
, style
)
886 self
._pages
= StyledTabsContainer(self
, wx
.ID_ANY
, wx
.DefaultPosition
, wx
.DefaultSize
, style
)
888 self
.Bind(wx
.EVT_NAVIGATION_KEY
, self
.OnNavigationKey
)
890 self
._pages
._colorBorder
= wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_BTNSHADOW
)
892 self
._mainSizer
= wx
.BoxSizer(wx
.VERTICAL
)
893 self
.SetSizer(self
._mainSizer
)
895 # The child panels will inherit this bg color, so leave it at the default value
896 #self.SetBackgroundColour(wx.SystemSettings.GetColour(wx.SYS_COLOUR_APPWORKSPACE))
898 # Add the tab container to the sizer
899 self
._mainSizer
.Insert(0, self
._pages
, 0, wx
.EXPAND
)
901 # Set default page height
902 dc
= wx
.ClientDC(self
)
903 font
= self
.GetFont()
904 font
.SetWeight(wx
.FONTWEIGHT_BOLD
)
906 height
= dc
.GetCharHeight()
907 ##print height, font.Ok()
909 tabHeight
= height
+ FNB_HEIGHT_SPACER
# We use 8 pixels as padding
910 self
._pages
.SetSizeHints(-1, tabHeight
)
912 self
._mainSizer
.Layout()
914 self
._pages
._nFrom
= self
._nFrom
915 self
._pDropTarget
= FNBDropTarget(self
)
916 self
.SetDropTarget(self
._pDropTarget
)
919 def CreatePageContainer(self
):
920 """ Creates the page container for the tabs. """
922 return PageContainerBase(self
, wx
.ID_ANY
)
925 def SetActiveTabTextColour(self
, textColour
):
926 """ Sets the text colour for the active tab. """
928 self
._pages
._activeTextColor
= textColour
931 def OnDropTarget(self
, x
, y
, nTabPage
, wnd_oldContainer
):
932 """ Handles the drop action from a DND operation. """
934 return self
._pages
.OnDropTarget(x
, y
, nTabPage
, wnd_oldContainer
)
937 def AddPage(self
, window
, caption
, selected
=True, imgindex
=-1):
939 Add a page to the FlatNotebook.
942 - window: Specifies the new page.
943 - caption: Specifies the text for the new page.
944 - selected: Specifies whether the page should be selected.
945 - imgindex: Specifies the optional image index for the new page.
948 True if successful, False otherwise.
955 # reparent the window to us
956 window
.Reparent(self
)
959 bSelected
= selected
or not self
._windows
960 curSel
= self
._pages
.GetSelection()
962 if not self
._pages
.IsShown():
965 self
._pages
.AddPage(caption
, bSelected
, imgindex
)
966 self
._windows
.append(window
)
970 # Check if a new selection was made
975 # Remove the window from the main sizer
976 self
._mainSizer
.Detach(self
._windows
[curSel
])
977 self
._windows
[curSel
].Hide()
979 if self
.GetWindowStyleFlag() & FNB_BOTTOM
:
981 self
._mainSizer
.Insert(0, window
, 1, wx
.EXPAND
)
985 # We leave a space of 1 pixel around the window
986 self
._mainSizer
.Add(window
, 1, wx
.EXPAND
)
993 self
._mainSizer
.Layout()
1000 def SetImageList(self
, imglist
):
1002 Sets the image list for the page control. It does not take ownership
1003 of the image list, you must delete it yourself.
1006 self
._pages
.SetImageList(imglist
)
1009 def GetImageList(self
):
1010 """ Returns the associated image list. """
1012 return self
._pages
.GetImageList()
1015 def InsertPage(self
, indx
, page
, text
, select
=True, imgindex
=-1):
1017 Inserts a new page at the specified position.
1020 - indx: Specifies the position of the new page.
1021 - page: Specifies the new page.
1022 - text: Specifies the text for the new page.
1023 - select: Specifies whether the page should be selected.
1024 - imgindex: Specifies the optional image index for the new page.
1027 True if successful, False otherwise.
1034 # reparent the window to us
1037 if not self
._windows
:
1039 self
.AddPage(page
, text
, select
, imgindex
)
1043 bSelected
= select
or not self
._windows
1044 curSel
= self
._pages
.GetSelection()
1046 indx
= max(0, min(indx
, len(self
._windows
)))
1048 if indx
<= len(self
._windows
):
1050 self
._windows
.insert(indx
, page
)
1054 self
._windows
.append(page
)
1056 self
._pages
.InsertPage(indx
, text
, bSelected
, imgindex
)
1063 # Check if a new selection was made
1068 # Remove the window from the main sizer
1069 self
._mainSizer
.Detach(self
._windows
[curSel
])
1070 self
._windows
[curSel
].Hide()
1072 self
._pages
.SetSelection(indx
)
1080 self
._mainSizer
.Layout()
1086 def SetSelection(self
, page
):
1088 Sets the selection for the given page.
1089 The call to this function generates the page changing events
1092 if page
>= len(self
._windows
) or not self
._windows
:
1095 # Support for disabed tabs
1096 if not self
._pages
.GetEnabled(page
) and len(self
._windows
) > 1 and not self
._bForceSelection
:
1099 curSel
= self
._pages
.GetSelection()
1101 # program allows the page change
1105 # Remove the window from the main sizer
1106 self
._mainSizer
.Detach(self
._windows
[curSel
])
1107 self
._windows
[curSel
].Hide()
1109 if self
.GetWindowStyleFlag() & FNB_BOTTOM
:
1111 self
._mainSizer
.Insert(0, self
._windows
[page
], 1, wx
.EXPAND
)
1115 # We leave a space of 1 pixel around the window
1116 self
._mainSizer
.Add(self
._windows
[page
], 1, wx
.EXPAND
)
1118 self
._windows
[page
].Show()
1120 self
._mainSizer
.Layout()
1121 self
._pages
._iActivePage
= page
1125 self
._pages
.DoSetSelection(page
)
1128 def DeletePage(self
, page
):
1130 Deletes the specified page, and the associated window.
1131 The call to this function generates the page changing events.
1134 if page
>= len(self
._windows
):
1137 # Fire a closing event
1138 event
= FlatNotebookEvent(wxEVT_FLATNOTEBOOK_PAGE_CLOSING
, self
.GetId())
1139 event
.SetSelection(page
)
1140 event
.SetEventObject(self
)
1141 self
.GetEventHandler().ProcessEvent(event
)
1143 # The event handler allows it?
1144 if not event
.IsAllowed():
1149 # Delete the requested page
1150 pageRemoved
= self
._windows
[page
]
1152 # If the page is the current window, remove it from the sizer
1154 if page
== self
._pages
.GetSelection():
1155 self
._mainSizer
.Detach(pageRemoved
)
1157 # Remove it from the array as well
1158 self
._windows
.pop(page
)
1160 # Now we can destroy it in wxWidgets use Destroy instead of delete
1161 pageRemoved
.Destroy()
1165 self
._pages
.DoDeletePage(page
)
1168 # Fire a closed event
1169 closedEvent
= FlatNotebookEvent(wxEVT_FLATNOTEBOOK_PAGE_CLOSED
, self
.GetId())
1170 closedEvent
.SetSelection(page
)
1171 closedEvent
.SetEventObject(self
)
1172 self
.GetEventHandler().ProcessEvent(closedEvent
)
1175 def DeleteAllPages(self
):
1176 """ Deletes all the pages. """
1178 if not self
._windows
:
1183 for page
in self
._windows
:
1189 # Clear the container of the tabs as well
1190 self
._pages
.DeleteAllPages()
1194 def GetCurrentPage(self
):
1195 """ Returns the currently selected notebook page or None. """
1197 sel
= self
._pages
.GetSelection()
1201 return self
._windows
[sel
]
1204 def GetPage(self
, page
):
1205 """ Returns the window at the given page position, or None. """
1207 if page
>= len(self
._windows
):
1210 return self
._windows
[page
]
1213 def GetPageIndex(self
, win
):
1214 """ Returns the index at which the window is found. """
1217 return self
._windows
.index(win
)
1222 def GetSelection(self
):
1223 """ Returns the currently selected page, or -1 if none was selected. """
1225 return self
._pages
.GetSelection()
1228 def AdvanceSelection(self
, bForward
=True):
1230 Cycles through the tabs.
1231 The call to this function generates the page changing events.
1234 self
._pages
.AdvanceSelection(bForward
)
1237 def GetPageCount(self
):
1238 """ Returns the number of pages in the FlatNotebook control. """
1239 return self
._pages
.GetPageCount()
1242 def OnNavigationKey(self
, event
):
1243 """ Handles the wx.EVT_NAVIGATION_KEY event for FlatNotebook. """
1245 if event
.IsWindowChange():
1247 self
.AdvanceSelection(event
.GetDirection())
1249 # pass to the parent
1250 if self
.GetParent():
1251 event
.SetCurrentFocus(self
)
1252 self
.GetParent().ProcessEvent(event
)
1255 def GetPageShapeAngle(self
, page_index
):
1256 """ Returns the angle associated to a tab. """
1258 if page_index
< 0 or page_index
>= len(self
._pages
._pagesInfoVec
):
1261 result
= self
._pages
._pagesInfoVec
[page_index
].GetTabAngle()
1265 def SetPageShapeAngle(self
, page_index
, angle
):
1266 """ Sets the angle associated to a tab. """
1268 if page_index
< 0 or page_index
>= len(self
._pages
._pagesInfoVec
):
1274 self
._pages
._pagesInfoVec
[page_index
].SetTabAngle(angle
)
1277 def SetAllPagesShapeAngle(self
, angle
):
1278 """ Sets the angle associated to all the tab. """
1283 for ii
in xrange(len(self
._pages
._pagesInfoVec
)):
1284 self
._pages
._pagesInfoVec
[ii
].SetTabAngle(angle
)
1289 def GetPageBestSize(self
):
1290 """ Return the page best size. """
1292 return self
._pages
.GetClientSize()
1295 def SetPageText(self
, page
, text
):
1296 """ Sets the text for the given page. """
1298 bVal
= self
._pages
.SetPageText(page
, text
)
1299 self
._pages
.Refresh()
1304 def SetPadding(self
, padding
):
1306 Sets the amount of space around each page's icon and label, in pixels.
1307 NB: only the horizontal padding is considered.
1310 self
._nPadding
= padding
.GetWidth()
1313 def GetTabArea(self
):
1314 """ Returns the associated page. """
1319 def GetPadding(self
):
1320 """ Returns the amount of space around each page's icon and label, in pixels. """
1322 return self
._nPadding
1325 def SetWindowStyleFlag(self
, style
):
1326 """ Sets the FlatNotebook window style flags. """
1328 wx
.Panel
.SetWindowStyleFlag(self
, style
)
1332 # For changing the tab position (i.e. placing them top/bottom)
1333 # refreshing the tab container is not enough
1334 self
.SetSelection(self
._pages
._iActivePage
)
1337 def RemovePage(self
, page
):
1338 """ Deletes the specified page, without deleting the associated window. """
1340 if page
>= len(self
._windows
):
1343 # Fire a closing event
1344 event
= FlatNotebookEvent(wxEVT_FLATNOTEBOOK_PAGE_CLOSING
, self
.GetId())
1345 event
.SetSelection(page
)
1346 event
.SetEventObject(self
)
1347 self
.GetEventHandler().ProcessEvent(event
)
1349 # The event handler allows it?
1350 if not event
.IsAllowed():
1355 # Remove the requested page
1356 pageRemoved
= self
._windows
[page
]
1358 # If the page is the current window, remove it from the sizer
1360 if page
== self
._pages
.GetSelection():
1361 self
._mainSizer
.Detach(pageRemoved
)
1363 # Remove it from the array as well
1364 self
._windows
.pop(page
)
1367 self
._pages
.DoDeletePage(page
)
1372 def SetRightClickMenu(self
, menu
):
1373 """ Sets the popup menu associated to a right click on a tab. """
1375 self
._pages
._pRightClickMenu
= menu
1378 def GetPageText(self
, page
):
1379 """ Returns the tab caption. """
1381 return self
._pages
.GetPageText(page
)
1384 def SetGradientColors(self
, fr
, to
, border
):
1385 """ Sets the gradient colours for the tab. """
1387 self
._pages
._colorFrom
= fr
1388 self
._pages
._colorTo
= to
1389 self
._pages
._colorBorder
= border
1392 def SetGradientColorFrom(self
, fr
):
1393 """ Sets the starting colour for the gradient. """
1395 self
._pages
._colorFrom
= fr
1398 def SetGradientColorTo(self
, to
):
1399 """ Sets the ending colour for the gradient. """
1401 self
._pages
._colorTo
= to
1404 def SetGradientColorBorder(self
, border
):
1405 """ Sets the tab border colour. """
1407 self
._pages
._colorBorder
= border
1410 def GetGradientColorFrom(self
):
1411 """ Gets first gradient colour. """
1413 return self
._pages
._colorFrom
1416 def GetGradientColorTo(self
):
1417 """ Gets second gradient colour. """
1419 return self
._pages
._colorTo
1422 def GetGradientColorBorder(self
):
1423 """ Gets the tab border colour. """
1425 return self
._pages
._colorBorder
1428 def GetActiveTabTextColour(self
):
1429 """ Get the active tab text colour. """
1431 return self
._pages
._activeTextColor
1434 def SetPageImageIndex(self
, page
, imgindex
):
1436 Sets the image index for the given page. Image is an index into the
1437 image list which was set with SetImageList.
1440 self
._pages
.SetPageImageIndex(page
, imgindex
)
1443 def GetPageImageIndex(self
, page
):
1445 Returns the image index for the given page. Image is an index into the
1446 image list which was set with SetImageList.
1449 return self
._pages
.GetPageImageIndex(page
)
1452 def GetEnabled(self
, page
):
1453 """ Returns whether a tab is enabled or not. """
1455 return self
._pages
.GetEnabled(page
)
1458 def Enable(self
, page
, enabled
=True):
1459 """ Enables or disables a tab. """
1461 if page
>= len(self
._windows
):
1464 self
._windows
[page
].Enable(enabled
)
1465 self
._pages
.Enable(page
, enabled
)
1468 def GetNonActiveTabTextColour(self
):
1469 """ Returns the non active tabs text colour. """
1471 return self
._pages
._nonActiveTextColor
1474 def SetNonActiveTabTextColour(self
, color
):
1475 """ Sets the non active tabs text colour. """
1477 self
._pages
._nonActiveTextColor
= color
1480 def SetTabAreaColour(self
, color
):
1481 """ Sets the area behind the tabs colour. """
1483 self
._pages
._tabAreaColor
= color
1486 def GetTabAreaColour(self
):
1487 """ Returns the area behind the tabs colour. """
1489 return self
._pages
._tabAreaColor
1492 def SetActiveTabColour(self
, color
):
1493 """ Sets the active tab colour. """
1495 self
._pages
._activeTabColor
= color
1498 def GetActiveTabColour(self
):
1499 """ Returns the active tab colour. """
1501 return self
._pages
._activeTabColor
1504 # ---------------------------------------------------------------------------- #
1505 # Class PageContainerBase
1506 # Acts as a container for the pages you add to FlatNotebook
1507 # ---------------------------------------------------------------------------- #
1509 class PageContainerBase(wx
.Panel
):
1511 def __init__(self
, parent
, id=wx
.ID_ANY
, pos
=wx
.DefaultPosition
,
1512 size
=wx
.DefaultSize
, style
=0):
1513 """ Default class constructor. """
1515 self
._ImageList
= None
1516 self
._iActivePage
= -1
1517 self
._pDropTarget
= None
1518 self
._nLeftClickZone
= FNB_NOWHERE
1519 self
._tabXBgBmp
= wx
.EmptyBitmap(16, 16)
1520 self
._xBgBmp
= wx
.EmptyBitmap(16, 14)
1521 self
._leftBgBmp
= wx
.EmptyBitmap(16, 14)
1522 self
._rightBgBmp
= wx
.EmptyBitmap(16, 14)
1524 self
._pRightClickMenu
= None
1525 self
._nXButtonStatus
= FNB_BTN_NONE
1526 self
._pParent
= parent
1527 self
._nRightButtonStatus
= FNB_BTN_NONE
1528 self
._nLeftButtonStatus
= FNB_BTN_NONE
1529 self
._nTabXButtonStatus
= FNB_BTN_NONE
1531 self
._pagesInfoVec
= []
1533 self
._colorTo
= wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_ACTIVECAPTION
)
1534 self
._colorFrom
= wx
.WHITE
1535 self
._activeTabColor
= wx
.WHITE
1536 self
._activeTextColor
= wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_BTNTEXT
)
1537 self
._nonActiveTextColor
= wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_BTNSHADOW
)
1538 self
._tabAreaColor
= wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_BTNFACE
)
1541 self
._isdragging
= False
1543 wx
.Panel
.__init
__(self
, parent
, id, pos
, size
, style|wx
.TAB_TRAVERSAL
)
1545 self
._pDropTarget
= FNBDropTarget(self
)
1546 self
.SetDropTarget(self
._pDropTarget
)
1548 self
.Bind(wx
.EVT_PAINT
, self
.OnPaint
)
1549 self
.Bind(wx
.EVT_SIZE
, self
.OnSize
)
1550 self
.Bind(wx
.EVT_LEFT_DOWN
, self
.OnLeftDown
)
1551 self
.Bind(wx
.EVT_LEFT_UP
, self
.OnLeftUp
)
1552 self
.Bind(wx
.EVT_RIGHT_DOWN
, self
.OnRightDown
)
1553 self
.Bind(wx
.EVT_MIDDLE_DOWN
, self
.OnMiddleDown
)
1554 self
.Bind(wx
.EVT_MOTION
, self
.OnMouseMove
)
1555 self
.Bind(wx
.EVT_ERASE_BACKGROUND
, self
.OnEraseBackground
)
1556 self
.Bind(wx
.EVT_LEAVE_WINDOW
, self
.OnMouseLeave
)
1557 self
.Bind(wx
.EVT_ENTER_WINDOW
, self
.OnMouseEnterWindow
)
1558 self
.Bind(wx
.EVT_LEFT_DCLICK
, self
.OnLeftDClick
)
1561 def GetButtonAreaWidth(self
):
1562 """ Returns the width of the navigation button area. """
1564 style
= self
.GetParent().GetWindowStyleFlag()
1565 btnareawidth
= 2*self
._pParent
._nPadding
1567 if style
& FNB_NO_X_BUTTON
== 0:
1568 btnareawidth
+= BUTTON_SPACE
1570 if style
& FNB_NO_NAV_BUTTONS
== 0:
1571 btnareawidth
+= 2*BUTTON_SPACE
1576 def OnEraseBackground(self
, event
):
1577 """ Handles the wx.EVT_ERASE_BACKGROUND event for PageContainerBase (does nothing)."""
1582 def OnPaint(self
, event
):
1583 """ Handles the wx.EVT_PAINT event for PageContainerBase."""
1585 dc
= wx
.BufferedPaintDC(self
)
1587 if "__WXMAC__" in wx
.PlatformInfo
:
1588 # Works well on MSW & GTK, however this lines should be skipped on MAC
1589 if len(self
._pagesInfoVec
) == 0 or self
._nFrom
>= len(self
._pagesInfoVec
):
1594 # Get the text hight
1595 style
= self
.GetParent().GetWindowStyleFlag()
1597 # For GTK it seems that we must do this steps in order
1598 # for the tabs will get the proper height on initialization
1599 # on MSW, preforming these steps yields wierd results
1600 normalFont
= wx
.SystemSettings
.GetFont(wx
.SYS_DEFAULT_GUI_FONT
)
1601 boldFont
= wx
.SystemSettings
.GetFont(wx
.SYS_DEFAULT_GUI_FONT
)
1602 boldFont
.SetWeight(wx
.FONTWEIGHT_BOLD
)
1603 if "__WXGTK__" in wx
.PlatformInfo
:
1604 dc
.SetFont(boldFont
)
1606 width
, height
= dc
.GetTextExtent("Tp")
1608 tabHeight
= height
+ FNB_HEIGHT_SPACER
# We use 8 pixels as padding
1610 # Calculate the number of rows required for drawing the tabs
1611 rect
= self
.GetClientRect()
1612 clientWidth
= rect
.width
1614 # Set the maximum client size
1615 self
.SetSizeHints(self
.GetButtonsAreaLength(), tabHeight
)
1616 borderPen
= wx
.Pen(wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_BTNSHADOW
))
1618 if style
& FNB_VC71
:
1619 backBrush
= wx
.Brush(wx
.Colour(247, 243, 233))
1621 backBrush
= wx
.Brush(self
._tabAreaColor
)
1623 noselBrush
= wx
.Brush(wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_BTNFACE
))
1624 selBrush
= wx
.Brush(self
._activeTabColor
)
1626 size
= self
.GetSize()
1629 dc
.SetTextBackground((style
& FNB_VC71
and [wx
.Colour(247, 243, 233)] or [self
.GetBackgroundColour()])[0])
1630 dc
.SetTextForeground(self
._activeTextColor
)
1631 dc
.SetBrush(backBrush
)
1633 # If border style is set, set the pen to be border pen
1634 if style
& FNB_TABS_BORDER_SIMPLE
:
1635 dc
.SetPen(borderPen
)
1637 pc
= (self
.HasFlag(FNB_VC71
) and [wx
.Colour(247, 243, 233)] or [self
.GetBackgroundColour()])[0]
1638 dc
.SetPen(wx
.Pen(pc
))
1640 dc
.DrawRectangle(0, 0, size
.x
, size
.y
)
1642 # Take 3 bitmaps for the background for the buttons
1644 mem_dc
= wx
.MemoryDC()
1646 #---------------------------------------
1648 #---------------------------------------
1649 rect
= wx
.Rect(self
.GetXPos(), 6, 16, 14)
1650 mem_dc
.SelectObject(self
._xBgBmp
)
1651 mem_dc
.Blit(0, 0, rect
.width
, rect
.height
, dc
, rect
.x
, rect
.y
)
1652 mem_dc
.SelectObject(wx
.NullBitmap
)
1654 #---------------------------------------
1656 #---------------------------------------
1657 rect
= wx
.Rect(self
.GetRightButtonPos(), 6, 16, 14)
1658 mem_dc
.SelectObject(self
._rightBgBmp
)
1659 mem_dc
.Blit(0, 0, rect
.width
, rect
.height
, dc
, rect
.x
, rect
.y
)
1660 mem_dc
.SelectObject(wx
.NullBitmap
)
1662 #---------------------------------------
1664 #---------------------------------------
1665 rect
= wx
.Rect(self
.GetLeftButtonPos(), 6, 16, 14)
1666 mem_dc
.SelectObject(self
._leftBgBmp
)
1667 mem_dc
.Blit(0, 0, rect
.width
, rect
.height
, dc
, rect
.x
, rect
.y
)
1668 mem_dc
.SelectObject(wx
.NullBitmap
)
1670 # We always draw the bottom/upper line of the tabs
1671 # regradless the style
1672 dc
.SetPen(borderPen
)
1673 self
.DrawTabsLine(dc
)
1676 dc
.SetPen(borderPen
)
1678 if self
.HasFlag(FNB_VC71
):
1680 greyLineYVal
= self
.HasFlag((FNB_BOTTOM
and [0] or [size
.y
- 2])[0])
1681 whiteLineYVal
= self
.HasFlag((FNB_BOTTOM
and [3] or [size
.y
- 3])[0])
1683 pen
= wx
.Pen(wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_3DFACE
))
1686 # Draw thik grey line between the windows area and
1689 for num
in xrange(3):
1690 dc
.DrawLine(0, greyLineYVal
+ num
, size
.x
, greyLineYVal
+ num
)
1692 wbPen
= wx
.Pen((self
.HasFlag(FNB_BOTTOM
) and [wx
.BLACK
] or [wx
.WHITE
])[0])
1694 dc
.DrawLine(1, whiteLineYVal
, size
.x
- 1, whiteLineYVal
)
1697 dc
.SetPen(borderPen
)
1699 if "__WXMAC__" in wx
.PlatformInfo
:
1700 # On MAC, Add these lines so the tab background gets painted
1701 if len(self
._pagesInfoVec
) == 0 or self
._nFrom
>= len(self
._pagesInfoVec
):
1706 dc
.SetFont(boldFont
)
1707 posx
= self
._pParent
.GetPadding()
1709 # Update all the tabs from 0 to '_nFrom' to be non visible
1710 for ii
in xrange(self
._nFrom
):
1711 self
._pagesInfoVec
[ii
].SetPosition(wx
.Point(-1, -1))
1712 self
._pagesInfoVec
[ii
].GetRegion().Clear()
1714 if style
& FNB_VC71
:
1715 tabHeight
= ((style
& FNB_BOTTOM
) and [tabHeight
- 4] or [tabHeight
])[0]
1716 elif style
& FNB_FANCY_TABS
:
1717 tabHeight
= ((style
& FNB_BOTTOM
) and [tabHeight
- 2] or [tabHeight
])[0]
1719 #----------------------------------------------------------
1720 # Go over and draw the visible tabs
1721 #----------------------------------------------------------
1725 for ii
in xrange(self
._nFrom
, len(self
._pagesInfoVec
)):
1727 if style
!= FNB_VC71
:
1728 shapePoints
= int(tabHeight
*math
.tan(float(self
._pagesInfoVec
[ii
].GetTabAngle())/180.0*math
.pi
))
1732 dc
.SetPen(borderPen
)
1733 dc
.SetBrush((ii
==self
.GetSelection() and [selBrush
] or [noselBrush
])[0])
1735 # Calculate the text length using the bold font, so when selecting a tab
1736 # its width will not change
1737 dc
.SetFont(boldFont
)
1738 width
, pom
= dc
.GetTextExtent(self
.GetPageText(ii
))
1740 # Now set the font to the correct font
1741 dc
.SetFont((ii
==self
.GetSelection() and [boldFont
] or [normalFont
])[0])
1743 # Set a minimum size to a tab
1747 # Add the padding to the tab width
1749 # +-----------------------------------------------------------+
1750 # | PADDING | IMG | IMG_PADDING | TEXT | PADDING | x |PADDING |
1751 # +-----------------------------------------------------------+
1753 tabWidth
= 2*self
._pParent
._nPadding
+ width
1754 imageYCoord
= (self
.HasFlag(FNB_BOTTOM
) and [6] or [8])[0]
1756 # Style to add a small 'x' button on the top right
1758 if style
& FNB_X_ON_TAB
and ii
== self
.GetSelection():
1760 # The xpm image that contains the 'x' button is 9 pixles
1761 tabWidth
+= self
._pParent
._nPadding
+ 9
1763 if not (style
& FNB_VC71
) and not (style
& FNB_FANCY_TABS
):
1765 tabWidth
+= 2*shapePoints
1767 hasImage
= self
._ImageList
!= None and self
._pagesInfoVec
[ii
].GetImageIndex() != -1
1769 # For VC71 style, we only add the icon size (16 pixels)
1772 if style
& FNB_VC71
or style
& FNB_FANCY_TABS
:
1773 tabWidth
+= 16 + self
._pParent
._nPadding
1776 tabWidth
+= 16 + self
._pParent
._nPadding
+ shapePoints
/2
1778 # Check if we can draw more
1779 if posx
+ tabWidth
+ self
.GetButtonsAreaLength() >= clientWidth
:
1784 # By default we clean the tab region
1785 self
._pagesInfoVec
[ii
].GetRegion().Clear()
1787 # Clean the 'x' buttn on the tab
1788 # 'Clean' rectanlge is a rectangle with width or height
1789 # with values lower than or equal to 0
1790 self
._pagesInfoVec
[ii
].GetXRect().SetSize(wx
.Size(-1, -1))
1793 if style
& FNB_FANCY_TABS
:
1794 self
.DrawFancyTab(dc
, posx
, ii
, tabWidth
, tabHeight
)
1795 elif style
& FNB_VC71
:
1796 self
.DrawVC71Tab(dc
, posx
, ii
, tabWidth
, tabHeight
)
1798 self
.DrawStandardTab(dc
, posx
, ii
, tabWidth
, tabHeight
)
1800 # The width of the images are 16 pixels
1802 textOffset
= 2*self
._pParent
._nPadding
+ 16 + shapePoints
/2
1804 textOffset
= self
._pParent
._nPadding
+ shapePoints
/2
1806 # After several testing, it seems that we can draw
1807 # the text 2 pixles to the right - this is done only
1808 # for the standard tabs
1810 if not self
.HasFlag(FNB_FANCY_TABS
):
1813 if ii
!= self
.GetSelection():
1814 # Set the text background to be like the vertical lines
1815 dc
.SetTextForeground(self
._nonActiveTextColor
)
1819 imageXOffset
= textOffset
- 16 - self
._pParent
._nPadding
1820 self
._ImageList
.Draw(self
._pagesInfoVec
[ii
].GetImageIndex(), dc
,
1821 posx
+ imageXOffset
, imageYCoord
,
1822 wx
.IMAGELIST_DRAW_TRANSPARENT
, True)
1824 dc
.DrawText(self
.GetPageText(ii
), posx
+ textOffset
, imageYCoord
)
1826 # From version 1.2 - a style to add 'x' button
1829 if self
.HasFlag(FNB_X_ON_TAB
) and ii
== self
.GetSelection():
1831 textWidth
, textHeight
= dc
.GetTextExtent(self
.GetPageText(ii
))
1832 tabCloseButtonXCoord
= posx
+ textOffset
+ textWidth
+ 1
1834 # take a bitmap from the position of the 'x' button (the x on tab button)
1835 # this bitmap will be used later to delete old buttons
1836 tabCloseButtonYCoord
= imageYCoord
1837 x_rect
= wx
.Rect(tabCloseButtonXCoord
, tabCloseButtonYCoord
, 16, 16)
1838 mem_dc
= wx
.MemoryDC()
1839 mem_dc
.SelectObject(self
._tabXBgBmp
)
1840 mem_dc
.Blit(0, 0, x_rect
.width
, x_rect
.height
, dc
, x_rect
.x
, x_rect
.y
)
1841 mem_dc
.SelectObject(wx
.NullBitmap
)
1844 self
.DrawTabX(dc
, x_rect
, ii
)
1846 # Restore the text forground
1847 dc
.SetTextForeground(self
._activeTextColor
)
1849 # Update the tab position & size
1850 posy
= (style
& FNB_BOTTOM
and [0] or [VERTICAL_BORDER_PADDING
])[0]
1852 self
._pagesInfoVec
[ii
].SetPosition(wx
.Point(posx
, posy
))
1853 self
._pagesInfoVec
[ii
].SetSize(wx
.Size(tabWidth
, tabHeight
))
1856 # Update all tabs that can not fit into the screen as non-visible
1857 for ii
in xrange(count
, len(self
._pagesInfoVec
)):
1859 self
._pagesInfoVec
[ii
].SetPosition(wx
.Point(-1, -1))
1860 self
._pagesInfoVec
[ii
].GetRegion().Clear()
1862 # Draw the left/right/close buttons
1864 self
.DrawLeftArrow(dc
)
1865 self
.DrawRightArrow(dc
)
1869 def DrawFancyTab(self
, dc
, posx
, tabIdx
, tabWidth
, tabHeight
):
1871 Fancy tabs - like with VC71 but with the following differences:
1872 - The Selected tab is colored with gradient color
1875 borderPen
= wx
.Pen(wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_BTNSHADOW
))
1876 pen
= (tabIdx
==self
.GetSelection() and [wx
.Pen(self
._colorBorder
)] \
1877 or [wx
.Pen(wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_3DFACE
))])[0]
1879 fnb_bottom
= self
.HasFlag(FNB_BOTTOM
)
1881 if tabIdx
== self
.GetSelection():
1883 posy
= (fnb_bottom
and [2] or [VERTICAL_BORDER_PADDING
])[0]
1884 th
= (fnb_bottom
and [tabHeight
- 2] or [tabHeight
- 5])[0]
1886 rect
= wx
.Rect(posx
, posy
, tabWidth
, th
)
1887 self
.FillGradientColor(dc
, rect
)
1888 dc
.SetBrush(wx
.TRANSPARENT_BRUSH
)
1890 dc
.DrawRectangleRect(rect
)
1892 # erase the bottom/top line of the rectangle
1893 dc
.SetPen(wx
.Pen(self
._colorFrom
))
1895 dc
.DrawLine(rect
.x
, 2, rect
.x
+ rect
.width
, 2)
1897 dc
.DrawLine(rect
.x
, rect
.y
+ rect
.height
- 1, rect
.x
+ rect
.width
, rect
.y
+ rect
.height
- 1)
1901 # We dont draw a rectangle for non selected tabs, but only
1902 # vertical line on the left
1903 dc
.SetPen(borderPen
)
1904 dc
.DrawLine(posx
+ tabWidth
, VERTICAL_BORDER_PADDING
+ 3, posx
+ tabWidth
, tabHeight
- 4)
1907 def DrawVC71Tab(self
, dc
, posx
, tabIdx
, tabWidth
, tabHeight
):
1908 """ Draws tabs with VC71 style. """
1910 fnb_bottom
= self
.HasFlag(FNB_BOTTOM
)
1912 # Visual studio 7.1 style
1913 borderPen
= wx
.Pen(wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_BTNSHADOW
))
1914 dc
.SetPen((tabIdx
==self
.GetSelection() and [wx
.Pen(wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_3DFACE
))] or [borderPen
])[0])
1915 dc
.SetBrush((tabIdx
==self
.GetSelection() and [wx
.Brush(wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_3DFACE
))] or \
1916 [wx
.Brush(wx
.Colour(247, 243, 233))])[0])
1918 if tabIdx
== self
.GetSelection():
1920 posy
= (fnb_bottom
and [0] or [VERTICAL_BORDER_PADDING
])[0]
1921 dc
.DrawRectangle(posx
, posy
, tabWidth
, tabHeight
- 1)
1923 # Draw a black line on the left side of the
1925 dc
.SetPen(wx
.BLACK_PEN
)
1927 blackLineY1
= VERTICAL_BORDER_PADDING
1928 blackLineY2
= (fnb_bottom
and [self
.GetSize().y
- 5] or [self
.GetSize().y
- 3])[0]
1929 dc
.DrawLine(posx
+ tabWidth
, blackLineY1
, posx
+ tabWidth
, blackLineY2
)
1931 # To give the tab more 3D look we do the following
1932 # Incase the tab is on top,
1933 # Draw a thick white line on top of the rectangle
1934 # Otherwise, draw a thin (1 pixel) black line at the bottom
1936 pen
= wx
.Pen((fnb_bottom
and [wx
.BLACK
] or [wx
.WHITE
])[0])
1938 whiteLinePosY
= (fnb_bottom
and [blackLineY2
] or [VERTICAL_BORDER_PADDING
])[0]
1939 dc
.DrawLine(posx
, whiteLinePosY
, posx
+ tabWidth
+ 1, whiteLinePosY
)
1941 # Draw a white vertical line to the left of the tab
1942 dc
.SetPen(wx
.WHITE_PEN
)
1946 dc
.DrawLine(posx
, blackLineY1
, posx
, blackLineY2
)
1950 # We dont draw a rectangle for non selected tabs, but only
1951 # vertical line on the left
1953 blackLineY1
= (fnb_bottom
and [VERTICAL_BORDER_PADDING
+ 2] or [VERTICAL_BORDER_PADDING
+ 1])[0]
1954 blackLineY2
= self
.GetSize().y
- 5
1955 dc
.DrawLine(posx
+ tabWidth
, blackLineY1
, posx
+ tabWidth
, blackLineY2
)
1958 def DrawStandardTab(self
, dc
, posx
, tabIdx
, tabWidth
, tabHeight
):
1959 """ Draws tabs with standard style. """
1961 fnb_bottom
= self
.HasFlag(FNB_BOTTOM
)
1964 borderPen
= wx
.Pen(wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_BTNSHADOW
))
1966 tabPoints
= [wx
.Point() for ii
in xrange(7)]
1967 tabPoints
[0].x
= posx
1968 tabPoints
[0].y
= (fnb_bottom
and [2] or [tabHeight
- 2])[0]
1970 tabPoints
[1].x
= int(posx
+(tabHeight
-2)*math
.tan(float(self
._pagesInfoVec
[tabIdx
].GetTabAngle())/180.0*math
.pi
))
1971 tabPoints
[1].y
= (fnb_bottom
and [tabHeight
- (VERTICAL_BORDER_PADDING
+2)] or [(VERTICAL_BORDER_PADDING
+2)])[0]
1973 tabPoints
[2].x
= tabPoints
[1].x
+2
1974 tabPoints
[2].y
= (fnb_bottom
and [tabHeight
- VERTICAL_BORDER_PADDING
] or [VERTICAL_BORDER_PADDING
])[0]
1976 tabPoints
[3].x
= int(posx
+tabWidth
-(tabHeight
-2)*math
.tan(float(self
._pagesInfoVec
[tabIdx
].GetTabAngle())/180.0*math
.pi
))-2
1977 tabPoints
[3].y
= (fnb_bottom
and [tabHeight
- VERTICAL_BORDER_PADDING
] or [VERTICAL_BORDER_PADDING
])[0]
1979 tabPoints
[4].x
= tabPoints
[3].x
+2
1980 tabPoints
[4].y
= (fnb_bottom
and [tabHeight
- (VERTICAL_BORDER_PADDING
+2)] or [(VERTICAL_BORDER_PADDING
+2)])[0]
1982 tabPoints
[5].x
= int(tabPoints
[4].x
+(tabHeight
-2)*math
.tan(float(self
._pagesInfoVec
[tabIdx
].GetTabAngle())/180.0*math
.pi
))
1983 tabPoints
[5].y
= (fnb_bottom
and [2] or [tabHeight
- 2])[0]
1985 tabPoints
[6].x
= tabPoints
[0].x
1986 tabPoints
[6].y
= tabPoints
[0].y
1988 if tabIdx
== self
.GetSelection():
1990 # Draw the tab as rounded rectangle
1991 dc
.DrawPolygon(tabPoints
)
1995 if tabIdx
!= self
.GetSelection() - 1:
1997 # Draw a vertical line to the right of the text
1998 pt1x
= tabPoints
[5].x
1999 pt1y
= (fnb_bottom
and [4] or [tabHeight
- 6])[0]
2000 pt2x
= tabPoints
[5].x
2001 pt2y
= (fnb_bottom
and [tabHeight
- 4] or [4])[0]
2002 dc
.DrawLine(pt1x
, pt1y
, pt2x
, pt2y
)
2004 if tabIdx
== self
.GetSelection():
2006 savePen
= dc
.GetPen()
2007 whitePen
= wx
.Pen(wx
.WHITE
)
2008 whitePen
.SetWidth(1)
2011 secPt
= wx
.Point(tabPoints
[5].x
+ 1, tabPoints
[5].y
)
2012 dc
.DrawLine(tabPoints
[0].x
, tabPoints
[0].y
, secPt
.x
, secPt
.y
)
2018 def AddPage(self
, caption
, selected
=True, imgindex
=-1):
2020 Add a page to the FlatNotebook.
2023 - window: Specifies the new page.
2024 - caption: Specifies the text for the new page.
2025 - selected: Specifies whether the page should be selected.
2026 - imgindex: Specifies the optional image index for the new page.
2029 True if successful, False otherwise.
2034 self
._iActivePage
= len(self
._pagesInfoVec
)
2036 # Create page info and add it to the vector
2037 pageInfo
= PageInfo(caption
, imgindex
)
2038 self
._pagesInfoVec
.append(pageInfo
)
2042 def InsertPage(self
, indx
, text
, selected
=True, imgindex
=-1):
2044 Inserts a new page at the specified position.
2047 - indx: Specifies the position of the new page.
2048 - page: Specifies the new page.
2049 - text: Specifies the text for the new page.
2050 - select: Specifies whether the page should be selected.
2051 - imgindex: Specifies the optional image index for the new page.
2054 True if successful, False otherwise.
2059 self
._iActivePage
= len(self
._pagesInfoVec
)
2061 self
._pagesInfoVec
.insert(indx
, PageInfo(text
, imgindex
))
2067 def OnSize(self
, event
):
2068 """ Handles the wx.EVT_SIZE events for PageContainerBase. """
2070 self
.Refresh() # Call on paint
2074 def OnMiddleDown(self
, event
):
2075 """ Handles the wx.EVT_MIDDLE_DOWN events for PageContainerBase. """
2077 # Test if this style is enabled
2078 style
= self
.GetParent().GetWindowStyleFlag()
2080 if not style
& FNB_MOUSE_MIDDLE_CLOSES_TABS
:
2083 where
, tabIdx
= self
.HitTest(event
.GetPosition())
2085 if where
== FNB_TAB
:
2086 self
.DeletePage(tabIdx
)
2091 def OnRightDown(self
, event
):
2092 """ Handles the wx.EVT_RIGHT_DOWN events for PageContainerBase. """
2094 if self
._pRightClickMenu
:
2096 where
, tabIdx
= self
.HitTest(event
.GetPosition())
2098 if where
in [FNB_TAB
, FNB_TAB_X
]:
2100 if self
._pagesInfoVec
[tabIdx
].GetEnabled():
2101 # Set the current tab to be active
2102 self
.SetSelection(tabIdx
)
2104 # If the owner has defined a context menu for the tabs,
2105 # popup the right click menu
2106 if self
._pRightClickMenu
:
2107 self
.PopupMenu(self
._pRightClickMenu
)
2109 # send a message to popup a custom menu
2110 event
= FlatNotebookEvent(wxEVT_FLATNOTEBOOK_PAGE_CONTEXT_MENU
, self
.GetParent().GetId())
2111 event
.SetSelection(tabIdx
)
2112 event
.SetOldSelection(self
._iActivePage
)
2113 event
.SetEventObject(self
.GetParent())
2114 self
.GetParent().GetEventHandler().ProcessEvent(event
)
2119 def OnLeftDown(self
, event
):
2120 """ Handles the wx.EVT_LEFT_DOWN events for PageContainerBase. """
2122 # Reset buttons status
2123 self
._nXButtonStatus
= FNB_BTN_NONE
2124 self
._nLeftButtonStatus
= FNB_BTN_NONE
2125 self
._nRightButtonStatus
= FNB_BTN_NONE
2126 self
._nTabXButtonStatus
= FNB_BTN_NONE
2128 self
._nLeftClickZone
, tabIdx
= self
.HitTest(event
.GetPosition())
2130 if self
._nLeftClickZone
== FNB_LEFT_ARROW
:
2131 self
._nLeftButtonStatus
= FNB_BTN_PRESSED
2133 elif self
._nLeftClickZone
== FNB_RIGHT_ARROW
:
2134 self
._nRightButtonStatus
= FNB_BTN_PRESSED
2136 elif self
._nLeftClickZone
== FNB_X
:
2137 self
._nXButtonStatus
= FNB_BTN_PRESSED
2139 elif self
._nLeftClickZone
== FNB_TAB_X
:
2140 self
._nTabXButtonStatus
= FNB_BTN_PRESSED
2143 elif self
._nLeftClickZone
== FNB_TAB
:
2145 if self
._iActivePage
!= tabIdx
:
2147 # In case the tab is disabled, we dont allow to choose it
2148 if self
._pagesInfoVec
[tabIdx
].GetEnabled():
2150 oldSelection
= self
._iActivePage
2152 event
= FlatNotebookEvent(wxEVT_FLATNOTEBOOK_PAGE_CHANGING
, self
.GetParent().GetId())
2153 event
.SetSelection(tabIdx
)
2154 event
.SetOldSelection(oldSelection
)
2155 event
.SetEventObject(self
.GetParent())
2156 if not self
.GetParent().GetEventHandler().ProcessEvent(event
) or event
.IsAllowed():
2158 self
.SetSelection(tabIdx
)
2160 # Fire a wxEVT_TABBEDCTRL_PAGE_CHANGED event
2161 event
.SetEventType(wxEVT_FLATNOTEBOOK_PAGE_CHANGED
)
2162 event
.SetOldSelection(oldSelection
)
2163 self
.GetParent().GetEventHandler().ProcessEvent(event
)
2166 def OnLeftUp(self
, event
):
2167 """ Handles the wx.EVT_LEFT_UP events for PageContainerBase. """
2169 # forget the zone that was initially clicked
2170 self
._nLeftClickZone
= FNB_NOWHERE
2172 where
, tabIdx
= self
.HitTest(event
.GetPosition())
2174 if where
== FNB_LEFT_ARROW
:
2176 if self
._nFrom
== 0:
2179 # Make sure that the button was pressed before
2180 if self
._nLeftButtonStatus
!= FNB_BTN_PRESSED
:
2183 self
._nLeftButtonStatus
= FNB_BTN_HOVER
2185 # We scroll left with bulks of 5
2186 scrollLeft
= self
.GetNumTabsCanScrollLeft()
2188 self
._nFrom
-= scrollLeft
2194 elif where
== FNB_RIGHT_ARROW
:
2196 if self
._nFrom
>= len(self
._pagesInfoVec
) - 1:
2199 # Make sure that the button was pressed before
2200 if self
._nRightButtonStatus
!= FNB_BTN_PRESSED
:
2203 self
._nRightButtonStatus
= FNB_BTN_HOVER
2205 # Check if the right most tab is visible, if it is
2206 # don't rotate right anymore
2207 if self
._pagesInfoVec
[-1].GetPosition() != wx
.Point(-1, -1):
2210 lastVisibleTab
= self
.GetLastVisibleTab()
2211 if lastVisibleTab
< 0:
2212 # Probably the screen is too small for displaying even a single
2213 # tab, in this case we do nothing
2216 self
._nFrom
+= self
.GetNumOfVisibleTabs()
2219 elif where
== FNB_X
:
2221 # Make sure that the button was pressed before
2222 if self
._nXButtonStatus
!= FNB_BTN_PRESSED
:
2225 self
._nXButtonStatus
= FNB_BTN_HOVER
2227 self
.DeletePage(self
._iActivePage
)
2229 elif where
== FNB_TAB_X
:
2231 # Make sure that the button was pressed before
2232 if self
._nTabXButtonStatus
!= FNB_BTN_PRESSED
:
2235 self
._nTabXButtonStatus
= FNB_BTN_HOVER
2237 self
.DeletePage(self
._iActivePage
)
2240 def HitTest(self
, pt
):
2242 HitTest method for PageContainerBase.
2243 Returns the flag (if any) and the hit page (if any).
2246 fullrect
= self
.GetClientRect()
2247 btnLeftPos
= self
.GetLeftButtonPos()
2248 btnRightPos
= self
.GetRightButtonPos()
2249 btnXPos
= self
.GetXPos()
2250 style
= self
.GetParent().GetWindowStyleFlag()
2254 if not self
._pagesInfoVec
:
2255 return FNB_NOWHERE
, -1
2257 rect
= wx
.Rect(btnXPos
, 6, 16, 16)
2258 if rect
.Contains(pt
):
2259 return (style
& FNB_NO_X_BUTTON
and [FNB_NOWHERE
] or [FNB_X
])[0], -1
2261 rect
= wx
.Rect(btnRightPos
, 6, 16, 16)
2262 if rect
.Contains(pt
):
2263 return (style
& FNB_NO_NAV_BUTTONS
and [FNB_NOWHERE
] or [FNB_RIGHT_ARROW
])[0], -1
2265 rect
= wx
.Rect(btnLeftPos
, 6, 16, 16)
2266 if rect
.Contains(pt
):
2267 return (style
& FNB_NO_NAV_BUTTONS
and [FNB_NOWHERE
] or [FNB_LEFT_ARROW
])[0], -1
2269 # Test whether a left click was made on a tab
2270 for cur
in xrange(self
._nFrom
, len(self
._pagesInfoVec
)):
2272 pgInfo
= self
._pagesInfoVec
[cur
]
2274 if pgInfo
.GetPosition() == wx
.Point(-1, -1):
2277 if style
& FNB_X_ON_TAB
and cur
== self
.GetSelection():
2278 # 'x' button exists on a tab
2279 if self
._pagesInfoVec
[cur
].GetXRect().Contains(pt
):
2280 return FNB_TAB_X
, cur
2282 tabRect
= wx
.Rect(pgInfo
.GetPosition().x
, pgInfo
.GetPosition().y
, pgInfo
.GetSize().x
, pgInfo
.GetSize().y
)
2283 if tabRect
.Contains(pt
):
2287 if self
._isdragging
:
2288 # We are doing DND, so check also the region outside the tabs
2290 # try before the first tab
2291 pgInfo
= self
._pagesInfoVec
[0]
2292 tabRect
= wx
.Rect(0, pgInfo
.GetPosition().y
, pgInfo
.GetPosition().x
, self
.GetParent().GetSize().y
)
2293 if tabRect
.Contains(pt
):
2296 # try after the last tab
2297 pgInfo
= self
._pagesInfoVec
[-1]
2298 startpos
= pgInfo
.GetPosition().x
+pgInfo
.GetSize().x
2299 tabRect
= wx
.Rect(startpos
, pgInfo
.GetPosition().y
, fullrect
.width
-startpos
, self
.GetParent().GetSize().y
)
2301 if tabRect
.Contains(pt
):
2302 return FNB_TAB
, len(self
._pagesInfoVec
)-1
2305 return FNB_NOWHERE
, -1
2308 def SetSelection(self
, page
):
2309 """ Sets the selected page. """
2311 book
= self
.GetParent()
2312 book
.SetSelection(page
)
2313 self
.DoSetSelection(page
)
2316 def DoSetSelection(self
, page
):
2317 """ Does the actual selection of a page. """
2319 # Make sure that the selection is visible
2320 style
= self
.GetParent().GetWindowStyleFlag()
2321 if style
& FNB_NO_NAV_BUTTONS
:
2322 # Incase that we dont have navigation buttons,
2323 # there is no point of checking if the tab is visible
2324 # Just do the refresh
2328 if page
< len(self
._pagesInfoVec
):
2330 da_page
= self
._pParent
.GetPage(page
)
2332 # THIS IS GIVING TROUBLES!!
2336 if not self
.IsTabVisible(page
):
2338 if page
== len(self
._pagesInfoVec
) - 1:
2339 # Incase the added tab is last,
2340 # the function IsTabVisible() will always return False
2341 # and thus will cause an evil behaviour that the new
2342 # tab will hide all other tabs, we need to check if the
2343 # new selected tab can fit to the current screen
2344 if not self
.CanFitToScreen(page
):
2349 if not self
.CanFitToScreen(page
):
2350 # Redraw the tabs starting from page
2356 def DeletePage(self
, page
):
2357 """ Delete the specified page from FlatNotebook. """
2359 book
= self
.GetParent()
2360 book
.DeletePage(page
)
2364 def IsTabVisible(self
, page
):
2365 """ Returns whether a tab is visible or not. """
2367 iLastVisiblePage
= self
.GetLastVisibleTab()
2368 return page
<= iLastVisiblePage
and page
>= self
._nFrom
2371 def DoDeletePage(self
, page
):
2372 """ Does the actual page deletion. """
2374 # Remove the page from the vector
2375 book
= self
.GetParent()
2376 self
._pagesInfoVec
.pop(page
)
2378 # Thanks to Yiaanis AKA Mandrav
2379 if self
._iActivePage
>= page
:
2380 self
._iActivePage
= self
._iActivePage
- 1
2382 # The delete page was the last first on the array,
2383 # but the book still has more pages, so we set the
2384 # active page to be the first one (0)
2385 if self
._iActivePage
< 0 and self
._pagesInfoVec
:
2386 self
._iActivePage
= 0
2389 if self
._iActivePage
>= 0:
2391 book
._bForceSelection
= True
2392 book
.SetSelection(self
._iActivePage
)
2393 book
._bForceSelection
= False
2395 if not self
._pagesInfoVec
:
2396 # Erase the page container drawings
2397 dc
= wx
.ClientDC(self
)
2401 def DeleteAllPages(self
):
2402 """ Deletes all the pages. """
2404 self
._iActivePage
= -1
2406 self
._pagesInfoVec
= []
2408 # Erase the page container drawings
2409 dc
= wx
.ClientDC(self
)
2413 def DrawTabX(self
, dc
, rect
, tabIdx
):
2414 """ Draws the 'X' in the selected tab (VC8 style excluded). """
2416 if not self
.HasFlag(FNB_X_ON_TAB
) or not self
.CanDrawXOnTab():
2419 # We draw the 'x' on the active tab only
2420 if tabIdx
!= self
.GetSelection() or tabIdx
< 0 or not self
.CanFitToScreen(tabIdx
):
2423 # Set the bitmap according to the button status
2424 if self
._nTabXButtonStatus
== FNB_BTN_HOVER
:
2425 xBmp
= wx
.BitmapFromXPMData(x_button_hilite_xpm
)
2426 elif self
._nTabXButtonStatus
== FNB_BTN_PRESSED
:
2427 xBmp
= wx
.BitmapFromXPMData(x_button_pressed_xpm
)
2429 xBmp
= wx
.BitmapFromXPMData(x_button_xpm
)
2432 xBmp
.SetMask(wx
.Mask(xBmp
, MASK_COLOR
))
2435 dc
.DrawBitmap(self
._tabXBgBmp
, rect
.x
, rect
.y
)
2437 # Draw the new bitmap
2438 dc
.DrawBitmap(xBmp
, rect
.x
, rect
.y
, True)
2441 self
._pagesInfoVec
[tabIdx
].SetXRect(rect
)
2444 def DrawLeftArrow(self
, dc
):
2445 """ Draw the left navigation arrow. """
2447 style
= self
.GetParent().GetWindowStyleFlag()
2448 if style
& FNB_NO_NAV_BUTTONS
:
2451 # Make sure that there are pages in the container
2452 if not self
._pagesInfoVec
:
2455 # Set the bitmap according to the button status
2456 if self
._nLeftButtonStatus
== FNB_BTN_HOVER
:
2457 arrowBmp
= wx
.BitmapFromXPMData(left_arrow_hilite_xpm
)
2458 elif self
._nLeftButtonStatus
== FNB_BTN_PRESSED
:
2459 arrowBmp
= wx
.BitmapFromXPMData(left_arrow_pressed_xpm
)
2461 arrowBmp
= wx
.BitmapFromXPMData(left_arrow_xpm
)
2463 if self
._nFrom
== 0:
2464 # Handle disabled arrow
2465 arrowBmp
= wx
.BitmapFromXPMData(left_arrow_disabled_xpm
)
2467 arrowBmp
.SetMask(wx
.Mask(arrowBmp
, MASK_COLOR
))
2470 posx
= self
.GetLeftButtonPos()
2471 dc
.DrawBitmap(self
._leftBgBmp
, posx
, 6)
2473 # Draw the new bitmap
2474 dc
.DrawBitmap(arrowBmp
, posx
, 6, True)
2477 def DrawRightArrow(self
, dc
):
2478 """ Draw the right navigation arrow. """
2480 style
= self
.GetParent().GetWindowStyleFlag()
2481 if style
& FNB_NO_NAV_BUTTONS
:
2484 # Make sure that there are pages in the container
2485 if not self
._pagesInfoVec
:
2488 # Set the bitmap according to the button status
2489 if self
._nRightButtonStatus
== FNB_BTN_HOVER
:
2490 arrowBmp
= wx
.BitmapFromXPMData(right_arrow_hilite_xpm
)
2491 elif self
._nRightButtonStatus
== FNB_BTN_PRESSED
:
2492 arrowBmp
= wx
.BitmapFromXPMData(right_arrow_pressed_xpm
)
2494 arrowBmp
= wx
.BitmapFromXPMData(right_arrow_xpm
)
2496 # Check if the right most tab is visible, if it is
2497 # don't rotate right anymore
2498 if self
._pagesInfoVec
[-1].GetPosition() != wx
.Point(-1, -1):
2499 arrowBmp
= wx
.BitmapFromXPMData(right_arrow_disabled_xpm
)
2501 arrowBmp
.SetMask(wx
.Mask(arrowBmp
, MASK_COLOR
))
2504 posx
= self
.GetRightButtonPos()
2505 dc
.DrawBitmap(self
._rightBgBmp
, posx
, 6)
2507 # Draw the new bitmap
2508 dc
.DrawBitmap(arrowBmp
, posx
, 6, True)
2511 def DrawX(self
, dc
):
2512 """ Draw the 'X' navigation button in the navigation area. """
2514 # Check if this style is enabled
2515 style
= self
.GetParent().GetWindowStyleFlag()
2516 if style
& FNB_NO_X_BUTTON
:
2519 # Make sure that there are pages in the container
2520 if not self
._pagesInfoVec
:
2523 # Set the bitmap according to the button status
2524 if self
._nXButtonStatus
== FNB_BTN_HOVER
:
2525 xbmp
= wx
.BitmapFromXPMData(x_button_hilite_xpm
)
2526 elif self
._nXButtonStatus
== FNB_BTN_PRESSED
:
2527 xbmp
= wx
.BitmapFromXPMData(x_button_pressed_xpm
)
2529 xbmp
= wx
.BitmapFromXPMData(x_button_xpm
)
2531 xbmp
.SetMask(wx
.Mask(xbmp
, MASK_COLOR
))
2534 posx
= self
.GetXPos()
2535 dc
.DrawBitmap(self
._xBgBmp
, posx
, 6)
2537 # Draw the new bitmap
2538 dc
.DrawBitmap(xbmp
, posx
, 6, True)
2541 def OnMouseMove(self
, event
):
2542 """ Handles the wx.EVT_MOTION for PageContainerBase. """
2544 if self
._pagesInfoVec
and self
.IsShown():
2546 xButtonStatus
= self
._nXButtonStatus
2547 xTabButtonStatus
= self
._nTabXButtonStatus
2548 rightButtonStatus
= self
._nRightButtonStatus
2549 leftButtonStatus
= self
._nLeftButtonStatus
2550 style
= self
.GetParent().GetWindowStyleFlag()
2552 self
._nXButtonStatus
= FNB_BTN_NONE
2553 self
._nRightButtonStatus
= FNB_BTN_NONE
2554 self
._nLeftButtonStatus
= FNB_BTN_NONE
2555 self
._nTabXButtonStatus
= FNB_BTN_NONE
2557 where
, tabIdx
= self
.HitTest(event
.GetPosition())
2560 if event
.LeftIsDown():
2562 self
._nXButtonStatus
= (self
._nLeftClickZone
==FNB_X
and [FNB_BTN_PRESSED
] or [FNB_BTN_NONE
])[0]
2566 self
._nXButtonStatus
= FNB_BTN_HOVER
2568 elif where
== FNB_TAB_X
:
2569 if event
.LeftIsDown():
2571 self
._nTabXButtonStatus
= (self
._nLeftClickZone
==FNB_TAB_X
and [FNB_BTN_PRESSED
] or [FNB_BTN_NONE
])[0]
2575 self
._nTabXButtonStatus
= FNB_BTN_HOVER
2577 elif where
== FNB_RIGHT_ARROW
:
2578 if event
.LeftIsDown():
2580 self
._nRightButtonStatus
= (self
._nLeftClickZone
==FNB_RIGHT_ARROW
and [FNB_BTN_PRESSED
] or [FNB_BTN_NONE
])[0]
2584 self
._nRightButtonStatus
= FNB_BTN_HOVER
2586 elif where
== FNB_LEFT_ARROW
:
2587 if event
.LeftIsDown():
2589 self
._nLeftButtonStatus
= (self
._nLeftClickZone
==FNB_LEFT_ARROW
and [FNB_BTN_PRESSED
] or [FNB_BTN_NONE
])[0]
2593 self
._nLeftButtonStatus
= FNB_BTN_HOVER
2595 elif where
== FNB_TAB
:
2596 # Call virtual method for showing tooltip
2597 self
.ShowTabTooltip(tabIdx
)
2599 if not self
.GetEnabled(tabIdx
):
2600 # Set the cursor to be 'No-entry'
2601 wx
.SetCursor(wx
.StockCursor(wx
.CURSOR_NO_ENTRY
))
2603 # Support for drag and drop
2604 if event
.LeftIsDown() and not (style
& FNB_NODRAG
):
2606 self
._isdragging
= True
2607 draginfo
= FNBDragInfo(self
, tabIdx
)
2608 drginfo
= cPickle
.dumps(draginfo
)
2609 dataobject
= wx
.CustomDataObject(wx
.CustomDataFormat("FlatNotebook"))
2610 dataobject
.SetData(drginfo
)
2611 dragSource
= wx
.DropSource(self
)
2612 dragSource
.SetData(dataobject
)
2613 dragSource
.DoDragDrop(wx
.Drag_DefaultMove
)
2615 bRedrawX
= self
._nXButtonStatus
!= xButtonStatus
2616 bRedrawRight
= self
._nRightButtonStatus
!= rightButtonStatus
2617 bRedrawLeft
= self
._nLeftButtonStatus
!= leftButtonStatus
2618 bRedrawTabX
= self
._nTabXButtonStatus
!= xTabButtonStatus
2620 if (bRedrawX
or bRedrawRight
or bRedrawLeft
or bRedrawTabX
):
2622 dc
= wx
.ClientDC(self
)
2629 self
.DrawLeftArrow(dc
)
2633 self
.DrawRightArrow(dc
)
2637 self
.DrawTabX(dc
, self
._pagesInfoVec
[tabIdx
].GetXRect(), tabIdx
)
2642 def GetLastVisibleTab(self
):
2643 """ Returns the last visible tab. """
2647 for ii
in xrange(self
._nFrom
, len(self
._pagesInfoVec
)):
2649 if self
._pagesInfoVec
[ii
].GetPosition() == wx
.Point(-1, -1):
2655 def GetNumTabsCanScrollLeft(self
):
2656 """ Returns the number of tabs than can be scrolled left. """
2658 # Reserved area for the buttons (<>x)
2659 rect
= self
.GetClientRect()
2660 clientWidth
= rect
.width
2661 posx
= self
._pParent
._nPadding
2665 dc
= wx
.ClientDC(self
)
2667 # In case we have error prevent crash
2671 style
= self
.GetParent().GetWindowStyleFlag()
2673 for ii
in xrange(self
._nFrom
, -1, -1):
2675 boldFont
= wx
.SystemSettings
.GetFont(wx
.SYS_DEFAULT_GUI_FONT
)
2676 boldFont
.SetWeight(wx
.FONTWEIGHT_BOLD
)
2677 dc
.SetFont(boldFont
)
2679 width
, height
= dc
.GetTextExtent("Tp")
2681 tabHeight
= height
+ FNB_HEIGHT_SPACER
# We use 6 pixels as padding
2682 if style
& FNB_VC71
:
2683 tabHeight
= (style
& FNB_BOTTOM
and [tabHeight
- 4] or [tabHeight
])[0]
2684 elif style
& FNB_FANCY_TABS
:
2685 tabHeight
= (style
& FNB_BOTTOM
and [tabHeight
- 3] or [tabHeight
])[0]
2687 width
, pom
= dc
.GetTextExtent(self
.GetPageText(ii
))
2688 if style
!= FNB_VC71
:
2689 shapePoints
= int(tabHeight
*math
.tan(float(self
._pagesInfoVec
[ii
].GetTabAngle())/180.0*math
.pi
))
2693 tabWidth
= self
._pParent
._nPadding
*2 + width
2695 if not (style
& FNB_VC71
):
2697 tabWidth
+= 2*shapePoints
2699 hasImage
= self
._ImageList
!= None and self
._pagesInfoVec
[ii
].GetImageIndex() != -1
2701 # For VC71 style, we only add the icon size (16 pixels)
2704 if not self
.IsDefaultTabs():
2705 tabWidth
+= 16 + self
._pParent
._nPadding
2708 tabWidth
+= 16 + self
._pParent
._nPadding
+ shapePoints
/2
2710 if posx
+ tabWidth
+ self
.GetButtonsAreaLength() >= clientWidth
:
2713 numTabs
= numTabs
+ 1
2719 def IsDefaultTabs(self
):
2720 """ Returns whether a tab has a default style. """
2722 style
= self
.GetParent().GetWindowStyleFlag()
2723 res
= (style
& FNB_VC71
) or (style
& FNB_FANCY_TABS
)
2727 def AdvanceSelection(self
, bForward
=True):
2729 Cycles through the tabs.
2730 The call to this function generates the page changing events.
2733 nSel
= self
.GetSelection()
2738 nMax
= self
.GetPageCount() - 1
2740 self
.SetSelection((nSel
== nMax
and [0] or [nSel
+ 1])[0])
2742 self
.SetSelection((nSel
== 0 and [nMax
] or [nSel
- 1])[0])
2745 def OnMouseLeave(self
, event
):
2746 """ Handles the wx.EVT_LEAVE_WINDOW event for PageContainerBase. """
2748 self
._nLeftButtonStatus
= FNB_BTN_NONE
2749 self
._nXButtonStatus
= FNB_BTN_NONE
2750 self
._nRightButtonStatus
= FNB_BTN_NONE
2751 self
._nTabXButtonStatus
= FNB_BTN_NONE
2753 dc
= wx
.ClientDC(self
)
2755 self
.DrawLeftArrow(dc
)
2756 self
.DrawRightArrow(dc
)
2758 selection
= self
.GetSelection()
2761 self
.DrawTabX(dc
, self
._pagesInfoVec
[selection
].GetXRect(), selection
)
2766 def OnMouseEnterWindow(self
, event
):
2767 """ Handles the wx.EVT_ENTER_WINDOW event for PageContainerBase. """
2769 self
._nLeftButtonStatus
= FNB_BTN_NONE
2770 self
._nXButtonStatus
= FNB_BTN_NONE
2771 self
._nRightButtonStatus
= FNB_BTN_NONE
2772 self
._nLeftClickZone
= FNB_BTN_NONE
2777 def ShowTabTooltip(self
, tabIdx
):
2778 """ Shows a tab tooltip. """
2780 pWindow
= self
._pParent
.GetPage(tabIdx
)
2783 pToolTip
= pWindow
.GetToolTip()
2784 if pToolTip
and pToolTip
.GetWindow() == pWindow
:
2785 self
.SetToolTipString(pToolTip
.GetTip())
2788 def FillGradientColor(self
, dc
, rect
):
2789 """ Gradient fill from colour 1 to colour 2 with top to bottom. """
2791 if rect
.height
< 1 or rect
.width
< 1:
2796 # calculate gradient coefficients
2797 style
= self
.GetParent().GetWindowStyleFlag()
2798 col2
= ((style
& FNB_BOTTOM
) and [self
._colorTo
] or [self
._colorFrom
])[0]
2799 col1
= ((style
& FNB_BOTTOM
) and [self
._colorFrom
] or [self
._colorTo
])[0]
2801 rf
, gf
, bf
= 0, 0, 0
2802 rstep
= float(col2
.Red() - col1
.Red())/float(size
)
2803 gstep
= float(col2
.Green() - col1
.Green())/float(size
)
2804 bstep
= float(col2
.Blue() - col1
.Blue())/float(size
)
2806 for y
in xrange(rect
.y
, rect
.y
+ size
):
2807 currCol
= wx
.Colour(col1
.Red() + rf
, col1
.Green() + gf
, col1
.Blue() + bf
)
2808 dc
.SetBrush(wx
.Brush(currCol
))
2809 dc
.SetPen(wx
.Pen(currCol
))
2810 dc
.DrawLine(rect
.x
, y
, rect
.x
+ rect
.width
, y
)
2816 def SetPageImageIndex(self
, page
, imgindex
):
2817 """ Sets the image index associated to a page. """
2819 if page
< len(self
._pagesInfoVec
):
2821 self
._pagesInfoVec
[page
].SetImageIndex(imgindex
)
2825 def GetPageImageIndex(self
, page
):
2826 """ Returns the image index associated to a page. """
2828 if page
< len(self
._pagesInfoVec
):
2830 return self
._pagesInfoVec
[page
].GetImageIndex()
2835 def OnDropTarget(self
, x
, y
, nTabPage
, wnd_oldContainer
):
2836 """ Handles the drop action from a DND operation. """
2838 # Disable drag'n'drop for disabled tab
2839 if not wnd_oldContainer
._pagesInfoVec
[nTabPage
].GetEnabled():
2840 return wx
.DragCancel
2842 self
._isdragging
= True
2843 oldContainer
= wnd_oldContainer
2846 where
, nIndex
= self
.HitTest(wx
.Point(x
, y
))
2848 oldNotebook
= oldContainer
.GetParent()
2849 newNotebook
= self
.GetParent()
2851 if oldNotebook
== newNotebook
:
2855 if where
== FNB_TAB
:
2856 self
.MoveTabPage(nTabPage
, nIndex
)
2860 if wx
.Platform
in ["__WXMSW__", "__WXGTK__"]:
2863 window
= oldNotebook
.GetPage(nTabPage
)
2866 where
, nIndex
= newNotebook
._pages
.HitTest(wx
.Point(x
, y
))
2867 caption
= oldContainer
.GetPageText(nTabPage
)
2868 imageindex
= oldContainer
.GetPageImageIndex(nTabPage
)
2869 oldNotebook
.RemovePage(nTabPage
)
2870 window
.Reparent(newNotebook
)
2872 newNotebook
.InsertPage(nIndex
, window
, caption
, True, imageindex
)
2874 self
._isdragging
= False
2879 def MoveTabPage(self
, nMove
, nMoveTo
):
2880 """ Moves a tab inside the same FlatNotebook. """
2882 if nMove
== nMoveTo
:
2885 elif nMoveTo
< len(self
._pParent
._windows
):
2886 nMoveTo
= nMoveTo
+ 1
2888 self
._pParent
.Freeze()
2890 # Remove the window from the main sizer
2891 nCurSel
= self
._pParent
._pages
.GetSelection()
2892 self
._pParent
._mainSizer
.Detach(self
._pParent
._windows
[nCurSel
])
2893 self
._pParent
._windows
[nCurSel
].Hide()
2895 pWindow
= self
._pParent
._windows
[nMove
]
2896 self
._pParent
._windows
.pop(nMove
)
2897 self
._pParent
._windows
.insert(nMoveTo
-1, pWindow
)
2899 pgInfo
= self
._pagesInfoVec
[nMove
]
2901 self
._pagesInfoVec
.pop(nMove
)
2902 self
._pagesInfoVec
.insert(nMoveTo
- 1, pgInfo
)
2904 # Add the page according to the style
2905 pSizer
= self
._pParent
._mainSizer
2906 style
= self
.GetParent().GetWindowStyleFlag()
2908 if style
& FNB_BOTTOM
:
2910 pSizer
.Insert(0, pWindow
, 1, wx
.EXPAND
)
2914 # We leave a space of 1 pixel around the window
2915 pSizer
.Add(pWindow
, 1, wx
.EXPAND
)
2920 self
._iActivePage
= nMoveTo
- 1
2921 self
.DoSetSelection(self
._iActivePage
)
2923 self
._pParent
.Thaw()
2926 def CanFitToScreen(self
, page
):
2927 """ Returns whether all the tabs can fit in the available space. """
2929 # Incase the from is greater than page,
2930 # we need to reset the self._nFrom, so in order
2931 # to force the caller to do so, we return False
2932 if self
._nFrom
> page
:
2935 # Calculate the tab width including borders and image if any
2936 dc
= wx
.ClientDC(self
)
2938 style
= self
.GetParent().GetWindowStyleFlag()
2940 width
, height
= dc
.GetTextExtent("Tp")
2941 width
, pom
= dc
.GetTextExtent(self
.GetPageText(page
))
2943 tabHeight
= height
+ FNB_HEIGHT_SPACER
# We use 6 pixels as padding
2945 if style
& FNB_VC71
:
2946 tabHeight
= (style
& FNB_BOTTOM
and [tabHeight
- 4] or [tabHeight
])[0]
2947 elif style
& FNB_FANCY_TABS
:
2948 tabHeight
= (style
& FNB_BOTTOM
and [tabHeight
- 2] or [tabHeight
])[0]
2950 tabWidth
= self
._pParent
._nPadding
* 2 + width
2952 if not style
& FNB_VC71
:
2953 shapePoints
= int(tabHeight
*math
.tan(float(self
._pagesInfoVec
[page
].GetTabAngle())/180.0*math
.pi
))
2957 if not style
& FNB_VC71
:
2959 tabWidth
+= 2*shapePoints
2961 hasImage
= self
._ImageList
!= None
2964 hasImage
&= self
._pagesInfoVec
[page
].GetImageIndex() != -1
2966 # For VC71 style, we only add the icon size (16 pixels)
2967 if hasImage
and (style
& FNB_VC71
or style
& FNB_FANCY_TABS
):
2971 tabWidth
+= 16 + shapePoints
/2
2973 # Check if we can draw more
2974 posx
= self
._pParent
._nPadding
2976 if self
._nFrom
>= 0:
2977 for ii
in xrange(self
._nFrom
, len(self
._pagesInfoVec
)):
2978 if self
._pagesInfoVec
[ii
].GetPosition() == wx
.Point(-1, -1):
2980 posx
+= self
._pagesInfoVec
[ii
].GetSize().x
2982 rect
= self
.GetClientRect()
2983 clientWidth
= rect
.width
2985 if posx
+ tabWidth
+ self
.GetButtonsAreaLength() >= clientWidth
:
2991 def GetNumOfVisibleTabs(self
):
2992 """ Returns the number of visible tabs. """
2995 for ii
in xrange(self
._nFrom
, len(self
._pagesInfoVec
)):
2996 if self
._pagesInfoVec
[ii
].GetPosition() == wx
.Point(-1, -1):
3003 def GetEnabled(self
, page
):
3004 """ Returns whether a tab is enabled or not. """
3006 if page
>= len(self
._pagesInfoVec
):
3007 return True # Seems strange, but this is the default
3009 return self
._pagesInfoVec
[page
].GetEnabled()
3012 def Enable(self
, page
, enabled
=True):
3013 """ Enables or disables a tab. """
3015 if page
>= len(self
._pagesInfoVec
):
3018 self
._pagesInfoVec
[page
].Enable(enabled
)
3021 def GetLeftButtonPos(self
):
3022 """ Returns the left button position in the navigation area. """
3024 style
= self
.GetParent().GetWindowStyleFlag()
3025 rect
= self
.GetClientRect()
3026 clientWidth
= rect
.width
3028 if style
& FNB_NO_X_BUTTON
:
3029 return clientWidth
- 38
3031 return clientWidth
- 54
3034 def GetRightButtonPos(self
):
3035 """ Returns the right button position in the navigation area. """
3037 style
= self
.GetParent().GetWindowStyleFlag()
3038 rect
= self
.GetClientRect()
3039 clientWidth
= rect
.width
3041 if style
& FNB_NO_X_BUTTON
:
3042 return clientWidth
- 22
3044 return clientWidth
- 38
3048 """ Returns the 'X' button position in the navigation area. """
3050 style
= self
.GetParent().GetWindowStyleFlag()
3051 rect
= self
.GetClientRect()
3052 clientWidth
= rect
.width
3054 if style
& FNB_NO_X_BUTTON
:
3057 return clientWidth
- 22
3060 def GetButtonsAreaLength(self
):
3061 """ Returns the navigation area width. """
3063 style
= self
.GetParent().GetWindowStyleFlag()
3065 if style
& FNB_NO_NAV_BUTTONS
and style
& FNB_NO_X_BUTTON
:
3067 elif style
& FNB_NO_NAV_BUTTONS
and not style
& FNB_NO_X_BUTTON
:
3069 elif not style
& FNB_NO_NAV_BUTTONS
and style
& FNB_NO_X_BUTTON
:
3076 def GetSingleLineBorderColor(self
):
3078 if self
.HasFlag(FNB_FANCY_TABS
):
3079 return self
._colorFrom
3084 def DrawTabsLine(self
, dc
):
3085 """ Draws a line over the tabs. """
3087 clntRect
= self
.GetClientRect()
3088 clientRect3
= wx
.Rect(0, 0, clntRect
.width
, clntRect
.height
)
3090 if self
.HasFlag(FNB_BOTTOM
):
3092 clientRect
= wx
.Rect(0, 2, clntRect
.width
, clntRect
.height
- 2)
3093 clientRect2
= wx
.Rect(0, 1, clntRect
.width
, clntRect
.height
- 1)
3097 clientRect
= wx
.Rect(0, 0, clntRect
.width
, clntRect
.height
- 2)
3098 clientRect2
= wx
.Rect(0, 0, clntRect
.width
, clntRect
.height
- 1)
3100 dc
.SetBrush(wx
.TRANSPARENT_BRUSH
)
3101 dc
.SetPen(wx
.Pen(self
.GetSingleLineBorderColor()))
3102 dc
.DrawRectangleRect(clientRect2
)
3103 dc
.DrawRectangleRect(clientRect3
)
3105 dc
.SetPen(wx
.Pen(wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_BTNSHADOW
)))
3106 dc
.DrawRectangleRect(clientRect
)
3108 if not self
.HasFlag(FNB_TABS_BORDER_SIMPLE
):
3110 dc
.SetPen(wx
.Pen((self
.HasFlag(FNB_VC71
) and [wx
.Colour(247, 243, 233)] or [self
._tabAreaColor
])[0]))
3111 dc
.DrawLine(0, 0, 0, clientRect
.height
+1)
3113 if self
.HasFlag(FNB_BOTTOM
):
3115 dc
.DrawLine(0, clientRect
.height
+1, clientRect
.width
, clientRect
.height
+1)
3118 dc
.DrawLine(0, 0, clientRect
.width
, 0)
3120 dc
.DrawLine(clientRect
.width
- 1, 0, clientRect
.width
- 1, clientRect
.height
+1)
3123 def HasFlag(self
, flag
):
3124 """ Returns whether a flag is present in the FlatNotebook style. """
3126 style
= self
.GetParent().GetWindowStyleFlag()
3127 res
= (style
& flag
and [True] or [False])[0]
3131 def ClearFlag(self
, flag
):
3132 """ Deletes a flag from the FlatNotebook style. """
3134 style
= self
.GetParent().GetWindowStyleFlag()
3136 self
.SetWindowStyleFlag(style
)
3139 def TabHasImage(self
, tabIdx
):
3140 """ Returns whether a tab has an associated image index or not. """
3143 return self
._pagesInfoVec
[tabIdx
].GetImageIndex() != -1
3148 def OnLeftDClick(self
, event
):
3149 """ Handles the wx.EVT_LEFT_DCLICK event for PageContainerBase. """
3151 if self
.HasFlag(FNB_DCLICK_CLOSES_TABS
):
3153 where
, tabIdx
= self
.HitTest(event
.GetPosition())
3155 if where
== FNB_TAB
:
3156 self
.DeletePage(tabIdx
)
3163 def SetImageList(self
, imglist
):
3164 """ Sets the image list for the page control. """
3166 self
._ImageList
= imglist
3169 def GetImageList(self
):
3170 """ Returns the image list for the page control. """
3172 return self
._ImageList
3175 def GetSelection(self
):
3176 """ Returns the current selected page. """
3178 return self
._iActivePage
3181 def GetPageCount(self
):
3182 """ Returns the number of tabs in the FlatNotebook control. """
3184 return len(self
._pagesInfoVec
)
3187 def GetPageText(self
, page
):
3188 """ Returns the tab caption of the page. """
3190 return self
._pagesInfoVec
[page
].GetCaption()
3193 def SetPageText(self
, page
, text
):
3194 """ Sets the tab caption of the page. """
3196 self
._pagesInfoVec
[page
].SetCaption(text
)
3200 def CanDrawXOnTab(self
):
3201 """ Returns whether an 'X' can be drawn on a tab (all styles except VC8. """
3206 # ---------------------------------------------------------------------------- #
3207 # Class FlatNotebook
3208 # Simple super class based on PageContainerBase
3209 # ---------------------------------------------------------------------------- #
3211 class FlatNotebook(FlatNotebookBase
):
3213 def __init__(self
, parent
, id=wx
.ID_ANY
, pos
=wx
.DefaultPosition
, size
=wx
.DefaultSize
,
3214 style
=0, name
="FlatNotebook"):
3216 Default class constructor.
3218 It is better to use directly the StyledNotebook class (see below) and then
3219 assigning the style you wish instead of calling FlatNotebook.
3222 style |
= wx
.TAB_TRAVERSAL
3224 FlatNotebookBase
.__init
__(self
, parent
, id, pos
, size
, style
, name
)
3225 self
._pages
= self
.CreatePageContainer()
3228 def CreatePageContainer(self
):
3229 """ Creates the page container. """
3231 return FlatNotebookBase
.CreatePageContainer(self
)
3234 #--------------------------------------------------------------------
3235 # StyledNotebook - a notebook with look n feel of Visual Studio 2005
3236 #--------------------------------------------------------------------
3238 class StyledNotebook(FlatNotebookBase
):
3240 def __init__(self
, parent
, id=wx
.ID_ANY
, pos
=wx
.DefaultPosition
, size
=wx
.DefaultSize
,
3241 style
=0, name
="StyledNotebook"):
3242 """ Default class constructor.
3244 It is better to use directly the StyledNotebook class and then
3245 assigning the style you wish instead of calling FlatNotebook.
3248 style |
= wx
.TAB_TRAVERSAL
3250 FlatNotebookBase
.__init
__(self
, parent
, id, pos
, size
, style
, name
)
3252 # Custom initialization of the tab area
3254 # Initialise the default style colors
3255 self
.SetNonActiveTabTextColour(wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_BTNTEXT
))
3258 def CreatePageContainer(self
):
3259 """ Creates the page container. """
3261 return StyledTabsContainer(self
, wx
.ID_ANY
)
3264 # ---------------------------------------------------------------------------- #
3265 # Class StyledTabsContainer
3266 # Acts as a container for the pages you add to FlatNotebook
3267 # A more generic and more powerful implementation of PageContainerBase, can
3268 # handle also VC8 tabs style
3269 # ---------------------------------------------------------------------------- #
3271 class StyledTabsContainer(PageContainerBase
):
3273 def __init__(self
, parent
, id=wx
.ID_ANY
, pos
=wx
.DefaultPosition
, size
=wx
.DefaultSize
,
3275 """ Default class constructor. """
3279 self
._colorTo
= LightColour(wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_3DFACE
), 0)
3280 self
._colorFrom
= LightColour(wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_3DFACE
), 60)
3282 PageContainerBase
.__init
__(self
, parent
, id, pos
, size
, style
)
3284 self
.Bind(wx
.EVT_PAINT
, self
.OnPaint
)
3287 def NumberTabsCanFit(self
, dc
):
3288 """ Returns the number of tabs that can fit inside the available space. """
3290 rect
= self
.GetClientRect()
3291 clientWidth
= rect
.width
3296 # We take the maxmimum font size, this is
3297 # achieved by setting the font to be bold
3298 font
= wx
.SystemSettings
.GetFont(wx
.SYS_DEFAULT_GUI_FONT
)
3299 font
.SetWeight(wx
.FONTWEIGHT_BOLD
)
3302 width
, height
= dc
.GetTextExtent("Tp")
3304 tabHeight
= height
+ FNB_HEIGHT_SPACER
# We use 8 pixels
3305 # The drawing starts from posx
3306 posx
= self
._pParent
.GetPadding()
3308 for i
in xrange(self
._nFrom
, len(self
._pagesInfoVec
)):
3310 width
, pom
= dc
.GetTextExtent(self
.GetPageText(i
))
3312 # Set a minimum size to a tab
3316 tabWidth
= self
._pParent
.GetPadding() * 2 + width
3318 # Add the image width if it exist
3319 if self
.TabHasImage(i
):
3320 tabWidth
+= 16 + self
._pParent
.GetPadding()
3322 vc8glitch
= tabHeight
+ FNB_HEIGHT_SPACER
3323 if posx
+ tabWidth
+ vc8glitch
+ self
.GetButtonsAreaLength() >= clientWidth
:
3326 # Add a result to the returned vector
3327 tabRect
= wx
.Rect(posx
, VERTICAL_BORDER_PADDING
, tabWidth
, tabHeight
)
3328 vTabInfo
.append(tabRect
)
3331 posx
+= tabWidth
+ FNB_HEIGHT_SPACER
3336 def GetNumTabsCanScrollLeft(self
):
3337 """ Returns the number of tabs than can be scrolled left. """
3339 # Reserved area for the buttons (<>x)
3340 rect
= self
.GetClientRect()
3341 clientWidth
= rect
.width
3342 posx
= self
._pParent
.GetPadding()
3346 dc
= wx
.ClientDC(self
)
3348 # Incase we have error prevent crash
3352 style
= self
.GetParent().GetWindowStyleFlag()
3354 for i
in xrange(self
._nFrom
, -1, -1):
3356 boldFont
= wx
.SystemSettings
.GetFont(wx
.SYS_DEFAULT_GUI_FONT
)
3357 boldFont
.SetWeight(wx
.FONTWEIGHT_BOLD
)
3358 dc
.SetFont(boldFont
)
3360 width
, height
= dc
.GetTextExtent("Tp")
3362 tabHeight
= height
+ FNB_HEIGHT_SPACER
# We use 6 pixels as padding
3364 if style
& FNB_VC71
:
3365 tabHeight
= (self
.HasFlag(FNB_BOTTOM
) and [tabHeight
- 4] or [tabHeight
])[0]
3366 elif style
& FNB_FANCY_TABS
:
3367 tabHeight
= (self
.HasFlag(FNB_BOTTOM
) and [tabHeight
- 3] or [tabHeight
])[0]
3369 width
, pom
= dc
.GetTextExtent(self
.GetPageText(i
))
3371 if style
!= FNB_VC71
:
3372 shapePoints
= int(tabHeight
*math
.tan(float(self
._pagesInfoVec
[i
].GetTabAngle())/180.0*math
.pi
))
3376 tabWidth
= self
._pParent
.GetPadding() * 2 + width
3377 if not style
& FNB_VC71
:
3379 tabWidth
+= 2*shapePoints
3381 # For VC71 style, we only add the icon size (16 pixels)
3382 if self
.TabHasImage(i
):
3384 if not self
.IsDefaultTabs():
3385 tabWidth
+= 16 + self
._pParent
.GetPadding()
3388 tabWidth
+= 16 + self
._pParent
.GetPadding() + shapePoints
/2
3390 vc8glitch
= (style
& FNB_VC8
and [tabHeight
+ FNB_HEIGHT_SPACER
] or [0])[0]
3392 if posx
+ tabWidth
+ vc8glitch
+ self
.GetButtonsAreaLength() >= clientWidth
:
3395 numTabs
= numTabs
+ 1
3401 def CanDrawXOnTab(self
):
3402 """ Returns whether an 'X' button can be drawn on a tab (not VC8 style). """
3404 style
= self
.GetParent().GetWindowStyleFlag()
3405 isVC8
= (style
& FNB_VC8
and [True] or [False])[0]
3409 def IsDefaultTabs(self
):
3410 """ Returns whether a tab has a default style or not. """
3412 style
= self
.GetParent().GetWindowStyleFlag()
3413 res
= (style
& FNB_VC71
) or (style
& FNB_FANCY_TABS
) or (style
& FNB_VC8
)
3417 def HitTest(self
, pt
):
3418 """ HitTest specific method for VC8 style. """
3420 fullrect
= self
.GetClientRect()
3421 btnLeftPos
= self
.GetLeftButtonPos()
3422 btnRightPos
= self
.GetRightButtonPos()
3423 btnXPos
= self
.GetXPos()
3424 style
= self
.GetParent().GetWindowStyleFlag()
3427 if not self
._pagesInfoVec
:
3428 return FNB_NOWHERE
, -1
3430 rect
= wx
.Rect(btnXPos
, 8, 16, 16)
3432 if rect
.Contains(pt
):
3433 return (style
& FNB_NO_X_BUTTON
and [FNB_NOWHERE
] or [FNB_X
])[0], -1
3435 rect
= wx
.Rect(btnRightPos
, 8, 16, 16)
3437 if rect
.Contains(pt
):
3438 return (style
& FNB_NO_NAV_BUTTONS
and [FNB_NOWHERE
] or [FNB_RIGHT_ARROW
])[0], -1
3440 rect
= wx
.Rect(btnLeftPos
, 8, 16, 16)
3442 if rect
.Contains(pt
):
3443 return (style
& FNB_NO_NAV_BUTTONS
and [FNB_NOWHERE
] or [FNB_LEFT_ARROW
])[0], -1
3445 # Test whether a left click was made on a tab
3448 for cur
in xrange(self
._nFrom
, len(self
._pagesInfoVec
)):
3450 pgInfo
= self
._pagesInfoVec
[cur
]
3452 if pgInfo
.GetPosition() == wx
.Point(-1, -1):
3457 if self
._pagesInfoVec
[cur
].GetRegion().Contains(pt
.x
, pt
.y
):
3459 if bFoundMatch
or cur
== self
.GetSelection():
3468 if style
& FNB_X_ON_TAB
and cur
== self
.GetSelection():
3470 # 'x' button exists on a tab
3471 if self
._pagesInfoVec
[cur
].GetXRect().Contains(pt
):
3472 return FNB_TAB_X
, cur
3474 tabRect
= wx
.Rect(pgInfo
.GetPosition().x
, pgInfo
.GetPosition().y
, pgInfo
.GetSize().x
, pgInfo
.GetSize().y
)
3476 if tabRect
.Contains(pt
):
3480 return FNB_TAB
, tabIdx
3482 if self
._isdragging
:
3483 # We are doing DND, so check also the region outside the tabs
3484 # try before the first tab
3485 pgInfo
= self
._pagesInfoVec
[0]
3486 tabRect
= wx
.Rect(0, pgInfo
.GetPosition().y
, pgInfo
.GetPosition().x
, self
.GetParent().GetSize().y
)
3487 if tabRect
.Contains(pt
):
3490 # try after the last tab
3491 pgInfo
= self
._pagesInfoVec
[-1]
3492 startpos
= pgInfo
.GetPosition().x
+pgInfo
.GetSize().x
3493 tabRect
= wx
.Rect(startpos
, pgInfo
.GetPosition().y
, fullrect
.width
-startpos
, self
.GetParent().GetSize().y
)
3495 if tabRect
.Contains(pt
):
3496 return FNB_TAB
, len(self
._pagesInfoVec
)
3499 return FNB_NOWHERE
, -1
3502 def OnPaint(self
, event
):
3504 Handles the wx.EVT_PAINT event for StyledTabsContainer.
3505 Switches to PageContainerBase.OnPaint() method if the style is not VC8.
3508 if not self
.HasFlag(FNB_VC8
):
3510 PageContainerBase
.OnPaint(self
, event
)
3513 # Visual studio 8 style
3514 dc
= wx
.BufferedPaintDC(self
)
3516 if "__WXMAC__" in wx
.PlatformInfo
:
3517 # Works well on MSW & GTK, however this lines should be skipped on MAC
3518 if not self
._pagesInfoVec
or self
._nFrom
>= len(self
._pagesInfoVec
):
3523 # Set the font for measuring the tab height
3524 normalFont
= wx
.SystemSettings
.GetFont(wx
.SYS_DEFAULT_GUI_FONT
)
3525 boldFont
= wx
.SystemSettings
.GetFont(wx
.SYS_DEFAULT_GUI_FONT
)
3526 boldFont
.SetWeight(wx
.FONTWEIGHT_BOLD
)
3528 if "__WXGTK__" in wx
.PlatformInfo
:
3529 dc
.SetFont(boldFont
)
3531 width
, height
= dc
.GetTextExtent("Tp")
3533 tabHeight
= height
+ FNB_HEIGHT_SPACER
# We use 8 pixels as padding
3535 # Calculate the number of rows required for drawing the tabs
3536 rect
= self
.GetClientRect()
3538 # Set the maximum client size
3539 self
.SetSizeHints(self
.GetButtonsAreaLength(), tabHeight
)
3540 borderPen
= wx
.Pen(wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_BTNSHADOW
))
3543 backBrush
= wx
.Brush(self
._tabAreaColor
)
3544 noselBrush
= wx
.Brush(wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_BTNFACE
))
3545 selBrush
= wx
.Brush(self
._activeTabColor
)
3546 size
= self
.GetSize()
3549 dc
.SetTextBackground(self
.GetBackgroundColour())
3550 dc
.SetTextForeground(self
._activeTextColor
)
3552 # If border style is set, set the pen to be border pen
3553 if self
.HasFlag(FNB_TABS_BORDER_SIMPLE
):
3554 dc
.SetPen(borderPen
)
3556 dc
.SetPen(wx
.TRANSPARENT_PEN
)
3558 lightFactor
= (self
.HasFlag(FNB_BACKGROUND_GRADIENT
) and [70] or [0])[0]
3559 # For VC8 style, we color the tab area in gradient coloring
3560 PaintStraightGradientBox(dc
, self
.GetClientRect(), self
._tabAreaColor
, LightColour(self
._tabAreaColor
, lightFactor
))
3562 dc
.SetBrush(wx
.TRANSPARENT_BRUSH
)
3563 dc
.DrawRectangle(0, 0, size
.x
, size
.y
)
3565 # Take 3 bitmaps for the background for the buttons
3567 mem_dc
= wx
.MemoryDC()
3569 #---------------------------------------
3571 #---------------------------------------
3572 rect
= wx
.Rect(self
.GetXPos(), 6, 16, 14)
3573 mem_dc
.SelectObject(self
._xBgBmp
)
3574 mem_dc
.Blit(0, 0, rect
.width
, rect
.height
, dc
, rect
.x
, rect
.y
)
3575 mem_dc
.SelectObject(wx
.NullBitmap
)
3577 #---------------------------------------
3579 #---------------------------------------
3580 rect
= wx
.Rect(self
.GetRightButtonPos(), 6, 16, 14)
3581 mem_dc
.SelectObject(self
._rightBgBmp
)
3582 mem_dc
.Blit(0, 0, rect
.width
, rect
.height
, dc
, rect
.x
, rect
.y
)
3583 mem_dc
.SelectObject(wx
.NullBitmap
)
3585 #---------------------------------------
3587 #---------------------------------------
3588 rect
= wx
.Rect(self
.GetLeftButtonPos(), 6, 16, 14)
3589 mem_dc
.SelectObject(self
._leftBgBmp
)
3590 mem_dc
.Blit(0, 0, rect
.width
, rect
.height
, dc
, rect
.x
, rect
.y
)
3591 mem_dc
.SelectObject(wx
.NullBitmap
)
3593 # We always draw the bottom/upper line of the tabs
3594 # regradless the style
3595 dc
.SetPen(borderPen
)
3596 self
.DrawTabsLine(dc
)
3599 dc
.SetPen(borderPen
)
3602 dc
.SetFont(boldFont
)
3605 # Update all the tabs from 0 to 'self._nFrom' to be non visible
3606 for i
in xrange(self
._nFrom
):
3608 self
._pagesInfoVec
[i
].SetPosition(wx
.Point(-1, -1))
3609 self
._pagesInfoVec
[i
].GetRegion().Clear()
3611 # Draw the visible tabs, in VC8 style, we draw them from right to left
3612 vTabsInfo
= self
.NumberTabsCanFit(dc
)
3614 for cur
in xrange(len(vTabsInfo
) - 1, -1, -1):
3616 # 'i' points to the index of the currently drawn tab
3617 # in self._pagesInfoVec vector
3618 i
= self
._nFrom
+ cur
3619 dc
.SetPen(borderPen
)
3620 dc
.SetBrush((i
==self
.GetSelection() and [selBrush
] or [noselBrush
])[0])
3622 # Calculate the text length using the bold font, so when selecting a tab
3623 # its width will not change
3624 dc
.SetFont(boldFont
)
3625 width
, pom
= dc
.GetTextExtent(self
.GetPageText(i
))
3627 # Now set the font to the correct font
3628 dc
.SetFont((i
==self
.GetSelection() and [boldFont
] or [normalFont
])[0])
3630 # Set a minimum size to a tab
3634 # Add the padding to the tab width
3636 # +-----------------------------------------------------------+
3637 # | PADDING | IMG | IMG_PADDING | TEXT | PADDING | x |PADDING |
3638 # +-----------------------------------------------------------+
3640 tabWidth
= self
._pParent
.GetPadding() * 2 + width
3641 imageYCoord
= (self
.HasFlag(FNB_BOTTOM
) and [6] or [8])[0]
3643 if self
.TabHasImage(i
):
3644 tabWidth
+= 16 + self
._pParent
.GetPadding()
3646 posx
= vTabsInfo
[cur
].x
3648 # By default we clean the tab region
3649 # incase we use the VC8 style which requires
3650 # the region, it will be filled by the function
3652 self
._pagesInfoVec
[i
].GetRegion().Clear()
3654 # Clean the 'x' buttn on the tab
3655 # 'Clean' rectanlge is a rectangle with width or height
3656 # with values lower than or equal to 0
3657 self
._pagesInfoVec
[i
].GetXRect().SetSize(wx
.Size(-1, -1))
3660 # Incase we are drawing the active tab
3661 # we need to redraw so it will appear on top
3663 if i
== self
.GetSelection():
3665 activeTabPosx
= posx
3669 self
.DrawVC8Tab(dc
, posx
, i
, tabWidth
, tabHeight
)
3671 # Text drawing offset from the left border of the
3673 # The width of the images are 16 pixels
3674 vc8ShapeLen
= tabHeight
3676 if self
.TabHasImage(i
):
3677 textOffset
= self
._pParent
.GetPadding() * 2 + 16 + vc8ShapeLen
3679 textOffset
= self
._pParent
.GetPadding() + vc8ShapeLen
3681 # Set the non-active text color
3682 if i
!= self
.GetSelection():
3683 dc
.SetTextForeground(self
._nonActiveTextColor
)
3685 if self
.TabHasImage(i
):
3686 imageXOffset
= textOffset
- 16 - self
._pParent
.GetPadding()
3687 self
._ImageList
.Draw(self
._pagesInfoVec
[i
].GetImageIndex(), dc
,
3688 posx
+ imageXOffset
, imageYCoord
,
3689 wx
.IMAGELIST_DRAW_TRANSPARENT
, True)
3691 dc
.DrawText(self
.GetPageText(i
), posx
+ textOffset
, imageYCoord
)
3693 textWidth
, textHeight
= dc
.GetTextExtent(self
.GetPageText(i
))
3695 # Restore the text forground
3696 dc
.SetTextForeground(self
._activeTextColor
)
3698 # Update the tab position & size
3699 self
._pagesInfoVec
[i
].SetPosition(wx
.Point(posx
, VERTICAL_BORDER_PADDING
))
3700 self
._pagesInfoVec
[i
].SetSize(wx
.Size(tabWidth
, tabHeight
))
3702 # Incase we are in VC8 style, redraw the active tab (incase it is visible)
3703 if self
.GetSelection() >= self
._nFrom
and self
.GetSelection() < self
._nFrom
+ len(vTabsInfo
):
3705 hasImage
= self
.TabHasImage(self
.GetSelection())
3707 dc
.SetFont(boldFont
)
3708 width
, pom
= dc
.GetTextExtent(self
.GetPageText(self
.GetSelection()))
3710 tabWidth
= self
._pParent
.GetPadding() * 2 + width
3713 tabWidth
+= 16 + self
._pParent
.GetPadding()
3715 # Set the active tab font, pen brush and font-color
3716 dc
.SetPen(borderPen
)
3717 dc
.SetBrush(selBrush
)
3718 dc
.SetFont(boldFont
)
3719 dc
.SetTextForeground(self
._activeTextColor
)
3720 self
.DrawVC8Tab(dc
, activeTabPosx
, self
.GetSelection(), tabWidth
, tabHeight
)
3722 # Text drawing offset from the left border of the
3724 # The width of the images are 16 pixels
3725 vc8ShapeLen
= tabHeight
- VERTICAL_BORDER_PADDING
- 2
3727 textOffset
= self
._pParent
.GetPadding() * 2 + 16 + vc8ShapeLen
3729 textOffset
= self
._pParent
.GetPadding() + vc8ShapeLen
3731 # Draw the image for the tab if any
3732 imageYCoord
= (self
.HasFlag(FNB_BOTTOM
) and [6] or [8])[0]
3735 imageXOffset
= textOffset
- 16 - self
._pParent
.GetPadding()
3736 self
._ImageList
.Draw(self
._pagesInfoVec
[self
.GetSelection()].GetImageIndex(), dc
,
3737 activeTabPosx
+ imageXOffset
, imageYCoord
,
3738 wx
.IMAGELIST_DRAW_TRANSPARENT
, True)
3740 dc
.DrawText(self
.GetPageText(self
.GetSelection()), activeTabPosx
+ textOffset
, imageYCoord
)
3742 # Update all tabs that can not fit into the screen as non-visible
3743 for xx
in xrange(self
._nFrom
+ len(vTabsInfo
), len(self
._pagesInfoVec
)):
3745 self
._pagesInfoVec
[xx
].SetPosition(wx
.Point(-1, -1))
3746 self
._pagesInfoVec
[xx
].GetRegion().Clear()
3748 # Draw the left/right/close buttons
3750 self
.DrawLeftArrow(dc
)
3751 self
.DrawRightArrow(dc
)
3755 def DrawVC8Tab(self
, dc
, posx
, tabIdx
, tabWidth
, tabHeight
):
3756 """ Draws the VC8 style tabs. """
3758 borderPen
= wx
.Pen(self
._colorBorder
)
3759 tabPoints
= [wx
.Point() for ii
in xrange(8)]
3761 # If we draw the first tab or the active tab,
3762 # we draw a full tab, else we draw a truncated tab
3773 tabPoints
[0].x
= (self
.HasFlag(FNB_BOTTOM
) and [posx
] or [posx
+self
._factor
])[0]
3774 tabPoints
[0].y
= (self
.HasFlag(FNB_BOTTOM
) and [2] or [tabHeight
- 3])[0]
3776 tabPoints
[1].x
= tabPoints
[0].x
+ tabHeight
- VERTICAL_BORDER_PADDING
- 3 - self
._factor
3777 tabPoints
[1].y
= (self
.HasFlag(FNB_BOTTOM
) and [tabHeight
- (VERTICAL_BORDER_PADDING
+2)] or [(VERTICAL_BORDER_PADDING
+2)])[0]
3779 tabPoints
[2].x
= tabPoints
[1].x
+ 4
3780 tabPoints
[2].y
= (self
.HasFlag(FNB_BOTTOM
) and [tabHeight
- VERTICAL_BORDER_PADDING
] or [VERTICAL_BORDER_PADDING
])[0]
3782 tabPoints
[3].x
= tabPoints
[2].x
+ tabWidth
- 2
3783 tabPoints
[3].y
= (self
.HasFlag(FNB_BOTTOM
) and [tabHeight
- VERTICAL_BORDER_PADDING
] or [VERTICAL_BORDER_PADDING
])[0]
3785 tabPoints
[4].x
= tabPoints
[3].x
+ 1
3786 tabPoints
[4].y
= (self
.HasFlag(FNB_BOTTOM
) and [tabPoints
[3].y
- 1] or [tabPoints
[3].y
+ 1])[0]
3788 tabPoints
[5].x
= tabPoints
[4].x
+ 1
3789 tabPoints
[5].y
= (self
.HasFlag(FNB_BOTTOM
) and [(tabPoints
[4].y
- 1)] or [tabPoints
[4].y
+ 1])[0]
3791 tabPoints
[6].x
= tabPoints
[2].x
+ tabWidth
3792 tabPoints
[6].y
= tabPoints
[0].y
3794 tabPoints
[7].x
= tabPoints
[0].x
3795 tabPoints
[7].y
= tabPoints
[0].y
3797 self
._pagesInfoVec
[tabIdx
].SetRegion(tabPoints
)
3801 dc
.SetBrush(wx
.Brush((tabIdx
== self
.GetSelection() and [self
._activeTabColor
] or [self
._colorTo
])[0]))
3802 dc
.SetPen(wx
.Pen((tabIdx
== self
.GetSelection() and [wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_BTNSHADOW
)] or [self
._colorBorder
])[0]))
3803 dc
.DrawPolygon(tabPoints
)
3808 rect
= self
.GetClientRect()
3810 if tabIdx
!= self
.GetSelection() and not self
.HasFlag(FNB_BOTTOM
):
3813 dc
.SetPen(wx
.Pen(self
._colorBorder
))
3815 curPen
= dc
.GetPen()
3818 dc
.DrawLine(posx
, lineY
, posx
+rect
.width
, lineY
)
3820 # In case we are drawing the selected tab, we draw the border of it as well
3821 # but without the bottom (upper line incase of wxBOTTOM)
3822 if tabIdx
== self
.GetSelection():
3824 borderPen
= wx
.Pen(wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_BTNSHADOW
))
3825 brush
= wx
.TRANSPARENT_BRUSH
3826 dc
.SetPen(borderPen
)
3828 dc
.DrawPolygon(tabPoints
)
3830 # Delete the bottom line (or the upper one, incase we use wxBOTTOM)
3831 dc
.SetPen(wx
.WHITE_PEN
)
3832 dc
.DrawLine(tabPoints
[0].x
, tabPoints
[0].y
, tabPoints
[6].x
, tabPoints
[6].y
)
3834 self
.FillVC8GradientColor(dc
, tabPoints
, tabIdx
== self
.GetSelection(), tabIdx
)
3836 # Draw a thin line to the right of the non-selected tab
3837 if tabIdx
!= self
.GetSelection():
3839 dc
.SetPen(wx
.Pen(wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_3DFACE
)))
3840 dc
.DrawLine(tabPoints
[4].x
-1, tabPoints
[4].y
, tabPoints
[5].x
-1, tabPoints
[5].y
)
3841 dc
.DrawLine(tabPoints
[5].x
-1, tabPoints
[5].y
, tabPoints
[6].x
-1, tabPoints
[6].y
)
3844 def FillVC8GradientColor(self
, dc
, tabPoints
, bSelectedTab
, tabIdx
):
3845 """ Fills a tab with a gradient colour. """
3847 # calculate gradient coefficients
3848 col2
= (self
.HasFlag(FNB_BOTTOM
) and [self
._colorTo
] or [self
._colorFrom
])[0]
3849 col1
= (self
.HasFlag(FNB_BOTTOM
) and [self
._colorFrom
] or [self
._colorTo
])[0]
3851 # If colorful tabs style is set, override the tab color
3852 if self
.HasFlag(FNB_COLORFUL_TABS
):
3854 if not self
._pagesInfoVec
[tabIdx
].GetColor():
3856 # First time, generate color, and keep it in the vector
3857 tabColor
= self
.GenTabColour()
3858 self
._pagesInfoVec
[tabIdx
].SetColor(tabColor
)
3860 if self
.HasFlag(FNB_BOTTOM
):
3862 col2
= LightColour(self
._pagesInfoVec
[tabIdx
].GetColor(), 50 )
3863 col1
= LightColour(self
._pagesInfoVec
[tabIdx
].GetColor(), 80 )
3867 col1
= LightColour(self
._pagesInfoVec
[tabIdx
].GetColor(), 50 )
3868 col2
= LightColour(self
._pagesInfoVec
[tabIdx
].GetColor(), 80 )
3870 size
= abs(tabPoints
[2].y
- tabPoints
[0].y
) - 1
3872 rf
, gf
, bf
= 0, 0, 0
3873 rstep
= float(col2
.Red() - col1
.Red())/float(size
)
3874 gstep
= float(col2
.Green() - col1
.Green())/float(size
)
3875 bstep
= float(col2
.Blue() - col1
.Blue())/float(size
)
3879 # If we are drawing the selected tab, we need also to draw a line
3880 # from 0.tabPoints[0].x and tabPoints[6].x . end, we achieve this
3881 # by drawing the rectangle with transparent brush
3882 # the line under the selected tab will be deleted by the drwaing loop
3884 self
.DrawTabsLine(dc
)
3888 if self
.HasFlag(FNB_BOTTOM
):
3890 if y
> tabPoints
[0].y
+ size
:
3895 if y
< tabPoints
[0].y
- size
:
3898 currCol
= wx
.Colour(col1
.Red() + rf
, col1
.Green() + gf
, col1
.Blue() + bf
)
3900 dc
.SetPen((bSelectedTab
and [wx
.Pen(self
._activeTabColor
)] or [wx
.Pen(currCol
)])[0])
3901 startX
= self
.GetStartX(tabPoints
, y
)
3902 endX
= self
.GetEndX(tabPoints
, y
)
3903 dc
.DrawLine(startX
, y
, endX
, y
)
3905 # Draw the border using the 'edge' point
3906 dc
.SetPen(wx
.Pen((bSelectedTab
and [wx
.SystemSettings
.GetColour(wx
.SYS_COLOUR_BTNSHADOW
)] or [self
._colorBorder
])[0]))
3908 dc
.DrawPoint(startX
, y
)
3909 dc
.DrawPoint(endX
, y
)
3911 # Progress the color
3916 if self
.HasFlag(FNB_BOTTOM
):
3922 def GetStartX(self
, tabPoints
, y
):
3923 """ Returns the x start position of a tab. """
3925 x1
, x2
, y1
, y2
= 0.0, 0.0, 0.0, 0.0
3927 # We check the 3 points to the left
3928 style
= self
.GetParent().GetWindowStyleFlag()
3929 bBottomStyle
= (style
& FNB_BOTTOM
and [True] or [False])[0]
3936 if y
>= tabPoints
[i
].y
and y
< tabPoints
[i
+1].y
:
3939 x2
= tabPoints
[i
+1].x
3941 y2
= tabPoints
[i
+1].y
3949 if y
<= tabPoints
[i
].y
and y
> tabPoints
[i
+1].y
:
3952 x2
= tabPoints
[i
+1].x
3954 y2
= tabPoints
[i
+1].y
3959 return tabPoints
[2].x
3961 # According to the equation y = ax + b => x = (y-b)/a
3962 # We know the first 2 points
3967 a
= (y2
- y1
)/(x2
- x1
)
3969 b
= y1
- ((y2
- y1
)/(x2
- x1
))*x1
3979 def GetEndX(self
, tabPoints
, y
):
3980 """ Returns the x end position of a tab. """
3982 x1
, x2
, y1
, y2
= 0.0, 0.0, 0.0, 0.0
3984 # We check the 3 points to the left
3985 style
= self
.GetParent().GetWindowStyleFlag()
3986 bBottomStyle
= (style
& FNB_BOTTOM
and [True] or [False])[0]
3991 for i
in xrange(7, 3, -1):
3993 if y
>= tabPoints
[i
].y
and y
< tabPoints
[i
-1].y
:
3996 x2
= tabPoints
[i
-1].x
3998 y2
= tabPoints
[i
-1].y
4004 for i
in xrange(7, 3, -1):
4006 if y
<= tabPoints
[i
].y
and y
> tabPoints
[i
-1].y
:
4009 x2
= tabPoints
[i
-1].x
4011 y2
= tabPoints
[i
-1].y
4016 return tabPoints
[3].x
4018 # According to the equation y = ax + b => x = (y-b)/a
4019 # We know the first 2 points
4025 a
= (y2
- y1
)/(x2
- x1
)
4026 b
= y1
- ((y2
- y1
)/(x2
- x1
)) * x1
4036 def GenTabColour(self
):
4037 """ Generates a random soft pleasant colour for a tab. """
4039 return RandomColor()
4042 def GetSingleLineBorderColor(self
):
4044 if self
.HasFlag(FNB_VC8
):
4045 return self
._activeTabColor
4047 return PageContainerBase
.GetSingleLineBorderColor(self
)
4050 def SetFactor(self
, factor
):
4051 """ Sets the brighten colour factor. """
4053 self
._factor
= factor
4057 def GetFactor(self
):
4058 """ Returns the brighten colour factor. """
projects / wxWidgets.git / blob