/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: rodney.dawes at canonical
  • Date: 2008-10-25 06:02:09 UTC
  • Revision ID: rodney.dawes@canonical.com-20081025060209-irlizouino63cs1m
        * preferences/__init__.py:
        Remove the dialog separator
        Remove useless extra call to self._create_pages()
        Make the default window size smaller
        Set the default border width on various widgets
        Set the current notebook page to the first one

        * preferences/identity.py:
        Set various border widths appropriately
        Align the labels to the left
        Remove the unneeded bold markup from the labels
        Change the "User Id" label to "E-Mail"
        Align the radio group labels to the top of the groups

        * preferences/plugins.py:
        Set various border widths appropriately
        Set the default paned position to something more sensible
        Set the shadow type on the treeview's scrolled window to in
        Align the Author and Version labels to the left

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
 
39
                          gobject.PARAM_WRITABLE
55
40
                        ),
56
 
        "tags":         ( GObject.TYPE_PYOBJECT, "tags",
 
41
        "tags":         ( gobject.TYPE_PYOBJECT, "tags",
57
42
                          "list of tags associated with the node",
58
 
                          GObject.PARAM_WRITABLE
 
43
                          gobject.PARAM_WRITABLE
59
44
                        ),
60
 
        "in-lines":     ( GObject.TYPE_PYOBJECT, "in-lines",
 
45
        "in-lines":     ( gobject.TYPE_PYOBJECT, "in-lines",
61
46
                          "instructions to draw lines into the cell",
62
 
                          GObject.PARAM_WRITABLE
 
47
                          gobject.PARAM_WRITABLE
63
48
                        ),
64
 
        "out-lines":    ( GObject.TYPE_PYOBJECT, "out-lines",
 
49
        "out-lines":    ( gobject.TYPE_PYOBJECT, "out-lines",
65
50
                          "instructions to draw lines out of the cell",
66
 
                          GObject.PARAM_WRITABLE
 
51
                          gobject.PARAM_WRITABLE
67
52
                        ),
68
53
        }
69
 
 
 
54
    
70
55
    def do_set_property(self, property, value):
71
56
        """Set properties from GObject properties."""
72
57
        if property.name == "node":
91
76
        except AttributeError:
92
77
            pango_ctx = widget.get_pango_context()
93
78
            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())
 
79
            metrics = pango_ctx.get_metrics(font_desc)
 
80
 
 
81
            ascent = pango.PIXELS(metrics.get_ascent())
 
82
            descent = pango.PIXELS(metrics.get_descent())
 
83
 
97
84
            self._box_size = ascent + descent + 6
98
85
            return self._box_size
99
86
 
126
113
 
127
114
        ctx.set_source_rgb(red, green, blue)
128
115
 
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):
 
116
    def on_get_size(self, widget, cell_area):
138
117
        """Return the size we need for this cell.
139
118
 
140
119
        Each cell is drawn individually and is only as wide as it needs
149
128
        # FIXME I have no idea how to use cell_area properly
150
129
        return (0, 0, width, height)
151
130
 
152
 
    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):
153
132
        """Render an individual cell.
154
133
 
155
134
        Draws the cell contents using cairo, taking care to clip what we
163
142
        instead of a pure diagonal ... this reduces confusion by an
164
143
        incredible amount.
