/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

Commit messages never contain config options

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":
68
90
            return self._box_size
69
91
        except AttributeError:
70
92
            pango_ctx = widget.get_pango_context()
71
 
            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
 
 
 
93
            font_desc = widget.get_style_context().get_font(
 
94
                Gtk.StateType.NORMAL)
 
95
            metrics = pango_ctx.get_metrics(font_desc, None)
 
96
            ascent = PANGO_PIXELS(metrics.get_ascent())
 
97
            descent = PANGO_PIXELS(metrics.get_descent())
77
98
            self._box_size = ascent + descent + 6
78
99
            return self._box_size
79
100
 
85
106
        colours and the fg parameter provides the multiplier that should be
86
107
        applied to the foreground colours.
87
108
        """
 
109
        mainline_color = ( 0.0, 0.0, 0.0 )
88
110
        colours = [
89
111
            ( 1.0, 0.0, 0.0 ),
90
112
            ( 1.0, 1.0, 0.0 ),
94
116
            ( 1.0, 0.0, 1.0 ),
95
117
            ]
96
118
 
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
 
119
        if colour == 0:
 
120
            colour_rgb = mainline_color
 
121
        else:
 
122
            colour_rgb = colours[colour % len(colours)]
 
123
 
 
124
        red   = (colour_rgb[0] * fg) or bg
 
125
        green = (colour_rgb[1] * fg) or bg
 
126
        blue  = (colour_rgb[2] * fg) or bg
101
127
 
102
128
        ctx.set_source_rgb(red, green, blue)
103
129
 
104
 
    def on_get_size(self, widget, cell_area):
 
130
    def do_activate(event, widget, path, bg_area, cell_area, flags):
 
131
        """Renderers cannot be activated; always return True."""
 
132
        return True
 
133
 
 
134
    def do_editing_started(event, widget, path, fb_area, cell_area, flags):
 
135
        """Renderers cannot be edited; always return None."""
 
136
        return None
 
137
 
 
138
    def do_get_size(self, widget, cell_area):
105
139
        """Return the size we need for this cell.
106
140
 
107
141
        Each cell is drawn individually and is only as wide as it needs
108
142
        to be, we let the TreeViewColumn take care of making them all
109
143
        line up.
110
144
        """
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)
 
145
        box_size = self.box_size(widget) + 1
 
146
 
 
147
        width = box_size * (self.columns_len + 1)
118
148
        height = box_size
119
149
 
120
150
        # FIXME I have no idea how to use cell_area properly
121
151
        return (0, 0, width, height)
122
152
 
123
 
    def on_render(self, window, widget, bg_area, cell_area, exp_area, flags):
 
153
    def do_render(self, ctx, widget, bg_area, cell_area, flags):
124
154
        """Render an individual cell.
125
155
 
126
156
        Draws the cell contents using cairo, taking care to clip what we
134
164
        instead of a pure diagonal ... this reduces confusion by an
135
165
        incredible amount.
