/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: Mikkel Kamstrup Erlandsen
  • Date: 2011-09-28 07:45:39 UTC
  • mto: This revision was merged to the branch mainline in revision 740.
  • Revision ID: mikkel.kamstrup@gmail.com-20110928074539-qxl1yn1bkjel6ir0
https://launchpad.net/bugs/861201
Add X-GNOME-Autostart-Delay=30 to bzr-notify.desktop

Show diffs side-by-side

added added

removed removed

Lines of Context:
diff.py
10
10
 
11
11
from cStringIO import StringIO
12
12
 
13
 
from gi.repository import Gtk
14
 
from gi.repository import Pango
 
13
import pygtk
 
14
pygtk.require("2.0")
 
15
import gtk
 
16
import pango
15
17
import os
16
18
import re
17
19
import sys
22
24
    from elementtree.ElementTree import Element, SubElement, tostring
23
25
 
24
26
try:
25
 
    from gi.repository import GtkSource
 
27
    import gtksourceview2
26
28
    have_gtksourceview = True
27
29
except ImportError:
28
30
    have_gtksourceview = False
29
31
try:
30
 
    from gi.repository import GConf
 
32
    import gconf
31
33
    have_gconf = True
32
34
except ImportError:
33
35
    have_gconf = False
64
66
    pass
65
67
 
66
68
 
67
 
class DiffFileView(Gtk.ScrolledWindow):
 
69
class DiffFileView(gtk.ScrolledWindow):
68
70
    """Window for displaying diffs from a diff file"""
69
71
 
70
72
    def __init__(self):
71
 
        super(DiffFileView, self).__init__()
 
73
        gtk.ScrolledWindow.__init__(self)
72
74
        self.construct()
73
75
        self._diffs = {}
74
76
 
75
77
    def construct(self):
76
 
        self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
77
 
        self.set_shadow_type(Gtk.ShadowType.IN)
 
78
        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
79
        self.set_shadow_type(gtk.SHADOW_IN)
78
80
 
79
81
        if have_gtksourceview:
80
 
            self.buffer = GtkSource.Buffer()
81
 
            lang_manager = GtkSource.LanguageManager.get_default()
82
 
            language = lang_manager.guess_language(None, "text/x-patch")
 
82
            self.buffer = gtksourceview2.Buffer()
 
83
            slm = gtksourceview2.LanguageManager()
 
84
            guess_language = getattr(gtksourceview2.LanguageManager, 
 
85
                "guess_language", fallback_guess_language)
 
86
            gsl = guess_language(slm, content_type="text/x-patch")
83
87
            if have_gconf:
84
88
                self.apply_gedit_colors(self.buffer)
85
89
            self.apply_colordiff_colors(self.buffer)
86
 
            self.buffer.set_language(language)
 
90
            self.buffer.set_language(gsl)
87
91
            self.buffer.set_highlight_syntax(True)
88
92
 
89
 
            self.sourceview = GtkSource.View(buffer=self.buffer)
 
93
            self.sourceview = gtksourceview2.View(self.buffer)
90
94
        else:
91
 
            self.buffer = Gtk.TextBuffer()
92
 
            self.sourceview = Gtk.TextView(self.buffer)
 
95
            self.buffer = gtk.TextBuffer()
 
96
            self.sourceview = gtk.TextView(self.buffer)
93
97
 
94
98
        self.sourceview.set_editable(False)
95
 
        self.sourceview.modify_font(Pango.FontDescription("Monospace"))
 
99
        self.sourceview.modify_font(pango.FontDescription("Monospace"))
96
100
        self.add(self.sourceview)
97
101
        self.sourceview.show()
98
102
 
102
106
 
103
107
        This method needs the gconf module.
104
108
 
105
 
        :param buf: a GtkSource.Buffer object.
 
109
        :param buf: a gtksourceview2.Buffer object.
