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

  • Committer: Vincent Ladeuil
  • Date: 2008-06-10 15:25:47 UTC
  • mto: This revision was merged to the branch mainline in revision 504.
  • Revision ID: v.ladeuil+lp@free.fr-20080610152547-dwmil1p8pd0mfpnl
Fix third failing test (thanks to jam).

* tests/test_commit.py:
(TestPendingRevisions.test_pending_revisions_multi_merge): Fix
provided by jam: bzr we now filter the pending merges so that only
the 'heads()' are included. We just ensure that the pending merges
contain the unique tips for the ancestries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
branchview/graphcell.py
1
 
#!/usr/bin/python
2
1
# -*- coding: UTF-8 -*-
3
2
"""Cell renderer for directed graph.
4
3
 
31
30
      in_lines          (start, end, colour) tuple list to draw inward lines,
32
31
      out_lines         (start, end, colour) tuple list to draw outward lines.
33
32
    """
 
33
    
 
34
    columns_len = 0
34
35
 
35
36
    __gproperties__ = {
36
37
        "node":         ( gobject.TYPE_PYOBJECT, "node",
37
38
                          "revision node instruction",
38
39
                          gobject.PARAM_WRITABLE
39
40
                        ),
 
41
        "tags":         ( gobject.TYPE_PYOBJECT, "tags",
 
42
                          "list of tags associated with the node",
 
43
                          gobject.PARAM_WRITABLE
 
44
                        ),
40
45
        "in-lines":     ( gobject.TYPE_PYOBJECT, "in-lines",
41
46
                          "instructions to draw lines into the cell",
42
47
                          gobject.PARAM_WRITABLE
46
51
                          gobject.PARAM_WRITABLE
47
52
                        ),
48
53
        }
49
 
 
 
54
    
50
55
    def do_set_property(self, property, value):
51
56
        """Set properties from GObject properties."""
52
57
        if property.name == "node":
53
58
            self.node = value
 
59
        elif property.name == "tags":
 
60
            self.tags = value
54
61
        elif property.name == "in-lines":
55
62
            self.in_lines = value
56
63
        elif property.name == "out-lines":
85
92
        colours and the fg parameter provides the multiplier that should be
86
93
        applied to the foreground colours.
87
94
        """
 
95
        mainline_color = ( 0.0, 0.0, 0.0 )
88
96
        colours = [
89
97
            ( 1.0, 0.0, 0.0 ),
90
98
            ( 1.0, 1.0, 0.0 ),
94
102
            ( 1.0, 0.0, 1.0 ),
95
103
            ]
96
104
 
97
 
        colour %= len(colours)
98
 
        red   = (colours[colour][0] * fg) or bg
99
 
        green = (colours[colour][1] * fg) or bg
100
 
        blue  = (colours[colour][2] * fg) or bg
 
105
        if colour == 0:
 
106
            colour_rgb = mainline_color
 
107
        else:
 
108
            colour_rgb = colours[colour % len(colours)]
 
109
 
 
110
        red   = (colour_rgb[0] * fg) or bg
 
111
        green = (colour_rgb[1] * fg) or bg
 
112
        blue  = (colour_rgb[2] * fg) or bg
101
113
 
102
114
        ctx.set_source_rgb(red, green, blue)
103
115
 
108
120
        to be, we let the TreeViewColumn take care of making them all
109
121
        line up.
110
122
        """
111
 
        box_size = self.box_size(widget)
112
 
 
113
 
        cols = self.node[0]
114
 
        for start, end, colour in self.in_lines + self.out_lines:
115
 
            cols = max(cols, start, end)
116
 
 
117
 
        width = box_size * (cols + 1)
 
123
        box_size = self.box_size(widget) + 1
 
124
 
 
125
        width = box_size * (self.columns_len + 1)
118
126
        height = box_size
119
127
 
120
128
        # FIXME I have no idea how to use cell_area properly
141
149
        box_size = self.box_size(widget)
142
150
 
143
151
        ctx.set_line_width(box_size / 8)
144
 
        ctx.set_line_cap(cairo.LINE_CAP_SQUARE)
145
152
 
