/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/linegraph.py

  • Committer: Jelmer Vernooij
  • Date: 2011-03-14 20:12:19 UTC
  • Revision ID: jelmer@samba.org-20110314201219-wo692nzwywu6mevh
Fix formatting, imports.

Show diffs side-by-side

added added

removed removed

Lines of Context:
12
12
from bzrlib.tsort import merge_sort
13
13
from bzrlib import ui
14
14
 
 
15
 
15
16
def linegraph(graph, start_revs, maxnum=None, broken_line_length=None,
16
17
              graph_data=True, mainline_only=False, root_progress=None):
17
18
    """Produce a directed graph of a bzr repository.
26
27
    * revid_index is a dict of each revision with the key being the revid, and
27
28
      the value the row index, and
28
29
    * columns_len is the number of columns need to draw the line graph.
29
 
    
 
30
 
30
31
 
31
32
    Node is a tuple of (column, colour) with column being a zero-indexed
32
33
    column number of the graph that this revision represents and colour
92
93
            generate_revno=True)
93
94
    else:
94
95
        merge_sorted_revisions = ()
95
 
    
 
96
 
96
97
    if mainline_only:
97
98
        merge_sorted_revisions = [elem for elem in merge_sorted_revisions \
98
99
                                  if len(elem[3])==1 ]
99
100
 
100
101
    assert merge_sorted_revisions[0][1] == "top:"
101
102
    merge_sorted_revisions = merge_sorted_revisions[1:]
102
 
    
 
103
 
103
104
    revid_index = {}
104
105
    revno_index = {}
105
 
    
 
106
 
106
107
    # This will hold an item for each "branch". For a revisions, the revsion
107
108
    # number less the least significant digit is the branch_id, and used as the
108
109
    # key for the dict. Hence revision with the same revsion number less the
111
112
    # and these two revisions will be in the same branch line. Each value is
112
113
    # a list of rev_indexes in the branch.
113
114
    branch_lines = {}
114
 
    
115
 
    linegraph = []    
116
 
    
 
115
 
 
116
    linegraph = []
 
117
 
117
118
    update_root_progress(3)
118
119
    progress_bar = ui.ui_factory.nested_progress_bar()
119
120
    try:
129
130
            if maxnum and rev_index >= maxnum:
130
131
                break
131
132
            revid_index[revid] = rev_index
132
 
            
 
133
 
133
134
            parents = graph_parents[revid]
134
135
            linegraph.append([revid,
135
136
                              None,
137
138
                              parents,
138
139
                              None,
139
140
                              revno_sequence])
140
 
            
 
141
 
141
142
            if graph_data:
142
143
                revno_index[revno_sequence] = rev_index
143
 
                
 
144
 
144
145
                branch_id = revno_sequence[0:-1]
145
 
                
 
146
 
146
147
                branch_line = None
147
148
                if branch_id not in branch_lines:
148
149
                    branch_line = []
149
150
                    branch_lines[branch_id] = branch_line
150
151
                else:
151
152
                    branch_line = branch_lines[branch_id]
152
 
                
153
 
                branch_line.append(rev_index)        
 
153
 
 
154
                branch_line.append(rev_index)
154
155
    finally:
155
156
        progress_bar.finished()
156
157
 
157
158
    if graph_data:
158
159
        branch_ids = branch_lines.keys()
159
 
    
 
160
 
160
161
        def branch_id_cmp(x, y):
161
162
            """Compaire branch_id's first by the number of digits, then reversed
