/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: Vincent Ladeuil
  • Date: 2008-06-10 15:25:47 UTC
  • mto: This revision was merged to the branch mainline in revision 504.
  • Revision ID: v.ladeuil+lp@free.fr-20080610152547-dwmil1p8pd0mfpnl
Fix third failing test (thanks to jam).

* tests/test_commit.py:
(TestPendingRevisions.test_pending_revisions_multi_merge): Fix
provided by jam: bzr we now filter the pending merges so that only
the 'heads()' are included. We just ensure that the pending merges
contain the unique tips for the ancestries.

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
29
30
import bzrlib.errors as errors
30
31
 
31
 
from olive import gladefile
 
32
from bzrlib.plugins.gtk import _i18n
 
33
 
32
34
from dialog import error_dialog, info_dialog
33
35
 
34
 
class OliveBranch:
35
 
    """ Display branch dialog and perform the needed operations. """
36
 
    def __init__(self, path=None):
 
36
from branchbox import BranchSelectionBox
 
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(_i18n("_Branch"), use_underline=True)
 
53
        self._remote_branch = BranchSelectionBox()
 
54
        self._button_revision = gtk.Button('')
 
55
        self._label_location = gtk.Label(_i18n("Branch location:"))
 
56
        self._label_location.set_alignment(0, 0.5)
 
57
        self._label_destination = gtk.Label(_i18n("Destination:"))
 
58
        self._label_nick = gtk.Label(_i18n("Branck nick:"))
 
59
        self._label_revision = gtk.Label(_i18n("Revision:"))
 
60
        self._filechooser = gtk.FileChooserButton(_i18n("Please select a folder"))
 
61
        self._filechooser.set_action(gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
 
62
        self._hbox_revision = gtk.HBox()
 
63
        self._entry_revision = gtk.Entry()
 
64
        self._entry_nick = gtk.Entry()
 
65
        
 
66
        # Set callbacks
 
67
        self._button_branch.connect('clicked', self._on_branch_clicked)
 
68
        self._button_revision.connect('clicked', self._on_revision_clicked)
 
69
        self._remote_branch.connect('branch-changed', self._on_branch_changed)
 
70
 
 
71
        # Create the table and pack the widgets into it
 
72
        self._table = gtk.Table(rows=3, columns=2)
 
73
        self._table.attach(self._label_location, 0, 1, 0, 1)
 
74
        self._table.attach(self._remote_branch, 1, 2, 0, 1)
 
75
        self._table.attach(self._label_destination, 0, 1, 1, 2)
 
76
        self._table.attach(self._label_nick, 0, 1, 2, 3)
 
77
        self._table.attach(self._label_revision, 0, 1, 3, 4)
 
78
        self._table.attach(self._filechooser, 1, 2, 1, 2)
 
79
        self._table.attach(self._entry_nick, 1, 2, 2, 3)
 
80
        self._table.attach(self._hbox_revision, 1, 2, 3, 4)
 
81
        
 
82
        # Set properties
 
83
        self._image_browse = gtk.Image()
 
84
        self._image_browse.set_from_stock(gtk.STOCK_OPEN, gtk.ICON_SIZE_BUTTON)
 
85
        self._button_revision.set_image(self._image_browse)
 
86
        self._button_revision.set_sensitive(False)
 
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 remote_path is not None:
 
94
            self._remote_branch.set_url(remote_path)
 
95
        if self.path is not None:
 
96
            self._filechooser.set_filename(self.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
    def _get_last_revno(self):
 
108
        """ Get the revno of the last revision (if any). """
 
109
        try:
 
110
            br = self._remote_branch.get_branch()
 
111
            return br.revno()
 
112
        except:
 
113
            pass
 
114
    
 
115
    def _on_revision_clicked(self, button):
 
116
        """ Browse for revision button clicked handler. """
 
117
        from revbrowser import RevisionBrowser
 
118
        
 
119
        
 
120
        try:
 
121
            br = self._remote_branch.get_branch()
 
122
        except:
 
123
            return
 
124
        revb = RevisionBrowser(br, self)
 
125
        response = revb.run()
 
126
        if response != gtk.RESPONSE_NONE:
 
127
            revb.hide()
 
128
    
 
129
            if response == gtk.RESPONSE_OK:
 
130
                if revb.selected_revno is not None:
 
131
                    self._entry_revision.set_text(revb.selected_revno)
 
132
        
 
133
            revb.destroy()
 
134
    
 
135
    @show_bzr_error
 
136
    def _on_branch_clicked(self, button):
 
137
        """ Branch button clicked handler. """
 
138
        location = self._remote_branch.get_url()
61
139
        if location is '':
62
 
            error_dialog(_('Missing branch location'),
63
 
                         _('You must specify a branch location.'))
 
140
            error_dialog(_i18n('Missing branch location'),
 
141
                         _i18n('You must specify a branch location.'))
64
142
            return
65
143
        
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
 
        
 
144
        destination = self._filechooser.get_filename()
 
145
        try:
 
146
            revno = int(self._entry_revision.get_text())
 
147
        except:
 
148
            revno = None
 
149
        
 
150
        nick = self._entry_nick.get_text()
 
151
        if nick is '':
 
152
            nick = os.path.basename(location.rstrip("/\\"))
 
153
        
 
154
        br_from = Branch.open(location)
 
155
        
 
156
        br_from.lock_read()
71
157
        try:
72
158
            from bzrlib.transport import get_transport
73
159
 
74
 
            br_from = Branch.open(location)
75
 
            br_from.lock_read()
76
 
            
77
160
            revision_id = br_from.get_rev_id(revno)
78
161
 
 
162
            basis_dir = None
 
163
            
 
164
            to_location = destination + os.sep + nick
 
165
            to_transport = get_transport(to_location)
 
166
            
 
167
            to_transport.mkdir('.')
 
168
            
79
169
            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()
 
170
                # preserve whatever source format we have.
 
171
                dir = br_from.bzrdir.sprout(to_transport.base,
 
172
                                            revision_id,
 
173
                                            basis_dir)
 
174
                branch = dir.open_branch()
 
175
                revs = branch.revno()
 
176
            except errors.NoSuchRevision:
 
177
                to_transport.delete_tree('.')
 
178
                raise
 
179
        finally:
 
180
            br_from.unlock()
94
181
                
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
 
182
        info_dialog(_i18n('Branching successful'),
 
183
                    _i18n('%d revision(s) branched.') % revs)
118
184
        
119
 
    def close(self, widget=None):
120
 
        self.window.destroy()
 
185
        self.response(gtk.RESPONSE_OK)
 
186
    
 
187
    def _on_branch_changed(self, widget, event):
 
188
        """ We try to get the last revision if focus lost. """
 
189
        rev = self._get_last_revno()
 
190
        if rev is None:
 
191
            self._entry_revision.set_text(_i18n('N/A'))
 
192
            self._button_revision.set_sensitive(False)
 
193
        else:
 
194
            self._entry_revision.set_text(str(rev))
 
195
            self._button_revision.set_sensitive(True)
 
196
            if self._entry_nick.get_text() == '':
 
197
                self._entry_nick.set_text(os.path.basename(self._remote_branch.get_url().rstrip("/\\")))