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

  • Committer: Jelmer Vernooij
  • Date: 2011-03-15 23:05:04 UTC
  • mfrom: (719.2.5 gtk)
  • Revision ID: jelmer@samba.org-20110315230504-b53r1h6qh9boofmi
Merge support for showing gravatars.

Show diffs side-by-side

added added

removed removed

Lines of Context:
avatarsbox.py
 
1
# Copyright (C) 2011 by Guillaume Hain (zedtux) <zedtux@zedroot.org>
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
import gtk
 
18
 
 
19
from bzrlib.config import parse_username
 
20
 
 
21
from bzrlib.plugins.gtk import _i18n
 
22
from bzrlib.plugins.gtk.avatarproviders import AvatarProviderGravatar, AvatarDownloaderWorker
 
23
 
 
24
 
 
25
class Avatar(gtk.Box):
 
26
    """ Author or committer avatar """
 
27
    
 
28
    def __init__(self, apparent_username):
 
29
        """ Constructor """
 
30
        gtk.Box.__init__(self)
 
31
        
 
32
        self.apparent_username = apparent_username
 
33
        self.username, self.email = parse_username(apparent_username)
 
34
        self.image = None
 
35
    
 
36
    def __eq__(self, other):
 
37
        """
 
38
        Return True if attributes of the given avatar
 
39
        match to current object attributes otherwise return False
 
40
        """
 
41
        return self.apparent_username == other.apparent_username and \
 
42
               self.name == other.name and \
 
43
               self.email == other.email
 
44
    
 
45
    # ~~~~~ Public methods ~~~~~
 
46
    def show_spinner(self):
 
47
        """
 
48
        Replace the current content of the Avatar with a gtk.Spinner
 
49
        if an email address has been parsed. If not, show an gtk.Label with
 
50
        the translatable 'No email' text.
 
51
        """
 
52
        if not self.email is "":
 
53
            spinner = gtk.Spinner()
 
54
            spinner.start()
 
55
            self.pack_start(spinner, False)
 
56
            spinner.set_tooltip_text(_i18n("Retrieving avatar for %s...") % self.email)
 
57
            spinner.set_size_request(20, 20)
 
58
            spinner.show()
 
59
        else:
 
60
            no_email = gtk.Label(_i18n("No email"))
 
61
            self.pack_start(no_email)
 
62
            self.set_tooltip_text(self.apparent_username)
 
63
            no_email.show()
 
64
    
 
65
    def show_image(self):
 
66
        """ Replace the current content of the Avatar with the gtk.Image """
 
67
        if not self.email is "" and self.image:
 
68
            self.remove(self.get_children()[0])
 
69
            self.pack_start(self.image)
 
70
            self.image.set_tooltip_text(self.apparent_username)
 
71
            self.image.show()
 
72
 
 
73
 
 
74
class AvatarBox(gtk.HBox):
 
75
    """ Improved gtk.HBox """
 
76
    
 
77
    def __init__(self, homogeneous=False, spacing=0):
 
78
        """ Constructor """
 
79
        gtk.HBox.__init__(self, homogeneous, spacing)
 
80
        self.__avatars = {}
 
81
        self.avatar = None
 
82
        self.__displaying = None
 
83
    
 
84
    
 
85
    # ~~~~~ Public methods ~~~~~
 
86
    def reset_view(self):
 
87
        """ Remove current avatars from the gtk box """
 
88
        for child in self.get_children():
 
89
            self.remove(child)
 
90
        self.__displaying = None
 
91
    
 
92
    def have_avatar(self, avatar):
 
93
        """
 
94
        Return True if this box has registered given avatar,
 
95
        otherwise return False
 
96
        """
 
97
        return avatar.email in self.__avatars
 
98
    
 
99
    def showing(self, avatar):
 
100
        """
 
101
        Return True if the displaying avatar is the same
 
102
        as the given one otherwise return False
 
103
        """
 
104
        return self.__displaying and self.__displaying == avatar
 
105
    
 
106
    def append_avatars_with(self, avatar):
 
107
        """
 
108
        Append avatars collection with the given one if not already registed
 
109
        otherwise render it back.
 
110
        When an avatar is added this method True, otherwise, if the avatar
 
111
        was in the collection, return False.
 
112
        """
 
113
        if not avatar.email is "" and not avatar.email in self.__avatars:
 
114
            self.__avatars[avatar.email] = avatar
 
115
            self._new_cell_for_avatar(avatar)
 
116
            return True
 
117
        else:
 
118
            self.and_avatar_email(avatar.email).come_back_to_gui()
 
119
        return False
 
120
    
 
121
    def and_avatar_email(self, email):
 
122
        """
 
123
        Select the avatar from avatars collection
 
124
        in order to apply future actions
 
125
        """
 
126
        self.avatar = None
 
127
        if not email is "" and email in self.__avatars:
 
128
            self.avatar = self.__avatars[email]
 
129
        else:
 
130
            self.avatar = None
 
131
        return self
 
132
    
 
133
    def update_avatar_image_from_pixbuf_loader(self, loader):
 
134
        """ Replace the gtk.Spinner with the given loader """
 
