/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: 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:
diff.py
73
73
            self.buffer.set_language(gsl)
74
74
            self.buffer.set_highlight(True)
75
75
 
76
 
            self.sourceview = gtksourceview.SourceView(self.buffer)
 
76
            sourceview = gtksourceview.SourceView(self.buffer)
77
77
        else:
78
78
            self.buffer = gtk.TextBuffer()
79
 
            self.sourceview = gtk.TextView(self.buffer)
 
79
            sourceview = gtk.TextView(self.buffer)
80
80
 
81
 
        self.sourceview.set_editable(False)
82
 
        self.sourceview.modify_font(pango.FontDescription("Monospace"))
83
 
        self.add(self.sourceview)
84
 
        self.sourceview.show()
 
81
        sourceview.set_editable(False)
 
82
        sourceview.modify_font(pango.FontDescription("Monospace"))
 
83
        self.add(sourceview)
 
84
        sourceview.show()
85
85
 
86
86
    @staticmethod
87
87
    def apply_gedit_colors(lang):
305
305
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
306
306
        self.pack1(scrollwin)
307
307
        scrollwin.show()
308
 
        
 
308
 
309
309
        self.model = gtk.TreeStore(str, str)
310
310
        self.treeview = gtk.TreeView(self.model)
311
311
        self.treeview.set_headers_visible(False)
328
328
        """
329
329
        # The diffs of the  selected file: a scrollable source or
330
330
        # text 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)
 
331
        self.diff_view = DiffFileView()
336
332
        self.diff_view.show()
337
 
        for oldname, newname, patch in sections:
 
333
        self.pack2(self.diff_view)
 
334
        self.model.append(None, [ "Complete Diff", "" ])
 
335
        self.diff_view._diffs[None] = ''.join(lines)
 
336
        for patch in parse_patches(lines):
 
337
            oldname = patch.oldname.split('\t')[0]
 
338
            newname = patch.newname.split('\t')[0]
 
339
            self.model.append(None, [oldname, newname])
338
340
            self.diff_view._diffs[newname] = str(patch)
339
 
            if newname is None:
340
 
                newname = ''
341
 
            self.model.append(None, [oldname, newname])
342
341
        self.diff_view.show_diff(None)
343
342
 
344
343
    def set_diff(self, rev_tree, parent_tree):
347
346
        Compares the two trees and populates the window with the
348
347
        differences.
349
348
        """
350
 
        if getattr(self, 'diff_view', None) is None:
351
 
            self.diff_view = DiffView()
352
 
            self.pack2(self.diff_view)
 
349
        self.diff_view = DiffView()
 
350
        self.pack2(self.diff_view)
353
351
        self.diff_view.show()
354
352
        self.diff_view.set_trees(rev_tree, parent_tree)
355
353
        self.rev_tree = rev_tree
382
380
                self.model.append(titer, [ path, path ])
383
381
 
384
382
        self.treeview.expand_all()
385
 
        self.diff_view.show_diff(None)
386
383
 
387
384
    def set_file(self, file_path):
388
385
        """Select the current file to display"""
405
402
            return
406
403
        elif specific_files == [ "" ]:
407
404
            specific_files = None
408
 
        
 
405
 
409
406
        self.diff_view.show_diff(specific_files)
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)
 
407
 
417
408
 
418
409
class DiffWindow(Window):
419
410
    """Diff window.
422
413
    differences between two revisions on a branch.
423
414
    """
424
415
 
425
 
    def __init__(self, parent=None, operations=None):
 
416
    def __init__(self, parent=None):
426
417
        Window.__init__(self, parent)
427
418
        self.set_border_width(0)
428
419
        self.set_title("bzrk diff")
433
424
        width = int(monitor.width * 0.66)
434
425
        height = int(monitor.height * 0.66)
435
426
        self.set_default_size(width, height)
436
 
        self.construct(operations)
437
 
 
438
 
    def construct(self, operations):
 
427
 
 
428
        self.construct()
 
429
 
 
430
    def construct(self):
439
431
        """Construct the window contents."""
440
432
        self.vbox = gtk.VBox()
441
433
        self.add(self.vbox)
442
434
        self.vbox.show()
 
435
        hbox = self._get_button_bar()
 
436
        if hbox is not None:
 
437
            self.vbox.pack_start(hbox, expand=False, fill=True)
443
438
        self.diff = DiffWidget()
444
 
        self.vbox.pack_end(self.diff, True, True, 0)
 
439
        self.vbox.add(self.diff)
445
440
        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):
 
441
 
 
442
    def _get_button_bar(self):
471
443
        """Return a button bar to use.
472
444
 
473
445
        :return: None, meaning that no button bar will be used.
474
446
        """
475
 
        if operations is None:
476
 
            return None
 
447
        return None
 
448
 
 
449
    def set_diff_text(self, description, lines):
 
450
        """Set the diff from a text.
 
451
 
 
452
        The diff must be in unified diff format, and will be parsed to
 
453
        determine filenames.
 
454
        """
 
455
        self.diff.set_diff_text(lines)
 
