/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 olive/menu.py

  • Committer: Jelmer Vernooij
  • Date: 2007-01-30 17:26:34 UTC
  • Revision ID: jelmer@samba.org-20070130172634-ov7ucauynnp5vso6
Warn about incompatible versions (taken from bzrtools, thanks Aaron).

Update version to 0.14.

Show diffs side-by-side

added added

removed removed

Lines of Context:
22
22
    pygtk.require("2.0")
23
23
except:
24
24
    pass
25
 
try:
26
 
    import gtk
27
 
    import gtk.glade
28
 
except:
29
 
    sys.exit(1)
30
 
 
31
 
import olive.backend.fileops as fileops
32
 
import olive.backend.errors as errors
33
 
 
 
25
 
 
26
import gtk
 
27
 
 
28
import bzrlib.errors as errors
 
29
from bzrlib.workingtree import WorkingTree
 
30
 
 
31
from dialog import error_dialog, info_dialog, warning_dialog
 
32
from errors import show_bzr_error
34
33
from launch import launch
 
34
from olive import OlivePreferences, DiffWindow
35
35
 
36
36
class OliveMenu:
37
37
    """ This class is responsible for building the context menus. """
38
 
    def __init__(self, gladefile, comm, dialog):
 
38
    def __init__(self, path, selected, app=None):
39
39
        # Load the UI file
40
 
        if sys.platform == 'win32':
41
 
            self.uifile = os.path.dirname(sys.executable) + "/share/olive/cmenu.ui"
42
 
        else:
43
 
            self.uifile = "/usr/share/olive/cmenu.ui"
44
 
        
45
 
        if not os.path.exists(self.uifile):
46
 
            # Load from current directory if not installed
47
 
            self.uifile = "cmenu.ui"
48
 
            # Check again
49
 
            if not os.path.exists(self.uifile):
50
 
                # Fail
51
 
                print _('UI description file cannot be found.')
52
 
                sys.exit(1)
53
 
        
54
 
        self.gladefile = gladefile
55
 
        self.comm = comm
56
 
        self.dialog = dialog
 
40
        from guifiles import UIFILENAME
 
41
 
 
42
        self.uifile = UIFILENAME
 
43
 
 
44
        # Preferences handler
 
45
        self.pref = OlivePreferences()
 
46
        
 
47
        # Set default values
 
48
        self.path = path
 
49
        self.selected = selected
 
50
        self.app = app
57
51
        
58
52
        # Create the file list context menu
59
53
        self.ui = gtk.UIManager()
67
61
                                       _('Remove'), None,
68
62
                                       _('Remove the selected file'),
69
63
                                       self.remove_file),
 
64
                                      ('rename', None,
 
65
                                       _('Rename'), None,
 
66
                                       _('Rename the selected file'),
 
67
                                       self.rename_file),
