/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: Jelmer Vernooij
  • Date: 2011-02-18 13:01:03 UTC
  • Revision ID: jelmer@samba.org-20110218130103-fiyk203auk28thpn
Remove some unused imports, fix some formatting.

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
 
10
import nautilus
 
11
import bzrlib
 
12
from bzrlib.branch import Branch
 
13
from bzrlib.bzrdir import BzrDir
 
14
from bzrlib.errors import NotBranchError, NoWorkingTree, UnsupportedProtocol
 
15
from bzrlib.workingtree import WorkingTree
 
16
from bzrlib.config import GlobalConfig
 
17
 
 
18
from bzrlib.plugin import load_plugins
 
19
load_plugins()
 
20
 
 
21
from bzrlib.plugins.gtk.commands import cmd_gannotate, start_viz_window
 
22
 
 
23
print "Bazaar nautilus module initialized"
 
24
 
 
25
 
 
26
class BzrExtension(nautilus.MenuProvider, nautilus.ColumnProvider, nautilus.InfoProvider):
 
27
    def __init__(self):
 
28
        pass
 
29
 
 
30
    def add_cb(self, menu, vfs_file):
 
31
        # We can only cope with local files
 
32
        if vfs_file.get_uri_scheme() != 'file':
 
33
            return
 
34
 
 
35
        file = vfs_file.get_uri()
 
36
        try:
 
37
            tree, path = WorkingTree.open_containing(file)
 
38
        except NotBranchError:
 
39
            return
 
40
 
 
41
        tree.add(path)
 
42
 
 
43
        return
 
44
 
 
45
    def ignore_cb(self, menu, vfs_file):
 
46
        # We can only cope with local files
 
47
        if vfs_file.get_uri_scheme() != 'file':
 
48
            return
 
49
 
 
50
        file = vfs_file.get_uri()
 
51
        try:
 
52
            tree, path = WorkingTree.open_containing(file)
 
53
        except NotBranchError:
 
54
            return
 
55
 
 
56
        #FIXME
 
57
 
 
58
        return
 
59
 
 
60
    def unignore_cb(self, menu, vfs_file):
 
61
        # We can only cope with local files
 
62
        if vfs_file.get_uri_scheme() != 'file':
 
63
            return
 
64
 
 
65
        file = vfs_file.get_uri()
 
66
        try:
 
67
            tree, path = WorkingTree.open_containing(file)
 
68
        except NotBranchError:
 
69
            return
 
70
 
 
71
        #FIXME
 
72
 
 
73
        return
 
74
 
 
75
    def diff_cb(self, menu, vfs_file):
 
76
        # We can only cope with local files
 
77
        if vfs_file.get_uri_scheme() != 'file':
 
78
            return
 
79
 
 
80
        file = vfs_file.get_uri()
 
81
        try:
 
82
            tree, path = WorkingTree.open_containing(file)
 
83
        except NotBranchError:
 
84
            return
 
85
 
 
86
        from bzrlib.plugins.gtk.diff import DiffWindow
 
87
        window = DiffWindow()
 
88
        window.set_diff(tree.branch._get_nick(local=True), tree, 
 
89
                        tree.branch.basis_tree())
 
90
        window.show()
 
91
 
 
92
        return
 
93
 
 
94
    def newtree_cb(self, menu, vfs_file):
 
95
        # We can only cope with local files
 
96
        if vfs_file.get_uri_scheme() != 'file':
 
97
            return
 
98
 
 
99
        file = vfs_file.get_uri()
 
100
 
 
101
        # We only want to continue here if we get a NotBranchError
 
102
        try:
 
103
            tree, path = WorkingTree.open_containing(file)
 
104
        except NotBranchError:
 
105
            BzrDir.create_standalone_workingtree(file)
 
106
 
 
107
    def remove_cb(self, menu, vfs_file):
 
108
        # We can only cope with local files
 
109
        if vfs_file.get_uri_scheme() != 'file':
 
110
            return
 
111
 
 
112
        file = vfs_file.get_uri()
 
113
        try:
 
114
            tree, path = WorkingTree.open_containing(file)
 
115
        except NotBranchError:
 
116
            return
 
117
 
 
118
        tree.remove(path)
 
119
 
 
120
    def annotate_cb(self, menu, vfs_file):
 
121
        # We can only cope with local files
 
122
        if vfs_file.get_uri_scheme() != 'file':
 
123
            return
 
124
 
 
125
        file = vfs_file.get_uri()
 
126
 
 
127
        vis = cmd_gannotate()
 
