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

  • Committer: Jelmer Vernooij
  • Date: 2007-07-15 15:22:29 UTC
  • Revision ID: jelmer@samba.org-20070715152229-clmlen0vpd8d2pzx
Add docstrings, remove unused code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
conflicts.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
import subprocess
18
 
 
19
 
from gi.repository import Gtk
20
 
from gi.repository import GObject
 
17
try:
 
18
    import pygtk
 
19
    pygtk.require("2.0")
 
20
except:
 
21
    pass
 
22
 
 
23
import os
 
24
 
 
25
import gtk
 
26
import gobject
21
27
 
22
28
from bzrlib.config import GlobalConfig
23
 
from bzrlib.plugins.gtk.i18n import _i18n
24
 
from bzrlib.plugins.gtk.dialog import (
25
 
    error_dialog,
26
 
    warning_dialog,
27
 
    )
28
 
 
29
 
 
30
 
class ConflictsDialog(Gtk.Dialog):
 
29
 
 
30
from dialog import error_dialog, warning_dialog
 
31
from errors import show_bzr_error
 
32
 
 
33
class ConflictsDialog(gtk.Dialog):
31
34
    """ This dialog displays the list of conflicts. """
32
 
 
33
35
    def __init__(self, wt, parent=None):
34
36
        """ Initialize the Conflicts dialog. """
35
 
        super(ConflictsDialog, self).__init__(
36
 
            title="Conflicts - Olive", parent=parent, flags=0,
37
 
            buttons=(Gtk.STOCK_CLOSE, Gtk.ResponseType.CANCEL))
38
 
 
 
37
        gtk.Dialog.__init__(self, title="Conflicts - Olive",
 
38
                                  parent=parent,
 
39
                                  flags=0,
 
40
                                  buttons=(gtk.STOCK_CLOSE, gtk.RESPONSE_CANCEL))
 
41
        
39
42
        # Get arguments
40
43
        self.wt = wt
41
 
 
 
44
        
42
45
        # Create the widgets
43
 
        self._scrolledwindow = Gtk.ScrolledWindow()
44
 
        self._treeview = Gtk.TreeView()
45
 
        self._label_diff3 = Gtk.Label(label=_i18n("External utility:"))
46
 
        self._entry_diff3 = Gtk.Entry()
47
 
        self._image_diff3 = Gtk.Image()
48
 
        self._button_diff3 = Gtk.Button()
49
 
        self._hbox_diff3 = Gtk.HBox()
50
 
 
 
46
        self._scrolledwindow = gtk.ScrolledWindow()
 
47
        self._treeview = gtk.TreeView()
 
48
        self._label_diff3 = gtk.Label(_("External utility:"))
 
49
        self._entry_diff3 = gtk.Entry()
 
50
        self._image_diff3 = gtk.Image()
 
51
        self._button_diff3 = gtk.Button()
 
52
        self._hbox_diff3 = gtk.HBox()
 
53
        
51
54
        # Set callbacks
52
55
        self._button_diff3.connect('clicked', self._on_diff3_clicked)
53
 
 
 
56
        
54
57
        # Set properties
55
 
        self._scrolledwindow.set_policy(Gtk.PolicyType.AUTOMATIC,
56
 
                                        Gtk.PolicyType.AUTOMATIC)
57
 
        self._image_diff3.set_from_stock(Gtk.STOCK_APPLY, Gtk.IconSize.BUTTON)
 
58
        self._scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC,
 
59
                                        gtk.POLICY_AUTOMATIC)
 
60
        self._image_diff3.set_from_stock(gtk.STOCK_APPLY, gtk.ICON_SIZE_BUTTON)
58
61
        self._button_diff3.set_image(self._image_diff3)
59
62
        self._entry_diff3.set_text(self._get_diff3())
60
63
        self._hbox_diff3.set_spacing(3)
61
 
        content_area = self.get_content_area()
62
 
        content_area.set_spacing(3)
 
64
        self.vbox.set_spacing(3)
63
65
        self.set_default_size(400, 300)
