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

  • Committer: Szilveszter Farkas (Phanatic)
  • Date: 2006-09-30 13:04:15 UTC
  • mto: (0.14.3 main)
  • mto: This revision was merged to the branch mainline in revision 86.
  • Revision ID: Szilveszter.Farkas@gmail.com-20060930130415-aba4100709e11f0a
Loads of fixes. Pyflakes cleanup.

Show diffs side-by-side

added added

removed removed

Lines of Context:
23
23
    pass
24
24
 
25
25
import gtk
26
 
 
27
 
from bzrlib.plugins.gtk import _i18n
28
 
from errors import show_bzr_error
 
26
import gtk.glade
29
27
 
30
28
from bzrlib.branch import Branch
31
 
from bzrlib.config import GlobalConfig
 
29
import bzrlib.bzrdir as bzrdir
 
30
import bzrlib.errors as errors
 
31
import bzrlib.osutils
32
32
 
 
33
from olive import gladefile
33
34
from dialog import error_dialog
34
35
 
35
 
from history import UrlHistory
36
 
from olive import Preferences
37
 
 
38
 
class CheckoutDialog(gtk.Dialog):
39
 
    """ New implementation of the Checkout dialog. """
40
 
    def __init__(self, path=None, parent=None, remote_path=None):
 
36
class OliveCheckout:
 
37
    """ Display checkout dialog and perform the needed operations. """
 
38
    def __init__(self, path=None):
41
39
        """ Initialize the Checkout dialog. """
42
 
        gtk.Dialog.__init__(self, title="Checkout - Olive",
43
 
                                  parent=parent,
44
 
                                  flags=0,
45
 
                                  buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))
46
 
        
47
 
        # Get arguments
48
 
        self.path = path
49
 
        
50
 
        # Create the widgets
51
 
        self._button_checkout = gtk.Button(_i18n("Check_out"), use_underline=True)
52
 
        self._button_revision = gtk.Button('')
53
 
        self._image_browse = gtk.Image()
54
 
        self._filechooser = gtk.FileChooserButton(_i18n("Please select a folder"))
55
 
        self._combo = gtk.ComboBoxEntry()
56
 
        self._label_location = gtk.Label(_i18n("Branch location:"))
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._hbox_revision = gtk.HBox()
61
 
        self._entry_revision = gtk.Entry()
62
 
        self._entry_nick = gtk.Entry()
63
 
        self._check_lightweight = gtk.CheckButton(_i18n("_Lightweight checkout"),
64
 
                                                  use_underline=True)
65
 
        
66
 
        # Set callbacks
67
 
        self._button_checkout.connect('clicked', self._on_checkout_clicked)
68
 
        self._button_revision.connect('clicked', self._on_revision_clicked)
69
 
        self._combo.child.connect('focus-out-event', self._on_combo_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._label_destination, 0, 1, 1, 2)
75
 
        self._table.attach(self._label_nick, 0, 1, 2, 3)
76
 
        self._table.attach(self._label_revision, 0, 1, 3, 4)
77
 
        self._table.attach(self._combo, 1, 2, 0, 1)
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
 
        self._table.attach(self._check_lightweight, 1, 2, 4, 5)
