/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
 
 
30
 
import olive.backend.init as init
31
 
import olive.backend.errors as errors
32
 
 
33
 
class OliveBranch:
34
 
    """ Display branch dialog and perform the needed operations. """
35
 
    def __init__(self, gladefile, comm, dialog):
 
24
 
 
25
import gtk
 
26
 
 
27
from errors import show_bzr_error
 
28
 
 
29
from bzrlib.branch import Branch
 
30
import bzrlib.errors as errors
 
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):
36
42
        """ Initialize the Branch dialog. """
37
 
        self.gladefile = gladefile
38
 
        self.glade = gtk.glade.XML(self.gladefile, 'window_branch', 'olive-gtk')
39
 
        
40
 
        # Communication object
41
 
        self.comm = comm
42
 
        # Dialog object
43
 
        self.dialog = dialog
44
 
        
45
 
        self.window = self.glade.get_widget('window_branch')
46
 
        
47
 
        # Dictionary for signal_autoconnect
48
 
        dic = { "on_button_branch_branch_clicked": self.branch,
49
 
                "on_button_branch_cancel_clicked": self.close }
50
 
        
51
 
        # Connect the signals to the handlers
52
 
        self.glade.signal_autoconnect(dic)
53
 
        
54
 
        # Save FileChooser state
55
 
        self.filechooser = self.glade.get_widget('filechooserbutton_branch')
56
 
        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)
57
70
 
58
 
    def display(self):
59
 
        """ Display the Branch dialog. """
60
 
        self.window.show_all()
61
 
    
62
 
    def branch(self, widget):
63
 
        entry_location = self.glade.get_widget('entry_branch_location')
64
 
        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()
65
139
        if location is '':
66
 
            self.dialog.error_dialog(_('Missing branch location'),
67
 
                                     _('You must specify a branch location.'))
 
140
            error_dialog(_i18n('Missing branch location'),
 
141
                         _i18n('You must specify a branch location.'))
68
142
            return
69
143
        
70
 
        destination = self.filechooser.get_filename()
71
 
        
72
 
        spinbutton_revno = self.glade.get_widget('spinbutton_branch_revno')
73
 
        revno = spinbutton_revno.get_value_as_int()
74
 
        if revno == 0:
 
144
        destination = self._filechooser.get_filename()
 
145
        try:
 
146
            revno = int(self._entry_revision.get_text())
 
147
        except:
75
148
            revno = None
76
149
        
77
 
        self.comm.set_busy(self.window)
 
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()
78
157
        try:
79
 
            revs = init.branch(location, destination, revno)
80
 
        except errors.NonExistingSource, errmsg:
81
 
            self.dialog.error_dialog(_('Non existing source'),
82
 
                                     _("The location (%s)\ndoesn't exist.") % errmsg)
83
 
            self.comm.set_busy(self.window, False)
84
 
            return
85
 
        except errors.TargetAlreadyExists, errmsg:
86
 
            self.dialog.error_dialog(_('Target already exists'),
87
 
                                     _('Target directory (%s)\nalready exists. Please select another target.') % errmsg)
88
 
            self.comm.set_busy(self.window, False)
89
 
            return
90
 
        except errors.NonExistingParent, errmsg:
91
 
            self.dialog.error_dialog(_('Non existing parent directory'),
92
 
                                     _("The parent directory (%s)\ndoesn't exist.") % errmsg)
93
 
            self.comm.set_busy(self.window, False)
94
 
            return
95
 
        except errors.NonExistingRevision:
96
 
            self.dialog.error_dialog(_('Non existing revision'),
97
 
                                     _("The revision you specified doesn't exist."))
98
 
            self.comm.set_busy(self.window, False)
99
 
            return
100
 
        except errors.NotBranchError, errmsg:
101
 
            self.dialog.error_dialog(_('Location is not a branch'),
102
 
                                     _('The specified location has to be a branch.'))
103
 
            self.comm.set_busy(self.window, False)
104
 
            return
105
 
        except:
106
 
            raise
 
158
            from bzrlib.transport import get_transport
 
159
 
 
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
            
 
169
            try:
 
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()
 
181
                
 
182
        info_dialog(_i18n('Branching successful'),
 
183
                    _i18n('%d revision(s) branched.') % revs)
107
184
        
108
 
        self.close()
109
 
        self.dialog.info_dialog(_('Branching successful'),
110
 
                                _('%d revision(s) branched.') % revs)
111
 
        self.comm.refresh_right()
112
 
 
113
 
    def close(self, widget=None):
114
 
        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("/\\")))