/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 branch.py

  • Committer: Jelmer Vernooij
  • Date: 2007-07-15 15:05:06 UTC
  • Revision ID: jelmer@samba.org-20070715150506-1uemecr5kt7d4kvg
Fix whitespace, add comment.

Show diffs side-by-side

added added

removed removed

Lines of Context:
23
23
    pass
24
24
 
25
25
import gtk
26
 
import gtk.glade
 
26
 
 
27
from errors import show_bzr_error
27
28
 
28
29
from bzrlib.branch import Branch
 
30
from bzrlib.config import GlobalConfig
29
31
import bzrlib.errors as errors
30
32
 
31
 
from olive import gladefile
32
33
from dialog import error_dialog, info_dialog
33
34
 
34
 
class OliveBranch:
35
 
    """ Display branch dialog and perform the needed operations. """
36
 
    def __init__(self, path=None):
 
35
from history import UrlHistory
 
36
from olive import Preferences
 
37
 
 
38
class BranchDialog(gtk.Dialog):
 
39
    """ New implementation of the Branch dialog. """
 
40
 
 
41
    def __init__(self, path=None, parent=None, remote_path=None):
37
42
        """ Initialize the Branch dialog. """
38
 
        self.glade = gtk.glade.XML(gladefile, 'window_branch', 'olive-gtk')
39
 
 
40
 
        self.window = self.glade.get_widget('window_branch')
41
 
        
42
 
        # Dictionary for signal_autoconnect
43
 
        dic = { "on_button_branch_branch_clicked": self.branch,
44
 
                "on_button_branch_cancel_clicked": self.close }
45
 
        
46
 
        # Connect the signals to the handlers
47
 
        self.glade.signal_autoconnect(dic)
48
 
        
49
 
        # Save FileChooser state
50
 
        self.filechooser = self.glade.get_widget('filechooserbutton_branch')
51
 
        if path is not None:
52
 
            self.filechooser.set_filename(path)
53
 
 
54
 
    def display(self):
55
 
        """ Display the Branch dialog. """
56
 
        self.window.show_all()
57
 
    
58
 
    def branch(self, widget):
59
 
        entry_location = self.glade.get_widget('entry_branch_location')
60
 
        location = entry_location.get_text()
 
43
        gtk.Dialog.__init__(self, title="Branch - Olive",
 
44
                                  parent=parent,
 
45
                                  flags=0,
 
46
                                  buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))
 
47
        
 
48
        # Get arguments
 
49
        self.path = path
 
50
        
 
51
        # Create the widgets
 
52
        self._button_branch = gtk.Button(_("_Branch"), use_underline=True)
 
53
        self._button_revision = gtk.Button('')
 
54
        self._image_browse = gtk.Image()
 
55
        self._filechooser = gtk.FileChooserButton(_("Please select a folder"))
 
56
        self._combo = gtk.ComboBoxEntry()
 
57
        self._label_location = gtk.Label(_("Branch location:"))
 
58
        self._label_destination = gtk.Label(_("Destination:"))
 
59
        self._label_nick = gtk.Label(_("Branck nick:"))
 
60
        self._label_revision = gtk.Label(_("Revision:"))
 
61
        self._hbox_revision = gtk.HBox()
 
62
        self._entry_revision = gtk.Entry()
 
63
        self._entry_nick = gtk.Entry()
 
64
        
 
65
        # Set callbacks
 
66
        self._button_branch.connect('clicked', self._on_branch_clicked)
 
67
        self._button_revision.connect('clicked', self._on_revision_clicked)
 
68
        self._combo.child.connect('focus-out-event', self._on_combo_changed)
 
69
        
 
70
        # Create the table and pack the widgets into it
 
71
        self._table = gtk.Table(rows=3, columns=2)
 
72
        self._table.attach(self._label_location, 0, 1, 0, 1)
 
73
        self._table.attach(self._label_destination, 0, 1, 1, 2)
 
74
        self._table.attach(self._label_nick, 0, 1, 2, 3)
 
75
        self._table.attach(self._label_revision, 0, 1, 3, 4)
 
