/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: matkor
  • Date: 2007-08-23 10:17:40 UTC
  • mto: This revision was merged to the branch mainline in revision 265.
  • Revision ID: matkor@laptop-hp-20070823101740-s17kf9qa383wiuje
Code for "branch update" menuitem and toolbox. Typo fix

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":
90
67
            return self._box_size
91
68
        except AttributeError:
92
69
            pango_ctx = widget.get_pango_context()
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())
 
70
            font_desc = widget.get_style().font_desc
 
71
            metrics = pango_ctx.get_metrics(font_desc)
 
72
 
 
73
            ascent = pango.PIXELS(metrics.get_ascent())
 
74
            descent = pango.PIXELS(metrics.get_descent())
 
75
 
98
76
            self._box_size = ascent + descent + 6
99
77
            return self._box_size
100
78
 
106
84
        colours and the fg parameter provides the multiplier that should be
107
85
        applied to the foreground colours.
108
86
        """
109
 
        mainline_color = ( 0.0, 0.0, 0.0 )
110
87
        colours = [
111
88
            ( 1.0, 0.0, 0.0 ),
112
89
            ( 1.0, 1.0, 0.0 ),
116
93
            ( 1.0, 0.0, 1.0 ),
117
94
            ]
118
95
 
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
 
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
127
100
 
128
101
        ctx.set_source_rgb(red, green, blue)
129
102
 
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):
 
103
    def on_get_size(self, widget, cell_area):
139
104
        """Return the size we need for this cell.
140
105
 
141
106
        Each cell is drawn individually and is only as wide as it needs
144
109
        """
145
110
        box_size = self.box_size(widget) + 1
146
111
 
147
 
        width = box_size * (self.columns_len + 1)
 
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)
148
117
        height = box_size
149
118
 
150
119
        # FIXME I have no idea how to use cell_area properly
151
120
        return (0, 0, width, height)
152
121
 
153
 
    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):
154
123
        """Render an individual cell.
155
124
 
156
125
        Draws the cell contents using cairo, taking care to clip what we
164
133
        instead of a pure diagonal ... this reduces confusion by an
165
134
        incredible amount.
166
135
        """
 
136
        ctx = window.cairo_create()
167
137
        ctx.rectangle(bg_area.x, bg_area.y, bg_area.width, bg_area.height)
168
138
        ctx.clip()
169
139
 
170
140
        box_size = self.box_size(widget)
171
141
 
172
142
        ctx.set_line_width(box_size / 8)
 
143
        ctx.set_line_cap(cairo.LINE_CAP_SQUARE)
173
144
 
174
145
        # Draw lines into the cell
175
146
        for start, end, colour in self.in_lines:
176
 
            self.render_line (ctx, cell_area, box_size,
177
 
                         bg_area.y, bg_area.height,
178
 
                         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()
179
163
 
180
164
        # Draw lines out of the cell
181
165
        for start, end, colour in self.out_lines:
182
 
            self.render_line (ctx, cell_area, box_size,
183
 
                         bg_area.y + bg_area.height, bg_area.height,
184
 
                         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()
185
185
 
186
186
        # Draw the revision node in the right column
187
187
        (column, colour) = self.node
189
189
                cell_area.y + cell_area.height / 2,
190
190
                box_size / 4, 0, 2 * math.pi)
191
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
 
 
198
192
        self.set_colour(ctx, colour, 0.0, 0.5)
199
193
        ctx.stroke_preserve()
200
194
 
201
195
        self.set_colour(ctx, colour, 0.5, 1.0)
202
196
        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)