136
166
        """
137
 
        ctx = window.cairo_create()
138
167
        ctx.rectangle(bg_area.x, bg_area.y, bg_area.width, bg_area.height)
139
168
        ctx.clip()
140
169
 
141
170
        box_size = self.box_size(widget)
142
171
 
143
172
        ctx.set_line_width(box_size / 8)
144
 
        ctx.set_line_cap(cairo.LINE_CAP_SQUARE)
145
173
 
146
174
        # Draw lines into the cell
147
175
        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()
 
176
            self.render_line (ctx, cell_area, box_size,
 
177
                         bg_area.y, bg_area.height,
 
178
                         start, end, colour, flags)
164
179
 
165
180
        # Draw lines out of the cell
166
181
        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()
 
182
            self.render_line (ctx, cell_area, box_size,
 
183
                         bg_area.y + bg_area.height, bg_area.height,
 
184
                         start, end, colour, flags)
186
185
 
187
186
        # Draw the revision node in the right column
188
187
        (column, colour) = self.node
190
189
                cell_area.y + cell_area.height / 2,
191
190
                box_size / 4, 0, 2 * math.pi)
192
191
 
 
192
        if flags & Gtk.CellRendererState.SELECTED:
 
193
            ctx.set_source_rgb(1.0, 1.0, 1.0)
 
194
            ctx.set_line_width(box_size / 4)
 
195
            ctx.stroke_preserve()
 
196
            ctx.set_line_width(box_size / 8)
 
197
 
193
198
        self.set_colour(ctx, colour, 0.0, 0.5)
194
199
        ctx.stroke_preserve()
195
200
 
196
201
        self.set_colour(ctx, colour, 0.5, 1.0)
197
202
        ctx.fill()
 
203
 
 
204
        self.render_tags(ctx, widget.create_pango_context(), cell_area, box_size)
 
205
 
 
206
    def render_line(self, ctx, cell_area, box_size,
 
207
                    mid, height, start, end, colour, flags):
 
208
        if start is None:
 
209
            ctx.set_line_cap(CAIRO_LINE_CAP_ROUND)
 
210
            x = cell_area.x + box_size * end + box_size / 2
 
211
            ctx.move_to(x, mid + height / 3)
 
212
            ctx.line_to(x, mid + height / 3)
 
213
            ctx.move_to(x, mid + height / 6)
 
214
            ctx.line_to(x, mid + height / 6)
 
215
 
 
216
        elif end is None:
 
217
            ctx.set_line_cap(CAIRO_LINE_CAP_ROUND)
 
218
            x = cell_area.x + box_size * start + box_size / 2
 
219
            ctx.move_to(x, mid - height / 3)
 
220
            ctx.line_to(x, mid - height / 3)
 
221
            ctx.move_to(x, mid - height / 6)
 
222
            ctx.line_to(x, mid - height / 6)
 
223
 
 
224
        else:
 
225
            ctx.set_line_cap(CAIRO_LINE_CAP_BUTT)
 
226
            startx = cell_area.x + box_size * start + box_size / 2
 
227
            endx = cell_area.x + box_size * end + box_size / 2
 
228
 
 
229
            ctx.move_to(startx, mid - height / 2)
 
230
 
 
231
            if start - end == 0 :
 
232
                ctx.line_to(endx, mid + height / 2 + 1)
 
233
            else:
 
234
                ctx.curve_to(startx, mid - height / 5,
 
235
                             startx, mid - height / 5,
 
236
                             startx + (endx - startx) / 2, mid)
 
237
 
 
238
                ctx.curve_to(endx, mid + height / 5,
 
239
                             endx, mid + height / 5 ,
 
240
                             endx, mid + height / 2 + 1)
 
241
 
 
242
        if flags & Gtk.CellRendererState.SELECTED:
 
243
            ctx.set_source_rgb(1.0, 1.0, 1.0)
 
244
            ctx.set_line_width(box_size / 5)
 
245
            ctx.stroke_preserve()
 
246
            ctx.set_line_width(box_size / 8)
 
247
 
 
248
        self.set_colour(ctx, colour, 0.0, 0.65)
 
249
 
 
250
        ctx.stroke()
 
251
 
 
252
    def render_tags(self, ctx, pango_ctx, cell_area, box_size):
 
253
        # colour ID used in self.set_colour on the tags
 
254
        TAG_COLOUR_ID = 1
 
255
 
 
256
        (column, colour) = self.node
 
257
 
 
258
        font_desc = Pango.FontDescription()
 
259
        font_desc.set_size(Pango.SCALE * 7)
 
260
 
 
261
        tag_layout = Pango.Layout(pango_ctx)
 
262
        tag_layout.set_font_description(font_desc)
 
263
 
 
264
        # The width of the tag label stack
 
265
        width = 0
 
266
 
 
267
        for tag_idx, tag in enumerate(self.tags):
 
268
            tag_layout.set_text(" " + tag + " ", -1)
 
269
            text_width, text_height = tag_layout.get_pixel_size()
 
270
 
 
271
            x0 = cell_area.x + \
 
272
                 box_size * (column + 1.3) + width
 
273
 
 
274
            y0 = cell_area.y + \
 
275
                 cell_area.height / 2 - \
 
276
                 text_height / 2
 
277
 
 
278
            width += text_width + 5
 
279
 
 
280
            # Draw the tag border
 
281
            ctx.move_to(x0 - box_size / 3, y0 + text_height / 2)
 
282
            ctx.line_to(x0, y0)
 
283
            ctx.line_to(x0 + text_width, y0)
 
284
            ctx.line_to(x0 + text_width, y0 + text_height)
 
285
            ctx.line_to(x0, y0 + text_height)
 
286
            ctx.line_to(x0 - box_size / 3, y0 + text_height / 2)
 
287
 
 
288
            ctx.new_sub_path()
 
289
            ctx.arc(x0 - box_size / 12,
 
290
                        y0 + text_height / 2,
 
291
                        box_size / 7,
 
292
                        0, 2 * math.pi);
 
293
 
 
294
            self.set_colour(ctx, TAG_COLOUR_ID, 0.0, 0.5)
 
295
            ctx.stroke_preserve()
 
296
 
 
297
            ctx.set_fill_rule (CAIRO_FILL_RULE_EVEN_ODD)
 
298
            self.set_colour(ctx, TAG_COLOUR_ID, 0.5, 1.0)
 
299
            ctx.fill()
 
300
 
 
301
            # Draw the tag text
 
302
            self.set_colour(ctx, 0, 0.0, 0.0)
 
303
            ctx.move_to(x0, y0)
 
304
            PangoCairo.show_layout(ctx, tag_layout)