/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
 
 
37
 
class BranchDialog(gtk.Dialog):
38
 
    """ New implementation of the Branch dialog. """
39
 
    def __init__(self, path=None, parent=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):
40
38
        """ Initialize the Branch dialog. """
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()
 
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()
151
62
        if location is '':
152
63
            error_dialog(_('Missing branch location'),
153
64
                         _('You must specify a branch location.'))
154
65
            return
155
66
        
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()
 
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
        
169
72
        try:
170
73
            from bzrlib.transport import get_transport
171
74
 
 
75
            br_from = Branch.open(location)
 
76
            br_from.lock_read()
 
77
            
172
78
            revision_id = br_from.get_rev_id(revno)
173
79
 
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
 
            
181
80
            try:
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()
 
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()
193
95
                
194
 
        self._history.add_entry(location)
195
 
        info_dialog(_('Branching successful'),
196
 
                    _('%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
197
119
        
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("/\\")))
 
120
    def close(self, widget=None):
 
121
        self.window.destroy()