root/hodgestar/PythonCode/TabStripCommonPrefix/tabs-strip-common-prefix.py

#!/usr/bin/env python

#  Copyright (C) 2008 Simon Cross
#
#  This program is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation; either version 2, or (at your option)
#  any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

"""A simple extension to strip common prefixes from tab titles."""

import string
import gtk

def find_longest_prefix(titles):
    """Find longest prefix from list of titles. Return "" if not common prefix."""
    if not titles:
        return ""

    remaining_titles = list(titles)
    length = 0

    while True:
        length += 1
        prefix_map = {}

        for title in remaining_titles:
            if len(title) < length:
                continue
            prefix = title[:length]
            prefix_map.setdefault(prefix,[])
            prefix_map[prefix].append(title)

        for prefix, title_list in prefix_map.items():
            if len(title_list) <= 1:
                del prefix_map[prefix]

        if len(prefix_map) == 0:
            length -= 1
            break

        remaining_titles = list()
        for title_list in prefix_map.values():
            remaining_titles.extend(title_list)

        assert remaining_titles

    return remaining_titles[0][:length]

def find_common_prefixes(tabs_to_titles, strip_chars):
    """Modify values to remove common prefixes containing end_chars."""
    tabs_to_titles = tabs_to_titles.copy()
    unprocessed = set(tabs_to_titles.keys())

    while True:
        prefix = find_longest_prefix([tabs_to_titles[x] for x in unprocessed])
        if prefix == "":
            break
        stripped_prefix = prefix.rstrip(strip_chars)
        for tab in list(unprocessed):
            title = tabs_to_titles[tab]
            if title.startswith(prefix):
                unprocessed.remove(tab)
                if title != prefix:
                    tabs_to_titles[tab] = title[len(stripped_prefix):]

    return tabs_to_titles

class TabStripExtension(object):
    def __init__(self):
        self.handler_ids = {}

    def set_tab_title(self, notebook, tab, title):
        """Set notebook tab title -- is there a better way?"""
        tab_label = notebook.get_tab_label(tab)
        labels = [x for x in tab_label.get_children() if isinstance(x, gtk.Label)]
        if labels:
            labels[0].set_label(title)

    def handler(self, notebook, page, page_numargs):
        """When an event occurs, check to see if there are new common prefixes."""
        tabs = notebook.get_children()
        strip_chars = string.letters + string.digits

        tabs_to_titles = dict([(t, t.props.title) for t in tabs])
        tabs_to_titles = find_common_prefixes(tabs_to_titles, strip_chars)

        for tab, title in tabs_to_titles.items():
            self.set_tab_title(notebook, tab, title)

    def attach_window(self, window):
        """Attach to a window."""
        notebook = window.get_notebook()
        self.handler_ids[notebook] = notebook.connect_after("switch-page", self.handler)

    def detach_window(self, window):
        """Detach from a window."""
        notebook = window.get_notebook()
        notebook.disconnect(self.handler_ids[notebook])
        del self.handler_ids[notebook]

def test_prefix_finding():
    """Test prefix finding code."""
    assert find_longest_prefix(["", "abc", "abab"]) == "ab"
    assert find_longest_prefix(["abcd", "abcd"]) == "abcd"
    assert find_longest_prefix(["foo - bar", "foo - eep", "other"]) == "foo - "

    s = string.letters + string.digits
    assert find_common_prefixes({ 1: "abcd", 2: "abcd" }, s) == { 1: "abcd", 2: "abcd" }
    assert find_common_prefixes({ 1: "foo - bar", 2: "foo - eep" }, s) == { 1: "bar", 2: "eep" }
    assert find_common_prefixes({ 1: "foo - bar", 2: "foo - eep", 3: "fop" }, s) == { 1: "bar", 2: "eep", 3: "fop" }

if __name__ == "__main__":
    test_prefix_finding()
else:
    import epiphany
    ext = TabStripExtension()
    attach_window = ext.attach_window
    detach_window = ext.detach_window