76
        self._table.attach(self._combo, 1, 2, 0, 1)
 
77
        self._table.attach(self._filechooser, 1, 2, 1, 2)
 
78
        self._table.attach(self._entry_nick, 1, 2, 2, 3)
 
79
        self._table.attach(self._hbox_revision, 1, 2, 3, 4)
 
80
        
 
81
        # Set properties
 
82
        self._image_browse.set_from_stock(gtk.STOCK_OPEN, gtk.ICON_SIZE_BUTTON)
 
83
        self._button_revision.set_image(self._image_browse)
 
84
        self._button_revision.set_sensitive(False)
 
85
        self._filechooser.set_action(gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
 
86
        self._label_location.set_alignment(0, 0.5)
 
87
        self._label_destination.set_alignment(0, 0.5)
 
88
        self._label_nick.set_alignment(0, 0.5)
 
89
        self._label_revision.set_alignment(0, 0.5)
 
90
        self._table.set_row_spacings(3)
 
91
        self._table.set_col_spacings(3)
 
92
        self.vbox.set_spacing(3)
 
93
        if self.path is not None:
 
94
            self._filechooser.set_filename(self.path)
 
95
        if remote_path is not None:
 
96
            self._combo.child.set_text(remote_path)
 
97
        
 
98
        # Pack some widgets
 
99
        self._hbox_revision.pack_start(self._entry_revision, True, True)
 
100
        self._hbox_revision.pack_start(self._button_revision, False, False)
 
101
        self.vbox.add(self._table)
 
102
        self.action_area.pack_end(self._button_branch)
 
103
        
 
104
        # Show the dialog
 
105
        self.vbox.show_all()
 
106
        
 
107
        # Build branch history
 
108
        self._history = UrlHistory(GlobalConfig(), 'branch_history')
 
109
        self._build_history()
 
110
    
 
111
    def _build_history(self):
 
112
        """ Build up the branch history. """
 
113
        self._combo_model = gtk.ListStore(str)
 
114
        
 
115
        for item in self._history.get_entries():
 
116
            self._combo_model.append([ item ])
 
117
        
 
118
        pref = Preferences()
 
119
        for item in pref.get_bookmarks():
 
120
            self._combo_model.append([ item ])
 
121
        
 
122
        self._combo.set_model(self._combo_model)
 
123
        self._combo.set_text_column(0)
 
124
    
 
125
    def _get_last_revno(self):
 
126
        """ Get the revno of the last revision (if any). """
 
127
        location = self._combo.get_child().get_text()
 
128
        try:
 
129
            br = Branch.open(location)
 
130
        except:
 
131
            return None
 
132
        else:
 
133
            return br.revno()
 
134
    
 
135
    def _on_revision_clicked(self, button):
 
136
        """ Browse for revision button clicked handler. """
 
137
        from revbrowser import RevisionBrowser
 
138
        
 
139
        location = self._combo.get_child().get_text()
 
140
        
 
141
        try:
 
142
            br = Branch.open(location)
 
143
        except:
 
144
            return
 
145
        else:
 
146
            revb = RevisionBrowser(br, self)
 
147
            response = revb.run()
 
148
            if response != gtk.RESPONSE_NONE:
 
149
                revb.hide()
 
150
        
 
151
                if response == gtk.RESPONSE_OK:
 
152
                    if revb.selected_revno is not None:
 
153
                        self._entry_revision.set_text(revb.selected_revno)
 
154
            
 
155
                revb.destroy()
 
156
    
 
157
    @show_bzr_error
 
158
    def _on_branch_clicked(self, button):
 
159
        """ Branch button clicked handler. """
 
160
        location = self._combo.get_child().get_text()
61
161
        if location is '':
62
162
            error_dialog(_('Missing branch location'),
63
163
                         _('You must specify a branch location.'))
64
164
            return
65
165
        
66
 
        destination = self.filechooser.get_filename()
67
 
        
68
 
        spinbutton_revno = self.glade.get_widget('spinbutton_branch_revno')
69
 
        revno = spinbutton_revno.get_value_as_int()
70
 
        
 
166
        destination = self._filechooser.get_filename()
 
167
        try:
 
168
            revno = int(self._entry_revision.get_text())
 
169
        except:
 
170
            revno = None
 
171
        
 
172
        nick = self._entry_nick.get_text()
 
173
        if nick is '':
 
174
            nick = os.path.basename(location.rstrip("/\\"))
 
175
        
 
176
        br_from = Branch.open(location)
 
177
        
 
178
        br_from.lock_read()
71
179
        try:
72
180
            from bzrlib.transport import get_transport
73
181
 
74
 
            br_from = Branch.open(location)
75
 
            br_from.lock_read()
76
 
            
77
182
            revision_id = br_from.get_rev_id(revno)
78
183
 
 
184
            basis_dir = None
 
185
            
 
186
            to_location = destination + os.sep + nick
 
187
            to_transport = get_transport(to_location)
 
188
            
 
189
            to_transport.mkdir('.')
 
190
            
79
191
            try:
80
 
                destination = destination + '/' + os.path.basename(location.rstrip("/\\"))
81
 
                to_transport = get_transport(destination)
82
 
                to_transport.mkdir('.')
83
 
 
84
 
                try:
85
 
                    dir = br_from.bzrdir.sprout(to_transport.base, revision_id)
86
 
                    branch = dir.open_branch()
87
 
                    revs = branch.revno()
88
 
                except errors.NoSuchRevision:
89
 
                    to_transport.delete_tree('.')
90
 
                    raise
91
 
 
92
 
            finally:
93
 
                br_from.unlock()
 
192
                # preserve whatever source format we have.
 
193
                dir = br_from.bzrdir.sprout(to_transport.base,
 
194
                                            revision_id,
 
195
                                            basis_dir)
 
196
                branch = dir.open_branch()
 
197
                revs = branch.revno()
 
198
            except errors.NoSuchRevision:
 
199
                to_transport.delete_tree('.')
 
200
                raise
 
201
        finally:
 
202
            br_from.unlock()
94
203
                
95
 
            self.close()
96
 
            info_dialog(_('Branching successful'),
97
 
                        _('%d revision(s) branched.') % revs)
98
 
        except errors.NonExistingSource, errmsg:
99
 
            error_dialog(_('Non existing source'),
100
 
                         _("The location (%s)\ndoesn't exist.") % errmsg)
101
 
            return
102
 
        except errors.TargetAlreadyExists, errmsg:
103
 
            error_dialog(_('Target already exists'),
104
 
                         _('Target directory (%s)\nalready exists. Please select another target.') % errmsg)
105
 
            return
106
 
        except errors.NonExistingParent, errmsg:
107
 
            error_dialog(_('Non existing parent directory'),
108
 
                         _("The parent directory (%s)\ndoesn't exist.") % errmsg)
109
 
            return
110
 
        except errors.NonExistingRevision:
111
 
            error_dialog(_('Non existing revision'),
112
 
                         _("The revision you specified doesn't exist."))
113
 
            return
114
 
        except errors.NotBranchError, errmsg:
115
 
            error_dialog(_('Location is not a branch'),
116
 
                         _('The specified location has to be a branch.'))
117
 
            return
 
204
        self._history.add_entry(location)
 
205
        info_dialog(_('Branching successful'),
 
206
                    _('%d revision(s) branched.') % revs)
118
207
        
119
 
    def close(self, widget=None):
120
 
        self.window.destroy()
 
208
        self.response(gtk.RESPONSE_OK)
 
209
    
 
210
    def _on_combo_changed(self, widget, event):
 
211
        """ We try to get the last revision if focus lost. """
 
212
        rev = self._get_last_revno()
 
213
        if rev is None:
 
214
            self._entry_revision.set_text(_('N/A'))
 
215
            self._button_revision.set_sensitive(False)
 
216
        else:
 
217
            self._entry_revision.set_text(str(rev))
 
218
            self._button_revision.set_sensitive(True)
 
219
            if self._entry_nick.get_text() == '':
 
220
                self._entry_nick.set_text(os.path.basename(self._combo.get_child().get_text().rstrip("/\\")))