/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: Jelmer Vernooij
  • Date: 2012-07-09 15:23:26 UTC
  • mto: This revision was merged to the branch mainline in revision 794.
  • Revision ID: jelmer@samba.org-20120709152326-dzxb8zoz0btull7n
https://launchpad.net/bugs/714767
https://launchpad.net/bugs/949798
https://launchpad.net/bugs/998994
https://launchpad.net/bugs/342135
https://launchpad.net/bugs/342136
https://launchpad.net/bugs/394536
Remove bzr-notify.

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
 
11
10
just be for the background.
12
11
"""
13
12
 
14
 
__copyright__ = "Copyright © 2005 Canonical Ltd."
 
13
__copyright__ = "Copyright © 2005-2011 Canonical Ltd."
15
14
__author__    = "Scott James Remnant <scott@ubuntu.com>"
16
15
 
17
16
 
18
17
import math
19
18
 
20
 
import gtk
21
 
import gobject
22
 
import pango
23
 
import cairo
24
 
 
25
 
 
26
 
class CellRendererGraph(gtk.GenericCellRenderer):
 
19
from gi.repository import Gtk
 
20
from gi.repository import GObject
 
21
from gi.repository import Pango
 
22
from gi.repository import PangoCairo
 
23
 
 
24
 
 
25
# Cairo constants are not exported yet. These are taken from documentation.
 
26
CAIRO_LINE_CAP_BUTT = 0
 
27
CAIRO_LINE_CAP_ROUND = 1
 
28
CAIRO_LINE_CAP_SQUARE = 2
 
29
 
 
30
 
 
31
CAIRO_FILL_RULE_WINDING = 0
 
32
CAIRO_FILL_RULE_EVEN_ODD = 1
 
33
 
 
34
 
 
35
# Macro from  Pango header.
 
36
def PANGO_PIXELS(d):
 
37
    return (d + 512) / 1000
 
38
 
 
39
 
 
40
class CellRendererGraph(Gtk.CellRendererPixbuf):
27
41
    """Cell renderer for directed graph.
28
42
 
29
43
    Properties:
32
46
      out_lines         (start, end, colour) tuple list to draw outward lines.
33
47
    """
34
48
 
 
49
    columns_len = 0
 
50
 
35
51
    __gproperties__ = {
36
 
        "node":         ( gobject.TYPE_PYOBJECT, "node",
 
52
        "node":         ( GObject.TYPE_PYOBJECT, "node",
37
53
                          "revision node instruction",
38
 
                          gobject.PARAM_WRITABLE
39
 
                        ),
40
 
        "in-lines":     ( gobject.TYPE_PYOBJECT, "in-lines",
 
54
                          GObject.PARAM_WRITABLE
 
55
                        ),
 
56
        "tags":         ( GObject.TYPE_PYOBJECT, "tags",
 
57
                          "list of tags associated with the node",
 
58
                          GObject.PARAM_WRITABLE
 
59
                        ),
 
60
        "in-lines":     ( GObject.TYPE_PYOBJECT, "in-lines",
41
61
                          "instructions to draw lines into the cell",
42
 
                          gobject.PARAM_WRITABLE
 
62
                          GObject.PARAM_WRITABLE
43
63
                        ),
44
 
        "out-lines":    ( gobject.TYPE_PYOBJECT, "out-lines",
 
64
        "out-lines":    ( GObject.TYPE_PYOBJECT, "out-lines",
45
65
                          "instructions to draw lines out of the cell",
46
 
                          gobject.PARAM_WRITABLE
 
66
                          GObject.PARAM_WRITABLE
47
67
                        ),
48
68
        }
49
69
 
51
71
        """Set properties from GObject properties."""
52
72
        if property.name == "node":
53
73
            self.node = value
 
74
        elif property.name == "tags":
 
75
            self.tags = value
54
76
        elif property.name == "in-lines":
55
77
            self.in_lines = value
56
78
        elif property.name == "out-lines":
69
91
        except AttributeError:
70
92
            pango_ctx = widget.get_pango_context()
71
93
            font_desc = widget.get_style().font_desc
72
 
            metrics = pango_ctx.get_metrics(font_desc)
73
 
 
74
 
            ascent = pango.PIXELS(metrics.get_ascent())
75
 
            descent = pango.PIXELS(metrics.get_descent())
76
 
 
 
94
            metrics = pango_ctx.get_metrics(font_desc, None)
 
95
            ascent = PANGO_PIXELS(metrics.get_ascent())
 
96
            descent = PANGO_PIXELS(metrics.get_descent())
77
97
            self._box_size = ascent + descent + 6
78
98
            return self._box_size
79
99
 
85
105
        colours and the fg parameter provides the multiplier that should be
86
106
        applied to the foreground colours.
87
107
        """
 
