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

  • Committer: Jasper Groenewegen
  • Date: 2008-07-27 12:01:40 UTC
  • mfrom: (576.3.2 improve-merge)
  • mto: This revision was merged to the branch mainline in revision 579.
  • Revision ID: colbrac@xs4all.nl-20080727120140-1agdlzkc9fumjk5f
Merge merge dialog improvements

Show diffs side-by-side

added added

removed removed

Lines of Context:
diff.py
30
30
except ImportError:
31
31
    have_gconf = False
32
32
 
33
 
from bzrlib import osutils
 
33
from bzrlib import (
 
34
    merge as _mod_merge,
 
35
    osutils,
 
36
    progress,
 
37
    urlutils,
 
38
    workingtree,
 
39
)
34
40
from bzrlib.diff import show_diff_trees, internal_diff
35
41
from bzrlib.errors import NoSuchFile
 
42
from bzrlib.patches import parse_patches
36
43
from bzrlib.trace import warning
 
44
from bzrlib.plugins.gtk import _i18n
37
45
from bzrlib.plugins.gtk.window import Window
38
 
 
39
 
 
40
 
class DiffView(gtk.ScrolledWindow):
41
 
    """This is the soft and chewy filling for a DiffWindow."""
 
46
from dialog import error_dialog, info_dialog, warning_dialog
 
47
 
 
48
 
 
49
class SelectCancelled(Exception):
 
50
 
 
51
    pass
 
52
 
 
53
 
 
54
class DiffFileView(gtk.ScrolledWindow):
 
55
    """Window for displaying diffs from a diff file"""
42
56
 
43
57
    def __init__(self):
44
58
        gtk.ScrolledWindow.__init__(self)
45
 
 
46
59
        self.construct()
47
 
        self.rev_tree = None
48
 
        self.parent_tree = None
 
60
        self._diffs = {}
49
61
 
50
62
    def construct(self):
51
63
        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
61
73
            self.buffer.set_language(gsl)
62
74
            self.buffer.set_highlight(True)
63
75
 
64
 
            sourceview = gtksourceview.SourceView(self.buffer)
 
76
            self.sourceview = gtksourceview.SourceView(self.buffer)
65
77
        else:
66
78
            self.buffer = gtk.TextBuffer()
67
 
            sourceview = gtk.TextView(self.buffer)
 
79
            self.sourceview = gtk.TextView(self.buffer)
68
80
 
69
 
        sourceview.set_editable(False)
70
 
        sourceview.modify_font(pango.FontDescription("Monospace"))
71
 
        self.add(sourceview)
72
 
        sourceview.show()
 
81
        self.sourceview.set_editable(False)
 
82
        self.sourceview.modify_font(pango.FontDescription("Monospace"))
 
83
        self.add(self.sourceview)
 
84
        self.sourceview.show()
73
85
 
74
86
    @staticmethod
75
87
    def apply_gedit_colors(lang):
134
146
 
135
147
            lang.set_tag_style(tag_id, style)
136
148
 
137
 
    @staticmethod
138
 
    def apply_colordiff_colors(lang):
 
149
    @classmethod
 
150
    def apply_colordiff_colors(klass, lang):