82
 
        
83
 
        # Set properties
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._filechooser.set_action(gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
88
 
        self._label_location.set_alignment(0, 0.5)
89
 
        self._label_destination.set_alignment(0, 0.5)
90
 
        self._label_nick.set_alignment(0, 0.5)
91
 
        self._label_revision.set_alignment(0, 0.5)
92
 
        self._table.set_row_spacings(3)
93
 
        self._table.set_col_spacings(3)
94
 
        self.vbox.set_spacing(3)
95
 
        if self.path is not None:
96
 
            self._filechooser.set_filename(self.path)
97
 
        if remote_path is not None:
98
 
            self._combo.child.set_text(remote_path)
99
 
        
100
 
        # Pack some widgets
101
 
        self._hbox_revision.pack_start(self._entry_revision, True, True)
102
 
        self._hbox_revision.pack_start(self._button_revision, False, False)
103
 
        self.vbox.add(self._table)
104
 
        self.action_area.pack_end(self._button_checkout)
105
 
        
106
 
        # Show the dialog
107
 
        self.vbox.show_all()
108
 
        
109
 
        # Build checkout history
110
 
        self._history = UrlHistory(GlobalConfig(), 'branch_history')
111
 
        self._build_history()
112
 
    
113
 
    def _build_history(self):
114
 
        """ Build up the checkout history. """
115
 
        self._combo_model = gtk.ListStore(str)
116
 
        
117
 
        for item in self._history.get_entries():
118
 
            self._combo_model.append([ item ])
119
 
        
120
 
        pref = Preferences()
121
 
        for item in pref.get_bookmarks():
122
 
            self._combo_model.append([ item ])
123
 
        
124
 
        self._combo.set_model(self._combo_model)
125
 
        self._combo.set_text_column(0)
126
 
    
127
 
    def _get_last_revno(self):
128
 
        """ Get the revno of the last revision (if any). """
129
 
        location = self._combo.get_child().get_text()
130
 
        try:
131
 
            br = Branch.open(location)
132
 
        except:
133
 
            return None
134
 
        else:
135
 
            return br.revno()
136
 
    
137
 
    def _on_revision_clicked(self, button):
138
 
        """ Browse for revision button clicked handler. """
139
 
        from revbrowser import RevisionBrowser
140
 
        
141
 
        location = self._combo.get_child().get_text()
142
 
        
143
 
        try:
144
 
            br = Branch.open(location)
145
 
        except:
146
 
            return
147
 
        else:
148
 
            revb = RevisionBrowser(br, self)
149
 
            response = revb.run()
150
 
            if response != gtk.RESPONSE_NONE:
151
 
                revb.hide()
152
 
        
153
 
                if response == gtk.RESPONSE_OK:
154
 
                    if revb.selected_revno is not None:
155
 
                        self._entry_revision.set_text(revb.selected_revno)
156
 
            
157
 
                revb.destroy()
158
 
    
159
 
    @show_bzr_error
160
 
    def _on_checkout_clicked(self, button):
161
 
        """ Checkout button clicked handler. """
162
 
        location = self._combo.get_child().get_text()
 
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()
163
63
        if location is '':
164
 
            error_dialog(_i18n('Missing branch location'),
165
 
                         _i18n('You must specify a branch location.'))
 
64
            error_dialog(_('Missing branch location'),
 
65
                         _('You must specify a branch location.'))
166
66
            return
167
67
        
168
 
        destination = self._filechooser.get_filename()
 
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
        
169
76
        try:
170
 
            revno = int(self._entry_revision.get_text())
171
 
        except:
172
 
            revno = None
173
 
        
174
 
        nick = self._entry_nick.get_text()
175
 
        if nick is '':
176
 
            nick = os.path.basename(location.rstrip("/\\"))
177
 
        
178
 
        br_from = Branch.open(location)
179
 
        
180
 
        revision_id = br_from.get_rev_id(revno)
181
 
        lightweight = self._check_lightweight.get_active()
182
 
        to_location = destination + os.sep + nick
183
 
        
184
 
        os.mkdir(to_location)
185
 
        
186
 
        br_from.create_checkout(to_location, revision_id, lightweight)
187
 
        
188
 
        self._history.add_entry(location)
189
 
        
190
 
        self.response(gtk.RESPONSE_OK)
191
 
    
192
 
    def _on_combo_changed(self, widget, event):
193
 
        """ We try to get the last revision if focus lost. """
194
 
        rev = self._get_last_revno()
195
 
        if rev is None:
196
 
            self._entry_revision.set_text(_i18n('N/A'))
197
 
            self._button_revision.set_sensitive(False)
198
 
        else:
199
 
            self._entry_revision.set_text(str(rev))
200
 
            self._button_revision.set_sensitive(True)
201
 
            if self._entry_nick.get_text() == '':
202
 
                self._entry_nick.set_text(os.path.basename(self._combo.get_child().get_text().rstrip("/\\")))
 
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()