/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 viz/branchwin.py

  • Committer: Szilveszter Farkas (Phanatic)
  • Date: 2007-03-15 16:23:15 UTC
  • mfrom: (170 trunk)
  • mto: (170.1.3 trunk)
  • mto: This revision was merged to the branch mainline in revision 172.
  • Revision ID: szilveszter.farkas@gmail.com-20070315162315-rs1sbxjh31n314zc
Merge from trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
viz/branchwin.py
1
 
#!/usr/bin/python
2
1
# -*- coding: UTF-8 -*-
3
2
"""Branch window.
4
3
 
10
9
__author__    = "Scott James Remnant <scott@ubuntu.com>"
11
10
 
12
11
 
13
 
import os
14
 
 
15
12
import gtk
16
13
import gobject
17
14
import pango
29
26
    for a particular branch.
30
27
    """
31
28
 
32
 
    def __init__(self, app=None):
 
29
    def __init__(self):
33
30
        gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
34
31
        self.set_border_width(0)
35
32
        self.set_title("bzrk")
36
33
 
37
 
        self.app = app
38
 
 
39
34
        # Use three-quarters of the screen by default
40
35
        screen = self.get_screen()
41
36
        monitor = screen.get_monitor_geometry(0)
54
49
 
55
50
    def construct(self):
56
51
        """Construct the window contents."""
 
52
        vbox = gtk.VBox(spacing=0)
 
53
        self.add(vbox)
 
54
 
 
55
        vbox.pack_start(self.construct_navigation(), expand=False, fill=True)
 
56
 
57
57
        paned = gtk.VPaned()
58
58
        paned.pack1(self.construct_top(), resize=True, shrink=False)
59
59
        paned.pack2(self.construct_bottom(), resize=False, shrink=True)
60
 
        self.add(paned)
61
60
        paned.show()
 
61
        vbox.pack_start(paned, expand=True, fill=True)
 
62
        vbox.set_focus_child(paned)
 
63
 
 
64
        vbox.show()
62
65
 
63
66
    def construct_top(self):
64
67
        """Construct the top-half of the window."""
65
 
        vbox = gtk.VBox(spacing=6)
66
 
        vbox.set_border_width(12)
67
 
        vbox.show()
68
 
 
69
68
        scrollwin = gtk.ScrolledWindow()
70
69
        scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
71
70
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
72
 
        vbox.pack_start(scrollwin, expand=True, fill=True)
73
71
        scrollwin.show()
74
72
 
75
73
        self.treeview = gtk.TreeView()
76
74
        self.treeview.set_rules_hint(True)
77
75
        self.treeview.set_search_column(4)
78
76
        self.treeview.connect("cursor-changed", self._treeview_cursor_cb)
 
77
        self.treeview.connect("row-activated", self._treeview_row_activated_cb)
79
78
        scrollwin.add(self.treeview)
80
79
        self.treeview.show()
81
80
 
82
81
        cell = CellRendererGraph()
83
82
        column = gtk.TreeViewColumn()
84
 
        column.set_resizable(False)
 
83
        column.set_resizable(True)
85
84
        column.pack_start(cell, expand=False)
86
85
        column.add_attribute(cell, "node", 1)
87
86
        column.add_attribute(cell, "in-lines", 2)
114
113
        column.add_attribute(cell, "text", 6)
115
114
        self.treeview.append_column(column)
116
115
 
117
 
        hbox = gtk.HBox(False, spacing=6)
118
 
        vbox.pack_start(hbox, expand=False, fill=False)
 
116
        return scrollwin
 
117
 
 
118
    def construct_navigation(self):
 
119
        """Construct the navigation buttons."""
 
120
        frame = gtk.Frame()
 
121
        frame.set_shadow_type(gtk.SHADOW_OUT)
 
122
        frame.show()
 
123
        
 
124
        hbox = gtk.HBox(spacing=12)
 
125
        frame.add(hbox)
119
126
        hbox.show()
120
127
 
121
128
        self.back_button = gtk.Button(stock=gtk.STOCK_GO_BACK)
 
129
        self.back_button.set_relief(gtk.RELIEF_NONE)
122
130
        self.back_button.add_accelerator("clicked", self.accel_group, ord('['),
123
131
                                         0, 0)
124
132
        self.back_button.connect("clicked", self._back_clicked_cb)
126
134
        self.back_button.show()
127
135
 
