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

  • Committer: Jelmer Vernooij
  • Date: 2012-07-09 15:23:26 UTC
  • mto: This revision was merged to the branch mainline in revision 794.
  • Revision ID: jelmer@samba.org-20120709152326-dzxb8zoz0btull7n
Remove bzr-notify.

Show diffs side-by-side

added added

removed removed

Lines of Context:
19
19
"""GTK UI
20
20
"""
21
21
 
22
 
import gtk
23
 
import sys
 
22
from gi.repository import Gtk
24
23
 
25
 
from bzrlib import progress
26
24
from bzrlib.ui import UIFactory
27
25
 
28
26
 
29
 
class PromptDialog(gtk.Dialog):
30
 
    """ Prompt the user for a yes/no answer. """
31
 
    def __init__(self, prompt):
32
 
        gtk.Dialog.__init__(self)
33
 
        
34
 
        label = gtk.Label(prompt)
35
 
        self.vbox.pack_start(label, padding=10)
36
 
        
37
 
        self.vbox.show_all()
38
 
 
39
 
        self.add_buttons(gtk.STOCK_YES, gtk.RESPONSE_YES, gtk.STOCK_NO, 
40
 
                         gtk.RESPONSE_NO)
41
 
 
42
 
 
43
 
class GtkProgressBar(gtk.ProgressBar,progress._BaseProgressBar):
44
 
    def __init__(self, _stack=None):
45
 
        gtk.ProgressBar.__init__(self)
 
27
def main_iteration(function):
 
28
    def with_main_iteration(self, *args, **kwargs):
 
29
        result = function(self, *args, **kwargs)
 
30
        while Gtk.events_pending():
 
31
            Gtk.main_iteration_do(False)
 
32
        return result
 
33
    return with_main_iteration
 
34
 
 
35
 
 
36
class PromptDialog(Gtk.MessageDialog):
 
37
    """Prompt the user for a yes/no answer."""
 
38
 
 
39
    def __init__(self, prompt, parent=None):
 
40
        super(PromptDialog, self).__init__(
 
41
            parent, Gtk.DialogFlags.DESTROY_WITH_PARENT,
 
42
            Gtk.MessageType.QUESTION, Gtk.ButtonsType.YES_NO, prompt)
 
43
 
 
44
 
 
45
class InfoDialog(Gtk.MessageDialog):
 
46
    """Show the user an informational message."""
 
47
 
 
48
    MESSAGE_TYPE = Gtk.MessageType.INFO
 
49
 
 
50
    def __init__(self, prompt, parent=None):
 
51
        super(InfoDialog, self).__init__(
 
52
            parent, Gtk.DialogFlags.DESTROY_WITH_PARENT,
 
53
            self.MESSAGE_TYPE, Gtk.ButtonsType.CLOSE, prompt)
 
54
 
 
55
 
 
56
class WarningDialog(InfoDialog):
 
57
    """Show the user a warning message."""
 
58
 
 
59
    MESSAGE_TYPE = Gtk.MessageType.WARNING
 
60
 
 
61
 
 
62
class ErrorDialog(InfoDialog):
 
63
    """Show the user a warning message."""
 
64
 
 
65
    MESSAGE_TYPE = Gtk.MessageType.ERROR
 
66
 
 
67
 
 
68
class GtkProgressBar(Gtk.ProgressBar):
 
69
 
 
70
    def __init__(self):
 
71
        super(GtkProgressBar, self).__init__()
46
72
        self.set_fraction(0.0)
47
 
        progress._BaseProgressBar.__init__(self, _stack=_stack)
48
73
        self.current = None
49
74
        self.total = None
50
75
 
51
 
    def clear(self):
52
 
        self.hide()
53
 
 
 
76
    @main_iteration
54
77
    def tick(self):
 
78
        self.show()
55
79
        self.pulse()
56
80
 
57
 
    def child_update(self, message, current, total):
58
 
        pass
59
 
 
 
81
    @main_iteration
60
82
    def update(self, msg=None, current_cnt=None, total_cnt=None):
61
 
        if current_cnt:
 
83
        self.show()
 
84
        if current_cnt is not None:
62
85
            self.current = current_cnt
63
 
        if total_cnt:
 
86
        if total_cnt is not None:
64
87
            self.total = total_cnt
65
88
        if msg is not None:
66
89
            self.set_text(msg)
67
90
        if None not in (self.current, self.total):
68
 
            self.fraction = float(self.current) / self.total
69
 
            self.set_fraction(self.fraction)
70
 
        while gtk.events_pending():
71
 
            gtk.main_iteration()
72
 
 
73
 
 
74
 
class ProgressBarWindow(gtk.Window):
 
91
            fraction = float(self.current) / self.total
 
92
            if fraction < 0.0 or fraction > 1.0:
 
93
                raise ValueError
 
94
            self.set_fraction(fraction)
 
95
 
 
96
    @main_iteration
 
97
    def finished(self):
 
98
        self.set_fraction(0.0)
 
99
        self.current = None
 
100
        self.total = None
 