70
68
                                      ('open', gtk.STOCK_OPEN,
71
69
                                       _('Open'), None,
72
70
                                       _('Open the selected file'),
113
111
        self.toolbar_diff = self.ui.get_widget('/toolbar_diff')
114
112
        
115
113
        # Set icons
116
 
        commit_menu = self.ui.get_widget('/context_right/commit')
117
 
        commit_image = self.comm.menuitem_branch_commit.get_image()
118
 
        commit_pixbuf = commit_image.get_pixbuf()
119
 
        commit_icon = gtk.Image()
120
 
        commit_icon.set_from_pixbuf(commit_pixbuf)
121
 
        commit_menu.set_image(commit_icon)
122
 
        diff_menu = self.ui.get_widget('/context_right/diff')
123
 
        diff_image = self.comm.menuitem_stats_diff.get_image()
124
 
        diff_pixbuf = diff_image.get_pixbuf()
125
 
        diff_icon = gtk.Image()
126
 
        diff_icon.set_from_pixbuf(diff_pixbuf)
127
 
        diff_menu.set_image(diff_icon)
 
114
        # TODO: do it without using deprecated comm
 
115
        #commit_menu = self.ui.get_widget('/context_right/commit')
 
116
        #commit_image = self.comm.menuitem_branch_commit.get_image()
 
117
        #commit_pixbuf = commit_image.get_pixbuf()
 
118
        #commit_icon = gtk.Image()
 
119
        #commit_icon.set_from_pixbuf(commit_pixbuf)
 
120
        #commit_menu.set_image(commit_icon)
 
121
        #diff_menu = self.ui.get_widget('/context_right/diff')
 
122
        #diff_image = self.comm.menuitem_stats_diff.get_image()
 
123
        #diff_pixbuf = diff_image.get_pixbuf()
 
124
        #diff_icon = gtk.Image()
 
125
        #diff_icon.set_from_pixbuf(diff_pixbuf)
 
126
        #diff_menu.set_image(diff_icon)
128
127
 
129
128
    def right_context_menu(self):
130
129
        return self.cmenu_right
132
131
    def left_context_menu(self):
133
132
        return self.cmenu_left
134
133
    
 
134
    @show_bzr_error
135
135
    def add_file(self, action):
136
136
        """ Right context menu -> Add """
 
137
        import bzrlib.add
 
138
        
137
139
        # Add only the selected file
138
 
        directory = self.comm.get_path()
139
 
        filename = self.comm.get_selected_right()
 
140
        directory = self.path
 
141
        filename = self.selected
140
142
            
141
143
        if filename is None:
142
 
            self.dialog.error_dialog(_('No file was selected'),
143
 
                                     _('Please select a file from the list,\nor choose the other option.'))
144
 
            return
145
 
        
146
 
        try:
147
 
            fileops.add([directory + '/' + filename])
148
 
        except errors.NotBranchError:
149
 
            self.dialog.error_dialog(_('Directory is not a branch'),
150
 
                                     _('You can perform this action only in a branch.'))
151
 
            return
152
 
        except:
153
 
            raise
154
 
        
155
 
        self.comm.refresh_right()
 
144
            error_dialog(_('No file was selected'),
 
145
                         _('Please select a file from the list,\nor choose the other option.'))
 
146
            return
 
147
        
 
148
        bzrlib.add.smart_add([os.path.join(directory, filename)])
156
149
    
 
150
    @show_bzr_error
157
151
    def remove_file(self, action):
158
152
        """ Right context menu -> Remove """
159
153
        # Remove only the selected file
160
 
        directory = self.comm.get_path()
161
 
        filename = self.comm.get_selected_right()
 
154
        directory = self.path
 
155
        filename = self.selected
162
156
        
163
157
        if filename is None:
164
 
            self.dialog.error_dialog(_('No file was selected'),
165
 
                                     _('Please select a file from the list,\nor choose the other option.'))
166
 
            return
167
 
        
168
 
        try:
169
 
            fileops.remove([directory + '/' + filename])
170
 
        except errors.NotBranchError:
171
 
            self.dialog.error_dialog(_('Directory is not a branch'),
172
 
                                     _('You can perform this action only in a branch.'))
173
 
            return
174
 
        except errors.NotVersionedError:
175
 
            self.dialog.error_dialog(_('File not versioned'),
176
 
                                     _('The selected file is not versioned.'))
177
 
            return
178
 
        except:
179
 
            raise
180
 
        
181
 
        self.comm.refresh_right()
 
158
            error_dialog(_('No file was selected'),
 
159
                         _('Please select a file from the list,\nor choose the other option.'))
 
160
            return
 
161
        
 
162
        wt, path = WorkingTree.open_containing(os.path.join(directory, filename))
 
163
        wt.remove(path)
 
164
        self.app.set_path(self.path)
 
165
        self.app.refresh_right()
182
166
 
 
167
    def rename_file(self, action):
 
168
        """ Right context menu -> Rename """
 
169
        from rename import OliveRename
 
170
        wt = WorkingTree.open_containing(self.path + os.sep + self.selected)[0]
 
171
        rename = OliveRename(wt, wt.relpath(self.path), self.selected)
 
172
        rename.display()
 
173
    
183
174
    def open_file(self, action):
184
175
        """ Right context menu -> Open """
185
176
        # Open only the selected file
186
 
        filename = self.comm.get_selected_right()
 
177
        filename = self.selected
187
178
        
188
179
        if filename is None:
189
 
            self.dialog.error_dialog(_('No file was selected'),
190
 
                                     _('Please select a file from the list,\nor choose the other option.'))
 
180
            error_dialog(_('No file was selected'),
 
181
                         _('Please select a file from the list,\nor choose the other option.'))
191
182
            return
192
183
 
193
184
        if filename == '..':
194
 
            self.comm.set_path(os.path.split(self.comm.get_path())[0])
 
185
            # TODO: how to enter a directory?
 
186
            return
195
187
        else:
196
 
            fullpath = self.comm.get_path() + os.sep + filename
 
188
            fullpath = self.path + os.sep + filename
197
189
            if os.path.isdir(fullpath):
198
190
                # selected item is an existant directory
199
 
                self.comm.set_path(fullpath)
 
191
                # TODO: how to enter a directory?
 
192
                return
200
193
            else:
201
194
                launch(fullpath) 
202
 
        
203
 
        self.comm.refresh_right()
204
195
 
205
196
    def commit(self, action):
206
197
        """ Right context menu -> Commit """
207
 
        from commit import OliveCommit
208
 
        commit = OliveCommit(self.gladefile, self.comm, self.dialog)
 
198
        from commit import CommitDialog
 
199
        branch = None
 
200
        try:
 
201
            wt, path = WorkingTree.open_containing(self.path)
 
202
            branch = wt.branch
 
203
        except NotBranchError, e:
 
204
            path = e.path
 
205
        commit = CommitDialog(wt, path, not branch)
209
206
        commit.display()
210
207
    
 
208
    @show_bzr_error
211
209
    def diff(self, action):
212
210
        """ Right context menu -> Diff """
213
 
        from diff import OliveDiff
214
 
        diff = OliveDiff(self.gladefile, self.comm, self.dialog)
215
 
        diff.display()
 
211
        wt = WorkingTree.open_containing(self.path)[0]
 
212
        window = DiffWindow()
 
213
        parent_tree = wt.branch.repository.revision_tree(wt.branch.last_revision())
 
214
        window.set_diff(wt.branch.nick, wt, parent_tree)
 
215
        window.set_file(wt.relpath(self.path + os.sep + self.selected))
 
216
        window.show()
216
217
    
217
218
    def bookmark(self, action):
218
219
        """ Right context menu -> Bookmark """
219
 
        if self.comm.pref.add_bookmark(self.comm.get_path()):
220
 
            self.dialog.info_dialog(_('Bookmark successfully added'),
221
 
                                    _('The current directory was bookmarked. You can reach\nit by selecting it from the left panel.'))
 
220
        if self.pref.add_bookmark(self.path):
 
221
            info_dialog(_('Bookmark successfully added'),
 
222
                        _('The current directory was bookmarked. You can reach\nit by selecting it from the left panel.'))
 
223
            self.pref.write()
222
224
        else:
223
 
            self.dialog.warning_dialog(_('Location already bookmarked'),
224
 
                                       _('The current directory is already bookmarked.\nSee the left panel for reference.'))
 
225
            warning_dialog(_('Location already bookmarked'),
 
226
                           _('The current directory is already bookmarked.\nSee the left panel for reference.'))
225
227
        
226
 
        self.comm.refresh_left()
 
228
        self.app.refresh_left()
227
229
 
228
230
    def edit_bookmark(self, action):
229
231
        """ Left context menu -> Edit """
230
 
        from bookmark import OliveBookmark
231
 
 
232
 
        if self.comm.get_selected_left() != None:
233
 
            bookmark = OliveBookmark(self.gladefile, self.comm, self.dialog)
234
 
            bookmark.display()
 
232
        from bookmark import OliveBookmarkDialog
 
233
        
 
234
        if self.selected != None:
 
235
            bookmark = OliveBookmarkDialog(self.selected, self.app.window)
 
236
            response = bookmark.run()
 
237
            
 
238
            if response != gtk.RESPONSE_NONE:
 
239
                bookmark.hide()
 
240
        
 
241
                if response == gtk.RESPONSE_OK:
 
242
                    self.app.refresh_left()
 
243
            
 
244
                bookmark.destroy()
235
245
 
236
246
    def remove_bookmark(self, action):
237
247
        """ Left context menu -> Remove """
238
248
        
239
 
        if self.comm.get_selected_left() != None:
240
 
            self.comm.pref.remove_bookmark(self.comm.get_selected_left())
241
 
            self.comm.refresh_left()
 
249
        if self.selected != None:
 
250
            self.pref.remove_bookmark(self.selected)
 
251
            self.pref.write()
 
252
        
 
253
        self.app.refresh_left()
242
254
    
243
255
    def open_folder(self, action):
244
256
        """ Left context menu -> Open Folder """
245
 
        path = self.comm.get_selected_left()
 
257
        path = self.selected
246
258
 
247
259
        if path != None:
248
260
            launch(path)
254
266
    def diff_all(self, action):
255
267
        """ Diff toolbutton -> All... """
256
268
        from diff import OliveDiff
257
 
        diff = OliveDiff(self.gladefile, self.comm, self.dialog)
 
269
        diff = OliveDiff(self.comm)
258
270
        diff.display()