128
136
        self.fwd_button = gtk.Button(stock=gtk.STOCK_GO_FORWARD)
 
137
        self.fwd_button.set_relief(gtk.RELIEF_NONE)
129
138
        self.fwd_button.add_accelerator("clicked", self.accel_group, ord(']'),
130
139
                                        0, 0)
131
140
        self.fwd_button.connect("clicked", self._fwd_clicked_cb)
132
141
        hbox.pack_start(self.fwd_button, expand=False, fill=True)
133
142
        self.fwd_button.show()
134
143
 
135
 
        return vbox
 
144
        return frame
136
145
 
137
146
    def construct_bottom(self):
138
147
        """Construct the bottom half of the window."""
139
 
        vbox = gtk.VBox(False, spacing=6)
140
 
        vbox.set_border_width(12)
 
148
        from bzrlib.plugins.gtk.logview import LogView
 
149
        self.logview = LogView()
 
150
        self.logview.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
 
151
        self.logview.set_shadow_type(gtk.SHADOW_NONE)
141
152
        (width, height) = self.get_size()
142
 
        vbox.set_size_request(width, int(height / 2.5))
143
 
        vbox.show()
144
 
 
145
 
        self.table = gtk.Table(rows=4, columns=2)
146
 
        self.table.set_row_spacings(6)
147
 
        self.table.set_col_spacings(6)
148
 
        vbox.pack_start(self.table, expand=False, fill=True)
149
 
        self.table.show()
150
 
 
151
 
        align = gtk.Alignment(0.0, 0.5)
152
 
        label = gtk.Label()
153
 
        label.set_markup("<b>Revision:</b>")
154
 
        align.add(label)
155
 
        self.table.attach(align, 0, 1, 0, 1, gtk.FILL, gtk.FILL)
156
 
        label.show()
157
 
        align.show()
158
 
 
159
 
        align = gtk.Alignment(0.0, 0.5)
160
 
        self.revid_label = gtk.Label()
161
 
        self.revid_label.set_selectable(True)
162
 
        align.add(self.revid_label)
163
 
        self.table.attach(align, 1, 2, 0, 1, gtk.EXPAND | gtk.FILL, gtk.FILL)
164
 
        self.revid_label.show()
165
 
        align.show()
166
 
 
167
 
        align = gtk.Alignment(0.0, 0.5)
168
 
        label = gtk.Label()
169
 
        label.set_markup("<b>Committer:</b>")
170
 
        align.add(label)
171
 
        self.table.attach(align, 0, 1, 1, 2, gtk.FILL, gtk.FILL)
172
 
        label.show()
173
 
        align.show()
174
 
 
175
 
        align = gtk.Alignment(0.0, 0.5)
176
 
        self.committer_label = gtk.Label()
177
 
        self.committer_label.set_selectable(True)
178
 
        align.add(self.committer_label)
179
 
        self.table.attach(align, 1, 2, 1, 2, gtk.EXPAND | gtk.FILL, gtk.FILL)
180
 
        self.committer_label.show()
181
 
        align.show()
182
 
 
183
 
        align = gtk.Alignment(0.0, 0.5)
184
 
        label = gtk.Label()
185
 
        label.set_markup("<b>Timestamp:</b>")
186
 
        align.add(label)
187
 
        self.table.attach(align, 0, 1, 2, 3, gtk.FILL, gtk.FILL)
188
 
        label.show()
189
 
        align.show()
190
 
 
191
 
        align = gtk.Alignment(0.0, 0.5)
192
 
        self.timestamp_label = gtk.Label()
193
 
        self.timestamp_label.set_selectable(True)
194
 
        align.add(self.timestamp_label)
195
 
        self.table.attach(align, 1, 2, 2, 3, gtk.EXPAND | gtk.FILL, gtk.FILL)
196
 
        self.timestamp_label.show()
197
 
        align.show()
198
 
 
199
 
        align = gtk.Alignment(0.0, 0.5)
200
 
        label = gtk.Label()
201
 
        label.set_markup("<b>Parents:</b>")
202
 
        align.add(label)
203
 
        self.table.attach(align, 0, 1, 3, 4, gtk.FILL, gtk.FILL)
204
 
        label.show()
205
 
        align.show()
206
 
 
207
 
        self.parents_widgets = []
208
 
 
209
 
        scrollwin = gtk.ScrolledWindow()
210
 
        scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
211
 
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
212
 
        vbox.pack_start(scrollwin, expand=True, fill=True)
