/b-gtk/fix-viz

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/b-gtk/fix-viz

« back to all changes in this revision

Viewing changes to branchview/treeview.py

  • Committer: rodney.dawes at canonical
  • Date: 2008-10-25 06:02:09 UTC
  • Revision ID: rodney.dawes@canonical.com-20081025060209-irlizouino63cs1m
        * preferences/__init__.py:
        Remove the dialog separator
        Remove useless extra call to self._create_pages()
        Make the default window size smaller
        Set the default border width on various widgets
        Set the current notebook page to the first one

        * preferences/identity.py:
        Set various border widths appropriately
        Align the labels to the left
        Remove the unneeded bold markup from the labels
        Change the "User Id" label to "E-Mail"
        Align the radio group labels to the top of the groups

        * preferences/plugins.py:
        Set various border widths appropriately
        Set the default paned position to something more sensible
        Set the shadow type on the treeview's scrolled window to in
        Align the Author and Version labels to the left

Show diffs side-by-side

added added

removed removed

Lines of Context:
branchview/treeview.py
13
13
import pango
14
14
import re
15
15
import treemodel
 
16
from bzrlib import ui
16
17
 
17
18
from bzrlib.plugins.gtk import _i18n
 
19
from bzrlib.plugins.gtk.ui import GtkProgressBar, ProgressPanel
18
20
from linegraph import linegraph, same_branch
19
21
from graphcell import CellRendererGraph
20
22
from treemodel import TreeModel
21
23
from bzrlib.revision import NULL_REVISION
22
24
 
 
25
 
23
26
class TreeView(gtk.VBox):
24
27
 
25
28
    __gproperties__ = {
82
85
    }
83
86
 
84
87
    __gsignals__ = {
85
 
        'revisions-loaded': (gobject.SIGNAL_RUN_FIRST, 
86
 
                             gobject.TYPE_NONE,
87
 
                             ()),
88
88
        'revision-selected': (gobject.SIGNAL_RUN_FIRST,
89
89
                              gobject.TYPE_NONE,
90
90
                              ()),
93
93
                              (gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT)),
94
94
        'tag-added': (gobject.SIGNAL_RUN_FIRST,
95
95
                              gobject.TYPE_NONE,
96
 
                              (gobject.TYPE_STRING, gobject.TYPE_STRING))
 
96
                              (gobject.TYPE_STRING, gobject.TYPE_STRING)),
 
97
        'refreshed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
 
98
                              ())
97
99
    }
98
100
 
99
101
    def __init__(self, branch, start, maxnum, compact=True):
108
110
        """
109
111
        gtk.VBox.__init__(self, spacing=0)
110
112
 
111
 
        self.pack_start(self.construct_loading_msg(), expand=False, fill=True)
112
 
        self.connect('revisions-loaded', 
113
 
                lambda x: self.loading_msg_box.hide())
 
113
        loading_msg_widget = ProgressPanel()
 
114
        if getattr(ui.ui_factory, "set_nested_progress_bar_widget", None) is not None:
 
115
            ui.ui_factory.set_nested_progress_bar_widget(loading_msg_widget.get_progress_bar)
 
116
        self.pack_start(loading_msg_widget, expand=False, fill=True)
114
117
 
115
118
        self.scrolled_window = gtk.ScrolledWindow()
116
119
        self.scrolled_window.set_policy(gtk.POLICY_AUTOMATIC,
120
123
        self.pack_start(self.scrolled_window, expand=True, fill=True)
121
124
 
122
125
        self.scrolled_window.add(self.construct_treeview())
123
 
        
124
126
 
125
127
        self.iter = None
126
128
        self.branch = branch
127
129
        self.revision = None
 
130
        self.index = {}
128
131
 
129
132
        self.start = start
130
133
        self.maxnum = maxnum
180
183
        """Return revision id of currently selected revision, or None."""
181
184
        return self.get_property('revision')
182
185
 
 
186
    def has_revision_id(self, revision_id):
 
187
        return (revision_id in self.index)
 
188
 
183
189
    def set_revision(self, revision):
184
190
        self.set_property('revision', revision)
185
191
 
223
229
        self.emit('tag-added', tag, revid)
224
230
        
225
231
    def refresh(self):
226
 
        self.loading_msg_box.show()
227
232
        gobject.idle_add(self.populate, self.get_revision())
228
233
 
229
234
    def update(self):
277
282
                       should be broken.
278
283
        """
279
284
 
280
 
        if self.compact:
281
 
            broken_line_length = 32
282
 
        else:
283
 
            broken_line_length = None
284
 
        
285
 
        show_graph = self.graph_column.get_visible()
286
 
 
287
 
        self.branch.lock_read()
288
 
        (linegraphdata, index, columns_len) = linegraph(self.branch.repository,
289
 
                                                        (self.start,) , # Sequence of start revisions
290
 
                                                        self.maxnum, 
291
 
                                                        broken_line_length,
292
 
                                                        show_graph,
293
 
                                                        self.mainline_only)
