/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: Alexander Belchenko
  • Date: 2006-10-05 14:06:23 UTC
  • mto: (93.1.1 win32.bialix)
  • mto: This revision was merged to the branch mainline in revision 103.
  • Revision ID: bialix@ukr.net-20061005140623-8026d413daa4d619
Added Makefile for building windows python-based installer

Show diffs side-by-side

added added

removed removed

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