213
 
        scrollwin.show()
214
 
 
215
 
        self.message_buffer = gtk.TextBuffer()
216
 
        textview = gtk.TextView(self.message_buffer)
217
 
        textview.set_editable(False)
218
 
        textview.set_wrap_mode(gtk.WRAP_WORD)
219
 
        textview.modify_font(pango.FontDescription("Monospace"))
220
 
        scrollwin.add(textview)
221
 
        textview.show()
222
 
 
223
 
        return vbox
224
 
 
225
 
    def set_branch(self, branch, start):
 
153
        self.logview.set_size_request(width, int(height / 2.5))
 
154
        self.logview.show()
 
155
        self.logview.set_show_callback(self._show_clicked_cb)
 
156
        self.logview.set_go_callback(self._go_clicked_cb)
 
157
        return self.logview
 
158
 
 
159
    def set_branch(self, branch, start, maxnum):
226
160
        """Set the branch and start position for this window.
227
161
 
228
162
        Creates a new TreeModel and populates it with information about
241
175
        index = 0
242
176
 
243
177
        last_lines = []
244
 
        (revids, self.revisions, colours, self.children) \
245
 
                 = distances(branch, start)
246
 
        for revision, node, lines in graph(revids, self.revisions, colours):
 
178
        (self.revisions, colours, self.children, self.parent_ids,
 
179
         merge_sorted) = distances(branch, start)
 
180
        for (index, (revision, node, lines)) in enumerate(graph(
 
181
                self.revisions, colours, merge_sorted)):
 
182
            # FIXME: at this point we should be able to show the graph order
 
183
            # and lines with no message or commit data - and then incrementally
 
184
            # fill the timestamp, committer etc data as desired.
247
185
            message = revision.message.split("\n")[0]
248
186
            if revision.committer is not None:
249
187
                timestamp = format_date(revision.timestamp, revision.timezone)
250
188
            else:
251
189
                timestamp = None
252
 
 
253
 
            self.model.append([ revision, node, last_lines, lines,
254
 
                                message, revision.committer, timestamp ])
 
190
            self.model.append([revision, node, last_lines, lines,
 
191
                               message, revision.committer, timestamp])
255
192
            self.index[revision] = index
256
 
            index += 1
257
 
 
258
193
            last_lines = lines
 
194
            if maxnum is not None and index > maxnum:
 
195
                break
259
196
 
260
 
        self.set_title(os.path.basename(branch.base) + " - bzrk")
 
197
        self.set_title(branch.nick + " - bzrk")
261
198
        self.treeview.set_model(self.model)
262
199
 
263
200
    def _treeview_cursor_cb(self, *args):
265
202
        (path, col) = self.treeview.get_cursor()
266
203
        revision = self.model[path][0]
267
204
 
268
 
        self.back_button.set_sensitive(len(revision.parent_ids) > 0)
 
205
        self.back_button.set_sensitive(len(self.parent_ids[revision]) > 0)
269
206
        self.fwd_button.set_sensitive(len(self.children[revision]) > 0)
270
 
 
271
 
        if revision.committer is not None:
272
 
            committer = revision.committer
273
 
            timestamp = format_date(revision.timestamp, revision.timezone)
274
 
            message = revision.message
275
 
        else:
276
 
            committer = ""
277
 
            timestamp = ""
278
 
            message = ""
279
 
 
280
 
        self.revid_label.set_text(revision.revision_id)
281
 
        self.committer_label.set_text(committer)
282
 
        self.timestamp_label.set_text(timestamp)
283
 
        self.message_buffer.set_text(message)
284
 
 
285
 
        for widget in self.parents_widgets:
286
 
            self.table.remove(widget)
287
 
 
288
 
        self.parents_widgets = []
289
 
        self.table.resize(4 + len(revision.parent_ids) - 1, 2)
290
 
        for idx, parent_id in enumerate(revision.parent_ids):
291
 
            self.table.set_row_spacing(idx + 3, 0)
292
 
 
293
 
            align = gtk.Alignment(0.0, 0.0)
294
 
            self.parents_widgets.append(align)
295
 
            self.table.attach(align, 1, 2, idx + 3, idx + 4,
296
 
                              gtk.EXPAND | gtk.FILL, gtk.FILL)
297
 
            align.show()
298
 
 
299
 
            hbox = gtk.HBox(False, 0)
300
 
            align.add(hbox)
301
 
            hbox.show()
302
 
 
303
 
            label = gtk.Label(parent_id)
304
 
            label.set_selectable(True)
305
 
            hbox.pack_start(label, expand=False, fill=True)
306
 
            label.show()
307
 
 
308
 
            image = gtk.Image()
309
 
            image.set_from_stock(gtk.STOCK_JUMP_TO, gtk.ICON_SIZE_MENU)
310
 
            image.show()
311
 
 
312
 
            button = gtk.Button()
313
 
            button.add(image)
314
 
            button.set_relief(gtk.RELIEF_NONE)
315
 
            button.connect("clicked", self._go_clicked_cb, parent_id)
316
 
            hbox.pack_start(button, expand=False, fill=True)
317
 
            button.show()
318
 
 
319
 
            image = gtk.Image()
320
 
            image.set_from_stock(gtk.STOCK_FIND, gtk.ICON_SIZE_MENU)
321
 
            image.show()
322
 
 
323
 
            button = gtk.Button()
324
 
            button.add(image)
325
 
            button.set_relief(gtk.RELIEF_NONE)
326
 
            button.set_sensitive(self.app is not None)
327
 
            button.connect("clicked", self._show_clicked_cb,
328
 
                           revision.revision_id, parent_id)
329
 
            hbox.pack_start(button, expand=False, fill=True)
330
 
            button.show()
 
207
        self.logview.set_revision(revision)
331
208
 
332
209
    def _back_clicked_cb(self, *args):
333
210
        """Callback for when the back button is clicked."""
334
211
        (path, col) = self.treeview.get_cursor()
335
212
        revision = self.model[path][0]
336
 
        if not len(revision.parent_ids):
 
213
        if not len(self.parent_ids[revision]):
337
214
            return
338
215
 
339
 
        for parent_id in revision.parent_ids:
 
216
        for parent_id in self.parent_ids[revision]:
340
217
            parent = self.revisions[parent_id]
341
218
            if same_branch(revision, parent):
342
219
                self.treeview.set_cursor(self.index[parent])
343
220
                break
344
221
        else:
345
 
            next = self.revisions[revision.parent_ids[0]]
 
222
            next = self.revisions[self.parent_ids[revision][0]]
346
223
            self.treeview.set_cursor(self.index[next])
 
224
        self.treeview.grab_focus()
347
225
 
348
226
    def _fwd_clicked_cb(self, *args):
349
227
        """Callback for when the forward button is clicked."""
359
237
        else:
360
238
            prev = list(self.children[revision])[0]
361
239
            self.treeview.set_cursor(self.index[prev])
 
240
        self.treeview.grab_focus()
362
241
 
363
 
    def _go_clicked_cb(self, widget, revid):
 
242
    def _go_clicked_cb(self, revid):
364
243
        """Callback for when the go button for a parent is clicked."""
365
244
        self.treeview.set_cursor(self.index[self.revisions[revid]])
366
 
 
367
 
    def _show_clicked_cb(self, widget, revid, parentid):
 
245
        self.treeview.grab_focus()
 
246
 
 
247
    def show_diff(self, branch, revid, parentid):
 
248
        """Open a new window to show a diff between the given revisions."""
 
249
        from bzrlib.plugins.gtk.diff import DiffWindow
 
250
        window = DiffWindow()
 
251
        rev_tree = branch.repository.revision_tree(revid)
 
252
        parent_tree = branch.repository.revision_tree(parentid)
 
253
        description = revid + " - " + branch.nick
 
254
        window.set_diff(description, rev_tree, parent_tree)
 
255
        window.show()
 
256
 
 
257
    def _show_clicked_cb(self, revid, parentid):
368
258
        """Callback for when the show button for a parent is clicked."""
369
 
        if self.app is not None:
370
 
            self.app.show_diff(self.branch, revid, parentid)
 
259
        self.show_diff(self.branch, revid, parentid)
 
260
        self.treeview.grab_focus()
 
261
 
 
262
    def _treeview_row_activated_cb(self, widget, path, col):
 
263
        # TODO: more than one parent
 
264
        """Callback for when a treeview row gets activated."""
 
265
        revision = self.model[path][0]
 
266
        if len(self.parent_ids[revision]) == 0:
 
267
            # Ignore revisions without parent
 
268
            return
 
269
        parent_id = self.parent_ids[revision][0]
 
270
        self.show_diff(self.branch, revision.revision_id, parent_id)
 
271
        self.treeview.grab_focus()