/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-09-30 10:21:43 UTC
  • Revision ID: jelmer@samba.org-20060930102143-c0ef64d6ca860c21
Merge some files from Olive and bzr-gtk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
viz/graphcell.py
10
10
just be for the background.
11
11
"""
12
12
 
13
 
__copyright__ = "Copyright © 2005-2011 Canonical Ltd."
 
13
__copyright__ = "Copyright © 2005 Canonical Ltd."
14
14
__author__    = "Scott James Remnant <scott@ubuntu.com>"
15
15
 
16
16
 
17
17
import math
18
18
 
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):
 
19
import gtk
 
20
import gobject
 
21
import pango
 
22
import cairo
 
23
 
 
24
 
 
25
class CellRendererGraph(gtk.GenericCellRenderer):
41
26
    """Cell renderer for directed graph.
42
27
 
43
28
    Properties:
46
31
      out_lines         (start, end, colour) tuple list to draw outward lines.
47
32
    """
48
33
 
49
 
    columns_len = 0
50
 
 
51
34
    __gproperties__ = {
52
 
        "node":         ( GObject.TYPE_PYOBJECT, "node",
 
35
        "node":         ( gobject.TYPE_PYOBJECT, "node",
53
36
                          "revision node instruction",
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",
 
37
                          gobject.PARAM_WRITABLE
 
38
                        ),
 
39
        "in-lines":     ( gobject.TYPE_PYOBJECT, "in-lines",
61
40
                          "instructions to draw lines into the cell",
62
 
                          GObject.PARAM_WRITABLE
 
41
                          gobject.PARAM_WRITABLE
63
42
                        ),
64
 
        "out-lines":    ( GObject.TYPE_PYOBJECT, "out-lines",
 
43
        "out-lines":    ( gobject.TYPE_PYOBJECT, "out-lines",
65
44
                          "instructions to draw lines out of the cell",
66
 
                          GObject.PARAM_WRITABLE
 
45
                          gobject.PARAM_WRITABLE
67
46
                        ),
68
47
        }
69
48
 
71
50
        """Set properties from GObject properties."""
72
51
        if property.name == "node":
73
52
            self.node = value
74
 
        elif property.name == "tags":
75
 
            self.tags = value
76
53
        elif property.name == "in-lines":
77
54
            self.in_lines = value
78
55
        elif property.name == "out-lines":
91
68
        except AttributeError:
92
69
            pango_ctx = widget.get_pango_context()
93
70
            font_desc = widget.get_style().font_desc
94
 
            metrics = pango_ctx.get_metrics(font_desc, None)
95
 
            ascent = PANGO_PIXELS(metrics.get_ascent())
96
 
            descent = PANGO_PIXELS(metrics.get_descent())
 
71
            metrics = pango_ctx.get_metrics(font_desc)
 
72
 
 
73
            ascent = pango.PIXELS(metrics.get_ascent())
 
74
            descent = pango.PIXELS(metrics.get_descent())
 
75
 
97
76
            self._box_size = ascent + descent + 6
98
77
            return self._box_size
99
78
 
105
84
        colours and the fg parameter provides the multiplier that should be
106
85
        applied to the foreground colours.
107
86
        """
108
 
        mainline_color = ( 0.0, 0.0, 0.0 )
109
87
        colours = [
110
88
            ( 1.0, 0.0, 0.0 ),
111
89
            ( 1.0, 1.0, 0.0 ),
115
93
            ( 1.0, 0.0, 1.0 ),
116
94
            ]
117
95
 
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
 
96
        colour %= len(colours)
 
97
        red   = (colours[colour][0] * fg) or bg
 
98
        green = (colours[colour][1] * fg) or bg
 
99
        blue  = (colours[colour][2] * fg) or bg
126
100
 
127
101
        ctx.set_source_rgb(red, green, blue)
128
102
 
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):
 
103
    def on_get_size(self, widget, cell_area):
138
104
        """Return the size we need for this cell.
139
105
 
140
106
        Each cell is drawn individually and is only as wide as it needs
141
107
        to be, we let the TreeViewColumn take care of making them all
142
108
        line up.
143
109
        """
144
 
        box_size = self.box_size(widget) + 1
145
 
 
146
 
        width = box_size * (self.columns_len + 1)
 