101
        self.hide()
 
102
 
 
103
    def clear(self):
 
104
        self.finished()
 
105
 
 
106
 
 
107
class ProgressContainerMixin:
 
108
    """Expose GtkProgressBar methods to a container class."""
 
109
 
 
110
    def tick(self, *args, **kwargs):
 
111
        self.show_all()
 
112
        self.pb.tick(*args, **kwargs)
 
113
 
 
114
    def update(self, *args, **kwargs):
 
115
        self.show_all()
 
116
        self.pb.update(*args, **kwargs)
 
117
 
 
118
    def finished(self):
 
119
        self.hide()
 
120
        self.pb.finished()
 
121
 
 
122
    def clear(self):
 
123
        self.hide()
 
124
        self.pb.clear()
 
125
 
 
126
 
 
127
class ProgressBarWindow(ProgressContainerMixin, Gtk.Window):
 
128
 
75
129
    def __init__(self):
76
 
        super(ProgressBarWindow, self).__init__(type=gtk.WINDOW_TOPLEVEL)
 
130
        super(ProgressBarWindow, self).__init__(type=Gtk.WindowType.TOPLEVEL)
77
131
        self.set_border_width(0)
78
132
        self.set_title("Progress")
79
 
        self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
80
 
        self.pb = GtkProgressBar(self)
 
133
        self.set_position(Gtk.WindowPosition.CENTER_ALWAYS)
 
134
        self.pb = GtkProgressBar()
81
135
        self.add(self.pb)
82
136
        self.resize(250, 15)
83
137
        self.set_resizable(False)
84
 
        self.show_all()
85
 
 
86
 
    def clear(self):
87
 
        self.pb.clear()
88
 
        self.destroy()
89
 
 
90
 
 
91
 
class ProgressPanel(gtk.HBox):
 
138
 
 
139
 
 
140
class ProgressPanel(ProgressContainerMixin, Gtk.Box):
 
141
 
92
142
    def __init__(self):
93
 
        super(ProgressPanel, self).__init__()
94
 
        image_loading = gtk.image_new_from_stock(gtk.STOCK_REFRESH,
95
 
                                                 gtk.ICON_SIZE_BUTTON)
 
143
        super(ProgressPanel, self).__init__(Gtk.Orientation.HORIZONTAL, 5)
 
144
        image_loading = Gtk.Image.new_from_stock(Gtk.STOCK_REFRESH,
 
145
                                                 Gtk.IconSize.BUTTON)
96
146
        image_loading.show()
97
 
        
98
 
        self.pb = GtkProgressBar(self)
99
 
        self.set_spacing(5)
100
 
        self.set_border_width(5)        
101
 
        self.pack_start(image_loading, False, False)
102
 
        self.pack_start(self.pb, True, True)
103
 
 
104
 
    def return_pb(self, pb):
105
 
        self._stack.return_pb(self)
106
 
 
107
 
    def get_progress_bar(self, to_file=None, show_pct=None, show_spinner=None, show_eta=None, 
108
 
                         show_bar=None, show_count=None, to_messages_file=None, 
109
 
                         _stack=None):
110
 
        self._stack = _stack
111
 
        self.show_all()
112
 
        return self
113
 
    
114
 
    def update(self, *args, **kwargs):
115
 
        self.pb.update(*args, **kwargs)
116
 
 
117
 
    def finished(self):
118
 
        self.pb.finished()
119
 
        self.hide_all()
120
 
 
121
 
    def clear(self):
122
 
        self.pb.clear()
123
 
        self.hide_all()
124
 
 
125
 
    def child_progress(self, *args, **kwargs):
126
 
        return self.pb.child_progress(*args, **kwargs)
127
 
 
128
 
    def child_update(self, *args, **kwargs):
129
 
        return self.pb.child_update(*args, **kwargs)
130
 
 
131
 
 
132
 
 
133
 
class PasswordDialog(gtk.Dialog):
 
147
 
 
148
        self.pb = GtkProgressBar()
 
149
        self.set_border_width(5)
 
150
        self.pack_start(image_loading, False, False, 0)
 
151
        self.pack_start(self.pb, True, True, 0)
 
152
 
 
153
 
 
154
class PasswordDialog(Gtk.Dialog):
134
155
    """ Prompt the user for a password. """
 
156
 
135
157
    def __init__(self, prompt):
136
 
        gtk.Dialog.__init__(self)
137
 
        
138
 
        label = gtk.Label(prompt)
139
 
        self.vbox.pack_start(label, padding=10)
140
 
        
141
 
        self.entry = gtk.Entry()
 
158
        super(PasswordDialog, self).__init__()
 
159
 
 
160
        label = Gtk.Label(label=prompt)
 
161
        self.get_content_area().pack_start(label, True, True, 10)
 
162
 
 
163
        self.entry = Gtk.Entry()
142
164
        self.entry.set_visibility(False)
143
 
        self.vbox.pack_end(self.entry, padding=10)
144
 
        
145
 
        self.vbox.show_all()