456
        self.set_title(description + " - bzrk diff")
 
457
 
 
458
    def set_diff(self, description, rev_tree, parent_tree):
 
459
        """Set the differences showed by this window.
 
460
 
 
461
        Compares the two trees and populates the window with the
 
462
        differences.
 
463
        """
 
464
        self.diff.set_diff(rev_tree, parent_tree)
 
465
        self.set_title(description + " - bzrk diff")
 
466
 
 
467
    def set_file(self, file_path):
 
468
        self.diff.set_file(file_path)
 
469
 
 
470
 
 
471
class MergeDirectiveWindow(DiffWindow):
 
472
 
 
473
    def __init__(self, directive, path):
 
474
        DiffWindow.__init__(self, None)
 
475
        self._merge_target = None
 
476
        self.directive = directive
 
477
        self.path = path
 
478
 
 
479
    def _get_button_bar(self):
 
480
        """The button bar has only the Merge button"""
 
481
        merge_button = gtk.Button('Merge')
 
482
        merge_button.show()
 
483
        merge_button.set_relief(gtk.RELIEF_NONE)
 
484
        merge_button.connect("clicked", self.perform_merge)
 
485
 
 
486
        save_button = gtk.Button('Save')
 
487
        save_button.show()
 
488
        save_button.set_relief(gtk.RELIEF_NONE)
 
489
        save_button.connect("clicked", self.perform_save)
 
490
 
477
491
        hbox = gtk.HButtonBox()
478
492
        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)
 
493
        hbox.pack_start(merge_button, expand=False, fill=True)
 
494
        hbox.pack_start(save_button, expand=False, fill=True)
485
495
        hbox.show()
486
496
        return hbox
487
497
 
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()
529
 
 
530
 
    def set_diff(self, description, rev_tree, parent_tree):
531
 
        """Set the differences showed by this window.
532
 
 
533
 
        Compares the two trees and populates the window with the
534
 
        differences.
535
 
        """
536
 
        self.diff.set_diff(rev_tree, parent_tree)
537
 
        self.set_title(description + " - bzrk diff")
538
 
 
539
 
    def set_file(self, file_path):
540
 
        self.diff.set_file(file_path)
541
 
 
542
 
 
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
498
    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)
 
499
        try:
 
500
            tree = self._get_merge_target()
 
501
        except SelectCancelled:
 
502
            return
601
503
        tree.lock_write()
602
504
        try:
603
505
            try:
608
510
                conflict_count = merger.do_merge()
609
511
                merger.set_pending()
610
512
                if conflict_count == 0:
611
 
                    self.window._merge_successful()
 
513
                    # No conflicts found.
 
514
                    info_dialog(_i18n('Merge successful'),
 
515
                                _i18n('All changes applied successfully.'))
612
516
                else:
613
 
                    self.window._conflicts()
614
517
                    # There are conflicts to be resolved.
615
 
                self.window.destroy()
 
518
                    warning_dialog(_i18n('Conflicts encountered'),
 
519
                                   _i18n('Please resolve the conflicts manually'
 
520
                                         ' before committing.'))
 
521
                self.destroy()
616
522
            except Exception, e:
617
 
                self.window._handle_error(e)
 
523
                error_dialog('Error', str(e))
618
524
        finally:
619
525
            tree.unlock()
620
526
 
 
527
    def _get_merge_target(self):
 
528
        if self._merge_target is not None:
 
529
            return self._merge_target
 
530
        d = gtk.FileChooserDialog('Merge branch', self,
 
531
                                  gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
 
532
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
 
533
                                           gtk.STOCK_CANCEL,
 
534
                                           gtk.RESPONSE_CANCEL,))
 
535
        try:
 
536
            result = d.run()
 
537
            if result != gtk.RESPONSE_OK:
 
538
                raise SelectCancelled()
 
539
            uri = d.get_current_folder_uri()
 
540
        finally:
 
541
            d.destroy()
 
542
        return workingtree.WorkingTree.open(uri)
 
543
 
 
544
    def perform_save(self, window):
 
545
        d = gtk.FileChooserDialog('Save As', self,
 
546
                                  gtk.FILE_CHOOSER_ACTION_SAVE,
 
547
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
 
548
                                           gtk.STOCK_CANCEL,
 
549
                                           gtk.RESPONSE_CANCEL,))
 
550
        d.set_current_name(osutils.basename(self.path))
 
551
        try:
 
552
            try:
 
553
                result = d.run()
 
554
                if result != gtk.RESPONSE_OK:
 
555
                    raise SelectCancelled()
 
556
                uri = d.get_uri()
 
557
            finally:
 
558
                d.destroy()
 
559
        except SelectCancelled:
 
560
            return
 
561
        source = open(self.path, 'rb')
 
562
        try:
 
563
            target = open(urlutils.local_path_from_url(uri), 'wb')
 
564
            try:
 
565
                target.write(source.read())
 
566
            finally:
 
567
                target.close()
 
568
        finally:
 
569
            source.close()
 
570
 
621
571
 
622
572
def iter_changes_to_status(source, target):
623
573
    """Determine the differences between trees.