/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/frontend/gtk/push.py

  • Committer: Szilveszter Farkas (Phanatic)
  • Date: 2006-08-15 17:37:54 UTC
  • mto: (0.14.1 main) (93.1.1 win32.bialix)
  • mto: This revision was merged to the branch mainline in revision 83.
  • Revision ID: Szilveszter.Farkas@gmail.com-20060815173754-9877ef0e3e64660e
Some small tweaks in the .desktop file.

2006-08-15  Szilveszter Farkas <Szilveszter.Farkas@gmail.com>

    * icons/olive-gtk.png: added application icon

Show diffs side-by-side

added added

removed removed

Lines of Context:
olive/frontend/gtk/push.py
21
21
    pygtk.require("2.0")
22
22
except:
23
23
    pass
24
 
    
25
 
import gtk
26
 
import gtk.gdk
27
 
import gtk.glade
28
 
 
29
 
import bzrlib.errors as errors
30
 
 
31
 
from olive import gladefile
 
24
try:
 
25
    import gtk
 
26
    import gtk.gdk
 
27
    import gtk.glade
 
28
except:
 
29
    sys.exit(1)
 
30
 
 
31
import olive.backend.commit as commit
 
32
import olive.backend.errors as errors
 
33
import olive.backend.info as info
32
34
 
33
35
class OlivePush:
34
36
    """ Display Push dialog and perform the needed actions. """
35
 
    def __init__(self, branch):
 
37
    def __init__(self, gladefile, comm, dialog):
36
38
        """ Initialize the Push dialog. """
37
 
        self.glade = gtk.glade.XML(gladefile, 'window_push')
 
39
        self.gladefile = gladefile
 
40
        self.glade = gtk.glade.XML(self.gladefile, 'window_push')
 
41
        
 
42
        # Communication object
 
43
        self.comm = comm
 
44
        # Dialog object
 
45
        self.dialog = dialog
38
46
        
39
47
        self.window = self.glade.get_widget('window_push')
40
 
 
41
 
        self.branch = branch
42
48
        
43
49
        # Dictionary for signal_autoconnect
44
50
        dic = { "on_button_push_push_clicked": self.push,
45
51
                "on_button_push_cancel_clicked": self.close,
46
 
                "on_button_push_test_clicked": self.test,
47
52
                "on_radiobutton_push_stored_toggled": self.stored_toggled,
48
53
                "on_radiobutton_push_specific_toggled": self.specific_toggled, }
49
54
        
51
56
        self.glade.signal_autoconnect(dic)
52
57
        
53
58
        # Get some useful widgets
54
 
        self.radio_stored = self.glade.get_widget('radiobutton_push_stored')
55
 
        self.radio_specific = self.glade.get_widget('radiobutton_push_specific')
56
59
        self.entry_stored = self.glade.get_widget('entry_push_stored')
57
60
        self.entry_location = self.glade.get_widget('entry_push_location')
58
61
        self.check_remember = self.glade.get_widget('checkbutton_push_remember')
59
62
        self.check_overwrite = self.glade.get_widget('checkbutton_push_overwrite')
60
63
        self.check_create = self.glade.get_widget('checkbutton_push_create')
61
 
        self.label_test = self.glade.get_widget('label_push_test')
62
 
        self.image_test = self.glade.get_widget('image_push_test')
63
 
        
64
 
        # Set initial state
65
 
        self.entry_location.set_sensitive(0)
66
 
        self.check_remember.set_sensitive(0)
67
 
        self.check_create.set_sensitive(0)
68
 
        
69
 
        self.entry_stored.set_text(branch.get_push_location())
 
64
        
 
65
        # Get stored location
 
66
        self.notbranch = False
 
67
        try:
 
68
            loc = info.get_push_location(self.comm.get_path())
 
69
        except errors.NotBranchError:
 
70
            self.notbranch = True
 
71
            return
 
72
 
 
73
        if loc is not None:
 
74
            self.entry_stored.set_text(loc)
70
75
    
