/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-03-09 17:47:28 UTC
  • Revision ID: jelmer@samba.org-20070309174728-gljlmt9b7fu0rrn9
Add simple test for tortoise_bzr

Show diffs side-by-side

added added

removed removed

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