/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 nautilus-bzr.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:
nautilus-bzr.py
 
1
# Trivial Bazaar plugin for Nautilus
 
2
#
 
3
# Copyright (C) 2006 Jeff Bailey
 
4
# Copyright (C) 2006 Wouter van Heyst
 
5
# Copyright (C) 2006-2008 Jelmer Vernooij <jelmer@samba.org>
 
6
#
 
7
# Published under the GNU GPL
 
8
 
 
9
import gtk
1
10
import nautilus
2
11
import bzrlib
 
12
from bzrlib.branch import Branch
3
13
from bzrlib.bzrdir import BzrDir
4
 
from bzrlib.errors import NotBranchError
 
14
from bzrlib.errors import NotBranchError, NoWorkingTree, UnsupportedProtocol
 
15
from bzrlib.tree import file_status
5
16
from bzrlib.workingtree import WorkingTree
 
17
from bzrlib.config import GlobalConfig
6
18
 
7
19
from bzrlib.plugin import load_plugins
8
20
load_plugins()
9
21
 
10
 
from bzrlib.plugins.gtk import cmd_visualise, cmd_gannotate
 
22
from bzrlib.plugins.gtk import _i18n, cmd_visualise, cmd_gannotate
11
23
 
12
 
class BzrExtension(nautilus.MenuProvider):
 
24
class BzrExtension(nautilus.MenuProvider, nautilus.ColumnProvider, nautilus.InfoProvider):
13
25
    def __init__(self):
14
26
        pass
15
27
 
69
81
        except NotBranchError:
70
82
            return
71
83
 
72
 
        from bzrlib.plugins.gtk.viz.diffwin import DiffWindow
 
84
        from bzrlib.plugins.gtk.diff import DiffWindow
73
85
        window = DiffWindow()
74
 
        window.set_diff(tree.branch, tree, tree.branch.revision_tree())
 
86
        window.set_diff(tree.branch.nick, tree, tree.branch.basis_tree())
75
87
        window.show()
76
88
 
77
89
        return
87
99
        try:
88
100
            tree, path = WorkingTree.open_containing(file)
89
101
        except NotBranchError:
90
 
            BzrDir.create_branch_and_repo(file)
 
102
            BzrDir.create_standalone_workingtree(file)
91
103
 
92
104
    def remove_cb(self, menu, vfs_file):
93
105
        # We can only cope with local files
117
129
        if vfs_file.get_uri_scheme() != 'file':
118
130
            return
119
131
 
120
 
        file = vfs_file.get_uri()
121
 
        try:
122
 
            tree, path = WorkingTree.open_containing(file)
123
 
        except NotBranchError:
124
 
            return
125
 
 
126
 
        from bzrlib.plugins.gtk.clone import CloneDialog
127
 
        dialog = CloneDialog(file)
128
 
        if dialog.run() != gtk.RESPONSE_CANCEL:
129
 
            bzrdir = BzrDir.open(dialog.url)
130
 
            bzrdir.sprout(dialog.dest_path)
 
132
        from bzrlib.plugins.gtk.branch import BranchDialog
 
133
        
 
134
        dialog = BranchDialog(vfs_file.get_name())
 
135
        response = dialog.run()
 
136
        if response != gtk.RESPONSE_NONE:
 
137
            dialog.hide()
 
138
            dialog.destroy()
131
139
 
132
140
    def commit_cb(self, menu, vfs_file=None):
133
141
        # We can only cope with local files
135
143
            return
136
144
 
137
145
        file = vfs_file.get_uri()
 
146
        tree = None
 
147
        branch = None
138
148
        try:
139
149
            tree, path = WorkingTree.open_containing(file)
140
 
        except NotBranchError:
141
 
            return
 
150
            branch = tree.branch
 
151
        except NotBranchError, e:
 
152
            path = e.path
 
153
            #return
 
154
        except NoWorkingTree, e:
 
155
            path = e.base
 
156
            try:
 
157
                (branch, path) = Branch.open_containing(path)
 
158
            except NotBranchError, e:
 
159
                path = e.path
142
160
 
143
 
        from bzrlib.plugins.gtk.commit import GCommitDialog
144
 
        dialog = GCommitDialog(tree)
145
 
        dialog.set_title(path + " - Commit")
146
 
        if dialog.run() != gtk.RESPONSE_CANCEL:
147
 
            Commit().commit(working_tree=wt,message=dialog.message,
148
 
                            specific_files=dialog.specific_files)
 
161
        from bzrlib.plugins.gtk.commit import CommitDialog
 
162
        dialog = CommitDialog(tree, path)
 
163
        response = dialog.run()
 
164
        if response != gtk.RESPONSE_NONE:
 
165
            dialog.hide()
 
166
            dialog.destroy()
149
167
 
150
168
    def log_cb(self, menu, vfs_file):
151
169
        # We can only cope with local files
165
183
 
166
184
        return
167
185
 
 
186
    def pull_cb(self, menu, vfs_file):
 
