--- a/orpg/tools/FlatNotebook.py	Thu Aug 20 08:41:29 2009 -0500
+++ b/orpg/tools/FlatNotebook.py	Fri Aug 21 21:40:22 2009 -0500
@@ -642,29 +642,23 @@
 def GetMondrianBitmap():
     return wx.BitmapFromImage(GetMondrianImage().Scale(16, 16))
 
-
 def GetMondrianImage():
     import cStringIO
     stream = cStringIO.StringIO(GetMondrianData())
     return wx.ImageFromStream(stream)
 
-
 def GetMondrianIcon():
     icon = wx.EmptyIcon()
     icon.CopyFromBitmap(GetMondrianBitmap())
     return icon
 #----------------------------------------------------------------------
 
-
 def LightColour(color, percent):
     """ Brighten input colour by percent. """
-
     end_color = wx.WHITE
-
     rd = end_color.Red() - color.Red()
     gd = end_color.Green() - color.Green()
     bd = end_color.Blue() - color.Blue()
-
     high = 100
 
     # We take the percent way of the color from color -. white
@@ -674,66 +668,43 @@
     b = color.Blue() + ((i*bd*100)/high)/100
     return wx.Colour(r, g, b)
 
-
 def RandomColour():
     """ Creates a random colour. """
-
     r = random.randint(0, 255) # Random value betweem 0-255
     g = random.randint(0, 255) # Random value betweem 0-255
     b = random.randint(0, 255) # Random value betweem 0-255
-
     return wx.Colour(r, g, b)
 
-
 def PaintStraightGradientBox(dc, rect, startColor, endColor, vertical=True):
     """ Draws a gradient colored box from startColor to endColor. """
-
     rd = endColor.Red() - startColor.Red()
     gd = endColor.Green() - startColor.Green()
     bd = endColor.Blue() - startColor.Blue()
-
     # Save the current pen and brush
     savedPen = dc.GetPen()
     savedBrush = dc.GetBrush()
-
-    if vertical:
-        high = rect.GetHeight()-1
-    else:
-        high = rect.GetWidth()-1
-
-    if high < 1:
-        return
-
+    if vertical: high = rect.GetHeight()-1
+    else: high = rect.GetWidth()-1
+    if high < 1: return
     for i in xrange(high+1):
-
         r = startColor.Red() + ((i*rd*100)/high)/100
         g = startColor.Green() + ((i*gd*100)/high)/100
         b = startColor.Blue() + ((i*bd*100)/high)/100
-
         p = wx.Pen(wx.Colour(r, g, b))
         dc.SetPen(p)
-
-        if vertical:
-            dc.DrawLine(rect.x, rect.y+i, rect.x+rect.width, rect.y+i)
-        else:
-            dc.DrawLine(rect.x+i, rect.y, rect.x+i, rect.y+rect.height)
-
+        if vertical: dc.DrawLine(rect.x, rect.y+i, rect.x+rect.width, rect.y+i)
+        else: dc.DrawLine(rect.x+i, rect.y, rect.x+i, rect.y+rect.height)
     # Restore the pen and brush
     dc.SetPen(savedPen)
     dc.SetBrush(savedBrush)
 
-
-
-# -----------------------------------------------------------------------------
+"""
 # Util functions
-# -----------------------------------------------------------------------------
-
+"""
 def DrawButton(dc, rect, focus, upperTabs):
-
     # Define the rounded rectangle base on the given rect
     # we need an array of 9 points for it
     regPts = [wx.Point() for indx in xrange(9)]
-
     if focus:
         if upperTabs:
             leftPt = wx.Point(rect.x, rect.y + (rect.height / 10)*8)
@@ -744,16 +715,11 @@
     else:
         leftPt = wx.Point(rect.x, rect.y + (rect.height / 2))
         rightPt = wx.Point(rect.x + rect.width - 2, rect.y + (rect.height / 2))
-
     # Define the top region
     top = wx.RectPP(rect.GetTopLeft(), rightPt)
     bottom = wx.RectPP(leftPt, rect.GetBottomRight())
-
     topStartColor = wx.WHITE
-
-    if not focus:
-        topStartColor = LightColour(wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DFACE), 50)
-
+    if not focus: topStartColor = LightColour(wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DFACE), 50)
     topEndColor = wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DFACE)
     bottomStartColor = topEndColor
     bottomEndColor = topEndColor
@@ -766,7 +732,6 @@
         else:
             PaintStraightGradientBox(dc, top, topEndColor , topStartColor)
             PaintStraightGradientBox(dc, bottom, bottomStartColor, bottomEndColor)
-
     else:
         if focus:
             PaintStraightGradientBox(dc, bottom, topEndColor, bottomEndColor)
@@ -774,107 +739,83 @@
         else:
             PaintStraightGradientBox(dc, bottom, bottomStartColor, bottomEndColor)
             PaintStraightGradientBox(dc, top, topEndColor, topStartColor)
-
     dc.SetBrush(wx.TRANSPARENT_BRUSH)
 
 
-# ---------------------------------------------------------------------------- #
+"""
 # Class FNBDropSource
 # Gives Some Custom UI Feedback during the DnD Operations
-# ---------------------------------------------------------------------------- #
-
+"""
 class FNBDropSource(wx.DropSource):
     """
     Give some custom UI feedback during the drag and drop operation in this
     function. It is called on each mouse move, so your implementation must
     not be too slow.
     """
-
     def __init__(self, win):
         """ Default class constructor. Used internally. """
-
         wx.DropSource.__init__(self, win)
         self._win = win
 
-
     def GiveFeedback(self, effect):
         """ Provides user with a nice feedback when tab is being dragged. """
-
         self._win.DrawDragHint()
         return False
 
 
-# ---------------------------------------------------------------------------- #
+"""
 # Class FNBDragInfo
 # Stores All The Information To Allow Drag And Drop Between Different
 # FlatNotebooks.
-# ---------------------------------------------------------------------------- #
-
+"""
 class FNBDragInfo:
-
     _map = weakref.WeakValueDictionary()
-
     def __init__(self, container, pageindex):
         """ Default class constructor. """
-
         self._id = id(container)
         FNBDragInfo._map[self._id] = container
         self._pageindex = pageindex
 
-
     def GetContainer(self):
         """ Returns the L{FlatNotebook} page (usually a panel). """
-
         return FNBDragInfo._map.get(self._id, None)
 
-
     def GetPageIndex(self):
         """ Returns the page index associated with a page. """
-
         return self._pageindex
 
 
-# ---------------------------------------------------------------------------- #
+"""
 # Class FNBDropTarget
 # Simply Used To Handle The OnDrop() Method When Dragging And Dropping Between
 # Different FlatNotebooks.
-# ---------------------------------------------------------------------------- #
-
+"""
 class FNBDropTarget(wx.DropTarget):
-
     def __init__(self, parent):
         """ Default class constructor. """
-
         wx.DropTarget.__init__(self)
-
         self._parent = parent
         self._dataobject = wx.CustomDataObject(wx.CustomDataFormat("FlatNotebook"))
         self.SetDataObject(self._dataobject)
 
-
     def OnData(self, x, y, dragres):
         """ Handles the OnData() method to call the real DnD routine. """
-
         if not self.GetData():
             return wx.DragNone
-
         draginfo = self._dataobject.GetData()
         drginfo = cPickle.loads(draginfo)
-
         return self._parent.OnDropTarget(x, y, drginfo.GetPageIndex(), drginfo.GetContainer())
 
 
-# ---------------------------------------------------------------------------- #
+"""
 # Class PageInfo
 # Contains parameters for every FlatNotebook page
-# ---------------------------------------------------------------------------- #
-
+"""
 class PageInfo:
     """
     This class holds all the information (caption, image, etc...) belonging to a
     single tab in L{FlatNotebook}.
     """
-
     def __init__(self, caption="", imageindex=-1, tabangle=0, enabled=True):
         """
         Default Class Constructor.
@@ -885,7 +826,6 @@
         @param tabangle: the tab angle (only on standard tabs, from 0 to 15 degrees);
         @param enabled: sets enabled or disabled the tab.
         """
-
         self._strCaption = caption
         self._TabAngle = tabangle
         self._ImageIndex = imageindex
@@ -897,119 +837,82 @@
         self._color = None
         self._hasFocus = False
 
-
     def SetCaption(self, value):
         """ Sets the tab caption. """
-
         self._strCaption = value
 
-
     def GetCaption(self):
         """ Returns the tab caption. """
-
         return self._strCaption
 
-
     def SetPosition(self, value):
         """ Sets the tab position. """
-
         self._pos = value
 
-
     def GetPosition(self):
         """ Returns the tab position. """
-
         return self._pos
 
-
     def SetSize(self, value):
         """ Sets the tab size. """
-
         self._size = value
 
-
     def GetSize(self):
         """ Returns the tab size. """
-
         return self._size
 
-
     def SetTabAngle(self, value):
         """ Sets the tab header angle (0 <= tab <= 15 degrees). """
-
         self._TabAngle = min(45, value)
 
-
     def GetTabAngle(self):
         """ Returns the tab angle. """
-
         return self._TabAngle
 
-
     def SetImageIndex(self, value):
         """ Sets the tab image index. """
-
         self._ImageIndex = value
 
-
     def GetImageIndex(self):
         """ Returns the tab umage index. """
-
         return self._ImageIndex
 
-
     def GetEnabled(self):
         """ Returns whether the tab is enabled or not. """
-
         return self._bEnabled
 
-
     def EnableTab(self, enabled):
         """ Sets the tab enabled or disabled. """
-
         self._bEnabled = enabled
 
-
     def SetRegion(self, points=[]):
         """ Sets the tab region. """
-
         self._region = wx.RegionFromPoints(points)
 
-
     def GetRegion(self):
         """ Returns the tab region. """
-
         return self._region
 
-
     def SetXRect(self, xrect):
         """ Sets the button 'X' area rect. """
-
         self._xRect = xrect
 
-
     def GetXRect(self):
         """ Returns the button 'X' area rect. """
-
         return self._xRect
 
-
     def GetColour(self):
         """ Returns the tab colour. """
-
         return self._color
 
-
     def SetColour(self, color):
         """ Sets the tab colour. """
-
         self._color = color
 
 
-# ---------------------------------------------------------------------------- #
+"""
 # Class FlatNotebookEvent
-# ---------------------------------------------------------------------------- #
-
+"""
 class FlatNotebookEvent(wx.PyCommandEvent):
     """
     This events will be sent when a EVT_FLATNOTEBOOK_PAGE_CHANGED,
@@ -1017,68 +920,48 @@
     EVT_FLATNOTEBOOK_PAGE_CLOSED and EVT_FLATNOTEBOOK_PAGE_CONTEXT_MENU is
     mapped in the parent.
     """
-
     def __init__(self, eventType, id=1, nSel=-1, nOldSel=-1):
         """ Default class constructor. """
-
         wx.PyCommandEvent.__init__(self, eventType, id)
         self._eventType = eventType
-
         self.notify = wx.NotifyEvent(eventType, id)
 
-
     def GetNotifyEvent(self):
         """Returns the actual wx.NotifyEvent."""
-
         return self.notify
 
-
     def IsAllowed(self):
         """Returns whether the event is allowed or not."""
-
         return self.notify.IsAllowed()
 
-
     def Veto(self):
         """Vetos the event."""
-
         self.notify.Veto()
 
-
     def Allow(self):
         """The event is allowed."""
-
         self.notify.Allow()
 
-
     def SetSelection(self, nSel):
         """ Sets event selection. """
-
         self._selection = nSel
 
-
     def SetOldSelection(self, nOldSel):
         """ Sets old event selection. """
-
         self._oldselection = nOldSel
 
-
     def GetSelection(self):
         """ Returns event selection. """
-
         return self._selection
 
-
     def GetOldSelection(self):
         """ Returns old event selection """
-
         return self._oldselection
 
 
-# ---------------------------------------------------------------------------- #
+"""
 # Class TabNavigatorWindow
-# ---------------------------------------------------------------------------- #
-
+"""
 class TabNavigatorWindow(wx.Dialog):
     """
     This class is used to create a modal dialog that enables "Smart Tabbing",
@@ -1087,39 +970,26 @@
 
     def __init__(self, parent=None, icon=None):
         """ Default class constructor. Used internally."""
-
         wx.Dialog.__init__(self, parent, wx.ID_ANY, "", style=0)
-
         self._selectedItem = -1
         self._indexMap = []
-
-        if icon is None:
-            self._bmp = GetMondrianBitmap()
-        else:
-            self._bmp = icon
-
+        if icon is None: self._bmp = GetMondrianBitmap()
+        else: self._bmp = icon
         sz = wx.BoxSizer(wx.VERTICAL)
-
         self._listBox = wx.ListBox(self, wx.ID_ANY, wx.DefaultPosition, wx.Size(200, 150), [], wx.LB_SINGLE | wx.NO_BORDER)
-
         mem_dc = wx.MemoryDC()
         mem_dc.SelectObject(wx.EmptyBitmap(1,1))
         font = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)
         font.SetWeight(wx.BOLD)
         mem_dc.SetFont(font)
-
         panelHeight = mem_dc.GetCharHeight()
         panelHeight += 4 # Place a spacer of 2 pixels
 
         # Out signpost bitmap is 24 pixels
-        if panelHeight < 24:
-            panelHeight = 24
-
+        if panelHeight < 24: panelHeight = 24
         self._panel = wx.Panel(self, wx.ID_ANY, wx.DefaultPosition, wx.Size(200, panelHeight))
-
         sz.Add(self._panel)
         sz.Add(self._listBox, 1, wx.EXPAND)
-
         self.SetSizer(sz)
 
         # Connect events to the list box
@@ -1130,114 +1000,76 @@
         # Connect paint event to the panel
         self._panel.Bind(wx.EVT_PAINT, self.OnPanelPaint)
         self._panel.Bind(wx.EVT_ERASE_BACKGROUND, self.OnPanelEraseBg)
-
         self.SetBackgroundColour(wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DFACE))
         self._listBox.SetBackgroundColour(wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DFACE))
         self.PopulateListControl(parent)
-
         self.GetSizer().Fit(self)
         self.GetSizer().SetSizeHints(self)
         self.GetSizer().Layout()
         self.Centre()
 
-
     def OnKeyUp(self, event):
         """Handles the wx.EVT_KEY_UP for the L{TabNavigatorWindow}."""
-
-        if event.GetKeyCode() == wx.WXK_CONTROL:
-            self.CloseDialog()
-
+        if event.GetKeyCode() == wx.WXK_CONTROL: self.CloseDialog()
 
     def OnNavigationKey(self, event):
         """Handles the wx.EVT_NAVIGATION_KEY for the L{TabNavigatorWindow}. """
-
         selected = self._listBox.GetSelection()
         bk = self.GetParent()
         maxItems = bk.GetPageCount()
-
         if event.GetDirection():
-
             # Select next page
-            if selected == maxItems - 1:
-                itemToSelect = 0
-            else:
-                itemToSelect = selected + 1
-
+            if selected == maxItems - 1: itemToSelect = 0
+            else: itemToSelect = selected + 1
         else:
-
             # Previous page
-            if selected == 0:
-                itemToSelect = maxItems - 1
-            else:
-                itemToSelect = selected - 1
-
+            if selected == 0: itemToSelect = maxItems - 1
+            else: itemToSelect = selected - 1
         self._listBox.SetSelection(itemToSelect)
 
-
     def PopulateListControl(self, book):
         """Populates the L{TabNavigatorWindow} listbox with a list of tabs."""
-
         selection = book.GetSelection()
         count = book.GetPageCount()
-
         self._listBox.Append(book.GetPageText(selection))
         self._indexMap.append(selection)
-
         prevSel = book.GetPreviousSelection()
-
         if prevSel != wx.NOT_FOUND:
-
             # Insert the previous selection as second entry
             self._listBox.Append(book.GetPageText(prevSel))
             self._indexMap.append(prevSel)
-
         for c in xrange(count):
-
             # Skip selected page
-            if c == selection:
-                continue
-
+            if c == selection: continue
             # Skip previous selected page as well
-            if c == prevSel:
-                continue
-
+            if c == prevSel: continue
             self._listBox.Append(book.GetPageText(c))
             self._indexMap.append(c)
-
         # Select the next entry after the current selection
         self._listBox.SetSelection(0)
         dummy = wx.NavigationKeyEvent()
         dummy.SetDirection(True)
         self.OnNavigationKey(dummy)
 
-
     def OnItemSelected(self, event):
         """Handles the wx.EVT_LISTBOX_DCLICK event for the wx.ListBox inside L{TabNavigatorWindow}. """
-
         self.CloseDialog()
 
-
     def CloseDialog(self):
         """Closes the L{TabNavigatorWindow} dialog, setting selection in L{FlatNotebook}."""
-
         bk = self.GetParent()
         self._selectedItem = self._listBox.GetSelection()
         iter = self._indexMap[self._selectedItem]
         bk._pages.FireEvent(iter)
         self.EndModal(wx.ID_OK)
 
-
     def OnPanelPaint(self, event):
         """Handles the wx.EVT_PAINT event for L{TabNavigatorWindow} top panel. """
-
         dc = wx.PaintDC(self._panel)
         rect = self._panel.GetClientRect()
-
         bmp = wx.EmptyBitmap(rect.width, rect.height)
-
         mem_dc = wx.MemoryDC()
         mem_dc.SelectObject(bmp)
-
         endColour = wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNSHADOW)
         startColour = LightColour(endColour, 50)
         PaintStraightGradientBox(mem_dc, rect, startColour, endColour)
@@ -1254,41 +1086,34 @@
         font.SetWeight(wx.BOLD)
         mem_dc.SetFont(font)
         fontHeight = mem_dc.GetCharHeight()
-
         txtPt.x = bmpPt.x + self._bmp.GetWidth() + 4
         txtPt.y = (rect.height - fontHeight)/2
         mem_dc.SetTextForeground(wx.WHITE)
         mem_dc.DrawText("Opened tabs:", txtPt.x, txtPt.y)
         mem_dc.SelectObject(wx.NullBitmap)
-
         dc.DrawBitmap(bmp, 0, 0)
 
-
     def OnPanelEraseBg(self, event):
         """Handles the wx.EVT_ERASE_BACKGROUND event for L{TabNavigatorWindow} top panel. """
-
         pass
 
-
-# ---------------------------------------------------------------------------- #
+"""
 # Class FNBRenderer
-# ---------------------------------------------------------------------------- #
-
+"""
 class FNBRenderer:
     """
     Parent class for the 4 renderers defined: I{Standard}, I{VC71}, I{Fancy}
     and I{VC8}. This class implements the common methods of all 4 renderers.
     """
-
     def __init__(self):
         """Default class constructor. """
-
         self._tabHeight = None
-
         if wx.Platform == "__WXMAC__":
+            """
             # Hack to get proper highlight color for focus rectangle from
             # current theme by creating a theme brush and getting its color.
             # kThemeBrushFocusHighlight is available on Mac OS 8.5 and higher