71
76
    def display(self):
72
77
        """ Display the Push dialog. """
73
 
        self.window.show()
74
 
        self.width, self.height = self.window.get_size()
 
78
        if self.notbranch:
 
79
            self.dialog.error_dialog('Directory is not a branch',
 
80
                                     'You can perform this action only in a branch.')
 
81
            self.close()
 
82
        else:
 
83
            self.window.show()
 
84
            self.width, self.height = self.window.get_size()
75
85
    
76
86
    def stored_toggled(self, widget):
77
87
        if widget.get_active():
78
 
            self.entry_stored.set_sensitive(1)
79
 
            self.entry_location.set_sensitive(0)
80
 
            self.check_remember.set_sensitive(0)
81
 
            self.check_create.set_sensitive(0)
 
88
            self.entry_stored.show()
 
89
            self.entry_location.hide()
 
90
            self.check_remember.hide()
 
91
            self.check_create.hide()
 
92
            self.window.resize(self.width, self.height)
82
93
        else:
83
 
            self.entry_stored.set_sensitive(0)
84
 
            self.entry_location.set_sensitive(1)
85
 
            self.check_remember.set_sensitive(1)
86
 
            self.check_create.set_sensitive(1)
 
94
            self.entry_stored.hide()
 
95
            self.entry_location.show()
 
96
            self.check_remember.show()
 
97
            self.check_create.show()
87
98
    
88
99
    def specific_toggled(self, widget):
89
100
        if widget.get_active():
90
 
            self.entry_stored.set_sensitive(0)
91
 
            self.entry_location.set_sensitive(1)
92
 
            self.check_remember.set_sensitive(1)
93
 
            self.check_create.set_sensitive(1)
 
101
            self.entry_stored.hide()
 
102
            self.entry_location.show()
 
103
            self.check_remember.show()
 
104
            self.check_create.show()
94
105
        else:
95
 
            self.entry_stored.set_sensitive(1)
96
 
            self.entry_location.set_sensitive(0)
97
 
            self.check_remember.set_sensitive(0)
98
 
            self.check_create.set_sensitive(0)
 
106
            self.entry_stored.show()
 
107
            self.entry_location.hide()
 
108
            self.check_remember.hide()
 
109
            self.check_create.hide()
99
110
    
100
111
    def push(self, widget):
 
112
        radio_stored = self.glade.get_widget('radiobutton_push_stored')
 
113
        radio_specific = self.glade.get_widget('radiobutton_push_specific')
 
114
        
101
115
        revs = 0
102
 
        if self.radio_stored.get_active():
 
116
        self.comm.set_busy(self.window)
 
117
        if radio_stored.get_active():
103
118
            try:
104
 
                revs = do_push(self.branch,
105
 
                               overwrite=self.check_overwrite.get_active())
 
119
                revs = commit.push(self.comm.get_path(),
 
120
                                   overwrite=self.check_overwrite.get_active())
106
121
            except errors.NotBranchError:
107
 
                error_dialog(_('Directory is not a branch'),
108
 
                                         _('You can perform this action only in a branch.'))
109
 
                return
110
 
            except errors.DivergedBranches:
111
 
                error_dialog(_('Branches have been diverged'),
112
 
                                         _('You cannot push if branches have diverged. Use the\noverwrite option if you want to push anyway.'))
113
 
                return
114
 
        elif self.radio_specific.get_active():
 
122
                self.dialog.error_dialog('Directory is not a branch',
 
123
                                         'You can perform this action only in a branch.')
 
124
                return
 
125
            except errors.NoLocationKnown:
 
126
                self.dialog.error_dialog('Push location is unknown',
 
127
                                         'Please specify a location manually.')
 
128
                return
 
129
            except errors.NonExistingParent, errmsg:
 
130
                self.dialog.error_dialog("Non existing parent directory",
 
131
                                         "The parent directory (%s)\ndoesn't exist." % errmsg)
 
132
                return
 
133
            except errors.DivergedBranchesError:
 
