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

  • Committer: Scott James Remnant
  • Date: 2005-10-17 01:07:49 UTC
  • Revision ID: scott@netsplit.com-20051017010749-15fa95fc2cf09289
Commit the first version of bzrk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
branchwin.py
 
1
#!/usr/bin/python
1
2
# -*- coding: UTF-8 -*-
2
3
"""Branch window.
3
4
 
9
10
__author__    = "Scott James Remnant <scott@ubuntu.com>"
10
11
 
11
12
 
 
13
import os
 
14
 
12
15
import gtk
13
16
import gobject
14
17
import pango
15
18
 
16
19
from bzrlib.osutils import format_date
17
20
 
18
 
from graph import distances, graph, same_branch
 
21
from graph import graph
19
22
from graphcell import CellRendererGraph
20
23
 
21
24
 
26
29
    for a particular branch.
27
30
    """
28
31
 
29
 
    def __init__(self, app=None):
 
32
    def __init__(self):
30
33
        gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
31
34
        self.set_border_width(0)
32
35
        self.set_title("bzrk")
33
36
 
34
 
        self.app = app
35
 
 
36
37
        # Use three-quarters of the screen by default
37
38
        screen = self.get_screen()
38
 
        monitor = screen.get_monitor_geometry(0)
39
 
        width = int(monitor.width * 0.75)
40
 
        height = int(monitor.height * 0.75)
 
39
        width = int(screen.get_width() * 0.75)
 
40
        height = int(screen.get_height() * 0.75)
41
41
        self.set_default_size(width, height)
42
42
 
43
43
        # FIXME AndyFitz!
44
44
        icon = self.render_icon(gtk.STOCK_INDEX, gtk.ICON_SIZE_BUTTON)
45
45
        self.set_icon(icon)
46
46
 
47
 
        self.accel_group = gtk.AccelGroup()
48
 
        self.add_accel_group(self.accel_group)
49
 
 
50
47
        self.construct()
51
48
 
52
49
    def construct(self):
53
50
        """Construct the window contents."""
54
 
        vbox = gtk.VBox(spacing=0)
55
 
        self.add(vbox)
56
 
 
57
 
        vbox.pack_start(self.construct_navigation(), expand=False, fill=True)
58
 
 
59
 
        paned = gtk.VPaned()
60
 
        paned.pack1(self.construct_top(), resize=True, shrink=False)
61
 
        paned.pack2(self.construct_bottom(), resize=False, shrink=True)
62
 
        paned.show()
63
 
        vbox.pack_start(paned, expand=True, fill=True)
64
 
        vbox.set_focus_child(paned)
65
 
 
66
 
        vbox.show()
67
 
 
68
 
    def construct_top(self):
69
 
        """Construct the top-half of the window."""
70
51
        scrollwin = gtk.ScrolledWindow()
71
52
        scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
72
53
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
 
54
        scrollwin.set_border_width(12)
 
55
        self.add(scrollwin)
73
56
        scrollwin.show()
74
57
 
75
58
        self.treeview = gtk.TreeView()
76
59
        self.treeview.set_rules_hint(True)
77
60
        self.treeview.set_search_column(4)
78
 
        self.treeview.connect("cursor-changed", self._treeview_cursor_cb)
79
 
        self.treeview.connect("row-activated", self._treeview_row_activated_cb)
80
61
        scrollwin.add(self.treeview)
81
62
        self.treeview.show()
82
63
 
83
64
        cell = CellRendererGraph()
84
65
        column = gtk.TreeViewColumn()
85
 
        column.set_resizable(True)
 
66
        column.set_resizable(False)
86
67
        column.pack_start(cell, expand=False)
87
68
        column.add_attribute(cell, "node", 1)
88
69
        column.add_attribute(cell, "in-lines", 2)
115
96
        column.add_attribute(cell, "text", 6)
116
97
        self.treeview.append_column(column)
117
98
 
118
 
        return scrollwin
119
 
 
120
 
    def construct_navigation(self):
121
 
        """Construct the navigation buttons."""
122
 
        frame = gtk.Frame()
123
 
        frame.set_shadow_type(gtk.SHADOW_OUT)
124
 
        frame.show()
125
 
        
126
 
        hbox = gtk.HBox(spacing=12)
127
 
        frame.add(hbox)
128
 
        hbox.show()
129
 
 
130
 
        self.back_button = gtk.Button(stock=gtk.STOCK_GO_BACK)
131
 
        self.back_button.set_relief(gtk.RELIEF_NONE)
132
 
        self.back_button.add_accelerator("clicked", self.accel_group, ord('['),
133
 
                                         0, 0)
134
 
        self.back_button.connect("clicked", self._back_clicked_cb)
135
 
        hbox.pack_start(self.back_button, expand=False, fill=True)
136
 
        self.back_button.show()
137
 
 
138
 
        self.fwd_button = gtk.Button(stock=gtk.STOCK_GO_FORWARD)
139
 
        self.fwd_button.set_relief(gtk.RELIEF_NONE)
140
 
        self.fwd_button.add_accelerator("clicked", self.accel_group, ord(']'),
141
 
                                        0, 0)
142
 
        self.fwd_button.connect("clicked", self._fwd_clicked_cb)
143
 
        hbox.pack_start(self.fwd_button, expand=False, fill=True)
144
 
        self.fwd_button.show()
145
 
 
146
 
        return frame
147
 
 
148
 
    def construct_bottom(self):
149
 
        """Construct the bottom half of the window."""
150
 
        from bzrlib.plugins.gtk.logview import LogView
151
 
        self.logview = LogView()
152
 
        self.logview.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
153
 
        self.logview.set_shadow_type(gtk.SHADOW_NONE)