+            """
             brush = wx.BLACK_BRUSH
             brush.MacSetTheme(Carbon.Appearance.kThemeBrushFocusHighlight)
             self._focusPen = wx.Pen(brush.GetColour(), 2, wx.SOLID)
@@ -1297,417 +1122,266 @@
             self._focusPen.SetDashes([1, 1])
             self._focusPen.SetCap(wx.CAP_BUTT)
 
-
     def GetLeftButtonPos(self, pageContainer):
         """ Returns the left button position in the navigation area. """
-
         pc = pageContainer
         style = pc.GetParent().GetWindowStyleFlag()
         rect = pc.GetClientRect()
         clientWidth = rect.width
-
-        if style & FNB_NO_X_BUTTON:
-            return clientWidth - 38
-        else:
-            return clientWidth - 54
-
+        if style & FNB_NO_X_BUTTON: return clientWidth - 38
+        else: return clientWidth - 54
 
     def GetRightButtonPos(self, pageContainer):
         """ Returns the right button position in the navigation area. """
-
         pc = pageContainer
         style = pc.GetParent().GetWindowStyleFlag()
         rect = pc.GetClientRect()
         clientWidth = rect.width
-
-        if style & FNB_NO_X_BUTTON:
-            return clientWidth - 22
-        else:
-            return clientWidth - 38
-
+        if style & FNB_NO_X_BUTTON: return clientWidth - 22
+        else: return clientWidth - 38
 
     def GetDropArrowButtonPos(self, pageContainer):
         """ Returns the drop down button position in the navigation area. """
-
         return self.GetRightButtonPos(pageContainer)
 
-
     def GetXPos(self, pageContainer):
         """ Returns the 'X' button position in the navigation area. """
-
         pc = pageContainer
         style = pc.GetParent().GetWindowStyleFlag()
         rect = pc.GetClientRect()
         clientWidth = rect.width
-
-        if style & FNB_NO_X_BUTTON:
-            return clientWidth
-        else:
-            return clientWidth - 22
-
+        if style & FNB_NO_X_BUTTON: return clientWidth
+        else: return clientWidth - 22
 
     def GetButtonsAreaLength(self, pageContainer):
         """ Returns the navigation area width. """
-
         pc = pageContainer
         style = pc.GetParent().GetWindowStyleFlag()
-
         # ''
-        if style & FNB_NO_NAV_BUTTONS and style & FNB_NO_X_BUTTON and not style & FNB_DROPDOWN_TABS_LIST:
-            return 0
-
+        if style & FNB_NO_NAV_BUTTONS and style & FNB_NO_X_BUTTON and not style & FNB_DROPDOWN_TABS_LIST: return 0
         # 'x'
-        elif style & FNB_NO_NAV_BUTTONS and not style & FNB_NO_X_BUTTON and not style & FNB_DROPDOWN_TABS_LIST:
-            return 22
-
+        elif style & FNB_NO_NAV_BUTTONS and not style & FNB_NO_X_BUTTON and not style & FNB_DROPDOWN_TABS_LIST: return 22
         # '<>'
-        if not style & FNB_NO_NAV_BUTTONS and style & FNB_NO_X_BUTTON and not style & FNB_DROPDOWN_TABS_LIST:
-            return 53 - 16
-
+        if not style & FNB_NO_NAV_BUTTONS and style & FNB_NO_X_BUTTON and not style & FNB_DROPDOWN_TABS_LIST: return 53 - 16
         # 'vx'
-        if style & FNB_DROPDOWN_TABS_LIST and not style & FNB_NO_X_BUTTON:
-            return 22 + 16
-
+        if style & FNB_DROPDOWN_TABS_LIST and not style & FNB_NO_X_BUTTON: return 22 + 16
         # 'v'
-        if style & FNB_DROPDOWN_TABS_LIST and style & FNB_NO_X_BUTTON:
-            return 22
-
+        if style & FNB_DROPDOWN_TABS_LIST and style & FNB_NO_X_BUTTON: return 22
         # '<>x'
         return 53
 
-
     def DrawArrowAccordingToState(self, dc, pc, rect):
-
         lightFactor = (pc.HasFlag(FNB_BACKGROUND_GRADIENT) and [70] or [0])[0]
         PaintStraightGradientBox(dc, rect, pc._tabAreaColor, LightColour(pc._tabAreaColor, lightFactor))
 
-
     def DrawLeftArrow(self, pageContainer, dc):
         """ Draw the left navigation arrow. """
-
         pc = pageContainer
-
         style = pc.GetParent().GetWindowStyleFlag()
-        if style & FNB_NO_NAV_BUTTONS:
-            return
-
+        if style & FNB_NO_NAV_BUTTONS: return
         # Make sure that there are pages in the container
-        if not pc._pagesInfoVec:
-            return
-
+        if not pc._pagesInfoVec: return
         # Set the bitmap according to the button status
-        if pc._nLeftButtonStatus == FNB_BTN_HOVER:
-            arrowBmp = wx.BitmapFromXPMData(left_arrow_hilite_xpm)
-        elif pc._nLeftButtonStatus == FNB_BTN_PRESSED:
-            arrowBmp = wx.BitmapFromXPMData(left_arrow_pressed_xpm)
-        else:
-            arrowBmp = wx.BitmapFromXPMData(left_arrow_xpm)
-
+        if pc._nLeftButtonStatus == FNB_BTN_HOVER: arrowBmp = wx.BitmapFromXPMData(left_arrow_hilite_xpm)
+        elif pc._nLeftButtonStatus == FNB_BTN_PRESSED: arrowBmp = wx.BitmapFromXPMData(left_arrow_pressed_xpm)
+        else: arrowBmp = wx.BitmapFromXPMData(left_arrow_xpm)
         if pc._nFrom == 0:
             # Handle disabled arrow
             arrowBmp = wx.BitmapFromXPMData(left_arrow_disabled_xpm)
-
         arrowBmp.SetMask(wx.Mask(arrowBmp, MASK_COLOR))
-
         # Erase old bitmap
         posx = self.GetLeftButtonPos(pc)
         self.DrawArrowAccordingToState(dc, pc, wx.Rect(posx, 6, 16, 14))
-
         # Draw the new bitmap
         dc.DrawBitmap(arrowBmp, posx, 6, True)
 
-
     def DrawRightArrow(self, pageContainer, dc):
         """ Draw the right navigation arrow. """
-
         pc = pageContainer
-
         style = pc.GetParent().GetWindowStyleFlag()
-        if style & FNB_NO_NAV_BUTTONS:
-            return
-
+        if style & FNB_NO_NAV_BUTTONS: return
         # Make sure that there are pages in the container
-        if not pc._pagesInfoVec:
-            return
+        if not pc._pagesInfoVec: return
 
         # Set the bitmap according to the button status
-        if pc._nRightButtonStatus == FNB_BTN_HOVER:
-            arrowBmp = wx.BitmapFromXPMData(right_arrow_hilite_xpm)
-        elif pc._nRightButtonStatus == FNB_BTN_PRESSED:
-            arrowBmp = wx.BitmapFromXPMData(right_arrow_pressed_xpm)
-        else:
-            arrowBmp = wx.BitmapFromXPMData(right_arrow_xpm)
+        if pc._nRightButtonStatus == FNB_BTN_HOVER: arrowBmp = wx.BitmapFromXPMData(right_arrow_hilite_xpm)
+        elif pc._nRightButtonStatus == FNB_BTN_PRESSED: arrowBmp = wx.BitmapFromXPMData(right_arrow_pressed_xpm)
+        else: arrowBmp = wx.BitmapFromXPMData(right_arrow_xpm)
 
         # Check if the right most tab is visible, if it is
         # don't rotate right anymore
         if pc._pagesInfoVec[-1].GetPosition() != wx.Point(-1, -1):
             arrowBmp = wx.BitmapFromXPMData(right_arrow_disabled_xpm)
-
         arrowBmp.SetMask(wx.Mask(arrowBmp, MASK_COLOR))
-
         # erase old bitmap
         posx = self.GetRightButtonPos(pc)
         self.DrawArrowAccordingToState(dc, pc, wx.Rect(posx, 6, 16, 14))
-
         # Draw the new bitmap
         dc.DrawBitmap(arrowBmp, posx, 6, True)
 
-
     def DrawDropDownArrow(self, pageContainer, dc):
         """ Draws the drop-down arrow in the navigation area. """
-
         pc = pageContainer
-
         # Check if this style is enabled
         style = pc.GetParent().GetWindowStyleFlag()
-        if not style & FNB_DROPDOWN_TABS_LIST:
-            return
-
+        if not style & FNB_DROPDOWN_TABS_LIST: return
         # Make sure that there are pages in the container
-        if not pc._pagesInfoVec:
-            return
-
-        if pc._nArrowDownButtonStatus == FNB_BTN_HOVER:
-            downBmp = wx.BitmapFromXPMData(down_arrow_hilite_xpm)
-        elif pc._nArrowDownButtonStatus == FNB_BTN_PRESSED:
-            downBmp = wx.BitmapFromXPMData(down_arrow_pressed_xpm)
-        else:
-            downBmp = wx.BitmapFromXPMData(down_arrow_xpm)
-
+        if not pc._pagesInfoVec: return
+        if pc._nArrowDownButtonStatus == FNB_BTN_HOVER: downBmp = wx.BitmapFromXPMData(down_arrow_hilite_xpm)
+        elif pc._nArrowDownButtonStatus == FNB_BTN_PRESSED: downBmp = wx.BitmapFromXPMData(down_arrow_pressed_xpm)
+        else: downBmp = wx.BitmapFromXPMData(down_arrow_xpm)
         downBmp.SetMask(wx.Mask(downBmp, MASK_COLOR))
-
         # erase old bitmap
         posx = self.GetDropArrowButtonPos(pc)
         self.DrawArrowAccordingToState(dc, pc, wx.Rect(posx, 6, 16, 14))
-
         # Draw the new bitmap
         dc.DrawBitmap(downBmp, posx, 6, True)
 
-
     def DrawX(self, pageContainer, dc):
         """ Draw the 'X' navigation button in the navigation area. """
-
         pc = pageContainer
-
         # Check if this style is enabled
         style = pc.GetParent().GetWindowStyleFlag()
-        if style & FNB_NO_X_BUTTON:
-            return
-
+        if style & FNB_NO_X_BUTTON: return
         # Make sure that there are pages in the container
-        if not pc._pagesInfoVec:
-            return
-
+        if not pc._pagesInfoVec: return
         # Set the bitmap according to the button status
-        if pc._nXButtonStatus == FNB_BTN_HOVER:
-            xbmp = wx.BitmapFromXPMData(x_button_hilite_xpm)
-        elif pc._nXButtonStatus == FNB_BTN_PRESSED:
-            xbmp = wx.BitmapFromXPMData(x_button_pressed_xpm)
-        else:
-            xbmp = wx.BitmapFromXPMData(x_button_xpm)
-
+        if pc._nXButtonStatus == FNB_BTN_HOVER: xbmp = wx.BitmapFromXPMData(x_button_hilite_xpm)
+        elif pc._nXButtonStatus == FNB_BTN_PRESSED: xbmp = wx.BitmapFromXPMData(x_button_pressed_xpm)
+        else: xbmp = wx.BitmapFromXPMData(x_button_xpm)
         xbmp.SetMask(wx.Mask(xbmp, MASK_COLOR))
-
         # erase old bitmap
         posx = self.GetXPos(pc)
         self.DrawArrowAccordingToState(dc, pc, wx.Rect(posx, 6, 16, 14))
-
         # Draw the new bitmap
         dc.DrawBitmap(xbmp, posx, 6, True)
 
-
     def DrawTabX(self, pageContainer, dc, rect, tabIdx, btnStatus):
         """ Draws the 'X' in the selected tab. """
-
         pc = pageContainer
-        if not pc.HasFlag(FNB_X_ON_TAB):
-            return
-
+        if not pc.HasFlag(FNB_X_ON_TAB): return
         # We draw the 'x' on the active tab only
-        if tabIdx != pc.GetSelection() or tabIdx < 0:
-            return
-
+        if tabIdx != pc.GetSelection() or tabIdx < 0: return
         # Set the bitmap according to the button status
-
-        if btnStatus == FNB_BTN_HOVER:
-            xBmp = wx.BitmapFromXPMData(x_button_hilite_xpm)
-        elif btnStatus == FNB_BTN_PRESSED:
-            xBmp = wx.BitmapFromXPMData(x_button_pressed_xpm)
-        else:
-            xBmp = wx.BitmapFromXPMData(x_button_xpm)
-
+        if btnStatus == FNB_BTN_HOVER: xBmp = wx.BitmapFromXPMData(x_button_hilite_xpm)
+        elif btnStatus == FNB_BTN_PRESSED: xBmp = wx.BitmapFromXPMData(x_button_pressed_xpm)
+        else: xBmp = wx.BitmapFromXPMData(x_button_xpm)
         # Set the masking
         xBmp.SetMask(wx.Mask(xBmp, MASK_COLOR))
-
         # Draw the new bitmap
         dc.DrawBitmap(xBmp, rect.x, rect.y, True)
-
         # Update the vector
         rr = wx.Rect(rect.x, rect.y, 14, 13)
         pc._pagesInfoVec[tabIdx].SetXRect(rr)
 
-
     def DrawTabsLine(self, pageContainer, dc, selTabX1=-1, selTabX2=-1):
         """ Draws a line over the tabs. """
-
         pc = pageContainer
-
         clntRect = pc.GetClientRect()
         clientRect3 = wx.Rect(0, 0, clntRect.width, clntRect.height)
-
         if pc.HasFlag(FNB_FF2):
-            if not pc.HasFlag(FNB_BOTTOM):
-                fillColor = wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DFACE)
-            else:
-                fillColor = wx.WHITE
-
+            if not pc.HasFlag(FNB_BOTTOM): fillColor = wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DFACE)
+            else: fillColor = wx.WHITE
             dc.SetPen(wx.Pen(fillColor))
-
             if pc.HasFlag(FNB_BOTTOM):
-
                 dc.DrawLine(1, 0, clntRect.width-1, 0)
                 dc.DrawLine(1, 1, clntRect.width-1, 1)
-
                 dc.SetPen(wx.Pen(wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNSHADOW)))
                 dc.DrawLine(1, 2, clntRect.width-1, 2)
-
                 dc.SetPen(wx.Pen(fillColor))
                 dc.DrawLine(selTabX1 + 2, 2, selTabX2 - 1, 2)
-
             else:
-
                 dc.DrawLine(1, clntRect.height, clntRect.width-1, clntRect.height)
                 dc.DrawLine(1, clntRect.height-1, clntRect.width-1, clntRect.height-1)
-
                 dc.SetPen(wx.Pen(wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNSHADOW)))
                 dc.DrawLine(1, clntRect.height-2, clntRect.width-1, clntRect.height-2)
-
                 dc.SetPen(wx.Pen(wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DFACE)))
                 dc.DrawLine(selTabX1 + 2, clntRect.height-2, selTabX2-1, clntRect.height-2)
-
         else:
 
             if pc.HasFlag(FNB_BOTTOM):
-
                 clientRect = wx.Rect(0, 2, clntRect.width, clntRect.height - 2)
                 clientRect2 = wx.Rect(0, 1, clntRect.width, clntRect.height - 1)
-
             else:
-
                 clientRect = wx.Rect(0, 0, clntRect.width, clntRect.height - 2)
                 clientRect2 = wx.Rect(0, 0, clntRect.width, clntRect.height - 1)
-
             dc.SetBrush(wx.TRANSPARENT_BRUSH)
             dc.SetPen(wx.Pen(pc.GetSingleLineBorderColour()))
             dc.DrawRectangleRect(clientRect2)
             dc.DrawRectangleRect(clientRect3)
-
             dc.SetPen(wx.Pen(wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNSHADOW)))
             dc.DrawRectangleRect(clientRect)
-
             if not pc.HasFlag(FNB_TABS_BORDER_SIMPLE):
-
                 dc.SetPen(wx.Pen((pc.HasFlag(FNB_VC71) and [wx.Colour(247, 243, 233)] or [pc._tabAreaColor])[0]))
                 dc.DrawLine(0, 0, 0, clientRect.height+1)
-
                 if pc.HasFlag(FNB_BOTTOM):
-
                     dc.DrawLine(0, clientRect.height+1, clientRect.width, clientRect.height+1)
-
                 else:
-
                     dc.DrawLine(0, 0, clientRect.width, 0)
-
                 dc.DrawLine(clientRect.width - 1, 0, clientRect.width - 1, clientRect.height+1)
 
-
     def CalcTabWidth(self, pageContainer, tabIdx, tabHeight):
         """ Calculates the width of the input tab. """
-
         pc = pageContainer
         dc = wx.MemoryDC()
         dc.SelectObject(wx.EmptyBitmap(1,1))
-
         boldFont = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)
         boldFont.SetWeight(wx.FONTWEIGHT_BOLD)
-
         if pc.IsDefaultTabs():
             shapePoints = int(tabHeight*math.tan(float(pc._pagesInfoVec[tabIdx].GetTabAngle())/180.0*math.pi))
-
         # Calculate the text length using the bold font, so when selecting a tab
         # its width will not change
         dc.SetFont(boldFont)
         width, pom = dc.GetTextExtent(pc.GetPageText(tabIdx))
-
         # Set a minimum size to a tab
-        if width < 20:
-            width = 20
-
+        if width < 20: width = 20
         tabWidth = 2*pc._pParent.GetPadding() + width
-
         # Style to add a small 'x' button on the top right
         # of the tab
         if pc.HasFlag(FNB_X_ON_TAB) and tabIdx == pc.GetSelection():
             # The xpm image that contains the 'x' button is 9 pixels
             spacer = 9
-            if pc.HasFlag(FNB_VC8):
-                spacer = 4
-
+            if pc.HasFlag(FNB_VC8): spacer = 4
             tabWidth += pc._pParent.GetPadding() + spacer
-
         if pc.IsDefaultTabs():
             # Default style
             tabWidth += 2*shapePoints
-
         hasImage = pc._ImageList != None and pc._pagesInfoVec[tabIdx].GetImageIndex() != -1
 
         # For VC71 style, we only add the icon size (16 pixels)
         if hasImage:
-
             if not pc.IsDefaultTabs():
                 tabWidth += 16 + pc._pParent.GetPadding()
             else:
                 # Default style
                 tabWidth += 16 + pc._pParent.GetPadding() + shapePoints/2
-
         return tabWidth
 
-
     def CalcTabHeight(self, pageContainer):
         """ Calculates the height of the input tab. """
-
         if self._tabHeight:
             return self._tabHeight
-
         pc = pageContainer
         dc = wx.MemoryDC()
         dc.SelectObject(wx.EmptyBitmap(1,1))
-
         # For GTK it seems that we must do this steps in order
         # for the tabs will get the proper height on initialization
         # on MSW, preforming these steps yields wierd results
         normalFont = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)
         boldFont = normalFont
-
         if "__WXGTK__" in wx.PlatformInfo:
             boldFont.SetWeight(wx.FONTWEIGHT_BOLD)
             dc.SetFont(boldFont)
-
         height = dc.GetCharHeight()
-
         tabHeight = height + FNB_HEIGHT_SPACER # We use 8 pixels as padding
         if "__WXGTK__" in wx.PlatformInfo:
             # On GTK the tabs are should be larger
             tabHeight += 6
-
         self._tabHeight = tabHeight
-
         return tabHeight
 
-
     def DrawTabs(self, pageContainer, dc):
         """ Actually draws the tabs in L{FlatNotebook}."""
-
         pc = pageContainer
         if "__WXMAC__" in wx.PlatformInfo:
             # Works well on MSW & GTK, however this lines should be skipped on MAC
@@ -1718,23 +1392,16 @@
         # Get the text hight
         tabHeight = self.CalcTabHeight(pageContainer)
         style = pc.GetParent().GetWindowStyleFlag()
-
         # Calculate the number of rows required for drawing the tabs
         rect = pc.GetClientRect()
         clientWidth = rect.width
-
         # Set the maximum client size
         pc.SetSizeHints(self.GetButtonsAreaLength(pc), tabHeight)
         borderPen = wx.Pen(wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNSHADOW))
-
-        if style & FNB_VC71:
-            backBrush = wx.Brush(wx.Colour(247, 243, 233))
-        else:
-            backBrush = wx.Brush(pc._tabAreaColor)
-
+        if style & FNB_VC71: backBrush = wx.Brush(wx.Colour(247, 243, 233))
+        else: backBrush = wx.Brush(pc._tabAreaColor)
         noselBrush = wx.Brush(wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNFACE))
         selBrush = wx.Brush(pc._activeTabColor)
-
         size = pc.GetSize()
 
         # Background
@@ -1748,29 +1415,23 @@
         else:
             colr = (pc.HasFlag(FNB_VC71) and [wx.Colour(247, 243, 233)] or [pc.GetBackgroundColour()])[0]
             dc.SetPen(wx.Pen(colr))
-
         if pc.HasFlag(FNB_FF2):
             lightFactor = (pc.HasFlag(FNB_BACKGROUND_GRADIENT) and [70] or [0])[0]
             PaintStraightGradientBox(dc, pc.GetClientRect(), pc._tabAreaColor, LightColour(pc._tabAreaColor, lightFactor))
             dc.SetBrush(wx.TRANSPARENT_BRUSH)
-
         dc.DrawRectangle(0, 0, size.x, size.y)
 
         # We always draw the bottom/upper line of the tabs
         # regradless the style
         dc.SetPen(borderPen)
-
         if not pc.HasFlag(FNB_FF2):
             self.DrawTabsLine(pc, dc)
 
         # Restore the pen
         dc.SetPen(borderPen)
-
         if pc.HasFlag(FNB_VC71):
-
             greyLineYVal  = (pc.HasFlag(FNB_BOTTOM) and [0] or [size.y - 2])[0]
             whiteLineYVal = (pc.HasFlag(FNB_BOTTOM) and [3] or [size.y - 3])[0]
-
             pen = wx.Pen(wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DFACE))
             dc.SetPen(pen)
 
@@ -1778,7 +1439,6 @@
             # the tab area
             for num in xrange(3):
                 dc.DrawLine(0, greyLineYVal + num, size.x, greyLineYVal + num)
-
             wbPen = (pc.HasFlag(FNB_BOTTOM) and [wx.BLACK_PEN] or [wx.WHITE_PEN])[0]
             dc.SetPen(wbPen)
             dc.DrawLine(1, whiteLineYVal, size.x - 1, whiteLineYVal)
@@ -1791,69 +1451,55 @@
         boldFont = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)
         boldFont.SetWeight(wx.FONTWEIGHT_BOLD)
         dc.SetFont(boldFont)
-
         posx = pc._pParent.GetPadding()
 
         # Update all the tabs from 0 to 'pc._nFrom' to be non visible
         for i in xrange(pc._nFrom):
-
             pc._pagesInfoVec[i].SetPosition(wx.Point(-1, -1))
             pc._pagesInfoVec[i].GetRegion().Clear()
-
         count = pc._nFrom
 
-        #----------------------------------------------------------
+        """
         # Go over and draw the visible tabs
