/b-gtk/fix-viz : contents of avatarsbox.py at revision 713.2.3

: (revision 713.2.3)

To get this branch, use:

bzr branch
http://gegoxaren.bato24.eu/bzr/b-gtk/fix-viz

# Copyright (C) 2011 by Guillaume Hain (zedtux) <zedtux@zedroot.org>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import gtk

from bzrlib.config import parse_username

from bzrlib.plugins.gtk import _i18n
from bzrlib.plugins.gtk.avatarproviders import AvatarProviderGravatar, AvatarDownloaderWorker


class Avatar(gtk.Box):
    """ Author or committer avatar """
    
    def __init__(self, apparent_username):
        """ Constructor """
        gtk.Box.__init__(self)
        
        self.apparent_username = apparent_username
        self.username, self.email = parse_username(apparent_username)
        self.image = None
    
    def __eq__(self, other):
        """
        Return True if attributes of the given avatar
        match to current object attributes otherwise return False
        """
        return self.apparent_username == other.apparent_username and \
               self.name == other.name and \
               self.email == other.email
    
    # ~~~~~ Public methods ~~~~~
    def show_spinner(self):
        """
        Replace the current content of the Avatar with a gtk.Spinner
        if an email address has been parsed. If not, show an gtk.Label with
        the translatable 'No email' text.
        """
        if not self.email is "":
            spinner = gtk.Spinner()
            spinner.start()
            self.pack_start(spinner, False)
            spinner.set_tooltip_text(_i18n("Retrieving avatar for %s...") % self.email)
            spinner.set_size_request(20, 20)
            spinner.show()
        else:
            no_email = gtk.Label(_i18n("No email"))
            self.pack_start(no_email)
            self.set_tooltip_text(self.apparent_username)
            no_email.show()
    
    def show_image(self):
        """ Replace the current content of the Avatar with the gtk.Image """
        if not self.email is "" and self.image:
            self.remove(self.get_children()[0])
            self.pack_start(self.image)
            self.image.set_tooltip_text(self.apparent_username)
            self.image.show()


class AvatarBox(gtk.HBox):
    """ Improved gtk.HBox """
    
    def __init__(self, homogeneous=False, spacing=0):
        """ Constructor """
        gtk.HBox.__init__(self, homogeneous, spacing)
        self.__avatars = {}
        self.avatar = None
        self.__displaying = None
    
    
    # ~~~~~ Public methods ~~~~~
    def reset_view(self):
        """ Remove current avatars from the gtk box """
        for child in self.get_children():
            self.remove(child)
        self.__displaying = None
    
    def have_avatar(self, avatar):
        """
        Return True if this box has registered given avatar,
        otherwise return False
        """
        return avatar.email in self.__avatars
    
    def showing(self, avatar):
        """
        Return True if the displaying avatar is the same
        as the given one otherwise return False
        """
        return self.__displaying and self.__displaying == avatar
    
    def append_avatars_with(self, avatar):
        """
        Append avatars collection with the given one if not already registed
        otherwise render it back.
        When an avatar is added this method True, otherwise, if the avatar
        was in the collection, return False.
        """
        if not avatar.email is "" and not avatar.email in self.__avatars:
            self.__avatars[avatar.email] = avatar
            self._new_cell_for_avatar(avatar)
            return True
        else:
            self.and_avatar_email(avatar.email).come_back_to_gui()
        return False
    
    def and_avatar_email(self, email):
        """
        Select the avatar from avatars collection
        in order to apply future actions
        """
        self.avatar = None
        if not email is "" and email in self.__avatars:
            self.avatar = self.__avatars[email]
        else:
            self.avatar = None
        return self
    
    def update_avatar_image_from_pixbuf_loader(self, loader):
        """ Replace the gtk.Spinner with the given loader """
        if self.avatar:
            self.avatar.image = gtk.Image()
            self.avatar.image.set_from_pixbuf(loader.get_pixbuf())
            self.avatar.show_image()
            self.__displaying = self.avatar
    
    def come_back_to_gui(self):
        """ Render back avatar in the GUI """
        if self.avatar:
            self.pack_start(self.avatar)
            self.__displaying = self.avatar
        else:
            self._show_no_email()
    
    
    # ~~~~~ Private methods ~~~~~~
    def _new_cell_for_avatar(self, avatar):
        """ Create a new cell in this box with a gtk.Spinner """
        avatar.show_spinner()
        self.pack_start(avatar)
        avatar.show()
        self.__displaying = avatar
    
    def _show_no_email(self):
        """ Show a gtk.Label with test 'No email' """
        no_email = gtk.Label(_i18n("No email"))
        self.pack_start(no_email)
        no_email.show()


