/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
1
 
#!/usr/bin/python
2
1
# -*- coding: UTF-8 -*-
3
2
"""Cell renderer for directed graph.
4
3
 
31
30
      in_lines          (start, end, colour) tuple list to draw inward lines,
32
31
      out_lines         (start, end, colour) tuple list to draw outward lines.
33
32
    """
 
33
    
 
34
    columns_len = 0
34
35
 
35
36
    __gproperties__ = {
36
37
        "node":         ( gobject.TYPE_PYOBJECT, "node",
37
38
                          "revision node instruction",
38
39
                          gobject.PARAM_WRITABLE
39
40
                        ),
 
41
        "tags":         ( gobject.TYPE_PYOBJECT, "tags",
 
42
                          "list of tags associated with the node",
 
43
                          gobject.PARAM_WRITABLE
 
44
                        ),
40
45
        "in-lines":     ( gobject.TYPE_PYOBJECT, "in-lines",
41
46
                          "instructions to draw lines into the cell",
42
47
                          gobject.PARAM_WRITABLE
46
51
                          gobject.PARAM_WRITABLE
47
52
                        ),
48
53
        }
49
 
 
 
54
    
50
55
    def do_set_property(self, property, value):
51
56
        """Set properties from GObject properties."""
52
57
        if property.name == "node":
53
58
            self.node = value
 
59
        elif property.name == "tags":
 
60
            self.tags = value
54
61
        elif property.name == "in-lines":
55
62
            self.in_lines = value
56
63
        elif property.name == "out-lines":
72
79
            metrics = pango_ctx.get_metrics(font_desc)
73
80
 
74
81
            ascent = pango.PIXELS(metrics.get_ascent())
75
 
            descent = pango.PIXELS(metrics.get_ascent())
 
82
            descent = pango.PIXELS(metrics.get_descent())
76
83
 
77
 
            self._box_size = ascent + descent
 
84
            self._box_size = ascent + descent + 6
78
85
            return self._box_size
79
86
 
80
87
    def set_colour(self, ctx, colour, bg, fg):
85
92
        colours and the fg parameter provides the multiplier that should be
86
93
        applied to the foreground colours.
87
94
        """
 
95
        mainline_color = ( 0.0, 0.0, 0.0 )
88
96
        colours = [
89
97
            ( 1.0, 0.0, 0.0 ),
90
98
            ( 1.0, 1.0, 0.0 ),
94
102
            ( 1.0, 0.0, 1.0 ),
95
103
            ]
96
104
 
97
 
        colour %= len(colours)
98
 
        red   = (colours[colour][0] * fg) or bg
99
 
        green = (colours[colour][1] * fg) or bg
100
 
        blue  = (colours[colour][2] * fg) or bg
 
105
        if colour == 0:
 
106
            colour_rgb = mainline_color
 
107
        else:
 
108
            colour_rgb = colours[colour % len(colours)]
 
109
 
 
110
        red   = (colour_rgb[0] * fg) or bg
 
111
        green = (colour_rgb[1] * fg) or bg
 
112
        blue  = (colour_rgb[2] * fg) or bg
101
113
 
102
114
        ctx.set_source_rgb(red, green, blue)
103
115
 
108
120
        to be, we let the TreeViewColumn take care of making them all
109
121
        line up.
110
122
        """
111
 
        box_size = self.box_size(widget)
112
 
 
113
 
        cols = self.node[0]
114
 
        for start, end, colour in self.in_lines + self.out_lines:
115
 
            cols = max(cols, start, end)
116
 
 
117
 
        width = box_size * (cols + 1)
 
123
        box_size = self.box_size(widget) + 1
 
124
 
 
125
        width = box_size * (self.columns_len + 1)
118
126
        height = box_size
119
127
 
120
128
        # FIXME I have no idea how to use cell_area properly
138
146
        ctx.rectangle(bg_area.x, bg_area.y, bg_area.width, bg_area.height)