146
153
        # Draw lines into the cell
147
154
        for start, end, colour in self.in_lines:
148
 
            ctx.move_to(cell_area.x + box_size * start + box_size / 2,
149
 
                        bg_area.y - bg_area.height / 2)
150
 
 
151
 
            if start - end > 1:
152
 
                ctx.line_to(cell_area.x + box_size * start, bg_area.y)
153
 
                ctx.line_to(cell_area.x + box_size * end + box_size, bg_area.y)
154
 
            elif start - end < -1:
155
 
                ctx.line_to(cell_area.x + box_size * start + box_size,
156
 
                            bg_area.y)
157
 
                ctx.line_to(cell_area.x + box_size * end, bg_area.y)
158
 
 
159
 
            ctx.line_to(cell_area.x + box_size * end + box_size / 2,
160
 
                        bg_area.y + bg_area.height / 2)
161
 
 
162
 
            self.set_colour(ctx, colour, 0.0, 0.65)
163
 
            ctx.stroke()
 
155
            self.render_line (ctx, cell_area, box_size,
 
156
                         bg_area.y, bg_area.height,
 
157
                         start, end, colour, flags)
164
158
 
165
159
        # Draw lines out of the cell
166
160
        for start, end, colour in self.out_lines:
167
 
            ctx.move_to(cell_area.x + box_size * start + box_size / 2,
168
 
                        bg_area.y + bg_area.height / 2)
169
 
 
170
 
            if start - end > 1:
171
 
                ctx.line_to(cell_area.x + box_size * start,
172
 
                            bg_area.y + bg_area.height)
173
 
                ctx.line_to(cell_area.x + box_size * end + box_size,
174
 
                            bg_area.y + bg_area.height)
175
 
            elif start - end < -1:
176
 
                ctx.line_to(cell_area.x + box_size * start + box_size,
177
 
                            bg_area.y + bg_area.height)
178
 
                ctx.line_to(cell_area.x + box_size * end,
179
 
                            bg_area.y + bg_area.height)
180
 
 
181
 
            ctx.line_to(cell_area.x + box_size * end + box_size / 2,
182
 
                        bg_area.y + bg_area.height / 2 + bg_area.height)
183
 
 
184
 
            self.set_colour(ctx, colour, 0.0, 0.65)
185
 
            ctx.stroke()
 
161
            self.render_line (ctx, cell_area, box_size,
 
162
                         bg_area.y + bg_area.height, bg_area.height,
 
163
                         start, end, colour, flags)
186
164
 
187
165
        # Draw the revision node in the right column
188
166
        (column, colour) = self.node
190
168
                cell_area.y + cell_area.height / 2,
191
169
                box_size / 4, 0, 2 * math.pi)
192
170
 
 
171
        if flags & gtk.CELL_RENDERER_SELECTED:
 
172
            ctx.set_source_rgb(1.0, 1.0, 1.0)
 
173
            ctx.set_line_width(box_size / 4)
 
174
            ctx.stroke_preserve()
 
175
            ctx.set_line_width(box_size / 8)
 
176
 
193
177
        self.set_colour(ctx, colour, 0.0, 0.5)
194
178
        ctx.stroke_preserve()
195
179
 
196
180
        self.set_colour(ctx, colour, 0.5, 1.0)
197
181
        ctx.fill()
 
182
 
 
183
        self.render_tags(ctx, widget.create_pango_context(), cell_area, box_size)
 
184
    
 
185
    def render_line(self, ctx, cell_area, box_size, mid, height, start, end, colour, flags):
 
186
        if start is None:
 
187
            ctx.set_line_cap(cairo.LINE_CAP_ROUND)
 
188
            x = cell_area.x + box_size * end + box_size / 2
 
189
            ctx.move_to(x, mid + height / 3)
 
190
            ctx.line_to(x, mid + height / 3)
 
191
            ctx.move_to(x, mid + height / 6)
 
192
            ctx.line_to(x, mid + height / 6)
 
193
            
 
194
        elif end is None:
 
195
            ctx.set_line_cap(cairo.LINE_CAP_ROUND)
 
