/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: 2012-02-05 05:14:11 UTC
  • mto: This revision was merged to the branch mainline in revision 775.
  • Revision ID: sinzui.is@verizon.net-20120205051411-y9ra08wae1wsfv52
Remove unneeded gtksourceview1 support.

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
 
 
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):
26
41
    """Cell renderer for directed graph.
27
42
 
28
43
    Properties:
30
45
      in_lines          (start, end, colour) tuple list to draw inward lines,
31
46
      out_lines         (start, end, colour) tuple list to draw outward lines.
32
47
    """
33
 
    
 
48
 
34
49
    columns_len = 0
35
50
 
36
51
    __gproperties__ = {
37
 
        "node":         ( gobject.TYPE_PYOBJECT, "node",
 
52
        "node":         ( GObject.TYPE_PYOBJECT, "node",
38
53
                          "revision node instruction",
39
 
                          gobject.PARAM_WRITABLE
40
 
                        ),
41
 
        "in-lines":     ( gobject.TYPE_PYOBJECT, "in-lines",
 
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",
42
61
                          "instructions to draw lines into the cell",
43
 
                          gobject.PARAM_WRITABLE
 
62
                          GObject.PARAM_WRITABLE
44
63
                        ),
45
 
        "out-lines":    ( gobject.TYPE_PYOBJECT, "out-lines",
 
64
        "out-lines":    ( GObject.TYPE_PYOBJECT, "out-lines",
46
65
                          "instructions to draw lines out of the cell",
47
 
                          gobject.PARAM_WRITABLE
 
66
                          GObject.PARAM_WRITABLE
48
67
                        ),
49
68
        }
50
 
    
 
69
 
51
70
    def do_set_property(self, property, value):
52
71
        """Set properties from GObject properties."""
53
72
        if property.name == "node":
54
73
            self.node = value
 
74
        elif property.name == "tags":
 
75
            self.tags = value
55
76
        elif property.name == "in-lines":
56
77
            self.in_lines = value
57
78
        elif property.name == "out-lines":
70
91
        except AttributeError:
71
92
            pango_ctx = widget.get_pango_context()
72
93
            font_desc = widget.get_style().font_desc
73
 
            metrics = pango_ctx.get_metrics(font_desc)
74
 
 
75
 
            ascent = pango.PIXELS(metrics.get_ascent())
76
 
            descent = pango.PIXELS(metrics.get_descent())
77
 
 
 
94
            metrics = pango_ctx.get_metrics(font_desc, None)
 
95
            ascent = PANGO_PIXELS(metrics.get_ascent())
 
96
            descent = PANGO_PIXELS(metrics.get_descent())
78
97
            self._box_size = ascent + descent + 6
79
98
            return self._box_size
80
99
 
107
126
 
108
127
        ctx.set_source_rgb(red, green, blue)
109
128
 
110
 
    def on_get_size(self, widget, cell_area):
 
129
    def do_activate(event, widget, path, bg_area, cell_area, flags):
 
130
        """Renderers cannot be activated; always return True."""
 
131
        return True
 
132
 
 
133
    def do_editing_started(event, widget, path, fb_area, cell_area, flags):
 
134
        """Renderers cannot be edited; always return None."""
 
135
        return None
 
136
 
 
137
    def do_get_size(self, widget, cell_area):
111
138
        """Return the size we need for this cell.
112
139
 
113
140
        Each cell is drawn individually and is only as wide as it needs
122
149
        # FIXME I have no idea how to use cell_area properly
123
150
        return (0, 0, width, height)
124
151
 
125
 
    def on_render(self, window, widget, bg_area, cell_area, exp_area, flags):
 
152
    def do_render(self, ctx, widget, bg_area, cell_area, flags):
126
153
        """Render an individual cell.
127
154
 
128
155
        Draws the cell contents using cairo, taking care to clip what we
136
163
        instead of a pure diagonal ... this reduces confusion by an
137
164
        incredible amount.
138
165
        """
139
 
        ctx = window.cairo_create()
140
166
        ctx.rectangle(bg_area.x, bg_area.y, bg_area.width, bg_area.height)
141
167
        ctx.clip()
142
168
 
143
169
        box_size = self.box_size(widget)
144
170
 
145
171
        ctx.set_line_width(box_size / 8)
146
 
        ctx.set_line_cap(cairo.LINE_CAP_ROUND)
147
172
 
148
173
        # Draw lines into the cell
149
174
        for start, end, colour in self.in_lines:
150
175
            self.render_line (ctx, cell_area, box_size,
151
176
                         bg_area.y, bg_area.height,
152
 
                         start, end, colour)
 
177
                         start, end, colour, flags)
153
178
 
154
179
        # Draw lines out of the cell
155
180
        for start, end, colour in self.out_lines:
156
181
            self.render_line (ctx, cell_area, box_size,
157
182
                         bg_area.y + bg_area.height, bg_area.height,
158
 
                         start, end, colour)
 
183
                         start, end, colour, flags)
159
184
 
160
185
        # Draw the revision node in the right column
161
186
        (column, colour) = self.node
163
188
                cell_area.y + cell_area.height / 2,
164
189
                box_size / 4, 0, 2 * math.pi)
165
190
 
 
191
        if flags & Gtk.CellRendererState.SELECTED:
 
192
            ctx.set_source_rgb(1.0, 1.0, 1.0)
 
193
            ctx.set_line_width(box_size / 4)
 
194
            ctx.stroke_preserve()
 
195
            ctx.set_line_width(box_size / 8)
 
196
 
166
197
        self.set_colour(ctx, colour, 0.0, 0.5)
167
198
        ctx.stroke_preserve()
168
199
 
169
200
        self.set_colour(ctx, colour, 0.5, 1.0)
170
201
        ctx.fill()
171
 
    
172
 
    def render_line (self, ctx, cell_area, box_size, mid, height, start, end, colour):
 
202
 
 
203
        self.render_tags(ctx, widget.create_pango_context(), cell_area, box_size)
 
204
 
 
205
    def render_line(self, ctx, cell_area, box_size,
 
206
                    mid, height, start, end, colour, flags):
173
207
        if start is None:
 
208
            ctx.set_line_cap(CAIRO_LINE_CAP_ROUND)
174
209
            x = cell_area.x + box_size * end + box_size / 2
175
210
            ctx.move_to(x, mid + height / 3)
176
211
            ctx.line_to(x, mid + height / 3)
177
212
            ctx.move_to(x, mid + height / 6)
178
213
            ctx.line_to(x, mid + height / 6)
179
 
            
 
214
 
180
215
        elif end is None:
 
216
            ctx.set_line_cap(CAIRO_LINE_CAP_ROUND)
181
217
            x = cell_area.x + box_size * start + box_size / 2
182
218
            ctx.move_to(x, mid - height / 3)
183
219
            ctx.line_to(x, mid - height / 3)
184
220
            ctx.move_to(x, mid - height / 6)
185
221
            ctx.line_to(x, mid - height / 6)
 
222
 
186
223
        else:
 
224
            ctx.set_line_cap(CAIRO_LINE_CAP_BUTT)
187
225
            startx = cell_area.x + box_size * start + box_size / 2
188
226
            endx = cell_area.x + box_size * end + box_size / 2
189
 
            
 
227
 
190
228
            ctx.move_to(startx, mid - height / 2)
191
 
            
 
229
 
192
230
            if start - end == 0 :
193
 
                ctx.line_to(endx, mid + height / 2)
 
231
                ctx.line_to(endx, mid + height / 2 + 1)
194
232
            else:
195
233
                ctx.curve_to(startx, mid - height / 5,
196
234
                             startx, mid - height / 5,
197
235
                             startx + (endx - startx) / 2, mid)
198
 
                
 
236
 
199
237
                ctx.curve_to(endx, mid + height / 5,
200
238
                             endx, mid + height / 5 ,
201
 
                             endx, mid + height / 2)
202
 
                
 
239
                             endx, mid + height / 2 + 1)
 
240
 
 
241
        if flags & Gtk.CellRendererState.SELECTED:
 
242
            ctx.set_source_rgb(1.0, 1.0, 1.0)
 
243
            ctx.set_line_width(box_size / 5)
 
244
            ctx.stroke_preserve()
 
245
            ctx.set_line_width(box_size / 8)
 
246
 
203
247
        self.set_colour(ctx, colour, 0.0, 0.65)
 
248
 
204
249
        ctx.stroke()
205
 
        
 
 
b'\\ No newline at end of file'
 
250
 
 
251
    def render_tags(self, ctx, pango_ctx, cell_area, box_size):
 
252
        # colour ID used in self.set_colour on the tags
 
253
        TAG_COLOUR_ID = 1
 
254
 
 
255
        (column, colour) = self.node
 
256
 
 
257
        font_desc = Pango.FontDescription()
 
258
        font_desc.set_size(Pango.SCALE * 7)
 
259
 
 
260
        tag_layout = Pango.Layout(pango_ctx)
 
261
        tag_layout.set_font_description(font_desc)
 
262
 
 
263
        # The width of the tag label stack
 
264
        width = 0
 
265
 
 
266
        for tag_idx, tag in enumerate(self.tags):
 
267
            tag_layout.set_text(" " + tag + " ", -1)
 
268
            text_width, text_height = tag_layout.get_pixel_size()
 
269
 
 
270
            x0 = cell_area.x + \
 
271
                 box_size * (column + 1.3) + width
 
272
 
 
273
            y0 = cell_area.y + \
 
274
                 cell_area.height / 2 - \
 
275
                 text_height / 2
 
276
 
 
277
            width += text_width + 5
 
278
 
 
279
            # Draw the tag border
 
280
            ctx.move_to(x0 - box_size / 3, y0 + text_height / 2)
 
281
            ctx.line_to(x0, y0)
 
282
            ctx.line_to(x0 + text_width, y0)
 
283
            ctx.line_to(x0 + text_width, y0 + text_height)
 
284
            ctx.line_to(x0, y0 + text_height)
 
285
            ctx.line_to(x0 - box_size / 3, y0 + text_height / 2)
 
286
 
 
287
            ctx.new_sub_path()
 
288
            ctx.arc(x0 - box_size / 12,
 
289
                        y0 + text_height / 2,
 
290
                        box_size / 7,
 
291
                        0, 2 * math.pi);
 
292
 
 
293
            self.set_colour(ctx, TAG_COLOUR_ID, 0.0, 0.5)
 
294
            ctx.stroke_preserve()
 
295
 
 
296
            ctx.set_fill_rule (CAIRO_FILL_RULE_EVEN_ODD)
 
297
            self.set_colour(ctx, TAG_COLOUR_ID, 0.5, 1.0)
 
298
            ctx.fill()
 
299
 
 
300
            # Draw the tag text
 
301
            self.set_colour(ctx, 0, 0.0, 0.0)
 
302
            ctx.move_to(x0, y0)
 
303
            PangoCairo.show_layout(ctx, tag_layout)