134
                self.dialog.error_dialog('Branches have been diverged',
 
135
                                         'You cannot push if branches have diverged. Use the\noverwrite option if you want to push anyway.')
 
136
                return
 
137
            except:
 
138
                raise
 
139
        elif radio_specific.get_active():
115
140
            location = self.entry_location.get_text()
116
141
            if location == '':
117
 
                error_dialog(_('No location specified'),
118
 
                                         _('Please specify a location or use the default.'))
 
142
                self.dialog.error_dialog('No location specified',
 
143
                                         'Please specify a location or use the default.')
119
144
                return
120
145
            
121
146
            try:
122
 
                revs = do_push(self.branch, location,
123
 
                               self.check_remember.get_active(),
124
 
                               self.check_overwrite.get_active(),
125
 
                               self.check_create.get_active())
 
147
                revs = commit.push(self.comm.get_path(), location,
 
148
                                   self.check_remember.get_active(),
 
149
                                   self.check_overwrite.get_active(),
 
150
                                   self.check_create.get_active())
126
151
            except errors.NotBranchError:
127
 
                error_dialog(_('Directory is not a branch'),
128
 
                                         _('You can perform this action only in a branch.'))
129
 
                return
130
 
            except errors.DivergedBranches:
131
 
                error_dialog(_('Branches have been diverged'),
132
 
                                         _('You cannot push if branches have diverged. Use the\noverwrite option if you want to push anyway.'))
133
 
                return
 
152
                self.dialog.error_dialog('Directory is not a branch',
 
153
                                         'You can perform this action only in a branch.')
 
154
                self.comm.set_busy(self.window, False)
 
155
                return
 
156
            except errors.NonExistingParent, errmsg:
 
157
                self.dialog.error_dialog("Non existing parent directory",
 
158
                                         "The parent directory (%s)\ndoesn't exist." % errmsg)
 
159
                self.comm.set_busy(self.window, False)
 
160
                return
 
161
            except errors.DivergedBranchesError:
 
162
                self.dialog.error_dialog('Branches have been diverged',
 
163
                                         'You cannot push if branches have diverged. Use the\noverwrite option if you want to push anyway.')
 
164
                self.comm.set_busy(self.window, False)
 
165
                return
 
166
            except errors.PathPrefixNotCreated:
 
167
                self.dialog.error_dialog("Path prefix not created",
 
168
                                         "The path leading up to the specified location couldn't\nbe created.")
 
169
                self.comm.set_busy(self.window, False)
 
170
                return
 
171
            except:
 
172
                raise
 
173
        else:
 
174
            # This should really never happen
 
175
            pass
134
176
        
135
177
        self.close()
136
 
        info_dialog(_('Push successful'),
137
 
                                _('%d revision(s) pushed.') % revs)
138
 
    
139
 
    def test(self, widget):
140
 
        """ Test if write access possible. """
141
 
        import re
142
 
        _urlRE = re.compile(r'^(?P<proto>[^:/\\]+)://(?P<path>.*)$')
143
 
        
144
 
        if self.radio_stored.get_active():
145
 
            url = self.entry_stored.get_text()
146
 
        elif self.radio_specific.get_active():
147
 
            url = self.entry_location.get_text()
148
 
        
149
 
        m = _urlRE.match(url)
150
 
        if m:
151
 
            proto = m.groupdict()['proto']
152
 
            if (proto == 'sftp') or (proto == 'file') or (proto == 'ftp'):
153
 
                # have write acces (most probably)
154
 
                self.image_test.set_from_stock(gtk.STOCK_YES, 4)
155
 
                self.label_test.set_markup(_('<b>Write access is probably available</b>'))
156
 
            else:
157
 
                # no write access
158
 
                self.image_test.set_from_stock(gtk.STOCK_NO, 4)
159
 
                self.label_test.set_markup(_('<b>No write access</b>'))
160
 
        else:
161
 
            # couldn't determine