139
147
        ctx.clip()
140
148
 
141
 
        ctx.set_line_width(2)
142
 
        ctx.set_line_cap(cairo.LINE_CAP_SQUARE)
143
 
 
144
149
        box_size = self.box_size(widget)
145
150
 
 
151
        ctx.set_line_width(box_size / 8)
 
152
        ctx.set_line_cap(cairo.LINE_CAP_ROUND)
 
153
 
146
154
        # Draw lines into the cell
147
155
        for start, end, colour in self.in_lines:
148
 
            ctx.move_to(cell_area.x + box_size * start + box_size / 2,
149
 
                        bg_area.y - bg_area.height / 2)
150
 
 
151
 
            if start - end > 1:
152
 
                ctx.line_to(cell_area.x + box_size * start, bg_area.y)
153
 
                ctx.line_to(cell_area.x + box_size * end + box_size, bg_area.y)
154
 
            elif start - end < -1:
155
 
                ctx.line_to(cell_area.x + box_size * start + box_size,
156
 
                            bg_area.y)
157
 
                ctx.line_to(cell_area.x + box_size * end, bg_area.y)
158
 
 
159
 
            ctx.line_to(cell_area.x + box_size * end + box_size / 2,
160
 
                        bg_area.y + bg_area.height / 2)
161
 
 
162
 
            self.set_colour(ctx, colour, 0.0, 0.65)
163
 
            ctx.stroke()
 
156
            self.render_line (ctx, cell_area, box_size,
 
157
                         bg_area.y, bg_area.height,
 
158
                         start, end, colour)
164
159
 
165
160
        # Draw lines out of the cell
166
161
        for start, end, colour in self.out_lines:
167
 
            ctx.move_to(cell_area.x + box_size * start + box_size / 2,
168
 
                        bg_area.y + bg_area.height / 2)
169
 
 
170
 
            if start - end > 1:
171
 
                ctx.line_to(cell_area.x + box_size * start,
172
 
                            bg_area.y + bg_area.height)
173
 
                ctx.line_to(cell_area.x + box_size * end + box_size,
174
 
                            bg_area.y + bg_area.height)
175
 
            elif start - end < -1:
176
 
                ctx.line_to(cell_area.x + box_size * start + box_size,
177
 
                            bg_area.y + bg_area.height)
178
 
                ctx.line_to(cell_area.x + box_size * end,
179
 
                            bg_area.y + bg_area.height)
180
 
 
181
 
            ctx.line_to(cell_area.x + box_size * end + box_size / 2,
182
 
                        bg_area.y + bg_area.height / 2 + bg_area.height)
183
 
 
184
 
            self.set_colour(ctx, colour, 0.0, 0.65)
185
 
            ctx.stroke()
 
162
            self.render_line (ctx, cell_area, box_size,
 
163
                         bg_area.y + bg_area.height, bg_area.height,
 
164
                         start, end, colour)
186
165
 
187
166
        # Draw the revision node in the right column
188
167
        (column, colour) = self.node
189
168
        ctx.arc(cell_area.x + box_size * column + box_size / 2,
190
169
                cell_area.y + cell_area.height / 2,
191
 
                box_size / 5, 0, 2 * math.pi)
 
170
                box_size / 4, 0, 2 * math.pi)
192
171
 
193
172
        self.set_colour(ctx, colour, 0.0, 0.5)
194
173
        ctx.stroke_preserve()
195
174
 
196
175
        self.set_colour(ctx, colour, 0.5, 1.0)
197
176
        ctx.fill()
 
177
 
 
178
        self.render_tags(ctx, widget.create_pango_context(), cell_area, box_size)
 
179
    
 
180
    def render_line(self, ctx, cell_area, box_size, mid, height, start, end, colour):
 
181
        if start is None:
 
182
            x = cell_area.x + box_size * end + box_size / 2
 
183
            ctx.move_to(x, mid + height / 3)
 