64
 
 
 
66
        
65
67
        # Construct dialog
66
 
        self._hbox_diff3.pack_start(self._label_diff3, False, False, 0)
67
 
        self._hbox_diff3.pack_start(self._entry_diff3, True, True, 0)
68
 
        self._hbox_diff3.pack_start(self._button_diff3, False, False, 0)
 
68
        self._hbox_diff3.pack_start(self._label_diff3, False, False)
 
69
        self._hbox_diff3.pack_start(self._entry_diff3, True, True)
 
70
        self._hbox_diff3.pack_start(self._button_diff3, False, False)
69
71
        self._scrolledwindow.add(self._treeview)
70
 
        content_area.pack_start(self._scrolledwindow, True, True, 0)
71
 
        content_area.pack_start(self._hbox_diff3, False, False, 0)
72
 
 
 
72
        self.vbox.pack_start(self._scrolledwindow, True, True)
 
73
        self.vbox.pack_start(self._hbox_diff3, False, False)
 
74
        
73
75
        # Create the conflict list
74
76
        self._create_conflicts()
75
 
 
 
77
        
76
78
        # Show the dialog
77
 
        content_area.show_all()
78
 
 
 
79
        self.vbox.show_all()
 
80
    
79
81
    def _get_diff3(self):
80
82
        """ Get the specified diff3 utility. Default is meld. """
81
83
        config = GlobalConfig()
83
85
        if diff3 is None:
84
86
            diff3 = 'meld'
85
87
        return diff3
86
 
 
 
88
    
87
89
    def _set_diff3(self, cmd):
88
90
        """ Set the default diff3 utility to cmd. """
89
91
        config = GlobalConfig()
90
92
        config.set_user_option('gconflicts_diff3', cmd)
91
 
 
 
93
    
92
94
    def _create_conflicts(self):
93
95
        """ Construct the list of conflicts. """
94
96
        if len(self.wt.conflicts()) == 0:
95
 
            self.model = Gtk.ListStore(GObject.TYPE_STRING)
 
97
            self.model = gtk.ListStore(gobject.TYPE_STRING)
96
98
            self._treeview.set_model(self.model)
97
 
            self._treeview.append_column(Gtk.TreeViewColumn(_i18n('Conflicts'),
98
 
                                         Gtk.CellRendererText(), text=0))
99
 
            self._treeview.set_headers_visible(False)
100
 
            self.model.append([ _i18n("No conflicts in working tree.") ])
101
 
            self._button_diff3.set_sensitive(False)
 
99
            self._treeview.append_column(gtk.TreeViewColumn(_('Conflicts'),
 
100
                                         gtk.CellRendererText(), text=0))
 
101
            self._treeview.set_headers_visible(False)            
 
102
            self.model.append([ _("No conflicts in working tree.") ])
102
103
        else:
103
 
            self.model = Gtk.ListStore(GObject.TYPE_STRING,
104
 
                                       GObject.TYPE_STRING,
105
 
                                       GObject.TYPE_STRING)
 
104
            self.model = gtk.ListStore(gobject.TYPE_STRING,
 
105
                                       gobject.TYPE_STRING,
 
106
                                       gobject.TYPE_STRING)
106
107
            self._treeview.set_model(self.model)
107
 
            self._treeview.append_column(Gtk.TreeViewColumn(_i18n('Path'),
108
 
                                         Gtk.CellRendererText(), text=0))
109
 
            self._treeview.append_column(Gtk.TreeViewColumn(_i18n('Type'),
110
 
                                         Gtk.CellRendererText(), text=1))
 
108
            self._treeview.append_column(gtk.TreeViewColumn(_('Path'),
 
109
                                         gtk.CellRendererText(), text=0))
 
110
            self._treeview.append_column(gtk.TreeViewColumn(_('Type'),
 
111
                                         gtk.CellRendererText(), text=1))
111
112
            self._treeview.set_search_column(0)
112
113
            for conflict in self.wt.conflicts():
113
114
                if conflict.typestring == 'path conflict':
114
 
                    t = _i18n("path conflict")
 