-        #----------------------------------------------------------
+        """
         x1 = x2 = -1
         for i in xrange(pc._nFrom, len(pc._pagesInfoVec)):
-
             dc.SetPen(borderPen)
-
             if not pc.HasFlag(FNB_FF2):
                 dc.SetBrush((i==pc.GetSelection() and [selBrush] or [noselBrush])[0])
 
             # Now set the font to the correct font
             dc.SetFont((i==pc.GetSelection() and [boldFont] or [normalFont])[0])
-
+            """
             # Add the padding to the tab width
             # Tab width:
             # +-----------------------------------------------------------+
             # | PADDING | IMG | IMG_PADDING | TEXT | PADDING | x |PADDING |
             # +-----------------------------------------------------------+
+            """
             tabWidth = self.CalcTabWidth(pageContainer, i, tabHeight)
-
             # Check if we can draw more
-            if posx + tabWidth + self.GetButtonsAreaLength(pc) >= clientWidth:
-                break
-
+            if posx + tabWidth + self.GetButtonsAreaLength(pc) >= clientWidth: break
             count = count + 1
-
             # By default we clean the tab region
             pc._pagesInfoVec[i].GetRegion().Clear()
-
             # Clean the 'x' buttn on the tab.
             # A 'Clean' rectangle, is a rectangle with width or height
             # with values lower than or equal to 0
             pc._pagesInfoVec[i].GetXRect().SetSize(wx.Size(-1, -1))
-
             # Draw the tab (border, text, image & 'x' on tab)
             self.DrawTab(pc, dc, posx, i, tabWidth, tabHeight, pc._nTabXButtonStatus)
-
             if pc.GetSelection() == i:
                 x1 = posx
                 x2 = posx + tabWidth + 2
 
             # Restore the text forground
             dc.SetTextForeground(pc._activeTextColor)
-
             # Update the tab position & size
             posy = (pc.HasFlag(FNB_BOTTOM) and [0] or [VERTICAL_BORDER_PADDING])[0]
-
             pc._pagesInfoVec[i].SetPosition(wx.Point(posx, posy))
             pc._pagesInfoVec[i].SetSize(wx.Size(tabWidth, tabHeight))
             self.DrawFocusRectangle(dc, pc, pc._pagesInfoVec[i])
-
             posx += tabWidth
 
         # Update all tabs that can not fit into the screen as non-visible
@@ -1867,92 +1513,66 @@
         self.DrawRightArrow(pc, dc)
         self.DrawX(pc, dc)
         self.DrawDropDownArrow(pc, dc)
-
-        if pc.HasFlag(FNB_FF2):
-            self.DrawTabsLine(pc, dc, x1, x2)
-
+        if pc.HasFlag(FNB_FF2): self.DrawTabsLine(pc, dc, x1, x2)
 
     def DrawFocusRectangle(self, dc, pageContainer, page):
         """ Draws a focus rectangle like the native Notebooks. """
-
         if not page._hasFocus:
             return
-
         tabPos = wx.Point(*page.GetPosition())
         if pageContainer.GetParent().GetWindowStyleFlag() & FNB_VC8:
             vc8ShapeLen = self.CalcTabHeight(pageContainer) - VERTICAL_BORDER_PADDING - 2
             tabPos.x += vc8ShapeLen
-
         rect = wx.RectPS(tabPos, page.GetSize())
         rect = wx.Rect(rect.x+2, rect.y+2, rect.width-4, rect.height-8)
-
         if wx.Platform == '__WXMAC__':
             rect.SetWidth(rect.GetWidth() + 1)
-
         dc.SetBrush(wx.TRANSPARENT_BRUSH)
         dc.SetPen(self._focusPen)
         dc.DrawRoundedRectangleRect(rect, 2)
 
-
     def DrawDragHint(self, pc, tabIdx):
         """
         Draws tab drag hint, the default implementation is to do nothing.
         You can override this function to provide a nice feedback to user.
         """
-
         pass
 
 
     def NumberTabsCanFit(self, pageContainer, fr=-1):
-
         pc = pageContainer
-
         rect = pc.GetClientRect()
         clientWidth = rect.width
-
         vTabInfo = []
-
         tabHeight = self.CalcTabHeight(pageContainer)
-
         # The drawing starts from posx
         posx = pc._pParent.GetPadding()
-
-        if fr < 0:
-            fr = pc._nFrom
-
+        if fr < 0: fr = pc._nFrom
         for i in xrange(fr, len(pc._pagesInfoVec)):
-
             tabWidth = self.CalcTabWidth(pageContainer, i, tabHeight)
             if posx + tabWidth + self.GetButtonsAreaLength(pc) >= clientWidth:
                 break;
-
             # Add a result to the returned vector
             tabRect = wx.Rect(posx, VERTICAL_BORDER_PADDING, tabWidth , tabHeight)
             vTabInfo.append(tabRect)
-
             # Advance posx
             posx += tabWidth + FNB_HEIGHT_SPACER
-
         return vTabInfo
 
 
-# ---------------------------------------------------------------------------- #
+"""
 # Class FNBRendererMgr
 # A manager that handles all the renderers defined below and calls the
 # appropriate one when drawing is needed
-# ---------------------------------------------------------------------------- #
-
+"""
 class FNBRendererMgr:
     """
     This class represents a manager that handles all the 4 renderers defined
     and calls the appropriate one when drawing is needed.
     """
-
     def __init__(self):
         """ Default class constructor. """
-
         # register renderers
-
         self._renderers = {}
         self._renderers.update({-1: FNBRendererDefault()})
         self._renderers.update({FNB_VC71: FNBRendererVC71()})
@@ -1960,99 +1580,69 @@
         self._renderers.update({FNB_VC8: FNBRendererVC8()})
         self._renderers.update({FNB_FF2: FNBRendererFirefox2()})
 
-
     def GetRenderer(self, style):
         """ Returns the current renderer based on the style selected. """
-
-        if style & FNB_VC71:
-            return self._renderers[FNB_VC71]
-
-        if style & FNB_FANCY_TABS:
-            return self._renderers[FNB_FANCY_TABS]
-
-        if style & FNB_VC8:
-            return self._renderers[FNB_VC8]
-
-        if style & FNB_FF2:
-            return self._renderers[FNB_FF2]
-
+        if style & FNB_VC71: return self._renderers[FNB_VC71]
+        if style & FNB_FANCY_TABS: return self._renderers[FNB_FANCY_TABS]
+        if style & FNB_VC8: return self._renderers[FNB_VC8]
+        if style & FNB_FF2: return self._renderers[FNB_FF2]
         # the default is to return the default renderer
         return self._renderers[-1]
 
 
-#------------------------------------------
+"""
 # Default renderer
-#------------------------------------------
-
+"""
 class FNBRendererDefault(FNBRenderer):
     """
     This class handles the drawing of tabs using the I{Standard} renderer.
     """
-
     def __init__(self):
         """ Default class constructor. """
-
         FNBRenderer.__init__(self)
 
-
     def DrawTab(self, pageContainer, dc, posx, tabIdx, tabWidth, tabHeight, btnStatus):
         """ Draws a tab using the I{Standard} style. """
-
         # Default style
         borderPen = wx.Pen(wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNSHADOW))
         pc = pageContainer
-
         tabPoints = [wx.Point() for ii in xrange(7)]
         tabPoints[0].x = posx
         tabPoints[0].y = (pc.HasFlag(FNB_BOTTOM) and [2] or [tabHeight - 2])[0]
-
         tabPoints[1].x = int(posx+(tabHeight-2)*math.tan(float(pc._pagesInfoVec[tabIdx].GetTabAngle())/180.0*math.pi))
         tabPoints[1].y = (pc.HasFlag(FNB_BOTTOM) and [tabHeight - (VERTICAL_BORDER_PADDING+2)] or [(VERTICAL_BORDER_PADDING+2)])[0]
-
         tabPoints[2].x = tabPoints[1].x+2
         tabPoints[2].y = (pc.HasFlag(FNB_BOTTOM) and [tabHeight - VERTICAL_BORDER_PADDING] or [VERTICAL_BORDER_PADDING])[0]
-
         tabPoints[3].x = int(posx+tabWidth-(tabHeight-2)*math.tan(float(pc._pagesInfoVec[tabIdx].GetTabAngle())/180.0*math.pi))-2
         tabPoints[3].y = (pc.HasFlag(FNB_BOTTOM) and [tabHeight - VERTICAL_BORDER_PADDING] or [VERTICAL_BORDER_PADDING])[0]
-
         tabPoints[4].x = tabPoints[3].x+2
         tabPoints[4].y = (pc.HasFlag(FNB_BOTTOM) and [tabHeight - (VERTICAL_BORDER_PADDING+2)] or [(VERTICAL_BORDER_PADDING+2)])[0]
-
         tabPoints[5].x = int(tabPoints[4].x+(tabHeight-2)*math.tan(float(pc._pagesInfoVec[tabIdx].GetTabAngle())/180.0*math.pi))
         tabPoints[5].y = (pc.HasFlag(FNB_BOTTOM) and [2] or [tabHeight - 2])[0]
-
         tabPoints[6].x = tabPoints[0].x
         tabPoints[6].y = tabPoints[0].y
-
         if tabIdx == pc.GetSelection():
-
             # Draw the tab as rounded rectangle
             dc.DrawPolygon(tabPoints)
-
         else:
-
             if tabIdx != pc.GetSelection() - 1:
-
                 # Draw a vertical line to the right of the text
                 pt1x = tabPoints[5].x
                 pt1y = (pc.HasFlag(FNB_BOTTOM) and [4] or [tabHeight - 6])[0]
                 pt2x = tabPoints[5].x
                 pt2y = (pc.HasFlag(FNB_BOTTOM) and [tabHeight - 4] or [4])[0]
                 dc.DrawLine(pt1x, pt1y, pt2x, pt2y)
-
         if tabIdx == pc.GetSelection():
-
             savePen = dc.GetPen()
             whitePen = wx.Pen(wx.WHITE)
             whitePen.SetWidth(1)
             dc.SetPen(whitePen)
-
             secPt = wx.Point(tabPoints[5].x + 1, tabPoints[5].y)
             dc.DrawLine(tabPoints[0].x, tabPoints[0].y, secPt.x, secPt.y)
-
             # Restore the pen
             dc.SetPen(savePen)
 
+        """
         # -----------------------------------
         # Text and image drawing
         # -----------------------------------
@@ -2061,211 +1651,236 @@
         # rectangle
 
         # The width of the images are 16 pixels
+        """
         padding = pc.GetParent().GetPadding()
         shapePoints = int(tabHeight*math.tan(float(pc._pagesInfoVec[tabIdx].GetTabAngle())/180.0*math.pi))
         hasImage = pc._pagesInfoVec[tabIdx].GetImageIndex() != -1
         imageYCoord = (pc.HasFlag(FNB_BOTTOM) and [6] or [8])[0]
 
-        if hasImage:
-            textOffset = 2*pc._pParent._nPadding + 16 + shapePoints/2
-        else:
-            textOffset = pc._pParent._nPadding + shapePoints/2
-
+        if hasImage: textOffset = 2*pc._pParent._nPadding + 16 + shapePoints/2
+        else: textOffset = pc._pParent._nPadding + shapePoints/2
         textOffset += 2
-
         if tabIdx != pc.GetSelection():
-
             # Set the text background to be like the vertical lines
             dc.SetTextForeground(pc._pParent.GetNonActiveTabTextColour())
-
         if hasImage:
-
             imageXOffset = textOffset - 16 - padding
             pc._ImageList.Draw(pc._pagesInfoVec[tabIdx].GetImageIndex(), dc,
                                      posx + imageXOffset, imageYCoord,
                                      wx.IMAGELIST_DRAW_TRANSPARENT, True)
-
         dc.DrawText(pc.GetPageText(tabIdx), posx + textOffset, imageYCoord)
-
         # draw 'x' on tab (if enabled)
         if pc.HasFlag(FNB_X_ON_TAB) and tabIdx == pc.GetSelection():
-
             textWidth, textHeight = dc.GetTextExtent(pc.GetPageText(tabIdx))
             tabCloseButtonXCoord = posx + textOffset + textWidth + 1
-
             # take a bitmap from the position of the 'x' button (the x on tab button)
             # this bitmap will be used later to delete old buttons
             tabCloseButtonYCoord = imageYCoord
             x_rect = wx.Rect(tabCloseButtonXCoord, tabCloseButtonYCoord, 16, 16)
-
             # Draw the tab
             self.DrawTabX(pc, dc, x_rect, tabIdx, btnStatus)
 
 
-#------------------------------------------
+"""
 # Firefox2 renderer
-#------------------------------------------
+"""
 class FNBRendererFirefox2(FNBRenderer):
     """
     This class handles the drawing of tabs using the I{Firefox 2} renderer.
     """
-
     def __init__(self):
         """ Default class constructor. """
-
         FNBRenderer.__init__(self)
 
-
     def DrawTab(self, pageContainer, dc, posx, tabIdx, tabWidth, tabHeight, btnStatus):
         """ Draws a tab using the I{Firefox 2} style. """
-
         borderPen = wx.Pen(wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNSHADOW))
         pc = pageContainer
-
         tabPoints = [wx.Point() for indx in xrange(7)]
         tabPoints[0].x = posx + 2
         tabPoints[0].y = (pc.HasFlag(FNB_BOTTOM) and [2] or [tabHeight - 2])[0]
-
         tabPoints[1].x = tabPoints[0].x
         tabPoints[1].y = (pc.HasFlag(FNB_BOTTOM) and [tabHeight - (VERTICAL_BORDER_PADDING+2)] or [(VERTICAL_BORDER_PADDING+2)])[0]
-
         tabPoints[2].x = tabPoints[1].x+2
         tabPoints[2].y = (pc.HasFlag(FNB_BOTTOM) and [tabHeight - VERTICAL_BORDER_PADDING] or [VERTICAL_BORDER_PADDING])[0]
-
         tabPoints[3].x = posx + tabWidth - 2
         tabPoints[3].y = (pc.HasFlag(FNB_BOTTOM) and [tabHeight - VERTICAL_BORDER_PADDING] or [VERTICAL_BORDER_PADDING])[0]
-
         tabPoints[4].x = tabPoints[3].x + 2
         tabPoints[4].y = (pc.HasFlag(FNB_BOTTOM) and [tabHeight - (VERTICAL_BORDER_PADDING+2)] or [(VERTICAL_BORDER_PADDING+2)])[0]
-
         tabPoints[5].x = tabPoints[4].x
         tabPoints[5].y = (pc.HasFlag(FNB_BOTTOM) and [2] or [tabHeight - 2])[0]
-
         tabPoints[6].x = tabPoints[0].x
         tabPoints[6].y = tabPoints[0].y
 
-        #------------------------------------
+        """
         # Paint the tab with gradient
-        #------------------------------------
+        """
         rr = wx.RectPP(tabPoints[2], tabPoints[5])
         DrawButton(dc, rr, pc.GetSelection() == tabIdx , not pc.HasFlag(FNB_BOTTOM))
-
         dc.SetBrush(wx.TRANSPARENT_BRUSH)
         dc.SetPen(borderPen)
-
         # Draw the tab as rounded rectangle
         dc.DrawPolygon(tabPoints)
-
-        # -----------------------------------
+        """
         # Text and image drawing
