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

  • Committer: Jelmer Vernooij
  • Date: 2006-05-19 16:56:46 UTC
  • mfrom: (0.1.25 gannotate)
  • Revision ID: jelmer@samba.org-20060519165646-0d867938fdbc9097
Merge in Dan Loda's gannotate plugin and put it in annotate/

Show diffs side-by-side

added added

removed removed

Lines of Context:
viz/graphcell.py
 
1
#!/usr/bin/python
1
2
# -*- coding: UTF-8 -*-
2
3
"""Cell renderer for directed graph.
3
4
 
16
17
 
17
18
import math
18
19
 
19
 
from gi.repository import Gtk
20
 
from gi.repository import GObject
21
 
from gi.repository import Pango
 
20
import gtk
 
21
import gobject
 
22
import pango
22
23
import cairo
23
24
 
24
25
 
25
 
class CellRendererGraph(Gtk.GenericCellRenderer):
 
26
class CellRendererGraph(gtk.GenericCellRenderer):
26
27
    """Cell renderer for directed graph.
27
28
 
28
29
    Properties:
31
32
      out_lines         (start, end, colour) tuple list to draw outward lines.
32
33
    """
33
34
 
34
 
    columns_len = 0
35
 
 
36
35
    __gproperties__ = {
37
 
        "node":         ( GObject.TYPE_PYOBJECT, "node",
 
36
        "node":         ( gobject.TYPE_PYOBJECT, "node",
38
37
                          "revision node instruction",
39
 
                          GObject.PARAM_WRITABLE
40
 
                        ),
41
 
        "tags":         ( GObject.TYPE_PYOBJECT, "tags",
42
 
                          "list of tags associated with the node",
43
 
                          GObject.PARAM_WRITABLE
44
 
                        ),
45
 
        "in-lines":     ( GObject.TYPE_PYOBJECT, "in-lines",
 
38
                          gobject.PARAM_WRITABLE
 
39
                        ),
 
40
        "in-lines":     ( gobject.TYPE_PYOBJECT, "in-lines",
46
41
                          "instructions to draw lines into the cell",
47
 
                          GObject.PARAM_WRITABLE
 
42
                          gobject.PARAM_WRITABLE
48
43
                        ),
49
 
        "out-lines":    ( GObject.TYPE_PYOBJECT, "out-lines",
 
44
        "out-lines":    ( gobject.TYPE_PYOBJECT, "out-lines",
50
45
                          "instructions to draw lines out of the cell",
51
 
                          GObject.PARAM_WRITABLE
 
46
                          gobject.PARAM_WRITABLE
52
47
                        ),
53
48
        }
54
49
 
56
51
        """Set properties from GObject properties."""
57
52
        if property.name == "node":
58
53
            self.node = value
59
 
        elif property.name == "tags":
60
 
            self.tags = value
61
54
        elif property.name == "in-lines":
62
55
            self.in_lines = value
63
56
        elif property.name == "out-lines":
78
71
            font_desc = widget.get_style().font_desc
79
72
            metrics = pango_ctx.get_metrics(font_desc)
80
73
 
81
 
            ascent = Pango.PIXELS(metrics.get_ascent())
82
 
            descent = Pango.PIXELS(metrics.get_descent())
 
74
            ascent = pango.PIXELS(metrics.get_ascent())
 
75
            descent = pango.PIXELS(metrics.get_descent())
83
76
 
84
77
            self._box_size = ascent + descent + 6
85
78
            return self._box_size
92
85
        colours and the fg parameter provides the multiplier that should be
93
86
        applied to the foreground colours.
94
87
        """
95
 
        mainline_color = ( 0.0, 0.0, 0.0 )
96
88
        colours = [
97
89
            ( 1.0, 0.0, 0.0 ),
98
90
            ( 1.0, 1.0, 0.0 ),
102
94
            ( 1.0, 0.0, 1.0 ),
103
95
            ]
104
96
 
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
 
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
113
101
 
114
102
        ctx.set_source_rgb(red, green, blue)
115
103
 
120
108
        to be, we let the TreeViewColumn take care of making them all
121
109
        line up.
122
110
        """
123
 
        box_size = self.box_size(widget) + 1
124
 
 
125
 
        width = box_size * (self.columns_len + 1)
 
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)
126
118
        height = box_size
127
119
 
128
120
        # FIXME I have no idea how to use cell_area properly
149
141
        box_size = self.box_size(widget)
150
142
 
151
143
        ctx.set_line_width(box_size / 8)
 
144
        ctx.set_line_cap(cairo.LINE_CAP_SQUARE)
152
145
 
153
146
        # Draw lines into the cell
154
147
        for start, end, colour in self.in_lines:
155
 
            self.render_line (ctx, cell_area, box_size,
156
 
                         bg_area.y, bg_area.height,
157
 
                         start, end, colour, flags)
 
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()
158
164
 
159
165
        # Draw lines out of the cell
160
166
        for start, end, colour in self.out_lines:
161
 
            self.render_line (ctx, cell_area, box_size,
162
 
                         bg_area.y + bg_area.height, bg_area.height,
163
 
                         start, end, colour, flags)
 
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()
164
186
 
165
187
        # Draw the revision node in the right column
166
188
        (column, colour) = self.node
168
190
                cell_area.y + cell_area.height / 2,
169
191
                box_size / 4, 0, 2 * math.pi)
170
192
 
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
 
 
177
193
        self.set_colour(ctx, colour, 0.0, 0.5)
178
194
        ctx.stroke_preserve()
179
195
 
180
196
        self.set_colour(ctx, colour, 0.5, 1.0)
181
197
        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