139
151
        """Set style colors for lang using the colordiff configuration file.
140
152
 
141
153
        Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
152
164
                except IOError, e:
153
165
                    warning('could not open file %s: %s' % (f, str(e)))
154
166
                else:
155
 
                    colors.update(DiffView.parse_colordiffrc(f))
 
167
                    colors.update(klass.parse_colordiffrc(f))
156
168
                    f.close()
157
169
 
158
170
        if not colors:
216
228
#        self.parent_tree.lock_read()
217
229
#        self.rev_tree.lock_read()
218
230
#        try:
219
 
#            self.delta = _iter_changes_to_status(self.parent_tree, self.rev_tree)
 
231
#            self.delta = iter_changes_to_status(self.parent_tree, self.rev_tree)
220
232
#            self.path_to_status = {}
221
233
#            self.path_to_diff = {}
222
234
#            source_inv = self.parent_tree.inventory
237
249
#            self.parent_tree.unlock()
238
250
 
239
251
    def show_diff(self, specific_files):
 
252
        sections = []
 
253
        if specific_files is None:
 
254
            self.buffer.set_text(self._diffs[None])
 
255
        else:
 
256
            for specific_file in specific_files:
 
257
                sections.append(self._diffs[specific_file])
 
258
            self.buffer.set_text(''.join(sections))
 
259
 
 
260
 
 
261
class DiffView(DiffFileView):
 
262
    """This is the soft and chewy filling for a DiffWindow."""
 
263
 
 
264
    def __init__(self):
 
265
        DiffFileView.__init__(self)
 
266
        self.rev_tree = None
 
267
        self.parent_tree = None
 
268
 
 
269
    def show_diff(self, specific_files):
 
270
        """Show the diff for the specified files"""
240
271
        s = StringIO()
241
272
        show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files,
242
273
                        old_label='', new_label='',
274
305
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
275
306
        self.pack1(scrollwin)
276
307
        scrollwin.show()
277
 
 
 
308
        
278
309
        self.model = gtk.TreeStore(str, str)
279
310
        self.treeview = gtk.TreeView(self.model)
280
311
        self.treeview.set_headers_visible(False)
290
321
        column.add_attribute(cell, "text", 0)
291
322
        self.treeview.append_column(column)
292
323
 
 
324
    def set_diff_text(self, lines):
 
325
        """Set the current diff from a list of lines
 
326
 
 
327
        :param lines: The diff to show, in unified diff format
 
328
        """
293
329
        # The diffs of the  selected file: a scrollable source or
294
330
        # text view
295
 
        self.diff_view = DiffView()
296
 
        self.pack2(self.diff_view)
 
331
 
 
332
    def set_diff_text_sections(self, sections):
 
333
        if getattr(self, 'diff_view', None) is None:
 
334
            self.diff_view = DiffFileView()
 
335
            self.pack2(self.diff_view)
297
336
        self.diff_view.show()
 
337
        for oldname, newname, patch in sections:
 
338
            self.diff_view._diffs[newname] = str(patch)
 
339
            if newname is None:
 
340
                newname = ''
 
341
            self.model.append(None, [oldname, newname])
 
342
        self.diff_view.show_diff(None)
298
343
 
299
344
    def set_diff(self, rev_tree, parent_tree):
300
345
        """Set the differences showed by this window.
302
347
        Compares the two trees and populates the window with the
303
348
        differences.
304
349
        """
 
350
        if getattr(self, 'diff_view', None) is None:
 
351
            self.diff_view = DiffView()
 
352
            self.pack2(self.diff_view)
 
353
        self.diff_view.show()
305
354
        self.diff_view.set_trees(rev_tree, parent_tree)
306
355
        self.rev_tree = rev_tree
307
356
        self.parent_tree = parent_tree
333
382
                self.model.append(titer, [ path, path ])
334
383
 
335
384
        self.treeview.expand_all()
 
385
        self.diff_view.show_diff(None)
336
386
 
337
387
    def set_file(self, file_path):
 
388
        """Select the current file to display"""
338
389
        tv_path = None
339
390
        for data in self.model:
340
391
            for child in data.iterchildren():
354
405
            return
355
406
        elif specific_files == [ "" ]:
356
407
            specific_files = None
357
 
 
 
408
        
358
409
        self.diff_view.show_diff(specific_files)
359
 
 
 
410
    
 
411
    def _on_wraplines_toggled(self, widget=None, wrap=False):
 
412
        """Callback for when the wrap lines checkbutton is toggled"""
 
413
        if wrap or widget.get_active():
 
414
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_WORD)
 
415
        else:
 
416
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_NONE)
360
417
 
361
418
class DiffWindow(Window):
362
419
    """Diff window.
365
422
    differences between two revisions on a branch.