-        # -----------------------------------
-
+        """
         # The width of the images are 16 pixels
         padding = pc.GetParent().GetPadding()
         shapePoints = int(tabHeight*math.tan(float(pc._pagesInfoVec[tabIdx].GetTabAngle())/180.0*math.pi))
         hasImage = pc._pagesInfoVec[tabIdx].GetImageIndex() != -1
         imageYCoord = (pc.HasFlag(FNB_BOTTOM) and [6] or [8])[0]
-
-        if hasImage:
-            textOffset = 2*padding + 16 + shapePoints/2
-        else:
-            textOffset = padding + shapePoints/2
-
+        if hasImage: textOffset = 2*padding + 16 + shapePoints/2
+        else: textOffset = padding + shapePoints/2
         textOffset += 2
-
         if tabIdx != pc.GetSelection():
-
             # Set the text background to be like the vertical lines
             dc.SetTextForeground(pc._pParent.GetNonActiveTabTextColour())
-
         if hasImage:
             imageXOffset = textOffset - 16 - padding
             pc._ImageList.Draw(pc._pagesInfoVec[tabIdx].GetImageIndex(), dc,
                                posx + imageXOffset, imageYCoord,
                                wx.IMAGELIST_DRAW_TRANSPARENT, True)
-
         dc.DrawText(pc.GetPageText(tabIdx), posx + textOffset, imageYCoord)
-
         # draw 'x' on tab (if enabled)
         if pc.HasFlag(FNB_X_ON_TAB) and tabIdx == pc.GetSelection():
-
             textWidth, textHeight = dc.GetTextExtent(pc.GetPageText(tabIdx))
             tabCloseButtonXCoord = posx + textOffset + textWidth + 1
-
             # take a bitmap from the position of the 'x' button (the x on tab button)
             # this bitmap will be used later to delete old buttons
             tabCloseButtonYCoord = imageYCoord
             x_rect = wx.Rect(tabCloseButtonXCoord, tabCloseButtonYCoord, 16, 16)
-
             # Draw the tab
             self.DrawTabX(pc, dc, x_rect, tabIdx, btnStatus)
 
 
-#------------------------------------------------------------------
+"""
 # Visual studio 7.1
-#------------------------------------------------------------------
-
+"""
 class FNBRendererVC71(FNBRenderer):
     """
     This class handles the drawing of tabs using the I{VC71} renderer.
     """
-
     def __init__(self):
         """ Default class constructor. """
-
         FNBRenderer.__init__(self)
 
-
     def DrawTab(self, pageContainer, dc, posx, tabIdx, tabWidth, tabHeight, btnStatus):
         """ Draws a tab using the I{VC71} style. """
-
         # Visual studio 7.1 style
         borderPen = wx.Pen(wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNSHADOW))
         pc = pageContainer
 
         dc.SetPen((tabIdx == pc.GetSelection() and [wx.Pen(wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DFACE))] or [borderPen])[0])
         dc.SetBrush((tabIdx == pc.GetSelection() and [wx.Brush(wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DFACE))] or [wx.Brush(wx.Colour(247, 243, 233))])[0])
-
         if tabIdx == pc.GetSelection():
-
             posy = (pc.HasFlag(FNB_BOTTOM) and [0] or [VERTICAL_BORDER_PADDING])[0]
             tabH = (pc.HasFlag(FNB_BOTTOM) and [tabHeight - 5] or [tabHeight - 3])[0]
             dc.DrawRectangle(posx, posy, tabWidth, tabH)
-
             # Draw a black line on the left side of the
             # rectangle
             dc.SetPen(wx.BLACK_PEN)
-
             blackLineY1 = VERTICAL_BORDER_PADDING
             blackLineY2 = tabH
             dc.DrawLine(posx + tabWidth, blackLineY1, posx + tabWidth, blackLineY2)
-
+            """
             # To give the tab more 3D look we do the following
             # Incase the tab is on top,
             # Draw a thik white line on topof the rectangle
             # Otherwise, draw a thin (1 pixel) black line at the bottom
-
+            """
             pen = wx.Pen((pc.HasFlag(FNB_BOTTOM) and [wx.BLACK] or [wx.WHITE])[0])
             dc.SetPen(pen)
             whiteLinePosY = (pc.HasFlag(FNB_BOTTOM) and [blackLineY2] or [VERTICAL_BORDER_PADDING ])[0]
             dc.DrawLine(posx , whiteLinePosY, posx + tabWidth + 1, whiteLinePosY)
-
             # Draw a white vertical line to the left of the tab
             dc.SetPen(wx.WHITE_PEN)
             if not pc.HasFlag(FNB_BOTTOM):
                 blackLineY2 += 1
-
             dc.DrawLine(posx, blackLineY1, posx, blackLineY2)
-
         else:
 
             # We dont draw a rectangle for non selected tabs, but only
             # vertical line on the left
-
             blackLineY1 = (pc.HasFlag(FNB_BOTTOM) and [VERTICAL_BORDER_PADDING + 2] or [VERTICAL_BORDER_PADDING + 1])[0]
             blackLineY2 = pc.GetSize().y - 5
             dc.DrawLine(posx + tabWidth, blackLineY1, posx + tabWidth, blackLineY2)
-
+        """
+        # -----------------------------------
+        # Text and image drawing
+        # -----------------------------------
+        """
+        # Text drawing offset from the left border of the
+        # rectangle
+
+        # The width of the images are 16 pixels
+        padding = pc.GetParent().GetPadding()
+        hasImage = pc._pagesInfoVec[tabIdx].GetImageIndex() != -1
+        imageYCoord = (pc.HasFlag(FNB_BOTTOM) and [5] or [8])[0]
+
+        if hasImage: textOffset = 2*pc._pParent._nPadding + 16
+        else: textOffset = pc._pParent._nPadding
+        if tabIdx != pc.GetSelection():
+            # Set the text background to be like the vertical lines
+            dc.SetTextForeground(pc._pParent.GetNonActiveTabTextColour())
+        if hasImage:
+            imageXOffset = textOffset - 16 - padding
+            pc._ImageList.Draw(pc._pagesInfoVec[tabIdx].GetImageIndex(), dc,
+                                     posx + imageXOffset, imageYCoord,
+                                     wx.IMAGELIST_DRAW_TRANSPARENT, True)
+        dc.DrawText(pc.GetPageText(tabIdx), posx + textOffset, imageYCoord)
+
+        # draw 'x' on tab (if enabled)
+        if pc.HasFlag(FNB_X_ON_TAB) and tabIdx == pc.GetSelection():
+            textWidth, textHeight = dc.GetTextExtent(pc.GetPageText(tabIdx))
+            tabCloseButtonXCoord = posx + textOffset + textWidth + 1
+            # take a bitmap from the position of the 'x' button (the x on tab button)
+            # this bitmap will be used later to delete old buttons
+            tabCloseButtonYCoord = imageYCoord
+            x_rect = wx.Rect(tabCloseButtonXCoord, tabCloseButtonYCoord, 16, 16)
+            # Draw the tab
+            self.DrawTabX(pc, dc, x_rect, tabIdx, btnStatus)
+
+
+"""
+# Fancy style
+"""
+class FNBRendererFancy(FNBRenderer):
+    """
+    This class handles the drawing of tabs using the I{Fancy} renderer.
+    """
+    def __init__(self):
+        """ Default class constructor. """
+        FNBRenderer.__init__(self)
+
+    def DrawTab(self, pageContainer, dc, posx, tabIdx, tabWidth, tabHeight, btnStatus):
+        """ Draws a tab using the I{Fancy} style, similar to VC71 but with gradients. """
+        # Fancy tabs - like with VC71 but with the following differences:
+        # - The Selected tab is colored with gradient color
+        borderPen = wx.Pen(wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNSHADOW))
+        pc = pageContainer
+        pen = (tabIdx == pc.GetSelection() and [wx.Pen(pc._pParent.GetBorderColour())] or [wx.Pen(wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DFACE))])[0]
+
+        if tabIdx == pc.GetSelection():
+            posy = (pc.HasFlag(FNB_BOTTOM) and [2] or [VERTICAL_BORDER_PADDING])[0]
+            th = tabHeight - 5
+            rect = wx.Rect(posx, posy, tabWidth, th)
+            col2 = (pc.HasFlag(FNB_BOTTOM) and [pc._pParent.GetGradientColourTo()] or [pc._pParent.GetGradientColourFrom()])[0]
+            col1 = (pc.HasFlag(FNB_BOTTOM) and [pc._pParent.GetGradientColourFrom()] or [pc._pParent.GetGradientColourTo()])[0]
+            PaintStraightGradientBox(dc, rect, col1, col2)
+            dc.SetBrush(wx.TRANSPARENT_BRUSH)
+            dc.SetPen(pen)
+            dc.DrawRectangleRect(rect)
+
+            # erase the bottom/top line of the rectangle
+            dc.SetPen(wx.Pen(pc._pParent.GetGradientColourFrom()))
+            if pc.HasFlag(FNB_BOTTOM): dc.DrawLine(rect.x, 2, rect.x + rect.width, 2)
+            else: dc.DrawLine(rect.x, rect.y + rect.height - 1, rect.x + rect.width, rect.y + rect.height - 1)
+        else:
+            # We dont draw a rectangle for non selected tabs, but only
+            # vertical line on the left
+            dc.SetPen(borderPen)
+            dc.DrawLine(posx + tabWidth, VERTICAL_BORDER_PADDING + 3, posx + tabWidth, tabHeight - 4)
+        """
         # -----------------------------------
         # Text and image drawing
         # -----------------------------------
@@ -2274,303 +1889,157 @@
         # rectangle
 
         # The width of the images are 16 pixels
+        """
         padding = pc.GetParent().GetPadding()
         hasImage = pc._pagesInfoVec[tabIdx].GetImageIndex() != -1
-        imageYCoord = (pc.HasFlag(FNB_BOTTOM) and [5] or [8])[0]
-
-        if hasImage:
-            textOffset = 2*pc._pParent._nPadding + 16
-        else:
-            textOffset = pc._pParent._nPadding
-
+        imageYCoord = (pc.HasFlag(FNB_BOTTOM) and [6] or [8])[0]
+
+        if hasImage: textOffset = 2*pc._pParent._nPadding + 16
+        else: textOffset = pc._pParent._nPadding
+        textOffset += 2
         if tabIdx != pc.GetSelection():
-
             # Set the text background to be like the vertical lines
             dc.SetTextForeground(pc._pParent.GetNonActiveTabTextColour())
-
         if hasImage:
-
             imageXOffset = textOffset - 16 - padding
             pc._ImageList.Draw(pc._pagesInfoVec[tabIdx].GetImageIndex(), dc,
                                      posx + imageXOffset, imageYCoord,
                                      wx.IMAGELIST_DRAW_TRANSPARENT, True)
-
         dc.DrawText(pc.GetPageText(tabIdx), posx + textOffset, imageYCoord)
-
         # draw 'x' on tab (if enabled)
         if pc.HasFlag(FNB_X_ON_TAB) and tabIdx == pc.GetSelection():
-
             textWidth, textHeight = dc.GetTextExtent(pc.GetPageText(tabIdx))
             tabCloseButtonXCoord = posx + textOffset + textWidth + 1
-
             # take a bitmap from the position of the 'x' button (the x on tab button)
             # this bitmap will be used later to delete old buttons
             tabCloseButtonYCoord = imageYCoord
             x_rect = wx.Rect(tabCloseButtonXCoord, tabCloseButtonYCoord, 16, 16)
-
             # Draw the tab
             self.DrawTabX(pc, dc, x_rect, tabIdx, btnStatus)
 
 
-#------------------------------------------------------------------
-# Fancy style
-#------------------------------------------------------------------
-
-class FNBRendererFancy(FNBRenderer):
-    """
-    This class handles the drawing of tabs using the I{Fancy} renderer.
-    """
-
-    def __init__(self):
-        """ Default class constructor. """
-
-        FNBRenderer.__init__(self)
-
-
-    def DrawTab(self, pageContainer, dc, posx, tabIdx, tabWidth, tabHeight, btnStatus):
-        """ Draws a tab using the I{Fancy} style, similar to VC71 but with gradients. """
-
-        # Fancy tabs - like with VC71 but with the following differences:
-        # - The Selected tab is colored with gradient color
-        borderPen = wx.Pen(wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNSHADOW))
-        pc = pageContainer
-
-        pen = (tabIdx == pc.GetSelection() and [wx.Pen(pc._pParent.GetBorderColour())] or [wx.Pen(wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DFACE))])[0]
-
-        if tabIdx == pc.GetSelection():
-
-            posy = (pc.HasFlag(FNB_BOTTOM) and [2] or [VERTICAL_BORDER_PADDING])[0]
-            th = tabHeight - 5
-
-            rect = wx.Rect(posx, posy, tabWidth, th)
-
-            col2 = (pc.HasFlag(FNB_BOTTOM) and [pc._pParent.GetGradientColourTo()] or [pc._pParent.GetGradientColourFrom()])[0]
-            col1 = (pc.HasFlag(FNB_BOTTOM) and [pc._pParent.GetGradientColourFrom()] or [pc._pParent.GetGradientColourTo()])[0]
-
-            PaintStraightGradientBox(dc, rect, col1, col2)
-            dc.SetBrush(wx.TRANSPARENT_BRUSH)
-            dc.SetPen(pen)
-            dc.DrawRectangleRect(rect)
-
-            # erase the bottom/top line of the rectangle
-            dc.SetPen(wx.Pen(pc._pParent.GetGradientColourFrom()))
-            if pc.HasFlag(FNB_BOTTOM):
-                dc.DrawLine(rect.x, 2, rect.x + rect.width, 2)
-            else:
-                dc.DrawLine(rect.x, rect.y + rect.height - 1, rect.x + rect.width, rect.y + rect.height - 1)
-
-        else:
-
-            # We dont draw a rectangle for non selected tabs, but only
-            # vertical line on the left
-            dc.SetPen(borderPen)
-            dc.DrawLine(posx + tabWidth, VERTICAL_BORDER_PADDING + 3, posx + tabWidth, tabHeight - 4)
-
-
-        # -----------------------------------
-        # Text and image drawing
-        # -----------------------------------
-
-        # Text drawing offset from the left border of the
-        # rectangle
-
-        # The width of the images are 16 pixels
-        padding = pc.GetParent().GetPadding()
-        hasImage = pc._pagesInfoVec[tabIdx].GetImageIndex() != -1
-        imageYCoord = (pc.HasFlag(FNB_BOTTOM) and [6] or [8])[0]
-
-        if hasImage:
-            textOffset = 2*pc._pParent._nPadding + 16
-        else:
-            textOffset = pc._pParent._nPadding
-
-        textOffset += 2
-
-        if tabIdx != pc.GetSelection():
-
-            # Set the text background to be like the vertical lines
-            dc.SetTextForeground(pc._pParent.GetNonActiveTabTextColour())
-
-        if hasImage:
-
-            imageXOffset = textOffset - 16 - padding
-            pc._ImageList.Draw(pc._pagesInfoVec[tabIdx].GetImageIndex(), dc,
-                                     posx + imageXOffset, imageYCoord,
-                                     wx.IMAGELIST_DRAW_TRANSPARENT, True)
-
-        dc.DrawText(pc.GetPageText(tabIdx), posx + textOffset, imageYCoord)
-
-        # draw 'x' on tab (if enabled)
-        if pc.HasFlag(FNB_X_ON_TAB) and tabIdx == pc.GetSelection():
-
-            textWidth, textHeight = dc.GetTextExtent(pc.GetPageText(tabIdx))
-            tabCloseButtonXCoord = posx + textOffset + textWidth + 1
-
-            # take a bitmap from the position of the 'x' button (the x on tab button)
-            # this bitmap will be used later to delete old buttons
-            tabCloseButtonYCoord = imageYCoord
-            x_rect = wx.Rect(tabCloseButtonXCoord, tabCloseButtonYCoord, 16, 16)
-
-            # Draw the tab
-            self.DrawTabX(pc, dc, x_rect, tabIdx, btnStatus)
-
-
-#------------------------------------------------------------------
+"""
 # Visual studio 2005 (VS8)
-#------------------------------------------------------------------
+"""
 class FNBRendererVC8(FNBRenderer):
     """
     This class handles the drawing of tabs using the I{VC8} renderer.
     """
-
     def __init__(self):
         """ Default class constructor. """
-
         FNBRenderer.__init__(self)
         self._first = True
         self._factor = 1
 
-
     def DrawTabs(self, pageContainer, dc):
         """ Draws all the tabs using VC8 style. Overloads The DrawTabs method in parent class. """
-
         pc = pageContainer
-
         if "__WXMAC__" in wx.PlatformInfo:
             # Works well on MSW & GTK, however this lines should be skipped on MAC
             if not pc._pagesInfoVec or pc._nFrom >= len(pc._pagesInfoVec):
                 pc.Hide()
                 return
-
         # Get the text hight
         tabHeight = self.CalcTabHeight(pageContainer)
-
         # Set the font for measuring the tab height
         normalFont = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)
         boldFont = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)
         boldFont.SetWeight(wx.FONTWEIGHT_BOLD)
-
         # Calculate the number of rows required for drawing the tabs
         rect = pc.GetClientRect()
-
         # Set the maximum client size
         pc.SetSizeHints(self.GetButtonsAreaLength(pc), tabHeight)
         borderPen = wx.Pen(wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNSHADOW))
-
         # Create brushes
         backBrush = wx.Brush(pc._tabAreaColor)
         noselBrush = wx.Brush(wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNFACE))
         selBrush = wx.Brush(pc._activeTabColor)
         size = pc.GetSize()
-
         # Background
         dc.SetTextBackground(pc.GetBackgroundColour())
         dc.SetTextForeground(pc._activeTextColor)
-
         # If border style is set, set the pen to be border pen
-        if pc.HasFlag(FNB_TABS_BORDER_SIMPLE):
-            dc.SetPen(borderPen)
-        else:
-            dc.SetPen(wx.TRANSPARENT_PEN)
-
+        if pc.HasFlag(FNB_TABS_BORDER_SIMPLE): dc.SetPen(borderPen)
+        else: dc.SetPen(wx.TRANSPARENT_PEN)
         lightFactor = (pc.HasFlag(FNB_BACKGROUND_GRADIENT) and [70] or [0])[0]
-
         # For VC8 style, we color the tab area in gradient coloring
         lightcolour = LightColour(pc._tabAreaColor, lightFactor)
         PaintStraightGradientBox(dc, pc.GetClientRect(), pc._tabAreaColor, lightcolour)
-
         dc.SetBrush(wx.TRANSPARENT_BRUSH)
         dc.DrawRectangle(0, 0, size.x, size.y)
-
         # We always draw the bottom/upper line of the tabs
         # regradless the style
         dc.SetPen(borderPen)
         self.DrawTabsLine(pc, dc)
-
         # Restore the pen
         dc.SetPen(borderPen)
-
         # Draw labels
         dc.SetFont(boldFont)
-
         # Update all the tabs from 0 to 'pc.self._nFrom' to be non visible
         for i in xrange(pc._nFrom):
-
             pc._pagesInfoVec[i].SetPosition(wx.Point(-1, -1))
             pc._pagesInfoVec[i].GetRegion().Clear()
-
         # Draw the visible tabs, in VC8 style, we draw them from right to left
         vTabsInfo = self.NumberTabsCanFit(pc)
-
         activeTabPosx = 0
         activeTabWidth = 0
         activeTabHeight = 0
-
         for cur in xrange(len(vTabsInfo)-1, -1, -1):
-
             # 'i' points to the index of the currently drawn tab
             # in pc.GetPageInfoVector() vector
             i = pc._nFrom + cur
             dc.SetPen(borderPen)
             dc.SetBrush((i==pc.GetSelection() and [selBrush] or [noselBrush])[0])
-
             # Now set the font to the correct font
             dc.SetFont((i==pc.GetSelection() and [boldFont] or [normalFont])[0])
-
+            """
             # Add the padding to the tab width
             # Tab width:
             # +-----------------------------------------------------------+
             # | PADDING | IMG | IMG_PADDING | TEXT | PADDING | x |PADDING |
             # +-----------------------------------------------------------+
