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

  • Committer: Szilveszter Farkas (Phanatic)
  • Date: 2006-08-07 16:51:21 UTC
  • mto: (0.14.1 main) (93.1.1 win32.bialix)
  • mto: This revision was merged to the branch mainline in revision 83.
  • Revision ID: Szilveszter.Farkas@gmail.com-20060807165121-10fe27c374bbdffd
Added new artwork.

2006-08-07  Szilveszter Farkas <Szilveszter.Farkas@gmail.com>

    * olive.galde: added custom artwork (icons)
    * icons/*: new icons for the toolbar
    * setup.py: install the icons

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
# Copyright (C) 2006 by Szilveszter Farkas (Phanatic) <szilveszter.farkas@gmail.com>
2
 
#
 
2
 
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
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 os
18
 
 
19
 
from gi.repository import GObject
20
 
from gi.repository import Gtk
21
 
 
22
 
from bzrlib.branch import Branch
23
 
from bzrlib.config import GlobalConfig
24
 
 
25
 
from bzrlib.plugins.gtk.dialog import error_dialog
26
 
from bzrlib.plugins.gtk.errors import show_bzr_error
27
 
from bzrlib.plugins.gtk.history import UrlHistory
28
 
from bzrlib.plugins.gtk.i18n import _i18n
29
 
 
30
 
 
31
 
class CheckoutDialog(Gtk.Dialog):
32
 
    """ New implementation of the Checkout dialog. """
33
 
 
34
 
    def __init__(self, path=None, parent=None, remote_path=None):
35
 
        """ Initialize the Checkout dialog. """
36
 
        super(CheckoutDialog, self).__init__(
37
 
            title="Checkout - Olive", parent=parent, flags=0,
38
 
            buttons=(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL))
39
 
 
40
 
        # Get arguments
41
 
        self.path = path
42
 
 
43
 
        # Create the widgets
44
 
        self._button_checkout = Gtk.Button(_i18n("Check_out"), use_underline=True)
45
 
        self._button_revision = Gtk.Button('')
46
 
        self._image_browse = Gtk.Image()
47
 
        self._filechooser = Gtk.FileChooserButton(_i18n("Please select a folder"))
48
 
        self._combo = Gtk.ComboBox.new_with_entry()
49
 
        self._label_location = Gtk.Label(label=_i18n("Branch location:"))
50
 
        self._label_destination = Gtk.Label(label=_i18n("Destination:"))
51
 
        self._label_nick = Gtk.Label(label=_i18n("Branch nick:"))
52
 
        self._label_revision = Gtk.Label(label=_i18n("Revision:"))
53
 
        self._hbox_revision = Gtk.HBox()
54
 
        self._entry_revision = Gtk.Entry()
55
 
        self._entry_nick = Gtk.Entry()
56
 
        self._check_lightweight = Gtk.CheckButton(_i18n("_Lightweight checkout"),
57
 
                                                  use_underline=True)
58
 
 
59
 
        # Set callbacks
60
 
        self._button_checkout.connect('clicked', self._on_checkout_clicked)
61
 
        self._button_revision.connect('clicked', self._on_revision_clicked)
62
 
        self._combo.get_child().connect('focus-out-event', self._on_combo_changed)
63
 
 
64
 
        # Create the table and pack the widgets into it
65
 
        self._table = Gtk.Table(rows=3, columns=2)
66
 
        self._table.attach(self._label_location, 0, 1, 0, 1)
67
 
        self._table.attach(self._label_destination, 0, 1, 1, 2)
68
 
        self._table.attach(self._label_nick, 0, 1, 2, 3)
69
 
        self._table.attach(self._label_revision, 0, 1, 3, 4)
70
 
        self._table.attach(self._combo, 1, 2, 0, 1)
71
 
        self._table.attach(self._filechooser, 1, 2, 1, 2)
72
 
        self._table.attach(self._entry_nick, 1, 2, 2, 3)
73
 
        self._table.attach(self._hbox_revision, 1, 2, 3, 4)
74
 
        self._table.attach(self._check_lightweight, 1, 2, 4, 5)
75
 
 
76
 
        # Set properties
77
 
        self._image_browse.set_from_stock(Gtk.STOCK_OPEN, Gtk.IconSize.BUTTON)
78
 
        self._button_revision.set_image(self._image_browse)
79
 
        self._button_revision.set_sensitive(False)
80
 
        self._filechooser.set_action(Gtk.FileChooserAction.SELECT_FOLDER)
81
 
        self._label_location.set_alignment(0, 0.5)
82
 
        self._label_destination.set_alignment(0, 0.5)
83
 
        self._label_nick.set_alignment(0, 0.5)
84
 
        self._label_revision.set_alignment(0, 0.5)
85
 
        self._table.set_row_spacings(3)
86
 
        self._table.set_col_spacings(3)
87
 
        self.get_content_area().set_spacing(3)
88
 
        if self.path is not None:
89
 
            self._filechooser.set_filename(self.path)
90
 
        if remote_path is not None:
91
 
            self._combo.get_child().set_text(remote_path)
92
 
 
93
 
        # Pack some widgets
94
 
        self._hbox_revision.pack_start(self._entry_revision, True, True, 0)
95
 
        self._hbox_revision.pack_start(self._button_revision, False, False, 0)
96
 
        self.get_content_area().add(self._table)
97
 
        self.action_area.pack_end(self._button_checkout, False, False, 0)
98
 
 
99
 
        # Show the dialog
100
 
        self.get_content_area().show_all()
101
 
 
102
 
        # Build checkout history
103
 
        self._history = UrlHistory(GlobalConfig(), 'branch_history')
104
 
        self._build_history()
105
 
 
106
 
    def _build_history(self):
107
 
        """ Build up the checkout history. """
108
 
        self._combo_model = Gtk.ListStore(str)
109
 
 
110
 
        for item in self._history.get_entries():
111
 
            self._combo_model.append([ item ])
112
 
 
113
 
        self._combo.set_model(self._combo_model)
114
 
        self._combo.set_entry_text_column(0)
115
 
 
116
 
    def _get_last_revno(self):
117
 
        """ Get the revno of the last revision (if any). """
118
 
        location = self._combo.get_child().get_text()
119
 
        try:
120
 
            br = Branch.open(location)
121
 
        except:
122
 
            return None
123
 
        else:
124
 
            return br.revno()
125
 
 
126
 
    def _on_revision_clicked(self, button):
127
 
        """ Browse for revision button clicked handler. """
128
 
        from revbrowser import RevisionBrowser
129
 
 
130
 
        location = self._combo.get_child().get_text()
131
 
 
132
 
        try:
133
 
            br = Branch.open(location)
134
 
        except:
135
 
            return
136
 
        else:
137
 
            revb = RevisionBrowser(br, self)
138
 
            response = revb.run()
139
 
            if response != Gtk.ResponseType.NONE:
140
 
                revb.hide()
141
 
 
142
 
                if response == Gtk.ResponseType.OK:
143
 
                    if revb.selected_revno is not None:
144
 
                        self._entry_revision.set_text(revb.selected_revno)
145
 
 
146
 
                revb.destroy()
147
 
 
148
 
    @show_bzr_error
149
 
    def _on_checkout_clicked(self, button):
150
 
        """ Checkout button clicked handler. """
151
 
        location = self._combo.get_child().get_text()
 
17
import sys
 
18
 
 
19
try:
 
20
    import pygtk
 
21
    pygtk.require("2.0")
 
22
except:
 
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 OliveCheckout:
 
34
    """ Display checkout dialog and perform the needed operations. """
 
35
    def __init__(self, gladefile, comm):
 
36
        """ Initialize the Branch dialog. """
 
37
        self.gladefile = gladefile
 
38
        self.glade = gtk.glade.XML(self.gladefile, 'window_checkout')
 
39
        
 
40
        self.comm = comm
 
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
        self.filechooser.set_filename(self.comm.get_path())
 
54
 
 
55
    def display(self):
 
56
        """ Display the Checkout dialog. """
 
57
        self.window.show_all()
 
58
    
 
59
    def checkout(self, widget):
 
60
        from dialog import OliveDialog
 
61
        dialog = OliveDialog(self.gladefile)
 
62
        
 
63
        entry_location = self.glade.get_widget('entry_checkout_location')
 
64
        location = entry_location.get_text()
152
65
        if location is '':
153
 
            error_dialog(_i18n('Missing branch location'),
154
 
                         _i18n('You must specify a branch location.'))
 
66
            dialog.error_dialog('You must specify a branch location.')
155
67
            return
156
 
 
157
 
        destination = self._filechooser.get_filename()
158
 
        try:
159
 
            revno = int(self._entry_revision.get_text())
160
 
        except:
 
68
        
 
69
        destination = self.filechooser.get_filename()
 
70
        
 
71
        spinbutton_revno = self.glade.get_widget('spinbutton_checkout_revno')
 
72
        revno = spinbutton_revno.get_value_as_int()
 
73
        if revno == 0:
161
74
            revno = None
162
 
 
163
 
        nick = self._entry_nick.get_text()
164
 
        if nick is '':
165
 
            nick = os.path.basename(location.rstrip("/\\"))
166
 
 
167
 
        br_from = Branch.open(location)
168
 
 
169
 
        revision_id = br_from.get_rev_id(revno)
170
 
        lightweight = self._check_lightweight.get_active()
171
 
        to_location = destination + os.sep + nick
172
 
 
173
 
        os.mkdir(to_location)
174
 
 
175
 
        br_from.create_checkout(to_location, revision_id, lightweight)
176
 
 
177
 
        self._history.add_entry(location)
178
 
 
179
 
        self.response(Gtk.ResponseType.OK)
180
 
 
181
 
    def _on_combo_changed(self, widget, event):
182
 
        """ We try to get the last revision if focus lost. """
183
 
        rev = self._get_last_revno()
184
 
        if rev is None:
185
 
            self._entry_revision.set_text(_i18n('N/A'))
186
 
            self._button_revision.set_sensitive(False)
187
 
        else:
188
 
            self._entry_revision.set_text(str(rev))
189
 
            self._button_revision.set_sensitive(True)
190
 
            if self._entry_nick.get_text() == '':
191
 
                self._entry_nick.set_text(os.path.basename(self._combo.get_child().get_text().rstrip("/\\")))
 
75
        
 
76
        checkbutton_lightweight = self.glade.get_widget('checkbutton_checkout_lightweight')
 
77
        lightweight = checkbutton_lightweight.get_active()
 
78
        
 
79
        self.comm.set_busy(self.window)
 
80
        try:
 
81
            init.checkout(location, destination, revno, lightweight)
 
82
        except errors.NotBranchError, errmsg:
 
83
            dialog.error_dialog('Not a branch: %s' % errmsg)
 
84
            self.comm.set_busy(self.window, False)
 
85
            return
 
86
        except errors.TargetAlreadyExists, errmsg:
 
87
            dialog.error_dialog('Target already exists: %s' % errmsg)
 
88
            self.comm.set_busy(self.window, False)
 
89
            return
 
90
        except errors.NonExistingParent, errmsg:
 
91
            dialog.error_dialog('Parent directory doesn\'t exist: %s' % errmsg)
 
92
            self.comm.set_busy(self.window, False)
 
93
            return
 
94
        except:
 
95
            raise
 
96
        
 
97
        self.close()
 
98
        self.comm.refresh_right()
 
99
 
 
100
    def close(self, widget=None):
 
101
        self.window.destroy()