/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: 2008-06-29 16:24:24 UTC
  • mto: This revision was merged to the branch mainline in revision 519.
  • Revision ID: jelmer@samba.org-20080629162424-48a6rrjmmpejfcyr
Stop emitting no longer used revisions-loaded message.

Show diffs side-by-side

added added

removed removed

Lines of Context:
branchview/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:
45
30
      in_lines          (start, end, colour) tuple list to draw inward lines,
46
31
      out_lines         (start, end, colour) tuple list to draw outward lines.
47
32
    """
48
 
 
 
33
    
49
34
    columns_len = 0
50
35
 
51
36
    __gproperties__ = {
52
 
        "node":         ( GObject.TYPE_PYOBJECT, "node",
 
37
        "node":         ( gobject.TYPE_PYOBJECT, "node",
53
38
                          "revision node instruction",
54
 
                          GObject.PARAM_WRITABLE
 
39
                          gobject.PARAM_WRITABLE
55
40
                        ),
56
 
        "tags":         ( GObject.TYPE_PYOBJECT, "tags",
 
41
        "tags":         ( gobject.TYPE_PYOBJECT, "tags",
57
42
                          "list of tags associated with the node",
58
 
                          GObject.PARAM_WRITABLE
 
43
                          gobject.PARAM_WRITABLE
59
44
                        ),
60
 
        "in-lines":     ( GObject.TYPE_PYOBJECT, "in-lines",
 
45
        "in-lines":     ( gobject.TYPE_PYOBJECT, "in-lines",
61
46
                          "instructions to draw lines into the cell",
62
 
                          GObject.PARAM_WRITABLE
 
47
                          gobject.PARAM_WRITABLE
63
48
                        ),
64
 
        "out-lines":    ( GObject.TYPE_PYOBJECT, "out-lines",
 
49
        "out-lines":    ( gobject.TYPE_PYOBJECT, "out-lines",
65
50
                          "instructions to draw lines out of the cell",
66
 
                          GObject.PARAM_WRITABLE
 
51
                          gobject.PARAM_WRITABLE
67
52
                        ),
68
53
        }
69
 
 
 
54
    
70
55
    def do_set_property(self, property, value):
71
56
        """Set properties from GObject properties."""
72
57
        if property.name == "node":
90
75
            return self._box_size
91
76
        except AttributeError:
92
77
            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())
 
78
            font_desc = widget.get_style().font_desc
 
79
            metrics = pango_ctx.get_metrics(font_desc)
 
80
 
 
81
            ascent = pango.PIXELS(metrics.get_ascent())
 
82
            descent = pango.PIXELS(metrics.get_descent())
 
83
 
98
84
            self._box_size = ascent + descent + 6
99
85
            return self._box_size
100
86
 
127
113
 
128
114
        ctx.set_source_rgb(red, green, blue)
129
115
 
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):
 
116
    def on_get_size(self, widget, cell_area):
139
117
        """Return the size we need for this cell.
140
118
 
141
119
        Each cell is drawn individually and is only as wide as it needs
150
128
        # FIXME I have no idea how to use cell_area properly
151
129
        return (0, 0, width, height)
152
130
 
153
 
    def do_render(self, ctx, widget, bg_area, cell_area, flags):
 
131
    def on_render(self, window, widget, bg_area, cell_area, exp_area, flags):
154
132
        """Render an individual cell.
155
133
 
156
134
        Draws the cell contents using cairo, taking care to clip what we
164
142
        instead of a pure diagonal ... this reduces confusion by an
165
143
        incredible amount.
166
144
        """
 
145
        ctx = window.cairo_create()
167
146
        ctx.rectangle(bg_area.x, bg_area.y, bg_area.width, bg_area.height)
168
147
        ctx.clip()
169
148
 
189
168
                cell_area.y + cell_area.height / 2,
190
169
                box_size / 4, 0, 2 * math.pi)
191
170
 
192
 
        if flags & Gtk.CellRendererState.SELECTED:
 
171
        if flags & gtk.CELL_RENDERER_SELECTED:
193
172
            ctx.set_source_rgb(1.0, 1.0, 1.0)
