/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: Curtis Hovey
  • Date: 2011-09-04 03:53:20 UTC
  • mfrom: (738 trunk)
  • mto: This revision was merged to the branch mainline in revision 741.
  • Revision ID: sinzui.is@verizon.net-20110904035320-5abg7as2ki1r8w88
Merged trunk

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 Canonical Ltd."
 
13
__copyright__ = "Copyright © 2005-2011 Canonical Ltd."
14
14
__author__    = "Scott James Remnant <scott@ubuntu.com>"
15
15
 
16
16
 
17
17
import math
18
18
 
19
 
import gtk
20
 
import gobject
21
 
import pango
22
 
import cairo
23
 
 
24
 
 
25
 
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
from gi.repository import cairo
 
24
 
 
25
 
 
26
# Cairo constants are not exported yet. These are taken from documentation.
 
27
CAIRO_LINE_CAP_BUTT = 0
 
28
CAIRO_LINE_CAP_ROUND = 1
 
29
CAIRO_LINE_CAP_SQUARE = 2
 
30
 
 
31
 
 
32
CAIRO_FILL_RULE_WINDING = 0
 
33
CAIRO_FILL_RULE_EVEN_ODD = 1
 
34
 
 
35
 
 
36
class CellRendererGraph(Gtk.CellRendererPixbuf):
26
37
    """Cell renderer for directed graph.
27
38
 
28
39
    Properties:
30
41
      in_lines          (start, end, colour) tuple list to draw inward lines,
31
42
      out_lines         (start, end, colour) tuple list to draw outward lines.
32
43
    """
33
 
    
 
44
 
34
45
    columns_len = 0
35
46
 