108
        mainline_color = ( 0.0, 0.0, 0.0 )
88
109
        colours = [
89
110
            ( 1.0, 0.0, 0.0 ),
90
111
            ( 1.0, 1.0, 0.0 ),
94
115
            ( 1.0, 0.0, 1.0 ),
95
116
            ]
96
117
 
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
 
118
        if colour == 0:
 
119
            colour_rgb = mainline_color
 
120
        else:
 
121
            colour_rgb = colours[colour % len(colours)]
 
122
 
 
123
        red   = (colour_rgb[0] * fg) or bg
 
124
        green = (colour_rgb[1] * fg) or bg
 
125
        blue  = (colour_rgb[2] * fg) or bg
101
126
 
102
127
        ctx.set_source_rgb(red, green, blue)
103
128
 
104
 
    def on_get_size(self, widget, cell_area):
 
129
    def do_activate(event, widget, path, bg_area, cell_area, flags):
 
130
        """Renderers cannot be activated; always return True."""
 
131
        return True
 
132
 
 
133
    def do_editing_started(event, widget, path, fb_area, cell_area, flags):
 
134
        """Renderers cannot be edited; always return None."""
 
135
        return None
 
136
 
 
137
    def do_get_size(self, widget, cell_area):
105
138
        """Return the size we need for this cell.
106
139
 
107
140
        Each cell is drawn individually and is only as wide as it needs
108
141
        to be, we let the TreeViewColumn take care of making them all
109
142
        line up.
110
143
        """
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)
 
144
        box_size = self.box_size(widget) + 1
 
145
 
 
146
        width = box_size * (self.columns_len + 1)
118
147
        height = box_size
119
148
 
120
149
        # FIXME I have no idea how to use cell_area properly
121
150
        return (0, 0, width, height)
122
151
 
123
 
    def on_render(self, window, widget, bg_area, cell_area, exp_area, flags):
 
152
    def do_render(self, ctx, widget, bg_area, cell_area, flags):
124
153
        """Render an individual cell.
125
154
 
126
155
        Draws the cell contents using cairo, taking care to clip what we
134
163
        instead of a pure diagonal ... this reduces confusion by an
135
164
        incredible amount.
136
165
        """
137
 
        ctx = window.cairo_create()
138
166
        ctx.rectangle(bg_area.x, bg_area.y, bg_area.width, bg_area.height)
139
167
        ctx.clip()
140
168
 
141
169
        box_size = self.box_size(widget)
142
170
 
143
171
        ctx.set_line_width(box_size / 8)
144
 
        ctx.set_line_cap(cairo.LINE_CAP_SQUARE)
145
172
 
146
173
        # Draw lines into the cell
147
174
        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()
 
175
            self.render_line (ctx, cell_area, box_size,
 
176
                         bg_area.y, bg_area.height,
 
177
                         start, end, colour, flags)
164
178
 
165
179
        # Draw lines out of the cell
166
180
        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()
 
181
            self.render_line (ctx, cell_area, box_size,
 
182
                         bg_area.y + bg_area.height, bg_area.height,
 
183
                         start, end, colour, flags)
186
184
 
187
185
        # Draw the revision node in the right column
188
186
        (column, colour) = self.node
190
188
                cell_area.y + cell_area.height / 2,
191
189
                box_size / 4, 0, 2 * math.pi)
192
190
 
 
191
        if flags & Gtk.CellRendererState.SELECTED:
 
192
            ctx.set_source_rgb(1.0, 1.0, 1.0)
 
193
            ctx.set_line_width(box_size / 4)
 
194
            ctx.stroke_preserve()
 
195
            ctx.set_line_width(box_size / 8)
 
196
 
193
197
        self.set_colour(ctx, colour, 0.0, 0.5)
194
198
        ctx.stroke_preserve()
195
199
 
196
200
        self.set_colour(ctx, colour, 0.5, 1.0)
197
201
        ctx.fill()
 
202
 
 
203
        self.render_tags(ctx, widget.create_pango_context(), cell_area, box_size)
 
204
 
 
205
    def render_line(self, ctx, cell_area, box_size,
 
206
                    mid, height, start, end, colour, flags):
 
207
        if start is None:
 
208
            ctx.set_line_cap(CAIRO_LINE_CAP_ROUND)
 
209
            x = cell_area.x + box_size * end + box_size / 2
 