294
 
 
295
 
        self.model = TreeModel(self.branch, linegraphdata)
296
 
        self.graph_cell.columns_len = columns_len
297
 
        width = self.graph_cell.get_size(self.treeview)[2]
298
 
        if width > 500:
299
 
            width = 500
300
 
        self.graph_column.set_fixed_width(width)
301
 
        self.graph_column.set_max_width(width)
302
 
        self.index = index
303
 
        self.treeview.set_model(self.model)
304
 
 
305
 
        if not revision or revision == NULL_REVISION:
306
 
            self.treeview.set_cursor(0)
307
 
        else:
308
 
            self.set_revision(revision)
309
 
 
310
 
        self.emit('revisions-loaded')
311
 
 
312
 
        return False
 
285
        self.progress_bar = ui.ui_factory.nested_progress_bar()
 
286
        self.progress_bar.update("Loading ancestry graph", 0, 5)
 
287
 
 
288
        try:
 
289
            if self.compact:
 
290
                broken_line_length = 32
 
291
            else:
 
292
                broken_line_length = None
 
293
            
 
294
            show_graph = self.graph_column.get_visible()
 
295
 
 
296
            self.branch.lock_read()
 
297
            (linegraphdata, index, columns_len) = linegraph(self.branch.repository.get_graph(),
 
298
                                                            self.start,
 
299
                                                            self.maxnum, 
 
300
                                                            broken_line_length,
 
301
                                                            show_graph,
 
302
                                                            self.mainline_only,
 
303
                                                            self.progress_bar)
 
304
 
 
305
            self.model = TreeModel(self.branch, linegraphdata)
 
306
            self.graph_cell.columns_len = columns_len
 
307
            width = self.graph_cell.get_size(self.treeview)[2]
 
308
            if width > 500:
 
309
                width = 500
 
310
            self.graph_column.set_fixed_width(width)
 
311
            self.graph_column.set_max_width(width)
 
312
            self.index = index
 
313
            self.treeview.set_model(self.model)
 
314
 
 
315
            if not revision or revision == NULL_REVISION:
 
316
                self.treeview.set_cursor(0)
 
317
            else:
 
318
                self.set_revision(revision)
 
319
 
 
320
            self.emit('refreshed')
 
321
            return False
 
322
        finally:
 
323
            self.progress_bar.finished()
313
324
 
314
325
    def construct_treeview(self):
315
326
        self.treeview = gtk.TreeView()
322
333
        if set_tooltip is not None:
323
334
            set_tooltip(treemodel.MESSAGE)
324
335
 
 
336
        self._prev_cursor_path = None
325
337
        self.treeview.connect("cursor-changed",
326
338
                self._on_selection_changed)
327
339
 
394
406
        
395
407
        return self.treeview
396
408
    
397
 
    def construct_loading_msg(self):
398
 
        image_loading = gtk.image_new_from_stock(gtk.STOCK_REFRESH,
399
 
                                                 gtk.ICON_SIZE_BUTTON)
400
 
        image_loading.show()
401
 
        
402
 
        label_loading = gtk.Label(
403
 
            _i18n("Please wait, loading ancestral graph..."))
404
 
        label_loading.set_alignment(0.0, 0.5)
405
 
        label_loading.show()
406
 
        
407
 
        self.loading_msg_box = gtk.HBox()
408
 
        self.loading_msg_box.set_spacing(5)
409
 
        self.loading_msg_box.set_border_width(5)        
410
 
        self.loading_msg_box.pack_start(image_loading, False, False)
411
 
        self.loading_msg_box.pack_start(label_loading, True, True)
412
 
        self.loading_msg_box.show()
413
 
        
414
 
        return self.loading_msg_box
415
 
 
416
409
    def _on_selection_changed(self, treeview):
417
410
        """callback for when the treeview changes."""
418
411
        (path, focus) = treeview.get_cursor()
419
 
        if path is not None:
 
412
        if (path is not None) and (path != self._prev_cursor_path):
 
413
            self._prev_cursor_path = path # avoid emitting twice per click
420
414
            self.iter = self.model.get_iter(path)
421
415
            self.emit('revision-selected')
422
416
 
423
417
    def _on_revision_selected(self, widget, event):
424
 
        from bzrlib.plugins.gtk.revisionmenu import RevisionPopupMenu
 
418
        from bzrlib.plugins.gtk.revisionmenu import RevisionMenu
425
419
        if event.button == 3:
426
 
            menu = RevisionPopupMenu(self.branch.repository, 
 
420
            menu = RevisionMenu(self.branch.repository, 
427
421
                [self.get_revision().revision_id],
428
422
                self.branch)
429
423
            menu.connect('tag-added', lambda w, t, r: self.add_tag(t, r))