/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 viz/graphcell.py

  • Committer: Jelmer Vernooij
  • Date: 2006-05-19 16:37:13 UTC
  • Revision ID: jelmer@samba.org-20060519163713-be77b31c72cbc7e8
Move visualisation code to a separate directory, preparing for bundling 
the GTK+ plugins for bzr.

Show diffs side-by-side

added added

removed removed

Lines of Context:
viz/graphcell.py
 
1
#!/usr/bin/python
1
2
# -*- coding: UTF-8 -*-
2
3
"""Cell renderer for directed graph.
3
4
 
30
31
      in_lines          (start, end, colour) tuple list to draw inward lines,
31
32
      out_lines         (start, end, colour) tuple list to draw outward lines.
32
33
    """
33
 
    
34
 
    columns_len = 0
35
34
 
36
35
    __gproperties__ = {
37
36
        "node":         ( gobject.TYPE_PYOBJECT, "node",
38
37
                          "revision node instruction",
39
38
                          gobject.PARAM_WRITABLE
40
39
                        ),
41
 
        "tags":         ( gobject.TYPE_PYOBJECT, "tags",
42
 
                          "list of tags associated with the node",
43
 
                          gobject.PARAM_WRITABLE
44
 
                        ),
45
40
        "in-lines":     ( gobject.TYPE_PYOBJECT, "in-lines",
46
41
                          "instructions to draw lines into the cell",
47
42
                          gobject.PARAM_WRITABLE
51
46
                          gobject.PARAM_WRITABLE
52
47
                        ),
53
48
        }
54
 
    
 
49
 
55
50
    def do_set_property(self, property, value):
56
51
        """Set properties from GObject properties."""
57
52
        if property.name == "node":
58
53
            self.node = value
59
 
        elif property.name == "tags":
60
 
            self.tags = value
61
54
        elif property.name == "in-lines":
62
55
            self.in_lines = value
63
56
        elif property.name == "out-lines":
92
85
        colours and the fg parameter provides the multiplier that should be
93
86
        applied to the foreground colours.
94
87
        """
95
 
        mainline_color = ( 0.0, 0.0, 0.0 )
96
88
        colours = [
97
89
            ( 1.0, 0.0, 0.0 ),
98
90
            ( 1.0, 1.0, 0.0 ),
102
94
            ( 1.0, 0.0, 1.0 ),
103
95
            ]
104
96
 
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
 
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
113
101
 
114
102
        ctx.set_source_rgb(red, green, blue)
115
103
 
120
108
        to be, we let the TreeViewColumn take care of making them all
121
109
        line up.
122
110
        """
123
 
        box_size = self.box_size(widget) + 1
124
 
 
125
 
        width = box_size * (self.columns_len + 1)
 
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)
126
118
        height = box_size
127
119
 
128
120
        # FIXME I have no idea how to use cell_area properly
149
141
        box_size = self.box_size(widget)
150
142
 
151
143
        ctx.set_line_width(box_size / 8)
152
 
        ctx.set_line_cap(cairo.LINE_CAP_ROUND)
 
144
        ctx.set_line_cap(cairo.LINE_CAP_SQUARE)
153
145
 
154
146
        # Draw lines into the cell
155
147
        for start, end, colour in self.in_lines:
156
 
            self.render_line (ctx, cell_area, box_size,
157
 
                         bg_area.y, bg_area.height,
158
 
                         start, end, colour)
 
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()
159
164
 
160
165
        # Draw lines out of the cell
161
166
        for start, end, colour in self.out_lines:
162
 
            self.render_line (ctx, cell_area, box_size,
163
 
                         bg_area.y + bg_area.height, bg_area.height,
164
 
                         start, end, colour)
 
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()
165
186
 
166
187
        # Draw the revision node in the right column
167
188
        (column, colour) = self.node
174
195
 
175
196
        self.set_colour(ctx, colour, 0.5, 1.0)
176
197
        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