128
        vis.run(file)
 
129
 
 
130
    def clone_cb(self, menu, vfs_file=None):
 
131
        # We can only cope with local files
 
132
        if vfs_file.get_uri_scheme() != 'file':
 
133
            return
 
134
 
 
135
        from bzrlib.plugins.gtk.branch import BranchDialog
 
136
        
 
137
        dialog = BranchDialog(vfs_file.get_name())
 
138
        response = dialog.run()
 
139
        if response != gtk.RESPONSE_NONE:
 
140
            dialog.hide()
 
141
            dialog.destroy()
 
142
 
 
143
    def commit_cb(self, menu, vfs_file=None):
 
144
        # We can only cope with local files
 
145
        if vfs_file.get_uri_scheme() != 'file':
 
146
            return
 
147
 
 
148
        file = vfs_file.get_uri()
 
149
        tree = None
 
150
        branch = None
 
151
        try:
 
152
            tree, path = WorkingTree.open_containing(file)
 
153
            branch = tree.branch
 
154
        except NotBranchError, e:
 
155
            path = e.path
 
156
            #return
 
157
        except NoWorkingTree, e:
 
158
            path = e.base
 
159
            try:
 
160
                (branch, path) = Branch.open_containing(path)
 
161
            except NotBranchError, e:
 
162
                path = e.path
 
163
 
 
164
        from bzrlib.plugins.gtk.commit import CommitDialog
 
165
        dialog = CommitDialog(tree, path)
 
166
        response = dialog.run()
 
167
        if response != gtk.RESPONSE_NONE:
 
168
            dialog.hide()
 
169
            dialog.destroy()
 
170
 
 
171
    def log_cb(self, menu, vfs_file):
 
172
        # We can only cope with local files
 
173
        if vfs_file.get_uri_scheme() != 'file':
 
174
            return
 
175
 
 
176
        file = vfs_file.get_uri()
 
177
 
 
178
        # We only want to continue here if we get a NotBranchError
 
179
        try:
 
180
            branch, path = Branch.open_containing(file)
 
181
        except NotBranchError:
 
182
            return
 
183
 
 
184
        pp = start_viz_window(branch, [branch.last_revision()])
 
185
        pp.show()
 
186
        gtk.main()
 
187
 
 
188
    def pull_cb(self, menu, vfs_file):
 
189
        # We can only cope with local files
 
190
        if vfs_file.get_uri_scheme() != 'file':
 
191
            return
 
192
 
 
193
        file = vfs_file.get_uri()
 
194
 
 
195
        # We only want to continue here if we get a NotBranchError
 
196
        try:
 
197
            tree, path = WorkingTree.open_containing(file)
 
198
        except NotBranchError:
 
199
            return
 
200
 
 
201
        from bzrlib.plugins.gtk.pull import PullDialog
 
202
        dialog = PullDialog(tree, path)
 
203
        dialog.display()
 
204
        gtk.main()
 
205
 
 
206
    def merge_cb(self, menu, vfs_file):
 
207
        # We can only cope with local files
 
208
        if vfs_file.get_uri_scheme() != 'file':
 
209
            return
 
210
 
 
211
        file = vfs_file.get_uri()
 
212
 
 
213
        # We only want to continue here if we get a NotBranchError
 
214
        try:
 
215
            tree, path = WorkingTree.open_containing(file)
 
216
        except NotBranchError:
 
217
            return
 
218
 
 
219
        from bzrlib.plugins.gtk.merge import MergeDialog
 
220
        dialog = MergeDialog(tree, path)
 
221
        dialog.run()
 
222
        dialog.destroy()
 
223
 
 
224
    def get_background_items(self, window, vfs_file):
 
225
        items = []
 
226
        file = vfs_file.get_uri()
 
227
 
 
228
        try:
 
229
            tree, path = WorkingTree.open_containing(file)
 
230
            disabled_flag = self.check_branch_enabled(tree.branch)
 
231
        except UnsupportedProtocol:
 
232
            return
 
233
        except NotBranchError:
 
234
            disabled_flag = self.check_branch_enabled()
 
235
            item = nautilus.MenuItem('BzrNautilus::newtree',
 
236
                                 'Make directory versioned',
 
237
                                 'Create new Bazaar tree in this folder')
 
238
            item.connect('activate', self.newtree_cb, vfs_file)
 
239
            items.append(item)
 
240
 
 
241
            item = nautilus.MenuItem('BzrNautilus::clone',
 
242
                                 'Checkout Bazaar branch ...',
 
243
                                 'Checkout Existing Bazaar Branch')
 
