/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: Jelmer Vernooij
  • Date: 2008-07-17 11:51:03 UTC
  • Revision ID: jelmer@samba.org-20080717115103-djh5sb0pvpse2zkb
Add note about glade.

Show diffs side-by-side

added added

removed removed

Lines of Context:
branchview/treeview.py
6
6
__copyright__ = "Copyright © 2005 Canonical Ltd."
7
7
__author__    = "Daniel Schierbeck <daniel.schierbeck@gmail.com>"
8
8
 
9
 
from gi.repository import Gtk
10
 
from gi.repository import GObject
11
 
from gi.repository import Pango
12
 
 
 
9
import sys
 
10
import string
 
11
import gtk
 
12
import gobject
 
13
import pango
 
14
import re
 
15
import treemodel
13
16
from bzrlib import ui
 
17
 
 
18
from bzrlib.plugins.gtk import _i18n
 
19
from bzrlib.plugins.gtk.ui import GtkProgressBar, ProgressPanel
 
20
from linegraph import linegraph, same_branch
 
21
from graphcell import CellRendererGraph
 
22
from treemodel import TreeModel
14
23
from bzrlib.revision import NULL_REVISION
15
24
 
16
 
from bzrlib.plugins.gtk import lock
17
 
from bzrlib.plugins.gtk.ui import ProgressPanel
18
 
from bzrlib.plugins.gtk.branchview import treemodel
19
 
from bzrlib.plugins.gtk.branchview.linegraph import linegraph, same_branch
20
 
from bzrlib.plugins.gtk.branchview.graphcell import CellRendererGraph
21
 
 
22
 
 
23
 
class TreeView(Gtk.VBox):
 
25
 
 
26
class TreeView(gtk.VBox):
24
27
 
25
28
    __gproperties__ = {
26
 
        'branch': (GObject.TYPE_PYOBJECT,
 
29
        'branch': (gobject.TYPE_PYOBJECT,
27
30
                   'Branch',
28
31
                   'The Bazaar branch being visualized',
29
 
                   GObject.PARAM_CONSTRUCT_ONLY | GObject.PARAM_WRITABLE),
 
32
                   gobject.PARAM_CONSTRUCT_ONLY | gobject.PARAM_WRITABLE),
30
33
 
31
 
        'revision': (GObject.TYPE_PYOBJECT,
 
34
        'revision': (gobject.TYPE_PYOBJECT,
32
35
                     'Revision',
33
36
                     'The currently selected revision',
34
 
                     GObject.PARAM_READWRITE),
 
37
                     gobject.PARAM_READWRITE),
35
38
 
36
 
        'revision-number': (GObject.TYPE_STRING,
 
39
        'revision-number': (gobject.TYPE_STRING,
37
40
                            'Revision number',
38
41
                            'The number of the selected revision',
39
42
                            '',
40
 
                            GObject.PARAM_READABLE),
 
43
                            gobject.PARAM_READABLE),
41
44
 
42
 
        'children': (GObject.TYPE_PYOBJECT,
 
45
        'children': (gobject.TYPE_PYOBJECT,
43
46
                     'Child revisions',
44
47
                     'Children of the currently selected revision',
45
 
                     GObject.PARAM_READABLE),
 
48
                     gobject.PARAM_READABLE),
46
49
 
47
 
        'parents': (GObject.TYPE_PYOBJECT,
 
50
        'parents': (gobject.TYPE_PYOBJECT,
48
51
                    'Parent revisions',
49
52
                    'Parents to the currently selected revision',
50
 
                    GObject.PARAM_READABLE),
 
53
                    gobject.PARAM_READABLE),
51
54
 
52
 
        'revno-column-visible': (GObject.TYPE_BOOLEAN,
 
55
        'revno-column-visible': (gobject.TYPE_BOOLEAN,
53
56
                                 'Revision number column',
54
57
                                 'Show revision number column',
55
58
                                 True,
56
 
                                 GObject.PARAM_READWRITE),
 
59
                                 gobject.PARAM_READWRITE),
57
60
 
58
 
        'graph-column-visible': (GObject.TYPE_BOOLEAN,
 
61
        'graph-column-visible': (gobject.TYPE_BOOLEAN,
59
62
                                 'Graph column',
60
63
                                 'Show graph column',
61
64
                                 True,
62
 
                                 GObject.PARAM_READWRITE),
 
65
                                 gobject.PARAM_READWRITE),
63
66
 
64
 
        'date-column-visible': (GObject.TYPE_BOOLEAN,
 
67
        'date-column-visible': (gobject.TYPE_BOOLEAN,
65
68
                                 'Date',
66
69
                                 'Show date column',
67
70
                                 False,
68
 
                                 GObject.PARAM_READWRITE),
 
71
                                 gobject.PARAM_READWRITE),
69
72
 
70
 
        'compact': (GObject.TYPE_BOOLEAN,
 
73
        'compact': (gobject.TYPE_BOOLEAN,
71
74
                    'Compact view',
72
75
                    'Break ancestry lines to save space',
73
76
                    True,
74
 
                    GObject.PARAM_CONSTRUCT | GObject.PARAM_READWRITE),
 
77
                    gobject.PARAM_CONSTRUCT | gobject.PARAM_READWRITE),
75
78
 
76
 
        'mainline-only': (GObject.TYPE_BOOLEAN,
 
79
        'mainline-only': (gobject.TYPE_BOOLEAN,
77
80
                    'Mainline only',
78
81
                    'Only show the mainline history.',
79
82
                    False,
80
 
                    GObject.PARAM_CONSTRUCT | GObject.PARAM_READWRITE),
 
83
                    gobject.PARAM_CONSTRUCT | gobject.PARAM_READWRITE),
81
84
 
82
85
    }