106
110
        """
107
111
        GEDIT_SCHEME_PATH = '/apps/gedit-2/preferences/editor/colors/scheme'
108
112
        GEDIT_USER_STYLES_PATH = os.path.expanduser('~/.gnome2/gedit/styles')
109
113
 
110
 
        client = GConf.Client.get_default()
 
114
        client = gconf.client_get_default()
111
115
        style_scheme_name = client.get_string(GEDIT_SCHEME_PATH)
112
116
        if style_scheme_name is not None:
113
 
            style_scheme_mgr = GtkSource.StyleSchemeManager()
 
117
            style_scheme_mgr = gtksourceview2.StyleSchemeManager()
114
118
            style_scheme_mgr.append_search_path(GEDIT_USER_STYLES_PATH)
115
119
            
116
120
            style_scheme = style_scheme_mgr.get_scheme(style_scheme_name)
124
128
 
125
129
        Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
126
130
 
127
 
        :param buf: a "Diff" GtkSource.Buffer object.
 
131
        :param buf: a "Diff" gtksourceview2.Buffer object.
128
132
        """
129
 
        scheme_manager = GtkSource.StyleSchemeManager()
 
133
        scheme_manager = gtksourceview2.StyleSchemeManager()
130
134
        style_scheme = scheme_manager.get_scheme('colordiff')
131
135
        
132
136
        # if style scheme not found, we'll generate it from colordiffrc
250
254
    """This is the soft and chewy filling for a DiffWindow."""
251
255
 
252
256
    def __init__(self):
253
 
        super(DiffView, self).__init__()
 
257
        DiffFileView.__init__(self)
254
258
        self.rev_tree = None
255
259
        self.parent_tree = None
256
260
 
280
284
        self.buffer.set_text(decoded.encode('UTF-8'))
281
285
 
282
286
 
283
 
class DiffWidget(Gtk.HPaned):
 
287
class DiffWidget(gtk.HPaned):
284
288
    """Diff widget
285
289
 
286
290
    """
288
292
        super(DiffWidget, self).__init__()
289
293
 
290
294
        # The file hierarchy: a scrollable treeview
291
 
        scrollwin = Gtk.ScrolledWindow()
292
 
        scrollwin.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
293
 
        scrollwin.set_shadow_type(Gtk.ShadowType.IN)
 
295
        scrollwin = gtk.ScrolledWindow()
 
296
        scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
 
297
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
294
298
        self.pack1(scrollwin)
295
299
        scrollwin.show()
296
300
        
297
 
        self.model = Gtk.TreeStore(str, str)
298
 
        self.treeview = Gtk.TreeView(model=self.model)
 
301
        self.model = gtk.TreeStore(str, str)
 
302
        self.treeview = gtk.TreeView(self.model)
299
303
        self.treeview.set_headers_visible(False)
300
304
        self.treeview.set_search_column(1)
301
305
        self.treeview.connect("cursor-changed", self._treeview_cursor_cb)
302
306
        scrollwin.add(self.treeview)
303
307
        self.treeview.show()
304
308
 
305
 
        cell = Gtk.CellRendererText()
 
309
        cell = gtk.CellRendererText()
306
310
        cell.set_property("width-chars", 20)
307
 
        column = Gtk.TreeViewColumn()
308
 
        column.pack_start(cell, True)
 
311
        column = gtk.TreeViewColumn()
 
312
        column.pack_start(cell, expand=True)
309
313
        column.add_attribute(cell, "text", 0)
310
314
        self.treeview.append_column(column)
311
315
 
382
386
                    break
383
387
        if tv_path is None:
384
388
            raise errors.NoSuchFile(file_path)
385
 
        self.treeview.set_cursor(tv_path, None, False)
 
389
        self.treeview.set_cursor(tv_path)
386
390
        self.treeview.scroll_to_cell(tv_path)
387
391
 
388
392
    def _treeview_cursor_cb(self, *args):
399
403
    def _on_wraplines_toggled(self, widget=None, wrap=False):
400
404
        """Callback for when the wrap lines checkbutton is toggled"""
401
405
        if wrap or widget.get_active():
402
 
            self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.WORD)
 
406
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_WORD)
403
407
        else:
404
 
            self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.NONE)
 
408
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_NONE)
405
409
 
406
410
class DiffWindow(Window):
407
411
    """Diff window.
411
415
    """
412
416
 
413
417
    def __init__(self, parent=None, operations=None):
414
 
        super(DiffWindow, self).__init__(parent=parent)
 
418
        Window.__init__(self, parent)
415
419
        self.set_border_width(0)
416
420
        self.set_title("bzrk diff")
417
421
 
425
429
 
426
430
    def construct(self, operations):
427
431
        """Construct the window contents."""
428
 
        self.vbox = Gtk.VBox()
 
432
        self.vbox = gtk.VBox()
429
433
        self.add(self.vbox)
430
434
        self.vbox.show()
