← Back to branch summary

~ubuntu-branches/ubuntu/karmic/pida/karmic

« back to all changes in this revision

Viewing changes to pida/ui/books.py

  • Committer: Bazaar Package Importer
  • Author(s): Jan Luebbe
  • Date: 2007-09-05 17:54:09 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20070905175409-ty9f6qpuctyjv1sd
Tags: 0.5.1-2
http://bugs.debian.org/394860
http://bugs.debian.org/436431
http://bugs.debian.org/421378
http://bugs.debian.org/349009
http://bugs.debian.org/440375
* Depend on librsvg2-common, which is not pulled in by the other depends
  (closes: #394860)
* gvim is no alternative for python-gnome2 and python-gnome2-extras
  (closes: #436431)
* Pida now uses ~/.pida2, so it can no longer be confused by old
  configurations (closes: #421378)
* Culebra is no longer supported by upstream (closes: #349009)
* Update manpage (closes: #440375)
* Update watchfile (pida is now called PIDA)

Show diffs side-by-side

added added

removed removed

Lines of Context:
pida/ui/books.py
 
1
 
 
2
import gtk
 
3
 
 
4
ORIENTATION_SIDEBAR_LEFT = 0
 
5
ORIENTATION_SIDEBAR_RIGHT = 1
 
6
 
 
7
BOOK_TERMINAL = 'Terminal'
 
8
BOOK_EDITOR = 'Editor'
 
9
BOOK_BUFFER = 'Buffer'
 
10
BOOK_PLUGIN = 'Plugin'
 
11
 
 
12
# locale
 
13
from pida.core.locale import Locale
 
14
locale = Locale('pida')
 
15
_ = locale.gettext
 
16
 
 
17
class BaseBookConfig(object):
 
18
    
 
19
    def __init__(self, orientation):
 
20
        self._orientation = orientation
 
21
 
 
22
    def get_tabs_visible(self):
 
23
        return True
 
24
 
 
25
    def get_tab_position(self):
 
26
        return gtk.POS_TOP
 
27
 
 
28
    def get_notebook_name(self):
 
29
        raise NotImplementedError(_('Must at least define a notebook name'))
 
30
 
 
31
    def get_name(self):
 
32
        raise NotImplementedError(_('Must at leaste define a Name'))
 
33
 
 
34
    def create_tab_label(self, icon, text):
 
35
        if None in [icon, text]:
 
36
            return None
 
37
        label = gtk.Label(text)
 
38
        if self.get_tab_position() in [gtk.POS_TOP, gtk.POS_BOTTOM]:
 
39
            b_factory = gtk.HBox
 
40
        else:
 
41
            b_factory = gtk.VBox
 
42
            label.set_angle(270)
 
43
        b = b_factory(spacing=2)
 
44
        b.pack_start(icon)
 
45
        b.pack_start(label)
 
46
        b.show_all()
 
47
        return b
 
48
 
 
49
 
 
50
 
 
51
 
 
52
class TerminalBookConfig(BaseBookConfig):
 
53
 
 
54
    def get_notebook_name(self):
 
55
        if self._orientation == ORIENTATION_SIDEBAR_LEFT:
 
56
            return 'br_book'
 
57
        else:
 
58
            return 'bl_book'
 
59
 
 
60
    def get_name(self):
 
61
        return 'Terminal'
 
62
 
 
63
 
 
64
class EditorBookConfig(BaseBookConfig):
 
65
    
 
66
    def get_notebook_name(self):
 
67
        if self._orientation == ORIENTATION_SIDEBAR_LEFT:
 
68
            return 'tr_book'
 
69
        else:
 
70
            return 'tl_book'
 
71
 
 
72
    def get_tabs_visible(self):
 
73
        return False
 
74
 
 
75
    def get_name(self):
 
76
        return 'Editor'
 
77
 
 
78
 
 
79
class BufferBookConfig(BaseBookConfig):
 
80
 
 
81
    def get_notebook_name(self):
 
82
        if self._orientation == ORIENTATION_SIDEBAR_LEFT:
 
83
            return 'tl_book'
 
84
        else:
 
85
            return 'tr_book'
 
86
 
 
87
    def get_tab_position(self):
 
88
        if self._orientation == ORIENTATION_SIDEBAR_LEFT:
 
89
            return gtk.POS_RIGHT
 
90
        else:
 
91
            return gtk.POS_LEFT
 
92
 
 
93
    def get_name(self):
 
94
        return 'Buffer'
 
95
 
 
96
class PluginBookConfig(BaseBookConfig):
 
97
 
 
98
    def get_notebook_name(self):
 
99
        if self._orientation == ORIENTATION_SIDEBAR_LEFT:
 
100
            return 'bl_book'
 
101
        else:
 
102
            return 'br_book'
 
103
 
 
104
    def get_tab_position(self):
 
105
        if self._orientation == ORIENTATION_SIDEBAR_LEFT:
 
106
            return gtk.POS_RIGHT
 
107
        else:
 
108
            return gtk.POS_LEFT
 
109
    
 
110
    def get_name(self):
 
111
        return 'Plugin'
 
112
 
 
113
class BookConfigurator(object):
 
114
    
 
115
    def __init__(self, orientation):
 
116
        self._orientation = orientation
 
117
        self._configs = {}
 
118
        self._books = {}
 
119
        self._widget_names = {}
 
120
        for conf in [
 
121
            TerminalBookConfig,
 
122
            EditorBookConfig,
 
123
            PluginBookConfig,
 
124
            BufferBookConfig
 
125
        ]:
 
126
            book_config = conf(self._orientation)
 
127
            self._configs[book_config.get_name()] = book_config
 
128
            self._widget_names[book_config.get_notebook_name()] = book_config
 
129
 
 
130
    def get_config(self, name):
 
131
        try:
 
132
            return self._configs[name]
 
133
        except KeyError:
 
134
            print self._configs
 
135
            raise KeyError(_('No Notebook attests to having that name %s') % name)
 
136
 
 
137
    def configure_book(self, name, book):
 
138
        conf = self._widget_names[name]
 
139
        self._books[conf.get_name()] = book
 
140
        book.set_show_tabs(conf.get_tabs_visible())
 
141
        book.set_tab_pos(conf.get_tab_position())
 
142
        book.remove_page(0)
 
143
        if conf.get_name() != BOOK_EDITOR:
 
144
            # Cannot drag to the editor terminal for now
 
145
            book.set_group_id(0)
 
146
 
 
147
    def get_book(self, name):
 
148
        return self._books[name]
 
149
 
 
150
    def get_books(self):
 
151
        return self._books.items()
 
152
 
 
153
 
 
154
    def get_names(self):
 
155
        return self._books.keys()
 
156
 
 
157
 
 
158
class BookManager(object):
 
159
 
 
160
    def __init__(self, configurator):
 
161
        self._conf = configurator
 
162
        self._views = dict()
 
163
        for k in self._conf.get_names():
 
164
            self._views[k] = dict()
 
165
 
 
166
    def add_view(self, bookname, view):
 
167
        if not self.has_view(view):
 
168
            self._views[bookname][view.get_unique_id()] = view
 
169
            book = self._get_book(bookname)
 
170
            tab_label = self._create_tab_label(
 
171
                bookname,
 
172
                view.create_tab_label_icon(),
 
173
                view.get_tab_label_text())
 
174
            book.append_page(view.get_toplevel(),
 
175
                tab_label=tab_label)
 
176
            book.set_current_page(-1)
 
177
            book.show_all()
 
178
            book.set_tab_detachable(view.get_toplevel(), True)
 
179
            self._focus_page(bookname)
 
180
        else:
 
181
            raise ValueError(_('This view is already in the manager'))
 
182
 
 
183
    def remove_view(self, view):
 
184
        book_name = self._get_book_for_view(view)
 
185
        book = self._get_book(book_name)
 
186
        book.remove(view.get_toplevel())
 
187
        del self._views[book_name][view.get_unique_id()]
 
188
 
 
189
    def move_view(self, bookname, view):
 
190
        self.remove_view(view)
 
191
        self.add_view(bookname, view)
 
192
 
 
193
    def has_view(self, view):
 
194
        return view.get_unique_id() in self._get_view_uids()
 
195
 
 
196
    def next_page(self, bookname):
 
197
        book = self._get_book(bookname)
 
198
        if self._get_current_page(bookname) == book.get_n_pages() - 1:
 
199
            book.set_current_page(0)
 
200
        else:
 
201
            book.next_page()
 
202
        self._focus_page(bookname)
 
203
 
 
204
    def prev_page(self, bookname):
 
205
        book = self._get_book(bookname)
 
206
        if self._get_current_page(bookname) == 0:
 
207
            book.set_current_page(book.get_n_pages() - 1)
 
208
        else:
 
209
            book.prev_page()
 
210
        self._focus_page(bookname)
 
211
 
 
212
    def _get_current_page(self, bookname):
 
213
        return self._get_book(bookname).get_current_page()
 
214
 
 
215
    def _focus_page(self, bookname):
 
216
        book = self._get_book(bookname)
 
217
        book.get_nth_page(book.get_current_page()).grab_focus()
 
218
 
 
219
    def _get_book(self, name):
 
220
        return self._conf.get_book(name)
 
221
        
 
222
    def _get_book_for_view(self, view):
 
223
        for name, views in self._views.items():
 
224
            if view.get_unique_id() in views:
 
225
                return name
 
226
        raise ValueError(_('View is not in any Notebook'))
 
227
 
 
228
    def _get_view_uids(self):
 
229
        uids = []
 
230
        for book in self._views.values():
 
231
            uids.extend(book.keys())
 
232
        return uids
 
233
 
 
234
    def _create_tab_label(self, bookname, icon, text):
 
235
        conf = self._conf.get_config(bookname)
 
236
        return conf.create_tab_label(icon, text)
 
237
        
 
238
 
 
239
 
 
240
 
 
241
 
 
242