135
        if self.avatar:
 
136
            self.avatar.image = gtk.Image()
 
137
            self.avatar.image.set_from_pixbuf(loader.get_pixbuf())
 
138
            self.avatar.show_image()
 
139
            self.__displaying = self.avatar
 
140
    
 
141
    def come_back_to_gui(self):
 
142
        """ Render back avatar in the GUI """
 
143
        if self.avatar:
 
144
            self.pack_start(self.avatar)
 
145
            self.__displaying = self.avatar
 
146
        else:
 
147
            self._show_no_email()
 
148
    
 
149
    
 
150
    # ~~~~~ Private methods ~~~~~~
 
151
    def _new_cell_for_avatar(self, avatar):
 
152
        """ Create a new cell in this box with a gtk.Spinner """
 
153
        avatar.show_spinner()
 
154
        self.pack_start(avatar)
 
155
        avatar.show()
 
156
        self.__displaying = avatar
 
157
    
 
158
    def _show_no_email(self):
 
159
        """ Show a gtk.Label with test 'No email' """
 
160
        no_email = gtk.Label(_i18n("No email"))
 
161
        self.pack_start(no_email)
 
162
        no_email.show()
 
163
 
 
164
 
 
165
class AvatarsBox(gtk.HBox):
 
166
    """ GTK container for authors and committers avatars """
 
167
    
 
168
    def __init__(self):
 
169
        """ Constructor """
 
170
        gtk.HBox.__init__(self, False, 10)
 
171
        
 
172
        self.__committer_box = None
 
173
        self.__authors_box = None
 
174
        self._init_gui()
 
175
        
 
176
        # If more later you want to implement more avatar providers, to it like this:
 
177
        # Create a new class named AvatarProvider + provider_name that inherit from
 
178
        # the AvatarProvider class.
 
179
        # Implement a method that return url to use in the request.
 
180
        # For example, with Gravatar, the method return the complete url
 
181
        # with MD5 hash of the email address and put the value in a gravatar_id field.
 
182
        # Then create a new worker (manage them in a python dictionnary).
 
183
        provider = AvatarProviderGravatar()
 
184
        self.__worker = AvatarDownloaderWorker(
 
185
            provider.gravatar_id_for_email
 
186
        )
 
187
        # This callback method should be fired bt all workers when a request is done.
 
188
        self.__worker.set_callback_method(self._update_avatar_from_response)
 
189
        self.__worker.start()
 
190
    
 
191
    
 
192
    # ~~~~~ Public methods ~~~~~
 
193
    def add(self, username, role):
 
194
        """
 
195
        Add the given username in the right role box and add in the worker queue.
 
196
        Here again: If you want to implement more providers, you should add the
 
197
        avatar request in all workers queue.
 
198
        """
 
199
        avatar = Avatar(username)
 
200
        if role is "author" and not self._role_box_for("committer").showing(avatar) or role is "committer":
 
201
            if self._role_box_for(role).append_avatars_with(avatar):
 
202
                self.__worker.queue(avatar.email)
 
203
    
 
204
    def merge(self, usernames, role):
 
205
        """ Add avatars from a list """
 
206
        for username in usernames:
 
207
            self.add(username, role)
 
208
    
 
209
    def reset(self):
 
210
        """
 
211
        Request a reset view for all boxes in order to show only avatars
 
212
        of the selected line in the revision view screen.
 
213
        """
 
214
        [self._role_box_for(role).reset_view() for role in ["committer", "author"]]
 
215
    
 
216
    
 
217
    # ~~~~~ Private methods ~~~~~
 
218
    def _init_gui(self):
 
219
        """ Create boxes where avatars will be displayed """
 
220
        # 2 gtk.HBox: One for the committer and one for authors
 
221
        # Committer
 
222
        self.__committer_box = AvatarBox()
 
223
        self.__committer_box.set_size_request(80, 80)
 
224
        self.pack_end(self.__committer_box, False)
 
225
        self.__committer_box.show()
 
226
        # Authors
 
227
        self.__authors_box = AvatarBox()
 
228
        self.pack_end(self.__authors_box, False)
 
229
        self.__authors_box.set_spacing(10)
 
230
        self.__authors_box.show()
 
231
    
 
232
    def _update_avatar_from_response(self, response, email):
 
233
        """
 
234
        Callback method fired by avatar worker when finished.
 
235
        
 
236
        response is a urllib2.urlopen() return value.
 
237
        email is used to identify item from self.__avatars.
 
238
        """
 
239
        if not email is "":
 
240
            # Convert downloaded image from provider to gtk.Image
 
241
            loader = gtk.gdk.PixbufLoader()
 
242
            loader.write(response.read())
 
243
            loader.close()
 
244
            
 
245
            for role in ["committer", "author"]:
 
246
                self._role_box_for(role).and_avatar_email(email).update_avatar_image_from_pixbuf_loader(loader)
 
247
    
 
248
    def _role_box_for(self, role):
 
249
        """ Return the gtk.HBox for the given role """
 
250
        return self.__committer_box if role is "committer" else self.__authors_box