196
            x = cell_area.x + box_size * start + box_size / 2
 
197
            ctx.move_to(x, mid - height / 3)
 
198
            ctx.line_to(x, mid - height / 3)
 
199
            ctx.move_to(x, mid - height / 6)
 
200
            ctx.line_to(x, mid - height / 6)
 
201
 
 
202
        else:
 
203
            ctx.set_line_cap(cairo.LINE_CAP_BUTT)
 
204
            startx = cell_area.x + box_size * start + box_size / 2
 
205
            endx = cell_area.x + box_size * end + box_size / 2
 
206
            
 
207
            ctx.move_to(startx, mid - height / 2)
 
208
            
 
209
            if start - end == 0 :
 
210
                ctx.line_to(endx, mid + height / 2 + 1)
 
211
            else:
 
212
                ctx.curve_to(startx, mid - height / 5,
 
213
                             startx, mid - height / 5,
 
214
                             startx + (endx - startx) / 2, mid)
 
215
 
 
216
                ctx.curve_to(endx, mid + height / 5,
 
217
                             endx, mid + height / 5 ,
 
218
                             endx, mid + height / 2 + 1)
 
219
 
 
220
        if flags & gtk.CELL_RENDERER_SELECTED:
 
221
            ctx.set_source_rgb(1.0, 1.0, 1.0)
 
222
            ctx.set_line_width(box_size / 5)
 
223
            ctx.stroke_preserve()
 
224
            ctx.set_line_width(box_size / 8)
 
225
 
 
226
        self.set_colour(ctx, colour, 0.0, 0.65)
 
227
 
 
228
        ctx.stroke()
 
229
 
 
230
    def render_tags(self, ctx, pango_ctx, cell_area, box_size):
 
231
        # colour ID used in self.set_colour on the tags
 
232
        TAG_COLOUR_ID = 1
 
233
 
 
234
        (column, colour) = self.node
 
235
 
 
236
        font_desc = pango.FontDescription()
 
237
        font_desc.set_size(pango.SCALE * 7)
 
238
 
 
239
        tag_layout = pango.Layout(pango_ctx)
 
240
        tag_layout.set_font_description(font_desc)
 
241
 
 
242
        # The width of the tag label stack
 
243
        width = 0
 
244
 
 
245
        for tag_idx, tag in enumerate(self.tags):
 
246
            tag_layout.set_text(" " + tag + " ")
 
247
            text_width, text_height = tag_layout.get_pixel_size()
 
248
 
 
249
            x0 = cell_area.x + \
 
250
                 box_size * (column + 1.3) + width
 
251
 
 
252
            y0 = cell_area.y + \
 
253
                 cell_area.height / 2 - \
 
254
                 text_height / 2
 
255
 
 
256
            width += text_width + 5
 
257
 
 
258
            # Draw the tag border
 
259
            ctx.move_to(x0 - box_size / 3, y0 + text_height / 2)
 
260
            ctx.line_to(x0, y0)
 
261
            ctx.line_to(x0 + text_width, y0)
 
262
            ctx.line_to(x0 + text_width, y0 + text_height)
 
263
            ctx.line_to(x0, y0 + text_height)
 
264
            ctx.line_to(x0 - box_size / 3, y0 + text_height / 2)
 
265
 
 
266
            ctx.new_sub_path()
 
267
            ctx.arc(x0 - box_size / 12,
 
268
                        y0 + text_height / 2,
 
269
                        box_size / 7,
 
270
                        0, 2 * math.pi);
 
271
 
 
272
            self.set_colour(ctx, TAG_COLOUR_ID, 0.0, 0.5)
 
273
            ctx.stroke_preserve()
 
274
 
 
275
            ctx.set_fill_rule (cairo.FILL_RULE_EVEN_ODD)
 
276
            self.set_colour(ctx, TAG_COLOUR_ID, 0.5, 1.0)
 
277
            ctx.fill()
 
278
 
 
279
            # Draw the tag text
 
280
            self.set_colour(ctx, 0, 0.0, 0.0)
 
281
            ctx.move_to(x0, y0)
 
282
            ctx.show_layout(tag_layout)
 
283