187
        # We can only cope with local files
 
188
        if vfs_file.get_uri_scheme() != 'file':
 
189
            return
 
190
 
 
191
        file = vfs_file.get_uri()
 
192
 
 
193
        # We only want to continue here if we get a NotBranchError
 
194
        try:
 
195
            tree, path = WorkingTree.open_containing(file)
 
196
        except NotBranchError:
 
197
            return
 
198
 
 
199
        from bzrlib.plugins.gtk.pull import PullDialog
 
200
        dialog = PullDialog(tree, path)
 
201
        dialog.display()
 
202
        gtk.main()
 
203
 
 
204
    def merge_cb(self, menu, vfs_file):
 
205
        # We can only cope with local files
 
206
        if vfs_file.get_uri_scheme() != 'file':
 
207
            return
 
208
 
 
209
        file = vfs_file.get_uri()
 
210
 
 
211
        # We only want to continue here if we get a NotBranchError
 
212
        try:
 
213
            tree, path = WorkingTree.open_containing(file)
 
214
        except NotBranchError:
 
215
            return
 
216
 
 
217
        from bzrlib.plugins.gtk.merge import MergeDialog
 
218
        dialog = MergeDialog(tree, path)
 
219
        dialog.display()
 
220
        gtk.main()
 
221
 
168
222
    def get_background_items(self, window, vfs_file):
 
223
        items = []
169
224
        file = vfs_file.get_uri()
 
225
 
170
226
        try:
171
227
            tree, path = WorkingTree.open_containing(file)
 
228
            disabled_flag = self.check_branch_enabled(tree.branch)
 
229
        except UnsupportedProtocol:
 
230
            return
172
231
        except NotBranchError:
 
232
            disabled_flag = self.check_branch_enabled()
173
233
            item = nautilus.MenuItem('BzrNautilus::newtree',
174
 
                                 'Create new Bazaar tree',
 
234
                                 'Make directory versioned',
175
235
                                 'Create new Bazaar tree in this folder')
176
236
            item.connect('activate', self.newtree_cb, vfs_file)
177
237
            items.append(item)
178
238
 
179
239
            item = nautilus.MenuItem('BzrNautilus::clone',
180
 
                                 'Checkout',
 
240
                                 'Checkout Bazaar branch',
181
241
                                 'Checkout Existing Bazaar Branch')
182
242
            item.connect('activate', self.clone_cb, vfs_file)
183
243
            items.append(item)
184
244
 
185
245
            return items
 
246
        except NoWorkingTree:
 
247
            return
 
248
        
 
249
        if disabled_flag == 'False':
 
250
            item = nautilus.MenuItem('BzrNautilus::enable',
 
251
                                     'Enable Bazaar Plugin for this Branch',
 
252
                                     'Enable Bazaar plugin for nautilus')
 
253
            item.connect('activate', self.toggle_integration, 'True', vfs_file)
 
254
            return item,
 
255
        else:
 
256
            item = nautilus.MenuItem('BzrNautilus::disable',
 
257
                                      'Disable Bazaar Plugin for the Branch',
 
258
                                      'Disable Bazaar plugin for nautilus')
 
259
            item.connect('activate', self.toggle_integration, 'False', vfs_file)
 
260
            items.append(item)
186
261
 
187
 
        items = []
188
262
        item = nautilus.MenuItem('BzrNautilus::log',
189
263
                             'Log',
190
264
                             'Show Bazaar history')
191
265
        item.connect('activate', self.log_cb, vfs_file)
192
266
        items.append(item)
193
267
 
 
268
        item = nautilus.MenuItem('BzrNautilus::pull',
 
269
                             'Pull',
 
270
                             'Pull from another branch')
 
271
        item.connect('activate', self.pull_cb, vfs_file)
 
272
        items.append(item)
 
273
 
 
274
        item = nautilus.MenuItem('BzrNautilus::merge',
 
275
                             'Merge',
 
276
                             'Merge from another branch')
 
277
        item.connect('activate', self.merge_cb, vfs_file)
 
278
        items.append(item)
 
279
 
194
280
        item = nautilus.MenuItem('BzrNautilus::commit',
195
281
                             'Commit',
196
282
                             'Commit Changes')
199
285
 
200
286
        return items
201
287
 
202
 
 
203
288
    def get_file_items(self, window, files):
204
289
        items = []
205
 
 
 
290
        
 
291
        wtfiles = {}
206
292
        for vfs_file in files:
207
293
            # We can only cope with local files
208
294
            if vfs_file.get_uri_scheme() != 'file':
209
 
                return
 
295
                continue
210
296
 
211
297
            file = vfs_file.get_uri()
212
298
            try:
213
299
                tree, path = WorkingTree.open_containing(file)
 
300
                disabled_flag = self.check_branch_enabled(tree.branch)
214
301
            except NotBranchError:
 
302
                disabled_flag = self.check_branch_enabled()
215
303
                if not vfs_file.is_directory():
 
304
                    continue
 