244
            item.connect('activate', self.clone_cb, vfs_file)
 
245
            items.append(item)
 
246
 
 
247
            return items
 
248
        except NoWorkingTree:
 
249
            return
 
250
        
 
251
        if disabled_flag == 'False':
 
252
            item = nautilus.MenuItem('BzrNautilus::enable',
 
253
                                     'Enable Bazaar Plugin for this Branch',
 
254
                                     'Enable Bazaar plugin for nautilus')
 
255
            item.connect('activate', self.toggle_integration, 'True', vfs_file)
 
256
            return item,
 
257
        else:
 
258
            item = nautilus.MenuItem('BzrNautilus::disable',
 
259
                                      'Disable Bazaar Plugin this Branch',
 
260
                                      'Disable Bazaar plugin for nautilus')
 
261
            item.connect('activate', self.toggle_integration, 'False', vfs_file)
 
262
            items.append(item)
 
263
 
 
264
        item = nautilus.MenuItem('BzrNautilus::log',
 
265
                             'History ...',
 
266
                             'Show Bazaar history')
 
267
        item.connect('activate', self.log_cb, vfs_file)
 
268
        items.append(item)
 
269
 
 
270
        item = nautilus.MenuItem('BzrNautilus::pull',
 
271
                             'Pull ...',
 
272
                             'Pull from another branch')
 
273
        item.connect('activate', self.pull_cb, vfs_file)
 
274
        items.append(item)
 
275
 
 
276
        item = nautilus.MenuItem('BzrNautilus::merge',
 
277
                             'Merge ...',
 
278
                             'Merge from another branch')
 
279
        item.connect('activate', self.merge_cb, vfs_file)
 
280
        items.append(item)
 
281
 
 
282
        item = nautilus.MenuItem('BzrNautilus::commit',
 
283
                             'Commit ...',
 
284
                             'Commit Changes')
 
285
        item.connect('activate', self.commit_cb, vfs_file)
 
286
        items.append(item)
 
287
 
 
288
        return items
 
289
 
 
290
    def get_file_items(self, window, files):
 
291
        items = []
 
292
        
 
293
        wtfiles = {}
 
294
        for vfs_file in files:
 
295
            # We can only cope with local files
 
296
            if vfs_file.get_uri_scheme() != 'file':
 
297
                continue
 
298
 
 
299
            file = vfs_file.get_uri()
 
300
            try:
 
301
                tree, path = WorkingTree.open_containing(file)
 
302
                disabled_flag = self.check_branch_enabled(tree.branch)
 
303
            except NotBranchError:
 
304
                disabled_flag = self.check_branch_enabled()
 
305
                if not vfs_file.is_directory():
 
306
                    continue
 
307
 
 
308
                if disabled_flag == 'False':
 
309
                    return
 
310
 
 
311
                item = nautilus.MenuItem('BzrNautilus::newtree',
 
312
                                     'Make directory versioned',
 
313
                                     'Create new Bazaar tree in %s' % vfs_file.get_name())
 
314
                item.connect('activate', self.newtree_cb, vfs_file)
 
315
                return item,
 
316
            except NoWorkingTree:
 
317
                continue
 
318
            # Refresh the list of filestatuses in the working tree
 
319
            if path not in wtfiles.keys():
 
320
                tree.lock_read()
 
321
                for rpath, file_class, kind, id, entry in tree.list_files():
 
322
                    wtfiles[rpath] = file_class
 
323
                tree.unlock()
 
324
                wtfiles[u''] = 'V'
 
325
 
 
326
            if wtfiles[path] == '?':
 
327
                item = nautilus.MenuItem('BzrNautilus::add',
 
328
                                     'Add',
 
329
                                     'Add as versioned file')
 
330
                item.connect('activate', self.add_cb, vfs_file)
 
331
                items.append(item)
 
332
 
 
333
                item = nautilus.MenuItem('BzrNautilus::ignore',
 
334
                                     'Ignore',
 
335
                                     'Ignore file for versioning')
 
336
                item.connect('activate', self.ignore_cb, vfs_file)
 
337
                items.append(item)
 
338
            elif wtfiles[path] == 'I':
 
339
                item = nautilus.MenuItem('BzrNautilus::unignore',
 
340
                                     'Unignore',
 
341
                                     'Unignore file for versioning')
 
342
                item.connect('activate', self.unignore_cb, vfs_file)
 
343
                items.append(item)
 
344
            elif wtfiles[path] == 'V':
 
