/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 18:12:29 UTC
  • mto: This revision was merged to the branch mainline in revision 519.
  • Revision ID: jelmer@samba.org-20080629181229-1l2m4cf7vvbyh8qg
Simplify progress bar code, use embedded progress bar inside viz window.

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
 
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
 
def PANGO_PIXELS(d):
37
 
    # Macro from  Pango header.
38
 
    return (d + 512) / 1000
39
 
 
40
 
 
41
 
class CellRendererGraph(Gtk.CellRendererPixbuf):
 
19
import gtk
 
20
import gobject
 
21
import pango
 
22
import cairo
 
23
 
 
24
 
 
25
class CellRendererGraph(gtk.GenericCellRenderer):
42
26
    """Cell renderer for directed graph.
43
27
 
44
28
    Properties:
46
30
      in_lines          (start, end, colour) tuple list to draw inward lines,
47
31
      out_lines         (start, end, colour) tuple list to draw outward lines.
48
32
    """
49
 
 
 
33
    
50
34
    columns_len = 0
51
35
 
52
36
    __gproperties__ = {
53
 
        "node":         ( GObject.TYPE_PYOBJECT, "node",
 
37
        "node":         ( gobject.TYPE_PYOBJECT, "node",
54
38
                          "revision node instruction",
55
 
                          GObject.PARAM_WRITABLE
 
39
                          gobject.PARAM_WRITABLE
56
40
                        ),
57
 
        "tags":         ( GObject.TYPE_PYOBJECT, "tags",
 
41
        "tags":         ( gobject.TYPE_PYOBJECT, "tags",
58
42
                          "list of tags associated with the node",
59
 
                          GObject.PARAM_WRITABLE
 
43
                          gobject.PARAM_WRITABLE
60
44
                        ),
61
 
        "in-lines":     ( GObject.TYPE_PYOBJECT, "in-lines",
 
45
        "in-lines":     ( gobject.TYPE_PYOBJECT, "in-lines",
62
46
                          "instructions to draw lines into the cell",
63
 
                          GObject.PARAM_WRITABLE
 
47
                          gobject.PARAM_WRITABLE
64
48
                        ),
65
 
        "out-lines":    ( GObject.TYPE_PYOBJECT, "out-lines",
 
49
        "out-lines":    ( gobject.TYPE_PYOBJECT, "out-lines",
66
50
                          "instructions to draw lines out of the cell",
67
 
                          GObject.PARAM_WRITABLE
 
51
                          gobject.PARAM_WRITABLE
68
52
                        ),
69
53
        }
70
 
 
 
54
    
71
55
    def do_set_property(self, property, value):
72
56
        """Set properties from GObject properties."""
73
57
        if property.name == "node":
92
76
        except AttributeError:
93
77
            pango_ctx = widget.get_pango_context()
94
78
            font_desc = widget.get_style().font_desc
95
 
            metrics = pango_ctx.get_metrics(font_desc, None)
96
 
            ascent = PANGO_PIXELS(metrics.get_ascent())
97
 
            descent = PANGO_PIXELS(metrics.get_descent())
 
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