431
435
        self.diff = DiffWidget()
440
444
        
441
445
    
442
446
    def _get_menu_bar(self):
443
 
        menubar = Gtk.MenuBar()
 
447
        menubar = gtk.MenuBar()
444
448
        # View menu
445
 
        mb_view = Gtk.MenuItem.new_with_mnemonic(_i18n("_View"))
446
 
        mb_view_menu = Gtk.Menu()
447
 
        mb_view_wrapsource = Gtk.CheckMenuItem.new_with_mnemonic(
448
 
            _i18n("Wrap _Long Lines"))
 
449
        mb_view = gtk.MenuItem(_i18n("_View"))
 
450
        mb_view_menu = gtk.Menu()
 
451
        mb_view_wrapsource = gtk.CheckMenuItem(_i18n("Wrap _Long Lines"))
449
452
        mb_view_wrapsource.connect('activate', self.diff._on_wraplines_toggled)
450
453
        mb_view_wrapsource.show()
451
454
        mb_view_menu.append(mb_view_wrapsource)
463
466
        """
464
467
        if operations is None:
465
468
            return None
466
 
        hbox = Gtk.HButtonBox()
467
 
        hbox.set_layout(Gtk.ButtonBoxStyle.START)
 
469
        hbox = gtk.HButtonBox()
 
470
        hbox.set_layout(gtk.BUTTONBOX_START)
468
471
        for title, method in operations:
469
 
            merge_button = Gtk.Button(title)
 
472
            merge_button = gtk.Button(title)
470
473
            merge_button.show()
471
 
            merge_button.set_relief(Gtk.ReliefStyle.NONE)
 
474
            merge_button.set_relief(gtk.RELIEF_NONE)
472
475
            merge_button.connect("clicked", method)
473
476
            hbox.pack_start(merge_button, expand=False, fill=True)
474
477
        hbox.show()
475
478
        return hbox
476
479
 
477
480
    def _get_merge_target(self):
478
 
        d = Gtk.FileChooserDialog('Merge branch', self,
479
 
                                  Gtk.FileChooserAction.SELECT_FOLDER,
480
 
                                  buttons=(Gtk.STOCK_OK, Gtk.ResponseType.OK,
481
 
                                           Gtk.STOCK_CANCEL,
482
 
                                           Gtk.ResponseType.CANCEL,))
 
481
        d = gtk.FileChooserDialog('Merge branch', self,
 
482
                                  gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
 
483
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
 
484
                                           gtk.STOCK_CANCEL,
 
485
                                           gtk.RESPONSE_CANCEL,))
483
486
        try:
484
487
            result = d.run()
485
 
            if result != Gtk.ResponseType.OK:
 
488
            if result != gtk.RESPONSE_OK:
486
489
                raise SelectCancelled()
487
490
            return d.get_current_folder_uri()
488
491
        finally:
502
505
        error_dialog('Error', str(e))
503
506
 
504
507
    def _get_save_path(self, basename):
505
 
        d = Gtk.FileChooserDialog('Save As', self,
506
 
                                  Gtk.FileChooserAction.SAVE,
507
 
                                  buttons=(Gtk.STOCK_OK, Gtk.ResponseType.OK,
508
 
                                           Gtk.STOCK_CANCEL,
509
 
                                           Gtk.ResponseType.CANCEL,))
 
508
        d = gtk.FileChooserDialog('Save As', self,
 
509
                                  gtk.FILE_CHOOSER_ACTION_SAVE,
 
510
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
 
511
                                           gtk.STOCK_CANCEL,
 
512
                                           gtk.RESPONSE_CANCEL,))
510
513
        d.set_current_name(basename)
511
514
        try:
512
515
            result = d.run()
513
 
            if result != Gtk.ResponseType.OK:
 
516
            if result != gtk.RESPONSE_OK:
514
517
                raise SelectCancelled()
515
518
            return urlutils.local_path_from_url(d.get_uri())
516
519
        finally:
578
581
class MergeDirectiveController(DiffController):
579
582
 
580
583
    def __init__(self, path, directive, window=None):
581
 
        super(MergeDirectiveController, self).__init__(
582
 
            path, directive.patch.splitlines(True), window)
 
584
        DiffController.__init__(self, path, directive.patch.splitlines(True),
 
585
                                window)
583
586
        self.directive = directive
584
587
        self.merge_target = None
585
588