305
 
 
306
                if disabled_flag == 'False':
216
307
                    return
 
308
 
217
309
                item = nautilus.MenuItem('BzrNautilus::newtree',
218
 
                                     'Create new Bazaar tree',
 
310
                                     'Make directory versioned',
219
311
                                     'Create new Bazaar tree in %s' % vfs_file.get_name())
220
312
                item.connect('activate', self.newtree_cb, vfs_file)
221
313
                return item,
222
 
 
223
 
            file_class = tree.file_class(path)
224
 
 
225
 
            if file_class == '?':
 
314
            except NoWorkingTree:
 
315
                continue
 
316
            # Refresh the list of filestatuses in the working tree
 
317
            if path not in wtfiles.keys():
 
318
                tree.lock_read()
 
319
                for rpath, file_class, kind, id, entry in tree.list_files():
 
320
                    wtfiles[rpath] = file_class
 
321
                tree.unlock()
 
322
                wtfiles[u''] = 'V'
 
323
 
 
324
            if wtfiles[path] == '?':
226
325
                item = nautilus.MenuItem('BzrNautilus::add',
227
326
                                     'Add',
228
327
                                     'Add as versioned file')
234
333
                                     'Ignore file for versioning')
235
334
                item.connect('activate', self.ignore_cb, vfs_file)
236
335
                items.append(item)
237
 
            elif file_class == 'I':
 
336
            elif wtfiles[path] == 'I':
238
337
                item = nautilus.MenuItem('BzrNautilus::unignore',
239
338
                                     'Unignore',
240
339
                                     'Unignore file for versioning')
241
340
                item.connect('activate', self.unignore_cb, vfs_file)
242
341
                items.append(item)
243
 
            elif file_class == 'V':
 
342
            elif wtfiles[path] == 'V':
244
343
                item = nautilus.MenuItem('BzrNautilus::log',
245
344
                                 'Log',
246
345
                                 'List changes')
272
371
                items.append(item)
273
372
 
274
373
        return items
 
374
 
 
375
    def get_columns(self):
 
376
        return nautilus.Column("BzrNautilus::bzr_status",
 
377
                               "bzr_status",
 
378
                               "Bzr Status",
 
379
                               "Version control status"),
 
380
 
 
381
    def update_file_info(self, file):
 
382
 
 
383
        if file.get_uri_scheme() != 'file':
 
384
            return
 
385
        
 
386
        try:
 
387
            tree, path = WorkingTree.open_containing(file.get_uri())
 
388
        except NotBranchError:
 
389
            return
 
390
        except NoWorkingTree:
 
391
            return   
 
392
 
 
393
        disabled_flag = self.check_branch_enabled(tree.branch)
 
394
        if disabled_flag == 'False':
 
395
            return
 
396
 
 
397
        emblem = None
 
398
        status = None
 
399
 
 
400
        if tree.has_filename(path):
 
401
            emblem = 'bzr-controlled'
 
402
            status = 'unchanged'
 
403
            id = tree.path2id(path)
 
404
 
 
405
            delta = tree.changes_from(tree.branch.basis_tree())
 
406
            if delta.touches_file_id(id):
 
407
                emblem = 'bzr-modified'
 
408
                status = 'modified'
 
409
            for f, _, _ in delta.added:
 
410
                if f == path:
 
411
                    emblem = 'bzr-added'
 
412
                    status = 'added'
 
413
 
 
414
            for of, f, _, _, _, _ in delta.renamed:
 
415
                if f == path:
 
416
                    status = 'renamed from %s' % f
 
417
 
 
418
        elif tree.branch.basis_tree().has_filename(path):
 
419
            emblem = 'bzr-removed'
 
420
            status = 'removed'
 
421
        else:
 
422
            # FIXME: Check for ignored files
 
423
            status = 'unversioned'
 
424
        
 
425
        if emblem is not None:
 
426
            file.add_emblem(emblem)
 
427
        file.add_string_attribute('bzr_status', status)
 
428
 
 
429
    def check_branch_enabled(self, branch=None):
 
430
        # Supports global disable, but there is currently no UI to do this
 
431
        config = GlobalConfig()
 
432
        disabled_flag = config.get_user_option('nautilus_integration')
 
433
        if disabled_flag != 'False':
 
434
            if branch is not None:
 
435
                config = branch.get_config()
 
436
                disabled_flag = config.get_user_option('nautilus_integration')
 
437
        return disabled_flag
 
438
 
 
439
    def toggle_integration(self, menu, action, vfs_file=None):
 
440
        try:
 
441
            tree, path = WorkingTree.open_containing(vfs_file.get_uri())
 
442
        except NotBranchError:
 
443
            return
 
444
        except NoWorkingTree:
 
445
            return
 
446
        branch = tree.branch
 
447
        if branch is None:
 
448
            config = GlobalConfig()
 
449
        else:
 
450
            config = branch.get_config()
 
451
        config.set_user_option('nautilus_integration', action)
 
452