36
47
    __gproperties__ = {
37
 
        "node":         ( gobject.TYPE_PYOBJECT, "node",
 
48
        "node":         ( GObject.TYPE_PYOBJECT, "node",
38
49
                          "revision node instruction",
39
 
                          gobject.PARAM_WRITABLE
 
50
                          GObject.PARAM_WRITABLE
40
51
                        ),
41
 
        "tags":         ( gobject.TYPE_PYOBJECT, "tags",
 
52
        "tags":         ( GObject.TYPE_PYOBJECT, "tags",
42
53
                          "list of tags associated with the node",
43
 
                          gobject.PARAM_WRITABLE
 
54
                          GObject.PARAM_WRITABLE
44
55
                        ),
45
 
        "in-lines":     ( gobject.TYPE_PYOBJECT, "in-lines",
 
56
        "in-lines":     ( GObject.TYPE_PYOBJECT, "in-lines",
46
57
                          "instructions to draw lines into the cell",
47
 
                          gobject.PARAM_WRITABLE
 
58
                          GObject.PARAM_WRITABLE
48
59
                        ),
49
 
        "out-lines":    ( gobject.TYPE_PYOBJECT, "out-lines",
 
60
        "out-lines":    ( GObject.TYPE_PYOBJECT, "out-lines",
50
61
                          "instructions to draw lines out of the cell",
51
 
                          gobject.PARAM_WRITABLE
 
62
                          GObject.PARAM_WRITABLE
52
63
                        ),
53
64
        }
54
 
    
 
65
 
55
66
    def do_set_property(self, property, value):
56
67
        """Set properties from GObject properties."""
57
68
        if property.name == "node":
65
76
        else:
66
77
            raise AttributeError, "no such property: '%s'" % property.name
67
78
 
 
79
    def do_get_property(self, property):
 
80
        """Get properties from GObject properties."""
 
81
        if property.name == "node":
 
82
            return self.node
 
83
        elif property.name == "tags":
 
84
            return self.tags
 
85
        elif property.name == "in-lines":
 
86
            return self.in_lines
 
87
        elif property.name == "out-lines":
 
88
            print "get outlines"
 
89
            return self.out_lines
 
90
        else:
 
91
            raise AttributeError, "no such property: '%s'" % property.name
 
92
 
68
93
    def box_size(self, widget):
69
94
        """Calculate box size based on widget's font.
70
95
 
76
101
        except AttributeError:
77
102
            pango_ctx = widget.get_pango_context()
78
103
            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())
 
104
            metrics = pango_ctx.get_metrics(font_desc, None)
 
105
 
 
106
            def PANGO_PIXELS(d):
 
107
                # Macro from  Pango header.
 
108
                return (d + 512) / 1000
 
109
 
 
110
            ascent = PANGO_PIXELS(metrics.get_ascent())
 
111
            descent = PANGO_PIXELS(metrics.get_descent())
83
112
 
84
113
            self._box_size = ascent + descent + 6
85
114
            return self._box_size
113
142
 
114
143
        ctx.set_source_rgb(red, green, blue)
115
144
 
116
 
    def on_get_size(self, widget, cell_area):
 
145
    def do_activate(event, widget, path, bg_area, cell_area, flags):
 
146
        return True
 
147
 
 
148
    def do_editing_started(event, widget, path, fb_area, cell_area, flags):
 
149
        return None
 
150
 
 
151
    def do_get_size(self, widget, cell_area):
117
152
        """Return the size we need for this cell.
118
153
 
119
154
        Each cell is drawn individually and is only as wide as it needs
128
163
        # FIXME I have no idea how to use cell_area properly
129
164
        return (0, 0, width, height)
130
165
 
131
 
    def on_render(self, window, widget, bg_area, cell_area, exp_area, flags):
 
166
    def do_render(self, ctx, widget, bg_area, cell_area, flags):
132
167
        """Render an individual cell.
133
168
 
134
169
        Draws the cell contents using cairo, taking care to clip what we
142
177
        instead of a pure diagonal ... this reduces confusion by an
143
178
        incredible amount.
144
179
        """
145
 
        ctx = window.cairo_create()
146
180
        ctx.rectangle(bg_area.x, bg_area.y, bg_area.width, bg_area.height)
147
181
        ctx.clip()
148
182
 
168
202
                cell_area.y + cell_area.height / 2,
169
203
                box_size / 4, 0, 2 * math.pi)
170
204
 
171
 
        if flags & gtk.CELL_RENDERER_SELECTED:
 
205
        if flags & Gtk.CellRendererState.SELECTED:
172
206
            ctx.set_source_rgb(1.0, 1.0, 1.0)
173
207
            ctx.set_line_width(box_size / 4)
174
208
            ctx.stroke_preserve()
181
215
        ctx.fill()
182
216
 
183
217
        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):
 
218
 
 
219
    def render_line(self, ctx, cell_area, box_size,
 
220
                    mid, height, start, end, colour, flags):
186
221
        if start is None:
187
 
            ctx.set_line_cap(cairo.LINE_CAP_ROUND)
 
222
            ctx.set_line_cap(CAIRO_LINE_CAP_ROUND)
188
223
            x = cell_area.x + box_size * end + box_size / 2
189
224
            ctx.move_to(x, mid + height / 3)
190
225
            ctx.line_to(x, mid + height / 3)
191
226
            ctx.move_to(x, mid + height / 6)
192
227
            ctx.line_to(x, mid + height / 6)
193
 
            
 
228
 
194
229
        elif end is None:
195
 
            ctx.set_line_cap(cairo.LINE_CAP_ROUND)
 
230
            ctx.set_line_cap(CAIRO_LINE_CAP_ROUND)
196
231
            x = cell_area.x + box_size * start + box_size / 2
197
232
            ctx.move_to(x, mid - height / 3)
198
233
            ctx.line_to(x, mid - height / 3)
200
235
            ctx.line_to(x, mid - height / 6)
201
236
 
202
237
        else:
203
 
            ctx.set_line_cap(cairo.LINE_CAP_BUTT)
 
238
            ctx.set_line_cap(CAIRO_LINE_CAP_BUTT)
204
239
            startx = cell_area.x + box_size * start + box_size / 2
205
240
            endx = cell_area.x + box_size * end + box_size / 2
206
 
            
 
241
 
207
242
            ctx.move_to(startx, mid - height / 2)
208
 
            
 
243
 
209
244
            if start - end == 0 :
210
245
                ctx.line_to(endx, mid + height / 2 + 1)
211
246
            else:
217
252
                             endx, mid + height / 5 ,
218
253
                             endx, mid + height / 2 + 1)
219
254
 
220
 
        if flags & gtk.CELL_RENDERER_SELECTED:
 
255
        if flags & Gtk.CellRendererState.SELECTED:
221
256
            ctx.set_source_rgb(1.0, 1.0, 1.0)
222
257
            ctx.set_line_width(box_size / 5)
223
258
            ctx.stroke_preserve()
233
268
 
234
269
        (column, colour) = self.node
235
270
 
236
 
        font_desc = pango.FontDescription()
237
 
        font_desc.set_size(pango.SCALE * 7)
 
271
        font_desc = Pango.FontDescription()
 
272
        font_desc.set_size(Pango.SCALE * 7)
238
273
 
239
 
        tag_layout = pango.Layout(pango_ctx)
 
274
        tag_layout = Pango.Layout(pango_ctx)
240
275
        tag_layout.set_font_description(font_desc)
241
276
 
242
277
        # The width of the tag label stack
243
278
        width = 0
244
279
 
245
280
        for tag_idx, tag in enumerate(self.tags):
246
 
            tag_layout.set_text(" " + tag + " ")
 
281
            tag_layout.set_text(" " + tag + " ", -1)
247
282
            text_width, text_height = tag_layout.get_pixel_size()
248
283
 
249
284
            x0 = cell_area.x + \
272
307
            self.set_colour(ctx, TAG_COLOUR_ID, 0.0, 0.5)
273
308
            ctx.stroke_preserve()
274
309
 
275
 
            ctx.set_fill_rule (cairo.FILL_RULE_EVEN_ODD)
 
310
            ctx.set_fill_rule (CAIRO_FILL_RULE_EVEN_ODD)
276
311
            self.set_colour(ctx, TAG_COLOUR_ID, 0.5, 1.0)
277
312
            ctx.fill()
278
313
 
279
314
            # Draw the tag text
280
315
            self.set_colour(ctx, 0, 0.0, 0.0)
281
316
            ctx.move_to(x0, y0)
282
 
            ctx.show_layout(tag_layout)
283
 
 
 
317
            PangoCairo.show_layout(ctx, tag_layout)