-
+            """
             tabWidth = self.CalcTabWidth(pageContainer, i, tabHeight)
             posx = vTabsInfo[cur].x
-
+            """
             # By default we clean the tab region
             # incase we use the VC8 style which requires
             # the region, it will be filled by the function
             # drawVc8Tab
+            """
             pc._pagesInfoVec[i].GetRegion().Clear()
-
+            """
             # Clean the 'x' buttn on the tab
             # 'Clean' rectanlge is a rectangle with width or height
             # with values lower than or equal to 0
+            """
             pc._pagesInfoVec[i].GetXRect().SetSize(wx.Size(-1, -1))
-
+            """
             # Draw the tab
             # Incase we are drawing the active tab
             # we need to redraw so it will appear on top
             # of all other tabs
-
+            """
             # when using the vc8 style, we keep the position of the active tab so we will draw it again later
             if i == pc.GetSelection() and pc.HasFlag(FNB_VC8):
-
                 activeTabPosx = posx
                 activeTabWidth = tabWidth
                 activeTabHeight = tabHeight
-
             else:
-
                 self.DrawTab(pc, dc, posx, i, tabWidth, tabHeight, pc._nTabXButtonStatus)
-
             # Restore the text forground
             dc.SetTextForeground(pc._activeTextColor)
-
             # Update the tab position & size
             pc._pagesInfoVec[i].SetPosition(wx.Point(posx, VERTICAL_BORDER_PADDING))
             pc._pagesInfoVec[i].SetSize(wx.Size(tabWidth, tabHeight))
 
         # Incase we are in VC8 style, redraw the active tab (incase it is visible)
         if pc.GetSelection() >= pc._nFrom and pc.GetSelection() < pc._nFrom + len(vTabsInfo):
-
             self.DrawTab(pc, dc, activeTabPosx, pc.GetSelection(), activeTabWidth, activeTabHeight, pc._nTabXButtonStatus)
-
         # Update all tabs that can not fit into the screen as non-visible
         for xx in xrange(pc._nFrom + len(vTabsInfo), len(pc._pagesInfoVec)):
-
             pc._pagesInfoVec[xx].SetPosition(wx.Point(-1, -1))
             pc._pagesInfoVec[xx].GetRegion().Clear()
-
         # Draw the left/right/close buttons
         # Left arrow
         self.DrawLeftArrow(pc, dc)
@@ -2578,14 +2047,12 @@
         self.DrawX(pc, dc)
         self.DrawDropDownArrow(pc, dc)
 
-
     def DrawTab(self, pageContainer, dc, posx, tabIdx, tabWidth, tabHeight, btnStatus):
         """ Draws a tab using VC8 style. """
-
         pc = pageContainer
         borderPen = wx.Pen(pc._pParent.GetBorderColour())
         tabPoints = [wx.Point() for ii in xrange(8)]
-
+        """
         # If we draw the first tab or the active tab,
         # we draw a full tab, else we draw a truncated tab
         #
@@ -2597,31 +2064,23 @@
         # X(0),(7)                                  X(6)
         #
         #
-
+        """
         tabPoints[0].x = (pc.HasFlag(FNB_BOTTOM) and [posx] or [posx+self._factor])[0]
         tabPoints[0].y = (pc.HasFlag(FNB_BOTTOM) and [2] or [tabHeight - 3])[0]
-
         tabPoints[1].x = tabPoints[0].x + tabHeight - VERTICAL_BORDER_PADDING - 3 - self._factor
         tabPoints[1].y = (pc.HasFlag(FNB_BOTTOM) and [tabHeight - (VERTICAL_BORDER_PADDING+2)] or [(VERTICAL_BORDER_PADDING+2)])[0]
-
         tabPoints[2].x = tabPoints[1].x + 4
         tabPoints[2].y = (pc.HasFlag(FNB_BOTTOM) and [tabHeight - VERTICAL_BORDER_PADDING] or [VERTICAL_BORDER_PADDING])[0]
-
         tabPoints[3].x = tabPoints[2].x + tabWidth - 2
         tabPoints[3].y = (pc.HasFlag(FNB_BOTTOM) and [tabHeight - VERTICAL_BORDER_PADDING] or [VERTICAL_BORDER_PADDING])[0]
-
         tabPoints[4].x = tabPoints[3].x + 1
         tabPoints[4].y = (pc.HasFlag(FNB_BOTTOM) and [tabPoints[3].y - 1] or [tabPoints[3].y + 1])[0]
-
         tabPoints[5].x = tabPoints[4].x + 1
         tabPoints[5].y = (pc.HasFlag(FNB_BOTTOM) and [(tabPoints[4].y - 1)] or [tabPoints[4].y + 1])[0]
-
         tabPoints[6].x = tabPoints[2].x + tabWidth
         tabPoints[6].y = tabPoints[0].y
-
         tabPoints[7].x = tabPoints[0].x
         tabPoints[7].y = tabPoints[0].y
-
         pc._pagesInfoVec[tabIdx].SetRegion(tabPoints)
 
         # Draw the polygon
@@ -2633,9 +2092,7 @@
         # Restore the brush
         dc.SetBrush(br)
         rect = pc.GetClientRect()
-
         if tabIdx != pc.GetSelection() and not pc.HasFlag(FNB_BOTTOM):
-
             # Top default tabs
             dc.SetPen(wx.Pen(pc._pParent.GetBorderColour()))
             lineY = rect.height
@@ -2647,57 +2104,46 @@
         # Incase we are drawing the selected tab, we draw the border of it as well
         # but without the bottom (upper line incase of wxBOTTOM)
         if tabIdx == pc.GetSelection():
-
             borderPen = wx.Pen(wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNSHADOW))
             dc.SetPen(borderPen)
             dc.SetBrush(wx.TRANSPARENT_BRUSH)
             dc.DrawPolygon(tabPoints)
-
             # Delete the bottom line (or the upper one, incase we use wxBOTTOM)
             dc.SetPen(wx.WHITE_PEN)
             dc.DrawLine(tabPoints[0].x, tabPoints[0].y, tabPoints[6].x, tabPoints[6].y)
-
         self.FillVC8GradientColour(pc, dc, tabPoints, tabIdx == pc.GetSelection(), tabIdx)
-
         # Draw a thin line to the right of the non-selected tab
         if tabIdx != pc.GetSelection():
-
             dc.SetPen(wx.Pen(wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DFACE)))
             dc.DrawLine(tabPoints[4].x-1, tabPoints[4].y, tabPoints[5].x-1, tabPoints[5].y)
             dc.DrawLine(tabPoints[5].x-1, tabPoints[5].y, tabPoints[6].x-1, tabPoints[6].y)
-
+        """
         # Text drawing offset from the left border of the
         # rectangle
 
         # The width of the images are 16 pixels
+        """
         vc8ShapeLen = tabHeight - VERTICAL_BORDER_PADDING - 2
-        if pc.TabHasImage(tabIdx):
-            textOffset = 2*pc._pParent.GetPadding() + 16 + vc8ShapeLen
-        else:
-            textOffset = pc._pParent.GetPadding() + vc8ShapeLen
+        if pc.TabHasImage(tabIdx): textOffset = 2*pc._pParent.GetPadding() + 16 + vc8ShapeLen
+        else: textOffset = pc._pParent.GetPadding() + vc8ShapeLen
 
         # Draw the image for the tab if any
         imageYCoord = (pc.HasFlag(FNB_BOTTOM) and [6] or [8])[0]
-
         if pc.TabHasImage(tabIdx):
-
             imageXOffset = textOffset - 16 - pc._pParent.GetPadding()
             pc._ImageList.Draw(pc._pagesInfoVec[tabIdx].GetImageIndex(), dc,
                                      posx + imageXOffset, imageYCoord,
                                      wx.IMAGELIST_DRAW_TRANSPARENT, True)
-
         boldFont = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)
 
         # if selected tab, draw text in bold
         if tabIdx == pc.GetSelection():
             boldFont.SetWeight(wx.FONTWEIGHT_BOLD)
-
         dc.SetFont(boldFont)
         dc.DrawText(pc.GetPageText(tabIdx), posx + textOffset, imageYCoord)
 
         # draw 'x' on tab (if enabled)
         if pc.HasFlag(FNB_X_ON_TAB) and tabIdx == pc.GetSelection():
-
             textWidth, textHeight = dc.GetTextExtent(pc.GetPageText(tabIdx))
             tabCloseButtonXCoord = posx + textOffset + textWidth + 1
 
@@ -2707,81 +2153,57 @@
             x_rect = wx.Rect(tabCloseButtonXCoord, tabCloseButtonYCoord, 16, 16)
             # Draw the tab
             self.DrawTabX(pc, dc, x_rect, tabIdx, btnStatus)
-
         self.DrawFocusRectangle(dc, pc, pc._pagesInfoVec[tabIdx])
 
-
     def FillVC8GradientColour(self, pageContainer, dc, tabPoints, bSelectedTab, tabIdx):
         """ Fills a tab with a gradient shading. """
-
         # calculate gradient coefficients
         pc = pageContainer
-
         if self._first:
             self._first = False
             pc._colorTo   = LightColour(wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DFACE), 0)
             pc._colorFrom = LightColour(wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DFACE), 60)
-
         col2 = pc._pParent.GetGradientColourTo()
         col1 = pc._pParent.GetGradientColourFrom()
 
         # If colorful tabs style is set, override the tab color
         if pc.HasFlag(FNB_COLORFUL_TABS):
-
             if not pc._pagesInfoVec[tabIdx].GetColour():
-
                 # First time, generate color, and keep it in the vector
                 tabColor = RandomColour()
                 pc._pagesInfoVec[tabIdx].SetColour(tabColor)
-
             if pc.HasFlag(FNB_BOTTOM):
-
                 col2 = LightColour(pc._pagesInfoVec[tabIdx].GetColour(), 50)
                 col1 = LightColour(pc._pagesInfoVec[tabIdx].GetColour(), 80)
-
             else:
-
                 col1 = LightColour(pc._pagesInfoVec[tabIdx].GetColour(), 50)
                 col2 = LightColour(pc._pagesInfoVec[tabIdx].GetColour(), 80)
-
         size = abs(tabPoints[2].y - tabPoints[0].y) - 1
-
         rf, gf, bf = 0, 0, 0
         rstep = float(col2.Red() - col1.Red())/float(size)
         gstep = float(col2.Green() - col1.Green())/float(size)
         bstep = float(col2.Blue() - col1.Blue())/float(size)
-
         y = tabPoints[0].y
-
+        """
         # If we are drawing the selected tab, we need also to draw a line
         # from 0.tabPoints[0].x and tabPoints[6].x . end, we achieve this
         # by drawing the rectangle with transparent brush
         # the line under the selected tab will be deleted by the drwaing loop
+        """
         if bSelectedTab:
             self.DrawTabsLine(pc, dc)
-
         while 1:
-
             if pc.HasFlag(FNB_BOTTOM):
-
-                if y > tabPoints[0].y + size:
-                    break
-
+                if y > tabPoints[0].y + size: break
             else:
-
-                if y < tabPoints[0].y - size:
-                    break
-
+                if y < tabPoints[0].y - size: break
             currCol = wx.Colour(col1.Red() + rf, col1.Green() + gf, col1.Blue() + bf)
-
             dc.SetPen((bSelectedTab and [wx.Pen(pc._activeTabColor)] or [wx.Pen(currCol)])[0])
             startX = self.GetStartX(tabPoints, y, pc.GetParent().GetWindowStyleFlag())
             endX = self.GetEndX(tabPoints, y, pc.GetParent().GetWindowStyleFlag())
             dc.DrawLine(startX, y, endX, y)
-
             # Draw the border using the 'edge' point
             dc.SetPen(wx.Pen((bSelectedTab and [wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNSHADOW)] or [pc._colorBorder])[0]))
-
             dc.DrawPoint(startX, y)
             dc.DrawPoint(endX, y)
 
@@ -2789,166 +2211,111 @@
             rf += rstep
             gf += gstep
             bf += bstep
-
-            if pc.HasFlag(FNB_BOTTOM):
-                y = y + 1
-            else:
-                y = y - 1
-
+            if pc.HasFlag(FNB_BOTTOM): y = y + 1
+            else: y = y - 1
 
     def GetStartX(self, tabPoints, y, style):
         """ Returns the x start position of a tab. """
-
         x1, x2, y1, y2 = 0.0, 0.0, 0.0, 0.0
 
         # We check the 3 points to the left
-
         bBottomStyle = (style & FNB_BOTTOM and [True] or [False])[0]
         match = False
-
         if bBottomStyle:
-
             for i in xrange(3):
-
                 if y >= tabPoints[i].y and y < tabPoints[i+1].y:
-
                     x1 = tabPoints[i].x
                     x2 = tabPoints[i+1].x
                     y1 = tabPoints[i].y
                     y2 = tabPoints[i+1].y
                     match = True
                     break
-
         else:
-
             for i in xrange(3):
-
                 if y <= tabPoints[i].y and y > tabPoints[i+1].y:
-
                     x1 = tabPoints[i].x
                     x2 = tabPoints[i+1].x
                     y1 = tabPoints[i].y
                     y2 = tabPoints[i+1].y
                     match = True
                     break
-
-        if not match:
-            return tabPoints[2].x
-
+        if not match: return tabPoints[2].x
+        """
         # According to the equation y = ax + b => x = (y-b)/a
         # We know the first 2 points
-
-        if x2 == x1:
-            return x2
-        else:
-            a = (y2 - y1)/(x2 - x1)
-
+        """
+        if x2 == x1: return x2
+        else: a = (y2 - y1)/(x2 - x1)
         b = y1 - ((y2 - y1)/(x2 - x1))*x1
-
-        if a == 0:
-            return int(x1)
-
+        if a == 0: return int(x1)
         x = (y - b)/a
-
         return int(x)
 
-
     def GetEndX(self, tabPoints, y, style):
         """ Returns the x end position of a tab. """
-
         x1, x2, y1, y2 = 0.0, 0.0, 0.0, 0.0
-
         # We check the 3 points to the left
         bBottomStyle = (style & FNB_BOTTOM and [True] or [False])[0]
         match = False
-
         if bBottomStyle:
-
             for i in xrange(7, 3, -1):
-
                 if y >= tabPoints[i].y and y < tabPoints[i-1].y:
-
                     x1 = tabPoints[i].x
                     x2 = tabPoints[i-1].x
                     y1 = tabPoints[i].y
                     y2 = tabPoints[i-1].y
                     match = True
                     break
-
         else:
-
             for i in xrange(7, 3, -1):
-
                 if y <= tabPoints[i].y and y > tabPoints[i-1].y:
-
                     x1 = tabPoints[i].x
                     x2 = tabPoints[i-1].x
                     y1 = tabPoints[i].y
                     y2 = tabPoints[i-1].y
                     match = True
                     break
-
         if not match:
             return tabPoints[3].x
-
+        """
         # According to the equation y = ax + b => x = (y-b)/a
         # We know the first 2 points
 
         # Vertical line
-        if x1 == x2:
-            return int(x1)
-
+        """
+        if x1 == x2: return int(x1)
         a = (y2 - y1)/(x2 - x1)
         b = y1 - ((y2 - y1)/(x2 - x1))*x1
-
-        if a == 0:
-            return int(x1)
-
+        if a == 0: return int(x1)
         x = (y - b)/a
-
         return int(x)
 
-
     def NumberTabsCanFit(self, pageContainer, fr=-1):
         """ Returns the number of tabs that can fit in the visible area. """
-
         pc = pageContainer
-
         rect = pc.GetClientRect()
         clientWidth = rect.width
-
         # Empty results
         vTabInfo = []
         tabHeight = self.CalcTabHeight(pageContainer)
-
         # The drawing starts from posx
         posx = pc._pParent.GetPadding()
-
-        if fr < 0:
-            fr = pc._nFrom
-
+        if fr < 0: fr = pc._nFrom
         for i in xrange(fr, len(pc._pagesInfoVec)):
-
             vc8glitch = tabHeight + FNB_HEIGHT_SPACER
             tabWidth = self.CalcTabWidth(pageContainer, i, tabHeight)
-
-            if posx + tabWidth + vc8glitch + self.GetButtonsAreaLength(pc) >= clientWidth:
-                break
-
+            if posx + tabWidth + vc8glitch + self.GetButtonsAreaLength(pc) >= clientWidth: break
             # Add a result to the returned vector
             tabRect = wx.Rect(posx, VERTICAL_BORDER_PADDING, tabWidth, tabHeight)
             vTabInfo.append(tabRect)
-
             # Advance posx
             posx += tabWidth + FNB_HEIGHT_SPACER
-
         return vTabInfo
 
 
-# ---------------------------------------------------------------------------- #
+"""
 # Class FlatNotebook
-# ---------------------------------------------------------------------------- #
-
+"""
 class FlatNotebook(wx.PyPanel):
     """
     Display one or more windows in a notebook.
@@ -2976,7 +2343,6 @@
         'style': this can be assigned to whatever combination of FNB_* styles.
 
         """
-
         self._bForceSelection = False
         self._nPadding = 6
         self._nFrom = 0
@@ -2985,91 +2351,69 @@
         self._windows = []
         self._popupWin = None
         self._naviIcon = None
-
         wx.PyPanel.__init__(self, parent, id, pos, size, style)
-
         self._pages = PageContainer(self, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, style)
-
         self.Bind(wx.EVT_NAVIGATION_KEY, self.OnNavigationKey)
-
         self.Init()
 
 
     def Init(self):
         """ Initializes all the class attributes. """
-
         self._pages._colorBorder = wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNSHADOW)
-
         self._mainSizer = wx.BoxSizer(wx.VERTICAL)
         self.SetSizer(self._mainSizer)
-
+        """
         # The child panels will inherit this bg color, so leave it at the default value
         #self.SetBackgroundColour(wx.SystemSettings_GetColour(wx.SYS_COLOUR_APPWORKSPACE))
 
         # Set default page height
+        """
         dc = wx.ClientDC(self)
-
         if "__WXGTK__" in wx.PlatformInfo:
+            """
             # For GTK it seems that we must do this steps in order
             # for the tabs will get the proper height on initialization
             # on MSW, preforming these steps yields wierd results
+            """
             boldFont = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)
             boldFont.SetWeight(wx.FONTWEIGHT_BOLD)
             dc.SetFont(boldFont)
-
         height = dc.GetCharHeight()
-
         tabHeight = height + FNB_HEIGHT_SPACER         # We use 8 pixels as padding
-
-        if "__WXGTK__" in wx.PlatformInfo:
-            tabHeight += 6
-
+        if "__WXGTK__" in wx.PlatformInfo: tabHeight += 6
         self._pages.SetSizeHints(-1, tabHeight)
         # Add the tab container to the sizer
         self._mainSizer.Insert(0, self._pages, 0, wx.EXPAND)
         self._mainSizer.Layout()
-
         self._pages._nFrom = self._nFrom
         self._pDropTarget = FNBDropTarget(self)
         self.SetDropTarget(self._pDropTarget)
 
-
     def DoGetBestSize(self):
         """ Overrides DoGetBestSize to handle sizers nicely. """
-
         if not self._windows:
             # Something is better than nothing... no pages!
             return wx.Size(20, 20)
-
         maxWidth = maxHeight = 0
         tabHeight = self.GetPageBestSize().height
-
         for win in self._windows:
             # Loop over all the windows to get their best size
             width, height = win.GetBestSize()
             maxWidth, maxHeight = max(maxWidth, width), max(maxHeight, height)
-
         return wx.Size(maxWidth, maxHeight+tabHeight)
 
-
     def SetActiveTabTextColour(self, textColour):
         """ Sets the text colour for the active tab. """
-
         self._pages._activeTextColor = textColour
 
-
     def OnDropTarget(self, x, y, nTabPage, wnd_oldContainer):
         """ Handles the drop action from a DND operation. """
-
         return self._pages.OnDropTarget(x, y, nTabPage, wnd_oldContainer)
 
-
     def GetPreviousSelection(self):
         """ Returns the previous selection. """
-
         return self._pages._iPreviousActivePage
 
-
     def AddPage(self, page, text, select=True, imageId=-1):
         """
         Add a page to the L{FlatNotebook}.