class AvatarsBox(gtk.HBox):
    """ GTK container for authors and committers avatars """
    
    def __init__(self):
        """ Constructor """
        gtk.HBox.__init__(self, False, 10)
        
        self.__committer_box = None
        self.__authors_box = None
        self._init_gui()
        
        # If more later you want to implement more avatar providers, to it like this:
        # Create a new class named AvatarProvider + provider_name that inherit from
        # the AvatarProvider class.
        # Implement a method that return url to use in the request.
        # For example, with Gravatar, the method return the complete url
        # with MD5 hash of the email address and put the value in a gravatar_id field.
        # Then create a new worker (manage them in a python dictionnary).
        provider = AvatarProviderGravatar()
        self.__worker = AvatarDownloaderWorker(
            provider.gravatar_id_for_email
        )
        # This callback method should be fired bt all workers when a request is done.
        self.__worker.set_callback_method(self._update_avatar_from_response)
        self.__worker.start()
    
    
    # ~~~~~ Public methods ~~~~~
    def add(self, username, role):
        """
        Add the given username in the right role box and add in the worker queue.
        Here again: If you want to implement more providers, you should add the
        avatar request in all workers queue.
        """
        avatar = Avatar(username)
        if role is "author" and not self._role_box_for("committer").showing(avatar) or role is "committer":
            if self._role_box_for(role).append_avatars_with(avatar):
                self.__worker.queue(avatar.email)
    
    def merge(self, usernames, role):
        """ Add avatars from a list """
        for username in usernames:
            self.add(username, role)
    
    def reset(self):
        """
        Request a reset view for all boxes in order to show only avatars
        of the selected line in the revision view screen.
        """
        [self._role_box_for(role).reset_view() for role in ["committer", "author"]]
    
    
    # ~~~~~ Private methods ~~~~~
    def _init_gui(self):
        """ Create boxes where avatars will be displayed """
        # 2 gtk.HBox: One for the committer and one for authors
        # Committer
        self.__committer_box = AvatarBox()
        self.__committer_box.set_size_request(80, 80)
        self.pack_end(self.__committer_box, False)
        self.__committer_box.show()
        # Authors
        self.__authors_box = AvatarBox()
        self.pack_end(self.__authors_box, False)
        self.__authors_box.set_spacing(10)
        self.__authors_box.show()
    
    def _update_avatar_from_response(self, response, email):
        """
        Callback method fired by avatar worker when finished.
        
        response is a urllib2.urlopen() return value.
        email is used to identify item from self.__avatars.
        """
        if not email is "":
            # Convert downloaded image from provider to gtk.Image
            loader = gtk.gdk.PixbufLoader()
            loader.write(response.read())
            loader.close()
            
            for role in ["committer", "author"]:
                self._role_box_for(role).and_avatar_email(email).update_avatar_image_from_pixbuf_loader(loader)
    
    def _role_box_for(self, role):
        """ Return the gtk.HBox for the given role """
        return self.__committer_box if role is "committer" else self.__authors_box

719.2.1 by zedtux Added committers and authors avatars from Gravatar (urllib2 version)	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
723 by Jelmer Vernooij Merge support for showing gravatars.	19	from bzrlib.config import parse_username
723 by Jelmer Vernooij Merge support for showing gravatars.	20
719.2.4 by zedtux Moved Avatar and AvatarBox classes into avatarsbox file	21	from bzrlib.plugins.gtk import _i18n
719.2.5 by zedtux Moved AvatarDownloaderWorker class into avatarsbox.py file	22	from bzrlib.plugins.gtk.avatarproviders import AvatarProviderGravatar, AvatarDownloaderWorker
719.2.1 by zedtux Added committers and authors avatars from Gravatar (urllib2 version)	23
719.2.4 by zedtux Moved Avatar and AvatarBox classes into avatarsbox file	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
719.2.1 by zedtux Added committers and authors avatars from Gravatar (urllib2 version)	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 """
719.2.2 by zedtux Patched code following Jelmer's recommandations	206	for username in usernames:
	207	self.add(username, role)
719.2.1 by zedtux Added committers and authors avatars from Gravatar (urllib2 version)	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