110
        box_size = self.box_size(widget)
 
111
 
 
112
        cols = self.node[0]
 
113
        for start, end, colour in self.in_lines + self.out_lines:
 
114
            cols = max(cols, start, end)
 
115
 
 
116
        width = box_size * (cols + 1)
147
117
        height = box_size
148
118
 
149
119
        # FIXME I have no idea how to use cell_area properly
150
120
        return (0, 0, width, height)
151
121
 
152
 
    def do_render(self, ctx, widget, bg_area, cell_area, flags):
 
122
    def on_render(self, window, widget, bg_area, cell_area, exp_area, flags):
153
123
        """Render an individual cell.
154
124
 
155
125
        Draws the cell contents using cairo, taking care to clip what we
163
133
        instead of a pure diagonal ... this reduces confusion by an
164
134
        incredible amount.
165
135
        """
 
136
        ctx = window.cairo_create()
166
137
        ctx.rectangle(bg_area.x, bg_area.y, bg_area.width, bg_area.height)
167
138
        ctx.clip()
168
139
 
169
140
        box_size = self.box_size(widget)
170
141
 
171
142
        ctx.set_line_width(box_size / 8)
 
143
        ctx.set_line_cap(cairo.LINE_CAP_SQUARE)
172
144
 
173
145
        # Draw lines into the cell
174
146
        for start, end, colour in self.in_lines:
175
 
            self.render_line (ctx, cell_area, box_size,
176
 
                         bg_area.y, bg_area.height,
177
 
                         start, end, colour, flags)
 
147
            ctx.move_to(cell_area.x + box_size * start + box_size / 2,
 
148
                        bg_area.y - bg_area.height / 2)
 
149
 
 
150
            if start - end > 1:
 
151
                ctx.line_to(cell_area.x + box_size * start, bg_area.y)
 
152
                ctx.line_to(cell_area.x + box_size * end + box_size, bg_area.y)
 
153
            elif start - end < -1:
 
154
                ctx.line_to(cell_area.x + box_size * start + box_size,
 
155
                            bg_area.y)
 
156
                ctx.line_to(cell_area.x + box_size * end, bg_area.y)
 
157
 
 
158
            ctx.line_to(cell_area.x + box_size * end + box_size / 2,
 
159
                        bg_area.y + bg_area.height / 2)
 
160
 
 
161
            self.set_colour(ctx, colour, 0.0, 0.65)
 
162
            ctx.stroke()
178
163
 
179
164
        # Draw lines out of the cell
180
165
        for start, end, colour in self.out_lines:
181
 
            self.render_line (ctx, cell_area, box_size,
182
 
                         bg_area.y + bg_area.height, bg_area.height,
183
 
                         start, end, colour, flags)
 
166
            ctx.move_to(cell_area.x + box_size * start + box_size / 2,
 
167
                        bg_area.y + bg_area.height / 2)
 
168
 
 
169
            if start - end > 1:
 
170
                ctx.line_to(cell_area.x + box_size * start,
 
171
                            bg_area.y + bg_area.height)
 
172
                ctx.line_to(cell_area.x + box_size * end + box_size,
 
173
                            bg_area.y + bg_area.height)
 
174
            elif start - end < -1:
 
175
                ctx.line_to(cell_area.x + box_size * start + box_size,
 
176
                            bg_area.y + bg_area.height)
 
177
                ctx.line_to(cell_area.x + box_size * end,
 
178
                            bg_area.y + bg_area.height)
 
179
 
 
180
            ctx.line_to(cell_area.x + box_size * end + box_size / 2,
 
181
                        bg_area.y + bg_area.height / 2 + bg_area.height)
 
182
 
 
183
            self.set_colour(ctx, colour, 0.0, 0.65)
 
184
            ctx.stroke()
184
185
 
185
186
        # Draw the revision node in the right column
186
187
        (column, colour) = self.node
188
189
                cell_area.y + cell_area.height / 2,
189
190
                box_size / 4, 0, 2 * math.pi)
190
191
 
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
 
 
197
192
        self.set_colour(ctx, colour, 0.0, 0.5)
198
193
        ctx.stroke_preserve()
199
194
 
200
195
        self.set_colour(ctx, colour, 0.5, 1.0)
201
196
        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)