@@ -3082,96 +2426,65 @@
         Return value:
         True if successful, False otherwise.
         """
-
         # sanity check
-        if not page:
-            return False
-
+        if not page: return False
         # reparent the window to us
         page.Reparent(self)
-
         # Add tab
         bSelected = select or len(self._windows) == 0
-
         if bSelected:
-
             bSelected = False
-
             # Check for selection and send events
             oldSelection = self._pages._iActivePage
             tabIdx = len(self._windows)
-
             event = FlatNotebookEvent(wxEVT_FLATNOTEBOOK_PAGE_CHANGING, self.GetId())
             event.SetSelection(tabIdx)
             event.SetOldSelection(oldSelection)
             event.SetEventObject(self)
-
             if not self.GetEventHandler().ProcessEvent(event) or event.IsAllowed() or len(self._windows) == 0:
                 bSelected = True
-
         curSel = self._pages.GetSelection()
-
         if not self._pages.IsShown():
             self._pages.Show()
-
         self._pages.AddPage(text, bSelected, imageId)
         self._windows.append(page)
-
         self.Freeze()
 
         # Check if a new selection was made
         if bSelected:
-
             if curSel >= 0:
-
                 # Remove the window from the main sizer
                 self._mainSizer.Detach(self._windows[curSel])
                 self._windows[curSel].Hide()
-
             if self.GetWindowStyleFlag() & FNB_BOTTOM:
-
                 self._mainSizer.Insert(0, page, 1, wx.EXPAND)
-
             else:
-
                 # We leave a space of 1 pixel around the window
                 self._mainSizer.Add(page, 1, wx.EXPAND)
-
             # Fire a wxEVT_FLATNOTEBOOK_PAGE_CHANGED event
             event.SetEventType(wxEVT_FLATNOTEBOOK_PAGE_CHANGED)
             event.SetOldSelection(oldSelection)
             self.GetEventHandler().ProcessEvent(event)
-
         else:
-
             # Hide the page
             page.Hide()
-
         self.Thaw()
         self._mainSizer.Layout()
         self.Refresh()
-
         return True
 
-
     def SetImageList(self, imageList):
         """ Sets the image list for the page control. """
-
         self._pages.SetImageList(imageList)
 
-
     def AssignImageList(self, imageList):
         """ Assigns the image list for the page control. """
-
         self._pages.AssignImageList(imageList)
 
-
     def GetImageList(self):
         """ Returns the associated image list. """
-
         return self._pages.GetImageList()
 
-
     def InsertPage(self, indx, page, text, select=True, imageId=-1):
         """
         Inserts a new page at the specified position.
@@ -3185,137 +2498,92 @@
         Return value:
         True if successful, False otherwise.
         """
-
         # sanity check
-        if not page:
-            return False
-
+        if not page: return False
         # reparent the window to us
         page.Reparent(self)
-
         if not self._windows:
-
             self.AddPage(page, text, select, imageId)
             return True
-
         # Insert tab
         bSelected = select or not self._windows
         curSel = self._pages.GetSelection()
-
         indx = max(0, min(indx, len(self._windows)))
-
-        if indx <= len(self._windows):
-
-            self._windows.insert(indx, page)
-
-        else:
-
-            self._windows.append(page)
-
+        if indx <= len(self._windows): self._windows.insert(indx, page)
+        else: self._windows.append(page)
         if bSelected:
-
             bSelected = False
 
             # Check for selection and send events
             oldSelection = self._pages._iActivePage
-
             event = FlatNotebookEvent(wxEVT_FLATNOTEBOOK_PAGE_CHANGING, self.GetId())
             event.SetSelection(indx)
             event.SetOldSelection(oldSelection)
             event.SetEventObject(self)
-
             if not self.GetEventHandler().ProcessEvent(event) or event.IsAllowed() or len(self._windows) == 0:
                 bSelected = True
-
         self._pages.InsertPage(indx, text, bSelected, imageId)
-
-        if indx <= curSel:
-            curSel = curSel + 1
-
+        if indx <= curSel: curSel = curSel + 1
         self.Freeze()
 
         # Check if a new selection was made
         if bSelected:
-
             if curSel >= 0:
 
                 # Remove the window from the main sizer
                 self._mainSizer.Detach(self._windows[curSel])
                 self._windows[curSel].Hide()
-
             self._pages.SetSelection(indx)
 
             # Fire a wxEVT_FLATNOTEBOOK_PAGE_CHANGED event
             event.SetEventType(wxEVT_FLATNOTEBOOK_PAGE_CHANGED)
             event.SetOldSelection(oldSelection)
             self.GetEventHandler().ProcessEvent(event)
-
         else:
-
             # Hide the page
             page.Hide()
-
         self.Thaw()
         self._mainSizer.Layout()
         self.Refresh()
-
         return True
 
-
     def SetSelection(self, page):
         """
         Sets the selection for the given page.
         The call to this function generates the page changing events
         """
-
-        if page >= len(self._windows) or not self._windows:
-            return
-
+        if page >= len(self._windows) or not self._windows: return
         # Support for disabed tabs
         if not self._pages.GetEnabled(page) and len(self._windows) > 1 and not self._bForceSelection:
             return
-
         curSel = self._pages.GetSelection()
-
         # program allows the page change
         self.Freeze()
         if curSel >= 0:
-
             # Remove the window from the main sizer
             self._mainSizer.Detach(self._windows[curSel])
             self._windows[curSel].Hide()
-
         if self.GetWindowStyleFlag() & FNB_BOTTOM:
-
             self._mainSizer.Insert(0, self._windows[page], 1, wx.EXPAND)
-
         else:
-
             # We leave a space of 1 pixel around the window
             self._mainSizer.Add(self._windows[page], 1, wx.EXPAND)
-
         self._windows[page].Show()
         self.Thaw()
-
         self._mainSizer.Layout()
-
         if page != self._pages._iActivePage:
             # there is a real page changing
             self._pages._iPreviousActivePage = self._pages._iActivePage
-
         self._pages._iActivePage = page
         self._pages.DoSetSelection(page)
 
-
     def DeletePage(self, page):
         """
         Deletes the specified page, and the associated window.
         The call to this function generates the page changing events.
         """
-
         if page >= len(self._windows) or page < 0:
             return
-
         # Fire a closing event
         event = FlatNotebookEvent(wxEVT_FLATNOTEBOOK_PAGE_CLOSING, self.GetId())
         event.SetSelection(page)
@@ -3325,7 +2593,6 @@
         # The event handler allows it?
         if not event.IsAllowed():
             return
-
         self.Freeze()
 
         # Delete the requested page
@@ -3333,17 +2600,14 @@
 
         # If the page is the current window, remove it from the sizer
         # as well
-        if page == self._pages.GetSelection():
-            self._mainSizer.Detach(pageRemoved)
+        if page == self._pages.GetSelection(): self._mainSizer.Detach(pageRemoved)
 
         # Remove it from the array as well
         self._windows.pop(page)
 
         # Now we can destroy it in wxWidgets use Destroy instead of delete
         pageRemoved.Destroy()
-
         self.Thaw()
-
         self._pages.DoDeletePage(page)
         self.Refresh()
         self.Update()
@@ -3354,72 +2618,46 @@
         closedEvent.SetEventObject(self)
         self.GetEventHandler().ProcessEvent(closedEvent)
 
-
     def DeleteAllPages(self):
         """ Deletes all the pages. """
-
-        if not self._windows:
-            return False
-
+        if not self._windows: return False
         self.Freeze()
-
-        for page in self._windows:
-            page.Destroy()
-
+        for page in self._windows: page.Destroy()
         self._windows = []
         self.Thaw()
-
         # Clear the container of the tabs as well
         self._pages.DeleteAllPages()
         return True
 
-
     def GetCurrentPage(self):
         """ Returns the currently selected notebook page or None. """
-
         sel = self._pages.GetSelection()
-        if sel < 0:
-            return None
-
+        if sel < 0: return None
         return self._windows[sel]
 
-
     def GetPage(self, page):
         """ Returns the window at the given page position, or None. """
-
-        if page >= len(self._windows):
-            return None
-
+        if page >= len(self._windows): return None
         return self._windows[page]
 
-
     def GetPageIndex(self, win):
         """ Returns the index at which the window is found. """
-
-        try:
-            return self._windows.index(win)
-        except:
-            return -1
-
+        try: return self._windows.index(win)
+        except: return -1
 
     def GetSelection(self):
         """ Returns the currently selected page, or -1 if none was selected. """
-
         return self._pages.GetSelection()
 
-
     def AdvanceSelection(self, forward=True):
         """
         Cycles through the tabs.
         The call to this function generates the page changing events.
         """
-
         self._pages.AdvanceSelection(forward)
 
-
     def GetPageCount(self):
         """ Returns the number of pages in the L{FlatNotebook} control. """
-
         return self._pages.GetPageCount()
 
     def SetNavigatorIcon(self, bmp):
@@ -3431,15 +2669,12 @@
                 img.Rescale(16, 16, wx.IMAGE_QUALITY_HIGH)
                 bmp = wx.BitmapFromImage(img)
             self._naviIcon = bmp
-        else:
-            raise TypeError, "SetNavigatorIcon requires a valid bitmap"
+        else: raise TypeError, "SetNavigatorIcon requires a valid bitmap"
 
     def OnNavigationKey(self, event):
         """ Handles the wx.EVT_NAVIGATION_KEY event for L{FlatNotebook}. """
-
         if event.IsWindowChange():
-            if len(self._windows) == 0:
-                return
+            if len(self._windows) == 0: return
             # change pages
             if self.HasFlag(FNB_SMART_TABS):
                 if not self._popupWin:
@@ -3455,292 +2690,198 @@
             else:
                 # change pages
                 self.AdvanceSelection(event.GetDirection())
-
-        else:
-            event.Skip()
-
+        else: event.Skip()
 
     def GetPageShapeAngle(self, page_index):
         """ Returns the angle associated to a tab. """
-
-        if page_index < 0 or page_index >= len(self._pages._pagesInfoVec):
-            return None, False
-
+        if page_index < 0 or page_index >= len(self._pages._pagesInfoVec): return None, False
         result = self._pages._pagesInfoVec[page_index].GetTabAngle()
         return result, True
 
-
     def SetPageShapeAngle(self, page_index, angle):
         """ Sets the angle associated to a tab. """
-
-        if page_index < 0 or page_index >= len(self._pages._pagesInfoVec):
-            return
-
-        if angle > 15:
-            return
-
+        if page_index < 0 or page_index >= len(self._pages._pagesInfoVec): return
+        if angle > 15: return
         self._pages._pagesInfoVec[page_index].SetTabAngle(angle)
 
-
     def SetAllPagesShapeAngle(self, angle):
         """ Sets the angle associated to all the tab. """
-
-        if angle > 15:
-            return
-
-        for ii in xrange(len(self._pages._pagesInfoVec)):
-            self._pages._pagesInfoVec[ii].SetTabAngle(angle)
-
+        if angle > 15: return
+        for ii in xrange(len(self._pages._pagesInfoVec)): self._pages._pagesInfoVec[ii].SetTabAngle(angle)
         self.Refresh()
 
-
     def GetPageBestSize(self):
         """ Return the page best size. """
-
         return self._pages.GetClientSize()
 
-
     def SetPageText(self, page, text):
         """ Sets the text for the given page. """
-
         bVal = self._pages.SetPageText(page, text)
         self._pages.Refresh()
-
         return bVal
 
-
     def SetPadding(self, padding):
         """
         Sets the amount of space around each page's icon and label, in pixels.
         NB: only the horizontal padding is considered.
         """
-
         self._nPadding = padding.GetWidth()
 
-
     def GetTabArea(self):
         """ Returns the associated page. """
-
         return self._pages
 
-
     def GetPadding(self):
         """ Returns the amount of space around each page's icon and label, in pixels. """
-
         return self._nPadding
 
-
     def SetWindowStyleFlag(self, style):
         """ Sets the L{FlatNotebook} window style flags. """
-
         wx.PyPanel.SetWindowStyleFlag(self, style)
         renderer = self._pages._mgr.GetRenderer(self.GetWindowStyleFlag())
         renderer._tabHeight = None
-
         if self._pages:
-
             # For changing the tab position (i.e. placing them top/bottom)
             # refreshing the tab container is not enough
             self.SetSelection(self._pages._iActivePage)
-
         if not self._pages.HasFlag(FNB_HIDE_ON_SINGLE_TAB):
             #For Redrawing the Tabs once you remove the Hide tyle
             self._pages._ReShow()
 
-
     def RemovePage(self, page):
         """ Deletes the specified page, without deleting the associated window. """
-
-        if page >= len(self._windows):
-            return False
-
+        if page >= len(self._windows): return False
         # Fire a closing event
         event = FlatNotebookEvent(wxEVT_FLATNOTEBOOK_PAGE_CLOSING, self.GetId())
         event.SetSelection(page)
         event.SetEventObject(self)
         self.GetEventHandler().ProcessEvent(event)
-
         # The event handler allows it?
-        if not event.IsAllowed():
-            return False
-
+        if not event.IsAllowed(): return False
         self.Freeze()
 
         # Remove the requested page
         pageRemoved = self._windows[page]
-
         # If the page is the current window, remove it from the sizer
         # as well
-        if page == self._pages.GetSelection():
-            self._mainSizer.Detach(pageRemoved)
-
+        if page == self._pages.GetSelection(): self._mainSizer.Detach(pageRemoved)
         # Remove it from the array as well
         self._windows.pop(page)
         self.Thaw()
-
         self._pages.DoDeletePage(page)
-
         return True
 
-
     def SetRightClickMenu(self, menu):
         """ Sets the popup menu associated to a right click on a tab. """
-
         self._pages._pRightClickMenu = menu
 
-
     def GetPageText(self, nPage):
         """ Returns the tab caption. """
-
         return self._pages.GetPageText(nPage)
 
-
     def SetGradientColours(self, fr, to, border):
         """ Sets the gradient colours for the tab. """
-
         self._pages._colorFrom = fr
         self._pages._colorTo   = to
         self._pages._colorBorder = border
 
-
     def SetGradientColourFrom(self, fr):
         """ Sets the starting colour for the gradient. """
-
         self._pages._colorFrom = fr
 
-
     def SetGradientColourTo(self, to):
         """ Sets the ending colour for the gradient. """
-
         self._pages._colorTo = to
 
-
     def SetGradientColourBorder(self, border):
         """ Sets the tab border colour. """
-
         self._pages._colorBorder = border
 
-
     def GetGradientColourFrom(self):
         """ Gets first gradient colour. """
-
         return self._pages._colorFrom
 
-
     def GetGradientColourTo(self):
         """ Gets second gradient colour. """
-
         return self._pages._colorTo
 
-
     def GetGradientColourBorder(self):
         """ Gets the tab border colour. """
-
         return self._pages._colorBorder
 
-
     def GetBorderColour(self):
         """ Returns the border colour. """
-
         return self._pages._colorBorder
 
-
     def GetActiveTabTextColour(self):
         """ Get the active tab text colour. """
-
         return self._pages._activeTextColor
 
-
     def SetPageImage(self, page, image):
         """
         Sets the image index for the given page. Image is an index into the
         image list which was set with SetImageList.
         """
-
         self._pages.SetPageImage(page, image)
 
-
     def GetPageImage(self, nPage):
         """
         Returns the image index for the given page. Image is an index into the
         image list which was set with SetImageList.
         """
-
         return self._pages.GetPageImage(nPage)
 
-
     def GetEnabled(self, page):
         """ Returns whether a tab is enabled or not. """
-
         return self._pages.GetEnabled(page)
 
-
     def EnableTab(self, page, enabled=True):
         """ Enables or disables a tab. """
-
-        if page >= len(self._windows):
-            return
-
+        if page >= len(self._windows): return
         self._windows[page].Enable(enabled)
         self._pages.EnableTab(page, enabled)
 
-
     def GetNonActiveTabTextColour(self):
         """ Returns the non active tabs text colour. """
-
         return self._pages._nonActiveTextColor
 
-
     def SetNonActiveTabTextColour(self, color):
         """ Sets the non active tabs text colour. """
-
         self._pages._nonActiveTextColor = color
 
-
     def SetTabAreaColour(self, color):
         """ Sets the area behind the tabs colour. """
-
         self._pages._tabAreaColor = color
 
-
     def GetTabAreaColour(self):
         """ Returns the area behind the tabs colour. """
-
         return self._pages._tabAreaColor
 
-
     def SetActiveTabColour(self, color):
         """ Sets the active tab colour. """
-
         self._pages._activeTabColor = color
 
-
     def GetActiveTabColour(self):
         """ Returns the active tab colour. """
-
         return self._pages._activeTabColor
 
 
-# ---------------------------------------------------------------------------- #
+"""
 # Class PageContainer
 # Acts as a container for the pages you add to FlatNotebook
-# ---------------------------------------------------------------------------- #
-
+"""
 class PageContainer(wx.Panel):
     """
     This class acts as a container for the pages you add to L{FlatNotebook}.
     """
-
     def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition,
                  size=wx.DefaultSize, style=0):
         """ Default class constructor. """
-
         self._ImageList = None
         self._iActivePage = -1
         self._pDropTarget = None
         self._nLeftClickZone = FNB_NOWHERE
         self._iPreviousActivePage = -1
-
         self._pRightClickMenu = None
         self._nXButtonStatus = FNB_BTN_NONE
         self._nArrowDownButtonStatus = FNB_BTN_NONE
@@ -3748,38 +2889,30 @@
         self._nRightButtonStatus = FNB_BTN_NONE
         self._nLeftButtonStatus = FNB_BTN_NONE
         self._nTabXButtonStatus = FNB_BTN_NONE
-
         self._pagesInfoVec = []
-
         self._colorTo = wx.SystemSettings_GetColour(wx.SYS_COLOUR_ACTIVECAPTION)
         self._colorFrom = wx.WHITE
         self._activeTabColor = wx.WHITE
         self._activeTextColor = wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNTEXT)
         self._nonActiveTextColor = wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNTEXT)
         self._tabAreaColor = wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNFACE)
-
         self._nFrom = 0
         self._isdragging = False
 
         # Set default page height, this is done according to the system font
         memDc = wx.MemoryDC()
         memDc.SelectObject(wx.EmptyBitmap(1,1))
-
         if "__WXGTK__" in wx.PlatformInfo:
             boldFont = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)
             boldFont.SetWeight(wx.BOLD)
             memDc.SetFont(boldFont)
-
         height = memDc.GetCharHeight()
         tabHeight = height + FNB_HEIGHT_SPACER # We use 10 pixels as padding
-
         wx.Panel.__init__(self, parent, id, pos, wx.Size(size.x, tabHeight),
                           style|wx.NO_BORDER|wx.NO_FULL_REPAINT_ON_RESIZE|wx.WANTS_CHARS)
