/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:
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
21
21
    pygtk.require("2.0")
22
22
except:
23
23
    pass
24
 
try:
25
 
    import gtk
26
 
    import gtk.glade
27
 
except:
28
 
    sys.exit(1)
29
 
 
 
24
 
 
25
import gtk
 
26
 
 
27
from errors import show_bzr_error
 
28
 
 
29
from bzrlib.branch import Branch
30
30
import bzrlib.errors as errors
31
31
 
32
 
class OliveBranch:
33
 
    """ Display branch dialog and perform the needed operations. """
34
 
    def __init__(self, gladefile, comm):
 
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):
35
42
        """ Initialize the Branch dialog. """
36
 
        self.gladefile = gladefile
37
 
        self.glade = gtk.glade.XML(self.gladefile, 'window_branch', 'olive-gtk')
38
 
        
39
 
        # Communication object
40
 
        self.comm = comm
41
 
        
42
 
        self.window = self.glade.get_widget('window_branch')
43
 
        
44
 
        # Dictionary for signal_autoconnect
45
 
        dic = { "on_button_branch_branch_clicked": self.branch,
46
 
                "on_button_branch_cancel_clicked": self.close }
47
 
        
48
 
        # Connect the signals to the handlers
49
 
        self.glade.signal_autoconnect(dic)
50
 
        
51
 
        # Save FileChooser state
52
 
        self.filechooser = self.glade.get_widget('filechooserbutton_branch')
53
 
        self.filechooser.set_filename(self.comm.get_path())
 
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)
54
70
 
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()
 
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()
62
139
        if location is '':
63
 
            error_dialog(_('Missing branch location'),
64
 
                                     _('You must specify a branch location.'))
 
140
            error_dialog(_i18n('Missing branch location'),
 
141
                         _i18n('You must specify a branch location.'))
65
142
            return
66
143
        
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
 
        revision_id = br_from.get_rev_id(revno)
72
 
        
73
 
        self.comm.set_busy(self.window)
 
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()
74
157
        try:
75
158
            from bzrlib.transport import get_transport
76
159
 
77
 
            br_from = Branch.open(location)
78
 
 
79
 
            br_from.lock_read()
80
 
 
 
160
            revision_id = br_from.get_rev_id(revno)
 
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
            
81
169
            try:
82
 
                destination = destination + '/' + os.path.basename(location.rstrip("/\\"))
83
 
                to_transport = get_transport(destination)
84
 
 
85
 
                to_transport.mkdir('.')
86
 
 
87
 
                try:
88
 
                    dir = br_from.bzrdir.sprout(to_transport.base, revision_id)
89
 
                    branch = dir.open_branch()
90
 
                except NoSuchRevision:
91
 
                    to_transport.delete_tree('.')
92
 
                    raise
93
 
 
94
 
            finally:
95
 
                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()
96
181
                
97
 
            self.close()
98
 
            info_dialog(_('Branching successful'),
99
 
                                _('%d revision(s) branched.') % revs)
100
 
            self.comm.refresh_right()
101
 
        except errors.NonExistingSource, errmsg:
102
 
            error_dialog(_('Non existing source'),
103
 
                                     _("The location (%s)\ndoesn't exist.") % errmsg)
104
 
            self.comm.set_busy(self.window, False)
105
 
            return
106
 
        except errors.TargetAlreadyExists, errmsg:
107
 
            error_dialog(_('Target already exists'),
108
 
                                     _('Target directory (%s)\nalready exists. Please select another target.') % errmsg)
109
 
            self.comm.set_busy(self.window, False)
110
 
            return
111
 
        except errors.NonExistingParent, errmsg:
112
 
            error_dialog(_('Non existing parent directory'),
113
 
                                     _("The parent directory (%s)\ndoesn't exist.") % errmsg)
114
 
            self.comm.set_busy(self.window, False)
115
 
            return
116
 
        except errors.NonExistingRevision:
117
 
            error_dialog(_('Non existing revision'),
118
 
                                     _("The revision you specified doesn't exist."))
119
 
            self.comm.set_busy(self.window, False)
120
 
            return
121
 
        except errors.NotBranchError, errmsg:
122
 
            error_dialog(_('Location is not a branch'),
123
 
                                     _('The specified location has to be a branch.'))
124
 
            self.comm.set_busy(self.window, False)
125
 
            return
 
182
        info_dialog(_i18n('Branching successful'),
 
183
                    _i18n('%d revision(s) branched.') % revs)
126
184
        
127
 
 
128
 
    def close(self, widget=None):
129
 
        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("/\\")))