146
 
        
147
 
        self.add_buttons(gtk.STOCK_OK, gtk.RESPONSE_OK, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
148
 
    
 
165
        self.get_content_area().pack_end(self.entry, False, False, 10)
 
166
 
 
167
        self.get_content_area().show_all()
 
168
 
 
169
        self.add_buttons(Gtk.STOCK_OK, Gtk.ResponseType.OK,
 
170
                         Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL)
 
171
 
149
172
    def _get_passwd(self):
150
173
        return self.entry.get_text()
151
174
 
155
178
class GtkUIFactory(UIFactory):
156
179
    """A UI factory for GTK user interfaces."""
157
180
 
158
 
    def __init__(self,
159
 
                 stdout=None,
160
 
                 stderr=None):
161
 
        """Create a GtkUIFactory.
162
 
 
163
 
        """
 
181
    def __init__(self):
 
182
        """Create a GtkUIFactory"""
164
183
        super(GtkUIFactory, self).__init__()
165
 
        self.set_nested_progress_bar_widget(ProgressBarWindow)
 
184
        self.set_progress_bar_widget(None)
 
185
 
 
186
    def set_progress_bar_widget(self, widget):
 
187
        self._progress_bar_widget = widget
166
188
 
167
189
    def get_boolean(self, prompt):
168
190
        """GtkDialog with yes/no answers"""
169
191
        dialog = PromptDialog(prompt)
170
192
        response = dialog.run()
171
193
        dialog.destroy()
172
 
        return (response == gtk.RESPONSE_YES)
173
 
        
 
194
        return (response == Gtk.ResponseType.YES)
 
195
 
 
196
    def show_message(self, msg):
 
197
        """See UIFactory.show_message."""
 
198
        dialog = InfoDialog(msg)
 
199
        dialog.run()
 
200
        dialog.destroy()
 
201
 
 
202
    def show_warning(self, msg):
 
203
        """See UIFactory.show_warning."""
 
204
        dialog = WarningDialog(msg)
 
205
        dialog.run()
 
206
        dialog.destroy()
 
207
 
 
208
    def show_error(self, msg):
 
209
        """See UIFactory.show_error."""
 
210
        dialog = ErrorDialog(msg)
 
211
        dialog.run()
 
212
        dialog.destroy()
 
213
 
 
214
    def show_user_warning(self, warning_id, **message_args):
 
215
        """See UIFactory.show_user_warning."""
 
216
        if warning_id not in self.suppressed_warnings:
 
217
            message = self.format_user_warning(warning_id, message_args)
 
218
            self.show_warning(message)
 
219
 
174
220
    def get_password(self, prompt='', **kwargs):
175
221
        """Prompt the user for a password.
176
222
 
178
224
        :param kwargs: Arguments which will be expanded into the prompt.
179
225
                       This lets front ends display different things if
180
226
                       they so choose.
181
 
        :return: The password string, return None if the user 
 
227
        :return: The password string, return None if the user
182
228
                 canceled the request.
183
229
        """
184
230
        dialog = PasswordDialog(prompt % kwargs)
185
231
        response = dialog.run()
186
232
        passwd = dialog.passwd
187
233
        dialog.destroy()
188
 
        if response == gtk.RESPONSE_OK:
 
234
        if response == Gtk.ResponseType.OK:
189
235
            return passwd
190
236
        else:
191
237
            return None
192
238
 
193
 
    def set_nested_progress_bar_widget(self, widget):
194
 
        self._progress_bar_stack = progress.ProgressBarStack(klass=widget)
195
 
 
196
 
    def nested_progress_bar(self):
197
 
        """Return a nested progress bar.
198
 
        """
199
 
        return self._progress_bar_stack.get_nested()
200
 
 
201
 
    def set_progress_bar_vbox(self, vbox):
202
 
        """Change the vbox to put progress bars in.
203
 
        """
204
 
        self._progress_bar_stack = vbox
205
 
 
206
 
    def clear_term(self):
207
 
        """Prepare the terminal for output.
208
 
 
209
 
        It has no sense when talking about GTK."""
210
 
        pass
 
239
    def _progress_all_finished(self):
 
240
        """See UIFactory._progress_all_finished."""
 
241
        pbw = self._progress_bar_widget
 
242
        if pbw:
 
243
            pbw.finished()
 
244
 
 
245
    def _ensure_progress_widget(self):
 
246
        if self._progress_bar_widget is None:
 
247
            # Default to a window since nobody gave us a better means to report
 
248
            # progress.
 
249
            self.set_progress_bar_widget(ProgressBarWindow())
 
250
 
 
251
    def _progress_updated(self, task):
 
252
        """See UIFactory._progress_updated."""
 
253
        self._ensure_progress_widget()
 
254
        self._progress_bar_widget.update(task.msg,
 
255
                                         task.current_cnt, task.total_cnt)
 
256
 
 
257
    def report_transport_activity(self, transport, byte_count, direction):
 
258
        """See UIFactory.report_transport_activity."""
 
259
        self._ensure_progress_widget()
 
260
        self._progress_bar_widget.tick()