/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-03 13:19:58 UTC
  • mto: This revision was merged to the branch mainline in revision 741.
  • Revision ID: sinzui.is@verizon.net-20110903131958-dvlxud881arul00m
Small performance improvement.

Show diffs side-by-side

added added

removed removed

Lines of Context:
branchview/graphcell.py
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 cairo
 
23
 
 
24
 
 
25
class CellRendererGraph(Gtk.CellRendererPixbuf):
26
26
    """Cell renderer for directed graph.
27
27
 
28
28
    Properties:
30
30
      in_lines          (start, end, colour) tuple list to draw inward lines,
31
31
      out_lines         (start, end, colour) tuple list to draw outward lines.
32
32
    """
33
 
    
 
33
 
34
34
    columns_len = 0
35
35
 
36
36
    __gproperties__ = {
37
 
        "node":         ( gobject.TYPE_PYOBJECT, "node",
 
37
        "node":         ( GObject.TYPE_PYOBJECT, "node",
38
38
                          "revision node instruction",
39
 
                          gobject.PARAM_WRITABLE
 
39
                          GObject.PARAM_WRITABLE
40
40
                        ),
41
 
        "tags":         ( gobject.TYPE_PYOBJECT, "tags",
 
41
        "tags":         ( GObject.TYPE_PYOBJECT, "tags",
42
42
                          "list of tags associated with the node",
43
 
                          gobject.PARAM_WRITABLE
 
43
                          GObject.PARAM_WRITABLE
44
44
                        ),
45
 
        "in-lines":     ( gobject.TYPE_PYOBJECT, "in-lines",
 
45
        "in-lines":     ( GObject.TYPE_PYOBJECT, "in-lines",
46
46
                          "instructions to draw lines into the cell",
47
 
                          gobject.PARAM_WRITABLE
 
47
                          GObject.PARAM_WRITABLE
48
48
                        ),
49
 
        "out-lines":    ( gobject.TYPE_PYOBJECT, "out-lines",
 
49
        "out-lines":    ( GObject.TYPE_PYOBJECT, "out-lines",
50
50
                          "instructions to draw lines out of the cell",
51
 
                          gobject.PARAM_WRITABLE
 
51
                          GObject.PARAM_WRITABLE
52
52
                        ),
53
53
        }
54
 
    
 
54
 
55
55
    def do_set_property(self, property, value):
56
56
        """Set properties from GObject properties."""
57
57
        if property.name == "node":
76
76
        except AttributeError:
77
77
            pango_ctx = widget.get_pango_context()
78
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())
 
79
            metrics = pango_ctx.get_metrics(font_desc, None)
 
80
 
 
81
            def PANGO_PIXELS(d):
 
82
                # Macro from  Pango header.
 
83
                return (d + 512) / 1000
 
84
 
 
85
            ascent = PANGO_PIXELS(metrics.get_ascent())
 
86
            descent = PANGO_PIXELS(metrics.get_descent())
83
87
 
84
88
            self._box_size = ascent + descent + 6
85
89
            return self._box_size
113
117
 
114
118
        ctx.set_source_rgb(red, green, blue)
115
119
 
116
 
    def on_get_size(self, widget, cell_area):
 
120
    def activate(event, widget, path, background_area, cell_area, flags):
 
121
        return True
 
122
 
 
123
    def start_editing(event, widget, path, background_area, cell_area, flags):
 
124
        return None
 
125
 
 
126
    def get_size(self, widget, cell_area, x_offset, y_offset, width, height):
117
127
        """Return the size we need for this cell.
118
128
 
119
129
        Each cell is drawn individually and is only as wide as it needs
128
138
        # FIXME I have no idea how to use cell_area properly
129
139
        return (0, 0, width, height)
130
140
 
131
 
    def on_render(self, window, widget, bg_area, cell_area, exp_area, flags):
 
141
    def render(self, ctx, widget, bg_area, cell_area, flags):
132
142
        """Render an individual cell.
133
143
 
134
144
        Draws the cell contents using cairo, taking care to clip what we
142
152
        instead of a pure diagonal ... this reduces confusion by an
143
153
        incredible amount.
144
154
        """
145
 
        ctx = window.cairo_create()
 
155
        print "rendering"
146
156
        ctx.rectangle(bg_area.x, bg_area.y, bg_area.width, bg_area.height)
147
157
        ctx.clip()
148
158
 
168
178
                cell_area.y + cell_area.height / 2,
169
179
                box_size / 4, 0, 2 * math.pi)
170
180
 
171
 
        if flags & gtk.CELL_RENDERER_SELECTED:
 
181
        if flags & Gtk.CELL_RENDERER_SELECTED:
172
182
            ctx.set_source_rgb(1.0, 1.0, 1.0)
173
183
            ctx.set_line_width(box_size / 4)
174
184
            ctx.stroke_preserve()
181
191
        ctx.fill()
182
192
 
183
193
        self.render_tags(ctx, widget.create_pango_context(), cell_area, box_size)
184
 
    
 
194
 
185
195
    def render_line(self, ctx, cell_area, box_size, mid, height, start, end, colour, flags):
186
196
        if start is None:
187
197
            ctx.set_line_cap(cairo.LINE_CAP_ROUND)
190
200
            ctx.line_to(x, mid + height / 3)
191
201
            ctx.move_to(x, mid + height / 6)
192
202
            ctx.line_to(x, mid + height / 6)
193
 
            
 
203
 
194
204
        elif end is None:
195
205
            ctx.set_line_cap(cairo.LINE_CAP_ROUND)
196
206
            x = cell_area.x + box_size * start + box_size / 2
203
213
            ctx.set_line_cap(cairo.LINE_CAP_BUTT)
204
214
            startx = cell_area.x + box_size * start + box_size / 2
205
215
            endx = cell_area.x + box_size * end + box_size / 2
206
 
            
 
216
 
207
217
            ctx.move_to(startx, mid - height / 2)
208
 
            
 
218
 
209
219
            if start - end == 0 :
210
220
                ctx.line_to(endx, mid + height / 2 + 1)
211
221
            else:
217
227
                             endx, mid + height / 5 ,
218
228
                             endx, mid + height / 2 + 1)
219
229
 
220
 
        if flags & gtk.CELL_RENDERER_SELECTED:
 
230
        if flags & Gtk.CELL_RENDERER_SELECTED:
221
231
            ctx.set_source_rgb(1.0, 1.0, 1.0)
222
232
            ctx.set_line_width(box_size / 5)
223
233
            ctx.stroke_preserve()
233
243
 
234
244
        (column, colour) = self.node
235
245
 
236
 
        font_desc = pango.FontDescription()
237
 
        font_desc.set_size(pango.SCALE * 7)
 
246
        font_desc = Pango.FontDescription()
 
247
        font_desc.set_size(Pango.SCALE * 7)
238
248
 
239
 
        tag_layout = pango.Layout(pango_ctx)
 
249
        tag_layout = Pango.Layout(pango_ctx)
240
250
        tag_layout.set_font_description(font_desc)
241
251
 
242
252
        # The width of the tag label stack