366
423
    """
367
424
 
368
 
    def __init__(self, parent=None):
 
425
    def __init__(self, parent=None, operations=None):
369
426
        Window.__init__(self, parent)
370
427
        self.set_border_width(0)
371
428
        self.set_title("bzrk diff")
376
433
        width = int(monitor.width * 0.66)
377
434
        height = int(monitor.height * 0.66)
378
435
        self.set_default_size(width, height)
379
 
 
380
 
        self.construct()
381
 
 
382
 
    def construct(self):
 
436
        self.construct(operations)
 
437
 
 
438
    def construct(self, operations):
383
439
        """Construct the window contents."""
 
440
        self.vbox = gtk.VBox()
 
441
        self.add(self.vbox)
 
442
        self.vbox.show()
384
443
        self.diff = DiffWidget()
385
 
        self.add(self.diff)
 
444
        self.vbox.pack_end(self.diff, True, True, 0)
386
445
        self.diff.show_all()
 
446
        # Build after DiffWidget to connect signals
 
447
        menubar = self._get_menu_bar()
 
448
        self.vbox.pack_start(menubar, False, False, 0)
 
449
        hbox = self._get_button_bar(operations)
 
450
        if hbox is not None:
 
451
            self.vbox.pack_start(hbox, False, True, 0)
 
452
        
 
453
    
 
454
    def _get_menu_bar(self):
 
455
        menubar = gtk.MenuBar()
 
456
        # View menu
 
457
        mb_view = gtk.MenuItem(_i18n("_View"))
 
458
        mb_view_menu = gtk.Menu()
 
459
        mb_view_wrapsource = gtk.CheckMenuItem(_i18n("Wrap _Long Lines"))
 
460
        mb_view_wrapsource.connect('activate', self.diff._on_wraplines_toggled)
 
461
        mb_view_wrapsource.show()
 
462
        mb_view_menu.append(mb_view_wrapsource)
 
463
        mb_view.show()
 
464
        mb_view.set_submenu(mb_view_menu)
 
465
        mb_view.show()
 
466
        menubar.append(mb_view)
 
467
        menubar.show()
 
468
        return menubar
 
469
    
 
470
    def _get_button_bar(self, operations):
 
471
        """Return a button bar to use.
 
472
 
 
473
        :return: None, meaning that no button bar will be used.
 
474
        """
 
475
        if operations is None:
 
476
            return None
 
477
        hbox = gtk.HButtonBox()
 
478
        hbox.set_layout(gtk.BUTTONBOX_START)
 
479
        for title, method in operations:
 
480
            merge_button = gtk.Button(title)
 
481
            merge_button.show()
 
482
            merge_button.set_relief(gtk.RELIEF_NONE)
 
483
            merge_button.connect("clicked", method)
 
484
            hbox.pack_start(merge_button, expand=False, fill=True)
 
485
        hbox.show()
 
486
        return hbox
 
487
 
 
488
    def _get_merge_target(self):
 
489
        d = gtk.FileChooserDialog('Merge branch', self,
 
490
                                  gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
 
491
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
 
492
                                           gtk.STOCK_CANCEL,
 
493
                                           gtk.RESPONSE_CANCEL,))
 
494
        try:
 
495
            result = d.run()
 
496
            if result != gtk.RESPONSE_OK:
 
497
                raise SelectCancelled()
 
498
            return d.get_current_folder_uri()
 
499
        finally:
 
500
            d.destroy()
 
501
 
 
502
    def _merge_successful(self):
 
503
        # No conflicts found.
 
504
        info_dialog(_i18n('Merge successful'),
 
505
                    _i18n('All changes applied successfully.'))
 
506
 
 
507
    def _conflicts(self):
 
508
        warning_dialog(_i18n('Conflicts encountered'),
 
509
                       _i18n('Please resolve the conflicts manually'
 
510
                             ' before committing.'))
 
511
 
 
512
    def _handle_error(self, e):
 
513
        error_dialog('Error', str(e))
 
514
 
 
515
    def _get_save_path(self, basename):
 
516
        d = gtk.FileChooserDialog('Save As', self,
 
517
                                  gtk.FILE_CHOOSER_ACTION_SAVE,
 
518
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
 
519
                                           gtk.STOCK_CANCEL,
 
520
                                           gtk.RESPONSE_CANCEL,))
 
521
        d.set_current_name(basename)
 
522
        try:
 
523
            result = d.run()
 
524
            if result != gtk.RESPONSE_OK:
 
525
                raise SelectCancelled()
 
526
            return urlutils.local_path_from_url(d.get_uri())
 
527
        finally:
 
528
            d.destroy()
387
529
 
388
530
    def set_diff(self, description, rev_tree, parent_tree):
389
531
        """Set the differences showed by this window.
