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