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 avatarsbox.py
- browse files at revision 719.2.5
- compare with another revision
- download diff
- download tarball
- view history from revision 719.2.5
- Committer: zedtux
- Date: 2011-03-15 16:50:15 UTC
- mto: This revision was merged to the branch mainline in revision 723.
- Revision ID: zedtux@zedroot.org-20110315165015-dc8r4yoqhkmfrye3
Moved AvatarDownloaderWorker class into avatarsbox.py file
- files added:
- bzr-notify
- files removed:
- commitmsgs.py
- files modified:
- AUTHORS
added
removed
avatarsbox.py
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
from gi.repository import Gtk
18
from gi.repository import GdkPixbuf
17
import gtk
19
18
19
from bzrlib.plugins.gtk import _i18n
20
20
from bzrlib.config import parse_username
21
22
from bzrlib.plugins.gtk.i18n import _i18n
23
from bzrlib.plugins.gtk.avatarproviders import (
24
AvatarProviderGravatar,
25
AvatarDownloaderWorker,
26
)
27
28
29
class Avatar(Gtk.HBox):
21
from bzrlib.plugins.gtk.avatarproviders import AvatarProviderGravatar, AvatarDownloaderWorker
22
23
24
class Avatar(gtk.Box):
30
25
""" Author or committer avatar """
31
26
32
27
def __init__(self, apparent_username):
33
28
""" Constructor """
34
super(Avatar, self).__init__()
35
29
gtk.Box.__init__(self)
30
36
31
self.apparent_username = apparent_username
37
32
self.username, self.email = parse_username(apparent_username)
38
33
self.image = None
39
34
40
35
def __eq__(self, other):
41
return (self.apparent_username == other.apparent_username and
42
self.username == other.username and
43
self.email == other.email)
44
36
"""
37
Return True if attributes of the given avatar
38
match to current object attributes otherwise return False
39
"""
40
return self.apparent_username == other.apparent_username and \
41
self.name == other.name and \
42
self.email == other.email
43
44
# ~~~~~ Public methods ~~~~~
45
45
def show_spinner(self):
46
46
"""
47
Replace the current content of the Avatar with a Gtk.Spinner
48
if an email address has been parsed. If not, show an Gtk.Label with
47
Replace the current content of the Avatar with a gtk.Spinner
48
if an email address has been parsed. If not, show an gtk.Label with
49
49
the translatable 'No email' text.
50
50
"""
51
if self.email:
52
tooltip = _i18n("Retrieving avatar for %s...") % self.email
53
spinner = Gtk.Spinner()
51
if not self.email is "":
52
spinner = gtk.Spinner()
54
53
spinner.start()
55
self.pack_start(spinner, False, True, 0)
56
spinner.set_tooltip_text(tooltip)
54
self.pack_start(spinner, False)
55
spinner.set_tooltip_text(_i18n("Retrieving avatar for %s...") % self.email)
57
56
spinner.set_size_request(20, 20)
58
57
spinner.show()
59
58
else:
60
no_email = Gtk.Label(label=_i18n("No email"))
61
self.pack_start(no_email, True, True, 0)
59
no_email = gtk.Label(_i18n("No email"))
60
self.pack_start(no_email)
62
61
self.set_tooltip_text(self.apparent_username)
63
62
no_email.show()
64
63
65
64
def show_image(self):
66
"""Replace the current content of the Avatar with the Gtk.Image """
67
if self.email and self.image:
68
children = self.get_children()
69
if children != []:
70
self.remove(children[0])
71
self.pack_start(self.image, True, True, 0)
65
""" Replace the current content of the Avatar with the gtk.Image """
66
if not self.email is "" and self.image:
67
self.remove(self.get_children()[0])
68
self.pack_start(self.image)
72
69
self.image.set_tooltip_text(self.apparent_username)
73
70
self.image.show()
74
71
75
72
76
class AvatarBox(Gtk.HBox):
77
"""HBox showing an avatar."""
78
73
class AvatarBox(gtk.HBox):
74
""" Improved gtk.HBox """
75
79
76
def __init__(self, homogeneous=False, spacing=0):
80
super(AvatarBox, self).__init__(
81
homogeneous=homogeneous, spacing=spacing)
77
""" Constructor """
78
gtk.HBox.__init__(self, homogeneous, spacing)
82
79
self.__avatars = {}
83
80
self.avatar = None
84
81
self.__displaying = None
85
82
83
84
# ~~~~~ Public methods ~~~~~
86
85
def reset_view(self):
87
"""Remove current avatars from the gtk box."""
86
""" Remove current avatars from the gtk box """
88
87
for child in self.get_children():
89
88
self.remove(child)
90
89
self.__displaying = None
91
90
92
91
def have_avatar(self, avatar):
93
"""Return True if this box has the specified avatar.
92
"""
93
Return True if this box has registered given avatar,
94
otherwise return False
94
95
"""
95
96
return avatar.email in self.__avatars
96
97
97
98
def showing(self, avatar):
98
"""Return True if the displaying avatar matches the specified one.
99
"""
100
Return True if the displaying avatar is the same
101
as the given one otherwise return False
99
102
"""
100
103
return self.__displaying and self.__displaying == avatar
101
104
102
105
def append_avatars_with(self, avatar):
103
106
"""
104
107
Append avatars collection with the given one if not already registed
106
109
When an avatar is added this method True, otherwise, if the avatar
107
110
was in the collection, return False.
108
111
"""
109
if avatar.email and not avatar.email in self.__avatars:
112
if not avatar.email is "" and not avatar.email in self.__avatars:
110
113
self.__avatars[avatar.email] = avatar
111
114
self._new_cell_for_avatar(avatar)
112
115
return True
113
116
else:
114
117
self.and_avatar_email(avatar.email).come_back_to_gui()
115
118
return False
116
119
117
120
def and_avatar_email(self, email):
118
121
"""
119
122
Select the avatar from avatars collection
120
123
in order to apply future actions
121
124
"""
122
125
self.avatar = None
123
if email and email in self.__avatars:
126
if not email is "" and email in self.__avatars:
124
127
self.avatar = self.__avatars[email]
125
128
else:
126
129
self.avatar = None
127
130
return self
128
131
129
132
def update_avatar_image_from_pixbuf_loader(self, loader):
130
"""Replace the Gtk.Spinner with the given loader."""
133
""" Replace the gtk.Spinner with the given loader """
131
134
if self.avatar:
132
self.avatar.image = Gtk.Image()
135
self.avatar.image = gtk.Image()
133
136
self.avatar.image.set_from_pixbuf(loader.get_pixbuf())
134
137
self.avatar.show_image()
135
138
self.__displaying = self.avatar
136
139
137
140
def come_back_to_gui(self):
138
"""Render back avatar in the GUI."""
141
""" Render back avatar in the GUI """
139
142
if self.avatar:
140
self.pack_start(self.avatar, True, True, 0)
143
self.pack_start(self.avatar)
141
144
self.__displaying = self.avatar
142
145
else:
143
146
self._show_no_email()
144
147
148
149
# ~~~~~ Private methods ~~~~~~
145
150
def _new_cell_for_avatar(self, avatar):
146
"""Create a new cell in this box with a Gtk.Spinner."""
151
""" Create a new cell in this box with a gtk.Spinner """
147
152
avatar.show_spinner()
148
self.pack_start(avatar, True, True, 0)
153
self.pack_start(avatar)
149
154
avatar.show()
150
155
self.__displaying = avatar
151
156
152
157
def _show_no_email(self):
153
"""Show a Gtk.Label with text 'No email'."""
154
no_email = Gtk.Label(label=_i18n("No email"))
155
self.pack_start(no_email, True, True, 0)
158
""" Show a gtk.Label with test 'No email' """
159
no_email = gtk.Label(_i18n("No email"))
160
self.pack_start(no_email)
156
161
no_email.show()
157
162
158
163
159
class AvatarsBox(Gtk.HBox):
160
"""GTK container for author and committer avatars."""
161
164
class AvatarsBox(gtk.HBox):
165
""" GTK container for authors and committers avatars """
166
162
167
def __init__(self):
163
super(AvatarsBox, self).__init__(homogeneous=False, spacing=10)
168
""" Constructor """
169
gtk.HBox.__init__(self, False, 10)
170
164
171
self.__committer_box = None
165
172
self.__authors_box = None
166
173
self._init_gui()
167
168
# If more later you want to implement more avatar providers:
169
# * Create a new class named AvatarProvider + provider_name that
170
# inherit from the AvatarProvider class.
171
# * Implement a method that return url to use in the request.
172
174
175
# If more later you want to implement more avatar providers, to it like this:
176
# Create a new class named AvatarProvider + provider_name that inherit from
177
# the AvatarProvider class.
178
# Implement a method that return url to use in the request.
173
179
# For example, with Gravatar, the method return the complete url
174
# with MD5 hash of the email address and put the value in a
175
# gravatar_id field.
176
# Then create a new worker (manage them in a python dictionary).
180
# with MD5 hash of the email address and put the value in a gravatar_id field.
181
# Then create a new worker (manage them in a python dictionnary).
177
182
provider = AvatarProviderGravatar()
178
183
self.__worker = AvatarDownloaderWorker(
179
184
provider.gravatar_id_for_email
180
185
)
181
# This callback method should be fired by all workers when a request
182
# is done.
186
# This callback method should be fired bt all workers when a request is done.
183
187
self.__worker.set_callback_method(self._update_avatar_from_response)
184
self.connect('destroy', self.on_destroy)
185
186
def on_destroy(self, widget):
187
self.__worker.stop()
188
if self.__worker.is_alive():
189
self.__worker.join()
190
188
self.__worker.start()
189
190
191
# ~~~~~ Public methods ~~~~~
191
192
def add(self, username, role):
192
"""Add the given username in the role box and add in the worker queue.
193
"""
194
Add the given username in the right role box and add in the worker queue.
195
Here again: If you want to implement more providers, you should add the
196
avatar request in all workers queue.
193
197
"""
194
198
avatar = Avatar(username)
195
is_shown = self._role_box_for("committer").showing(avatar)
196
if (role == "author" and not is_shown) or role == "committer":
199
if role is "author" and not self._role_box_for("committer").showing(avatar) or role is "committer":
197
200
if self._role_box_for(role).append_avatars_with(avatar):
198
201
self.__worker.queue(avatar.email)
199
202
200
203
def merge(self, usernames, role):
201
"""Add avatars from a list"""
204
""" Add avatars from a list """
202
205
for username in usernames:
203
206
self.add(username, role)
204
207
205
208
def reset(self):
206
209
"""
207
210
Request a reset view for all boxes in order to show only avatars
208
211
of the selected line in the revision view screen.
209
212
"""
210
for role in ("committer", "author"):
211
self._role_box_for(role).reset_view()
212
213
[self._role_box_for(role).reset_view() for role in ["committer", "author"]]
214
215
216
# ~~~~~ Private methods ~~~~~
213
217
def _init_gui(self):
214
"""Create boxes where avatars will be displayed."""
215
# 2 Gtk.HBox: One for the committer and one for authors
218
""" Create boxes where avatars will be displayed """
219
# 2 gtk.HBox: One for the committer and one for authors
216
220
# Committer
217
221
self.__committer_box = AvatarBox()
218
222
self.__committer_box.set_size_request(80, 80)
219
self.pack_end(self.__committer_box, False, True, 0)
223
self.pack_end(self.__committer_box, False)
220
224
self.__committer_box.show()
221
225
# Authors
222
226
self.__authors_box = AvatarBox()
223
self.pack_end(self.__authors_box, False, True, 0)
227
self.pack_end(self.__authors_box, False)
224
228
self.__authors_box.set_spacing(10)
225
229
self.__authors_box.show()
226
230
227
231
def _update_avatar_from_response(self, response, email):
228
"""Callback method fired by avatar worker when finished.
229
230
:param response: a urllib2.urlopen() return value.
231
:param email: used to identify item from self.__avatars.
232
"""
233
if email:
234
# Convert downloaded image from provider to Gtk.Image
235
loader = GdkPixbuf.PixbufLoader()
232
"""
233
Callback method fired by avatar worker when finished.
234
235
response is a urllib2.urlopen() return value.
236
email is used to identify item from self.__avatars.
237
"""
238
if not email is "":
239
# Convert downloaded image from provider to gtk.Image
240
loader = gtk.gdk.PixbufLoader()
236
241
loader.write(response.read())
237
242
loader.close()
238
243
239
244
for role in ["committer", "author"]:
240
self._role_box_for(role).and_avatar_email(
241
email).update_avatar_image_from_pixbuf_loader(loader)
242
245
self._role_box_for(role).and_avatar_email(email).update_avatar_image_from_pixbuf_loader(loader)
246
243
247
def _role_box_for(self, role):
244
""" Return the Gtk.HBox for the given role """
245
if role == "committer":
246
return self.__committer_box
247
else:
248
return self.__authors_box
248
""" Return the gtk.HBox for the given role """
249
return self.__committer_box if role is "committer" else self.__authors_box
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0