-
         self._pDropTarget = FNBDropTarget(self)
         self.SetDropTarget(self._pDropTarget)
         self._mgr = FNBRendererMgr()
-
         self.Bind(wx.EVT_PAINT, self.OnPaint)
         self.Bind(wx.EVT_SIZE, self.OnSize)
         self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
@@ -3795,33 +2928,26 @@
         self.Bind(wx.EVT_KILL_FOCUS, self.OnKillFocus)
         self.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
 
-
     def OnEraseBackground(self, event):
         """ Handles the wx.EVT_ERASE_BACKGROUND event for L{PageContainer} (does nothing)."""
-
         pass
 
-
     def _ReShow(self):
         """ Handles the Redraw of the tabs when the FNB_HIDE_ON_SINGLE_TAB has been removed """
         self.Show()
         self.GetParent()._mainSizer.Layout()
         self.Refresh()
 
-
     def OnPaint(self, event):
         """ Handles the wx.EVT_PAINT event for L{PageContainer}."""
-
         dc = wx.BufferedPaintDC(self)
         renderer = self._mgr.GetRenderer(self.GetParent().GetWindowStyleFlag())
         renderer.DrawTabs(self, dc)
-
         if self.HasFlag(FNB_HIDE_ON_SINGLE_TAB) and len(self._pagesInfoVec) <= 1:
             self.Hide()
             self.GetParent()._mainSizer.Layout()
             self.Refresh()
 
-
     def AddPage(self, caption, selected=True, imgindex=-1):
         """
         Add a page to the L{FlatNotebook}.
@@ -3834,18 +2960,14 @@
         Return value:
         True if successful, False otherwise.
         """
-
         if selected:
-
             self._iPreviousActivePage = self._iActivePage
             self._iActivePage = len(self._pagesInfoVec)
-
         # Create page info and add it to the vector
         pageInfo = PageInfo(caption, imgindex)
         self._pagesInfoVec.append(pageInfo)
         self.Refresh()
 
-
     def InsertPage(self, indx, text, selected=True, imgindex=-1):
         """
         Inserts a new page at the specified position.
@@ -3859,93 +2981,62 @@
         Return value:
         True if successful, False otherwise.
         """
-
         if selected:
-
             self._iPreviousActivePage = self._iActivePage
             self._iActivePage = len(self._pagesInfoVec)
-
         self._pagesInfoVec.insert(indx, PageInfo(text, imgindex))
-
         self.Refresh()
         return True
 
-
     def OnSize(self, event):
         """ Handles the wx.EVT_SIZE events for L{PageContainer}. """
-
         # When resizing the control, try to fit to screen as many tabs as we can
         style = self.GetParent().GetWindowStyleFlag()
         renderer = self._mgr.GetRenderer(style)
-
         fr = 0
         page = self.GetSelection()
-
         for fr in xrange(self._nFrom):
             vTabInfo = renderer.NumberTabsCanFit(self, fr)
-            if page - fr >= len(vTabInfo):
-                continue
+            if page - fr >= len(vTabInfo): continue
             break
-
         self._nFrom = fr
-
         self.Refresh() # Call on paint
         event.Skip()
 
-
     def OnMiddleDown(self, event):
         """ Handles the wx.EVT_MIDDLE_DOWN events for L{PageContainer}. """
-
         # Test if this style is enabled
         style = self.GetParent().GetWindowStyleFlag()
-
-        if not style & FNB_MOUSE_MIDDLE_CLOSES_TABS:
-            return
-
+        if not style & FNB_MOUSE_MIDDLE_CLOSES_TABS: return
         where, tabIdx = self.HitTest(event.GetPosition())
-
-        if where == FNB_TAB:
-            self.DeletePage(tabIdx)
-
+        if where == FNB_TAB: self.DeletePage(tabIdx)
         event.Skip()
 
-
     def OnRightDown(self, event):
         """ Handles the wx.EVT_RIGHT_DOWN events for L{PageContainer}. """
-
         where, tabIdx = self.HitTest(event.GetPosition())
-
         if where in [FNB_TAB, FNB_TAB_X]:
-
             if self._pagesInfoVec[tabIdx].GetEnabled():
                 # Fire events and eventually (if allowed) change selection
                 self.FireEvent(tabIdx)
-
                 # send a message to popup a custom menu
                 event = FlatNotebookEvent(wxEVT_FLATNOTEBOOK_PAGE_CONTEXT_MENU, self.GetParent().GetId())
                 event.SetSelection(tabIdx)
                 event.SetOldSelection(self._iActivePage)
                 event.SetEventObject(self.GetParent())
                 self.GetParent().GetEventHandler().ProcessEvent(event)
-
-                if self._pRightClickMenu:
-                    self.PopupMenu(self._pRightClickMenu)
-
+                if self._pRightClickMenu: self.PopupMenu(self._pRightClickMenu)
         event.Skip()
 
-
     def OnLeftDown(self, event):
         """ Handles the wx.EVT_LEFT_DOWN events for L{PageContainer}. """
-
         # Reset buttons status
         self._nXButtonStatus     = FNB_BTN_NONE
         self._nLeftButtonStatus  = FNB_BTN_NONE
         self._nRightButtonStatus = FNB_BTN_NONE
         self._nTabXButtonStatus  = FNB_BTN_NONE
         self._nArrowDownButtonStatus = FNB_BTN_NONE
-
         self._nLeftClickZone, tabIdx = self.HitTest(event.GetPosition())
-
         if self._nLeftClickZone == FNB_DROP_DOWN_ARROW:
             self._nArrowDownButtonStatus = FNB_BTN_PRESSED
             self.Refresh()
@@ -3961,387 +3052,244 @@
         elif self._nLeftClickZone == FNB_TAB_X:
             self._nTabXButtonStatus = FNB_BTN_PRESSED
             self.Refresh()
-
         elif self._nLeftClickZone == FNB_TAB:
-
             if self._iActivePage != tabIdx:
-
                 # In case the tab is disabled, we dont allow to choose it
-                if self._pagesInfoVec[tabIdx].GetEnabled():
-                    self.FireEvent(tabIdx)
-
+                if self._pagesInfoVec[tabIdx].GetEnabled(): self.FireEvent(tabIdx)
 
     def RotateLeft(self):
-
         if self._nFrom == 0:
             return
-
         # Make sure that the button was pressed before
-        if self._nLeftButtonStatus != FNB_BTN_PRESSED:
-            return
-
+        if self._nLeftButtonStatus != FNB_BTN_PRESSED: return
         self._nLeftButtonStatus = FNB_BTN_HOVER
-
         # We scroll left with bulks of 5
         scrollLeft = self.GetNumTabsCanScrollLeft()
-
         self._nFrom -= scrollLeft
-        if self._nFrom < 0:
-            self._nFrom = 0
-
+        if self._nFrom < 0: self._nFrom = 0
         self.Refresh()
 
-
     def RotateRight(self):
-
-        if self._nFrom >= len(self._pagesInfoVec) - 1:
-            return
-
+        if self._nFrom >= len(self._pagesInfoVec) - 1: return
         # Make sure that the button was pressed before
-        if self._nRightButtonStatus != FNB_BTN_PRESSED:
-            return
-
+        if self._nRightButtonStatus != FNB_BTN_PRESSED: return
         self._nRightButtonStatus = FNB_BTN_HOVER
-
         # Check if the right most tab is visible, if it is
         # don't rotate right anymore
-        if self._pagesInfoVec[len(self._pagesInfoVec)-1].GetPosition() != wx.Point(-1, -1):
-            return
-
+        if self._pagesInfoVec[len(self._pagesInfoVec)-1].GetPosition() != wx.Point(-1, -1): return
         self._nFrom += 1
         self.Refresh()
 
-
     def OnLeftUp(self, event):
         """ Handles the wx.EVT_LEFT_UP events for L{PageContainer}. """
-
         # forget the zone that was initially clicked
         self._nLeftClickZone = FNB_NOWHERE
-
         where, tabIdx = self.HitTest(event.GetPosition())
-
         # Make sure selected tab has focus
         self.SetFocus()
-
-        if where == FNB_LEFT_ARROW:
-            self.RotateLeft()
-
-        elif where == FNB_RIGHT_ARROW:
-            self.RotateRight()
-
+        if where == FNB_LEFT_ARROW: self.RotateLeft()
+        elif where == FNB_RIGHT_ARROW: self.RotateRight()
         elif where == FNB_X:
-
             # Make sure that the button was pressed before
-            if self._nXButtonStatus != FNB_BTN_PRESSED:
-                return
-
+            if self._nXButtonStatus != FNB_BTN_PRESSED: return
             self._nXButtonStatus = FNB_BTN_HOVER
-
             self.DeletePage(self._iActivePage)
-
         elif where == FNB_TAB_X:
-
             # Make sure that the button was pressed before
-            if self._nTabXButtonStatus != FNB_BTN_PRESSED:
-                return
-
+            if self._nTabXButtonStatus != FNB_BTN_PRESSED: return
             self._nTabXButtonStatus = FNB_BTN_HOVER
-
             self.DeletePage(self._iActivePage)
-
         elif where == FNB_DROP_DOWN_ARROW:
-
             # Make sure that the button was pressed before
-            if self._nArrowDownButtonStatus != FNB_BTN_PRESSED:
-                return
-
+            if self._nArrowDownButtonStatus != FNB_BTN_PRESSED: return
             self._nArrowDownButtonStatus = FNB_BTN_NONE
-
             # Refresh the button status
             renderer = self._mgr.GetRenderer(self.GetParent().GetWindowStyleFlag())
             dc = wx.ClientDC(self)
             renderer.DrawDropDownArrow(self, dc)
-
             self.PopupTabsMenu()
-
         event.Skip()
 
-
     def HitTest(self, pt):
         """
         HitTest method for L{PageContainer}.
         Returns the flag (if any) and the hit page (if any).
         """
-
         style = self.GetParent().GetWindowStyleFlag()
         render = self._mgr.GetRenderer(style)
-
         fullrect = self.GetClientRect()
         btnLeftPos = render.GetLeftButtonPos(self)
         btnRightPos = render.GetRightButtonPos(self)
         btnXPos = render.GetXPos(self)
-
         tabIdx = -1
-
-        if len(self._pagesInfoVec) == 0:
-            return FNB_NOWHERE, tabIdx
-
+        if len(self._pagesInfoVec) == 0: return FNB_NOWHERE, tabIdx
         rect = wx.Rect(btnXPos, 8, 16, 16)
-        if rect.Contains(pt):
-            return (style & FNB_NO_X_BUTTON and [FNB_NOWHERE] or [FNB_X])[0], tabIdx
-
+        if rect.Contains(pt): return (style & FNB_NO_X_BUTTON and [FNB_NOWHERE] or [FNB_X])[0], tabIdx
         rect = wx.Rect(btnRightPos, 8, 16, 16)
         if style & FNB_DROPDOWN_TABS_LIST:
             rect = wx.Rect(render.GetDropArrowButtonPos(self), 8, 16, 16)
-            if rect.Contains(pt):
-                return FNB_DROP_DOWN_ARROW, tabIdx
-
+            if rect.Contains(pt): return FNB_DROP_DOWN_ARROW, tabIdx
         if rect.Contains(pt):
             return (style & FNB_NO_NAV_BUTTONS and [FNB_NOWHERE] or [FNB_RIGHT_ARROW])[0], tabIdx
-
         rect = wx.Rect(btnLeftPos, 8, 16, 16)
         if rect.Contains(pt):
             return (style & FNB_NO_NAV_BUTTONS and [FNB_NOWHERE] or [FNB_LEFT_ARROW])[0], tabIdx
-
         # Test whether a left click was made on a tab
         bFoundMatch = False
-
         for cur in xrange(self._nFrom, len(self._pagesInfoVec)):
-
             pgInfo = self._pagesInfoVec[cur]
-
             if pgInfo.GetPosition() == wx.Point(-1, -1):
                 continue
-
             if style & FNB_X_ON_TAB and cur == self.GetSelection():
                 # 'x' button exists on a tab
                 if self._pagesInfoVec[cur].GetXRect().Contains(pt):
                     return FNB_TAB_X, cur
-
             if style & FNB_VC8:
-
                 if self._pagesInfoVec[cur].GetRegion().Contains(pt.x, pt.y):
-                    if bFoundMatch or cur == self.GetSelection():
-                        return FNB_TAB, cur
-
+                    if bFoundMatch or cur == self.GetSelection(): return FNB_TAB, cur
                     tabIdx = cur
                     bFoundMatch = True
-
             else:
-
                 tabRect = wx.Rect(pgInfo.GetPosition().x, pgInfo.GetPosition().y,
                                   pgInfo.GetSize().x, pgInfo.GetSize().y)
-
                 if tabRect.Contains(pt):
                     # We have a match
                     return FNB_TAB, cur
-
-        if bFoundMatch:
-            return FNB_TAB, tabIdx
-
+        if bFoundMatch: return FNB_TAB, tabIdx
         if self._isdragging:
             # We are doing DND, so check also the region outside the tabs
             # try before the first tab
             pgInfo = self._pagesInfoVec[0]
             tabRect = wx.Rect(0, pgInfo.GetPosition().y, pgInfo.GetPosition().x, self.GetParent().GetSize().y)
-            if tabRect.Contains(pt):
-                return FNB_TAB, 0
-
+            if tabRect.Contains(pt): return FNB_TAB, 0
             # try after the last tab
             pgInfo = self._pagesInfoVec[-1]
             startpos = pgInfo.GetPosition().x+pgInfo.GetSize().x
             tabRect = wx.Rect(startpos, pgInfo.GetPosition().y, fullrect.width-startpos, self.GetParent().GetSize().y)
-
-            if tabRect.Contains(pt):
-                return FNB_TAB, len(self._pagesInfoVec)
-
+            if tabRect.Contains(pt): return FNB_TAB, len(self._pagesInfoVec)
         # Default
         return FNB_NOWHERE, -1
 
-
     def SetSelection(self, page):
         """ Sets the selected page. """
-
         book = self.GetParent()
         book.SetSelection(page)
         self.DoSetSelection(page)
 
-
     def DoSetSelection(self, page):
         """ Does the actual selection of a page. """
-
         if page < len(self._pagesInfoVec):
             #! fix for tabfocus
             da_page = self._pParent.GetPage(page)
-
-            if da_page != None:
-                da_page.SetFocus()
-
+            if da_page != None: da_page.SetFocus()
         if not self.IsTabVisible(page):
             # Try to remove one tab from start and try again
-
             if not self.CanFitToScreen(page):
-
-                if self._nFrom > page:
-                    self._nFrom = page
+                if self._nFrom > page: self._nFrom = page
                 else:
                     while self._nFrom < page:
                         self._nFrom += 1
-                        if self.CanFitToScreen(page):
-                            break
-
+                        if self.CanFitToScreen(page): break
         self.Refresh()
 
-
     def DeletePage(self, page):
         """ Delete the specified page from L{FlatNotebook}. """
-
         book = self.GetParent()
         book.DeletePage(page)
         book.Refresh()
 
-
     def IsTabVisible(self, page):
         """ Returns whether a tab is visible or not. """
-
         iLastVisiblePage = self.GetLastVisibleTab()
         return page <= iLastVisiblePage and page >= self._nFrom
 
-
     def DoDeletePage(self, page):
         """ Does the actual page deletion. """
-
         # Remove the page from the vector
         book = self.GetParent()
         self._pagesInfoVec.pop(page)
-
         # Thanks to Yiaanis AKA Mandrav
         if self._iActivePage >= page:
             self._iActivePage = self._iActivePage - 1
             self._iPreviousActivePage = -1
-
         # The delete page was the last first on the array,
         # but the book still has more pages, so we set the
         # active page to be the first one (0)
         if self._iActivePage < 0 and len(self._pagesInfoVec) > 0:
             self._iActivePage = 0
             self._iPreviousActivePage = -1
-
         # Refresh the tabs
         if self._iActivePage >= 0:
-
             book._bForceSelection = True
-
             # Check for selection and send event
             event = FlatNotebookEvent(wxEVT_FLATNOTEBOOK_PAGE_CHANGING, self.GetParent().GetId())
             event.SetSelection(self._iActivePage)
             event.SetOldSelection(self._iPreviousActivePage)
             event.SetEventObject(self.GetParent())
-
             book.SetSelection(self._iActivePage)
             book._bForceSelection = False
-
             # Fire a wxEVT_FLATNOTEBOOK_PAGE_CHANGED event
             event.SetEventType(wxEVT_FLATNOTEBOOK_PAGE_CHANGED)
             event.SetOldSelection(self._iPreviousActivePage)
             self.GetParent().GetEventHandler().ProcessEvent(event)
-
         if not self._pagesInfoVec:
             # Erase the page container drawings
             dc = wx.ClientDC(self)
             dc.Clear()
 
-
     def DeleteAllPages(self):
         """ Deletes all the pages. """
-
         self._iActivePage = -1
         self._iPreviousActivePage = -1
         self._nFrom = 0
         self._pagesInfoVec = []
-
         # Erase the page container drawings
         dc = wx.ClientDC(self)
         dc.Clear()
 
-
     def OnMouseMove(self, event):
         """ Handles the wx.EVT_MOTION for L{PageContainer}. """
-
         if self._pagesInfoVec and self.IsShown():
-
             xButtonStatus = self._nXButtonStatus
             xTabButtonStatus = self._nTabXButtonStatus
             rightButtonStatus = self._nRightButtonStatus
             leftButtonStatus = self._nLeftButtonStatus
             dropDownButtonStatus = self._nArrowDownButtonStatus
-
             style = self.GetParent().GetWindowStyleFlag()
-
             self._nXButtonStatus = FNB_BTN_NONE
             self._nRightButtonStatus = FNB_BTN_NONE
             self._nLeftButtonStatus = FNB_BTN_NONE
             self._nTabXButtonStatus = FNB_BTN_NONE
             self._nArrowDownButtonStatus = FNB_BTN_NONE
-
             where, tabIdx = self.HitTest(event.GetPosition())
-
             if where == FNB_X:
                 if event.LeftIsDown():
-
                     self._nXButtonStatus = (self._nLeftClickZone==FNB_X and [FNB_BTN_PRESSED] or [FNB_BTN_NONE])[0]
-
-                else:
-
-                    self._nXButtonStatus = FNB_BTN_HOVER
-
+                else: self._nXButtonStatus = FNB_BTN_HOVER
             elif where == FNB_DROP_DOWN_ARROW:
                 if event.LeftIsDown():
-
                     self._nArrowDownButtonStatus = (self._nLeftClickZone==FNB_DROP_DOWN_ARROW and [FNB_BTN_PRESSED] or [FNB_BTN_NONE])[0]
-
-                else:
-
-                    self._nArrowDownButtonStatus = FNB_BTN_HOVER
-
+                else: self._nArrowDownButtonStatus = FNB_BTN_HOVER
             elif where == FNB_TAB_X:
                 if event.LeftIsDown():
-
                     self._nTabXButtonStatus = (self._nLeftClickZone==FNB_TAB_X and [FNB_BTN_PRESSED] or [FNB_BTN_NONE])[0]
-
-                else:
-
-                    self._nTabXButtonStatus = FNB_BTN_HOVER
-
+                else: self._nTabXButtonStatus = FNB_BTN_HOVER
             elif where == FNB_RIGHT_ARROW:
                 if event.LeftIsDown():
