/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 checkout.py

  • Committer: Jelmer Vernooij
  • Date: 2007-02-03 14:19:44 UTC
  • Revision ID: jelmer@samba.org-20070203141944-oa6iqhetsy0slqo0
Fix references to dialog.

Show diffs side-by-side

added added

removed removed

Lines of Context:
checkout.py
23
23
    pass
24
24
 
25
25
import gtk
26
 
import gtk.glade
 
26
 
 
27
from olive import delimiter
 
28
from errors import show_bzr_error
27
29
 
28
30
from bzrlib.branch import Branch
29
 
import bzrlib.bzrdir as bzrdir
30
 
import bzrlib.errors as errors
31
 
import bzrlib.osutils
32
 
 
33
 
from olive import gladefile
34
 
from dialog import error_dialog
35
 
 
36
 
class OliveCheckout:
37
 
    """ Display checkout dialog and perform the needed operations. """
38
 
    def __init__(self, path=None):
 
31
from bzrlib.config import GlobalConfig
 
32
 
 
33
from olive.dialog import error_dialog
 
34
 
 
35
 
 
36
class CheckoutDialog(gtk.Dialog):
 
37
    """ New implementation of the Checkout dialog. """
 
38
    def __init__(self, path=None, parent=None):
39
39
        """ Initialize the Checkout dialog. """
40
 
        self.glade = gtk.glade.XML(gladefile, 'window_checkout', 'olive-gtk')
41
 
        
42
 
        self.window = self.glade.get_widget('window_checkout')
43
 
        
44
 
        # Dictionary for signal_autoconnect
45
 
        dic = { "on_button_checkout_checkout_clicked": self.checkout,
46
 
                "on_button_checkout_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_checkout')
53
 
        if path is not None:
54
 
            self.filechooser.set_filename(path)
55
 
 
56
 
    def display(self):
57
 
        """ Display the Checkout dialog. """
58
 
        self.window.show_all()
59
 
    
60
 
    def checkout(self, widget):
61
 
        entry_location = self.glade.get_widget('entry_checkout_location')
62
 
        location = entry_location.get_text()
 
40
        gtk.Dialog.__init__(self, title="Checkout - Olive",
 
41
                                  parent=parent,
 
42
                                  flags=0,
 
43
                                  buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))
 
44
        
 
45
        # Get arguments
 
46
        self.path = path
 
47
        
 
48
        # Create the widgets
 
49
        self._button_checkout = gtk.Button(_("Check_out"), use_underline=True)
 
50
        self._button_revision = gtk.Button('')
 
51
        self._image_browse = gtk.Image()
 
52
        self._filechooser = gtk.FileChooserButton(_("Please select a folder"))
 
53
        self._combo = gtk.ComboBoxEntry()
 
54
        self._label_location = gtk.Label(_("Branch location:"))
 
55
        self._label_destination = gtk.Label(_("Destination:"))
 
56
        self._label_nick = gtk.Label(_("Branck nick:"))
 
57
        self._label_revision = gtk.Label(_("Revision:"))
 
58
        self._hbox_revision = gtk.HBox()
 
59
        self._entry_revision = gtk.Entry()
 
60
        self._entry_nick = gtk.Entry()
 
61
        self._check_lightweight = gtk.CheckButton(_("_Lightweight checkout"),
 
62
                                                  use_underline=True)
 
63
        
 
64
        # Set callbacks
 
65
        self._button_checkout.connect('clicked', self._on_checkout_clicked)
 
66
        self._button_revision.connect('clicked', self._on_revision_clicked)
 
67
        self._combo.connect('changed', self._on_combo_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._label_destination, 0, 1, 1, 2)
 
73
        self._table.attach(self._label_nick, 0, 1, 2, 3)
 
74
        self._table.attach(self._label_revision, 0, 1, 3, 4)
 
75
        self._table.attach(self._combo, 1, 2, 0, 1)
 
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
        self._table.attach(self._check_lightweight, 1, 2, 4, 5)
 
80
        
 
81
        # Set properties
 
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._filechooser.set_action(gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
 
86
        self._label_location.set_alignment(0, 0.5)
 
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 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_checkout)
 
101
        
 
102
        # Show the dialog
 
103
        self.vbox.show_all()
 
104
        
 
105
        # Build checkout history
 
106
        self._build_history()
 
107
    
 
108
    def _build_history(self):
 
109
        """ Build up the checkout history. """
 
110
        config = GlobalConfig()
 
111
        history = config.get_user_option('gcheckout_history')
 
112
        if history is not None:
 
113
            self._combo_model = gtk.ListStore(str)
 
114
            for item in history.split(delimiter):
 
115
                self._combo_model.append([ item ])
 
116
            self._combo.set_model(self._combo_model)
 
117
            self._combo.set_text_column(0)
 
118
    
 
119
    def _add_to_history(self, location):
 
120
        """ Add specified location to the history (if not yet added). """
 
121
        config = GlobalConfig()
 
122
        history = config.get_user_option('gcheckout_history')
 
123
        if history is None:
 
124
            config.set_user_option('gcheckout_history', location)
 
125
        else:
 
126
            h = history.split(delimiter)
 
127
            if location not in h:
 
128
                h.append(location)
 
129
            config.set_user_option('gcheckout_history', delimiter.join(h))                
 
130
    
 
131
    def _get_last_revno(self):
 
132
        """ Get the revno of the last revision (if any). """
 
133
        location = self._combo.get_child().get_text()
 
134
        try:
 
135
            br = Branch.open(location)
 
