/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: Daniel Schierbeck
  • Date: 2008-01-23 16:36:21 UTC
  • mto: (423.1.8 trunk)
  • mto: This revision was merged to the branch mainline in revision 429.
  • Revision ID: daniel.schierbeck@gmail.com-20080123163621-x8kublc38ojipnly
Made the revision popup menu correctly add tags.

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