83
86
 
84
87
    __gsignals__ = {
85
 
        'revision-selected': (GObject.SignalFlags.RUN_FIRST,
86
 
                              None,
 
88
        'revision-selected': (gobject.SIGNAL_RUN_FIRST,
 
89
                              gobject.TYPE_NONE,
87
90
                              ()),
88
 
        'revision-activated': (GObject.SignalFlags.RUN_FIRST,
89
 
                              None,
90
 
                              (GObject.TYPE_PYOBJECT, GObject.TYPE_PYOBJECT)),
91
 
        'tag-added': (GObject.SignalFlags.RUN_FIRST,
92
 
                              None,
93
 
                              (GObject.TYPE_STRING, GObject.TYPE_STRING)),
94
 
        'refreshed': (GObject.SignalFlags.RUN_FIRST, None,
95
 
                              ())
 
91
        'revision-activated': (gobject.SIGNAL_RUN_FIRST,
 
92
                              gobject.TYPE_NONE,
 
93
                              (gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT)),
 
94
        'tag-added': (gobject.SIGNAL_RUN_FIRST,
 
95
                              gobject.TYPE_NONE,
 
96
                              (gobject.TYPE_STRING, gobject.TYPE_STRING))
96
97
    }
97
98
 
98
99
    def __init__(self, branch, start, maxnum, compact=True):
105
106
        :param broken_line_length: After how much lines to break 
106
107
                                   branches.
107
108
        """
108
 
        Gtk.VBox.__init__(self, homogeneous=False, spacing=0)
109
 
 
110
 
        self.progress_widget = ProgressPanel()
111
 
        self.pack_start(self.progress_widget, False, True, 0)
112
 
        if getattr(ui.ui_factory, "set_progress_bar_widget", None) is not None:
113
 
            # We'are using our own ui, let's tell it to use our widget.
114
 
            ui.ui_factory.set_progress_bar_widget(self.progress_widget)
115
 
 
116
 
        self.scrolled_window = Gtk.ScrolledWindow()
117
 
        self.scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC,
118
 
                                        Gtk.PolicyType.AUTOMATIC)
119
 
        self.scrolled_window.set_shadow_type(Gtk.ShadowType.IN)
 
109
        gtk.VBox.__init__(self, spacing=0)
 
110
 
 
111
        loading_msg_widget = ProgressPanel()
 
112
        ui.ui_factory.set_nested_progress_bar_widget(loading_msg_widget.get_progress_bar)
 
113
        self.pack_start(loading_msg_widget, expand=False, fill=True)
 
114
 
 
115
        self.scrolled_window = gtk.ScrolledWindow()
 
116
        self.scrolled_window.set_policy(gtk.POLICY_AUTOMATIC,
 
117
                                        gtk.POLICY_AUTOMATIC)
 
118
        self.scrolled_window.set_shadow_type(gtk.SHADOW_IN)
120
119
        self.scrolled_window.show()
121
 
        self.pack_start(self.scrolled_window, True, True, 0)
 
120
        self.pack_start(self.scrolled_window, expand=True, fill=True)
122
121
 
123
122
        self.scrolled_window.add(self.construct_treeview())
124
123
 
125
 
        self.path = None
 
124
        self.iter = None
126
125
        self.branch = branch
127
126
        self.revision = None
128
 
        self.index = {}
129
127
 
130
128
        self.start = start
131
129
        self.maxnum = maxnum
132
130
        self.compact = compact
133
131
 
134
 
        self.model = treemodel.TreeModel(self.branch, [])
135
 
        GObject.idle_add(self.populate)
136
 
 
137
 
        self.connect("destroy", self._on_destroy)
138
 
 
139
 
    def _on_destroy(self, *ignored):
140
 
        self.branch.unlock()
141
 
        if getattr(ui.ui_factory, "set_progress_bar_widget", None) is not None:
142
 
            # We'are using our own ui, let's tell it to stop using our widget.
143
 
            ui.ui_factory.set_progress_bar_widget(None)
 
132
        gobject.idle_add(self.populate)
 
133
 
 
134
        self.connect("destroy", lambda x: self.branch.unlock())
144
135
 
145
136
    def do_get_property(self, property):
146
137
        if property.name == 'revno-column-visible':
156
147
        elif property.name == 'branch':
157
148
            return self.branch
158
149
        elif property.name == 'revision':
159
 
            if self.path is None:
160
 
                return None
161
 
            return self.model.get_value(self.model.get_iter(self.path),
162
 
                                        treemodel.REVISION)
 
150
            return self.model.get_value(self.iter, treemodel.REVISION)
163
151
        elif property.name == 'revision-number':
164
 
            if self.path is None:
165
 
                return None
166
 
            return self.model.get_value(self.model.get_iter(self.path),
167
 
                                        treemodel.REVNO)
 
152
            return self.model.get_value(self.iter, treemodel.REVNO)
168
153
        elif property.name == 'children':
169
 
            if self.path is None:
170
 
                return None
171
 
            return self.model.get_value(self.model.get_iter(self.path),
172
 
                                        treemodel.CHILDREN)
 
154
            return self.model.get_value(self.iter, treemodel.CHILDREN)
173
155
        elif property.name == 'parents':
174
 
            if self.path is None:
175
 
                return None
176
 
            return self.model.get_value(self.model.get_iter(self.path),
177
 
                                        treemodel.PARENTS)
 
156
            return self.model.get_value(self.iter, treemodel.PARENTS)
178
157
        else:
179
158
            raise AttributeError, 'unknown property %s' % property.name
180
159
 
200
179
        """Return revision id of currently selected revision, or None."""
201
180
        return self.get_property('revision')
202
181
 
203
 
    def has_revision_id(self, revision_id):
204
 
        return (revision_id in self.index)
205
 
 
206
182
    def set_revision(self, revision):
207
183
        self.set_property('revision', revision)
208
184
 
211
187
 
212
188
        :param revid: Revision id of revision to display.
213
189
        """
214
 
        self.treeview.set_cursor(
215
 
            Gtk.TreePath(path=self.index[revid]), None, False)
 
190
        self.treeview.set_cursor(self.index[revid])
216
191
        self.treeview.grab_focus()
217
192
 
218
193
    def get_children(self):
232
207
    def add_tag(self, tag, revid=None):
233
208
        if revid is None: revid = self.revision.revision_id
234
209
 
235
 
        if lock.release(self.branch):
 
210
        try:
 
211
            self.branch.unlock()
 
212
 
236
213
            try:
237
 
                lock.acquire(self.branch, lock.WRITE)
 
214
                self.branch.lock_write()
238
215
                self.model.add_tag(tag, revid)
239
216
            finally:
240
 
                lock.release(self.branch)
241
 
 
242
 
            lock.acquire(self.branch, lock.READ)
243
 
 
244
 
            self.emit('tag-added', tag, revid)
245
 
 
 
217
                self.branch.unlock()
 
218
 
 
219
        finally:
 
220
            self.branch.lock_read()
 
221
 
 
222
        self.emit('tag-added', tag, revid)
 
223
        
246
224
    def refresh(self):
247
 
        GObject.idle_add(self.populate, self.get_revision())
 
225
        gobject.idle_add(self.populate, self.get_revision())
248
226
 
249
227
    def update(self):
250
228
        try:
297
275
                       should be broken.
298
276
        """
299
277
 
300
 
        if getattr(ui.ui_factory, "set_progress_bar_widget", None) is not None:
301
 
            # We'are using our own ui, let's tell it to use our widget.
302
 
            ui.ui_factory.set_progress_bar_widget(self.progress_widget)
303
278
        self.progress_bar = ui.ui_factory.nested_progress_bar()
304
 
        self.progress_bar.update("Loading ancestry graph", 0, 5)
 
279
        self.progress_bar.update(msg="Loading ancestry graph", total_cnt=5)
305
280
 
306
281
        try:
307
282
            if self.compact:
308
283
                broken_line_length = 32
309
284
            else:
310
285
                broken_line_length = None
311
 
 
 
286
            
312
287
            show_graph = self.graph_column.get_visible()
313
288
 
314
289
            self.branch.lock_read()
320
295
                                                            self.mainline_only,
321
296
                                                            self.progress_bar)
322
297
 
323
 
            self.model.line_graph_data = linegraphdata
 
298
            self.model = TreeModel(self.branch, linegraphdata)
324
299
            self.graph_cell.columns_len = columns_len
325
 
            width = self.graph_cell.get_preferred_width(self.treeview)[1]
 
300
            width = self.graph_cell.get_size(self.treeview)[2]
326
301
            if width > 500:
327
302
                width = 500
328
303
            self.graph_column.set_fixed_width(width)
331
306
            self.treeview.set_model(self.model)
332
307
 
333
308
            if not revision or revision == NULL_REVISION:
334
 
                self.treeview.set_cursor(Gtk.TreePath(path=0), None, False)
 
309
                self.treeview.set_cursor(0)
335
310
            else:
336
311
                self.set_revision(revision)
337
312
 
338
 
            self.emit('refreshed')
339
313
            return False
340
314
        finally:
341
315
            self.progress_bar.finished()
342
316
 
343
317
    def construct_treeview(self):
344
 
        self.treeview = Gtk.TreeView()
 
318
        self.treeview = gtk.TreeView()
345
319
 
346
320
        self.treeview.set_rules_hint(True)
347
 
        # combined revno/summary interactive search
348
 
        #
349
 
        # the row in a treemodel is considered "matched" if a REVNO *starts*
350
 
        # from the key (that is the key is found in a REVNO at the offset 0)
351
 
        # or if a MESSAGE *contains* the key anywhere (that is, the key is
352
 
        # found case insensitively in a MESSAGE at any offset)
353
 
        def search_equal_func(model, column, key, iter):
354
 
            return (model.get_value(iter, treemodel.REVNO).find(key) != 0
355
 
                and model.get_value(iter, treemodel.MESSAGE).lower().find(key.lower()) == -1)
356
 
 
357
 
        self.treeview.set_search_equal_func(search_equal_func, None)
358
 
        self.treeview.set_enable_search(True)
359
 
 
360
 
        self.treeview.set_tooltip_column(treemodel.MESSAGE)
361
 
 
362
 
        self._prev_cursor_path = None
 
321
        self.treeview.set_search_column(treemodel.REVNO)
 
322
        
 
323
        # Fix old PyGTK bug - by JAM
 
324
        set_tooltip = getattr(self.treeview, 'set_tooltip_column', None)
 
325
        if set_tooltip is not None:
 
326
            set_tooltip(treemodel.MESSAGE)
 
327
 
363
328
        self.treeview.connect("cursor-changed",
364
329
                self._on_selection_changed)
365
330
 
373
338
 
374
339
        self.treeview.show()
375
340
 
376
 
        cell = Gtk.CellRendererText()
 
341
        cell = gtk.CellRendererText()
377
342
        cell.set_property("width-chars", 15)
378
 
        cell.set_property("ellipsize", Pango.EllipsizeMode.END)
379
 
        self.revno_column = Gtk.TreeViewColumn("Revision No")
380
 
        self.revno_column.set_resizable(True)
381
 
        self.revno_column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
382
 
        self.revno_column.set_fixed_width(
383
 
            cell.get_preferred_width(self.treeview)[1])
384
 
        self.revno_column.pack_start(cell, True)
 
343
        cell.set_property("ellipsize", pango.ELLIPSIZE_END)
 
344
        self.revno_column = gtk.TreeViewColumn("Revision No")
 
345
        self.revno_column.set_resizable(False)
 
346
        self.revno_column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
 
347
        self.revno_column.set_fixed_width(cell.get_size(self.treeview)[2])
 
348
        self.revno_column.pack_start(cell, expand=True)
385
349
        self.revno_column.add_attribute(cell, "text", treemodel.REVNO)
386
350
        self.treeview.append_column(self.revno_column)
387
351
 
388
352
        self.graph_cell = CellRendererGraph()
389
 
        self.graph_column = Gtk.TreeViewColumn()
390
 
        self.graph_column.set_resizable(True)
391
 
        self.graph_column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
392
 
        self.graph_column.pack_start(self.graph_cell, True)
 
353
        self.graph_column = gtk.TreeViewColumn()
 
354
        self.graph_column.set_resizable(False)
 
355
        self.graph_column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
 
356
        self.graph_column.pack_start(self.graph_cell, expand=True)
393
357
        self.graph_column.add_attribute(self.graph_cell, "node", treemodel.NODE)
394
358
        self.graph_column.add_attribute(self.graph_cell, "tags", treemodel.TAGS)
395
359
        self.graph_column.add_attribute(self.graph_cell, "in-lines", treemodel.LAST_LINES)
396
360
        self.graph_column.add_attribute(self.graph_cell, "out-lines", treemodel.LINES)
397
361
        self.treeview.append_column(self.graph_column)
398
362
 
399
 
        cell = Gtk.CellRendererText()
 
363
        cell = gtk.CellRendererText()
400
364
        cell.set_property("width-chars", 65)
401
 
        cell.set_property("ellipsize", Pango.EllipsizeMode.END)
402
 
        self.summary_column = Gtk.TreeViewColumn("Summary")
403
 
        self.summary_column.set_resizable(True)
 
365
        cell.set_property("ellipsize", pango.ELLIPSIZE_END)
 
366
        self.summary_column = gtk.TreeViewColumn("Summary")
 
367
        self.summary_column.set_resizable(False)
404
368
        self.summary_column.set_expand(True)
405
 
        self.summary_column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
406
 
        self.summary_column.set_fixed_width(
407
 
            cell.get_preferred_width(self.treeview)[1])
408
 
        self.summary_column.pack_start(cell, True)
 
369
        self.summary_column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
 
370
        self.summary_column.set_fixed_width(cell.get_size(self.treeview)[2])
 
371
        self.summary_column.pack_start(cell, expand=True)
409
372
        self.summary_column.add_attribute(cell, "markup", treemodel.SUMMARY)
410
373
        self.treeview.append_column(self.summary_column)
411
374
 
412
 
        cell = Gtk.CellRendererText()
 
375
        cell = gtk.CellRendererText()
413
376
        cell.set_property("width-chars", 15)
414
 
        cell.set_property("ellipsize", Pango.EllipsizeMode.END)
415
 
        self.authors_column = Gtk.TreeViewColumn("Author(s)")
416
 
        self.authors_column.set_resizable(False)
417
 
        self.authors_column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
418
 
        self.authors_column.set_fixed_width(200)
419
 
        self.authors_column.pack_start(cell, True)
420
 
        self.authors_column.add_attribute(cell, "text", treemodel.AUTHORS)
421
 
        self.treeview.append_column(self.authors_column)
 
377
        cell.set_property("ellipsize", pango.ELLIPSIZE_END)
 
378
        self.committer_column = gtk.TreeViewColumn("Committer")
 
379
        self.committer_column.set_resizable(False)
 
380
        self.committer_column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
 
381
        self.committer_column.set_fixed_width(200)
 
382
        self.committer_column.pack_start(cell, expand=True)
 
383
        self.committer_column.add_attribute(cell, "text", treemodel.COMMITTER)
 
384
        self.treeview.append_column(self.committer_column)
422
385
 
423
 
        cell = Gtk.CellRendererText()
 
386
        cell = gtk.CellRendererText()
424
387
        cell.set_property("width-chars", 20)
425
 
        cell.set_property("ellipsize", Pango.EllipsizeMode.END)
426
 
        self.date_column = Gtk.TreeViewColumn("Date")
 
388
        cell.set_property("ellipsize", pango.ELLIPSIZE_END)
 
389
        self.date_column = gtk.TreeViewColumn("Date")
427
390
        self.date_column.set_visible(False)
428
 
        self.date_column.set_resizable(True)
429
 
        self.date_column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
 
391
        self.date_column.set_resizable(False)
 
392
        self.date_column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
430
393
        self.date_column.set_fixed_width(130)
431
 
        self.date_column.pack_start(cell, True)
 
394
        self.date_column.pack_start(cell, expand=True)
432
395
        self.date_column.add_attribute(cell, "text", treemodel.TIMESTAMP)
433
396
        self.treeview.append_column(self.date_column)
434
 
 
 
397
        
435
398
        return self.treeview
436
 
 
 
399
    
437
400
    def _on_selection_changed(self, treeview):
438
401
        """callback for when the treeview changes."""
439
402
        (path, focus) = treeview.get_cursor()
440
 
        if (path is not None) and (path != self._prev_cursor_path):
441
 
            self._prev_cursor_path = path # avoid emitting twice per click
442
 
            self.path = path
 
403
        if path is not None:
 
404
            self.iter = self.model.get_iter(path)
443
405
            self.emit('revision-selected')
444
406
 
445
407
    def _on_revision_selected(self, widget, event):