home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 October / maximum-cd-2011-10.iso / DiscContents / digsby_setup.exe / lib / gui / uberwidgets / uberbook / tabbar.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-06-22  |  24.6 KB  |  819 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. from __future__ import with_statement
  5. from tab import Tab
  6. from gui import skin
  7. from OverlayImage import OverlayImage
  8. from navigation_arrows import Navi
  9. from gui.uberwidgets.UberButton import UberButton
  10. from gui.uberwidgets.UberEvents import EVT_DRAG_START
  11. import wx
  12. from wx import RectS, Rect, RectPS
  13. from util.primitives.funcs import do
  14. from common import pref, profile, prefprop
  15. from gui.uberwidgets import UberWidget
  16. from cgui import SimplePanel
  17. CUPID = wx.NewId()
  18. CDOWNID = wx.NewId()
  19. CLOSE_TAB = wx.NewId()
  20. CLOSE_OTHER_TABS = wx.NewId()
  21.  
  22. class TabBar(SimplePanel, UberWidget):
  23.     
  24.     def __init__(self, parent, skinkey):
  25.         SimplePanel.__init__(self, parent)
  26.         self.tabs = []
  27.         self.rows = []
  28.         self.rowindex = 0
  29.         self.tabindex = 0
  30.         self.tabendex = 0
  31.         events = [
  32.             (wx.EVT_PAINT, self.OnPaint),
  33.             (wx.EVT_SIZE, self.OnSize),
  34.             (wx.EVT_BUTTON, self.OnButton),
  35.             (wx.EVT_MOUSEWHEEL, self.OnWheel),
  36.             (wx.EVT_MOTION, self.OnMotion)]
  37.         for event, method in events:
  38.             self.Bind(event, method)
  39.         
  40.         self.flagedrows = set()
  41.         self.lastsize = self.Size
  42.         self.rowheight = 0
  43.         self.SetSkinKey(skinkey, True)
  44.         self.cupb = UberButton(self, CUPID, skin = self.scrollbuttonskin, icon = self.upicon)
  45.         self.cupb.Show(False)
  46.         self.cdownb = UberButton(self, CDOWNID, skin = self.scrollbuttonskin, icon = self.downicon)
  47.         self.cdownb.Show(False)
  48.         self.navi = Navi(self)
  49.         self.dragorigin = None
  50.         self.dragtarget = None
  51.         self.dropmarker = OverlayImage(self, self.dropmarkerimage)
  52.         self.dragside = None
  53.         link = profile.prefs.link
  54.         link('tabs.rows', self.Generate, False)
  55.         link('tabs.tabbar_x', self.Generate, False)
  56.         link('tabs.hide_at_1', self.Generate, False)
  57.         link('tabs.side_tabs', self.SkinRedirect, False)
  58.         self.Top.Bind(wx.EVT_MENU, self.OnMenuEvent)
  59.  
  60.     side_tabs = prefprop('tabs.side_tabs')
  61.     tab_rows = prefprop('tabs.rows', 2)
  62.     
  63.     def UpdateSkin(self):
  64.         key = self.tabskin = self.skinkey
  65.         
  66.         g = lambda k, default = (sentinel,): skin.get(key + '.' + k, default)
  67.         
  68.         sg = lambda k, default = (sentinel,): skin.get('side' + key + '.' + k, default)
  69.         elems = (('spacing', 'spacing', 2), ('bg', 'backgrounds.bar'), ('dropmarkerimage', 'dropmarker.image'), ('dropmarkeroffset', 'dropmarker.offset', 0), ('closebuttonskin', 'closebuttonskin', ''), ('closeicon', 'icons.close', None), ('scrollbuttonskin', 'scrollbuttonskin', ''), ('lefticon', 'icons.left', ''), ('righticon', 'icons.right', ''), ('upicon', 'icons.up', ''), ('downicon', 'icons.down', ''))
  70.         for elem in elems:
  71.             setattr(self, 'top' + elem[0], g(*elem[1:]))
  72.             setattr(self, 'side' + elem[0], sg(elem[1], getattr(self, 'top' + elem[0])))
  73.             None(setattr, self, elem[0](getattr, self if self.side_tabs else 'top' + elem[0]))
  74.         
  75.         if hasattr(self, 'dropmarker'):
  76.             self.dropmarker.SetImage(self.dropmarkerimage)
  77.             if self.side_tabs:
  78.                 pass
  79.             self.dropmarker.SetRotation(not (self.dropmarkerimage))
  80.         
  81.         navi = getattr(self, 'navi', None)
  82.         if navi is not None:
  83.             self.cdownb.SetSkinKey(self.scrollbuttonskin)
  84.             self.cupb.SetSkinKey(self.scrollbuttonskin)
  85.             self.cdownb.SetIcon(self.downicon)
  86.             self.cupb.SetIcon(self.upicon)
  87.             self.navi.closebutton.SetSkinKey(self.closebuttonskin)
  88.             self.navi.closebutton.SetIcon(self.closeicon)
  89.             scrollskin = self.scrollbuttonskin
  90.             navi.prevb.SetSkinKey(scrollskin)
  91.             navi.nextb.SetSkinKey(scrollskin)
  92.             navi.upb.SetSkinKey(scrollskin)
  93.             navi.downb.SetSkinKey(scrollskin)
  94.             navi.prevb.SetIcon(self.lefticon)
  95.             navi.nextb.SetIcon(self.righticon)
  96.             navi.upb.SetIcon(self.upicon)
  97.             navi.downb.SetIcon(self.downicon)
  98.         
  99.         wx.CallAfter(self.Generate)
  100.  
  101.     
  102.     def SkinRedirect(self, val = None):
  103.         elems = ('spacing', 'bg', 'dropmarkerimage', 'closebuttonskin', 'closeicon', 'scrollbuttonskin', 'lefticon', 'righticon', 'upicon', 'downicon')
  104.         for elem in elems:
  105.             None(setattr, self, elem(getattr, self if self.side_tabs else 'top' + elem))
  106.         
  107.         self.UpdateChildSkins()
  108.  
  109.     
  110.     def UpdateChildSkins(self):
  111.         self.cdownb.SetSkinKey(self.scrollbuttonskin, True)
  112.         self.cupb.SetSkinKey(self.scrollbuttonskin, True)
  113.         navi = self.navi
  114.         sbs = self.scrollbuttonskin
  115.         navi.closebutton.SetSkinKey(self.closebuttonskin, True)
  116.         navi.prevb.SetSkinKey(sbs, True)
  117.         navi.nextb.SetSkinKey(sbs, True)
  118.         navi.upb.SetSkinKey(sbs, True)
  119.         navi.downb.SetSkinKey(sbs, True)
  120.         self.UpdateChildrenIcons()
  121.         for tab in self.tabs:
  122.             tab.UpdateMode()
  123.         
  124.         self.Generate()
  125.  
  126.     
  127.     def __repr__(self):
  128.         return '<TabBar %r>' % self.tabs
  129.  
  130.     
  131.     def OnDragStart(self, tab):
  132.         self.NotifyDrag(tab)
  133.  
  134.     
  135.     def OnMotion(self, event):
  136.         if event.LeftIsDown():
  137.             if self.dragorigin or self.Manager.source:
  138.                 self.DragCalc(event.Position)
  139.             
  140.  
  141.     
  142.     def __getitem__(self, index):
  143.         return self.tabs[index]
  144.  
  145.     
  146.     def OnPaint(self, event):
  147.         dc = wx.PaintDC(self)
  148.         rect = RectS(self.Size)
  149.         if not self.side_tabs:
  150.             rcount = min(len(self.rows), pref('tabs.rows', 2))
  151.             height = self.tabs[0].Size.height
  152.             y = 0
  153.             for unused_i in xrange(rcount):
  154.                 self.bg.Draw(dc, Rect(rect.x, y, rect.width, height))
  155.                 y += height
  156.             
  157.         else:
  158.             self.bg.Draw(dc, rect)
  159.  
  160.     
  161.     def Add(self, page, focus, resort = True):
  162.         tab = Tab(self, page, skinkey = self.tabskin)
  163.         tab.Bind(wx.EVT_CONTEXT_MENU, self.ShowMenu)
  164.         tab.Show(False)
  165.         self.tabs.append(tab)
  166.         if focus:
  167.             wx.CallAfter(tab.SetActive, True)
  168.         elif resort:
  169.             if self.side_tabs:
  170.                 self.ReVgenerate()
  171.             else:
  172.                 self.Regenerate(True)
  173.         
  174.         return tab
  175.  
  176.     
  177.     def ShowMenu(self, e):
  178.         self._menutab = e.EventObject
  179.         
  180.         try:
  181.             menu = self._tabmenu
  182.         except AttributeError:
  183.             UMenu = UMenu
  184.             import gui.uberwidgets.umenu
  185.             menu = self._tabmenu = UMenu(self)
  186.             menu.AddItem('Close &Other Tabs', id = CLOSE_OTHER_TABS)
  187.             menu.AddSep()
  188.             menu.AddItem('&Close Tab', id = CLOSE_TAB)
  189.  
  190.         menu.PopupMenu()
  191.  
  192.     
  193.     def OnMenuEvent(self, e):
  194.         if e.Id == CLOSE_TAB:
  195.             self._menutab.CloseTab()
  196.         elif e.Id == CLOSE_OTHER_TABS:
  197.             menutab = self._menutab
  198.             menutab.active = True
  199.             self.Frozen().__enter__()
  200.             
  201.             try:
  202.                 for tab in self.tabs[:]:
  203.                     if tab is not menutab:
  204.                         tab.CloseTab()
  205.                         continue
  206.                     self.Frozen().__exit__
  207.             finally:
  208.                 pass
  209.  
  210.         else:
  211.             e.Skip()
  212.  
  213.     
  214.     def Generate(self, val = None):
  215.         self.navi.closebutton.Show(pref('tabs.tabbar_x', False))
  216.         if self.side_tabs:
  217.             self.ReVgenerate(True)
  218.         else:
  219.             self.Regenerate()
  220.  
  221.     
  222.     def ReVgenerate(self, total = False, safe = False, dotoggle = True):
  223.         tabs = self.tabs
  224.         if not tabs:
  225.             return None
  226.         do((lambda .0: for tab in .0:
  227. tab.Show(False))(self.tabs))
  228.         for tab in self.tabs:
  229.             tab.row = None
  230.         
  231.         del self.rows[:]
  232.         if self.tabindex < 0 or self.tabindex >= len(tabs):
  233.             self.tabindex = 0
  234.         
  235.         n = self.tabindex
  236.         self.rowheight = tabs[0].GetMinHeight()
  237.         area = self.Notebook.Size.height - 32
  238.         i = area // self.rowheight
  239.         count = len(tabs)
  240.         for r in xrange(count):
  241.             tabs[r].row = r
  242.         
  243.         rows = self.rows
  244.         size = self.Size
  245.         navi = self.navi
  246.         navi.ShowNav(4)
  247.         navi.Hide()
  248.         navi.Position = wx.Point(size.width - navi.Size.width, 0)
  249.         if (total and not rows or i + 1 != len(rows[0])) and not (i > len(rows[0])) and len(rows[0]) == len(tabs):
  250.             rows.append([])
  251.             col = rows[0]
  252.             if i >= count:
  253.                 n = 0
  254.                 self.tabindex = 0
  255.                 (do,)((lambda .0: for tab in .0:
  256. col.append(tab))(tabs))
  257.                 av = col[0].MinSize.height
  258.             else:
  259.                 for t in xrange(n, n + i + 1):
  260.                     if t < len(tabs):
  261.                         col.append(tabs[t])
  262.                         continue
  263.                 
  264.                 while len(col) < i and n > 0:
  265.                     n -= 1
  266.                     col.insert(0, tabs[n])
  267.                 if col:
  268.                     av = col[0].MinSize.height
  269.                 
  270.         else:
  271.             col = rows[0]
  272.             av = col[0].MinSize.height
  273.         count = 16
  274.         for t in col:
  275.             t.Size = (self.Size.width, av)
  276.             t.Position = (0, count)
  277.             count += av
  278.             t.Show()
  279.         
  280.         self.tabindex = n
  281.         endex = self.tabendex = n + len(col)
  282.         if dotoggle:
  283.             self.Toggle()
  284.         
  285.         cupb = self.cupb
  286.         cdownb = self.cdownb
  287.         cupb.Enable(self.tabindex != 0)
  288.         if not endex < len(tabs):
  289.             pass
  290.         cdownb.Enable(tabs[endex - 1].Position.y + tabs[endex - 1].Size.height > size.height - 16)
  291.         self.UpdateNotify()
  292.  
  293.     
  294.     def Regenerate(self, safe = False, dotoggle = True):
  295.         if not self.IsShown() and len(self.tabs) == 1:
  296.             return None
  297.         self.Frozen().__enter__()
  298.         
  299.         try:
  300.             self._Regenerate(safe = safe, dotoggle = dotoggle)
  301.         finally:
  302.             pass
  303.  
  304.         self.Refresh(False)
  305.  
  306.     
  307.     def _Regenerate(self, safe = False, dotoggle = True):
  308.         self.cupb.Show(False)
  309.         self.cdownb.Show(False)
  310.         parentpage = self.Parent.pagecontainer
  311.         style = self.tab_rows
  312.         if not safe:
  313.             pass
  314.         careful = parentpage.active
  315.         for tab in self.tabs:
  316.             tab.Show(False)
  317.             tab.row = None
  318.         
  319.         del self.rows[:]
  320.         tally = sum((lambda .0: for tab in .0:
  321. tab.MinSize.width)(self.tabs))
  322.         navi = self.navi
  323.         tabs = self.tabs
  324.         rows = self.rows
  325.         if not tabs:
  326.             return None
  327.         if self.tabindex < 0 or self.tabindex >= len(tabs):
  328.             self.tabindex = 0
  329.         
  330.         n = self.tabindex
  331.         i = n
  332.         row = 0
  333.         self.rowheight = tabs[0].MinHeight
  334.         my_w = self.Size.width
  335.         nav_w = navi.Size.width
  336.         if tally >= my_w - nav_w and not style:
  337.             navi.ShowNav(1)
  338.         elif tally >= my_w - nav_w:
  339.             navi.ShowNav(3)
  340.         else:
  341.             navi.ShowNav(0)
  342.         navi.Freeze()
  343.         navi.Show(True)
  344.         navi.Fit()
  345.         navi.Position = wx.Point(self.Size.width - navi.Size.width, 0)
  346.         navi.Size = wx.Size(-1, self.Size.height)
  347.         navi.Thaw()
  348.         area = self.Notebook.Size.width - navi.Size.width
  349.         while len(tabs) > i:
  350.             tally = tabs[i].MinSize.width
  351.             rows.append([])
  352.             while i < len(tabs) and tally < area:
  353.                 i += 1
  354.                 if i < len(tabs):
  355.                     tally += tabs[i].MinSize.width
  356.                     continue
  357.             if careful and not style:
  358.                 activeindex = tabs.index(parentpage.active.tab)
  359.                 change = False
  360.                 while activeindex >= i and n != i:
  361.                     i += 1
  362.                     tally += tabs[i].MinSize.width
  363.                     change = True
  364.                 if tally >= area and change:
  365.                     tally -= tabs[n].MinSize.width
  366.                     n += 1
  367.                     self.tabindex = n
  368.                 
  369.             
  370.             if not style:
  371.                 while n > 0 and area - tally > tabs[n - 1].MinSize.width:
  372.                     n -= 1
  373.                     self.tabindex = n
  374.                     tally += tabs[n].MinSize.width
  375.             
  376.             if not style:
  377.                 break
  378.             
  379.             row += 1
  380.             n = i
  381.         if self.rowindex >= len(rows):
  382.             self.rowindex = len(rows) - 1
  383.         
  384.         row = self.rowindex
  385.         if not self.tab_rows:
  386.             pass
  387.         visible = 1
  388.         if careful and style:
  389.             active = parentpage.active.tab
  390.             for ir, r in enumerate(rows):
  391.                 if active in r:
  392.                     if ir < row:
  393.                         row = self.rowindex = ir
  394.                     elif ir >= row + visible:
  395.                         row = ir - visible - 1
  396.                     
  397.                 ir < row
  398.             
  399.         
  400.         if len(rows) - (row + 1) < visible and len(rows) >= visible:
  401.             row = len(rows) - visible
  402.             self.rowindex = row
  403.         
  404.         while row < len(rows) and row < self.rowindex + visible and len(rows[row]) != 0:
  405.             if rows.index(rows[row]) == len(rows) - 1:
  406.                 if style or len(rows[row]) == len(tabs):
  407.                     for t in xrange(0, len(rows[row])):
  408.                         thistab = rows[row][t]
  409.                         thistab.SetSize(thistab.MinSize)
  410.                         if not t:
  411.                             thistab.SetPosition((0, self.rowheight * (row - self.rowindex)))
  412.                         else:
  413.                             thistab.SetPosition((rows[row][t - 1].Position.x + rows[row][t - 1].Size.width, self.rowheight * (row - self.rowindex)))
  414.                         thistab.Show(True)
  415.                     
  416.                 elif len(rows) > row:
  417.                     ordered = [ rows[row].index(t) for t in sorted(rows[row], key = (lambda o: o.MinSize.width), reverse = True) ]
  418.                     length = len(ordered)
  419.                     reserved = 0
  420.                     o = 0
  421.                     av = (area - reserved) / (length - o)
  422.                     mark = 0
  423.                     while o < length:
  424.                         for t in xrange(o, length):
  425.                             tab = rows[row][ordered[t]]
  426.                             if tab.GetMinSize()[0] > av:
  427.                                 tab.SetSize(tab.MinSize)
  428.                                 reserved += tab.MinSize.width
  429.                                 o += 1
  430.                                 mark = o
  431.                                 if length - o:
  432.                                     av = (area - reserved) / (length - o)
  433.                                 
  434.                             length - o
  435.                             o += 1
  436.                         
  437.                         continue
  438.                         []
  439.                     for t in xrange(mark, length):
  440.                         tab = rows[row][ordered[t]]
  441.                         tab.SetSize((av, tab.MinSize.height))
  442.                     
  443.                     for t, tab in enumerate(rows[row]):
  444.                         tab.Show(True)
  445.                     
  446.                 
  447.             row += 1
  448.         if dotoggle:
  449.             self.Toggle()
  450.         
  451.         if len(rows) < style or not style:
  452.             rows_shown = len(rows)
  453.         else:
  454.             rows_shown = style
  455.         if self.Parent.SashPosition != rows_shown * self.rowheight:
  456.             self.MinSize = wx.Size(-1, rows_shown * self.rowheight)
  457.             self.Parent.SetSashPosition(self.MinSize.height)
  458.         
  459.         navi.Enabler()
  460.         self.tabendex = i - 1
  461.         self.UpdateNotify()
  462.         navi.Size = wx.Size(-1, rows_shown * self.rowheight)
  463.  
  464.     
  465.     def Remove(self, target):
  466.         index = self.tabs.index(target)
  467.         self.tabs.remove(target)
  468.         if len(self.tabs) == 0:
  469.             self.Notebook.window.Close()
  470.         elif index > self.tabindex and index < self.tabendex and self.tabindex > 0:
  471.             self.tabindex -= 1
  472.         
  473.         if self.side_tabs:
  474.             self.ReVgenerate(total = True)
  475.         else:
  476.             self.Regenerate(safe = True)
  477.  
  478.     
  479.     def OnSize(self, event):
  480.         event.Skip()
  481.         if self.side_tabs and self.tabs:
  482.             cupb = self.cupb
  483.             cdownb = self.cdownb
  484.             size = self.Size
  485.             tabs = self.tabs
  486.             endex = self.tabendex
  487.             cupb.Position = (0, 0)
  488.             cupb.Size = (size.width, 16)
  489.             cupb.Show()
  490.             cupb.Enable(self.tabindex != 0)
  491.             cdownb.Position = (0, size.height - 16)
  492.             cdownb.Size = (size.width, 16)
  493.             cdownb.Show()
  494.             if not endex < len(tabs):
  495.                 pass
  496.             cdownb.Enable(tabs[endex - 1].Position.y + tabs[endex - 1].Size.height > size.height - 16)
  497.         
  498.         sz = self.Size
  499.         if (sz.width != self.lastsize.width or not (self.side_tabs) or sz != self.lastsize or self.side_tabs) and self.IsShownOnScreen():
  500.             self.lastsize = sz
  501.             if self.side_tabs:
  502.                 self.ReVgenerate(dotoggle = False)
  503.             else:
  504.                 self.Regenerate(False, dotoggle = False)
  505.         
  506.         
  507.         try:
  508.             wx.CallAfter(wx.CallAfter, self.Parent.pagecontainer.active.panel.input_area.expandEvent)
  509.         except AttributeError:
  510.             pass
  511.  
  512.         self.Refresh(False)
  513.  
  514.     
  515.     def GetTabCount(self):
  516.         return [](_[1])
  517.  
  518.     
  519.     def NextTab(self):
  520.         self.SetNextActive(self.ActiveTab, wrap = True)
  521.  
  522.     
  523.     def PrevTab(self):
  524.         self.SetLastActive(self.ActiveTab, wrap = True)
  525.  
  526.     
  527.     def SetNextActive(self, origin, wrap = False):
  528.         if origin in self.tabs:
  529.             index = self.tabs.index(origin)
  530.             if not (index < len(self.tabs) - 1) and wrap:
  531.                 self.tabs[0].SetActive(True)
  532.             elif index < len(self.tabs) - 1:
  533.                 self.tabs[index + 1].SetActive(True)
  534.             elif index > 0:
  535.                 self.tabs[index - 1].SetActive(True)
  536.             
  537.             self.Refresh(False)
  538.         
  539.  
  540.     
  541.     def SetLastActive(self, origin, wrap = False):
  542.         if origin in self.tabs:
  543.             index = self.tabs.index(origin)
  544.             if not (index > 0) and wrap:
  545.                 self.tabs[len(self.tabs) - 1].SetActive(True)
  546.             elif index > 0:
  547.                 self.tabs[index - 1].SetActive(True)
  548.             elif index < 0:
  549.                 self.tabs[index + 1].SetActive(True)
  550.             
  551.             self.Refresh(False)
  552.         
  553.  
  554.     
  555.     def SyncActive(self, atab):
  556.         if not atab:
  557.             return None
  558.         if self.side_tabs:
  559.             if atab < self.tabindex:
  560.                 self.tabindex = atab
  561.                 self.ReVgenerate(True)
  562.             else:
  563.                 thetab = self.tabs[atab]
  564.                 while atab >= self.tabendex or thetab.Position.y + thetab.Size.height > self.Size.height - 16:
  565.                     self.tabindex += 1
  566.                     self.ReVgenerate(True)
  567.                     continue
  568.                     self
  569.         else:
  570.             style = self.tab_rows
  571.             if atab < self.rowindex:
  572.                 self.rowindex = atab
  573.                 self.Regenerate()
  574.             elif atab > self.rowindex + style - 1:
  575.                 self.rowindex = (atab - style) + 1
  576.                 self.Regenerate()
  577.             
  578.  
  579.     
  580.     def OnWheel(self, event):
  581.         if RectS(self.Size).Contains(event.Position):
  582.             direction = event.GetWheelRotation()
  583.             if direction < 0:
  584.                 self.SetNextActive(self.ActiveTab, True)
  585.             elif direction > 0:
  586.                 self.SetLastActive(self.ActiveTab, True)
  587.             
  588.         
  589.  
  590.     
  591.     def Notebook(self):
  592.         return self.Parent
  593.  
  594.     Notebook = property(Notebook)
  595.     
  596.     def Manager(self):
  597.         return self.Notebook.manager
  598.  
  599.     Manager = property(Manager)
  600.     
  601.     def ActiveTab(self):
  602.         active = self.Notebook.pagecontainer.active
  603.         if active is not None:
  604.             return active.tab
  605.  
  606.     ActiveTab = property(ActiveTab)
  607.     
  608.     def OnButton(self, event):
  609.         if event.GetId() == CUPID:
  610.             if self.tabindex > 0:
  611.                 self.tabindex -= 1
  612.                 self.ReVgenerate(total = True)
  613.             
  614.         elif event.GetId() == CDOWNID:
  615.             if self.tabendex < len(self.tabs) or self.tabs[self.tabendex - 1].Position.y + self.tabs[self.tabendex - 1].Size.height > self.Size.height - 16:
  616.                 self.tabindex += 1
  617.                 self.ReVgenerate(total = True)
  618.             
  619.         
  620.         self.UpdateNotify()
  621.  
  622.     
  623.     def NotifyDrag(self, origin):
  624.         self.dragorigin = origin
  625.         origin.SetCursor(wx.StockCursor(wx.CURSOR_NO_ENTRY))
  626.         self.Manager.Notify(self.Notebook)
  627.  
  628.     
  629.     def DragCalc(self, point):
  630.         sidetabs = self.side_tabs
  631.         if not (self.dragorigin) and self.Manager.source:
  632.             master = self.Manager.source
  633.             dragorigin = master.tabbar.dragorigin
  634.             self.Manager.Request(self.Notebook)
  635.         else:
  636.             dragorigin = self.dragorigin
  637.         if not (self.dragtarget) or not self.dragtarget.Rect.Contains(point):
  638.             wap = wx.FindWindowAtPointer()
  639.             self.dragtarget = None if isinstance(wap, Tab) else None
  640.             self.dragside = None
  641.         
  642.         if self.dragtarget and self.dragtarget != dragorigin:
  643.             dtrect = self.dragtarget.Rect
  644.             if not sidetabs:
  645.                 x = point[0] - dtrect.x
  646.                 x2 = dtrect.width / 2
  647.             else:
  648.                 x = point[1] - dtrect.y
  649.                 x2 = dtrect.height / 2
  650.             if x <= x2:
  651.                 if self.dragside != False:
  652.                     self.dragside = False
  653.                     if not sidetabs:
  654.                         self.DrawDropMarker(dtrect.x, dtrect.y)
  655.                     else:
  656.                         self.DrawDropMarker(dtrect.x, dtrect.y)
  657.                 
  658.             elif not self.dragside:
  659.                 self.dragside = True
  660.                 if not sidetabs:
  661.                     self.DrawDropMarker(dtrect.x + dtrect.width, dtrect.y)
  662.                 else:
  663.                     self.DrawDropMarker(dtrect.x, dtrect.y + dtrect.height)
  664.             
  665.             self.SetFocus()
  666.         elif not dragorigin or self.dragtarget != dragorigin:
  667.             if (dragorigin == None or self.dragtarget == None) and self.Rect.Contains(point):
  668.                 if not sidetabs:
  669.                     row = self.rows[point[1] // self.rowheight + self.rowindex]
  670.                     tab = row[len(row) - 1]
  671.                     self.dragside = True
  672.                 elif point.y > self.rowheight:
  673.                     tab = self.rows[0][len(self.rows[0]) - 1]
  674.                     self.dragside = True
  675.                 else:
  676.                     tab = self.rows[0][0]
  677.                     self.dragside = False
  678.                 dtrect = tab.Rect
  679.                 if not sidetabs:
  680.                     self.DrawDropMarker(dtrect.x + dtrect.width, dtrect.y)
  681.                 elif self.dragside == True:
  682.                     self.DrawDropMarker(dtrect.x, dtrect.y + dtrect.height)
  683.                 else:
  684.                     self.DrawDropMarker(dtrect.x + dtrect.width / 2, dtrect.y)
  685.                 self.SetFocus()
  686.                 self.dragtarget = tab
  687.             else:
  688.                 self.dropmarker.Show(False)
  689.  
  690.     
  691.     def DragFinish(self, new = False):
  692.         if not wx.IsDestroyed(self.dragorigin):
  693.             self.dragorigin.SetCursor(wx.StockCursor(wx.CURSOR_ARROW))
  694.         
  695.         if self.dragorigin and self.dragorigin.previewtabs:
  696.             self.dragorigin.previewtabs.Stop()
  697.             self.dragorigin.previewtabs = None
  698.         
  699.         rect = RectPS(self.Notebook.ClientToScreen(self.Position), self.Size)
  700.         parentrect = self.Notebook.window.Rect
  701.         mousepos = wx.GetMousePosition()
  702.         manager = self.Manager
  703.         if not new:
  704.             if manager.destination or not parentrect.Contains(mousepos) or not rect.Contains(mousepos):
  705.                 if self.ActiveTab == self.dragorigin:
  706.                     self.SetNextActive(self.dragorigin)
  707.                 
  708.                 self.dragorigin.Show(False)
  709.                 dest = manager.destination
  710.                 if not dest or not dest.tabbar.Rect.Contains(dest.ScreenToClient(wx.GetMousePosition())):
  711.                     originsize = self.dragorigin.GetSize()
  712.                     newpoint = wx.Point(mousepos[0] - originsize[0], mousepos[1] - originsize[1])
  713.                     destination = self.Notebook.winman.NewWindow(newpoint, self.Notebook.window.GetSize()).notebook
  714.                 else:
  715.                     destination = dest
  716.                 manager.Request()
  717.                 page = self.dragorigin.page
  718.                 self.Notebook.did_remove(page.panel)
  719.                 del self.dragorigin.page
  720.                 del page.tab
  721.                 self.tabs.remove(self.dragorigin)
  722.                 self.dragorigin.Close()
  723.                 destination.Insert(page, False)
  724.                 manager.Notify()
  725.                 self.dragorigin = None
  726.                 if self.side_tabs:
  727.                     self.ReVgenerate(True)
  728.                 else:
  729.                     self.Regenerate(safe = True)
  730.             elif self.dragtarget and self.dragorigin and self.dragorigin != self.dragtarget and self.Rect.Contains(self.Notebook.ScreenToClient(mousepos)):
  731.                 self.tabs.remove(self.dragorigin)
  732.                 pos = None + self.tabs.index(self.dragtarget) if self.dragside else 0
  733.                 self.tabs.insert(pos, self.dragorigin)
  734.                 after = None if pos + 1 < len(self.tabs) else None
  735.                 if after is not None:
  736.                     after = after.page.panel
  737.                 
  738.                 wx.CallAfter(self.Notebook.did_rearrange, self.dragorigin.page.panel, after)
  739.                 if self.side_tabs:
  740.                     self.ReVgenerate(True)
  741.                 else:
  742.                     self.Regenerate()
  743.             elif new:
  744.                 if self.side_tabs:
  745.                     self.ReVgenerate(True)
  746.                 else:
  747.                     self.Regenerate()
  748.             
  749.         if self.dragorigin:
  750.             self.dragorigin.OnMouseLeave()
  751.         
  752.         self.dropmarker.Show(False)
  753.         self.dragorigin = None
  754.         self.dragtarget = None
  755.         dest = manager.destination
  756.         if dest:
  757.             dest.tabbar.dragorigin = None
  758.             dest.tabbar.dragtarget = None
  759.         
  760.         manager.Request()
  761.         manager.Notify()
  762.         if len(self.tabs) == 0:
  763.             self.Notebook.window.Close()
  764.         
  765.  
  766.     
  767.     def DrawDropMarker(self, x, y):
  768.         self.dropmarker.Teleport(self.ClientToScreen((x, y + self.dropmarkeroffset)))
  769.         if not self.dropmarker.IsShown():
  770.             self.Manager.ShowDropMarker(self.dropmarker)
  771.         
  772.  
  773.     
  774.     def Toggle(self, switch = None):
  775.         if pref('tabs.hide_at_1', True) and len(self.tabs) <= 1 and not switch:
  776.             self.Notebook.Split(False)
  777.             self.ProcessEvent(wx.CommandEvent(wx.wxEVT_SIZE))
  778.         else:
  779.             self.Notebook.Split(True)
  780.  
  781.     
  782.     def UpdateNotify(self):
  783.         frows = self.flagedrows
  784.         frows.clear()
  785.         if self.side_tabs:
  786.             tabs = self.tabs
  787.             for i, tab in enumerate(tabs):
  788.                 if tab.notified:
  789.                     frows.add(i)
  790.                     continue
  791.                 if i in self.flagedrows:
  792.                     frows.remove(i)
  793.                     continue
  794.             
  795.             if len(frows):
  796.                 pass
  797.             self.cupb.SetNotify(min(frows) < self.tabindex)
  798.             if not len(frows) and max(frows) >= self.tabendex:
  799.                 pass
  800.             self.cdownb.SetNotify(tabs[max(frows)].Position.y + tabs[max(frows)].Size.height > self.Size.height - 16)
  801.         else:
  802.             for i, row in enumerate(self.rows):
  803.                 flaged = False
  804.                 for tab in row:
  805.                     if tab and tab.notified:
  806.                         flaged = True
  807.                         frows.add(i)
  808.                         continue
  809.                 
  810.             
  811.             if len(frows):
  812.                 pass
  813.             self.navi.upb.SetNotify(min(frows) < self.rowindex)
  814.             if len(frows):
  815.                 pass
  816.             self.navi.downb.SetNotify(max(frows) > self.rowindex + self.tab_rows - 1)
  817.  
  818.  
  819.