162
163
            by their value"""
165
166
            if len_x == len_y:
166
167
                return -cmp(x, y)
167
168
            return cmp(len_x, len_y)
168
 
        
 
169
 
169
170
        branch_ids.sort(branch_id_cmp)
170
171
        # This will hold a tuple of (child_index, parent_index, col_index) for each
171
172
        # line that needs to be drawn. If col_index is not none, then the line is
178
179
        # cell allready contains a node or line. This use when deciding what column
179
180
        # to place a branch line or line in, without it overlaping something else.
180
181
        columns = [list(empty_column)]
181
 
        
182
 
        
 
182
 
 
183
 
183
184
        update_root_progress(4)
184
185
        progress_bar = ui.ui_factory.nested_progress_bar()
185
186
        try:
188
189
                if i % 25 == 0:
189
190
                    progress_bar.update(None, i)
190
191
                branch_line = branch_lines[branch_id]
191
 
                
 
192
 
192
193
                # Find the col_index for the direct parent branch. This will be the
193
194
                # starting point when looking for a free column.
194
195
                parent_col_index = 0
200
201
                        parent_node = linegraph[parent_index][1]
201
202
                        if parent_node:
202
203
                            parent_col_index = parent_node[0]
203
 
                        
204
 
                
 
204
 
 
205
 
205
206
                col_search_order = _branch_line_col_search_order(columns,
206
207
                                                                 parent_col_index)
207
208
                color = reduce(lambda x, y: x+y, branch_id, 0)
208
209
                cur_cont_line = []
209
 
                
 
210
 
210
211
                line_range = []
211
212
                last_rev_index = None
212
213
                for rev_index in branch_line:
217
218
                            line_range.append(rev_index-1)
218
219
                        else:
219
220
                            line_range.extend(range(last_rev_index+1, rev_index))
220
 
                    
 
221
 
221
222
                    line_range.append(rev_index)
222
223
                    last_rev_index = rev_index
223
 
                
 
224
 
224
225
                if parent_index:
225
226
                    if broken_line_length and \
226
227
                       parent_index - last_rev_index > broken_line_length:
227
228
                        line_range.append(last_rev_index+1)
228
229
                    else:
229
230
                        line_range.extend(range(last_rev_index+1, parent_index))
230
 
                
 
231
 
231
232
                col_index = _find_free_column(columns,
232
233
                                              empty_column,
233
234
                                              col_search_order,
236
237
                for rev_index in branch_line:
237
238
                    linegraph[rev_index][1] = node
238
239
                    columns[col_index][rev_index] = True
239
 
                
 
240
 
240
241
                for rev_index in branch_line:
241
242
                    (sequence_number,
242
243
                         revid,
243
244
                         merge_depth,
244
245
                         revno_sequence,
245
246
                         end_of_merge) = merge_sorted_revisions[rev_index]
246
 
                    
 
247
 
247
248
                    linegraph[rev_index][4] = graph_children[revid]
248
249
                    col_index = linegraph[rev_index][1][0]
249
 
                    
 
250
 
250
251
                    for parent_revid in graph_parents[revid]:
251
252
                        if parent_revid in revid_index:
252
 
                            
253
 
                            parent_index = revid_index[parent_revid]                            
 
253
 
 
254
                            parent_index = revid_index[parent_revid]
254
255
                            parent_node = linegraph[parent_index][1]
255
256
                            if parent_node:
256
257
                                parent_col_index = parent_node[0]
260
261
                                    _line_col_search_order(columns,
261
262
                                                           parent_col_index,
262
263
                                                           col_index)
263
 
                                
 
264
 
264
265
                            # If this line is really long, break it.
265
266
                            if len(branch_id) > 0 and \
266
267
                               broken_line_length and \
273
274
                                _mark_column_as_used(columns,
274
275
                                                     child_line_col_index,
275
276
                                                     (rev_index + 1,))
276
 
                                
 
277
 
277
278
                                # Recall _line_col_search_order to reset it back to
278
279
                                # the beging.
279
280
                                col_search_order = \
309
310
                                              (line_col_index,)))
310
311
        finally:
311
312
            progress_bar.finished()
312
 
        
 
313
 
313
314
        update_root_progress(5)
314
315
        progress_bar = ui.ui_factory.nested_progress_bar()
315
316
        try:
319
320
                    progress_bar.update(None, i)
320
321
                (child_col_index, child_color) = linegraph[child_index][1]
321
322
                (parent_col_index, parent_color) = linegraph[parent_index][1]
322
 
                
 
323
 
323
324
                if len(line_col_indexes) == 1:
324
325
                    if parent_index - child_index == 1:
325
326
                        linegraph[child_index][2].append(
335
336
                        # lines down the line's column
336
337
                        for line_part_index in range(child_index+1, parent_index-1):
337
338
                            linegraph[line_part_index][2].append(
338
 
                                (line_col_indexes[0],   
 
339
                                (line_col_indexes[0], 
339
340
                                 line_col_indexes[0],
340
341
                                 parent_color))
341
342
                        # line from the line's column to the parent's column
355
356
                        (line_col_indexes[0],
356
357
                         None,
357
358
                         parent_color))
358
 
                    
 
359
 
359
360
                    # Broken line end 
360
361
                    linegraph[parent_index-2][2].append(
361
362
                        (None,
371
372
        return (linegraph, revid_index, len(columns))
372
373
    else:
373
374
        return (linegraph, revid_index, 0)
374
 
    
 
375
 
375
376
 
376
377
def _branch_line_col_search_order(columns, parent_col_index):
377
378
    for col_index in range(parent_col_index, len(columns)):
417
418
def _mark_column_as_used(columns, col_index, line_range):
418
419
    column = columns[col_index]
419
420
    for row_index in line_range:
420
 
        column[row_index] = True    
 
421
        column[row_index] = True
421
422
 
422
423
def same_branch(a, b):
423
424
    """Return whether we think revisions a and b are on the same branch."""