/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: Daniel Schierbeck
  • Date: 2008-01-13 14:12:49 UTC
  • mto: (423.1.2 trunk)
  • mto: This revision was merged to the branch mainline in revision 429.
  • Revision ID: daniel.schierbeck@gmail.com-20080113141249-gd0i2lknr3yik55r
Moved branch view to its own package.

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
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",
 
39
                          gobject.PARAM_WRITABLE
 
40
                        ),
 
41
        "in-lines":     ( gobject.TYPE_PYOBJECT, "in-lines",
61
42
                          "instructions to draw lines into the cell",
62
 
                          GObject.PARAM_WRITABLE
 
43
                          gobject.PARAM_WRITABLE
63
44
                        ),
64
 
        "out-lines":    ( GObject.TYPE_PYOBJECT, "out-lines",
 
45
        "out-lines":    ( gobject.TYPE_PYOBJECT, "out-lines",
65
46
                          "instructions to draw lines out of the cell",
66
 
                          GObject.PARAM_WRITABLE
 
47
                          gobject.PARAM_WRITABLE
67
48
                        ),
68
49
        }
69
 
 
 
50
    
70
51
    def do_set_property(self, property, value):
71
52
        """Set properties from GObject properties."""
72
53
        if property.name == "node":
73
54
            self.node = value
74
 
        elif property.name == "tags":
75
 
            self.tags = value
76
55
        elif property.name == "in-lines":
77
56
            self.in_lines = value
78
57
        elif property.name == "out-lines":
91
70
        except AttributeError:
92
71
            pango_ctx = widget.get_pango_context()
93
72
            font_desc = widget.get_style().font_desc
94
 
            metrics = pango_ctx.get_metrics(font_desc, None)
95
 
            ascent = PANGO_PIXELS(metrics.get_ascent())
96
 
            descent = PANGO_PIXELS(metrics.get_descent())
 
73
            metrics = pango_ctx.get_metrics(font_desc)
 
74
 
 
75
            ascent = pango.PIXELS(metrics.get_ascent())
 
76
            descent = pango.PIXELS(metrics.get_descent())
 
77
 
97
78
            self._box_size = ascent + descent + 6
98
79
            return self._box_size
99
80
 
126
107
 
127
108
        ctx.set_source_rgb(red, green, blue)
128
109
 
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):
 
110
    def on_get_size(self, widget, cell_area):
138
111
        """Return the size we need for this cell.
139
112
 
140
113
        Each cell is drawn individually and is only as wide as it needs
149
122
        # FIXME I have no idea how to use cell_area properly
150
123
        return (0, 0, width, height)
151
124
 
152
 
    def do_render(self, ctx, widget, bg_area, cell_area, flags):
 
125
    def on_render(self, window, widget, bg_area, cell_area, exp_area, flags):
153
126
        """Render an individual cell.
154
127
 
155
128
        Draws the cell contents using cairo, taking care to clip what we
163
136
        instead of a pure diagonal ... this reduces confusion by an
164
137
        incredible amount.
165
138
        """
 
139
        ctx = window.cairo_create()
166
140
        ctx.rectangle(bg_area.x, bg_area.y, bg_area.width, bg_area.height)
167
141
        ctx.clip()
168
142
 
169
143
        box_size = self.box_size(widget)
170
144
 
171
145
        ctx.set_line_width(box_size / 8)
 
146
        ctx.set_line_cap(cairo.LINE_CAP_ROUND)
172
147
 
173
148
        # Draw lines into the cell
174
149
        for start, end, colour in self.in_lines:
175
150
            self.render_line (ctx, cell_area, box_size,
176
151
                         bg_area.y, bg_area.height,
177
 
                         start, end, colour, flags)
 
152
                         start, end, colour)
178
153
 
179
154
        # Draw lines out of the cell
180
155
        for start, end, colour in self.out_lines:
181
156
            self.render_line (ctx, cell_area, box_size,
182
157
                         bg_area.y + bg_area.height, bg_area.height,
183
 
                         start, end, colour, flags)
 
158
                         start, end, colour)
184
159
 
185
160
        # Draw the revision node in the right column
186
161
        (column, colour) = self.node
188
163
                cell_area.y + cell_area.height / 2,
189
164
                box_size / 4, 0, 2 * math.pi)
190
165
 
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
 
 
197
166
        self.set_colour(ctx, colour, 0.0, 0.5)
198
167
        ctx.stroke_preserve()
199
168
 
200
169
        self.set_colour(ctx, colour, 0.5, 1.0)
201
170
        ctx.fill()
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):
 
171
    
 
172
    def render_line (self, ctx, cell_area, box_size, mid, height, start, end, colour):
207
173
        if start is None:
208
 
            ctx.set_line_cap(CAIRO_LINE_CAP_ROUND)
209
174
            x = cell_area.x + box_size * end + box_size / 2
210
175
            ctx.move_to(x, mid + height / 3)
211
176
            ctx.line_to(x, mid + height / 3)
212
177
            ctx.move_to(x, mid + height / 6)
213
178
            ctx.line_to(x, mid + height / 6)
214
 
 
 
179
            
215
180
        elif end is None:
216
 
            ctx.set_line_cap(CAIRO_LINE_CAP_ROUND)
217
181
            x = cell_area.x + box_size * start + box_size / 2
218
182
            ctx.move_to(x, mid - height / 3)
219
183
            ctx.line_to(x, mid - height / 3)
220
184
            ctx.move_to(x, mid - height / 6)
221
185
            ctx.line_to(x, mid - height / 6)
222
 
 
223
186
        else:
224
 
            ctx.set_line_cap(CAIRO_LINE_CAP_BUTT)
225
187
            startx = cell_area.x + box_size * start + box_size / 2
226
188
            endx = cell_area.x + box_size * end + box_size / 2
227
 
 
 
189
            
228
190
            ctx.move_to(startx, mid - height / 2)
229
 
 
 
191
            
230
192
            if start - end == 0 :
231
 
                ctx.line_to(endx, mid + height / 2 + 1)
 
193
                ctx.line_to(endx, mid + height / 2)
232
194
            else:
233
195
                ctx.curve_to(startx, mid - height / 5,
234
196
                             startx, mid - height / 5,
235
197
                             startx + (endx - startx) / 2, mid)
236
 
 
 
198
                
237
199
                ctx.curve_to(endx, mid + height / 5,
238
200
                             endx, mid + height / 5 ,
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
 
 
 
201
                             endx, mid + height / 2)
 
202
                
247
203
        self.set_colour(ctx, colour, 0.0, 0.65)
248
 
 
249
204
        ctx.stroke()
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)
 
205
        
 
 
b'\\ No newline at end of file'