210
            ctx.move_to(x, mid + height / 3)
 
211
            ctx.line_to(x, mid + height / 3)
 
212
            ctx.move_to(x, mid + height / 6)
 
213
            ctx.line_to(x, mid + height / 6)
 
214
 
 
215
        elif end is None:
 
216
            ctx.set_line_cap(CAIRO_LINE_CAP_ROUND)
 
217
            x = cell_area.x + box_size * start + box_size / 2
 
218
            ctx.move_to(x, mid - height / 3)
 
219
            ctx.line_to(x, mid - height / 3)
 
220
            ctx.move_to(x, mid - height / 6)
 
221
            ctx.line_to(x, mid - height / 6)
 
222
 
 
223
        else:
 
224
            ctx.set_line_cap(CAIRO_LINE_CAP_BUTT)
 
225
            startx = cell_area.x + box_size * start + box_size / 2
 
226
            endx = cell_area.x + box_size * end + box_size / 2
 
227
 
 
228
            ctx.move_to(startx, mid - height / 2)
 
229
 
 
230
            if start - end == 0 :
 
231
                ctx.line_to(endx, mid + height / 2 + 1)
 
232
            else:
 
233
                ctx.curve_to(startx, mid - height / 5,
 
234
                             startx, mid - height / 5,
 
235
                             startx + (endx - startx) / 2, mid)
 
236
 
 
237
                ctx.curve_to(endx, mid + height / 5,
 
238
                             endx, mid + height / 5 ,
 
239
                             endx, mid + height / 2 + 1)
 
240
 
 
241
        if flags & Gtk.CellRendererState.SELECTED:
 
242
            ctx.set_source_rgb(1.0, 1.0, 1.0)
 
243
            ctx.set_line_width(box_size / 5)
 
244
            ctx.stroke_preserve()
 
245
            ctx.set_line_width(box_size / 8)
 
246
 
 
247
        self.set_colour(ctx, colour, 0.0, 0.65)
 
248
 
 
249
        ctx.stroke()
 
250
 
 
251
    def render_tags(self, ctx, pango_ctx, cell_area, box_size):
 
252
        # colour ID used in self.set_colour on the tags
 
253
        TAG_COLOUR_ID = 1
 
254
 
 
255
        (column, colour) = self.node
 
256
 
 
257
        font_desc = Pango.FontDescription()
 
258
        font_desc.set_size(Pango.SCALE * 7)
 
259
 
 
260
        tag_layout = Pango.Layout(pango_ctx)
 
261
        tag_layout.set_font_description(font_desc)
 
262
 
 
263
        # The width of the tag label stack
 
264
        width = 0
 
265
 
 
266
        for tag_idx, tag in enumerate(self.tags):
 
267
            tag_layout.set_text(" " + tag + " ", -1)
 
268
            text_width, text_height = tag_layout.get_pixel_size()
 
269
 
 
270
            x0 = cell_area.x + \
 
271
                 box_size * (column + 1.3) + width
 
272
 
 
273
            y0 = cell_area.y + \
 
274
                 cell_area.height / 2 - \
 
275
                 text_height / 2
 
276
 
 
277
            width += text_width + 5
 
278
 
 
279
            # Draw the tag border
 
280
            ctx.move_to(x0 - box_size / 3, y0 + text_height / 2)
 
281
            ctx.line_to(x0, y0)
 
282
            ctx.line_to(x0 + text_width, y0)
 
283
            ctx.line_to(x0 + text_width, y0 + text_height)
 
284
            ctx.line_to(x0, y0 + text_height)
 
285
            ctx.line_to(x0 - box_size / 3, y0 + text_height / 2)
 
286
 
 
287
            ctx.new_sub_path()
 
288
            ctx.arc(x0 - box_size / 12,
 
289
                        y0 + text_height / 2,
 
290
                        box_size / 7,
 
291
                        0, 2 * math.pi);
 
292
 
 
293
            self.set_colour(ctx, TAG_COLOUR_ID, 0.0, 0.5)
 
294
            ctx.stroke_preserve()
 
295
 
 
296
            ctx.set_fill_rule (CAIRO_FILL_RULE_EVEN_ODD)
 
297
            self.set_colour(ctx, TAG_COLOUR_ID, 0.5, 1.0)
 
298
            ctx.fill()
 
299
 
 
300
            # Draw the tag text
 
301
            self.set_colour(ctx, 0, 0.0, 0.0)
 
302
            ctx.move_to(x0, y0)
 
303
            PangoCairo.show_layout(ctx, tag_layout)