/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: Vincent Ladeuil
  • Date: 2008-05-05 18:16:46 UTC
  • mto: (487.1.1 gtk)
  • mto: This revision was merged to the branch mainline in revision 490.
  • Revision ID: v.ladeuil+lp@free.fr-20080505181646-n95l8ltw2u6jtr26
Fix bug #187283 fix replacing _() by _i18n().

* genpot.sh 
Remove duplication. Add the ability to specify the genrated pot
file on command-line for debugging purposes.

* po/olive-gtk.pot:
Regenerated.

* __init__.py, branch.py, branchview/treeview.py, checkout.py,
commit.py, conflicts.py, diff.py, errors.py, initialize.py,
merge.py, nautilus-bzr.py, olive/__init__.py, olive/add.py,
olive/bookmark.py, olive/guifiles.py, olive/info.py,
olive/menu.py, olive/mkdir.py, olive/move.py, olive/remove.py,
olive/rename.py, push.py, revbrowser.py, status.py, tags.py:
Replace all calls to _() by calls to _i18n(), the latter being
defined in __init__.py and imported in the other modules from
there. This fix the problem encountered countless times when
running bzr selftest and getting silly error messages about
boolean not being callables.

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
 
169
149
        box_size = self.box_size(widget)
170
150
 
171
151
        ctx.set_line_width(box_size / 8)
 
152
        ctx.set_line_cap(cairo.LINE_CAP_ROUND)
172
153
 
173
154
        # Draw lines into the cell
174
155
        for start, end, colour in self.in_lines:
175
156
            self.render_line (ctx, cell_area, box_size,
176
157
                         bg_area.y, bg_area.height,
177
 
                         start, end, colour, flags)
 
158
                         start, end, colour)
178
159
 
179
160
        # Draw lines out of the cell
180
161
        for start, end, colour in self.out_lines:
181
162
            self.render_line (ctx, cell_area, box_size,
182
163
                         bg_area.y + bg_area.height, bg_area.height,
183
 
                         start, end, colour, flags)
 
164
                         start, end, colour)
184
165
 
185
166
        # Draw the revision node in the right column
186
167
        (column, colour) = self.node
188
169
                cell_area.y + cell_area.height / 2,
189
170
                box_size / 4, 0, 2 * math.pi)
190
171
 
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
172
        self.set_colour(ctx, colour, 0.0, 0.5)
198
173
        ctx.stroke_preserve()
199
174
 
201
176
        ctx.fill()
202
177
 
203
178
        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):
 
179
    
 
180
    def render_line(self, ctx, cell_area, box_size, mid, height, start, end, colour):
207
181
        if start is None:
208
 
            ctx.set_line_cap(CAIRO_LINE_CAP_ROUND)
209
182
            x = cell_area.x + box_size * end + box_size / 2
210
183
            ctx.move_to(x, mid + height / 3)
211
184
            ctx.line_to(x, mid + height / 3)
212
185
            ctx.move_to(x, mid + height / 6)
213
186
            ctx.line_to(x, mid + height / 6)
214
 
 
 
187
            
215
188
        elif end is None:
216
 
            ctx.set_line_cap(CAIRO_LINE_CAP_ROUND)
217
189
            x = cell_area.x + box_size * start + box_size / 2
218
190
            ctx.move_to(x, mid - height / 3)
219
191
            ctx.line_to(x, mid - height / 3)
220
192
            ctx.move_to(x, mid - height / 6)
221
193
            ctx.line_to(x, mid - height / 6)
222
 
 
223
194
        else:
224
 
            ctx.set_line_cap(CAIRO_LINE_CAP_BUTT)
225
195
            startx = cell_area.x + box_size * start + box_size / 2
226
196
            endx = cell_area.x + box_size * end + box_size / 2
227
 
 
 
197
            
228
198
            ctx.move_to(startx, mid - height / 2)
229
 
 
 
199
            
230
200
            if start - end == 0 :
231
 
                ctx.line_to(endx, mid + height / 2 + 1)
 
201
                ctx.line_to(endx, mid + height / 2)
232
202
            else:
233
203
                ctx.curve_to(startx, mid - height / 5,
234
204
                             startx, mid - height / 5,
235
205
                             startx + (endx - startx) / 2, mid)
236
 
 
 
206
                
237
207
                ctx.curve_to(endx, mid + height / 5,
238
208
                             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
 
 
 
209
                             endx, mid + height / 2)
 
210
                
247
211
        self.set_colour(ctx, colour, 0.0, 0.65)
248
 
 
249
212
        ctx.stroke()
250
213
 
251
214
    def render_tags(self, ctx, pango_ctx, cell_area, box_size):
254
217
 
255
218
        (column, colour) = self.node
256
219
 
257
 
        font_desc = Pango.FontDescription()
258
 
        font_desc.set_size(Pango.SCALE * 7)
 
220
        font_desc = pango.FontDescription()
 
221
        font_desc.set_size(pango.SCALE * 7)
259
222
 
260
 
        tag_layout = Pango.Layout(pango_ctx)
 
223
        tag_layout = pango.Layout(pango_ctx)
261
224
        tag_layout.set_font_description(font_desc)
262
225
 
263
226
        # The width of the tag label stack
264
227
        width = 0
265
228
 
266
229
        for tag_idx, tag in enumerate(self.tags):
267
 
            tag_layout.set_text(" " + tag + " ", -1)
 
230
            tag_layout.set_text(" " + tag + " ")
268
231
            text_width, text_height = tag_layout.get_pixel_size()
269
232
 
270
233
            x0 = cell_area.x + \
293
256
            self.set_colour(ctx, TAG_COLOUR_ID, 0.0, 0.5)
294
257
            ctx.stroke_preserve()
295
258
 
296
 
            ctx.set_fill_rule (CAIRO_FILL_RULE_EVEN_ODD)
 
259
            ctx.set_fill_rule (cairo.FILL_RULE_EVEN_ODD)
297
260
            self.set_colour(ctx, TAG_COLOUR_ID, 0.5, 1.0)
298
261
            ctx.fill()
299
262
 
300
263
            # Draw the tag text
301
264
            self.set_colour(ctx, 0, 0.0, 0.0)
302
265
            ctx.move_to(x0, y0)
303
 
            PangoCairo.show_layout(ctx, tag_layout)
 
266
            ctx.show_layout(tag_layout)
 
267