194
173
            ctx.set_line_width(box_size / 4)
195
174
            ctx.stroke_preserve()
202
181
        ctx.fill()
203
182
 
204
183
        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):
 
184
    
 
185
    def render_line(self, ctx, cell_area, box_size, mid, height, start, end, colour, flags):
208
186
        if start is None:
209
 
            ctx.set_line_cap(CAIRO_LINE_CAP_ROUND)
 
187
            ctx.set_line_cap(cairo.LINE_CAP_ROUND)
210
188
            x = cell_area.x + box_size * end + box_size / 2
211
189
            ctx.move_to(x, mid + height / 3)
212
190
            ctx.line_to(x, mid + height / 3)
213
191
            ctx.move_to(x, mid + height / 6)
214
192
            ctx.line_to(x, mid + height / 6)
215
 
 
 
193
            
216
194
        elif end is None:
217
 
            ctx.set_line_cap(CAIRO_LINE_CAP_ROUND)
 
195
            ctx.set_line_cap(cairo.LINE_CAP_ROUND)
218
196
            x = cell_area.x + box_size * start + box_size / 2
219
197
            ctx.move_to(x, mid - height / 3)
220
198
            ctx.line_to(x, mid - height / 3)
222
200
            ctx.line_to(x, mid - height / 6)
223
201
 
224
202
        else:
225
 
            ctx.set_line_cap(CAIRO_LINE_CAP_BUTT)
 
203
            ctx.set_line_cap(cairo.LINE_CAP_BUTT)
226
204
            startx = cell_area.x + box_size * start + box_size / 2
227
205
            endx = cell_area.x + box_size * end + box_size / 2
228
 
 
 
206
            
229
207
            ctx.move_to(startx, mid - height / 2)
230
 
 
 
208
            
231
209
            if start - end == 0 :
232
210
                ctx.line_to(endx, mid + height / 2 + 1)
233
211
            else:
239
217
                             endx, mid + height / 5 ,
240
218
                             endx, mid + height / 2 + 1)
241
219
 
242
 
        if flags & Gtk.CellRendererState.SELECTED:
 
220
        if flags & gtk.CELL_RENDERER_SELECTED:
243
221
            ctx.set_source_rgb(1.0, 1.0, 1.0)
244
222
            ctx.set_line_width(box_size / 5)
245
223
            ctx.stroke_preserve()
255
233
 
256
234
        (column, colour) = self.node
257
235
 
258
 
        font_desc = Pango.FontDescription()
259
 
        font_desc.set_size(Pango.SCALE * 7)
 
236
        font_desc = pango.FontDescription()
 
237
        font_desc.set_size(pango.SCALE * 7)
260
238
 
261
 
        tag_layout = Pango.Layout(pango_ctx)
 
239
        tag_layout = pango.Layout(pango_ctx)
262
240
        tag_layout.set_font_description(font_desc)
263
241
 
264
242
        # The width of the tag label stack
265
243
        width = 0
266
244
 
267
245
        for tag_idx, tag in enumerate(self.tags):
268
 
            tag_layout.set_text(" " + tag + " ", -1)
 
246
            tag_layout.set_text(" " + tag + " ")
269
247
            text_width, text_height = tag_layout.get_pixel_size()
270
248
 
271
249
            x0 = cell_area.x + \
294
272
            self.set_colour(ctx, TAG_COLOUR_ID, 0.0, 0.5)
295
273
            ctx.stroke_preserve()
296
274
 
297
 
            ctx.set_fill_rule (CAIRO_FILL_RULE_EVEN_ODD)
 
275
            ctx.set_fill_rule (cairo.FILL_RULE_EVEN_ODD)
298
276
            self.set_colour(ctx, TAG_COLOUR_ID, 0.5, 1.0)
299
277
            ctx.fill()
300
278
 
301
279
            # Draw the tag text
302
280
            self.set_colour(ctx, 0, 0.0, 0.0)
303
281
            ctx.move_to(x0, y0)
304
 
            PangoCairo.show_layout(ctx, tag_layout)
 
282
            ctx.show_layout(tag_layout)
 
283