/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

Commit messages never contain config options

Show diffs side-by-side

added added

removed removed

Lines of Context:
ui.py
19
19
"""GTK UI
20
20
"""
21
21
 
22
 
import gtk
23
 
import sys
 
22
from gi.repository import Gtk
24
23
 
25
 
import bzrlib.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):
44
 
    def __init__(self, stack):
 
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):
45
71
        super(GtkProgressBar, self).__init__()
46
72
        self.set_fraction(0.0)
47
 
        self._stack = stack
48
 
 
49
 
    def finished(self):
50
 
        self._stack.remove(self)
51
 
 
52
 
    def clear(self):
53
 
        pass
54
 
 
 
73
        self.current = None
 
74
        self.total = None
 
75
 
 
76
    @main_iteration
55
77
    def tick(self):
 
78
        self.show()
56
79
        self.pulse()
57
80
 
58
 
    def update(self, msg=None, current=None, total=None):
 
81
    @main_iteration
 
82
    def update(self, msg=None, current_cnt=None, total_cnt=None):
 
83
        self.show()
 
84
        if current_cnt is not None:
 
85
            self.current = current_cnt
 
86
        if total_cnt is not None:
 
87
            self.total = total_cnt
59
88
        if msg is not None:
60
89
            self.set_text(msg)
61
 
        self.set_fraction(1.0 * current / total)
62
 
        while gtk.events_pending():
63
 
            gtk.main_iteration()
64
 
 
65
 
 
66
 
class GtkProgressBarStack(gtk.Window):
 
90
        if None not in (self.current, self.total):
 
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
 
67
129
    def __init__(self):
68
 
        super(GtkProgressBarStack, self).__init__(type=gtk.WINDOW_TOPLEVEL)
 
130
        super(ProgressBarWindow, self).__init__(type=Gtk.WindowType.TOPLEVEL)
69
131
        self.set_border_width(0)
70
132
        self.set_title("Progress")
71
 
        self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
72
 
        self.vbox = gtk.VBox()
73
 
        self.add(self.vbox)
 
133
        self.set_position(Gtk.WindowPosition.CENTER_ALWAYS)
 
134
        self.pb = GtkProgressBar()
 
135
        self.add(self.pb)
 
136
        self.resize(250, 15)
74
137
        self.set_resizable(False)
75
138
 
76
 
    def _adapt_size(self):
77
 
        self.resize(250, 15 * len(self.vbox.get_children()))
78
 
 
79
 
    def get_nested(self):
80
 
        nested = GtkProgressBar(self)
81
 
        self.vbox.pack_start(nested)
82
 
        self._adapt_size()
83
 
        self.show_all()
84
 
        return nested
85
 
 
86
 
    def remove(self, pb):
87
 
        self.vbox.remove(pb)
88
 
 
89
 
 
90
 
class PasswordDialog(gtk.Dialog):
 
139
 
 
140
class ProgressPanel(ProgressContainerMixin, Gtk.Box):
 
141
 
 
142
    def __init__(self):
 
143
        super(ProgressPanel, self).__init__(Gtk.Orientation.HORIZONTAL, 5)
 
144
        image_loading = Gtk.Image.new_from_stock(Gtk.STOCK_REFRESH,
 
145
                                                 Gtk.IconSize.BUTTON)
 
146
        image_loading.show()
 
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):
91
155
    """ Prompt the user for a password. """
 
156
 
92
157
    def __init__(self, prompt):
93
 
        gtk.Dialog.__init__(self)
94
 
        
95
 
        label = gtk.Label(prompt)
96
 
        self.vbox.pack_start(label, padding=10)
97
 
        
98
 
        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()
99
164
        self.entry.set_visibility(False)
100
 
        self.vbox.pack_end(self.entry, padding=10)
101
 
        
102
 
        self.vbox.show_all()
103
 
        
104
 
        self.add_buttons(gtk.STOCK_OK, gtk.RESPONSE_OK, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
105
 
    
 
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
 
106
172
    def _get_passwd(self):
107
173
        return self.entry.get_text()
108
174
 
112
178
class GtkUIFactory(UIFactory):
113
179
    """A UI factory for GTK user interfaces."""
114
180
 
115
 
    def __init__(self,
116
 
                 stdout=None,
117
 
                 stderr=None):
118
 
        """Create a GtkUIFactory.
119
 
 
120
 
        """
 
181
    def __init__(self):
 
182
        """Create a GtkUIFactory"""
121
183
        super(GtkUIFactory, self).__init__()
122
 
        self._progress_bar_stack = None
 
184
        self.set_progress_bar_widget(None)
 
185
 
 
186
    def set_progress_bar_widget(self, widget):
 
187
        self._progress_bar_widget = widget
123
188
 
124
189
    def get_boolean(self, prompt):
125
190
        """GtkDialog with yes/no answers"""
126
191
        dialog = PromptDialog(prompt)
127
192
        response = dialog.run()
128
193
        dialog.destroy()
129
 
        return (response == gtk.RESPONSE_YES)
130
 
        
 
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
 
131
220
    def get_password(self, prompt='', **kwargs):
132
221
        """Prompt the user for a password.
133
222
 
135
224
        :param kwargs: Arguments which will be expanded into the prompt.
136
225
                       This lets front ends display different things if
137
226
                       they so choose.
138
 
        :return: The password string, return None if the user 
 
227
        :return: The password string, return None if the user
139
228
                 canceled the request.
140
229
        """
141
230
        dialog = PasswordDialog(prompt % kwargs)
142
231
        response = dialog.run()
143
232
        passwd = dialog.passwd
144
233
        dialog.destroy()
145
 
        if response == gtk.RESPONSE_OK:
 
234
        if response == Gtk.ResponseType.OK:
146
235
            return passwd
147
236
        else:
148
237
            return None
149
238
 
150
 
    def nested_progress_bar(self):
151
 
        """Return a nested progress bar.
152
 
        """
153
 
        if self._progress_bar_stack is None:
154
 
            self._progress_bar_stack = GtkProgressBarStack()
155
 
        return self._progress_bar_stack.get_nested()
156
 
 
157
 
    def set_progress_bar_vbox(self, vbox):
158
 
        """Change the vbox to put progress bars in.
159
 
        """
160
 
        self._progress_bar_stack = vbox
161
 
 
162
 
    def clear_term(self):
163
 
        """Prepare the terminal for output.
164
 
 
165
 
        It has no sense when talking about GTK."""
166
 
        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()