162
 
            self.image_test.set_from_stock(gtk.STOCK_DIALOG_QUESTION, 4)
163
 
            self.label_test.set_markup(_('<b>Could not determine</b>'))
 
178
        self.dialog.info_dialog('Push successful',
 
179
                                '%d revision(s) pushed.' % revs)
164
180
    
165
181
    def close(self, widget=None):
166
182
        self.window.destroy()
167
 
 
168
 
def do_push(branch, location=None, remember=False, overwrite=False,
169
 
         create_prefix=False):
170
 
    """ Update a mirror of a branch.
171
 
    
172
 
    :param branch: the source branch
173
 
    
174
 
    :param location: the location of the branch that you'd like to update
175
 
    
176
 
    :param remember: if set, the location will be stored
177
 
    
178
 
    :param overwrite: overwrite target location if it diverged
179
 
    
180
 
    :param create_prefix: create the path leading up to the branch if it doesn't exist
181
 
    
182
 
    :return: number of revisions pushed
183
 
    """
184
 
    from bzrlib.branch import Branch
185
 
    from bzrlib.bzrdir import BzrDir
186
 
    from bzrlib.transport import get_transport
187
 
        
188
 
    br_from = Branch.open_containing(branch)[0]
189
 
    
190
 
    stored_loc = br_from.get_push_location()
191
 
    if location is None:
192
 
        if stored_loc is None:
193
 
            error_dialog(_('Push location is unknown'),
194
 
                                     _('Please specify a location manually.'))
195
 
            return
196
 
        else:
197
 
            location = stored_loc
198
 
 
199
 
    transport = get_transport(location)
200
 
    location_url = transport.base
201
 
 
202
 
    if br_from.get_push_location() is None or remember:
203
 
        br_from.set_push_location(location_url)
204
 
 
205
 
    old_rh = []
206
 
 
207
 
    try:
208
 
        dir_to = BzrDir.open(location_url)
209
 
        br_to = dir_to.open_branch()
210
 
    except errors.NotBranchError:
211
 
        # create a branch.
212
 
        transport = transport.clone('..')
213
 
        if not create_prefix:
214
 
            try:
215
 
                relurl = transport.relpath(location_url)
216
 
                transport.mkdir(relurl)
217
 
            except errors.NoSuchFile:
218
 
                error_dialog(_('Non existing parent directory'),
219
 
                                         _("The parent directory (%s)\ndoesn't exist.") % location)
220
 
                return
221
 
        else:
222
 
            current = transport.base
223
 
            needed = [(transport, transport.relpath(location_url))]
224
 
            while needed:
225
 
                try:
226
 
                    transport, relpath = needed[-1]
227
 
                    transport.mkdir(relpath)
228
 
                    needed.pop()
229
 
                except errors.NoSuchFile:
230
 
                    new_transport = transport.clone('..')
231
 
                    needed.append((new_transport,
232
 
                                   new_transport.relpath(transport.base)))
233
 
                    if new_transport.base == transport.base:
234
 
                        error_dialog(_('Path prefix not created'),
235
 
                                                 _("The path leading up to the specified location couldn't\nbe created."))
236
 
                        return
237
 
        dir_to = br_from.bzrdir.clone(location_url,
238
 
            revision_id=br_from.last_revision())
239
 
        br_to = dir_to.open_branch()
240
 
        count = len(br_to.revision_history())
241
 
    else:
242
 
        old_rh = br_to.revision_history()
243
 
        try:
244
 
            tree_to = dir_to.open_workingtree()
245
 
        except errors.NotLocalUrl:
246
 
            # FIXME - what to do here? how should we warn the user?
247
 
            #warning('This transport does not update the working '
248
 
            #        'tree of: %s' % (br_to.base,))
249
 
            count = br_to.pull(br_from, overwrite)
250
 
        except errors.NoWorkingTree:
251
 
            count = br_to.pull(br_from, overwrite)
252
 
        else:
253
 
            count = tree_to.pull(br_from, overwrite)
254
 
 
255
 
    return count