345
                item = nautilus.MenuItem('BzrNautilus::log',
 
346
                                 'History ...',
 
347
                                 'List changes')
 
348
                item.connect('activate', self.log_cb, vfs_file)
 
349
                items.append(item)
 
350
 
 
351
                item = nautilus.MenuItem('BzrNautilus::diff',
 
352
                                 'View Changes ...',
 
353
                                 'Show differences')
 
354
                item.connect('activate', self.diff_cb, vfs_file)
 
355
                items.append(item)
 
356
 
 
357
                item = nautilus.MenuItem('BzrNautilus::remove',
 
358
                                     'Remove',
 
359
                                     'Remove this file from versioning')
 
360
                item.connect('activate', self.remove_cb, vfs_file)
 
361
                items.append(item)
 
362
 
 
363
                item = nautilus.MenuItem('BzrNautilus::annotate',
 
364
                             'Annotate ...',
 
365
                             'Annotate File Data')
 
366
                item.connect('activate', self.annotate_cb, vfs_file)
 
367
                items.append(item)
 
368
 
 
369
                item = nautilus.MenuItem('BzrNautilus::commit',
 
370
                             'Commit ...',
 
371
                             'Commit Changes')
 
372
                item.connect('activate', self.commit_cb, vfs_file)
 
373
                items.append(item)
 
374
 
 
375
        return items
 
376
 
 
377
    def get_columns(self):
 
378
        return nautilus.Column("BzrNautilus::bzr_status",
 
379
                               "bzr_status",
 
380
                               "Bzr Status",
 
381
                               "Version control status"),
 
382
 
 
383
    def update_file_info(self, file):
 
384
 
 
385
        if file.get_uri_scheme() != 'file':
 
386
            return
 
387
        
 
388
        try:
 
389
            tree, path = WorkingTree.open_containing(file.get_uri())
 
390
        except NotBranchError:
 
391
            return
 
392
        except NoWorkingTree:
 
393
            return   
 
394
 
 
395
        disabled_flag = self.check_branch_enabled(tree.branch)
 
396
        if disabled_flag == 'False':
 
397
            return
 
398
 
 
399
        emblem = None
 
400
        status = None
 
401
 
 
402
        id = tree.path2id(path)
 
403
        if id == None:
 
404
            if tree.is_ignored(path):
 
405
                status = 'ignored'
 
406
                emblem = 'bzr-ignored'
 
407
            else:
 
408
                status = 'unversioned'
 
409
                        
 
410
        elif tree.has_filename(path):
 
411
            emblem = 'bzr-controlled'
 
412
            status = 'unchanged'
 
413
 
 
414
            delta = tree.changes_from(tree.branch.basis_tree())
 
415
            if delta.touches_file_id(id):
 
416
                emblem = 'bzr-modified'
 
417
                status = 'modified'
 
418
            for f, _, _ in delta.added:
 
419
                if f == path:
 
420
                    emblem = 'bzr-added'
 
421
                    status = 'added'
 
422
 
 
423
            for of, f, _, _, _, _ in delta.renamed:
 
424
                if f == path:
 
425
                    status = 'renamed from %s' % f
 
426
 
 
427
        elif tree.branch.basis_tree().has_filename(path):
 
428
            emblem = 'bzr-removed'
 
429
            status = 'removed'
 
430
        else:
 
431
            # FIXME: Check for ignored files
 
432
            status = 'unversioned'
 
433
        
 
434
        if emblem is not None:
 
435
            file.add_emblem(emblem)
 
436
        file.add_string_attribute('bzr_status', status)
 
437
 
 
438
    def check_branch_enabled(self, branch=None):
 
439
        # Supports global disable, but there is currently no UI to do this
 
440
        config = GlobalConfig()
 
441
        disabled_flag = config.get_user_option('nautilus_integration')
 
442
        if disabled_flag != 'False':
 
443
            if branch is not None:
 
444
                config = branch.get_config()
 
445
                disabled_flag = config.get_user_option('nautilus_integration')
 
446
        return disabled_flag
 
447
 
 
448
    def toggle_integration(self, menu, action, vfs_file=None):
 
449
        try:
 
450
            tree, path = WorkingTree.open_containing(vfs_file.get_uri())
 
451
        except NotBranchError:
 
452
            return
 
453
        except NoWorkingTree:
 
454
            return
 
455
        branch = tree.branch
 
456
        if branch is None:
 
457
            config = GlobalConfig()
 
458
        else:
 
459
            config = branch.get_config()
 
460
        config.set_user_option('nautilus_integration', action)
 
461