/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: Jelmer Vernooij
  • Date: 2008-03-14 02:13:27 UTC
  • mto: (452.2.2 trunk)
  • mto: This revision was merged to the branch mainline in revision 453.
  • Revision ID: jelmer@samba.org-20080314021327-q1pabtpneeasz8qv
Fix support for default value in BranchSelectionDialog.

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