/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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
import sys
 
17
import os
18
18
 
19
19
try:
20
20
    import pygtk
23
23
    pass
24
24
 
25
25
import gtk
26
 
import gtk.glade
27
 
 
 
26
 
 
27
from errors import show_bzr_error
 
28
 
 
29
from bzrlib.branch import Branch
28
30
import bzrlib.errors as errors
29
 
from __init__ import gladefile
30
 
 
31
 
class OliveBranch:
32
 
    """ Display branch dialog and perform the needed operations. """
33
 
    def __init__(self, path=None):
 
31
 
 
32
from bzrlib.plugins.gtk import _i18n
 
33
 
 
34
from dialog import error_dialog, info_dialog
 
35
 
 
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):
34
42
        """ Initialize the Branch dialog. """
35
 
        self.glade = gtk.glade.XML(gladefile, 'window_branch', 'olive-gtk')
36
 
 
37
 
        self.window = self.glade.get_widget('window_branch')
38
 
        
39
 
        # Dictionary for signal_autoconnect
40
 
        dic = { "on_button_branch_branch_clicked": self.branch,
41
 
                "on_button_branch_cancel_clicked": self.close }
42
 
        
43
 
        # Connect the signals to the handlers
44
 
        self.glade.signal_autoconnect(dic)
45
 
        
46
 
        # Save FileChooser state
47
 
        self.filechooser = self.glade.get_widget('filechooserbutton_branch')
48
 
        if path is not None:
49
 
            self.filechooser.set_filename(path)
50
 
 
51
 
    def display(self):
52
 
        """ Display the Branch dialog. """
53
 
        self.window.show_all()
54
 
    
55
 
    def branch(self, widget):
56
 
        entry_location = self.glade.get_widget('entry_branch_location')
57
 
        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()
58
139
        if location is '':
59
 
            error_dialog(_('Missing branch location'),
60
 
                                     _('You must specify a branch location.'))
 
140
            error_dialog(_i18n('Missing branch location'),
 
141
                         _i18n('You must specify a branch location.'))
61
142
            return
62
143
        
63
 
        destination = self.filechooser.get_filename()
64
 
        
65
 
        spinbutton_revno = self.glade.get_widget('spinbutton_branch_revno')
66
 
        revno = spinbutton_revno.get_value_as_int()
67
 
        revision_id = br_from.get_rev_id(revno)
68
 
        
 
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()
69
157
        try:
70
158
            from bzrlib.transport import get_transport
71
159
 
72
 
            br_from = Branch.open(location)
73
 
            br_from.lock_read()
 
160
            revision_id = br_from.get_rev_id(revno)
74
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
            
75
169
            try:
76
 
                destination = destination + '/' + os.path.basename(location.rstrip("/\\"))
77
 
                to_transport = get_transport(destination)
78
 
                to_transport.mkdir('.')
79
 
 
80
 
                try:
81
 
                    dir = br_from.bzrdir.sprout(to_transport.base, revision_id)
82
 
                    branch = dir.open_branch()
83
 
                except NoSuchRevision:
84
 
                    to_transport.delete_tree('.')
85
 
                    raise
86
 
 
87
 
            finally:
88
 
                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()
89
181
                
90
 
            self.close()
91
 
            info_dialog(_('Branching successful'),
92
 
                        _('%d revision(s) branched.') % revs)
93
 
        except errors.NonExistingSource, errmsg:
94
 
            error_dialog(_('Non existing source'),
95
 
                                     _("The location (%s)\ndoesn't exist.") % errmsg)
96
 
            return
97
 
        except errors.TargetAlreadyExists, errmsg:
98
 
            error_dialog(_('Target already exists'),
99
 
                                     _('Target directory (%s)\nalready exists. Please select another target.') % errmsg)
100
 
            return
101
 
        except errors.NonExistingParent, errmsg:
102
 
            error_dialog(_('Non existing parent directory'),
103
 
                                     _("The parent directory (%s)\ndoesn't exist.") % errmsg)
104
 
            return
105
 
        except errors.NonExistingRevision:
106
 
            error_dialog(_('Non existing revision'),
107
 
                                     _("The revision you specified doesn't exist."))
108
 
            return
109
 
        except errors.NotBranchError, errmsg:
110
 
            error_dialog(_('Location is not a branch'),
111
 
                                     _('The specified location has to be a branch.'))
112
 
            return
 
182
        info_dialog(_i18n('Branching successful'),
 
183
                    _i18n('%d revision(s) branched.') % revs)
113
184
        
114
 
 
115
 
    def close(self, widget=None):
116
 
        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("/\\")))