115
                    t = _("path conflict")
115
116
                elif conflict.typestring == 'contents conflict':
116
 
                    t = _i18n("contents conflict")
 
117
                    t = _("contents conflict")
117
118
                elif conflict.typestring == 'text conflict':
118
 
                    t = _i18n("text conflict")
 
119
                    t = _("text conflict")
119
120
                elif conflict.typestring == 'duplicate id':
120
 
                    t = _i18n("duplicate id")
 
121
                    t = _("duplicate id")
121
122
                elif conflict.typestring == 'duplicate':
122
 
                    t = _i18n("duplicate")
 
123
                    t = _("duplicate")
123
124
                elif conflict.typestring == 'parent loop':
124
 
                    t = _i18n("parent loop")
 
125
                    t = _("parent loop")
125
126
                elif conflict.typestring == 'unversioned parent':
126
 
                    t = _i18n("unversioned parent")
 
127
                    t = _("unversioned parent")
127
128
                elif conflict.typestring == 'missing parent':
128
 
                    t = _i18n("missing parent")
 
129
                    t = _("missing parent")
129
130
                elif conflict.typestring == 'deleting parent':
130
 
                    t = _i18n("deleting parent")
 
131
                    t = _("deleting parent")
131
132
                else:
132
 
                    t = _i18n("unknown type of conflict")
133
 
 
134
 
                self.model.append([ conflict.path, t, conflict.typestring ])
135
 
 
 
133
                    t = _("unknown type of conflict")
 
134
                
 
135
                self.model.append([ conflict.path, t, conflict.typestring ]) 
 
136
    
136
137
    def _get_selected_file(self):
137
138
        """ Return the selected conflict's filename. """
138
139
        treeselection = self._treeview.get_selection()
139
140
        (model, iter) = treeselection.get_selected()
140
 
 
 
141
        
141
142
        if iter is None:
142
143
            return None
143
144
        else:
144
145
            return model.get_value(iter, 0)
145
 
 
 
146
    
146
147
    def _get_selected_type(self):
147
148
        """ Return the type of the selected conflict. """
148
149
        treeselection = self._treeview.get_selection()
149
150
        (model, iter) = treeselection.get_selected()
150
 
 
 
151
        
151
152
        if iter is None:
152
153
            return None
153
154
        else:
154
155
            return model.get_value(iter, 2)
155
 
 
 
156
    
156
157
    def _on_diff3_clicked(self, widget):
157
158
        """ Launch external utility to resolve conflicts. """
158
159
        self._set_diff3(self._entry_diff3.get_text())
159
160
        selected = self._get_selected_file()
160
161
        if selected is None:
161
 
            error_dialog(_i18n('No file was selected'),
162
 
                         _i18n('Please select a file from the list.'))
 
162
            error_dialog(_('No file was selected'),
 
163
                         _('Please select a file from the list.'))
163
164
            return
164
165
        elif self._get_selected_type() == 'text conflict':
165
166
            base = self.wt.abspath(selected) + '.BASE'
166
167
            this = self.wt.abspath(selected) + '.THIS'
167
168
            other = self.wt.abspath(selected) + '.OTHER'
168
 
            try:
169
 
                p = subprocess.Popen([ self._entry_diff3.get_text(), base, this, other ])
170
 
                p.wait()
171
 
            except OSError, e:
172
 
                warning_dialog(_i18n('Call to external utility failed'), str(e))
 
169
            os.system(self._entry_diff3.get_text() + ' ' + base + ' ' + this + ' ' + other)
173
170
        else:
174
 
            warning_dialog(_i18n('Cannot resolve conflict'),
175
 
                           _i18n('Only conflicts on the text of files can be resolved with Olive at the moment. Content conflicts, on the structure of the tree, need to be resolved using the command line.'))
 
171
            warning_dialog(_('Cannot resolve conflict'),
 
172
                           _('Only conflicts on the text of files can be resolved with Olive at the moment. Content conflicts, on the structure of the tree, need to be resolved using the command line.'))
176
173
            return