136
        except:
 
137
            return None
 
138
        else:
 
139
            return br.revno()
 
140
    
 
141
    def _on_revision_clicked(self, button):
 
142
        """ Browse for revision button clicked handler. """
 
143
        from revbrowser import RevisionBrowser
 
144
        
 
145
        location = self._combo.get_child().get_text()
 
146
        
 
147
        try:
 
148
            br = Branch.open(location)
 
149
        except:
 
150
            return
 
151
        else:
 
152
            revb = RevisionBrowser(br, self)
 
153
            response = revb.run()
 
154
            if response != gtk.RESPONSE_NONE:
 
155
                revb.hide()
 
156
        
 
157
                if response == gtk.RESPONSE_OK:
 
158
                    if revb.selected_revno is not None:
 
159
                        self._entry_revision.set_text(revb.selected_revno)
 
160
            
 
161
                revb.destroy()
 
162
    
 
163
    @show_bzr_error
 
164
    def _on_checkout_clicked(self, button):
 
165
        """ Checkout button clicked handler. """
 
166
        location = self._combo.get_child().get_text()
63
167
        if location is '':
64
168
            error_dialog(_('Missing branch location'),
65
169
                         _('You must specify a branch location.'))
66
170
            return
67
171
        
68
 
        destination = self.filechooser.get_filename()
69
 
        
70
 
        spinbutton_revno = self.glade.get_widget('spinbutton_checkout_revno')
71
 
        revno = spinbutton_revno.get_value_as_int()
72
 
        
73
 
        checkbutton_lightweight = self.glade.get_widget('checkbutton_checkout_lightweight')
74
 
        lightweight = checkbutton_lightweight.get_active()
75
 
        
 
172
        destination = self._filechooser.get_filename()
76
173
        try:
77
 
            source = Branch.open(location)
78
 
            rev_id = source.get_rev_id(revno)
79
 
            
80
 
            # if the source and destination are the same, 
81
 
            # and there is no working tree,
82
 
            # then reconstitute a branch
83
 
            if (bzrlib.osutils.abspath(destination) ==
84
 
                bzrlib.osutils.abspath(location)):
85
 
                try:
86
 
                    source.bzrdir.open_workingtree()
87
 
                except errors.NoWorkingTree:
88
 
                    source.bzrdir.create_workingtree()
89
 
                    return
90
 
 
91
 
            destination = destination + '/' + os.path.basename(location.rstrip("/\\"))
92
 
            
93
 
            os.mkdir(destination)
94
 
 
95
 
            old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
96
 
            bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
97
 
 
98
 
            try:
99
 
                if lightweight:
100
 
                    checkout = bzrdir.BzrDirMetaFormat1().initialize(destination)
101
 
                    bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
102
 
                else:
103
 
                    checkout_branch = bzrlib.bzrdir.BzrDir.create_branch_convenience(
104
 
                        destination, force_new_tree=False)
105
 
                    checkout = checkout_branch.bzrdir
106
 
                    checkout_branch.bind(source)
107
 
                    if rev_id is not None:
108
 
                        rh = checkout_branch.revno_history()
109
 
                        checkout_branch.set_revno_history(rh[:rh.index(rev_id) + 1])
110
 
 
111
 
                checkout.create_workingtree(rev_id)
112
 
            finally:
113
 
                bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
114
 
        except errors.NotBranchError, errmsg:
115
 
            error_dialog(_('Location is not a branch'),
116
 
                         _('The specified location has to be a branch.'))
117
 
            return
118
 
        except errors.TargetAlreadyExists, errmsg:
119
 
            error_dialog(_('Target already exists'),
120
 
                         _('Target directory (%s)\nalready exists. Please select another target.') % errmsg)
121
 
            return
122
 
        except errors.NonExistingParent, errmsg:
123
 
            error_dialog(_('Non existing parent directory'),
124
 
                         _("The parent directory (%s)\ndoesn't exist.") % errmsg)
125
 
            return
126
 
        
127
 
        self.close()
128
 
        self.comm.refresh_right()
129
 
 
130
 
    def close(self, widget=None):
131
 
        self.window.destroy()
 
174
            revno = int(self._entry_revision.get_text())
 
175
        except:
 
176
            revno = None
 
177
        
 
178
        nick = self._entry_nick.get_text()
 
179
        if nick is '':
 
180
            nick = os.path.basename(location.rstrip("/\\"))
 
181
        
 
182
        br_from = Branch.open(location)
 
183
        
 
184
        revision_id = br_from.get_rev_id(revno)
 
185
        lightweight = self._check_lightweight.get_active()
 
186
        to_location = destination + os.sep + nick
 
187
        
 
188
        os.mkdir(to_location)
 
189
        
 
190
        br_from.create_checkout(to_location, revision_id, lightweight)
 
191
        
 
192
        self._add_to_history(location)
 
193
        
 
194
        self.response(gtk.RESPONSE_OK)
 
195
    
 
196
    def _on_combo_changed(self, widget):
 
197
        """ We try to get the last revision if focus lost. """
 
198
        rev = self._get_last_revno()
 
199
        if rev is None:
 
200
            self._entry_revision.set_text(_('N/A'))
 
201
            self._button_revision.set_sensitive(False)
 
202
        else:
 
203
            self._entry_revision.set_text(str(rev))
 
204
            self._button_revision.set_sensitive(True)
 
205
            if self._entry_nick.get_text() == '':
 
206
                self._entry_nick.set_text(os.path.basename(self._combo.get_child().get_text().rstrip("/\\")))