184
            ctx.line_to(x, mid + height / 3)
 
185
            ctx.move_to(x, mid + height / 6)
 
186
            ctx.line_to(x, mid + height / 6)
 
187
            
 
188
        elif end is None:
 
189
            x = cell_area.x + box_size * start + box_size / 2
 
190
            ctx.move_to(x, mid - height / 3)
 
191
            ctx.line_to(x, mid - height / 3)
 
192
            ctx.move_to(x, mid - height / 6)
 
193
            ctx.line_to(x, mid - height / 6)
 
194
        else:
 
195
            startx = cell_area.x + box_size * start + box_size / 2
 
196
            endx = cell_area.x + box_size * end + box_size / 2
 
197
            
 
198
            ctx.move_to(startx, mid - height / 2)
 
199
            
 
200
            if start - end == 0 :
 
201
                ctx.line_to(endx, mid + height / 2)
 
202
            else:
 
203
                ctx.curve_to(startx, mid - height / 5,
 
204
                             startx, mid - height / 5,
 
205
                             startx + (endx - startx) / 2, mid)
 
206
                
 
207
                ctx.curve_to(endx, mid + height / 5,
 
208
                             endx, mid + height / 5 ,
 
209
                             endx, mid + height / 2)
 
210
                
 
211
        self.set_colour(ctx, colour, 0.0, 0.65)
 
212
        ctx.stroke()
 
213
 
 
214
    def render_tags(self, ctx, pango_ctx, cell_area, box_size):
 
215
        # colour ID used in self.set_colour on the tags
 
216
        TAG_COLOUR_ID = 1
 
217
 
 
218
        (column, colour) = self.node
 
219
 
 
220
        font_desc = pango.FontDescription()
 
221
        font_desc.set_size(pango.SCALE * 7)
 
222
 
 
223
        tag_layout = pango.Layout(pango_ctx)
 
224
        tag_layout.set_font_description(font_desc)
 
225
 
 
226
        # The width of the tag label stack
 
227
        width = 0
 
228
 
 
229
        for tag_idx, tag in enumerate(self.tags):
 
230
            tag_layout.set_text(" " + tag + " ")
 
231
            text_width, text_height = tag_layout.get_pixel_size()
 
232
 
 
233
            x0 = cell_area.x + \
 
234
                 box_size * (column + 1.3) + width
 
235
 
 
236
            y0 = cell_area.y + \
 
237
                 cell_area.height / 2 - \
 
238
                 text_height / 2
 
239
 
 
240
            width += text_width + 5
 
241
 
 
242
            # Draw the tag border
 
243
            ctx.move_to(x0 - box_size / 3, y0 + text_height / 2)
 
244
            ctx.line_to(x0, y0)
 
245
            ctx.line_to(x0 + text_width, y0)
 
246
            ctx.line_to(x0 + text_width, y0 + text_height)
 
247
            ctx.line_to(x0, y0 + text_height)
 
248
            ctx.line_to(x0 - box_size / 3, y0 + text_height / 2)
 
249
 
 
250
            ctx.new_sub_path()
 
251
            ctx.arc(x0 - box_size / 12,
 
252
                        y0 + text_height / 2,
 
253
                        box_size / 7,
 
254
                        0, 2 * math.pi);
 
255
 
 
256
            self.set_colour(ctx, TAG_COLOUR_ID, 0.0, 0.5)
 
257
            ctx.stroke_preserve()
 
258
 
 
259
            ctx.set_fill_rule (cairo.FILL_RULE_EVEN_ODD)
 
260
            self.set_colour(ctx, TAG_COLOUR_ID, 0.5, 1.0)
 
261
            ctx.fill()
 
262
 
 
263
            # Draw the tag text
 
264
            self.set_colour(ctx, 0, 0.0, 0.0)
 
265
            ctx.move_to(x0, y0)
 
266
            ctx.show_layout(tag_layout)
 
267