check in Tal Einat's update to tabpage.py

Patch 1612746

M    configDialog.py
M    NEWS.txt
AM   tabbedpages.py

Lib/idlelib/NEWS.txt

@@ -3,6 +3,9 @@ What's New in IDLE 2.6a1?
 
 *Release date: XX-XXX-200X*
 
+- tabpage.py updated: tabbedPages.py now supports multiple dynamic rows
+  of tabs.  Patch 1612746 Tal Einat.
+
 - Add confirmation dialog before printing.  Patch 1717170 Tal Einat.
 
 - Show paste position if > 80 col.  Patch 1659326 Tal Einat.

Lib/idlelib/configDialog.py

@@ -15,7 +15,7 @@ import string, copy
 
 from configHandler import idleConf
 from dynOptionMenuWidget import DynOptionMenu
-from tabpage import TabPageSet
+from tabbedpages import TabbedPageSet
 from keybindingDialog import GetKeysDialog
 from configSectionNameDialog import GetCfgSectionNameDialog
 from configHelpSourceEdit import GetHelpSourceDialog
@@ -65,10 +65,9 @@ class ConfigDialog(Toplevel):
         self.wait_window()
 
     def CreateWidgets(self):
-        self.tabPages = TabPageSet(self,
-                pageNames=['Fonts/Tabs','Highlighting','Keys','General'])
-        self.tabPages.ChangePage()#activates default (first) page
-        frameActionButtons = Frame(self)
+        self.tabPages = TabbedPageSet(self,
+                page_names=['Fonts/Tabs','Highlighting','Keys','General'])
+        frameActionButtons = Frame(self,pady=2)
         #action buttons
         self.buttonHelp = Button(frameActionButtons,text='Help',
                 command=self.Help,takefocus=FALSE,
@@ -103,7 +102,7 @@ class ConfigDialog(Toplevel):
         self.editFont=tkFont.Font(self,('courier',10,'normal'))
         ##widget creation
         #body frame
-        frame=self.tabPages.pages['Fonts/Tabs']['page']
+        frame=self.tabPages.pages['Fonts/Tabs'].frame
         #body section frames
         frameFont=LabelFrame(frame,borderwidth=2,relief=GROOVE,
                              text=' Base Editor Font ')
@@ -167,7 +166,7 @@ class ConfigDialog(Toplevel):
         self.highlightTarget=StringVar(self)
         ##widget creation
         #body frame
-        frame=self.tabPages.pages['Highlighting']['page']
+        frame=self.tabPages.pages['Highlighting'].frame
         #body section frames
         frameCustom=LabelFrame(frame,borderwidth=2,relief=GROOVE,
                                text=' Custom Highlighting ')
@@ -255,7 +254,7 @@ class ConfigDialog(Toplevel):
         self.keyBinding=StringVar(self)
         ##widget creation
         #body frame
-        frame=self.tabPages.pages['Keys']['page']
+        frame=self.tabPages.pages['Keys'].frame
         #body section frames
         frameCustom=LabelFrame(frame,borderwidth=2,relief=GROOVE,
                                text=' Custom Key Bindings ')
@@ -325,7 +324,7 @@ class ConfigDialog(Toplevel):
         self.helpBrowser=StringVar(self)
         #widget creation
         #body
-        frame=self.tabPages.pages['General']['page']
+        frame=self.tabPages.pages['General'].frame
         #body section frames
         frameRun=LabelFrame(frame,borderwidth=2,relief=GROOVE,
                             text=' Startup Preferences ')

Lib/idlelib/tabbedpages.py

+"""An implementation of tabbed pages using only standard Tkinter.
+
+Originally developed for use in IDLE. Based on tabpage.py.
+
+Classes exported:
+TabbedPageSet -- A Tkinter implementation of a tabbed-page widget.
+TabBarSet -- A widget containing tabs (buttons) in one or more rows.
+
+"""
+from Tkinter import *
+
+class InvalidNameError(Exception): pass
+class AlreadyExistsError(Exception): pass
+
+
+class TabBarSet(Frame):
+    """A widget containing tabs (buttons) in one or more rows.
+
+    Only one tab may be selected at a time.
+
+    """
+    def __init__(self, page_set, select_command,
+                 tabs=None, n_rows=1, max_tabs_per_row=5,
+                 expand_tabs=False, **kw):
+        """Constructor arguments:
+
+        select_command -- A callable which will be called when a tab is
+        selected. It is called with the name of the selected tab as an
+        argument.
+
+        tabs -- A list of strings, the names of the tabs. Should be specified in
+        the desired tab order. The first tab will be the default and first
+        active tab. If tabs is None or empty, the TabBarSet will be initialized
+        empty.
+
+        n_rows -- Number of rows of tabs to be shown. If n_rows <= 0 or is
+        None, then the number of rows will be decided by TabBarSet. See
+        _arrange_tabs() for details.
+
+        max_tabs_per_row -- Used for deciding how many rows of tabs are needed,
+        when the number of rows is not constant. See _arrange_tabs() for
+        details.
+
+        """
+        Frame.__init__(self, page_set, **kw)
+        self.select_command = select_command
+        self.n_rows = n_rows
+        self.max_tabs_per_row = max_tabs_per_row
+        self.expand_tabs = expand_tabs
+        self.page_set = page_set
+
+        self._tabs = {}
+        self._tab2row = {}
+        if tabs:
+            self._tab_names = list(tabs)
+        else:
+            self._tab_names = []
+        self._selected_tab = None
+        self._tab_rows = []
+
+        self.padding_frame = Frame(self, height=2,
+                                   borderwidth=0, relief=FLAT,
+                                   background=self.cget('background'))
+        self.padding_frame.pack(side=TOP, fill=X, expand=False)
+
+        self._arrange_tabs()
+
+    def add_tab(self, tab_name):
+        """Add a new tab with the name given in tab_name."""
+        if not tab_name:
+            raise InvalidNameError("Invalid Tab name: '%s'" % tab_name)
+        if tab_name in self._tab_names:
+            raise AlreadyExistsError("Tab named '%s' already exists" %tab_name)
+
+        self._tab_names.append(tab_name)
+        self._arrange_tabs()
+
+    def remove_tab(self, tab_name):
+        """Remove the tab with the name given in tab_name."""
+        if not tab_name in self._tab_names:
+            raise KeyError("No such Tab: '%s" % page_name)
+
+        self._tab_names.remove(tab_name)
+        self._arrange_tabs()
+
+    def select_tab(self, tab_name):
+        """Select the tab with the name given in tab_name."""
+        if tab_name == self._selected_tab:
+            return
+        if tab_name is not None and tab_name not in self._tabs:
+            raise KeyError("No such Tab: '%s" % page_name)
+
+        # deselect the current selected tab
+        if self._selected_tab is not None:
+            self._tabs[self._selected_tab].set_normal()
+        self._selected_tab = None
+
+        if tab_name is not None:
+            # activate the tab named tab_name
+            self._selected_tab = tab_name
+            tab = self._tabs[tab_name]
+            tab.set_selected()
+            # move the tab row with the selected tab to the bottom
+            tab_row = self._tab2row[tab]
+            tab_row.pack_forget()
+            tab_row.pack(side=TOP, fill=X, expand=0)
+
+    def _add_tab_row(self, tab_names, expand_tabs):
+        if not tab_names:
+            return
+
+        tab_row = Frame(self)
+        tab_row.pack(side=TOP, fill=X, expand=0)
+        tab_row.tab_set = self
+        self._tab_rows.append(tab_row)
+
+        for tab_name in tab_names:
+            def tab_command(select_command=self.select_command,
+                            tab_name=tab_name):
+                return select_command(tab_name)
+            tab = TabBarSet.TabButton(tab_row, tab_name, tab_command)
+            if expand_tabs:
+                tab.pack(side=LEFT, fill=X, expand=True)
+            else:
+                tab.pack(side=LEFT)
+            self._tabs[tab_name] = tab
+            self._tab2row[tab] = tab_row
+
+        tab.is_last_in_row = True
+
+    def _reset_tab_rows(self):
+        while self._tab_rows:
+            tab_row = self._tab_rows.pop()
+            tab_row.destroy()
+        self._tab2row = {}
+
+    def _arrange_tabs(self):
+        """
+        Arrange the tabs in rows, in the order in which they were added.
+
+        If n_rows >= 1, this will be the number of rows used. Otherwise the
+        number of rows will be calculated according to the number of tabs and
+        max_tabs_per_row. In this case, the number of rows may change when
+        adding/removing tabs.
+
+        """
+        # remove all tabs and rows
+        for tab_name in self._tabs.keys():
+            self._tabs.pop(tab_name).destroy()
+        self._reset_tab_rows()
+
+        if not self._tab_names:
+            return
+
+        if self.n_rows is not None and self.n_rows > 0:
+            n_rows = self.n_rows
+        else:
+            # calculate the required number of rows
+            n_rows = (len(self._tab_names) - 1) // self.max_tabs_per_row + 1
+
+        i = 0
+        expand_tabs = self.expand_tabs or n_rows > 1
+        for row_index in xrange(n_rows):
+            # calculate required number of tabs in this row
+            n_tabs = (len(self._tab_names) - i - 1) // (n_rows - row_index) + 1
+            tab_names = self._tab_names[i:i + n_tabs]
+            i += n_tabs
+            self._add_tab_row(tab_names, expand_tabs)
+
+        # re-select selected tab so it is properly displayed
+        selected = self._selected_tab
+        self.select_tab(None)
+        if selected in self._tab_names:
+            self.select_tab(selected)
+
+    class TabButton(Frame):
+        """A simple tab-like widget."""
+
+        bw = 2 # borderwidth
+
+        def __init__(self, tab_row, name, command):
+            """Constructor arguments:
+
+            name -- The tab's name, which will appear in its button.
+
+            command -- The command to be called upon selection of the tab. It
+            is called with the tab's name as an argument.
+
+            """
+            Frame.__init__(self, tab_row, borderwidth=self.bw)
+            self.button = Radiobutton(self, text=name, command=command,
+                padx=5, pady=1, takefocus=FALSE, indicatoron=FALSE,
+                highlightthickness=0, selectcolor='', borderwidth=0)
+            self.button.pack(side=LEFT, fill=X, expand=True)
+
+            self.tab_set = tab_row.tab_set
+
+            self.is_last_in_row = False
+
+            self._init_masks()
+            self.set_normal()
+
+        def set_selected(self):
+            """Assume selected look"""
+            for widget in self, self.mskl.ml, self.mskr.mr:
+                widget.config(relief=RAISED)
+            self._place_masks(selected=True)
+
+        def set_normal(self):
+            """Assume normal look"""
+            for widget in self, self.mskl.ml, self.mskr.mr:
+                widget.config(relief=RAISED)
+            self._place_masks(selected=False)
+
+        def _init_masks(self):
+            page_set = self.tab_set.page_set
+            background = page_set.pages_frame.cget('background')
+            # mask replaces the middle of the border with the background color
+            self.mask = Frame(page_set, borderwidth=0, relief=FLAT,
+                              background=background)
+            # mskl replaces the bottom-left corner of the border with a normal
+            # left border
+            self.mskl = Frame(page_set, borderwidth=0, relief=FLAT,
+                              background=background)
+            self.mskl.ml = Frame(self.mskl, borderwidth=self.bw,
+                                 relief=RAISED)
+            self.mskl.ml.place(x=0, y=-self.bw,
+                               width=2*self.bw, height=self.bw*4)
+            # mskr replaces the bottom-right corner of the border with a normal
+            # right border
+            self.mskr = Frame(page_set, borderwidth=0, relief=FLAT,
+                              background=background)
+            self.mskr.mr = Frame(self.mskr, borderwidth=self.bw,
+                                 relief=RAISED)
+
+        def _place_masks(self, selected=False):
+            height = self.bw
+            if selected:
+                height += self.bw
+
+            self.mask.place(in_=self,
+                            relx=0.0, x=0,
+                            rely=1.0, y=0,
+                            relwidth=1.0, width=0,
+                            relheight=0.0, height=height)
+
+            self.mskl.place(in_=self,
+                            relx=0.0, x=-self.bw,
+                            rely=1.0, y=0,
+                            relwidth=0.0, width=self.bw,
+                            relheight=0.0, height=height)
+
+            page_set = self.tab_set.page_set
+            if selected and ((not self.is_last_in_row) or
+                             (self.winfo_rootx() + self.winfo_width() <
+                              page_set.winfo_rootx() + page_set.winfo_width())
+                             ):
+                # for a selected tab, if its rightmost edge isn't on the
+                # rightmost edge of the page set, the right mask should be one
+                # borderwidth shorter (vertically)
+                height -= self.bw
+
+            self.mskr.place(in_=self,
+                            relx=1.0, x=0,
+                            rely=1.0, y=0,
+                            relwidth=0.0, width=self.bw,
+                            relheight=0.0, height=height)
+
+            self.mskr.mr.place(x=-self.bw, y=-self.bw,
+                               width=2*self.bw, height=height + self.bw*2)
+
+            # finally, lower the tab set so that all of the frames we just
+            # placed hide it
+            self.tab_set.lower()
+
+class TabbedPageSet(Frame):
+    """A Tkinter tabbed-pane widget.
+
+    Constains set of 'pages' (or 'panes') with tabs above for selecting which
+    page is displayed. Only one page will be displayed at a time.
+
+    Pages may be accessed through the 'pages' attribute, which is a dictionary
+    of pages, using the name given as the key. A page is an instance of a
+    subclass of Tk's Frame widget.
+
+    The page widgets will be created (and destroyed when required) by the
+    TabbedPageSet. Do not call the page's pack/place/grid/destroy methods.
+
+    Pages may be added or removed at any time using the add_page() and
+    remove_page() methods.
+
+    """
+    class Page(object):
+        """Abstract base class for TabbedPageSet's pages.
+
+        Subclasses must override the _show() and _hide() methods.
+
+        """
+        uses_grid = False
+
+        def __init__(self, page_set):
+            self.frame = Frame(page_set, borderwidth=2, relief=RAISED)
+
+        def _show(self):
+            raise NotImplementedError
+
+        def _hide(self):
+            raise NotImplementedError
+
+    class PageRemove(Page):
+        """Page class using the grid placement manager's "remove" mechanism."""
+        uses_grid = True
+
+        def _show(self):
+            self.frame.grid(row=0, column=0, sticky=NSEW)
+
+        def _hide(self):
+            self.frame.grid_remove()
+
+    class PageLift(Page):
+        """Page class using the grid placement manager's "lift" mechanism."""
+        uses_grid = True
+
+        def __init__(self, page_set):
+            super(TabbedPageSet.PageLift, self).__init__(page_set)
+            self.frame.grid(row=0, column=0, sticky=NSEW)
+            self.frame.lower()
+
+        def _show(self):
+            self.frame.lift()
+
+        def _hide(self):
+            self.frame.lower()
+
+    class PagePackForget(Page):
+        """Page class using the pack placement manager's "forget" mechanism."""
+        def _show(self):
+            self.frame.pack(fill=BOTH, expand=True)
+
+        def _hide(self):
+            self.frame.pack_forget()
+
+    def __init__(self, parent, page_names=None, page_class=PageLift,
+                 n_rows=1, max_tabs_per_row=5, expand_tabs=False,
+                 **kw):
+        """Constructor arguments:
+
+        page_names -- A list of strings, each will be the dictionary key to a
+        page's widget, and the name displayed on the page's tab. Should be
+        specified in the desired page order. The first page will be the default
+        and first active page. If page_names is None or empty, the
+        TabbedPageSet will be initialized empty.
+
+        n_rows, max_tabs_per_row -- Parameters for the TabBarSet which will
+        manage the tabs. See TabBarSet's docs for details.
+
+        page_class -- Pages can be shown/hidden using three mechanisms:
+
+        * PageLift - All pages will be rendered one on top of the other. When
+          a page is selected, it will be brought to the top, thus hiding all
+          other pages. Using this method, the TabbedPageSet will not be resized
+          when pages are switched. (It may still be resized when pages are
+          added/removed.)
+
+        * PageRemove - When a page is selected, the currently showing page is
+          hidden, and the new page shown in its place. Using this method, the
+          TabbedPageSet may resize when pages are changed.
+
+        * PagePackForget - This mechanism uses the pack placement manager.
+          When a page is shown it is packed, and when it is hidden it is
+          unpacked (i.e. pack_forget). This mechanism may also cause the
+          TabbedPageSet to resize when the page is changed.
+
+        """
+        Frame.__init__(self, parent, kw)
+
+        self.page_class = page_class
+        self.pages = {}
+        self._pages_order = []
+        self._current_page = None
+        self._default_page = None
+
+        self.columnconfigure(0, weight=1)
+        self.rowconfigure(1, weight=1)
+
+        self.pages_frame = Frame(self)
+        self.pages_frame.grid(row=1, column=0, sticky=NSEW)
+        if self.page_class.uses_grid:
+            self.pages_frame.columnconfigure(0, weight=1)
+            self.pages_frame.rowconfigure(0, weight=1)
+
+        # the order of the following commands is important
+        self._tab_set = TabBarSet(self, self.change_page, n_rows=n_rows,
+                                  max_tabs_per_row=max_tabs_per_row,
+                                  expand_tabs=expand_tabs)
+        if page_names:
+            for name in page_names:
+                self.add_page(name)
+        self._tab_set.grid(row=0, column=0, sticky=NSEW)
+
+        self.change_page(self._default_page)
+
+    def add_page(self, page_name):
+        """Add a new page with the name given in page_name."""
+        if not page_name:
+            raise InvalidNameError("Invalid TabPage name: '%s'" % page_name)
+        if page_name in self.pages:
+            raise AlreadyExistsError(
+                "TabPage named '%s' already exists" % page_name)
+
+        self.pages[page_name] = self.page_class(self.pages_frame)
+        self._pages_order.append(page_name)
+        self._tab_set.add_tab(page_name)
+
+        if len(self.pages) == 1: # adding first page
+            self._default_page = page_name
+            self.change_page(page_name)
+
+    def remove_page(self, page_name):
+        """Destroy the page whose name is given in page_name."""
+        if not page_name in self.pages:
+            raise KeyError("No such TabPage: '%s" % page_name)
+
+        self._pages_order.remove(page_name)
+
+        # handle removing last remaining, default, or currently shown page
+        if len(self._pages_order) > 0:
+            if page_name == self._default_page:
+                # set a new default page
+                self._default_page = self._pages_order[0]
+        else:
+            self._default_page = None
+
+        if page_name == self._current_page:
+            self.change_page(self._default_page)
+
+        self._tab_set.remove_tab(page_name)
+        page = self.pages.pop(page_name)
+        page.frame.destroy()
+
+    def change_page(self, page_name):
+        """Show the page whose name is given in page_name."""
+        if self._current_page == page_name:
+            return
+        if page_name is not None and page_name not in self.pages:
+            raise KeyError("No such TabPage: '%s'" % page_name)
+
+        if self._current_page is not None:
+            self.pages[self._current_page]._hide()
+        self._current_page = None
+
+        if page_name is not None:
+            self._current_page = page_name
+            self.pages[page_name]._show()
+
+        self._tab_set.select_tab(page_name)
+
+if __name__ == '__main__':
+    # test dialog
+    root=Tk()
+    tabPage=TabbedPageSet(root, page_names=['Foobar','Baz'], n_rows=0,
+                          expand_tabs=False,
+                          )
+    tabPage.pack(side=TOP, expand=TRUE, fill=BOTH)
+    Label(tabPage.pages['Foobar'].frame, text='Foo', pady=20).pack()
+    Label(tabPage.pages['Foobar'].frame, text='Bar', pady=20).pack()
+    Label(tabPage.pages['Baz'].frame, text='Baz').pack()
+    entryPgName=Entry(root)
+    buttonAdd=Button(root, text='Add Page',
+            command=lambda:tabPage.add_page(entryPgName.get()))
+    buttonRemove=Button(root, text='Remove Page',
+            command=lambda:tabPage.remove_page(entryPgName.get()))
+    labelPgName=Label(root, text='name of page to add/remove:')
+    buttonAdd.pack(padx=5, pady=5)
+    buttonRemove.pack(padx=5, pady=5)
+    labelPgName.pack(padx=5)
+    entryPgName.pack(padx=5)
+    root.mainloop()