165
144
        """
 
145
        ctx = window.cairo_create()
166
146
        ctx.rectangle(bg_area.x, bg_area.y, bg_area.width, bg_area.height)
167
147
        ctx.clip()
168
148
 
188
168
                cell_area.y + cell_area.height / 2,
189
169
                box_size / 4, 0, 2 * math.pi)
190
170
 
191
 
        if flags & Gtk.CellRendererState.SELECTED:
 
171
        if flags & gtk.CELL_RENDERER_SELECTED:
192
172
            ctx.set_source_rgb(1.0, 1.0, 1.0)
193
173
            ctx.set_line_width(box_size / 4)
194
174
            ctx.stroke_preserve()
201
181
        ctx.fill()
202
182
 
203
183
        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):
 
184
    
 
185
    def render_line(self, ctx, cell_area, box_size, mid, height, start, end, colour, flags):
207
186
        if start is None:
208
 
            ctx.set_line_cap(CAIRO_LINE_CAP_ROUND)
 
187
            ctx.set_line_cap(cairo.LINE_CAP_ROUND)
209
188
            x = cell_area.x + box_size * end + box_size / 2
210
189
            ctx.move_to(x, mid + height / 3)
211
190
            ctx.line_to(x, mid + height / 3)
212
191
            ctx.move_to(x, mid + height / 6)
213
192
            ctx.line_to(x, mid + height / 6)
214
 
 
 
193
            
215
194
        elif end is None:
216
 
            ctx.set_line_cap(CAIRO_LINE_CAP_ROUND)
 
195
            ctx.set_line_cap(cairo.LINE_CAP_ROUND)
217
196
            x = cell_area.x + box_size * start + box_size / 2
218
197
            ctx.move_to(x, mid - height / 3)
219
198
            ctx.line_to(x, mid - height / 3)
221
200
            ctx.line_to(x, mid - height / 6)
222
201
 
223
202
        else:
224
 
            ctx.set_line_cap(CAIRO_LINE_CAP_BUTT)
 
203
            ctx.set_line_cap(cairo.LINE_CAP_BUTT)
225
204
            startx = cell_area.x + box_size * start + box_size / 2
226
205
            endx = cell_area.x + box_size * end + box_size / 2
227
 
 
 
206
            
228
207
            ctx.move_to(startx, mid - height / 2)
229
 
 
 
208
            
230
209
            if start - end == 0 :
231
210
                ctx.line_to(endx, mid + height / 2 + 1)
232
211
            else:
238
217
                             endx, mid + height / 5 ,
239
218
                             endx, mid + height / 2 + 1)
240
219
 
241
 
        if flags & Gtk.CellRendererState.SELECTED:
 
220
        if flags & gtk.CELL_RENDERER_SELECTED:
242
221
            ctx.set_source_rgb(1.0, 1.0, 1.0)
243
222
            ctx.set_line_width(box_size / 5)
244
223
            ctx.stroke_preserve()
254
233
 
255
234
        (column, colour) = self.node
256
235
 
257
 
        font_desc = Pango.FontDescription()
258
 
        font_desc.set_size(Pango.SCALE * 7)
 
236
        font_desc = pango.FontDescription()
 
237
        font_desc.set_size(pango.SCALE * 7)
259
238
 
260
 
        tag_layout = Pango.Layout(pango_ctx)
 
239
        tag_layout = pango.Layout(pango_ctx)
261
240
        tag_layout.set_font_description(font_desc)
262
241
 
263
242
        # The width of the tag label stack
264
243
        width = 0
265
244
 
266
245
        for tag_idx, tag in enumerate(self.tags):
267
 
            tag_layout.set_text(" " + tag + " ", -1)
 
246
            tag_layout.set_text(" " + tag + " ")
268
247
            text_width, text_height = tag_layout.get_pixel_size()
269
248
 
270
249
            x0 = cell_area.x + \
293
272
            self.set_colour(ctx, TAG_COLOUR_ID, 0.0, 0.5)
294
273
            ctx.stroke_preserve()
295
274
 
296
 
            ctx.set_fill_rule (CAIRO_FILL_RULE_EVEN_ODD)
 
275
            ctx.set_fill_rule (cairo.FILL_RULE_EVEN_ODD)
297
276
            self.set_colour(ctx, TAG_COLOUR_ID, 0.5, 1.0)
298
277
            ctx.fill()
299
278
 
300
279
            # Draw the tag text
301
280
            self.set_colour(ctx, 0, 0.0, 0.0)
302
281
            ctx.move_to(x0, y0)
303
 
            PangoCairo.show_layout(ctx, tag_layout)
 
282
            ctx.show_layout(tag_layout)
 
283