398
540
        self.diff.set_file(file_path)
399
541
 
400
542
 
401
 
def _iter_changes_to_status(source, target):
 
543
class DiffController(object):
 
544
 
 
545
    def __init__(self, path, patch, window=None):
 
546
        self.path = path
 
547
        self.patch = patch
 
548
        if window is None:
 
549
            window = DiffWindow(operations=self._provide_operations())
 
550
            self.initialize_window(window)
 
551
        self.window = window
 
552
 
 
553
    def initialize_window(self, window):
 
554
        window.diff.set_diff_text_sections(self.get_diff_sections())
 
555
        window.set_title(self.path + " - diff")
 
556
 
 
557
    def get_diff_sections(self):
 
558
        yield "Complete Diff", None, ''.join(self.patch)
 
559
        for patch in parse_patches(self.patch):
 
560
            oldname = patch.oldname.split('\t')[0]
 
561
            newname = patch.newname.split('\t')[0]
 
562
            yield oldname, newname, str(patch)
 
563
 
 
564
    def perform_save(self, window):
 
565
        try:
 
566
            save_path = self.window._get_save_path(osutils.basename(self.path))
 
567
        except SelectCancelled:
 
568
            return
 
569
        source = open(self.path, 'rb')
 
570
        try:
 
571
            target = open(save_path, 'wb')
 
572
            try:
 
573
                osutils.pumpfile(source, target)
 
574
            finally:
 
575
                target.close()
 
576
        finally:
 
577
            source.close()
 
578
 
 
579
    def _provide_operations(self):
 
580
        return [('Save', self.perform_save)]
 
581
 
 
582
 
 
583
class MergeDirectiveController(DiffController):
 
584
 
 
585
    def __init__(self, path, directive, window=None):
 
586
        DiffController.__init__(self, path, directive.patch.splitlines(True),
 
587
                                window)
 
588
        self.directive = directive
 
589
        self.merge_target = None
 
590
 
 
591
    def _provide_operations(self):
 
592
        return [('Merge', self.perform_merge), ('Save', self.perform_save)]
 
593
 
 
594
    def perform_merge(self, window):
 
595
        if self.merge_target is None:
 
596
            try:
 
597
                self.merge_target = self.window._get_merge_target()
 
598
            except SelectCancelled:
 
599
                return
 
600
        tree = workingtree.WorkingTree.open(self.merge_target)
 
601
        tree.lock_write()
 
602
        try:
 
603
            try:
 
604
                merger, verified = _mod_merge.Merger.from_mergeable(tree,
 
605
                    self.directive, progress.DummyProgress())
 
606
                merger.check_basis(True)
 
607
                merger.merge_type = _mod_merge.Merge3Merger
 
608
                conflict_count = merger.do_merge()
 
609
                merger.set_pending()
 
610
                if conflict_count == 0:
 
611
                    self.window._merge_successful()
 
612
                else:
 
613
                    self.window._conflicts()
 
614
                    # There are conflicts to be resolved.
 
615
                self.window.destroy()
 
616
            except Exception, e:
 
617
                self.window._handle_error(e)
 
618
        finally:
 
619
            tree.unlock()
 
620
 
 
621
 
 
622
def iter_changes_to_status(source, target):
402
623
    """Determine the differences between trees.
403
624
 
404
 
    This is a wrapper around _iter_changes which just yields more
 
625
    This is a wrapper around iter_changes which just yields more
405
626
    understandable results.
406
627
 
407
628
    :param source: The source tree (basis tree)
423
644
        source.lock_read()
424
645
        try:
425
646
            for (file_id, paths, changed_content, versioned, parent_ids, names,
426
 
                 kinds, executables) in target._iter_changes(source):
 
647
                 kinds, executables) in target.iter_changes(source):
427
648
 
428
649
                # Skip the root entry if it isn't very interesting
429
650
                if parent_ids == (None, None):