-
                     self._nRightButtonStatus = (self._nLeftClickZone==FNB_RIGHT_ARROW and [FNB_BTN_PRESSED] or [FNB_BTN_NONE])[0]
-
-                else:
-
-                    self._nRightButtonStatus = FNB_BTN_HOVER
-
+                else: self._nRightButtonStatus = FNB_BTN_HOVER
             elif where == FNB_LEFT_ARROW:
                 if event.LeftIsDown():
-
                     self._nLeftButtonStatus = (self._nLeftClickZone==FNB_LEFT_ARROW and [FNB_BTN_PRESSED] or [FNB_BTN_NONE])[0]
-
-                else:
-
-                    self._nLeftButtonStatus = FNB_BTN_HOVER
-
+                else: self._nLeftButtonStatus = FNB_BTN_HOVER
             elif where == FNB_TAB:
                 # Call virtual method for showing tooltip
                 self.ShowTabTooltip(tabIdx)
-
                 if not self.GetEnabled(tabIdx):
                     # Set the cursor to be 'No-entry'
                     wx.SetCursor(wx.StockCursor(wx.CURSOR_NO_ENTRY))
-
                 # Support for drag and drop
                 if event.Dragging() and not (style & FNB_NODRAG):
-
                     self._isdragging = True
                     draginfo = FNBDragInfo(self, tabIdx)
                     drginfo = cPickle.dumps(draginfo)
@@ -4350,123 +3298,70 @@
                     dragSource = FNBDropSource(self)
                     dragSource.SetData(dataobject)
                     dragSource.DoDragDrop(wx.Drag_DefaultMove)
-
             bRedrawX = self._nXButtonStatus != xButtonStatus
             bRedrawRight = self._nRightButtonStatus != rightButtonStatus
             bRedrawLeft = self._nLeftButtonStatus != leftButtonStatus
             bRedrawTabX = self._nTabXButtonStatus != xTabButtonStatus
             bRedrawDropArrow = self._nArrowDownButtonStatus != dropDownButtonStatus
-
             render = self._mgr.GetRenderer(style)
-
             if (bRedrawX or bRedrawRight or bRedrawLeft or bRedrawTabX or bRedrawDropArrow):
-
                 dc = wx.ClientDC(self)
-
-                if bRedrawX:
-
-                    render.DrawX(self, dc)
-
-                if bRedrawLeft:
-
-                    render.DrawLeftArrow(self, dc)
-
-                if bRedrawRight:
-
-                    render.DrawRightArrow(self, dc)
-
-                if bRedrawTabX:
-
-                    self.Refresh()
-
-                if bRedrawDropArrow:
-
-                    render.DrawDropDownArrow(self, dc)
-
+                if bRedrawX: render.DrawX(self, dc)
+                if bRedrawLeft: render.DrawLeftArrow(self, dc)
+                if bRedrawRight: render.DrawRightArrow(self, dc)
+                if bRedrawTabX: self.Refresh()
+                if bRedrawDropArrow: render.DrawDropDownArrow(self, dc)
         event.Skip()
 
-
     def GetLastVisibleTab(self):
         """ Returns the last visible tab. """
-
-        if self._nFrom < 0:
-            return -1
-
+        if self._nFrom < 0: return -1
         ii = 0
-
         for ii in xrange(self._nFrom, len(self._pagesInfoVec)):
-
-            if self._pagesInfoVec[ii].GetPosition() == wx.Point(-1, -1):
-                break
-
+            if self._pagesInfoVec[ii].GetPosition() == wx.Point(-1, -1): break
         return ii-1
 
-
     def GetNumTabsCanScrollLeft(self):
         """ Returns the number of tabs than can be scrolled left. """
-
-        if self._nFrom - 1 >= 0:
-            return 1
-
+        if self._nFrom - 1 >= 0: return 1
         return 0
 
-
     def IsDefaultTabs(self):
         """ Returns whether a tab has a default style. """
-
         style = self.GetParent().GetWindowStyleFlag()
         res = (style & FNB_VC71) or (style & FNB_FANCY_TABS) or (style & FNB_VC8)
         return not res
 
-
     def AdvanceSelection(self, bForward=True):
         """
         Cycles through the tabs.
         The call to this function generates the page changing events.
         """
-
         nSel = self.GetSelection()
-
-        if nSel < 0:
-            return
-
+        if nSel < 0: return
         nMax = self.GetPageCount() - 1
-
-        if bForward:
-            newSelection = (nSel == nMax and [0] or [nSel + 1])[0]
-        else:
-            newSelection = (nSel == 0 and [nMax] or [nSel - 1])[0]
-
-        if not self._pagesInfoVec[newSelection].GetEnabled():
-            return
-
+        if bForward: newSelection = (nSel == nMax and [0] or [nSel + 1])[0]
+        else: newSelection = (nSel == 0 and [nMax] or [nSel - 1])[0]
+        if not self._pagesInfoVec[newSelection].GetEnabled(): return
         self.FireEvent(newSelection)
 
-
     def OnMouseLeave(self, event):
         """ Handles the wx.EVT_LEAVE_WINDOW event for L{PageContainer}. """
-
         self._nLeftButtonStatus = FNB_BTN_NONE
         self._nXButtonStatus = FNB_BTN_NONE
         self._nRightButtonStatus = FNB_BTN_NONE
         self._nTabXButtonStatus = FNB_BTN_NONE
         self._nArrowDownButtonStatus = FNB_BTN_NONE
-
         style = self.GetParent().GetWindowStyleFlag()
         render = self._mgr.GetRenderer(style)
-
         dc = wx.ClientDC(self)
-
         render.DrawX(self, dc)
         render.DrawLeftArrow(self, dc)
         render.DrawRightArrow(self, dc)
-
         selection = self.GetSelection()
-
         if selection == -1:
             event.Skip()
             return
-
         if not self.IsTabVisible(selection):
             if selection == len(self._pagesInfoVec) - 1:
                 if not self.CanFitToScreen(selection):
@@ -4478,151 +3373,96 @@
 
         render.DrawTabX(self, dc, self._pagesInfoVec[selection].GetXRect(), selection, self._nTabXButtonStatus)
         render.DrawFocusRectangle(dc, self, self._pagesInfoVec[selection])
-
         event.Skip()
 
-
     def OnMouseEnterWindow(self, event):
         """ Handles the wx.EVT_ENTER_WINDOW event for L{PageContainer}. """
-
         self._nLeftButtonStatus = FNB_BTN_NONE
         self._nXButtonStatus = FNB_BTN_NONE
         self._nRightButtonStatus = FNB_BTN_NONE
         self._nLeftClickZone = FNB_BTN_NONE
         self._nArrowDownButtonStatus = FNB_BTN_NONE
-
         event.Skip()
 
-
     def ShowTabTooltip(self, tabIdx):
         """ Shows a tab tooltip. """
-
         pWindow = self._pParent.GetPage(tabIdx)
-
         if pWindow:
             pToolTip = pWindow.GetToolTip()
             if pToolTip and pToolTip.GetWindow() == pWindow:
                 self.SetToolTipString(pToolTip.GetTip())
 
-
     def SetPageImage(self, page, imgindex):
         """ Sets the image index associated to a page. """
-
         if page < len(self._pagesInfoVec):
-
             self._pagesInfoVec[page].SetImageIndex(imgindex)
             self.Refresh()
 
-
     def GetPageImage(self, page):
         """ Returns the image index associated to a page. """
-
-        if page < len(self._pagesInfoVec):
-
-            return self._pagesInfoVec[page].GetImageIndex()
-
+        if page < len(self._pagesInfoVec): return self._pagesInfoVec[page].GetImageIndex()
         return -1
 
-
     def OnDropTarget(self, x, y, nTabPage, wnd_oldContainer):
         """ Handles the drop action from a DND operation. """
-
         # Disable drag'n'drop for disabled tab
-        if not wnd_oldContainer._pagesInfoVec[nTabPage].GetEnabled():
-            return wx.DragCancel
-
+        if not wnd_oldContainer._pagesInfoVec[nTabPage].GetEnabled(): return wx.DragCancel
         self._isdragging = True
         oldContainer = wnd_oldContainer
         nIndex = -1
-
         where, nIndex = self.HitTest(wx.Point(x, y))
-
         oldNotebook = oldContainer.GetParent()
         newNotebook = self.GetParent()
-
         if oldNotebook == newNotebook:
-
             if nTabPage >= 0:
-
-                if where == FNB_TAB:
-                    self.MoveTabPage(nTabPage, nIndex)
-
+                if where == FNB_TAB: self.MoveTabPage(nTabPage, nIndex)
         elif self.GetParent().GetWindowStyleFlag() & FNB_ALLOW_FOREIGN_DND:
-
             if wx.Platform in ["__WXMSW__", "__WXGTK__", "__WXMAC__"]:
                 if nTabPage >= 0:
-
                     window = oldNotebook.GetPage(nTabPage)
-
                     if window:
                         where, nIndex = newNotebook._pages.HitTest(wx.Point(x, y))
                         caption = oldContainer.GetPageText(nTabPage)
                         imageindex = oldContainer.GetPageImage(nTabPage)
                         oldNotebook.RemovePage(nTabPage)
                         window.Reparent(newNotebook)
-
                         if imageindex >= 0:
-
                             bmp = oldNotebook.GetImageList().GetBitmap(imageindex)
                             newImageList = newNotebook.GetImageList()
-
                             if not newImageList:
                                 xbmp, ybmp = bmp.GetWidth(), bmp.GetHeight()
                                 newImageList = wx.ImageList(xbmp, ybmp)
                                 imageindex = 0
-                            else:
-                                imageindex = newImageList.GetImageCount()
-
+                            else: imageindex = newImageList.GetImageCount()
                             newImageList.Add(bmp)
                             newNotebook.SetImageList(newImageList)
-
                         newNotebook.InsertPage(nIndex, window, caption, True, imageindex)
-
         self._isdragging = False
-
         return wx.DragMove
 
-
     def MoveTabPage(self, nMove, nMoveTo):
         """ Moves a tab inside the same L{FlatNotebook}. """
-
-        if nMove == nMoveTo:
-            return
-
-        elif nMoveTo < len(self._pParent._windows):
-            nMoveTo = nMoveTo + 1
-
+        if nMove == nMoveTo: return
+        elif nMoveTo < len(self._pParent._windows): nMoveTo = nMoveTo + 1
         self._pParent.Freeze()
-
         # Remove the window from the main sizer
         nCurSel = self._pParent._pages.GetSelection()
         self._pParent._mainSizer.Detach(self._pParent._windows[nCurSel])
         self._pParent._windows[nCurSel].Hide()
-
         pWindow = self._pParent._windows[nMove]
         self._pParent._windows.pop(nMove)
         self._pParent._windows.insert(nMoveTo-1, pWindow)
-
         pgInfo = self._pagesInfoVec[nMove]
-
         self._pagesInfoVec.pop(nMove)
         self._pagesInfoVec.insert(nMoveTo - 1, pgInfo)
-
         # Add the page according to the style
         pSizer = self._pParent._mainSizer
         style = self.GetParent().GetWindowStyleFlag()
-
-        if style & FNB_BOTTOM:
-
-            pSizer.Insert(0, pWindow, 1, wx.EXPAND)
-
+        if style & FNB_BOTTOM: pSizer.Insert(0, pWindow, 1, wx.EXPAND)
         else:
-
             # We leave a space of 1 pixel around the window
             pSizer.Add(pWindow, 1, wx.EXPAND)
-
         pWindow.Show()
-
         pSizer.Layout()
         self._iActivePage = nMoveTo - 1
         self._iPreviousActivePage = -1
@@ -4630,128 +3470,79 @@
         self.Refresh()
         self._pParent.Thaw()
 
-
     def CanFitToScreen(self, page):
         """ Returns wheter a tab can fit in the left space in the screen or not. """
-
         # Incase the from is greater than page,
         # we need to reset the self._nFrom, so in order
         # to force the caller to do so, we return false
-        if self._nFrom > page:
-            return False
-
+        if self._nFrom > page: return False
         style = self.GetParent().GetWindowStyleFlag()
         render = self._mgr.GetRenderer(style)
-
         vTabInfo = render.NumberTabsCanFit(self)
-
-        if page - self._nFrom >= len(vTabInfo):
-            return False
-
+        if page - self._nFrom >= len(vTabInfo): return False
         return True
 
-
     def GetNumOfVisibleTabs(self):
         """ Returns the number of visible tabs. """
-
         count = 0
         for ii in xrange(self._nFrom, len(self._pagesInfoVec)):
-            if self._pagesInfoVec[ii].GetPosition() == wx.Point(-1, -1):
-                break
+            if self._pagesInfoVec[ii].GetPosition() == wx.Point(-1, -1): break
             count = count + 1
-
         return count
 
-
     def GetEnabled(self, page):
         """ Returns whether a tab is enabled or not. """
-
-        if page >= len(self._pagesInfoVec):
-            return True # Seems strange, but this is the default
-
+        if page >= len(self._pagesInfoVec): return True # Seems strange, but this is the default
         return self._pagesInfoVec[page].GetEnabled()
 
-
     def EnableTab(self, page, enabled=True):
         """ Enables or disables a tab. """
-
-        if page >= len(self._pagesInfoVec):
-            return
-
+        if page >= len(self._pagesInfoVec): return
         self._pagesInfoVec[page].EnableTab(enabled)
 
-
     def GetSingleLineBorderColour(self):
         """ Returns the colour for the single line border. """
-
-        if self.HasFlag(FNB_FANCY_TABS):
-            return self._colorFrom
-
+        if self.HasFlag(FNB_FANCY_TABS): return self._colorFrom
         return wx.WHITE
 
-
     def HasFlag(self, flag):
         """ Returns whether a flag is present in the L{FlatNotebook} style. """
-
         style = self.GetParent().GetWindowStyleFlag()
         res = (style & flag and [True] or [False])[0]
         return res
 
-
     def ClearFlag(self, flag):
         """ Deletes a flag from the L{FlatNotebook} style. """
-
         style = self.GetParent().GetWindowStyleFlag()
         style &= ~flag
         self.SetWindowStyleFlag(style)
 
-
     def TabHasImage(self, tabIdx):
         """ Returns whether a tab has an associated image index or not. """
-
         if self._ImageList:
             return self._pagesInfoVec[tabIdx].GetImageIndex() != -1
-
         return False
 
-
     def OnLeftDClick(self, event):
         """ Handles the wx.EVT_LEFT_DCLICK event for L{PageContainer}. """
-
         where, tabIdx = self.HitTest(event.GetPosition())
-
-        if where == FNB_RIGHT_ARROW:
-            self.RotateRight()
-
-        elif where == FNB_LEFT_ARROW:
-            self.RotateLeft()
-
+        if where == FNB_RIGHT_ARROW: self.RotateRight()
+        elif where == FNB_LEFT_ARROW: self.RotateLeft()
         elif self.HasFlag(FNB_DCLICK_CLOSES_TABS):
-
-            if where == FNB_TAB:
-                self.DeletePage(tabIdx)
-
-        else:
-
-            event.Skip()
-
+            if where == FNB_TAB: self.DeletePage(tabIdx)
+        else: event.Skip()
 
     def OnSetFocus(self, event):
         """ Handles the wx.EVT_SET_FOCUS event for L{PageContainer}. """
-
         if self._iActivePage < 0:
             event.Skip()
             return
-
         self.SetFocusedPage(self._iActivePage)
 
-
     def OnKillFocus(self, event):
         """ Handles the wx.EVT_KILL_FOCUS event for L{PageContainer}. """
-
         self.SetFocusedPage()
 
-
     def OnKeyDown(self, event):
         """
         When the PageContainer has the focus tabs can be changed with
@@ -4770,125 +3561,92 @@
         else:
             event.Skip()
 
-
     def SetFocusedPage(self, pageIndex=-1):
         """
         Sets/Unsets the focus on the appropriate page.
         If pageIndex is defaulted, we have lost focus and no focus indicator is drawn.
         """
-
         for indx, page in enumerate(self._pagesInfoVec):
             if indx == pageIndex:
                 page._hasFocus = True
             else:
                 page._hasFocus = False
-
         self.Refresh()
 
-
     def PopupTabsMenu(self):
         """ Pops up the menu activated with the drop down arrow in the navigation area. """
-
         popupMenu = wx.Menu()
-
         for i in xrange(len(self._pagesInfoVec)):
             pi = self._pagesInfoVec[i]
             item = wx.MenuItem(popupMenu, i+1, pi.GetCaption(), pi.GetCaption(), wx.ITEM_NORMAL)
             self.Bind(wx.EVT_MENU, self.OnTabMenuSelection, item)
-
             # There is an alignment problem with wx2.6.3 & Menus so only use
             # images for versions above 2.6.3
             if wx.VERSION > (2, 6, 3, 0) and self.TabHasImage(i):
                 item.SetBitmap(self.GetImageList().GetBitmap(pi.GetImageIndex()))
-
             popupMenu.AppendItem(item)
             item.Enable(pi.GetEnabled())
-
         self.PopupMenu(popupMenu)
 
-
     def OnTabMenuSelection(self, event):
         """ Handles the wx.EVT_MENU event for L{PageContainer}. """
-
         selection = event.GetId() - 1
         self.FireEvent(selection)
 
-
     def FireEvent(self, selection):
         """
         Fires the wxEVT_FLATNOTEBOOK_PAGE_CHANGING and wxEVT_FLATNOTEBOOK_PAGE_CHANGED events
         called from other methods (from menu selection or Smart Tabbing).
         Utility function.
         """
-
         if selection == self._iActivePage:
             # No events for the same selection
             return
-
         oldSelection = self._iActivePage
-
         event = FlatNotebookEvent(wxEVT_FLATNOTEBOOK_PAGE_CHANGING, self.GetParent().GetId())
         event.SetSelection(selection)
         event.SetOldSelection(oldSelection)
         event.SetEventObject(self.GetParent())
-
         if not self.GetParent().GetEventHandler().ProcessEvent(event) or event.IsAllowed():
-
             self.SetSelection(selection)
-
             # Fire a wxEVT_FLATNOTEBOOK_PAGE_CHANGED event
             event.SetEventType(wxEVT_FLATNOTEBOOK_PAGE_CHANGED)
             event.SetOldSelection(oldSelection)
             self.GetParent().GetEventHandler().ProcessEvent(event)
             self.SetFocus()
 
-
     def SetImageList(self, imglist):
         """ Sets the image list for the page control. """
-
         self._ImageList = imglist
 
-
     def AssignImageList(self, imglist):
         """ Assigns the image list for the page control. """
-
         self._ImageList = imglist
 
-
     def GetImageList(self):
         """ Returns the image list for the page control. """
-
         return self._ImageList
 
-
     def GetSelection(self):
         """ Returns the current selected page. """
 
         return self._iActivePage
 
-
     def GetPageCount(self):
         """ Returns the number of tabs in the L{FlatNotebook} control. """
-
         return len(self._pagesInfoVec)
 
-
     def GetPageText(self, page):
         """ Returns the tab caption of the page. """
-
         return self._pagesInfoVec[page].GetCaption()
 
-
     def SetPageText(self, page, text):
         """ Sets the tab caption of the page. """
-
         self._pagesInfoVec[page].SetCaption(text)
         return True
 
-
     def DrawDragHint(self):
         """ Draws small arrow at the place that the tab will be placed. """
-
         # get the index of tab that will be replaced with the dragged tab
         pt = wx.GetMousePosition()
         client_pt = self.ScreenToClient(pt)