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

  • Committer: Jelmer Vernooij
  • Date: 2007-02-01 15:50:40 UTC
  • Revision ID: jelmer@samba.org-20070201155040-3hq4mfbxs99kzazy
add framework for tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
23
23
    pass
24
24
 
25
25
import gtk
26
 
 
27
 
from errors import show_bzr_error
 
26
import gtk.glade
28
27
 
29
28
from bzrlib.branch import Branch
30
 
from bzrlib.config import GlobalConfig
31
29
import bzrlib.errors as errors
32
30
 
33
31
from dialog import error_dialog, info_dialog
34
 
 
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):
 
32
from guifiles import GLADEFILENAME
 
33
 
 
34
 
 
35
class BranchDialog:
 
36
    """ Display branch dialog and perform the needed operations. """
 
37
    def __init__(self, path=None):
42
38
        """ Initialize the Branch dialog. """
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()
 
39
        self.glade = gtk.glade.XML(GLADEFILENAME, 'window_branch', 'olive-gtk')
 
40
 
 
41
        self.window = self.glade.get_widget('window_branch')
 
42
        
 
43
        # Dictionary for signal_autoconnect
 
44
        dic = { "on_button_branch_branch_clicked": self.branch,
 
45
                "on_button_branch_cancel_clicked": self.close }
 
46
        
 
47
        # Connect the signals to the handlers
 
48
        self.glade.signal_autoconnect(dic)
 
49
        
 
50
        # Save FileChooser state
 
51
        self.filechooser = self.glade.get_widget('filechooserbutton_branch')
 
52
        if path is not None:
 
53
            self.filechooser.set_filename(path)
 
54
 
 
55
    def display(self):
 
56
        """ Display the Branch dialog. """
 
57
        self.window.show_all()
 
58
    
 
59
    def branch(self, widget):
 
60
        entry_location = self.glade.get_widget('entry_branch_location')
 
61
        location = entry_location.get_text()
161
62
        if location is '':
162
63
            error_dialog(_('Missing branch location'),
163
64
                         _('You must specify a branch location.'))
164
65
            return
165
66
        
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()
 
67
        destination = self.filechooser.get_filename()
 
68
        
 
69
        spinbutton_revno = self.glade.get_widget('spinbutton_branch_revno')
 
70
        revno = spinbutton_revno.get_value_as_int()
 
71
        
179
72
        try:
180
73
            from bzrlib.transport import get_transport
181
74
 
 
75
            br_from = Branch.open(location)
 
76
            br_from.lock_read()
 
77
            
182
78
            revision_id = br_from.get_rev_id(revno)
183
79
 
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
 
            
191
80
            try:
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()
 
81
                destination = destination + '/' + os.path.basename(location.rstrip("/\\"))
 
82
                to_transport = get_transport(destination)
 
83
                to_transport.mkdir('.')
 
84
 
 
85
                try:
 
86
                    dir = br_from.bzrdir.sprout(to_transport.base, revision_id)
 
87
                    branch = dir.open_branch()
 
88
                    revs = branch.revno()
 
89
                except errors.NoSuchRevision:
 
90
                    to_transport.delete_tree('.')
 
91
                    raise
 
92
 
 
93
            finally:
 
94
                br_from.unlock()
203
95
                
204
 
        self._history.add_entry(location)
205
 
        info_dialog(_('Branching successful'),
206
 
                    _('%d revision(s) branched.') % revs)
 
96
            self.close()
 
97
            info_dialog(_('Branching successful'),
 
98
                        _('%d revision(s) branched.') % revs)
 
99
        except errors.NonExistingSource, errmsg:
 
100
            error_dialog(_('Non existing source'),
 
101
                         _("The location (%s)\ndoesn't exist.") % errmsg)
 
102
            return
 
103
        except errors.TargetAlreadyExists, errmsg:
 
104
            error_dialog(_('Target already exists'),
 
105
                         _('Target directory (%s)\nalready exists. Please select another target.') % errmsg)
 
106
            return
 
107
        except errors.NonExistingParent, errmsg:
 
108
            error_dialog(_('Non existing parent directory'),
 
109
                         _("The parent directory (%s)\ndoesn't exist.") % errmsg)
 
110
            return
 
111
        except errors.NonExistingRevision:
 
112
            error_dialog(_('Non existing revision'),
 
113
                         _("The revision you specified doesn't exist."))
 
114
            return
 
115
        except errors.NotBranchError, errmsg:
 
116
            error_dialog(_('Location is not a branch'),
 
117
                         _('The specified location has to be a branch.'))
 
118
            return
207
119
        
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("/\\")))
 
120
    def close(self, widget=None):
 
121
        self.window.destroy()