154
 
        (width, height) = self.get_size()
155
 
        self.logview.set_size_request(width, int(height / 2.5))
156
 
        self.logview.show()
157
 
        self.logview.set_show_callback(self._show_clicked_cb)
158
 
        self.logview.set_go_callback(self._go_clicked_cb)
159
 
        return self.logview
160
 
 
161
 
    def set_branch(self, branch, start, maxnum):
 
99
    def set_branch(self, branch, start):
162
100
        """Set the branch and start position for this window.
163
101
 
164
102
        Creates a new TreeModel and populates it with information about
165
103
        the new branch before updating the window title and model of the
166
104
        treeview itself.
167
105
        """
168
 
        self.branch = branch
169
 
 
170
106
        # [ revision, node, last_lines, lines, message, committer, timestamp ]
171
 
        self.model = gtk.ListStore(gobject.TYPE_PYOBJECT,
172
 
                                   gobject.TYPE_PYOBJECT,
173
 
                                   gobject.TYPE_PYOBJECT,
174
 
                                   gobject.TYPE_PYOBJECT,
175
 
                                   str, str, str)
176
 
        self.index = {}
177
 
        index = 0
 
107
        model = gtk.ListStore(gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT,
 
108
                              gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT,
 
109
                              str, str, str)
178
110
 
179
111
        last_lines = []
180
 
        (self.revisions, colours, self.children, self.parent_ids,
181
 
         merge_sorted) = distances(branch, start)
182
 
        for (index, (revision, node, lines)) in enumerate(graph(
183
 
                self.revisions, colours, merge_sorted)):
184
 
            # FIXME: at this point we should be able to show the graph order
185
 
            # and lines with no message or commit data - and then incrementally
186
 
            # fill the timestamp, committer etc data as desired.
 
112
        for revision, node, lines in graph(branch, start):
187
113
            message = revision.message.split("\n")[0]
188
114
            if revision.committer is not None:
189
115
                timestamp = format_date(revision.timestamp, revision.timezone)
190
116
            else:
191
117
                timestamp = None
192
 
            self.model.append([revision, node, last_lines, lines,
193
 
                               message, revision.committer, timestamp])
194
 
            self.index[revision] = index
 
118
 
 
119
            model.append([ revision, node, last_lines, lines,
 
120
                           message, revision.committer, timestamp ])
195
121
            last_lines = lines
196
 
            if maxnum is not None and index > maxnum:
197
 
                break
198
 
 
199
 
        self.set_title(branch.nick + " - bzrk")
200
 
        self.treeview.set_model(self.model)
201
 
 
202
 
    def _treeview_cursor_cb(self, *args):
203
 
        """Callback for when the treeview cursor changes."""
204
 
        (path, col) = self.treeview.get_cursor()
205
 
        revision = self.model[path][0]
206
 
 
207
 
        self.back_button.set_sensitive(len(self.parent_ids[revision]) > 0)
208
 
        self.fwd_button.set_sensitive(len(self.children[revision]) > 0)
209
 
        self.logview.set_revision(revision)
210
 
 
211
 
    def _back_clicked_cb(self, *args):
212
 
        """Callback for when the back button is clicked."""
213
 
        (path, col) = self.treeview.get_cursor()
214
 
        revision = self.model[path][0]
215
 
        if not len(self.parent_ids[revision]):
216
 
            return
217
 
 
218
 
        for parent_id in self.parent_ids[revision]:
219
 
            parent = self.revisions[parent_id]
220
 
            if same_branch(revision, parent):
221
 
                self.treeview.set_cursor(self.index[parent])
222
 
                break
223
 
        else:
224
 
            next = self.revisions[self.parent_ids[revision][0]]
225
 
            self.treeview.set_cursor(self.index[next])
226
 
        self.treeview.grab_focus()
227
 
 
228
 
    def _fwd_clicked_cb(self, *args):
229
 
        """Callback for when the forward button is clicked."""
230
 
        (path, col) = self.treeview.get_cursor()
231
 
        revision = self.model[path][0]
232
 
        if not len(self.children[revision]):
233
 
            return
234
 
 
235
 
        for child in self.children[revision]:
236
 
            if same_branch(child, revision):
237
 
                self.treeview.set_cursor(self.index[child])
238
 
                break
239
 
        else:
240
 
            prev = list(self.children[revision])[0]
241
 
            self.treeview.set_cursor(self.index[prev])
242
 
        self.treeview.grab_focus()
243
 
 
244
 
    def _go_clicked_cb(self, revid):
245
 
        """Callback for when the go button for a parent is clicked."""
246
 
        self.treeview.set_cursor(self.index[self.revisions[revid]])
247
 
        self.treeview.grab_focus()
248
 
 
249
 
    def _show_clicked_cb(self, revid, parentid):
250
 
        """Callback for when the show button for a parent is clicked."""
251
 
        if self.app is not None:
252
 
            self.app.show_diff(self.branch, revid, parentid)
253
 
        self.treeview.grab_focus()
254
 
 
255
 
    def _treeview_row_activated_cb(self, widget, path, col):
256
 
        # TODO: more than one parent
257
 
        """Callback for when a treeview row gets activated."""
258
 
        revision = self.model[path][0]
259
 
        if len(self.parent_ids[revision]) == 0:
260
 
            # Ignore revisions without parent
261
 
            return
262
 
        parent_id = self.parent_ids[revision][0]
263
 
        if self.app is not None:
264
 
            self.app.show_diff(self.branch, revision.revision_id, parent_id)
265
 
        self.treeview.grab_focus()
 
122
 
 
123
        self.set_title(os.path.basename(branch.base) + " - bzrk")
 
124
        self.treeview.set_model(model)