← Back to branch summary

~ubuntu-branches/ubuntu/wily/blueman/wily

« back to all changes in this revision

Viewing changes to blueman/gui/manager/ManagerProgressbar.py

  • Committer: Package Import Robot
  • Author(s): Sean Davis
  • Date: 2015-09-07 12:48:18 UTC
  • mfrom: (2.3.11 sid)
  • Revision ID: package-import@ubuntu.com-20150907124818-evulc0mhjotz8q29
Tags: 2.0-1ubuntu1
https://launchpad.net/bugs/1482626
* Merge from Debian unstable (LP: #1482626). Remaining changes:
  - debian/patches/03_filemanage_fix.patch:
    + Dropped, no longer needed.
  - debian/patches/dhcpclient_priority
  - debian/patches/01_dont_autostart_lxde.patch
    + Refreshed patches

Show diffs side-by-side

added added

removed removed

Lines of Context:
blueman/gui/manager/ManagerProgressbar.py
1
 
# Copyright (C) 2008 Valmantas Paliksa <walmis at balticum-tv dot lt>
2
 
# Copyright (C) 2008 Tadas Dailyda <tadas at dailyda dot com>
3
 
#
4
 
# Licensed under the GNU General Public License Version 3
5
 
#
6
 
# This program is free software: you can redistribute it and/or modify
7
 
# it under the terms of the GNU General Public License as published by
8
 
# the Free Software Foundation, either version 3 of the License, or
9
 
# (at your option) any later version.
10
 
#
11
 
# This program is distributed in the hope that it will be useful,
12
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
# GNU General Public License for more details.
15
 
#
16
 
# You should have received a copy of the GNU General Public License
17
 
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
18
 
# 
 
1
from __future__ import print_function
 
2
from __future__ import division
 
3
from __future__ import absolute_import
 
4
from __future__ import unicode_literals
 
5
 
19
6
from gi.repository import Pango
20
7
from gi.repository import GObject
21
8
from gi.repository import Gtk
22
9
from gi.repository import Gdk
23
 
from blueman.Functions import get_icon
 
10
from blueman.Functions import get_icon, dprint
24
11
from blueman.main.SignalTracker import SignalTracker
25
12
 
 
13
 
26
14
class ManagerProgressbar(GObject.GObject):
27
 
 
28
 
        __gsignals__ = {
29
 
                'cancelled' : (GObject.SignalFlags.RUN_LAST, None, ()),
30
 
        }
31
 
        __instances__ = []
32
 
        def __init__(self, blueman, cancellable=True, text=_("Connecting")):
33
 
                def on_enter(evbox, event):
34
 
                        c = Gdk.Cursor.new(Gdk.CursorType.HAND2)
35
 
                        self.window.get_window().set_cursor(c)
36
 
                
37
 
                def on_leave(evbox, event):
38
 
                        self.window.get_window().set_cursor(None)
39
 
                        
40
 
                def on_clicked(evbox, event):
41
 
                        self.eventbox.props.sensitive = False
42
 
                        self.emit("cancelled")
43
 
                
44
 
                GObject.GObject.__init__(self)
45
 
                self.Blueman = blueman
46
 
                
47
 
                self.cancellable = cancellable
48
 
                
49
 
                self.hbox = hbox = blueman.Builder.get_object("statusbar1")
50
 
                
51
 
                self.progressbar = Gtk.ProgressBar()
52
 
                
53
 
                self.signals = SignalTracker()
54
 
 
55
 
                self.button = Gtk.Image.new_from_pixbuf(get_icon("gtk-stop", 16))
56
 
        
57
 
                self.eventbox = eventbox = Gtk.EventBox()
58
 
                eventbox.add(self.button)
59
 
                eventbox.props.tooltip_text = _("Cancel Operation")
60
 
                self.signals.Handle(eventbox, "enter-notify-event", on_enter)
61
 
                self.signals.Handle(eventbox, "leave-notify-event", on_leave)
62
 
                self.signals.Handle(eventbox, "button-press-event", on_clicked)
63
 
 
64
 
                
65
 
                self.progressbar.set_size_request(100, 15)
66
 
                self.progressbar.set_ellipsize(Pango.EllipsizeMode.END)
67
 
                self.progressbar.set_text(text)
68
 
                self.progressbar.set_pulse_step(0.05)
69
 
                
70
 
                self.window = blueman.Builder.get_object("window")
71
 
 
72
 
                hbox.pack_end(eventbox, True, False, 0)
73
 
                hbox.pack_end(self.progressbar, False, False, 0)
74
 
 
75
 
                if ManagerProgressbar.__instances__ != []:
76
 
                        dprint("hiding", ManagerProgressbar.__instances__[-1])
77
 
                        ManagerProgressbar.__instances__[-1].hide()
78
 
                
79
 
                self.show()
80
 
                if not self.cancellable:
81
 
                        self.eventbox.props.sensitive = False
82
 
                
83
 
                self.gsource = None
84
 
                self.finalized = False
85
 
                
86
 
                ManagerProgressbar.__instances__.append(self)
87
 
                
88
 
        def connect(self, *args):
89
 
                self.signals.Handle("gobject", super(ManagerProgressbar, self), *args)
90
 
                
91
 
        def show(self):
92
 
                if self.Blueman.Config.props.show_statusbar == False:
93
 
                        self.Blueman.Builder.get_object("statusbar").props.visible = True
94
 
 
95
 
                
96
 
                #if self.Blueman.Stats.hbox.size_request()[0] + self.progressbar.size_request()[0] + 16 > self.Blueman.window.get_size()[0]:
97
 
                #       self.Blueman.Stats.hbox.hide_all()
98
 
 
99
 
                
100
 
                self.progressbar.props.visible = True
101
 
                self.eventbox.props.visible = True
102
 
                self.button.props.visible = True                
103
 
        
104
 
        def hide(self):
105
 
                self.Blueman.Stats.hbox.show_all()              
106
 
                self.progressbar.props.visible = False
107
 
                self.eventbox.props.visible = False
108
 
                self.button.props.visible = False
109
 
                
110
 
        def message(self, msg, timeout=1500):
111
 
                self.stop()
112
 
                self.set_label(msg)
113
 
                self.set_cancellable(False)
114
 
                GObject.timeout_add(timeout, self.finalize)             
115
 
 
116
 
                
117
 
        def finalize(self):
118
 
                if not self.finalized:
119
 
                        self.hide()
120
 
                        self.stop()
121
 
                        Gdk.Window.set_cursor(self.window.get_window(), None)
122
 
                        self.hbox.remove(self.eventbox)
123
 
                        self.hbox.remove(self.progressbar)
124
 
                        #self.hbox.remove(self.seperator)
125
 
                        self.finalized = True
126
 
                        
127
 
                        if ManagerProgressbar.__instances__[-1] == self:
128
 
                                ManagerProgressbar.__instances__.pop()
129
 
                                #remove all finalized instances
130
 
                                for inst in reversed(ManagerProgressbar.__instances__):
131
 
                                        if inst.finalized:
132
 
                                                ManagerProgressbar.__instances__.pop()
133
 
                                        else:
134
 
                                                #show last active progress bar
135
 
                                                inst.show()
136
 
                                                break
137
 
                                                
138
 
                        if ManagerProgressbar.__instances__ == []:
139
 
                                if self.Blueman.Config.props.show_statusbar == False:
140
 
                                        self.Blueman.Builder.get_object("statusbar").props.visible = False
141
 
                                        
142
 
                        self.signals.DisconnectAll()
143
 
                
144
 
                
145
 
        def set_cancellable(self, b, hide=False):
146
 
                if b:
147
 
                        self.eventbox.props.visible = True
148
 
                        self.eventbox.props.sensitive = True
149
 
                else:
150
 
                        if hide:
151
 
                                self.eventbox.props.visible = False
152
 
                        else:
153
 
                                self.eventbox.props.sensitive = False
154
 
                
155
 
        def set_label(self, label):
156
 
                self.progressbar.props.text = label
157
 
                
158
 
        def fraction(self, frac):
159
 
                if not self.finalized:
160
 
                        self.progressbar.set_fraction(frac)
161
 
                        
162
 
        def started(self):
163
 
                return self.gsource != None
164
 
        
165
 
        def start(self):
166
 
                def pulse():
167
 
                        self.progressbar.pulse()
168
 
                        return True
169
 
                if not self.gsource:
170
 
                        self.gsource = GObject.timeout_add(1000/24, pulse)
171
 
        
172
 
        def stop(self):
173
 
                if self.gsource != None:
174
 
                        GObject.source_remove(self.gsource)
175
 
                self.progressbar.set_fraction(0.0)
 
15
    __gsignals__ = {
 
16
    str('cancelled'): (GObject.SignalFlags.RUN_LAST, None, ()),
 
17
    }
 
18
    __instances__ = []
 
19
 
 
20
    def __init__(self, blueman, cancellable=True, text=_("Connecting")):
 
21
        def on_enter(evbox, event):
 
22
            c = Gdk.Cursor.new(Gdk.CursorType.HAND2)
 
23
            self.window.get_window().set_cursor(c)
 
24
 
 
25
        def on_leave(evbox, event):
 
26
            self.window.get_window().set_cursor(None)
 
27
 
 
28
        def on_clicked(evbox, event):
 
29
            self.eventbox.props.sensitive = False
 
30
            self.emit("cancelled")
 
31
 
 
32
        GObject.GObject.__init__(self)
 
33
        self.Blueman = blueman
 
34
 
 
35
        self.cancellable = cancellable
 
36
 
 
37
        self.hbox = hbox = blueman.Builder.get_object("statusbar1")
 
38
 
 
39
        self.progressbar = Gtk.ProgressBar()
 
40
 
 
41
        self.signals = SignalTracker()
 
42
 
 
43
        self.button = Gtk.Image.new_from_pixbuf(get_icon("process-stop", 16))
 
44
 
 
45
        self.eventbox = eventbox = Gtk.EventBox()
 
46
        eventbox.add(self.button)
 
47
        eventbox.props.tooltip_text = _("Cancel Operation")
 
48
        self.signals.Handle(eventbox, "enter-notify-event", on_enter)
 
49
        self.signals.Handle(eventbox, "leave-notify-event", on_leave)
 
50
        self.signals.Handle(eventbox, "button-press-event", on_clicked)
 
51
 
 
52
        self.progressbar.set_size_request(100, 15)
 
53
        self.progressbar.set_ellipsize(Pango.EllipsizeMode.END)
 
54
        self.progressbar.set_text(text)
 
55
        self.progressbar.set_pulse_step(0.05)
 
56
 
 
57
        self.window = blueman.Builder.get_object("window")
 
58
 
 
59
        hbox.pack_end(eventbox, True, False, 0)
 
60
        hbox.pack_end(self.progressbar, False, False, 0)
 
61
 
 
62
        if ManagerProgressbar.__instances__ != []:
 
63
            dprint("hiding", ManagerProgressbar.__instances__[-1])
 
64
            ManagerProgressbar.__instances__[-1].hide()
 
65
 
 
66
        self.show()
 
67
        if not self.cancellable:
 
68
            self.eventbox.props.sensitive = False
 
69
 
 
70
        self.gsource = None
 
71
        self.finalized = False
 
72
 
 
73
        ManagerProgressbar.__instances__.append(self)
 
74
 
 
75
    def connect(self, *args):
 
76
        self.signals.Handle("gobject", super(ManagerProgressbar, self), *args)
 
77
 
 
78
    def show(self):
 
79
        if not self.Blueman.Config["show-statusbar"]:
 
80
            self.Blueman.Builder.get_object("statusbar").props.visible = True
 
81
 
 
82
 
 
83
        # if self.Blueman.Stats.hbox.size_request()[0] + self.progressbar.size_request()[0] + 16 > self.Blueman.window.get_size()[0]:
 
84
        #       self.Blueman.Stats.hbox.hide_all()
 
85
 
 
86
 
 
87
        self.progressbar.props.visible = True
 
88
        self.eventbox.props.visible = True
 
89
        self.button.props.visible = True
 
90
 
 
91
    def hide(self):
 
92
        self.Blueman.Stats.hbox.show_all()
 
93
        self.progressbar.props.visible = False
 
94
        self.eventbox.props.visible = False
 
95
        self.button.props.visible = False
 
96
 
 
97
    def message(self, msg, timeout=1500):
 
98
        self.stop()
 
99
        self.set_label(msg)
 
100
        self.set_cancellable(False)
 
101
        GObject.timeout_add(timeout, self.finalize)
 
102
 
 
103
 
 
104
    def finalize(self):
 
105
        if not self.finalized:
 
106
            self.hide()
 
107
            self.stop()
 
108
            Gdk.Window.set_cursor(self.window.get_window(), None)
 
109
            self.hbox.remove(self.eventbox)
 
110
            self.hbox.remove(self.progressbar)
 
111
            # self.hbox.remove(self.seperator)
 
112
            self.finalized = True
 
113
 
 
114
            if ManagerProgressbar.__instances__[-1] == self:
 
115
                ManagerProgressbar.__instances__.pop()
 
116
                #remove all finalized instances
 
117
                for inst in reversed(ManagerProgressbar.__instances__):
 
118
                    if inst.finalized:
 
119
                        ManagerProgressbar.__instances__.pop()
 
120
                    else:
 
121
                        #show last active progress bar
 
122
                        inst.show()
 
123
                        break
 
124
 
 
125
            if ManagerProgressbar.__instances__ == []:
 
126
                if not self.Blueman.Config["show-statusbar"]:
 
127
                    self.Blueman.Builder.get_object("statusbar").props.visible = False
 
128
 
 
129
            self.signals.DisconnectAll()
 
130
 
 
131
 
 
132
    def set_cancellable(self, b, hide=False):
 
133
        if b:
 
134
            self.eventbox.props.visible = True
 
135
            self.eventbox.props.sensitive = True
 
136
        else:
 
137
            if hide:
 
138
                self.eventbox.props.visible = False
 
139
            else:
 
140
                self.eventbox.props.sensitive = False
 
141
 
 
142
    def set_label(self, label):
 
143
        self.progressbar.props.text = label
 
144
 
 
145
    def fraction(self, frac):
 
146
        if not self.finalized:
 
147
            self.progressbar.set_fraction(frac)
 
148
 
 
149
    def started(self):
 
150
        return self.gsource != None
 
151
 
 
152
    def start(self):
 
153
        def pulse():
 
154
            self.progressbar.pulse()
 
155
            return True
 
156
 
 
157
        if not self.gsource:
 
158
            self.gsource = GObject.timeout_add(1000 / 24, pulse)
 
159
 
 
160
    def stop(self):
 
161
        if self.gsource != None:
 
162
            GObject.source_remove(self.gsource)
 
163
        self.progressbar.set_fraction(0.0)