Merge lp:~samuel-buffet/entertainer/reactive_menus into lp:entertainer

[Samuel Buffet]

All menus are now reactive to mouse pointer events.

[Samuel Buffet (samuel-buffet)]

Devs,

Finally the day has come.

I think it's now time for me to propose this work around menus.

The goal was first to make menu pointer reactive, but it turned out that I've done a GridMenu refactoring at the same time. For me it was just none sense to change the current GridMenu.

As menus are everywhere, the branch is quite big (the diff is around 5kline).
I know that this branch is far from being perfect, but if I wait longer then it will become very hard to land that work.

As it is not perfect, I'm prepared for a long and hard review with probably a lot of discussions.

But definitely, the work is enough mature to be proposed. A lot of other things can be done but it can be done later imho.

Good review.

Samuel-

[Matt Layman (mblayman)]

Cripes!! This is going to take quite a long time to review. :)

Do you have suggestions of where to start? What's the core change? Some widget? GridMenu? I typically like to look at the core change, then examine everything that it affected. That might just be the entire frontend in this case, but I thought I'd ask in case there was hope for me. ;)

[Samuel Buffet (samuel-buffet)]

> Cripes!! This is going to take quite a long time to review. :)
>
> Do you have suggestions of where to start? What's the core change? Some
> widget? GridMenu? I typically like to look at the core change, then examine
> everything that it affected. That might just be the entire frontend in this
> case, but I thought I'd ask in case there was hope for me. ;)

Well, everything starts from the GridMenu which has been greatly refactored.
Then, the classes inheriting from it: ImageMenu, TextMenu.
Then maybe the relative menuitems.
And to finish the screens.

That might be a good order.

The GridMenu looks difficult but is quite simple in fact. There's only a couple of methods that will need a bit of abstraction (those linked to the cursor's motion).

Keep in mind that the GridMenu is a group containing a moving group which is translated on x,y and a cursor also translatable on x,y.

The rest of the code is really classic and easy to read.

Samuel-

[Samuel Buffet (samuel-buffet)]

I forgot to mention that there's also a new specif behaviour.

We now have 2, LoopedPathBehaviour and the new FontSizeBehaviour used to do a font size effect.

When clutter 1.0 will be released, we'll have quite a lot of work. Not only to change our code to the new API but also to see if there's no better way to do things with it.

Samuel-

[Matt Layman (mblayman)]

Well, here we go. Please keep in mind that these comments are basically everything that I could think of. I understand if not all comments are landed in this branch. This is just comments for the two files listed below (because it's all I'm going to review tonight). More comments will come later, but this is at least something to chew on.

base.py:
 * y_for_x docstring isn't very clear (gramatically). The word "than" just doesn't work well in that context. I think you could replace "than" with "equivalent to".
 * Could you add a test for this method?

grid_menu.py:
 * Is this widget testable? I've got to believe that somewhere in those 561 lines is something that can be tested. :)
 * import order. math is a Python standard library module.
 * Please add something meaningful to the class docstring.
 * I'm fairly lost by the init. There are so many instance variables. You seem to have some groupings, but could you add some comments to help us understand what those groupings are?
 * init seems to have some default width and heights. The values seem like they are pixels and not percentages. Why is that? Could they be percentages instead?
 * self.motion_duration in init: what is the unit of time for it? 100 is just a magic number right now.
 * _item_width_abs for the default value of item_width=200 will be enormous. Way larger than the stage.
 * event rect color of Orange. I like it. :D
 * When the branch lands, please file a bug about your XXX in the init. I'm okay with that XXX comment landing.
 * on_bottom & on_right: you could move the end_row calculation into the if statement of _is_vertical to slightly improve performance of horizontal menus. (Remember, these comments are *everything* I could think of :D).
 * _set_selected_index: "relatively" should be "relative"
 * _set_selected_index comment needs cleanup (start with "#start select...").
 * What is the cursor in _set_selected_index comments? Is that the mouse cursor? Is it some other cursor that is tracked by the GridMenu? I'm having a hard time figuring it out. Maybe there could be a comment by cursor property definition.
 * I got to the direction methods (up, down, left, right) and said to myself "WTF!? Why isn't there code to move something?" I then realized that the _set_selected_index method triggers the actual movement. I think it would be wise to mention this in the docstring.
 * Xc and Yc seems like the coordinates of "index" to me (line 234) and not like "coordinates of the cursor relatively to the moving group". Am I missing something?
 * Could you add some comments to the series of if statements in _set_selected_index? Mapping variable names in my head (because xm, Xc, and xc aren't very descriptive) and determining boolean logic at the same time is difficult to do. I'm sure the rules make sense, but it's hard as a reader to immediately understand what the code is trying to accomplish in those lines.
 * What is items_anchor_west? Everywhere that it is used in the code, it is set to False. And only one part of GridMenu uses it (raw_add_item). Therefore, the if portion of "if self.items_anchor_west" will never execute.
 * Could you expand the raw_add_item docstring? For example, wh...

review: Needs Fixing

[lp:~samuel-buffet/entertainer/reactive_menus]

508. By Samuel Buffet on 2009-07-15

Fixes after first set of comments from Matt (part 1).

[Samuel Buffet (samuel-buffet)]

Evening Matt,

See my first set of fixes.

The fixes are for this part of your comments.
To be continued.

Samuel-

> base.py:
> * y_for_x docstring isn't very clear (gramatically). The word "than" just
> doesn't work well in that context. I think you could replace "than" with
> "equivalent to".
> * Could you add a test for this method?
>
> grid_menu.py:
> * Is this widget testable? I've got to believe that somewhere in those 561
> lines is something that can be tested. :)
> * import order. math is a Python standard library module.
> * Please add something meaningful to the class docstring.
> * I'm fairly lost by the init. There are so many instance variables. You seem
> to have some groupings, but could you add some comments to help us understand
> what those groupings are?
> * init seems to have some default width and heights. The values seem like
> they are pixels and not percentages. Why is that? Could they be percentages
> instead?
> * self.motion_duration in init: what is the unit of time for it? 100 is just
> a magic number right now.
> * _item_width_abs for the default value of item_width=200 will be enormous.
> Way larger than the stage.
> * event rect color of Orange. I like it. :D
> * When the branch lands, please file a bug about your XXX in the init. I'm
> okay with that XXX comment landing.
> * on_bottom & on_right: you could move the end_row calculation into the if
> statement of _is_vertical to slightly improve performance of horizontal menus.
> (Remember, these comments are *everything* I could think of :D).
> * _set_selected_index: "relatively" should be "relative"
> * _set_selected_index comment needs cleanup (start with "#start select...").
> * What is the cursor in _set_selected_index comments? Is that the mouse
> cursor? Is it some other cursor that is tracked by the GridMenu? I'm having a
> hard time figuring it out. Maybe there could be a comment by cursor property
> definition.
> * I got to the direction methods (up, down, left, right) and said to myself
> "WTF!? Why isn't there code to move something?" I then realized that the
> _set_selected_index method triggers the actual movement. I think it would be
> wise to mention this in the docstring.
> * Xc and Yc seems like the coordinates of "index" to me (line 234) and not
> like "coordinates of the cursor relatively to the moving group". Am I missing
> something?
> * Could you add some comments to the series of if statements in
> _set_selected_index? Mapping variable names in my head (because xm, Xc, and xc
> aren't very descriptive) and determining boolean logic at the same time is
> difficult to do. I'm sure the rules make sense, but it's hard as a reader to
> immediately understand what the code is trying to accomplish in those lines.

[Samuel Buffet (samuel-buffet)]

incremental diff:

=== modified file 'entertainerlib/frontend/gui/widgets/base.py'
--- entertainerlib/frontend/gui/widgets/base.py 2009-05-24 14:28:19 +0000
+++ entertainerlib/frontend/gui/widgets/base.py 2009-07-15 21:22:17 +0000
@@ -24,7 +24,7 @@
     def y_for_x(self, percentage):
         """
         Returns the percentage of stage height giving the same number of pixels
- than `percentage` applied to the stage width.
+ equivalent to `percentage` applied to the stage width.
         """
         stage_ratio = float(self.config.get_stage_width())
         stage_ratio /= self.config.get_stage_height()

=== modified file 'entertainerlib/frontend/gui/widgets/grid_menu.py'
--- entertainerlib/frontend/gui/widgets/grid_menu.py 2009-05-28 19:12:05 +0000
+++ entertainerlib/frontend/gui/widgets/grid_menu.py 2009-07-15 21:22:17 +0000
@@ -1,16 +1,20 @@
 # Copyright (c) 2009 Entertainer Developers - See COPYING - GPLv2
 '''GridMenu contains a grid of MenuItem based widgets.'''

+import math
+
 import clutter
 import gobject
-import math

 from entertainerlib.frontend.gui.widgets.base import Base
 from entertainerlib.frontend.gui.widgets.motion_buffer import MotionBuffer

 class GridMenu(Base, clutter.Group):
     """
- GridMenu widget
+ GridMenu widget.
+
+ A core widget to handle MenuItem in a grid with a cursor.
+ This widget provides all the necessary logic to move items and the cursor.
     """
     __gsignals__ = {
         'activated' : ( gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, () ),
@@ -22,17 +26,18 @@
     MODE_SELECT = 1
     MODE_SEEK = 2

- def __init__(self, x=0, y=0, item_width=200, item_height=100):
+ def __init__(self, x=0, y=0, item_width=0.2, item_height=0.1):
         Base.__init__(self)
         clutter.Group.__init__(self)

- self.motion_duration = 100
- self.cursor_below = True
+ self.motion_duration = 100 # Default duration for animations.
+ self.cursor_below = True # Is the cursor below items?
         self._active = None
         self._is_vertical = True
- self.items_anchor_west = False
+ self.items_anchor_west = False # Special anchor mode for items.
         self.items = []

+ # Items dimensions variable: relative, absolute, center
         self._item_width = item_width
         self._item_height = item_height
         self._item_width_abs = self.get_abs_x(item_width)
@@ -40,23 +45,30 @@
         self._dx = int(self._item_width_abs / 2)
         self._dy = int(self._item_height_abs / 2)

+ # Default cursor's index.
         self._selected_index = 0
+
+ # Grid dimensions: real, visible
         self.items_per_row = 10
         self.items_per_col = 10
         self._visible_rows = 3
         self._visible_cols = 5

+ # The moving_group is a Clutter group containing all the items.
         self._moving_group_x = 0
         self._moving_group_y = 0
         self._moving_group = clutter.Group()
         self.add(self._moving_group)

+ # The moving_group is translated using a `BehaviourPath`.
         self._moving_group_timeline = clutter.Timeline(fps=200, duration=200)
         moving_...

[lp:~samuel-buffet/entertainer/reactive_menus]

509. By Samuel Buffet on 2009-07-15

Fixed a stupid regression.

[Matt Layman (mblayman)]

Review comment of the day:

image_menu.py:
 * I need to raise a point that will be contentious. I have to disagree with putting specific logic for videos/albums/clips embedded into a widget. IMO, the only async_add method should be async_add, not async_add_*. I know that this puts more burden on the screen objects, but I strongly believe that classes should serve only the purpose that they were intended for. In the case of the ImageMenu, I think it should only know how to display images that are provided to it. I think that the easy solution would be to move the asyn specific method back into the screen/tab that it came from.

I have a decent idea for how to keep the async_add functionality in ImageMenu, but keep the specific logic out. We can talk about it on IRC. It involves concrete factories as input parameters to async_add (if that makes any sense to you right now, then our conversation on IRC will be a short one).

[Samuel Buffet (samuel-buffet)]

Hi Matt,

> image_menu.py:
> * I need to raise a point that will be contentious. I have to disagree with
> putting specific logic for videos/albums/clips embedded into a widget. IMO,
> the only async_add method should be async_add, not async_add_*. I know that
> this puts more burden on the screen objects, but I strongly believe that
> classes should serve only the purpose that they were intended for. In the case
> of the ImageMenu, I think it should only know how to display images that are
> provided to it. I think that the easy solution would be to move the asyn
> specific method back into the screen/tab that it came from.

I have to agree with you, this was also my concern doing that. I was pretty happy to be able to add items asynchronously but definitely not with adding specific methods for specific items.

Now questions are, what to do instead, where (I'd prefer to do that in another branch if it's okay for you).

> I have a decent idea for how to keep the async_add functionality in ImageMenu,
> but keep the specific logic out. We can talk about it on IRC. It involves
> concrete factories as input parameters to async_add (if that makes any sense
> to you right now, then our conversation on IRC will be a short one).

Okay, let's talk of tha on IRC.

Samuel-

(missing tests for text and image menus are on the road.)

[lp:~samuel-buffet/entertainer/reactive_menus]

510. By Samuel Buffet on 2009-07-16

Fixes after first set of comments from Matt (part 2).

[Samuel Buffet (samuel-buffet)]

Matt,

I've pushed my second part of fixes.

> base.py:
> * y_for_x docstring isn't very clear (gramatically). The word "than" just
> doesn't work well in that context. I think you could replace "than" with
> "equivalent to".
> * Could you add a test for this method?

Fixed.

> grid_menu.py:
> * Is this widget testable? I've got to believe that somewhere in those 561
> lines is something that can be tested. :)

Yeah of course. Added. (other menus will come).

> * import order. math is a Python standard library module.
> * Please add something meaningful to the class docstring.

Fixed.

> * I'm fairly lost by the init. There are so many instance variables. You seem
> to have some groupings, but could you add some comments to help us understand
> what those groupings are?

I've added more comments. It should be better.

> * init seems to have some default width and heights. The values seem like
> they are pixels and not percentages. Why is that? Could they be percentages
> instead?

Yeah it was a mistake. That's fixed.

> * self.motion_duration in init: what is the unit of time for it? 100 is just
> a magic number right now.

Here it's a regular timeline duration in ms.

> * _item_width_abs for the default value of item_width=200 will be enormous.
> Way larger than the stage.
> * event rect color of Orange. I like it. :D

:D Saddly it was a debug fossil so I've removed that line.

> * When the branch lands, please file a bug about your XXX in the init. I'm
> okay with that XXX comment landing.

New that. That was my intention.

> * on_bottom & on_right: you could move the end_row calculation into the if
> statement of _is_vertical to slightly improve performance of horizontal menus.
> (Remember, these comments are *everything* I could think of :D).

Changed.

> * _set_selected_index: "relatively" should be "relative"

Also fixed.

> * _set_selected_index comment needs cleanup (start with "#start select...").

Fixed.

> * What is the cursor in _set_selected_index comments? Is that the mouse
> cursor? Is it some other cursor that is tracked by the GridMenu? I'm having a
> hard time figuring it out. Maybe there could be a comment by cursor property
> definition.

I've change the docstring to specify that we're dealing with the menu's cursor.
Cursor's coordinates are linked to the cursor's index (index in the item list) for a specific menu geometry. So if we have x, y = 0, 0 (which is equivalent to index = 0) the the cursor is on top/left "Cell" of the menu.

> * I got to the direction methods (up, down, left, right) and said to myself
> "WTF!? Why isn't there code to move something?" I then realized that the
> _set_selected_index method triggers the actual movement. I think it would be
> wise to mention this in the docstring.

Done.

> * Xc and Yc seems like the coordinates of "index" to me (line 234) and not
> like "coordinates of the cursor relatively to the moving group". Am I missing
> something?
> * Could you add some comments to the series of if statements in
> _set_selected_index? Mapping variable names in my head (because xm, Xc, and xc
> aren't very descriptive) and determining boolean logic at the same tim...

[Matt Layman (mblayman)]

Samuel,

You don't need to bother with adding new diffs for me. I either use LP loggerhead to look at the commit or I just look at the branch when I'm merging the code and testing it.

I'll hopefully get some more time to look at it when I get home from work today (more than 8 hours from now).

[Matt Layman (mblayman)]

Round 2
=======

grid_menu.py:
 * I counted 32 instance variables in use declared by the init. I know that GridMenu does a ton of stuff and I have no expectations for major refactorings of this branch, but maybe there are some class abstractions that can be extracted out somewhere else (because there's a lot of stuff to think about in this class). Maybe you have some thoughts on this subject. What do you think? Is there future common classes that could be pulled out from GridMenu?
 * Line 80 comment "usefull" should be "useful" (English is silly, I know. :)
 * _set_selected_index comment needs cleanup (start with "#start select..."). Still not fixed.
 * I think I may have push you too far with the comments for the series of if statements in _set_selected_index. Rather than a textual description of what the logic is saying for each if statement, I think what I meant to ask for is "What are the if statements doing as a whole?" Once I have an idea of what the if statements are supposed to accomplish, I should have a good idea of how to read the code. In all of these if statements, it looks like you're adjusting xm, ym, xc, or yc. Maybe these if statements could be extracted into a method to help explain what the section is supposed to do. As a good rule of thumb that I use personally, if you have to write more lines of comments than code, something probably needs to be changed.
 * I caught one more items_anchor_west still in the init.

image_menu.py:
 * You've already seen my comment about the specific types of async_add. I'll let it land, but please add an XXX comment so that we remember to come back to it.
 * async_add items are a pack of information, but there is no comment explaining what an item is (texture and data). I think that this could use a clarifying comment.

image_menu_item.py:
 * Glad you condensed this class into the image menu file.

label.py:
 * Can you add a color property test?

menu.py:
 * One more unneeded widget down!

menu_item.py:
 * No comment.

scroll_menu.py:
 * No comment.

selector.py:
 * No comment.

special_behaviours.py:
 * No comment.

tab_group.py:
 * No comment.

text_menu.py:
 * "self.extra_label.position = ( \" Is the continuation character helpful here?
 * ArtistsMenuItem. I don't think this needs to be specific to artists (even though it may be the only place it is used right now). How about AnimatingMenuItem instead?
 * self.timeline is only used by ArtistsMenuItem, not the parent TextMenuItem. Could you please move it to the subclass?
 * add_item also calls a mysterious pack item. A comment might help.
 * TextMenu also has the context specific async_add_artists method. I'll let this land too, but please add an XXX comment here too.

text_menu_item.py:
 * 1 less file, nice.

music.py:
 * I did this by mistake too in a different branch that I was working on (and should hopefully finish some day), but get_length_string should not zfill the first value. It should just zfill the second (otherwise it means there is a leading zero on the minute when we don't need there to be one). The places that in-lined this code only used one zfill as expected.

mock.py:
 * No comment.

test_base.py:
 * No comment.

test_gr...

review: Approve

[lp:~samuel-buffet/entertainer/reactive_menus]

511. By Samuel Buffet on 2009-07-16

Fixed another docstring in the GridMenu.

512. By Samuel Buffet on 2009-07-19

Fixes after Matt's comment round 2.

[Samuel Buffet (samuel-buffet)]

Evening Matt,

> grid_menu.py:
> * I counted 32 instance variables in use declared by the init. I know that
> GridMenu does a ton of stuff and I have no expectations for major refactorings
> of this branch, but maybe there are some class abstractions that can be
> extracted out somewhere else (because there's a lot of stuff to think about in
> this class). Maybe you have some thoughts on this subject. What do you think?
> Is there future common classes that could be pulled out from GridMenu?

Short answer Yes.
Indeed this is something I have in mind since a long time. I'm deeply convinced that there's a lot of line of code we can save and a much better readability we can reach doing a widget API refactoring which would take better usage of inheritance.
>>> http://wiki.entertainer-project.com/wiki/BluePrints/widget-API-changes
This is still in my mind (a few updates needed though).

> * Line 80 comment "usefull" should be "useful" (English is silly, I know. :)

Fixed.

> * _set_selected_index comment needs cleanup (start with "#start select...").
> Still not fixed.

Was fixed in a standing alone commit.

> * I think I may have push you too far with the comments for the series of if
> statements in _set_selected_index. Rather than a textual description of what
> the logic is saying for each if statement, I think what I meant to ask for is
> "What are the if statements doing as a whole?" Once I have an idea of what the
> if statements are supposed to accomplish, I should have a good idea of how to
> read the code. In all of these if statements, it looks like you're adjusting
> xm, ym, xc, or yc. Maybe these if statements could be extracted into a method
> to help explain what the section is supposed to do. As a good rule of thumb
> that I use personally, if you have to write more lines of comments than code,
> something probably needs to be changed.

Agreed, so what I propose to you is that I'll create a wiki page with drawings and text to better explain that. And when it will be totally clear for you then maybe you'll be able to help be to find better words. I'll try to do that this week.

> * I caught one more items_anchor_west still in the init.

Yep, fixed now.

> image_menu.py:
> * You've already seen my comment about the specific types of async_add. I'll
> let it land, but please add an XXX comment so that we remember to come back to
> it.

Done.

> * async_add items are a pack of information, but there is no comment
> explaining what an item is (texture and data). I think that this could use a
> clarifying comment.

Done.

> label.py:
> * Can you add a color property test?

Indeed that was missing. I've added a test for this property.

> text_menu.py:
> * "self.extra_label.position = ( \" Is the continuation character helpful
> here?

Absolutely not. That's fixed.

> * ArtistsMenuItem. I don't think this needs to be specific to artists (even
> though it may be the only place it is used right now). How about
> AnimatingMenuItem instead?

Yes you're right. I've renamed this Class.

> * self.timeline is only used by ArtistsMenuItem, not the parent TextMenuItem.
> Could you please move it to the subclass?

Agreed with ...

[Samuel Buffet (samuel-buffet)]

incremental diff:

=== modified file 'entertainerlib/frontend/gui/screens/disc.py'
--- entertainerlib/frontend/gui/screens/disc.py 2009-07-12 07:57:05 +0000
+++ entertainerlib/frontend/gui/screens/disc.py 2009-07-19 19:27:31 +0000
@@ -71,7 +71,13 @@
             self.track_menu = self._create_track_menu(tracks)
             self.add(self.track_menu)
             self._create_album_cover_texture(artist, title)
- self._create_list_indicator()
+
+ self.li = ListIndicator(0.75, 0.8, 0.2, 0.045,
+ ListIndicator.VERTICAL)
+ tracks = \
+ self.music_library.get_compact_disc_information().get_tracks()
+ self.li.set_maximum(len(tracks))
+ self.add(self.li)

             art_file = os.path.join(self.config.ALBUM_ART_DIR,
                 artist + " - " + title + ".jpg")
@@ -185,13 +191,6 @@

         return menu

- def _create_list_indicator(self):
- '''Create list indicator for track list.'''
- self.li = ListIndicator(0.75, 0.8, 0.2, 0.045, ListIndicator.VERTICAL)
- tracks = self.music_library.get_compact_disc_information().get_tracks()
- self.li.set_maximum(len(tracks))
- self.add(self.li)
-
     def _handle_up(self):
         '''Handle UserEvent.NAVIGATE_UP.'''
         self.track_menu.up()

=== modified file 'entertainerlib/frontend/gui/screens/main.py'
--- entertainerlib/frontend/gui/screens/main.py 2009-06-29 05:25:01 +0000
+++ entertainerlib/frontend/gui/screens/main.py 2009-07-19 19:27:31 +0000
@@ -47,6 +47,8 @@
         self.menu = self._create_main_menu()
         self.add(self.menu)

+ self._update_preview_area()
+
         self.add(ClockLabel(0.13, "screentitle", 0, 0.87))

         self.menu.connect('selected', self._handle_select)
@@ -60,11 +62,11 @@
         return Screen.NORMAL

     def get_name(self):
- """Return screen name (human readble)"""
+ """Return screen name (human readble)."""
         return "Main"

     def _create_main_menu(self):
- """Create main menu of the home screen"""
+ """Create main menu of the home screen."""
         menu = ScrollMenu(10, 60, 0.045, "menuitem_active")
         menu.set_name("mainmenu")

=== modified file 'entertainerlib/frontend/gui/screens/movie.py'
--- entertainerlib/frontend/gui/screens/movie.py 2009-07-12 07:57:05 +0000
+++ entertainerlib/frontend/gui/screens/movie.py 2009-07-19 19:27:31 +0000
@@ -155,7 +155,7 @@
         """
         Create menu of the screen. This displayed the left side of the screen.
         """
- self.menu = TextMenu(0.07, 0.1, 0.2196, 0.0781)
+ self.menu = TextMenu(0.07, 0.1, 0.2196, 0.0781)
         self.menu.add_item(_("Watch"), None, "watch")
         self.menu.active = True

=== modified file 'entertainerlib/frontend/gui/screens/photo_albums.py'
--- entertainerlib/frontend/gui/screens/photo_albums.py 2009-07-12 07:57:05 +0000
+++ entertainerlib/frontend/gui/screens/photo_albums.py 2009-07-19 19:27:31 +0000
@@ -240,7 +240,10 @@
     def _create_list_indicator(self):
         '''Create list indicator for albums list.'''
         self.li = ListIndicator(0.77, 0.9, 0.2, 0.045, ListIndic...

[lp:~samuel-buffet/entertainer/reactive_menus]

513. By Samuel Buffet on 2009-07-19

Removed a redundant "tracks" variable in disc.py.

=== modified file 'entertainerlib/frontend/gui/screens/album.py'
--- entertainerlib/frontend/gui/screens/album.py	2009-05-10 07:43:27 +0000
+++ entertainerlib/frontend/gui/screens/album.py	2009-07-14 10:46:47 +0000
@@ -11,7 +11,6 @@
 from entertainerlib.frontend.gui.widgets.label import Label
 from entertainerlib.frontend.gui.widgets.list_indicator import ListIndicator
 from entertainerlib.frontend.gui.widgets.text_menu import TextMenu
-from entertainerlib.frontend.gui.widgets.text_menu_item import TextMenuItem
 
 class Album(Screen):
     '''Screen that allows user to browse and play tracks of the music album.'''
@@ -28,21 +27,25 @@
         self.track_menu = None
 
         # Create and initialize screen items
-        self._create_track_menu()
+        self.track_menu = self._create_track_menu()
+        self.add(self.track_menu)
         self._create_album_cover_texture()
         self._create_album_info()
 
         self.screen_title = Label(0.13, "screentitle", 0, 0.87, "")
         self.screen_title.set_ellipsize(pango.ELLIPSIZE_END)
         self.screen_title.width = 0.8
-        self.show_artist()
         self.add(self.screen_title)
 
         #List indicator
-        self.li = ListIndicator(0.74, 0.8, 0.2, 0.045, ListIndicator.VERTICAL)
-        self.li.set_maximum(self.track_menu.get_number_of_items())
+        self.li = ListIndicator(0.74, 0.85, 0.2, 0.045, ListIndicator.VERTICAL)
+        self.li.set_maximum(len(self.album.get_tracks()))
         self.add(self.li)
 
+        self.track_menu.active = True
+        self.track_menu.connect('selected', self._on_menu_selected)
+        self.track_menu.connect('moved', self._display_selected_track)
+
     def _create_album_cover_texture(self):
         """
         Create a texture that is displayed next to track list. This texture
@@ -83,31 +86,14 @@
         """
         Create track menu. This menu contains list of all tracks on album.
         """
-        self.track_menu = TextMenu(self.theme, self.config.show_effects())
-        self.track_menu.set_row_count(1)
-        self.track_menu.set_visible_column_count(7)
-        self.track_menu.set_item_size(self.get_abs_x(0.4393),
-            self.get_abs_y(0.0781))
-        self.track_menu.set_position(self.get_abs_x(0.4978),
-            self.get_abs_y(0.2344))
+        menu = TextMenu(0.4978, 0.2344, 0.4393, 0.0781)
 
-        # Create menu items based on MusicLibrary
         tracks = self.album.get_tracks()
-        for track in tracks:
-            track_length = str(track.get_length() / 60) + ":" + \
-                str(track.get_length() % 60).zfill(2)
-            item = TextMenuItem(0.4393, 0.0781, track.get_title(), track_length)
-            item.set_userdata(track)
-            self.track_menu.add_actor(item)
-
-        self.track_menu.set_active(True)
-        self.add(self.track_menu)
-
-    def show_artist(self):
-        # Screen Title (Displayed at the bottom left corner)
-        track = self.track_menu.get_current_menuitem().get_userdata()
-        self.screen_title.set_text(track.get_artist())
-        self.screen_title.show()
+        tracks_list = [[track.get_title(), track.get_length_string(), track] \
+            for track in tracks]
+        menu.async_add(tracks_list)
+
+        return menu
 
     def is_interested_in_play_action(self):
         """
@@ -121,27 +107,32 @@
         Override function from Screen class. See Screen class for
         better documentation.
         """
-        track = self.track_menu.get_current_menuitem().get_userdata()
+        track = self.track_menu.selected_userdata
         self.media_player.set_media(track)
         self.media_player.play()
 
-    def _move_menu(self, menu_direction):
-        '''Move the text menu in the provided direction.'''
-        self.track_menu.move(menu_direction)
-        self.li.set_current(self.track_menu.get_current_position() + 1)
-        self.show_artist()
-
     def _handle_up(self):
         '''Handle UserEvent.NAVIGATE_UP.'''
-        self._move_menu(TextMenu.UP)
+        self.track_menu.up()
 
     def _handle_down(self):
         '''Handle UserEvent.NAVIGATE_DOWN.'''
-        self._move_menu(TextMenu.DOWN)
+        self.track_menu.down()
 
-    def _handle_select(self):
+    def _handle_select(self, event=None):
         '''Handle UserEvent.NAVIGATE_SELECT.'''
-        track = self.track_menu.get_current_menuitem().get_userdata()
+        track = self.track_menu.selected_userdata
         kwargs = { 'track' : track }
         self.callback("audio_play", kwargs)
 
+    def _on_menu_selected(self, actor=None):
+        '''Handle a *select command* if an item was selected.'''
+        self._handle_select()
+
+    def _display_selected_track(self, actor=None):
+        '''Update of the list indicator and the screen's title'''
+        self.li.set_current(self.track_menu.selected_index + 1)
+        track = self.track_menu.selected_userdata
+        self.screen_title.set_text(track.get_artist())
+        self.screen_title.show()
+
 
=== modified file 'entertainerlib/frontend/gui/screens/disc.py'
--- entertainerlib/frontend/gui/screens/disc.py	2009-05-10 07:43:27 +0000
+++ entertainerlib/frontend/gui/screens/disc.py	2009-07-12 07:57:05 +0000
@@ -18,7 +18,6 @@
     LoadingAnimation)
 from entertainerlib.frontend.gui.widgets.texture import Texture
 from entertainerlib.frontend.gui.widgets.text_menu import TextMenu
-from entertainerlib.frontend.gui.widgets.text_menu_item import TextMenuItem
 from entertainerlib.frontend.medialibrary.playlist import Playlist
 from entertainerlib.utils.albumart_downloader import AlbumArtDownloader
 
@@ -69,7 +68,8 @@
 
             self.playlist = Playlist(tracks)
             self._create_album_info(title, artist, tracks, disc.get_length())
-            self._create_track_menu(tracks)
+            self.track_menu = self._create_track_menu(tracks)
+            self.add(self.track_menu)
             self._create_album_cover_texture(artist, title)
             self._create_list_indicator()
 
@@ -172,45 +172,37 @@
         Create a track menu. This menu contains list of all tracks on album.
         @param tracks: List of CompactDisc objects
         """
-        self.track_menu = TextMenu(self.theme, self.config.show_effects())
-        self.track_menu.set_row_count(1)
-        self.track_menu.set_visible_column_count(7)
-        self.track_menu.set_item_size(self.get_abs_x(0.4393),
-            self.get_abs_y(0.0781))
-        self.track_menu.set_position(self.get_abs_x(0.4978),
-            self.get_abs_y(0.2344))
-
-        for index, track in enumerate(tracks):
-            length = str(track.get_length() / 60) + ":" + \
-                str(track.get_length() % 60).zfill(2)
-            item = TextMenuItem(0.4393, 0.0781, track.get_title(), length)
-            item.set_userdata(index)
-            self.track_menu.add_actor(item)
-        self.track_menu.set_active(True)
-        self.add(self.track_menu)
+        menu = TextMenu(0.4978, 0.2344, 0.4393, 0.0781)
+        menu.visible_rows = 7
+
+        tracks_list = [[track.get_title(), track.get_length_string(), index] \
+            for index, track in enumerate(tracks)]
+        menu.async_add(tracks_list)
+
+        menu.active = True
+        menu.connect('selected', self._handle_select)
+        menu.connect('moved', self._display_selected_track)
+
+        return menu
 
     def _create_list_indicator(self):
         '''Create list indicator for track list.'''
         self.li = ListIndicator(0.75, 0.8, 0.2, 0.045, ListIndicator.VERTICAL)
-        self.li.set_maximum(self.track_menu.get_number_of_items())
+        tracks = self.music_library.get_compact_disc_information().get_tracks()
+        self.li.set_maximum(len(tracks))
         self.add(self.li)
 
-    def _move_menu(self, menu_direction):
-        '''Move the text menu in the provided direction.'''
-        self.track_menu.move(menu_direction)
-        self.li.set_current(self.track_menu.get_current_position() + 1)
-
     def _handle_up(self):
         '''Handle UserEvent.NAVIGATE_UP.'''
-        self._move_menu(TextMenu.UP)
+        self.track_menu.up()
 
     def _handle_down(self):
         '''Handle UserEvent.NAVIGATE_DOWN.'''
-        self._move_menu(TextMenu.DOWN)
+        self.track_menu.down()
 
-    def _handle_select(self):
+    def _handle_select(self, event=None):
         '''Handle UserEvent.NAVIGATE_SELECT.'''
-        track_index = self.track_menu.get_current_menuitem().get_userdata()
+        track_index = self.track_menu.selected_userdata
         self.playlist.set_current(track_index)
         self.media_player.set_playlist(self.playlist)
         self.media_player.play()
@@ -220,3 +212,7 @@
         if self.has_disc:
             Screen.handle_user_event(self, event)
 
+    def _display_selected_track(self, event=None):
+        '''Update of the list indicator.'''
+        self.li.set_current(self.track_menu.selected_index + 1)
+
 
=== modified file 'entertainerlib/frontend/gui/screens/feed.py'
--- entertainerlib/frontend/gui/screens/feed.py	2009-06-25 19:06:28 +0000
+++ entertainerlib/frontend/gui/screens/feed.py	2009-07-12 07:57:05 +0000
@@ -8,7 +8,6 @@
 from entertainerlib.frontend.gui.widgets.list_indicator import ListIndicator
 from entertainerlib.frontend.gui.widgets.texture import Texture
 from entertainerlib.frontend.gui.widgets.text_menu import TextMenu
-from entertainerlib.frontend.gui.widgets.text_menu_item import TextMenuItem
 from entertainerlib.utils.feed_utils import FeedEntryParser
 
 class Feed(Screen):
@@ -21,7 +20,8 @@
         self.feed = feed
         self.menu = None
 
-        self._create_entry_menu()
+        self.menu = self._create_entry_menu()
+        self.add(self.menu)
 
         # Screen Title (Displayed at the bottom left corner)
         screen_title = Label(0.13, "screentitle", 0, 0.87, _("Feed"))
@@ -56,44 +56,47 @@
 
         #List indicator
         self.li = ListIndicator(0.57, 0.9, 0.2, 0.045, ListIndicator.VERTICAL)
-        self.li.set_maximum(self.menu.get_number_of_items())
+        self.li.set_maximum(len(self.feed.entries))
         self.add(self.li)
 
+        self._display_selected_feed()
+
+        self.menu.connect('selected', self._on_menu_selected)
+        self.menu.connect('moved', self._display_selected_feed)
+
     def _create_entry_menu(self):
-        """
-        Create Entries-menu. This menu contains list of entries.
-        """
-        self.menu = TextMenu(self.theme, self.config.show_effects())
-        self.menu.set_row_count(1)
-        self.menu.set_item_size(self.get_abs_x(0.5124), self.get_abs_y(0.0781))
-        self.menu.set_position(self.get_abs_x(0.2438), self.get_abs_y(0.2604))
-
-        # Create menu items based on FeedLibrary
-        for entry in self.feed.entries:
-            item = TextMenuItem(0.5124, 0.0781,
-                FeedEntryParser().strip_tags(entry.title))
-            item.set_userdata(entry)
-            self.menu.add_actor(item)
-
-        self.menu.set_active(True)
-        self.add(self.menu)
-
-    def _move_menu(self, menu_direction):
-        '''Move the text menu in the given direction.'''
-        self.menu.move(menu_direction)
-        self.li.set_current(self.menu.get_current_position() + 1)
+        """Create Entries-menu. This menu contains list of entries."""
+        menu = TextMenu(0.2438, 0.2604, 0.5124, 0.0781)
+
+        parser = FeedEntryParser()
+        feeds = self.feed.entries
+        feeds_list = [[parser.strip_tags(feed.title), None, feed] \
+            for feed in feeds]
+        menu.async_add(feeds_list)
+
+        menu.active = True
+
+        return menu
 
     def _handle_up(self):
         '''Handle UserEvent.NAVIGATE_UP.'''
-        self._move_menu(TextMenu.UP)
+        self.menu.up()
 
     def _handle_down(self):
         '''Handle UserEvent.NAVIGATE_DOWN.'''
-        self._move_menu(TextMenu.DOWN)
+        self.menu.down()
 
-    def _handle_select(self):
+    def _handle_select(self, event=None):
         '''Handle UserEvent.NAVIGATE_SELECT.'''
-        entry = self.menu.get_current_menuitem().get_userdata()
+        entry = self.menu.selected_userdata
         kwargs = { 'feed' : self.feed, 'entry' : entry }
         self.callback("entry", kwargs)
 
+    def _on_menu_selected(self, event=None):
+        '''Handle a *select command* if an item was selected.'''
+        self._handle_select()
+
+    def _display_selected_feed(self, event=None):
+        '''Update of the list indicator'''
+        self.li.set_current(self.menu.selected_index + 1)
+
 
=== modified file 'entertainerlib/frontend/gui/screens/main.py'
--- entertainerlib/frontend/gui/screens/main.py	2009-06-28 20:12:13 +0000
+++ entertainerlib/frontend/gui/screens/main.py	2009-06-29 05:25:01 +0000
@@ -9,7 +9,6 @@
 from entertainerlib.frontend.gui.widgets.scroll_menu import ScrollMenu
 from entertainerlib.frontend.gui.widgets.texture import Texture
 from entertainerlib.frontend.gui.widgets.text_menu import TextMenu
-from entertainerlib.frontend.gui.widgets.text_menu_item import TextMenuItem
 from entertainerlib.utils.cd_utils import eject_cd
 from entertainerlib.utils.feed_utils import FeedEntryParser
 
@@ -47,13 +46,15 @@
 
         self.menu = self._create_main_menu()
         self.add(self.menu)
-        self.menu.connect('selected', self._on_menu_selected)
+
+        self.add(ClockLabel(0.13, "screentitle", 0, 0.87))
+
+        self.menu.connect('selected', self._handle_select)
         self.menu.connect('moved', self._on_menu_moved)
-        self.menu.connect('activated', self._main_menu_activation)
+        self.menu.connect('activated', self._on_menu_activated)
+
         self.menu.active = True
 
-        self.add(ClockLabel(0.13, "screentitle", 0, 0.87))
-
     def get_type(self):
         """Return screen type."""
         return Screen.NORMAL
@@ -96,24 +97,18 @@
         '''Create the RSS preview menu that will show feed highlights. An
         uninitialized menu will be returned to prevent move errors if there
         is nothing in the feed library.'''
-        menu = TextMenu(self.theme, self.config.show_effects())
+        menu = TextMenu(0.035, 0.12, 0.549, 0.078)
 
         if self.feed_library.is_empty() is False:
-            menu.set_row_count(1)
-            menu.set_position(self.get_abs_x(0.035), self.get_abs_y(0.12))
-            menu.set_item_size(self.get_abs_x(0.549), self.get_abs_y(0.078))
-
-            # List of latest entries. pack = (Feed object, Entry object)
+            parser = FeedEntryParser()
             entries = self.feed_library.get_latest_entries(5)
-            for pack in entries:
-                text = pack[0].title + " - " + pack[1].title
-                item = TextMenuItem(0.549, 0.078,
-                    FeedEntryParser().strip_tags(text), pack[1].date)
-                kwargs = { 'feed' : pack[0], 'entry' : pack[1] }
-                item.set_userdata(kwargs)
-                menu.add_actor(item)
+            entries_list = [[parser.strip_tags(entry[0].title + " - " + \
+                entry[1].title), entry[1].date, \
+                { 'feed' : entry[0], 'entry' : entry[1] }] for entry in entries]
+            menu.async_add(entries_list)
 
-            menu.set_active(False)
+        menu.connect('selected', self._handle_select)
+        menu.connect('activated', self._on_rss_menu_activated)
 
         return menu
 
@@ -198,11 +193,15 @@
             # No headlines available in the library
             info = Label(0.05, "title", 0.1, 0.35, _("No headlines available"))
             preview.add(info)
+            self.rss_preview_menu = None
 
         return preview
 
     def _update_preview_area(self):
         '''Update the preview area to display the current menu item.'''
+        if self.rss_preview_menu:
+            rss_preview_menu_active = self.rss_preview_menu.active
+
         self.preview.remove_all()
         item = self.menu.get_selected()
 
@@ -214,10 +213,8 @@
             self.preview.add(self._create_playing_preview())
         elif item.get_name() == "rss":
             self.preview.add(self._create_rss_preview())
-            # When we update the rss preview menu, we must set it active if
-            # main menu is not.
-            if not self.menu.active:
-                self.rss_preview_menu.set_active(True)
+            if self.rss_preview_menu:
+                self.rss_preview_menu.active = rss_preview_menu_active
         else:
             update = False
 
@@ -225,7 +222,7 @@
         if update:
             fade_in = clutter.Timeline(20, 60)
             alpha_in = clutter.Alpha(fade_in, clutter.smoothstep_inc_func)
-            self.behaviour = clutter.BehaviourOpacity(0x00, 0xff, alpha_in)
+            self.behaviour = clutter.BehaviourOpacity(0, 255, alpha_in)
             self.behaviour.apply(self.preview)
             fade_in.start()
 
@@ -257,25 +254,25 @@
         if self.menu.active:
             self.menu.scroll_up()
         else:
-            self.rss_preview_menu.move(TextMenu.UP)
+            self.rss_preview_menu.up()
 
     def _handle_down(self):
         '''Handle UserEvent.NAVIGATE_DOWN.'''
         if self.menu.active:
             self.menu.scroll_down()
         else:
-            self.rss_preview_menu.move(TextMenu.DOWN)
+            self.rss_preview_menu.down()
 
     def _handle_left(self):
         '''Handle UserEvent.NAVIGATE_LEFT.'''
         if self._can_move_horizontally():
-            self._preview_activation()
+            self.rss_preview_menu.active = True
 
     def _handle_right(self):
         '''Handle UserEvent.NAVIGATE_RIGHT.'''
         self.menu.active = True
 
-    def _handle_select(self):
+    def _handle_select(self, event=None):
         '''Handle UserEvent.NAVIGATE_SELECT.'''
         item = self.menu.get_selected()
 
@@ -297,27 +294,20 @@
             if self.menu.active:
                 self.callback("rss")
             else:
-                menu_item = self.rss_preview_menu.get_current_menuitem()
-                kwargs = menu_item.get_userdata()
+                menu_item = self.rss_preview_menu.selected_item
+                kwargs = menu_item.userdata
                 self.callback("entry", kwargs)
 
-    def _on_menu_moved(self, actor):
+    def _on_menu_moved(self, event):
         '''Update preview area when selected item changed on the menu.'''
         self._update_preview_area()
 
-    def _on_menu_selected(self, actor):
-        '''Handle a *select command* if an item was selected.'''
-        self._handle_select()
-
-    def _main_menu_activation(self, actor=None):
+    def _on_menu_activated(self, event=None):
         '''Handle the main menu activation.'''
-        self.menu.active = True
-        if self.rss_preview_menu:
-            self.rss_preview_menu.set_active(False)
+        if self.rss_preview_menu is not None:
+            self.rss_preview_menu.active = False
 
-    def _preview_activation(self, actor=None):
-        '''Handle the preview activation.'''
+    def _on_rss_menu_activated(self, event=None):
+        '''Handle the rss menu activation.'''
         self.menu.active = False
-        if self.rss_preview_menu:
-            self.rss_preview_menu.set_active(True)
 
 
=== modified file 'entertainerlib/frontend/gui/screens/movie.py'
--- entertainerlib/frontend/gui/screens/movie.py	2009-06-05 05:10:21 +0000
+++ entertainerlib/frontend/gui/screens/movie.py	2009-07-12 07:57:05 +0000
@@ -13,7 +13,6 @@
 from entertainerlib.frontend.gui.widgets.scroll_area import ScrollArea
 from entertainerlib.frontend.gui.widgets.texture import Texture
 from entertainerlib.frontend.gui.widgets.text_menu import TextMenu
-from entertainerlib.frontend.gui.widgets.text_menu_item import TextMenuItem
 
 class Movie(Screen):
     '''Screen contains information of one movie.'''
@@ -156,47 +155,40 @@
         """
         Create menu of the screen. This displayed the left side of the screen.
         """
-        self.menu = TextMenu(self.theme, self.config.show_effects())
-        self.menu.set_row_count(1)
-        #self.track_menu.set_visible_column_count(10)
-        self.menu.set_item_size(self.get_abs_x(0.2196), self.get_abs_y(0.0781))
-        self.menu.set_position(self.get_abs_x(0.07), self.get_abs_y(0.1))
-
-        item1 = TextMenuItem(0.2196, 0.0781, _("Watch"))
-        item1.set_userdata("watch")
-        self.menu.add_actor(item1)
-
-        self.menu.set_active(True)
+        self.menu = TextMenu(0.07, 0.1, 0.2196, 0.0781)   
+        self.menu.add_item(_("Watch"), None, "watch")
+        self.menu.active = True
+
         self.add(self.menu)
 
     def _handle_up(self):
         '''Handle UserEvent.NAVIGATE_UP.'''
-        if self.menu.is_active():
-            self.menu.move(self.menu.UP)
+        if self.menu.active:
+            self.menu.up()
         else:
             self.scroll_area.scroll_up()
 
     def _handle_down(self):
         '''Handle UserEvent.NAVIGATE_DOWN.'''
-        if self.menu.is_active():
-            self.menu.move(self.menu.DOWN)
+        if self.menu.active:
+            self.menu.down()
         else:
             self.scroll_area.scroll_down()
 
     def _handle_left(self):
         '''Handle UserEvent.NAVIGATE_LEFT.'''
-        self.menu.set_active(True)
+        self.menu.active = True
         self.scroll_area.set_active(False)
 
     def _handle_right(self):
         '''Handle UserEvent.NAVIGATE_RIGHT.'''
-        self.menu.set_active(False)
+        self.menu.active = False
         self.scroll_area.set_active(True)
 
-    def _handle_select(self):
+    def _handle_select(self, event=None):
         '''Handle UserEvent.NAVIGATE_SELECT.'''
-        if self.menu.is_active():
-            item = self.menu.get_current_menuitem().get_userdata()
+        if self.menu.active:
+            item = self.menu.selected_userdata
             if item == "watch":
                 self.media_player.set_media(self.movie)
                 self.media_player.play()
 
=== modified file 'entertainerlib/frontend/gui/screens/photo.py'
--- entertainerlib/frontend/gui/screens/photo.py	2009-05-10 06:24:43 +0000
+++ entertainerlib/frontend/gui/screens/photo.py	2009-05-21 16:12:09 +0000
@@ -182,7 +182,7 @@
         else:
             self.texture.move_by(-self.MOVE_SIZE, 0)
 
-    def _handle_select(self):
+    def _handle_select(self, event=None):
         '''Handle UserEvent.NAVIGATE_SELECT.'''
         # Zoom image. If we zoom then we stop sliding photos.
         self.stop_slideshow()
 
=== modified file 'entertainerlib/frontend/gui/screens/photo_albums.py'
--- entertainerlib/frontend/gui/screens/photo_albums.py	2009-05-10 07:43:27 +0000
+++ entertainerlib/frontend/gui/screens/photo_albums.py	2009-07-12 07:57:05 +0000
@@ -13,7 +13,6 @@
 from entertainerlib.frontend.gui.widgets.list_indicator import ListIndicator
 from entertainerlib.frontend.gui.widgets.texture import Texture
 from entertainerlib.frontend.gui.widgets.text_menu import TextMenu
-from entertainerlib.frontend.gui.widgets.text_menu_item import TextMenuItem
 
 class PhotoAlbums(Screen):
     '''Screen contains a list of photo albums and album previews.'''
@@ -46,10 +45,16 @@
             self.in_opacity = None
             self.out_opacity = None
             self.preview_textures = None
-            self._create_album_menu()
+            self.menu = self._create_album_menu()
+            self.add(self.menu)
             self.li = None
             self._create_list_indicator()
 
+            self._update_album_preview(self.menu.selected_userdata)
+
+            self.menu.connect('selected', self._handle_select)
+            self.menu.connect('moved', self._display_selected_album)
+
     def _create_no_photos_information(self):
         """
         Create textures and labels for information screen. This is displayed
@@ -80,28 +85,17 @@
         Create ImageAlbum-menu. This menu contains list of albums. It also
         displays number of photographs per album.
         """
-        self.menu = TextMenu(self.theme, self.config.show_effects())
-        self.menu.set_row_count(1)
-        self.menu.set_visible_column_count(7)
-        self.menu.set_item_size(self.get_abs_x(0.4393), self.get_abs_y(0.0781))
-        self.menu.set_position(self.get_abs_x(0.5271), self.get_abs_y(0.3385))
+        menu = TextMenu(0.5271, 0.3385, 0.4393, 0.0781)
+        menu.visible_rows = 7
 
-        # Create menu items based on ImageLibrary
         albums = self.image_library.get_albums()
-        for album in albums:
-            nro_of_photos = album.get_number_of_images()
-            if nro_of_photos == 0: # Skip empty albums
-                continue
-            else:
-                nro_of_photos = str(nro_of_photos)
-            item = TextMenuItem(0.4393, 0.0781, album.get_title(),
-                nro_of_photos)
-            item.set_userdata(album)
-            self.menu.add_actor(item)
-
-        self.add(self.menu)
-        self._update_album_preview(
-            self.menu.get_current_menuitem().get_userdata())
+        albums_list = [[album.get_title(), str(album.get_number_of_images()),
+            album] for album in albums if album.get_number_of_images() != 0]
+        menu.async_add(albums_list)
+
+        menu.active = True
+
+        return menu
 
     def _create_album_preview(self, album):
         """
@@ -246,30 +240,20 @@
     def _create_list_indicator(self):
         '''Create list indicator for albums list.'''
         self.li = ListIndicator(0.77, 0.9, 0.2, 0.045, ListIndicator.VERTICAL)
-        self.li.set_maximum(self.menu.get_number_of_items())
+        self.li.set_maximum(len(self.image_library.get_albums()))
         self.add(self.li)
 
-    def _move_menu(self, menu_direction):
-        '''Move the menu in the given direction.'''
-        self.menu.move(menu_direction)
-        self.li.set_current(self.menu.get_current_position() + 1)
-        # 500ms timeout before preview is updated (fast scrolling)
-        if self.timeout is not None:
-            gobject.source_remove(self.timeout)
-        self.timeout = gobject.timeout_add(500, self._update_album_preview,
-            self.menu.get_current_menuitem().get_userdata())
-
     def _handle_up(self):
         '''Handle UserEvent.NAVIGATE_UP.'''
-        self._move_menu(TextMenu.UP)
+        self.menu.up()
 
     def _handle_down(self):
         '''Handle UserEvent.NAVIGATE_DOWN.'''
-        self._move_menu(TextMenu.DOWN)
+        self.menu.down()
 
-    def _handle_select(self):
+    def _handle_select(self, event=None):
         '''Handle UserEvent.NAVIGATE_SELECT.'''
-        album = self.menu.get_current_menuitem().get_userdata()
+        album = self.menu.selected_userdata
         kwargs = { 'title' : album.get_title(), 'images' : album.get_images() }
         self.callback("photographs", kwargs)
 
@@ -280,3 +264,12 @@
         else:
             Screen.handle_user_event(self, event)
 
+    def _display_selected_album(self, event=None):
+        '''Update of the list indicator'''
+        self.li.set_current(self.menu.selected_index + 1)
+        # 500ms timeout before preview is updated (fast scrolling)
+        if self.timeout is not None:
+            gobject.source_remove(self.timeout)
+        self.timeout = gobject.timeout_add(500, self._update_album_preview,
+            self.menu.selected_userdata)
+
 
=== modified file 'entertainerlib/frontend/gui/screens/photographs.py'
--- entertainerlib/frontend/gui/screens/photographs.py	2009-05-10 07:43:27 +0000
+++ entertainerlib/frontend/gui/screens/photographs.py	2009-07-14 11:06:21 +0000
@@ -2,13 +2,11 @@
 '''Photographs - Screen contains a list/grid of photographs'''
 
 import pango
-import gobject
 
 from entertainerlib.frontend.gui.screens.screen import Screen
 from entertainerlib.frontend.gui.widgets.image_menu import ImageMenu
 from entertainerlib.frontend.gui.widgets.label import Label
 from entertainerlib.frontend.gui.widgets.list_indicator import ListIndicator
-from entertainerlib.frontend.gui.widgets.image_menu_item import ImageMenuItem
 from entertainerlib.frontend.gui.widgets.loading_animation import (
     LoadingAnimation)
 from entertainerlib.frontend.gui.widgets.texture import Texture
@@ -19,7 +17,6 @@
     def __init__(self, move_to_new_screen_callback, title, images):
         Screen.__init__(self, 'Photographs', move_to_new_screen_callback)
 
-        self.theme = self.config.theme
         self.images = images
 
         # Screen Title (Displayed at the bottom left corner)
@@ -46,54 +43,32 @@
         self._create_list_indicator()
 
         # Create photomenu
-        self.menu = ImageMenu(self.theme)
-        self.menu.set_visible_column_count(6)
-        self.menu.set_position(self.get_abs_x(0.0586), self.get_abs_y(0.1823))
-
-        if self.config.show_effects():
-            self.menu.set_animate(True)
-
+        self.menu = ImageMenu(0.03, 0.08, 0.12, self.y_for_x(0.12))
+        self.menu.items_per_col = 3
+        self.menu.visible_rows = 3
+        self.menu.visible_cols = 8
+        self.menu.active = True
         self.add(self.menu)
 
         photos = self.images
-        self.behaviour = None
-        gobject.timeout_add(25, self._create_photo_menuitems, photos)
-
-        self._update_image_info(0)
-
-    def _create_photo_menuitems(self, photographs):
-        """
-        This function is called as async callback. It is also recursive
-        function. This allows us load menu items in the background without
-        blocking the user interface.
-        """
-        # Check if we should stop recursive calls (menu is complete)
-        if len(photographs) > 0:
-            photo = photographs[0]
-            texture = Texture(photo.get_thumbnail_url())
-            item = ImageMenuItem(0.1464, 0.75, texture)
-            item.set_userdata(photo)
-            self.menu.add_actor(item)
-            # Recursive call, remove first artist from the list
-            gobject.timeout_add(15, self._create_photo_menuitems,
-                photographs[1:])
-            return False
-        else:
-            self.throbber.hide()
-            return False
-
-    def _update_image_info(self, number):
-        """
-        Update image information box.
-        @param number: Number of image. This is index of the self.__images
-        """
-        image = self.images[number]
+        photos_list = [[Texture(photo.get_thumbnail_url()), photo] \
+            for photo in photos]
+        self.menu.async_add(photos_list)
+
+        self.menu.connect("selected", self._handle_select)
+        self.menu.connect('moved', self._update_image_info)
+        self.menu.connect("filled", self._on_menu_filled)
+
+    def _update_image_info(self, event=None):
+        """Update image information box."""
+        image = self.images[self.menu.selected_index]
         name = image.get_title()
         desc = image.get_description()
         self.image_title.set_text(name)
         self.image_title.set_size(0.366, 0.04167)
         self.image_desc.set_text(desc)
         self.image_desc.set_size(0.366, 0.0911)
+        self.li.set_current(self.menu.selected_index + 1)
 
     def _create_list_indicator(self):
         '''Create list indicator for albums list.'''
@@ -102,31 +77,29 @@
         self.li.set_maximum(len(self.images))
         self.add(self.li)
 
-    def _move_menu(self, menu_direction):
-        '''Move the menu in the given direction.'''
-        self.menu.move(menu_direction)
-        self._update_image_info(self.menu.get_current_position())
-        self.li.set_current(self.menu.get_current_position() + 1)
-
     def _handle_up(self):
         '''Handle UserEvent.NAVIGATE_UP.'''
-        self._move_menu(ImageMenu.UP)
+        self.menu.up()
 
     def _handle_down(self):
         '''Handle UserEvent.NAVIGATE_DOWN.'''
-        self._move_menu(ImageMenu.DOWN)
+        self.menu.down()
 
     def _handle_left(self):
         '''Handle UserEvent.NAVIGATE_LEFT.'''
-        self._move_menu(ImageMenu.LEFT)
+        self.menu.left()
 
     def _handle_right(self):
         '''Handle UserEvent.NAVIGATE_RIGHT.'''
-        self._move_menu(ImageMenu.RIGHT)
+        self.menu.right()
 
-    def _handle_select(self):
+    def _handle_select(self, event=None):
         '''Handle UserEvent.NAVIGATE_SELECT.'''
-        index = self.menu.get_current_position()
+        index = self.menu.selected_index
         kwargs = {'current_photo_index' : index, 'images' : self.images}
         self.callback("photo", kwargs)
 
+    def _on_menu_filled(self, event=None):
+        '''Handles filled event.'''
+        self.throbber.hide()
+
 
=== modified file 'entertainerlib/frontend/gui/screens/question.py'
--- entertainerlib/frontend/gui/screens/question.py	2009-06-02 01:16:03 +0000
+++ entertainerlib/frontend/gui/screens/question.py	2009-06-27 09:03:33 +0000
@@ -4,7 +4,6 @@
 from entertainerlib.frontend.gui.screens.screen import Screen
 from entertainerlib.frontend.gui.widgets.label import Label
 from entertainerlib.frontend.gui.widgets.text_menu import TextMenu
-from entertainerlib.frontend.gui.widgets.text_menu_item import TextMenuItem
 
 class Question(Screen):
     '''Screen is displayed when the application needs to ask a close ended
@@ -32,18 +31,14 @@
 
     def display_answers(self):
         '''Display a menu with answers on the screen.'''
-        self.menu = TextMenu(self.config.theme, self.config.show_effects())
+        self.menu = TextMenu(0.095, 0.5, 0.4393, 0.0781)
         self.menu.set_name("questionmenu")
-        self.menu.set_row_count(1)
-        self.menu.set_visible_column_count(7)
-        self.menu.set_item_size(self.get_abs_x(0.4393), self.get_abs_y(0.0781))
-        self.menu.set_position(self.get_abs_x(0.095), self.get_abs_y(0.5))
+        self.menu.connect('selected', self._handle_select)
 
         for answer in self.answers:
-            item = TextMenuItem(0.4173, 0.0781, str(answer))
-            item.set_userdata(str(answer))
-            self.menu.add_actor(item)
+            self.menu.add_item(str(answer), None, str(answer))
 
+        self.menu.active = True
         self.add(self.menu)
 
     def question_callback(self, selected_answer):
@@ -63,20 +58,16 @@
         '''Go back to previous screen'''
         self.move_to_previous_screen_callback()
 
-    def _move_menu(self, menu_direction):
-        '''Move the menu in the given direction.'''
-        self.menu.move(menu_direction)
-
     def _handle_up(self):
         '''Handle UserEvent.NAVIGATE_UP.'''
-        self._move_menu(TextMenu.UP)
+        self.menu.up()
 
     def _handle_down(self):
         '''Handle UserEvent.NAVIGATE_DOWN.'''
-        self._move_menu(TextMenu.DOWN)
+        self.menu.down()
 
-    def _handle_select(self):
+    def _handle_select(self, event=None):
         '''Handle UserEvent.NAVIGATE_SELECT.'''
-        self.question_callback(self.menu.get_current_menuitem().get_userdata())
+        self.question_callback(self.menu.selected_userdata)
         self.go_back()
 
 
=== modified file 'entertainerlib/frontend/gui/screens/rss.py'
--- entertainerlib/frontend/gui/screens/rss.py	2009-06-25 19:06:28 +0000
+++ entertainerlib/frontend/gui/screens/rss.py	2009-07-14 11:06:21 +0000
@@ -5,13 +5,9 @@
 
 from entertainerlib.frontend.gui.screens.screen import Screen
 from entertainerlib.frontend.gui.widgets.label import Label
-from entertainerlib.frontend.gui.widgets.menu import Menu
-from entertainerlib.frontend.gui.widgets.selector import Selector
 from entertainerlib.frontend.gui.widgets.texture import Texture
 from entertainerlib.frontend.gui.widgets.text_menu import TextMenu
-from entertainerlib.frontend.gui.widgets.text_menu_item import TextMenuItem
 from entertainerlib.frontend.gui.widgets.list_indicator import ListIndicator
-from entertainerlib.frontend.medialibrary.feeds import Feed
 from entertainerlib.utils.feed_utils import FeedEntryParser
 
 class Rss(Screen):
@@ -21,9 +17,9 @@
         Screen.__init__(self, 'Rss', move_to_new_screen_callback)
 
         self.feed_order = 'UNREAD' # Feeds ordered by number of unread entries
-        self.active_menu = "feed"
         self.theme = self.config.theme
         self.library = feed_library
+        self.parser = FeedEntryParser()
 
         # Screen Title (Displayed at the bottom left corner)
         screen_title = Label(0.13, "screentitle", 0, 0.87, _("Headlines"))
@@ -47,11 +43,12 @@
         else:
             # Menus
             self._create_context_menu()
-            self._create_feed_menu()
+            self.menu = self._create_feed_menu()
+            self.add(self.menu)
             self.li = None
             self._create_feed_menu_indicator()
-            self.menu.set_active(True)
-            self.context_menu.set_active(False)
+            self.menu.active = True
+            self.context_menu.active = False
 
             # Feeds Title
             feeds_title = Label(0.04167, "title", 0.3953, 0.2, _("Feeds"))
@@ -62,45 +59,41 @@
             self.add(unread_title)
 
             # Feed description text
-            desc_text = FeedEntryParser().strip_tags(
-                Feed(self.menu.get_current_menuitem().get_userdata()
-                ).description)
+            desc_text = self.parser.strip_tags(
+                self.menu.selected_userdata.description)
+
             self.description = Label(0.03646, "text", 0.3953, 0.9, desc_text)
             self.description.set_ellipsize(pango.ELLIPSIZE_END)
             self.description.set_use_markup(True)
             self.description.set_size(0.5088, 0.0651)
             self.add(self.description)
 
+            self.menu.connect('selected', self._handle_select)
+            self.menu.connect('moved', self._display_selected_feed)
+            self.menu.connect('activated', self._menu_activation)
+            self.context_menu.connect('selected', self._handle_select)
+            self.context_menu.connect('activated',
+                self._context_menu_activation)
+
     def _create_feed_menu(self):
         """
         Create Feed-menu. This menu contains list of Feeds. It also displays
         number of unread entries per feed.
         """
-        self.menu = TextMenu(self.theme, self.config.show_effects())
-        self.menu.set_row_count(1)
-        self.menu.set_visible_column_count(7)
-        self.menu.set_item_size(self.get_abs_x(0.5124), self.get_abs_y(0.0781))
-        self.menu.set_position(self.get_abs_x(0.3807), self.get_abs_y(0.2604))
+        menu = TextMenu(0.3807, 0.2604, 0.5124, 0.0781)
 
-        # Create menu items based on FeedLibrary
         feeds = self.library.get_feeds(self.feed_order)
-        for feed in feeds:
-            unread = feed.get_number_of_unread()
-            if unread == 0:
-                unread = None
-            else:
-                unread = str(unread)
-            item = TextMenuItem(0.5124, 0.0781,
-                FeedEntryParser().strip_tags(feed.title), unread)
-            item.set_userdata(feed.url)
-            self.menu.add_actor(item)
+        feeds_list = [[self.parser.strip_tags(feed.title), \
+            str(feed.get_number_of_unread()), feed] \
+            for feed in feeds]
+        menu.async_add(feeds_list)
 
-        self.add(self.menu)
+        return menu
 
     def _create_feed_menu_indicator(self):
         '''Create a ListIndicator for feed menu.'''
         self.li = ListIndicator(0.7, 0.9, 0.2, 0.045, ListIndicator.VERTICAL)
-        self.li.set_maximum(self.menu.get_number_of_items())
+        self.li.set_maximum(self.menu.count)
         self.add(self.li)
 
     def _create_context_menu(self):
@@ -108,24 +101,14 @@
         Create RSS-feed context menu and add it to the screen.
         This menu contains buttons for update and sorting.
         """
-        select = Selector(Selector.LARGE, self.theme)
-        self.context_menu = Menu()
-
-        self.context_menu.set_loop(True)
-        item1 = TextMenuItem(0.2196, 0.0781, _("Update feeds"))
-        self.context_menu.add(item1)
-        item2 = TextMenuItem(0.2196, 0.0781, _("Mark all as read"))
-        self.context_menu.add(item2)
-        item3 = TextMenuItem(0.2196, 0.0781, _("Sort by name"))
-        self.context_menu.add(item3)
-        item4 = TextMenuItem(0.2196, 0.0781, _("Sort by unread"))
-        self.context_menu.add(item4)
-
-        self.context_menu.set_selector(select)
-        self.context_menu.set_position(self.get_abs_x(0.0732),
-            self.get_abs_y(0.2604))
-        self.context_menu.set_active(False)
-        self.context_menu.show_all()
+        self.context_menu = TextMenu(0.0732, 0.2604, 0.2196, 0.0781)
+
+        self.context_menu.add_item(_("Update feeds"))
+        self.context_menu.add_item(_("Mark all as read"))
+        self.context_menu.add_item(_("Sort by name"))
+        self.context_menu.add_item(_("Sort by unread"))
+
+        self.context_menu.active = False
         self.add(self.context_menu)
 
     def _create_no_feeds_information(self):
@@ -159,64 +142,41 @@
         Update screen widgets. This is called always when screen is poped from
         the screen history.
         """
-        #remove current feed menu, create a new one and set it to active
-        selected_name = self.menu.get_current_menuitem().label.get_text()
-
-        self.remove(self.menu)
-        self._create_feed_menu()
-        self.menu.set_active(True)
-
-        index = self.menu.get_index(selected_name)
-        if not index == -1:
-            self.menu.select(index)
-
-    def _move_menu(self, menu_direction):
-        '''Move the menu in the given direction.'''
-        if menu_direction == TextMenu.UP:
-            scroll_direction = self.context_menu.scroll_up
-        elif menu_direction == TextMenu.DOWN:
-            scroll_direction = self.context_menu.scroll_down
-
-        if self.active_menu == "feed":
-            self.menu.move(menu_direction)
-            self.li.set_current(self.menu.get_current_position() + 1)
-            feed = Feed(self.menu.get_current_menuitem().get_userdata())
-            self.description.set_text(FeedEntryParser().strip_tags(
-                feed.description))
-            self.description.set_size(0.5088, 0.0651)
-        else:
-            scroll_direction()
+        feeds = self.library.get_feeds(self.feed_order)
+        for idx, item in enumerate(self.menu.items):
+            feed = feeds[idx]
+            item.userdata = feed
+            item.update(self.parser.strip_tags(feed.title),
+                str(feed.get_number_of_unread()))
 
     def _handle_up(self):
         '''Handle UserEvent.NAVIGATE_UP.'''
-        self._move_menu(TextMenu.UP)
+        if self.menu.active:
+            self.menu.up()
+        else:
+            self.context_menu.up()
 
     def _handle_down(self):
         '''Handle UserEvent.NAVIGATE_DOWN.'''
-        self._move_menu(TextMenu.DOWN)
+        if self.menu.active:
+            self.menu.down()
+        else:
+            self.context_menu.down()
 
     def _handle_left(self):
         '''Handle UserEvent.NAVIGATE_LEFT.'''
-        if self.active_menu == "feed":
-            self.active_menu = "context"
-            self.li.hide_position()
-            self.menu.set_active(False)
-            self.description.hide()
-            self.context_menu.set_active(True)
+        if self.menu.active:
+            self._context_menu_activation()
 
     def _handle_right(self):
         '''Handle UserEvent.NAVIGATE_RIGHT.'''
-        if self.active_menu == "context":
-            self.active_menu = "feed"
-            self.li.show_position()
-            self.menu.set_active(True)
-            self.description.show()
-            self.context_menu.set_active(False)
+        if not self.menu.active:
+            self._menu_activation()
 
-    def _handle_select(self):
+    def _handle_select(self, event=None):
         '''Handle UserEvent.NAVIGATE_SELECT.'''
-        if self.active_menu == "context":
-            index = self.context_menu.get_current_position()
+        if not self.menu.active:
+            index = self.context_menu.selected_index
             if index == 0:
                 # Send message to bus and update screen
                 self.library.request_feed_update()
@@ -235,14 +195,34 @@
                 self.update()
         else:
             # Feed selected from the menu. Change screen.
-            feed = Feed(self.menu.get_current_menuitem().get_userdata())
+            feed = self.menu.selected_userdata
             kwargs = { 'feed' : feed }
             self.callback("feed", kwargs)
 
-    def handle_user_event(self, event):
+    def handle_user_event(self, event=None):
         '''Handle screen specific user events unless the library is empty.'''
         if self.library.is_empty() or len(self.library.get_feeds()) == 0:
             return
         else:
             Screen.handle_user_event(self, event)
 
+    def _display_selected_feed(self, actor=None):
+        '''Update of the list indicator and the description label'''
+        self.li.set_current(self.menu.selected_index + 1)
+        feed = self.menu.selected_userdata
+        self.description.set_text(self.parser.strip_tags(feed.description))
+
+    def _menu_activation(self, actor=None):
+        '''Handle the menu activation'''
+        self.menu.active = True
+        self.context_menu.active = False
+        self.li.show_position()
+        self.description.show()
+
+    def _context_menu_activation(self, actor=None):
+        '''Handle the context menu activation'''
+        self.menu.active = False
+        self.context_menu.active = True
+        self.li.hide_position()
+        self.description.hide()
+
 
=== modified file 'entertainerlib/frontend/gui/screens/screen.py'
--- entertainerlib/frontend/gui/screens/screen.py	2009-05-16 16:40:48 +0000
+++ entertainerlib/frontend/gui/screens/screen.py	2009-05-28 20:15:47 +0000
@@ -112,7 +112,7 @@
         '''Handle UserEvent.NAVIGATE_RIGHT.'''
         pass
 
-    def _handle_select(self):
+    def _handle_select(self, event=None):
         '''Handle UserEvent.NAVIGATE_SELECT.'''
         pass
 
@@ -134,6 +134,7 @@
         if not self.has_tabs:
             raise ScreenException('This screen does not support tabs.')
 
+        tab.tab_group = self.tab_group
         self.tab_group.add_tab(tab)
         # XXX: laymansterms - figure this out, why do we need to add directly
         # to the screen instead of the tab group, why is the positioning
 
=== modified file 'entertainerlib/frontend/gui/screens/tv_episodes.py'
--- entertainerlib/frontend/gui/screens/tv_episodes.py	2009-07-01 11:15:57 +0000
+++ entertainerlib/frontend/gui/screens/tv_episodes.py	2009-07-12 07:57:05 +0000
@@ -5,14 +5,12 @@
 import pango
 
 from entertainerlib.frontend.gui.screens.screen import Screen
-from entertainerlib.frontend.gui.user_event import UserEvent
 from entertainerlib.frontend.gui.widgets.eyecandy_texture import (
     EyeCandyTexture)
 from entertainerlib.frontend.gui.widgets.label import Label
 from entertainerlib.frontend.gui.widgets.list_indicator import ListIndicator
 from entertainerlib.frontend.gui.widgets.text_menu import TextMenu
 from entertainerlib.frontend.gui.widgets.scroll_area import ScrollArea
-from entertainerlib.frontend.gui.widgets.text_menu_item import TextMenuItem
 
 class TvEpisodes(Screen):
     '''Screen contains list of all episodes of one specific season.'''
@@ -32,58 +30,42 @@
         self.add(screen_title)
 
         self.scroll_area = None
-        self.episode_menu = None
+        self.menu = None
         self.title = None
         self.thumb = None
-        self._create_episode_menu()
+        self.menu = self._create_episode_menu()
+        self.add(self.menu)
         self._create_episode_info_box()
 
         #List indicator
         self.li = ListIndicator(0.8, 0.9, 0.2, 0.045, ListIndicator.VERTICAL)
-        self.li.set_maximum(self.episode_menu.get_number_of_items())
+        self.li.set_maximum(self.menu.count)
         self.add(self.li)
 
-        # Add the additional actions that are needed but not handled by default
-        self.event_handlers.update({
-            UserEvent.NAVIGATE_FIRST_PAGE : self._handle_first_page,
-            UserEvent.NAVIGATE_LAST_PAGE : self._handle_last_page,
-            UserEvent.NAVIGATE_PREVIOUS_PAGE : self._handle_previous_page,
-            UserEvent.NAVIGATE_NEXT_PAGE : self._handle_next_page
-        })
+        self.menu.connect("moved", self._update_episode_info)
+        self.menu.connect("selected", self._handle_select)
 
     def _create_episode_menu(self):
-        """
-        Create a list of available seasons
-        """
-        self.episode_menu = TextMenu(self.theme, self.config.show_effects())
-        self.episode_menu.set_row_count(1)
-        #self.episode_menu.set_visible_column_count(10)
-        self.episode_menu.set_item_size(self.get_abs_x(0.4393),
-            self.get_abs_y(0.0781))
-        self.episode_menu.set_position(self.get_abs_x(0.4978),
-            self.get_abs_y(0.1563))
+        """Create a list of available seasons."""
+        menu = TextMenu(0.4978, 0.1563, 0.4393, 0.0781)
 
-        # Create menu items based on MusicLibrary
         episodes = self.tv_series.get_episodes_from_season(self.season_number)
-        for episode in episodes:
-            item = TextMenuItem(0.4393, 0.0781,
-                str(episode.get_episode_number()) + ". " + episode.get_title())
-            item.set_userdata(episode)
-            self.episode_menu.add_actor(item)
-
-        self.episode_menu.set_active(True)
-        self.add(self.episode_menu)
+        episodes_list = [[_("%(num)d. %(title)s") % \
+            {'num': episode.get_episode_number(), 'title': episode.get_title()},
+            None, episode] for episode in episodes]
+        menu.async_add(episodes_list)
+
+        menu.active = True
+
+        return menu
 
     def _create_thumbnail_texture(self):
-        """
-        Create a thumbnail texture. This is called as menu is scrolled
-        """
+        """Create a thumbnail texture. This is called as menu is scrolled."""
         if self.thumb:
             self.thumb.hide()
 
         # Thumbnail. Use cover art if thumbnail doesn't exist
-        menu_item = self.episode_menu.get_current_menuitem()
-        thumbnail = menu_item.get_userdata().get_thumbnail_url()
+        thumbnail = self.menu.selected_userdata.get_thumbnail_url()
         if(thumbnail is not None):
             pixbuf = gtk.gdk.pixbuf_new_from_file(thumbnail)
             thumb_width = 0.2928
@@ -115,7 +97,7 @@
 
         # Title
         self.title = Label(0.04, "title", 0.05, 0.55,
-            self.episode_menu.get_current_menuitem().get_userdata().get_title(),
+            self.menu.selected_userdata.get_title(),
             font_weight="bold")
         self.title.set_ellipsize(pango.ELLIPSIZE_END)
         self.title.width = 0.4
@@ -123,79 +105,53 @@
 
         # Plot
         plot = Label(0.029, "subtitle", 0, 0,
-            self.episode_menu.get_current_menuitem().get_userdata().get_plot())
+            self.menu.selected_userdata.get_plot())
         plot.width = 0.4
 
-        self.scroll_area = ScrollArea(0.4, 0.3516, 0.05, 0.63, plot)
+        self.scroll_area = ScrollArea(0.4, 0.15, 0.05, 0.63, plot)
         self.add(self.scroll_area)
 
-    def _update_episode_info_box(self, episode):
-        """
-        Update episode infobox
-        @param episode: Display information from this episode
-        """
+    def _update_episode_info(self, event=None):
+        '''Update information from this episode.'''
+        self.li.set_current(self.menu.selected_index + 1)
+
         self._create_thumbnail_texture()
-        self.title.set_text(episode.get_title())
+        self.title.set_text(self.menu.selected_userdata.get_title())
         self.title.width = 0.4
 
         plot = Label(0.029, "subtitle", 0, 0,
-            self.episode_menu.get_current_menuitem().get_userdata().get_plot())
+            self.menu.selected_userdata.get_plot())
         plot.width = 0.4
         self.scroll_area.set_content(plot)
 
-    def _move_menu(self, menu_direction):
-        '''Move the menu in the given direction.'''
-        if menu_direction == TextMenu.UP:
-            scroll_direction = self.scroll_area.scroll_up
-        elif menu_direction == TextMenu.DOWN:
-            scroll_direction = self.scroll_area.scroll_down
-
-        if self.episode_menu.is_active():
-            self.episode_menu.move(menu_direction)
-            self.li.set_current(self.episode_menu.get_current_position() + 1)
-            self._update_episode_info_box(
-                self.episode_menu.get_current_menuitem().get_userdata())
-        else:
-            scroll_direction()
-
     def _handle_up(self):
         '''Handle UserEvent.NAVIGATE_UP.'''
-        self._move_menu(TextMenu.UP)
+        if self.menu.active:
+            self.menu.up()
+        else:
+            self.scroll_area.scroll_up()
 
     def _handle_down(self):
         '''Handle UserEvent.NAVIGATE_DOWN.'''
-        self._move_menu(TextMenu.DOWN)
+        if self.menu.active:
+            self.menu.down()
+        else:
+            self.scroll_area.scroll_down()
 
     def _handle_left(self):
         '''Handle UserEvent.NAVIGATE_LEFT.'''
-        self.episode_menu.set_active(False)
+        self.menu.active = False
         self.scroll_area.set_active(True)
 
     def _handle_right(self):
         '''Handle UserEvent.NAVIGATE_RIGHT.'''
-        self.episode_menu.set_active(True)
+        self.menu.active = True
         self.scroll_area.set_active(False)
 
-    def _handle_select(self):
+    def _handle_select(self, event=None):
         '''Handle UserEvent.NAVIGATE_SELECT.'''
-        episode = self.episode_menu.get_current_menuitem().get_userdata()
+        episode = self.menu.selected_userdata
         self.media_player.set_media(episode)
         self.media_player.play()
         self.callback("video_osd")
 
-    def _handle_first_page(self):
-        '''Handle UserEvent.NAVIGATE_FIRST_PAGE.'''
-        self.scroll_area.scroll_to_top()
-
-    def _handle_last_page(self):
-        '''Handle UserEvent.NAVIGATE_LAST_PAGE.'''
-        self.scroll_area.scroll_to_bottom()
-
-    def _handle_previous_page(self):
-        '''Handle UserEvent.NAVIGATE_PREVIOUS_PAGE.'''
-        self.scroll_area.scroll_page_up()
-
-    def _handle_next_page(self):
-        '''Handle UserEvent.NAVIGATE_NEXT_PAGE.'''
-        self.scroll_area.scroll_page_down()
-
 
=== modified file 'entertainerlib/frontend/gui/screens/tv_series.py'
--- entertainerlib/frontend/gui/screens/tv_series.py	2009-07-01 11:15:57 +0000
+++ entertainerlib/frontend/gui/screens/tv_series.py	2009-07-12 07:57:05 +0000
@@ -9,7 +9,6 @@
 from entertainerlib.frontend.gui.widgets.label import Label
 from entertainerlib.frontend.gui.widgets.list_indicator import ListIndicator
 from entertainerlib.frontend.gui.widgets.text_menu import TextMenu
-from entertainerlib.frontend.gui.widgets.text_menu_item import TextMenuItem
 
 class TvSeries(Screen):
     '''Screen that contains all seasons of one TV series.'''
@@ -26,37 +25,35 @@
         self.add(screen_title)
 
         self.art = None
-        self.season_menu = None
+        self.menu = None
         self._create_series_cover_texture()
-        self._create_season_menu()
+        self.menu = self._create_season_menu()
+        self.add(self.menu)
 
         #List indicator
         self.li = ListIndicator(0.8, 0.9, 0.2, 0.045, ListIndicator.VERTICAL)
-        self.li.set_maximum(self.season_menu.get_number_of_items())
+        self.li.set_maximum(len(self.tv_series.get_seasons()))
         self.add(self.li)
 
+        self.menu.connect("moved", self._update_season_info)
+        self.menu.connect("selected", self._handle_select)
+
     def _create_season_menu(self):
         """
         Create a list of available seasons
         """
-        self.season_menu = TextMenu(self.theme, self.config.show_effects())
-        self.season_menu.set_row_count(1)
-        self.season_menu.set_item_size(self.get_abs_x(0.4393),
-            self.get_abs_y(0.0781))
-        self.season_menu.set_position(self.get_abs_x(0.4978),
-            self.get_abs_y(0.1563))
+        menu = TextMenu(0.4978, 0.1563, 0.4393, 0.0781)
 
-        # Create menu items based on MusicLibrary
         seasons = self.tv_series.get_seasons()
         seasons.sort()
-        for season in seasons:
-            item = TextMenuItem(0.4393, 0.0781,
-                _("Season %(num)s") % {'num': season})
-            item.set_userdata(season)
-            self.season_menu.add_actor(item)
-
-        self.season_menu.set_active(True)
-        self.add(self.season_menu)
+
+        seasons_list = [[_("Season %(num)s") % {'num': season}, None, season] \
+            for season in seasons]
+        menu.async_add(seasons_list)
+
+        menu.active = True
+
+        return menu
 
     def _create_series_cover_texture(self):
         """
@@ -72,22 +69,21 @@
         self.art = EyeCandyTexture(0.16, 0.15, 0.2196, 0.5859, pixbuf)
         self.add(self.art)
 
-    def _move_menu(self, menu_direction):
-        '''Move the menu in the given direction.'''
-        self.season_menu.move(menu_direction)
-        self.li.set_current(self.season_menu.get_current_position() + 1)
+    def _update_season_info(self, event=None):
+        '''Update the ListIndicator.'''
+        self.li.set_current(self.menu.selected_index + 1)
 
     def _handle_up(self):
         '''Handle UserEvent.NAVIGATE_UP.'''
-        self._move_menu(TextMenu.UP)
+        self.menu.up()
 
     def _handle_down(self):
         '''Handle UserEvent.NAVIGATE_DOWN.'''
-        self._move_menu(TextMenu.DOWN)
+        self.menu.down()
 
-    def _handle_select(self):
+    def _handle_select(self, event=None):
         '''Handle UserEvent.NAVIGATE_SELECT.'''
-        season = self.season_menu.get_current_menuitem().get_userdata()
+        season = self.menu.selected_userdata
         kwargs = { 'tv_series' : self.tv_series, 'season_number' : season }
         self.callback("tv_episodes", kwargs)
 
 
=== modified file 'entertainerlib/frontend/gui/tabs/albums_tab.py'
--- entertainerlib/frontend/gui/tabs/albums_tab.py	2009-05-14 03:22:31 +0000
+++ entertainerlib/frontend/gui/tabs/albums_tab.py	2009-07-14 11:06:21 +0000
@@ -2,18 +2,14 @@
 '''Albums tab which displays albums and allows users to select them'''
 # pylint: disable-msg=W1001
 
-import clutter
-import gobject
 import pango
 
 from entertainerlib.frontend.gui.tabs.tab import Tab
 from entertainerlib.frontend.gui.widgets.image_menu import ImageMenu
-from entertainerlib.frontend.gui.widgets.image_menu_item import ImageMenuItem
 from entertainerlib.frontend.gui.widgets.label import Label
 from entertainerlib.frontend.gui.widgets.list_indicator import ListIndicator
 from entertainerlib.frontend.gui.widgets.loading_animation import (
     LoadingAnimation)
-from entertainerlib.frontend.gui.widgets.texture import Texture
 
 class AlbumsTab(Tab):
     '''Tab to show album listings'''
@@ -28,48 +24,28 @@
         self.add(self.throbber)
 
         if len(albums) < 4:
-            # XXX: laymansterms - This is "less than elegant." I'm not fixing
-            # ImageMenu right now so we can't get rid of tex_size_x and y yet.
-            # We really need to eliminate the concept tex_size_y, but it will
-            # have to wait for now.
             x_percent = 0.2928
-            tex_size_x = self.get_abs_x(x_percent)
-            tex_size_y = self.get_abs_y(0.5208)
-            row_count = 1
-            visible = 3
+            visible_rows = 1
+            visible_cols = 3
         elif len(albums) < 13:
             x_percent = 0.1464
-            tex_size_x = self.get_abs_x(x_percent)
-            tex_size_y = self.get_abs_y(0.2604)
-            row_count = 2
-            visible = 6
+            visible_rows = 2
+            visible_cols = 6
         else:
             x_percent = 0.1098
-            tex_size_x = self.get_abs_x(x_percent)
-            tex_size_y = self.get_abs_y(0.1953)
-            row_count = 3
-            visible = 8
+            visible_rows = 3
+            visible_cols = 8
 
         # Create albums menu
-        self.menu = ImageMenu(self.theme)
-        self.menu.set_row_count(row_count)
-        self.menu.set_visible_column_count(visible)
-        self.menu.set_item_size(tex_size_x, tex_size_y)
-
-        # Default texture
-        self.default_cover = Texture(self.theme.getImage("default_album_art"))
-
-        self._async_menu_build(albums, x_percent)
-        self._selected_album = self.menu.get_current_menuitem().get_userdata()
-
-        self.menu.set_position(self.get_abs_x(0.0586), self.get_abs_y(0.1823))
-        self.menu.show()
-
-        if self.config.show_effects():
-            self.menu.set_animate(True)
-
+        self.menu = ImageMenu(0.07, 0.16, x_percent, self.y_for_x(x_percent))
+        self.menu.visible_rows = visible_rows
+        self.menu.visible_cols = visible_cols
+        self.menu.items_per_col = self.menu.visible_rows
         self.add(self.menu)
 
+        albums_list = [[album.get_album_art_url(), album] for album in albums]
+        self.menu.async_add_albums(albums_list)
+
         self.li = ListIndicator(0.77, 0.8, 0.18, 0.045,
             ListIndicator.HORIZONTAL)
         self.li.set_maximum(len(albums))
@@ -92,102 +68,79 @@
 
         self.connect('activated', self._on_activated)
         self.connect('deactivated', self._on_deactivated)
-
-    def _async_menu_build(self, albums, item_size_percent):
-        """
-        This function is called as an async callback. It is also a recursive
-        function. This allows us to load menu items in the background without
-        blocking the user interface.
-        """
-
-        # Check if we should stop recursive calls (menu is complete)
-        if len(albums) > 0:
-            album = albums[0]
-            if album.has_album_art():
-                texture = Texture(album.get_album_art_url())
-            else:
-                texture = clutter.CloneTexture(self.default_cover)
-
-            item = ImageMenuItem(item_size_percent, 1, texture)
-            item.set_userdata(album)
-            self.menu.add_actor(item)
-            # Recursive call, remove first album from the list
-            gobject.timeout_add(25, self._async_menu_build, albums[1:],
-                item_size_percent)
-            return False
-        else:
-            self.throbber.hide()
-            # Done loading the albums, notify gobject to stop calling menu build
-            return False
-
-    def _get_selected_album(self):
-        '''Get the currently selected album from the menu.'''
-        return self.menu.get_current_menuitem().get_userdata()
-
-    selected_album = property(_get_selected_album)
+        self.menu.connect("moved", self._update_album_info)
+        self.menu.connect("selected", self._handle_select)
+        self.menu.connect("activated", self._on_activated)
+        self.menu.connect("filled", self._on_menu_filled)
 
     def can_activate(self):
         '''Albums tab will always be created from an existing artist with at
         least one album.'''
         return True
 
-    def _update_album_info(self):
+    def _update_album_info(self, event=None):
         '''Update the album information labels.'''
         if self.active:
-            album = self.menu.get_current_menuitem().get_userdata()
+            album = self.menu.selected_userdata
             self.album_title.set_text(album.get_title())
             self.album_artist.set_text(album.get_artist())
             self.album_tracks.set_text(_("%(total)s tracks") % \
                 {'total': album.get_number_of_tracks()})
+            self.li.show()
+            self.li.set_current(self.menu.selected_index + 1)
         else:
             self.album_title.set_text("")
             self.album_artist.set_text("")
             self.album_tracks.set_text("")
-
-    def _update_menu(self, direction):
-        '''Update the menu based on the provided menu direction.'''
-        self.menu.move(direction)
-        self._update_album_info()
-        self.li.set_current(self.menu.get_current_position() + 1)
-        return False
+            self.li.hide()
 
     def _handle_up(self):
         '''Handle the up user event.'''
-        if self.menu.get_cursor_position()[1] == 0:
+        if self.menu.on_top:
             return True # Move control back to tab bar
         else:
-            return self._update_menu(self.menu.UP)
+            self.menu.up()
+            return False
 
     def _handle_down(self):
         '''Handle the down user event.'''
-        return self._update_menu(self.menu.DOWN)
+        self.menu.down()
+        return False
 
     def _handle_left(self):
         '''Handle the left user event.'''
-        return self._update_menu(self.menu.LEFT)
+        self.menu.left()
+        return False
 
     def _handle_right(self):
         '''Handle the right user event.'''
-        return self._update_menu(self.menu.RIGHT)
+        self.menu.right()
+        return False
 
-    def _handle_select(self):
+    def _handle_select(self, event=None):
         '''Handle the select user event.'''
-        album = self.menu.get_current_menuitem().get_userdata()
+        album = self.menu.selected_userdata
         kwargs = { 'album' : album }
         self.callback("album", kwargs)
         return False
 
     def _on_activated(self, event=None):
         '''Tab activated.'''
+        if self.tab_group is not None:
+            self.tab_group.active = False
+        self.menu.active = True
+        self.active = True
         self._update_album_info()
-        self.menu.set_active(True)
-        self.menu.set_opacity(255)
         return False
 
     def _on_deactivated(self, event=None):
         '''Tab deactivated.'''
+        self.active = False
+        self.menu.active = False
         self._update_album_info()
-        self.menu.set_active(False)
-        self.menu.set_opacity(128)
         return False
 
+    def _on_menu_filled(self, event=None):
+        '''Handles filled event.'''
+        self.throbber.hide()
+
 
=== modified file 'entertainerlib/frontend/gui/tabs/artists_tab.py'
--- entertainerlib/frontend/gui/tabs/artists_tab.py	2009-05-14 03:22:31 +0000
+++ entertainerlib/frontend/gui/tabs/artists_tab.py	2009-07-14 11:06:21 +0000
@@ -2,8 +2,6 @@
 '''Artists tab for the music screen'''
 # pylint: disable-msg=W1001
 
-import clutter
-import gobject
 import pango
 
 from entertainerlib.frontend.gui.tabs.tab import Tab
@@ -12,7 +10,6 @@
 from entertainerlib.frontend.gui.widgets.loading_animation import (
     LoadingAnimation)
 from entertainerlib.frontend.gui.widgets.text_menu import TextMenu
-from entertainerlib.frontend.gui.widgets.text_menu_item import TextMenuItem
 
 class ArtistsTab(Tab):
     '''Tab for the music screen to show artist listings'''
@@ -27,19 +24,18 @@
         self.throbber.show()
         self.add(self.throbber)
 
-        self.menu = TextMenu(self.config.theme, self.config.show_effects())
-        self.menu.set_item_size(self.get_abs_x(0.293), self.get_abs_y(0.078))
-        cursor = clutter.Rectangle()
-        cursor.set_color((0, 0, 0, 0))
-        self.menu.set_cursor(cursor)
-        self.menu.set_orientation(TextMenu.HORIZONTAL)
-        self.menu.set_row_count(7)
-        self.menu.set_visible_column_count(3)
-        self.menu.set_position(self.get_abs_x(0.057), self.get_abs_y(0.208))
-        if self.config.show_effects():
-            self.menu.set_animate(True)
+        self.menu = TextMenu(0.057, 0.208, 0.293, 0.078)
+        self.menu.items_per_row = 3
+        self.menu.visible_rows = 7
+        self.menu.visible_cols = 3
+        self.menu.active = False
+        self.menu.cursor = None
+        self.menu.items_anchor_west = False
         self.add(self.menu)
 
+        artists_list = [[artist, None, artist] for artist in artists]
+        self.menu.async_add_artists(artists_list)
+
         # Create artist label
         self.artist_title = Label(0.0416, "title", 0.22, 0.794, "")
         self.artist_title.set_ellipsize(pango.ELLIPSIZE_END)
@@ -54,107 +50,85 @@
 
         # Create artis menu list indicator
         self.li = ListIndicator(0.77, 0.8, 0.18, 0.045,
-            ListIndicator.HORIZONTAL)
+            ListIndicator.VERTICAL)
         self.li.set_maximum(len(artists))
         self.add(self.li)
 
-        self._async_menu_build(artists)
-        self._selected_artist = self.menu.get_current_menuitem().get_userdata()
-
         self.connect('activated', self._on_activated)
         self.connect('deactivated', self._on_deactivated)
-
-    def _async_menu_build(self, artists):
-        """
-        This function is called as an async callback. It is also a recursive
-        function. This allows us to load menu items in the background without
-        blocking the user interface.
-        """
-
-        # Check if we should stop recursive calls (menu is complete)
-        if len(artists) > 0:
-            artist = artists[0]
-            item = TextMenuItem(0.293, 0.104, artist)
-            item.justified = True
-            item.set_userdata(artist)
-            self.menu.add_actor(item)
-            # Recursive call, remove first artist from the list
-            gobject.timeout_add(15, self._async_menu_build, artists[1:])
-            return False
-        else:
-            self.throbber.hide()
-            # Done loading artists, notify gobject to stop calling menu build
-            return False
-
-    def _get_selected_artist(self):
-        '''Get the currently selected artist from the menu.'''
-        return self.menu.get_current_menuitem().get_userdata()
-
-    selected_artist = property(_get_selected_artist)
+        self.menu.connect("moved", self._update_artist_info)
+        self.menu.connect("selected", self._handle_select)
+        self.menu.connect("activated", self._on_activated)
+        self.menu.connect("filled", self._on_menu_filled)
 
     def can_activate(self):
         '''Albums tab will always be created from an existing artist with at
         least one album.'''
         return True
 
-    def _update_artist_info(self):
+    def _update_artist_info(self, event=None):
         '''Update the artist information labels'''
         if self.active:
-            artist = self.menu.get_current_menuitem().get_userdata()
+            artist = self.menu.selected_userdata
             self.artist_title.set_text(artist)
             self.artist_albums.set_text(_("%(albums)d albums") %
                 {'albums': self.library.number_of_albums_by_artist(artist)})
             self.artist_tracks.set_text(_("%(tracks)d tracks") %
                 {'tracks': self.library.number_of_tracks_by_artist(artist)})
+            self.li.show()
+            self.li.set_current(self.menu.selected_index + 1)
         else:
             self.artist_title.set_text("")
             self.artist_albums.set_text("")
             self.artist_tracks.set_text("")
-
-    def _update_menu(self, direction):
-        '''Update the menu based on the provided menu direction.'''
-        self.menu.move(direction)
-        self._update_artist_info()
-        self.li.set_current(self.menu.get_current_position() + 1)
-        return False
+            self.li.hide()
 
     def _handle_up(self):
         '''Handle the up user event.'''
-        if self.menu.get_cursor_position()[1] == 0:
+        if self.menu.on_top:
             return True # Move control back to tab bar
         else:
-            return self._update_menu(self.menu.UP)
+            self.menu.up()
+            return False
 
     def _handle_down(self):
         '''Handle the down user event.'''
-        return self._update_menu(self.menu.DOWN)
+        self.menu.down()
+        return False
 
     def _handle_left(self):
         '''Handle the left user event.'''
-        return self._update_menu(self.menu.LEFT)
+        self.menu.left()
+        return False
 
     def _handle_right(self):
         '''Handle the right user event.'''
-        return self._update_menu(self.menu.RIGHT)
+        self.menu.right()
+        return False
 
-    def _handle_select(self):
+    def _handle_select(self, event=None):
         '''Handle the select user event.'''
-        artist = self.menu.get_current_menuitem().get_userdata()
+        artist = self.menu.selected_userdata
         kwargs = { 'artist' : artist }
         self.callback("artist", kwargs)
         return False
 
     def _on_activated(self, event=None):
         '''Tab activated.'''
+        if self.tab_group is not None:
+            self.tab_group.active = False
+        self.menu.active = True
+        self.active = True
         self._update_artist_info()
-        self.menu.set_active(True)
-        self.menu.set_opacity(255)
         return False
 
     def _on_deactivated(self, event=None):
         '''Tab deactivated.'''
+        self.active = False
+        self.menu.active = False
         self._update_artist_info()
-        self.menu.set_active(False)
-        self.menu.set_opacity(128)
-        return False
+
+    def _on_menu_filled(self, event=None):
+        '''Handles filled event.'''
+        self.throbber.hide()
 
 
=== modified file 'entertainerlib/frontend/gui/tabs/movies_tab.py'
--- entertainerlib/frontend/gui/tabs/movies_tab.py	2009-05-14 03:22:31 +0000
+++ entertainerlib/frontend/gui/tabs/movies_tab.py	2009-07-14 11:06:21 +0000
@@ -1,17 +1,14 @@
 # Copyright (c) 2009 Entertainer Developers - See COPYING - GPLv2
 '''MoviesTab - MoviesTab is group of objects that are displayed on movie tab'''
 
-import clutter
-import gtk
 import pango
 
 from entertainerlib.frontend.gui.tabs.tab import Tab
 from entertainerlib.frontend.gui.widgets.image_menu import ImageMenu
-from entertainerlib.frontend.gui.widgets.image_menu_item import ImageMenuItem
 from entertainerlib.frontend.gui.widgets.label import Label
 from entertainerlib.frontend.gui.widgets.list_indicator import ListIndicator
-from entertainerlib.frontend.gui.widgets.rounded_texture import RoundedTexture
-from entertainerlib.frontend.gui.widgets.texture import Texture
+from entertainerlib.frontend.gui.widgets.loading_animation import (
+    LoadingAnimation)
 
 class MoviesTab(Tab):
     """
@@ -24,6 +21,7 @@
     def __init__(self, video_library, move_to_new_screen_callback,
         name="movies", tab_title=_("Movies")):
         Tab.__init__(self, name, tab_title, move_to_new_screen_callback)
+
         self.video_library = video_library
         self.theme = self.config.theme
         self.list_indicator = None
@@ -35,7 +33,17 @@
         if self.video_library.get_number_of_movies() == 0:
             self._create_empty_library_notice()
         else:
-            self._create_menu()
+            # Start the loading animation while the menu is loading
+            self.throbber = LoadingAnimation(0.1, 0.1)
+            self.throbber.show()
+            self.add(self.throbber)
+
+            self.menu = self._create_menu()
+            self.add(self.menu)
+            self.menu.connect("moved", self._update_movie_info)
+            self.menu.connect("selected", self._handle_select)
+            self.menu.connect("activated", self._on_activated)
+            self.menu.connect("filled", self._on_menu_filled)
 
             self.connect('activated', self._on_activated)
             self.connect('deactivated', self._on_deactivated)
@@ -67,40 +75,19 @@
         the video library.
         """
         #Create movie menu
-        self.menu = ImageMenu(self.theme)
-        self.menu.set_item_size(self.get_abs_x(0.1), self.get_abs_y(0.25))
-        self.menu.set_item_spacing(self.get_abs_y(0.025))
-        self.menu.set_visible_column_count(2)
-        self.menu.set_row_count(7)
-        self.menu.set_orientation(self.menu.VERTICAL)
-
-        # Default texture
-        default_cover = Texture(self.theme.getImage("default_movie_art"))
+        menu = ImageMenu(0.06, 0.18, 0.12, 0.25)
+        menu.items_per_col = 2
+        menu.visible_rows = 2
+        menu.visible_cols = 7
 
         movies = self.video_library.get_movies()
-        for movie in movies:
-            if movie.has_cover_art():
-                pix_buffer = gtk.gdk.pixbuf_new_from_file(
-                    movie.get_cover_art_url())
-                texture = RoundedTexture(0.0, 0.0, 0.1, 0.25, pix_buffer)
-            else:
-                texture = clutter.CloneTexture(default_cover)
-            item = ImageMenuItem(0.1, 1.41, texture)
-            item.set_userdata(movie)
-            self.menu.add_actor(item)
-
-        self.menu.set_position(self.get_abs_x(0.11), self.get_abs_y(0.2))
-        self.menu.show()
-
-        if self.config.show_effects():
-            self.menu.set_animate(True)
-
-        self.add(self.menu)
+        movies_list = [[movie.get_cover_art_url(), movie] for movie in movies]
+        menu.async_add_videos(movies_list)
 
         # Create list indicator
         self.list_indicator = ListIndicator(0.75, 0.76, 0.2, 0.045,
-            ListIndicator.VERTICAL)
-        self.list_indicator.set_maximum(self.menu.get_number_of_items())
+            ListIndicator.HORIZONTAL)
+        self.list_indicator.set_maximum(len(movies))
         self.show()
         self.add(self.list_indicator)
 
@@ -120,10 +107,12 @@
         self.movie_plot.width = 0.7
         self.add(self.movie_plot)
 
-    def _update_movie_info(self):
+        return menu
+
+    def _update_movie_info(self, event=None):
         '''Update the movie information labels.'''
         if self.active:
-            movie = self.menu.get_current_menuitem().get_userdata()
+            movie = self.menu.selected_userdata
             genres = movie.get_genres()
             if len(genres) > 1:
                 genre = genres[0] + "/" + genres[1]
@@ -135,55 +124,61 @@
             self.movie_info.set_text(_("%(min)d min, (%(genre)s)") % \
                 {'min': movie.get_runtime(), 'genre': genre})
             self.movie_plot.set_text(movie.get_short_plot())
+            self.list_indicator.show()
+            self.list_indicator.set_current(self.menu.selected_index + 1)
         else:
             self.movie_title.set_text("")
             self.movie_info.set_text("")
             self.movie_plot.set_text("")
-
-    def _update_menu(self, direction):
-        '''Update the menu based on the provided menu direction.'''
-        self.menu.move(direction)
-        self._update_movie_info()
-        self.list_indicator.set_current(self.menu.get_current_position() + 1)
-        return False
+            self.list_indicator.hide()
 
     def _handle_up(self):
         '''Handle the up user event.'''
-        if self.menu.get_current_position() <= 6:
+        if self.menu.on_top:
             return True # Move control back to tab bar
         else:
-            return self._update_menu(self.menu.UP)
+            self.menu.up()
+            return False
 
     def _handle_down(self):
         '''Handle the down user event.'''
-        return self._update_menu(self.menu.DOWN)
+        self.menu.down()
+        return False
 
     def _handle_left(self):
         '''Handle the left user event.'''
-        return self._update_menu(self.menu.LEFT)
+        self.menu.left()
+        return False
 
     def _handle_right(self):
         '''Handle the right user event.'''
-        return self._update_menu(self.menu.RIGHT)
+        self.menu.right()
+        return False
 
-    def _handle_select(self):
+    def _handle_select(self, event=None):
         '''Handle the select user event.'''
-        movie = self.menu.get_current_menuitem().get_userdata()
+        movie = self.menu.selected_userdata
         kwargs = { 'movie' : movie }
         self.callback("movie", kwargs)
         return False
 
     def _on_activated(self, event=None):
         '''Tab activated.'''
+        if self.tab_group is not None:
+            self.tab_group.active = False
+        self.menu.active = True
+        self.active = True
         self._update_movie_info()
-        self.menu.set_active(True)
-        self.menu.set_opacity(255)
         return False
 
     def _on_deactivated(self, event=None):
         '''Tab deactivated.'''
+        self.active = False
+        self.menu.active = False
         self._update_movie_info()
-        self.menu.set_active(False)
-        self.menu.set_opacity(128)
         return False
 
+    def _on_menu_filled(self, event=None):
+        '''Handles filled event.'''
+        self.throbber.hide()
+
 
=== modified file 'entertainerlib/frontend/gui/tabs/series_tab.py'
--- entertainerlib/frontend/gui/tabs/series_tab.py	2009-05-14 03:22:31 +0000
+++ entertainerlib/frontend/gui/tabs/series_tab.py	2009-07-14 11:06:21 +0000
@@ -1,17 +1,14 @@
 # Copyright (c) 2009 Entertainer Developers - See COPYING - GPLv2
 '''SeriesTab - Group of objects that are displayed on tv-series tab'''
 
-import clutter
-import gtk
 import pango
 
 from entertainerlib.frontend.gui.tabs.tab import Tab
 from entertainerlib.frontend.gui.widgets.image_menu import ImageMenu
-from entertainerlib.frontend.gui.widgets.image_menu_item import ImageMenuItem
 from entertainerlib.frontend.gui.widgets.label import Label
 from entertainerlib.frontend.gui.widgets.list_indicator import ListIndicator
-from entertainerlib.frontend.gui.widgets.rounded_texture import RoundedTexture
-from entertainerlib.frontend.gui.widgets.texture import Texture
+from entertainerlib.frontend.gui.widgets.loading_animation import (
+    LoadingAnimation)
 
 class SeriesTab(Tab):
     """
@@ -24,6 +21,7 @@
     def __init__(self, video_library, move_to_new_screen_callback,
         name="series", tab_title=_("TV-Series")):
         Tab.__init__(self, name, tab_title, move_to_new_screen_callback)
+
         self.video_library = video_library
         self.theme = self.config.theme
         self.list_indicator = None
@@ -34,7 +32,17 @@
         if self.video_library.get_number_of_tv_series() == 0:
             self._create_empty_library_notice()
         else:
-            self._create_menu()
+            # Start the loading animation while the menu is loading
+            self.throbber = LoadingAnimation(0.4, 0.1)
+            self.throbber.show()
+            self.add(self.throbber)
+
+            self.menu = self._create_menu()
+            self.add(self.menu)
+            self.menu.connect("moved", self._update_serie_info)
+            self.menu.connect("selected", self._handle_select)
+            self.menu.connect("activated", self._on_activated)
+            self.menu.connect("filled", self._on_menu_filled)
 
             self.connect('activated', self._on_activated)
             self.connect('deactivated', self._on_deactivated)
@@ -66,42 +74,19 @@
         the video library.
         """
         #Create TV-series menu
-        self.menu = ImageMenu(self.theme)
-        self.menu.set_item_size(self.get_abs_x(0.1), self.get_abs_y(0.25))
-        self.menu.set_item_spacing(self.get_abs_y(0.025))
-        self.menu.set_visible_column_count(2)
-        self.menu.set_row_count(7)
-        self.menu.set_orientation(self.menu.VERTICAL)
-
-        # Default texture
-        default_cover = Texture(self.theme.getImage("default_movie_art"))
-
-        all_series = self.video_library.get_tv_series()
-        for series in all_series:
-            if series.has_cover_art():
-                pix_buffer = gtk.gdk.pixbuf_new_from_file(
-                    series.get_cover_art_url())
-                texture = RoundedTexture(0.0, 0.0, 0.1, 0.25, pix_buffer)
-            else:
-                texture = clutter.CloneTexture(default_cover)
-
-            item = ImageMenuItem(0.1, 1.41, texture)
-            item.set_userdata(series)
-            self.menu.add_actor(item)
-
-        self.menu.set_position(self.get_abs_x(0.11), self.get_abs_y(0.2))
-        self.menu.set_active(False)
-        self.menu.show()
-
-        if self.config.show_effects():
-            self.menu.set_animate(True)
-
-        self.add(self.menu)
+        menu = ImageMenu(0.06, 0.18, 0.12, 0.25)
+        menu.items_per_col = 2
+        menu.visible_rows = 2
+        menu.visible_cols = 7
+
+        series = self.video_library.get_tv_series()
+        series_list = [[serie.get_cover_art_url(), serie] for serie in series]
+        menu.async_add_videos(series_list)
 
         # Create list indicator
         self.list_indicator = ListIndicator(0.75, 0.76, 0.2, 0.045,
-            ListIndicator.VERTICAL)
-        self.list_indicator.set_maximum(self.menu.get_number_of_items())
+            ListIndicator.HORIZONTAL)
+        self.list_indicator.set_maximum(len(series))
         self.list_indicator.show()
         self.add(self.list_indicator)
 
@@ -115,64 +100,72 @@
         self.series_info = Label(0.034, "subtitle", 0.2, 0.82, "")
         self.add(self.series_info)
 
-    def _update_series_info(self):
+        return menu
+
+    def _update_serie_info(self, event=None):
         '''Update the series information labels.'''
         if self.active:
-            series = self.menu.get_current_menuitem().get_userdata()
+            series = self.menu.selected_userdata
             info = _("%(season)d Seasons\n%(episode)d Episodes") % {'season':
                 series.get_number_of_seasons(), 'episode':
                 series.get_number_of_episodes()}
 
             self.series_info.set_text(info)
             self.series_title.set_text(series.get_title())
+            self.list_indicator.show()
+            self.list_indicator.set_current(self.menu.selected_index + 1)
         else:
             self.series_info.set_text("")
             self.series_title.set_text("")
-
-    def _update_menu(self, direction):
-        '''Update the menu based on the provided menu direction.'''
-        self.menu.move(direction)
-        self._update_series_info()
-        self.list_indicator.set_current(self.menu.get_current_position() + 1)
-        return False
+            self.list_indicator.hide()
 
     def _handle_up(self):
         '''Handle the up user event.'''
-        if self.menu.get_current_position() <= 6:
+        if self.menu.on_top:
             return True # Move control back to tab bar
         else:
-            return self._update_menu(self.menu.UP)
+            self.menu.up()
+            return False
 
     def _handle_down(self):
         '''Handle the down user event.'''
-        return self._update_menu(self.menu.DOWN)
+        self.menu.down()
+        return False
 
     def _handle_left(self):
         '''Handle the left user event.'''
-        return self._update_menu(self.menu.LEFT)
+        self.menu.left()
+        return False
 
     def _handle_right(self):
         '''Handle the right user event.'''
-        return self._update_menu(self.menu.RIGHT)
+        self.menu.right()
+        return False
 
-    def _handle_select(self):
+    def _handle_select(self, event=None):
         '''Handle the select user event.'''
-        series = self.menu.get_current_menuitem().get_userdata()
+        series = self.menu.selected_userdata
         kwargs = { 'tv_series' : series }
         self.callback("tv_series", kwargs)
         return False
 
     def _on_activated(self, event=None):
         '''Tab activated.'''
-        self._update_series_info()
-        self.menu.set_active(True)
-        self.menu.set_opacity(255)
+        if self.tab_group is not None:
+            self.tab_group.active = False
+        self.menu.active = True
+        self.active = True
+        self._update_serie_info()
         return False
 
     def _on_deactivated(self, event=None):
         '''Tab deactivated.'''
-        self._update_series_info()
-        self.menu.set_active(False)
-        self.menu.set_opacity(128)
+        self.active = False
+        self.menu.active = False
+        self._update_serie_info()
         return False
 
+    def _on_menu_filled(self, event=None):
+        '''Handles filled event.'''
+        self.throbber.hide()
+
 
=== modified file 'entertainerlib/frontend/gui/tabs/tab.py'
--- entertainerlib/frontend/gui/tabs/tab.py	2009-05-12 17:18:10 +0000
+++ entertainerlib/frontend/gui/tabs/tab.py	2009-05-21 16:12:09 +0000
@@ -40,6 +40,7 @@
 
         # show/hide animation on the Tab
         self.timeline = clutter.Timeline(30, 60)
+        self.timeline.connect('completed', self._on_timeline_completed)
         self.alpha = clutter.Alpha(self.timeline, clutter.smoothstep_inc_func)
         self.behaviour = clutter.BehaviourOpacity(0, 255, self.alpha)
         self.behaviour.apply(self)
@@ -48,6 +49,7 @@
         self._active = None
         self._visible = False
         self.set_opacity(0)
+        self.hide()
 
     def _get_active(self):
         '''active property getter.'''
@@ -81,6 +83,7 @@
         self._visible = boolean
 
         if boolean:
+            self.show()
             self.timeline.set_direction(clutter.TIMELINE_FORWARD)
             self.timeline.rewind()
             self.timeline.start()
@@ -90,6 +93,11 @@
 
     visible = property(_get_visible, _set_visible)
 
+    def _on_timeline_completed(self, timeline):
+        """Hides the Tab on the end of the fade out animation."""
+        if timeline.get_direction() == clutter.TIMELINE_BACKWARD:
+            self.hide()
+
     def can_activate(self):
         '''
         Returns a boolean whether or not this tab can be activated. If tab
@@ -135,7 +143,7 @@
         '''Dummy method for unimplemented handlers in subclass.'''
         return False
 
-    def _handle_select(self):
+    def _handle_select(self, event=None):
         '''Dummy method for unimplemented handlers in subclass.'''
         return False
 
 
=== modified file 'entertainerlib/frontend/gui/tabs/tracks_tab.py'
--- entertainerlib/frontend/gui/tabs/tracks_tab.py	2009-05-14 03:22:31 +0000
+++ entertainerlib/frontend/gui/tabs/tracks_tab.py	2009-07-14 11:06:21 +0000
@@ -1,14 +1,14 @@
 # Copyright (c) 2009 Entertainer Developers - See COPYING - GPLv2
 '''Tracks tab for the artist screen'''
 
-import clutter
 import pango
 
 from entertainerlib.frontend.gui.tabs.tab import Tab
 from entertainerlib.frontend.gui.widgets.label import Label
 from entertainerlib.frontend.gui.widgets.list_indicator import ListIndicator
+from entertainerlib.frontend.gui.widgets.loading_animation import (
+    LoadingAnimation)
 from entertainerlib.frontend.gui.widgets.text_menu import TextMenu
-from entertainerlib.frontend.gui.widgets.text_menu_item import TextMenuItem
 
 class TracksTab(Tab):
     '''Tab for the artist screen to show track listings'''
@@ -17,31 +17,23 @@
         tab_title=_("Tracks")):
         Tab.__init__(self, name, tab_title, move_to_new_screen_callback)
 
-        self.menu = TextMenu(self.theme, self.config.show_effects())
-        self.menu.set_item_size(self.get_abs_x(0.2928), self.get_abs_y(0.0781))
-
-        cursor = clutter.Rectangle()
-        cursor.set_color((0, 0, 0, 0))
-        self.menu.set_cursor(cursor)
-
-        for track in tracks:
-            item = TextMenuItem(0.2928, 0.104, track.get_title())
-            item.justified = True
-            item.set_userdata(track)
-            self.menu.add_actor(item)
-
-        self.menu.set_orientation(TextMenu.HORIZONTAL)
-        self.menu.set_row_count(7)
-        self.menu.set_visible_column_count(3)
-        self.menu.set_position(self.get_abs_x(0.0586), self.get_abs_y(0.2083))
-        self.menu.set_active(False)
-        self.menu.show()
-
-        if self.config.show_effects():
-            self.menu.set_animate(True)
-
+        # Start the loading animation while the menu is loading
+        self.throbber = LoadingAnimation(0.1, 0.1)
+        self.throbber.show()
+        self.add(self.throbber)
+
+        self.menu = TextMenu(0.0586, 0.2083, 0.2928, 0.0781)
+        self.menu.items_per_row = 3
+        self.menu.visible_rows = 7
+        self.menu.visible_cols = 3
+        self.menu.active = False
+        self.menu.cursor = None
+        self.menu.items_anchor_west = False
         self.add(self.menu)
 
+        tracks_list = [[track.get_title(), None, track] for track in tracks]
+        self.menu.async_add_artists(tracks_list)
+
         self.track_title = Label(0.045, "title", 0.22, 0.79, "")
         self.track_title.set_ellipsize(pango.ELLIPSIZE_END)
         self.track_title.width = 0.366
@@ -56,78 +48,88 @@
         self.add(self.track_length)
 
         self.li = ListIndicator(0.77, 0.8, 0.18, 0.045,
-            ListIndicator.HORIZONTAL)
-        self.li.set_maximum(self.menu.get_number_of_items())
+            ListIndicator.VERTICAL)
+        self.li.set_maximum(len(tracks))
         self.li.show()
         self.add(self.li)
 
         self.connect('activated', self._on_activated)
         self.connect('deactivated', self._on_deactivated)
+        self.menu.connect("moved", self._update_track_info)
+        self.menu.connect("selected", self._handle_select)
+        self.menu.connect("activated", self._on_activated)
+        self.menu.connect("filled", self._on_menu_filled)
 
     def can_activate(self):
         '''Tracks tab will always be created from an existing artist with at
         least one track.'''
         return True
 
-    def _update_track_info(self):
+    def _update_track_info(self, event=None):
         '''Update the track information labels'''
         if self.active:
-            track = self.menu.get_current_menuitem().get_userdata()
+            track = self.menu.selected_userdata
             self.track_title.set_text(track.get_title())
             self.track_length.set_text(str(track.get_length() / 60) + ":" + \
                 str(track.get_length() % 60).zfill(2))
             self.track_number.set_text(_("Track %(track)s from %(album)s") % \
                 {'track': track.get_tracknumber(),
                 'album': track.get_album().get_title()})
+            self.li.show()
+            self.li.set_current(self.menu.selected_index + 1)
         else:
             self.track_title.set_text("")
             self.track_length.set_text("")
             self.track_number.set_text("")
-
-    def _update_menu(self, direction):
-        '''Update the menu based on the provided menu direction.'''
-        self.menu.move(direction)
-        self._update_track_info()
-        self.li.set_current(self.menu.get_current_position() + 1)
-        return False
+            self.li.hide()
 
     def _handle_up(self):
         '''Handle the up user event.'''
-        if self.menu.get_cursor_position()[1] == 0:
+        if self.menu.on_top:
             return True # Move control back to tab bar
         else:
-            return self._update_menu(self.menu.UP)
+            self.menu.up()
+            return False
 
     def _handle_down(self):
         '''Handle the down user event.'''
-        return self._update_menu(self.menu.DOWN)
+        self.menu.down()
+        return False
 
     def _handle_left(self):
         '''Handle the left user event.'''
-        return self._update_menu(self.menu.LEFT)
+        self.menu.left()
+        return False
 
     def _handle_right(self):
         '''Handle the right user event.'''
-        return self._update_menu(self.menu.RIGHT)
+        self.menu.right()
+        return False
 
-    def _handle_select(self):
+    def _handle_select(self, event=None):
         '''Handle the select user event.'''
-        track = self.menu.get_current_menuitem().get_userdata()
+        track = self.menu.selected_userdata
         kwargs = { 'track' : track }
         self.callback("audio_play", kwargs)
         return False
 
     def _on_activated(self, event=None):
         '''Tab activated.'''
+        if self.tab_group is not None:
+            self.tab_group.active = False
+        self.menu.active = True
+        self.active = True
         self._update_track_info()
-        self.menu.set_active(True)
-        self.menu.set_opacity(255)
         return False
 
     def _on_deactivated(self, event=None):
         '''Tab deactivated.'''
+        self.active = False
+        self.menu.active = False
         self._update_track_info()
-        self.menu.set_active(False)
-        self.menu.set_opacity(128)
         return False
 
+    def _on_menu_filled(self, event=None):
+        '''Handles filled event.'''
+        self.throbber.hide()
+
 
=== modified file 'entertainerlib/frontend/gui/tabs/video_clips_tab.py'
--- entertainerlib/frontend/gui/tabs/video_clips_tab.py	2009-05-14 03:22:31 +0000
+++ entertainerlib/frontend/gui/tabs/video_clips_tab.py	2009-07-14 11:06:21 +0000
@@ -3,15 +3,14 @@
 
 import os
 
-import gtk
 import pango
 
 from entertainerlib.frontend.gui.tabs.tab import Tab
 from entertainerlib.frontend.gui.widgets.image_menu import ImageMenu
-from entertainerlib.frontend.gui.widgets.image_menu_item import ImageMenuItem
 from entertainerlib.frontend.gui.widgets.label import Label
 from entertainerlib.frontend.gui.widgets.list_indicator import ListIndicator
-from entertainerlib.frontend.gui.widgets.rounded_texture import RoundedTexture
+from entertainerlib.frontend.gui.widgets.loading_animation import (
+    LoadingAnimation)
 
 class VideoClipsTab(Tab):
     """
@@ -35,7 +34,17 @@
         if self.video_library.get_number_of_video_clips() == 0:
             self._create_empty_library_notice()
         else:
-            self._create_menu()
+            # Start the loading animation while the menu is loading
+            self.throbber = LoadingAnimation(0.7, 0.1)
+            self.throbber.show()
+            self.add(self.throbber)
+
+            self.menu = self._create_menu()
+            self.add(self.menu)
+            self.menu.connect("moved", self._update_clip_info)
+            self.menu.connect("selected", self._handle_select)
+            self.menu.connect("activated", self._on_activated)
+            self.menu.connect("filled", self._on_menu_filled)
 
             self.connect('activated', self._on_activated)
             self.connect('deactivated', self._on_deactivated)
@@ -65,33 +74,19 @@
         Create a view that is displayed when there are indexed clips in
         the video library.
         """
-        self.menu = ImageMenu(self.theme)
-        self.menu.set_item_size(self.get_abs_x(0.233), self.get_abs_y(0.25))
-        self.menu.set_item_spacing(self.get_abs_y(0.025))
-        self.menu.set_visible_column_count(2)
-        self.menu.set_row_count(3)
-        self.menu.set_orientation(self.menu.VERTICAL)
+        menu = ImageMenu(0.04, 0.16, 0.23, self.y_for_x(0.23) * 0.7)
+        menu.items_per_col = 2
+        menu.visible_rows = 2
+        menu.visible_cols = 4
 
         clips = self.video_library.get_video_clips()
-        for clip in clips:
-            pix_buffer = gtk.gdk.pixbuf_new_from_file(clip.get_thumbnail_url())
-            texture = RoundedTexture(0.0, 0.0, 0.233, 0.25, pix_buffer)
-            item = ImageMenuItem(0.233, 0.5625, texture)
-            item.set_userdata(clip)
-            self.menu.add_actor(item)
-
-        self.menu.set_position(self.get_abs_x(0.15), self.get_abs_y(0.2))
-        self.menu.set_active(False)
-
-        if self.config.show_effects():
-            self.menu.set_animate(True)
-
-        self.add(self.menu)
+        clips_list = [[clip.get_thumbnail_url(), clip] for clip in clips]
+        menu.async_add_clips(clips_list)
 
         # Create list indicator
         self.list_indicator = ListIndicator(0.7, 0.8, 0.2, 0.045,
-            ListIndicator.VERTICAL)
-        self.list_indicator.set_maximum(self.menu.get_number_of_items())
+            ListIndicator.HORIZONTAL)
+        self.list_indicator.set_maximum(len(clips))
         self.list_indicator.show()
         self.add(self.list_indicator)
 
@@ -107,46 +102,48 @@
         self.clip_info.width = 0.5
         self.add(self.clip_info)
 
-    def _update_clip_info(self):
+        return menu
+
+    def _update_clip_info(self, event=None):
         '''Update the VideoClip information labels.'''
         if self.active:
-            clip = self.menu.get_current_menuitem().get_userdata()
+            clip = self.menu.selected_userdata
             (folder, filename) = os.path.split(clip.get_filename())
             self.clip_title.set_text(filename)
             self.clip_info.set_text(folder)
+            self.list_indicator.show()
+            self.list_indicator.set_current(self.menu.selected_index + 1)
         else:
             self.clip_title.set_text("")
             self.clip_info.set_text("")
-
-    def _update_menu(self, direction):
-        '''Update the menu based on the provided menu direction.'''
-        self.menu.move(direction)
-        self._update_clip_info()
-        self.list_indicator.set_current(self.menu.get_current_position() + 1)
-        return False
+            self.list_indicator.hide()
 
     def _handle_up(self):
         '''Handle the up user event.'''
-        if self.menu.get_current_position() <= 2:
+        if self.menu.on_top:
             return True # Move control back to tab bar
         else:
-            return self._update_menu(self.menu.UP)
+            self.menu.up()
+            return False
 
     def _handle_down(self):
         '''Handle the down user event.'''
-        return self._update_menu(self.menu.DOWN)
+        self.menu.down()
+        return False
 
     def _handle_left(self):
         '''Handle the left user event.'''
-        return self._update_menu(self.menu.LEFT)
+        self.menu.left()
+        return False
 
     def _handle_right(self):
         '''Handle the right user event.'''
-        return self._update_menu(self.menu.RIGHT)
+        self.menu.right()
+        return False
 
-    def _handle_select(self):
+    def _handle_select(self, event=None):
         '''Handle the select user event.'''
-        clip = self.menu.get_current_menuitem().get_userdata()
+        clip = self.menu.selected_userdata
         self.media_player.set_media(clip)
         self.media_player.play()
         self.callback("video_osd")
@@ -154,15 +151,21 @@
 
     def _on_activated(self, event=None):
         '''Tab activated.'''
+        if self.tab_group is not None:
+            self.tab_group.active = False
+        self.menu.active = True
+        self.active = True
         self._update_clip_info()
-        self.menu.set_active(True)
-        self.menu.set_opacity(255)
         return False
 
     def _on_deactivated(self, event=None):
         '''Tab deactivated.'''
+        self.active = False
+        self.menu.active = False
         self._update_clip_info()
-        self.menu.set_active(False)
-        self.menu.set_opacity(128)
         return False
 
+    def _on_menu_filled(self, event=None):
+        '''Handles filled event.'''
+        self.throbber.hide()
+
 
=== modified file 'entertainerlib/frontend/gui/widgets/base.py'
--- entertainerlib/frontend/gui/widgets/base.py	2009-04-28 22:30:06 +0000
+++ entertainerlib/frontend/gui/widgets/base.py	2009-05-24 14:28:19 +0000
@@ -21,3 +21,12 @@
         result = int(self.config.get_stage_height() * percentage)
         return result
 
+    def y_for_x(self, percentage):
+        """
+        Returns the percentage of stage height giving the same number of pixels
+        than `percentage` applied to the stage width.
+        """
+        stage_ratio = float(self.config.get_stage_width())
+        stage_ratio /= self.config.get_stage_height()
+        return stage_ratio * percentage
+
 
=== modified file 'entertainerlib/frontend/gui/widgets/grid_menu.py'
--- entertainerlib/frontend/gui/widgets/grid_menu.py	2009-05-10 06:24:43 +0000
+++ entertainerlib/frontend/gui/widgets/grid_menu.py	2009-05-28 19:12:05 +0000
@@ -1,672 +1,561 @@
 # Copyright (c) 2009 Entertainer Developers - See COPYING - GPLv2
-'''GridMenu contains a grid of textures and allows user to select one'''
+'''GridMenu contains a grid of MenuItem based widgets.'''
 
 import clutter
-
-class GridMenu(clutter.Group):
+import gobject
+import math
+
+from entertainerlib.frontend.gui.widgets.base import Base
+from entertainerlib.frontend.gui.widgets.motion_buffer import MotionBuffer
+
+class GridMenu(Base, clutter.Group):
     """
     GridMenu widget
-
-    This is a flexible menu widget that supports horizontal, vertical,
-    scrollable, multirow menus. Real menus should inherit this class
-    and override few methods.
     """
-
-    # Orientation constants
-    HORIZONTAL = 0
-    VERTICAL = 1
-
-    # Direction constants
-    UP = 2
-    DOWN = 3
-    LEFT = 4
-    RIGHT = 5
-
-    # Cursor placement (Is cursor drawn above or below of all menuitems)
-    BELOW = 6
-    ABOVE = 7
-
-    def __init__(self, orientation = 1): # Default orientation is VERTICAL
-        """
-        Initialize GridMenu widget
-        @param orientation: Orientation of the menu. Use class constatants.
-        """
+    __gsignals__ = {
+        'activated' : ( gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, () ),
+        'moved' : ( gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, () ),
+        'selected' : ( gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, () ),
+    }
+
+    MODE_NONE = 0
+    MODE_SELECT = 1
+    MODE_SEEK = 2
+
+    def __init__(self, x=0, y=0, item_width=200, item_height=100):
+        Base.__init__(self)
         clutter.Group.__init__(self)
 
-        self.itemgroup = clutter.Group()    # Group for menuitems
-        self.items = []                     # List of Menuitems
-        self.orientation = orientation      # Menu orientation
-        self.row_count = 1                  # Items per row
-        self.visible_cols = 8               # Number of visible columns
-        self.cell_height = 100              # Menuitem height
-        self.cell_width = 100               # Menuitem width
-        self.cell_spacing = 0               # Space between items
-        self.logical_position = 0           # Logical position (in item list)
-        self.cursor_position = (0, 0)        # Cursor position (on screen)
-        self.content_position = (0, 0)       # Content position
-        self.animate = False                # Should we animate this widget
-        self.cursor = None                  # Cursor (clutter.Actor)
-        self.cursor_placement = 7           # Cursor placement (Default: Above)
-        self.active = True                  # Is this menu active
-        self.content_timeline = None        # Content scroll timeline
-        self.cursor_timeline = None         # Cursor move timeline
-
-        self.add(self.itemgroup)
-
-        # Default red transparent cursor
-        c = clutter.Rectangle()
-        c.set_color((255, 0, 0, 128))
-        self.set_cursor(c)
-
-    def set_cursor(self, cursor):
-        """
-        Set cursor actor. This is usually a Texture or clutter.Rectangle.
-        @param cursor: clutter.Actor - Cursor graphics
-        """
-        # Remove old if exists
-        if self.cursor is not None:
-            self.remove(self.cursor)
-
-        # Set new cursor
-        self.cursor = cursor
-
-        # If widget is currently active display cursor
-        if self.active:
-            self.cursor.show()
-
-        self.add(self.cursor)
-        self.cursor.set_size(self.cell_width, self.cell_height)
-        self._scale_cursor()
-
-        # Set cursor placement
-        if self.cursor_placement == self.BELOW:
-            self.cursor.lower_bottom()
-        elif self.cursor_placement == self.ABOVE:
-            self.cursor.raise_top()
-
-    def set_cursor_placement(self, placement):
-        """
-        Set cursor placement. Is cursor drawn below or above of all menuitems.
-        @param placement: GridMenu.BELOW or GridMenu.ABOVE
-        """
-        self.cursor_placement = placement
-        if self.cursor_placement == self.BELOW:
-            self.cursor.lower_bottom()
-        elif self.cursor_placement == self.ABOVE:
-            self.cursor.raise_top()
-
-    def set_active(self, boolean):
-        """
-        Set menu widget to active / disabled. Please see API references of
-        the self._animate_items_on_state_change() method. It handels all actor
-        changes when menu widget state changes.
-        """
-        self.active = boolean
-        self._animate_items_on_state_change()
-
-    def is_active(self):
-        """
-        Is this menu active?
-        @return: True if menu is active, otherwise False
-        """
-        return self.active
-
-    def set_animate(self, boolean):
-        """
-        Enable/disable widget animation.
-        @param boolean: True if widget should be animated, otherwise False
-        """
-        self.animate = boolean
-
-    def add_actor(self, item):
-        """
-        Add menuitem to this menu.
-        @param item: clutter.Actor object
-        """
-        #item.set_size(self.cell_width, self.cell_height)
-        self._scale_menuitem(item)   # Scale item
-        self.items.append(item)      # Add to logical list
-        self.itemgroup.add(item)     # Add to menuitem group (visible list)
-        self._update_menuitem_position(item, len(self.items) - 1)
-
-        # Update cursor
-        if self.cursor_placement == self.BELOW:
-            self.cursor.lower_bottom()
-        elif self.cursor_placement == self.ABOVE:
-            self.cursor.raise_top()
-
-        # If this is a first item in the menu.
-        if len(self.items) == 1:
-            self._update_selected_item(0)
-            self.set_visible_column_count(self.visible_cols)
-
-    def remove_actor(self, item):
-        """
-        Remove menuitem from this menu.
-        @param item: clutter.Actor object
-        """
-        try:
-            self.items.remove(item)        # Remove from logical list
-            self.itemgroup.remove(item)    # Remove from visible list group
-            for i in range(len(self.items)):
-                self._update_menuitem_position(self.items[i], i)
-        except:
-            raise Exception("Couldn't remove menuitem. Item doesn't exist.")
-
-    def remove_all(self):
-        """
-        Remove all menuitems from this menu.
-        """
+        self.motion_duration = 100
+        self.cursor_below = True
+        self._active = None
+        self._is_vertical = True
+        self.items_anchor_west = False
         self.items = []
-        self.itemgroup.remove_all()
-
-    def select(self, logical_position):
-        '''Selects the item at the passed logical_position.'''
-        # pylint: disable-msg=W0612
-        target = (  int(logical_position / self.row_count),
-                    int(logical_position % self.row_count))
-
-        move_y = self.cursor_position[0] - target[0]
-        move_x = self.cursor_position[1] - target[1]
-
-        #Move Vertically
-        if move_y > 0:
-            for i in xrange(move_y):
-                self._move_cursor(self.UP)
-        else:
-            for i in xrange(-move_y):
-                self._move_cursor(self.DOWN)
-
-        #Move Horizontally
-        if move_x > 0:
-            for i in xrange(move_x):
-                self._move_cursor(self.RIGHT)
-        else:
-            for i in xrange(-move_x):
-                self._move_cursor(self.LEFT)
-
-    def get_n_children(self):
-        """
-        Override clutter.Group method. Returns number of menuitems.
-        """
-        return len(self.items)
-
-    def get_nth_child(self, index):
-        """
-        Override clutter.Group method. Returns one menuitem.
-        """
-        return self.items[index]
-
-    def get_number_of_items(self):
-        """
-        Get number of menuitems.
-        @return: Integer
-        """
-        return len(self.items)
-
-    def get_current_position(self):
-        """
-        Get logical position of the menu cursor.
-        """
-        return self.logical_position
-
-    def get_current_menuitem(self):
-        """
-        Get current menuitem. (Menuitem under menu cursor)
-        @return: clutter.Actor
-        """
-        return self.items[self.logical_position]
-
-    def get_cursor_position(self):
-        """
-        Get cursor position. This is a (x,y) coordinate of the cursor. Cursor
-        position is always in displayble area.
-        @return: (x,y) tuple
-        """
-        return self.cursor_position
-
-    def set_orientation(self, orientation):
-        """
-        Set widget orientation. This defines which way widget is scrolled when
-        all items don't fit into the widget area at the same time.
-        @param orientation: GridMenu.HORIZONTAL or GridMenu.VERTICAL
-        """
-        if orientation < 0 or orientation > 1:
-            raise Exception("Invalid orientation")
-        self.orientation = orientation
-        for i in range(len(self.items)):
-            self._update_menuitem_position(self.items[i], i)
-
-    def get_orientation(self):
-        """
-        Get menu orientation.
-        @return: GridMenu.VERTICAL or GridMenu.HORIZONTAL (Integer constant)
-        """
-        return self.orientation
-
-    def set_row_count(self, count):
-        """
-        Set how many items there should be on one row. Notice that row's
-        direction depends on widget's orientation. For example, 'normal menu'
-        would be VERTICAL with a row count 1.
-        @param count: Number of items per row
-        """
-        if count < 1:
-            raise Exception("Row count must be a positive value.")
-        self.row_count = count
-        for i in range(len(self.items)):
-            self._update_menuitem_position(self.items[i], i)
-
-    def get_row_count(self):
-        """
-        Get row count.
-        @return: Integer
-        """
-        return self.row_count
-
-    def set_visible_column_count(self, count):
-        """
-        Set how many columns are allowed to be visible at the same time. Column
-        direction depends on widget orientation. For example, if menu is
-        VERTICAL, row_count is 1 and visible columns is 8, then there are at
-        most 8 visible items which are scrolled vertically.
-        """
-        if count < 1:
-            raise Exception("Only positive values allowed!")
-        self.visible_cols = count
-
-        if self.orientation == self.VERTICAL:
-            w = (self.cell_width + self.cell_spacing) * self.row_count
-            h = count * (self.cell_height + self.cell_spacing)
-        else:
-            w = count * (self.cell_width + self.cell_spacing)
-            h = (self.cell_height + self.cell_spacing) * self.row_count
-
-        self.remove_clip()
-        #print "clip area: (width: " + str(w) + " and height: " + str(h)
-        self.set_clip(0, 0, w, h)
-
-    def get_visible_column_count(self):
-        """
-        Get the number of visible columns.
-        @return: Integer
-        """
-        return self.visible_cols
-
-    def set_item_spacing(self, space):
-        """
-        Set how many pixels should be left between menu items.
-        @param space: Item spacing in pixels (0 or higher)
-        """
-        if space < 0:
-            raise Exception("Spacing must be a positive integer.")
-        self.cell_spacing = space
-        for i in range(len(self.items)):
-            self._update_menuitem_position(self.items[i], i)
-
-    def set_item_height(self, height):
-        """
-        Set the height of the one cell in the grid.
-        @param height: Height in pixels (positive value)
-        """
-
-        if height < 1:
-            raise Exception("Height must be a positive value")
-
-        self.cell_height = height
-
-        # Update cursor
-        self._scale_cursor()
-
-        # Update menuitems
-        for item in self.items:
-            self._scale_menuitem(item)
-        for i in range(len(self.items)):
-            self._update_menuitem_position(self.items[i], i)
-
-    def set_item_width(self, width):
-        """
-        Set the width of the one cell in the grid.
-        @param height: Width in pixels (positive value)
-        """
-        if width < 1:
-            raise Exception("Width must be a positive value")
-
-        self.cell_width = width
-
-        # Update cursor
-        self._scale_cursor()
-
-        # Update menuitems
-        for item in self.items:
-            self._scale_menuitem(item)
-        for i in range(len(self.items)):
-            self._update_menuitem_position(self.items[i], i)
-
-    def set_item_size(self, width, height):
-        """
-        Set the width of the one cell in the grid.
-        @param height: Width in pixels (positive value)
-        """
-        if width < 1 or height < 1 :
-            raise Exception("Width and height must be positive values!")
-
-        self.cell_width = width
-        self.cell_height = height
-
-        # Update clipping
-        #self.set_visible_column_count(self.visible_cols)
-
-        # Update cursor
-        self._scale_cursor()
-
-        # Update menuitems
-        for item in self.items:
-            self._scale_menuitem(item)
-        for i in range(len(self.items)):
-            self._update_menuitem_position(self.items[i], i)
-
-    def move(self, direction):
-        """
-        Move to given direction. Cursor is moved or grid content is scrolled if
-        needed.
-        @param direction: GridMenu class variables (UP, DOWN, LEFT, RIGHT)
-        """
-        if not self._is_move_legal(direction):
-            return
-
-        # Current position of the content and cursor
-        cur_x, cur_y = self.cursor_position
-        con_x, con_y = self.content_position
-
-        # Define limit value for cursor and content move
-        max_row = len(self.items) / self.row_count
-        if (len(self.items) % self.row_count) != 0:
-            max_row = max_row + 1
-
-        content_scroll_max = max_row - self.visible_cols
-
-        if self.visible_cols > max_row:
-            # There are less rows than allowed to be visible at the same time
-            cursor_scroll_max = max_row - 1
-        else:
-            cursor_scroll_max = self.visible_cols - 1
-
-        # Menu has a vertical orientation
-        if self.orientation == self.VERTICAL:
-            if direction == self.UP:
-                if cur_y == 0:
-                    if con_y > 0:
-                        self._move_content(1, self.DOWN)
-                else:
-                    self._move_cursor(self.UP)
-            elif direction == self.DOWN:
-                if cur_y < cursor_scroll_max:
-                    self._move_cursor(self.DOWN)
-                else:
-                    if con_y < content_scroll_max:
-                        self._move_content(1, self.UP)
-            elif direction == self.LEFT:
-                if cur_x > 0:
-                    self._move_cursor(self.LEFT)
-            elif direction == self.RIGHT:
-                if cur_x < self.row_count - 1:
-                    self._move_cursor(self.RIGHT)
-
-        # Menu has a horizontal orientation
-        else:
-            if direction == self.UP:
-                if cur_y > 0:
-                    self._move_cursor(self.UP)
-            elif direction == self.DOWN:
-                if cur_y < self.row_count - 1:
-                    self._move_cursor(self.DOWN)
-            elif direction == self.LEFT:
-                if cur_x == 0:
-                    if con_x > 0:
-                        self._move_content(1, self.RIGHT)
-                else:
-                    self._move_cursor(self.LEFT)
-            elif direction == self.RIGHT:
-                if cur_x < cursor_scroll_max:
-                    self._move_cursor(self.RIGHT)
-                else:
-                    if con_x < content_scroll_max:
-                        self._move_content(1, self.LEFT)
-
-        old_position = self.logical_position
-
-        # Calculate logical position
-        if self.orientation == self.VERTICAL:
-            tmp = (self.cursor_position[1] +
-                self.content_position[1]) * self.row_count
-            self.logical_position = tmp + self.cursor_position[0]
-        else:
-            tmp = (self.cursor_position[0] +
-                self.content_position[0]) * self.row_count
-            self.logical_position = tmp + self.cursor_position[1]
-
-        self._update_selected_item(self.logical_position, old_position)
-
-    def _is_move_legal(self, direction):
-        """
-        Check if move is legal. This prevents cursor from leaving menu items.
-        This could happen when grid's last row is not "full".
-        @param direction: GridMenu class variables (UP, DOWN, LEFT, RIGHT)
-        @return: True if move can be executed, otherwise False
-        """
-        # If last row is "full" we can't go wrong
-        if len(self.items) % self.row_count == 0:
-            return True
-
-        # -1 because rows start from 0
-        last_full_row = len(self.items) / self.row_count -1
-        items_on_last_row = len(self.items) % self.row_count
-
-        # Checking for vertical menu
-        if self.orientation == self.VERTICAL:
-            current_row = self.cursor_position[1] + self.content_position[1]
-            if current_row == last_full_row and direction == self.DOWN:
-                if self.cursor_position[0] + 1 > items_on_last_row:
-                    return False
-            if current_row == last_full_row + 1 and direction == self.RIGHT:
-                if self.logical_position == len(self.items) - 1:
-                    return False
-        # Checking for horizontal menu
-        else:
-            current_row = self.cursor_position[0] + self.content_position[0]
-            if current_row == last_full_row and direction == self.RIGHT:
-                if self.cursor_position[1] + 1 > items_on_last_row:
-                    return False
-            if current_row == last_full_row + 1 and direction == self.DOWN:
-                if self.logical_position == len(self.items) - 1:
-                    return False
-        return True
-
-    def _move_cursor(self, direction):
-        """
-        Move cursor on grid.
-        """
-        # Change logical position
-        x, y = self.cursor_position
-        if direction == self.UP:
-            self.cursor_position = (x, y-1)
-        elif direction == self.DOWN:
-            self.cursor_position = (x, y+1)
-        elif direction == self.LEFT:
-            self.cursor_position = (x-1, y)
-        elif direction == self.RIGHT:
-            self.cursor_position = (x+1, y)
-
-        # Change cursor texture position
-        x_offset = self.cell_width + self.cell_spacing
-        y_offset = self.cell_height + self.cell_spacing
-
-        # BELOW IS ANIMATION CODE FOR MENU CURSOR. SHOULD CURSOR BE ANIMATED?
-#        if self.animate:
-#            # Finish previous animation before new
-#            if self.cursor_timeline is not None and (
-#               self.cursor_timeline.is_playing():
-#                self.cursor_timeline.pause()
-#                self.cursor_timeline.advance(4)
-#
-#            self.cursor_timeline = clutter.Timeline(4, 26)
-#            alpha = clutter.Alpha(self.cursor_timeline, clutter.ramp_inc_func)
-#
-#            x = self.cursor.get_x()
-#            y = self.cursor.get_y()
-#            if direction == self.UP:
-#                behaviour = clutter.BehaviourPath(alpha,
-#                                                  ((x,y),
-#                                                   (x,y - y_offset)))
-#            elif direction == self.DOWN:
-#                behaviour = clutter.BehaviourPath(alpha,
-#                                                  ((x,y),
-#                                                   (x,y + y_offset)))
-#            elif direction == self.RIGHT:
-#                behaviour = clutter.BehaviourPath(alpha,
-#                                                  ((x,y),
-#                                                   (x + x_offset,y)))
-#            elif direction == self.LEFT:
-#                behaviour = clutter.BehaviourPath(alpha,
-#                                                  ((x,y),
-#                                                   (x - x_offset,y)))
-#            behaviour.apply(self.cursor)
-#            self.cursor_timeline.start()
-#        else:
-        if direction == self.UP:
-            self.cursor.move_by(0, -y_offset)
-        elif direction == self.DOWN:
-            self.cursor.move_by(0, y_offset)
-        elif direction == self.LEFT:
-            self.cursor.move_by(-x_offset, 0)
-        elif direction == self.RIGHT:
-            self.cursor.move_by(x_offset, 0)
-
-    def _move_content(self, count, direction):
-        """
-        Move menuitems to given direction.
-        @param count: How much we scroll (number of menuitems)
-        @param direction: Which direction we scroll (See class constants)
-        """
-        # Change logical position
-        x, y = self.content_position
-        if direction == self.UP:
-            self.content_position = (x, y+1)
-        elif direction == self.DOWN:
-            self.content_position = (x, y-1)
-        elif direction == self.LEFT:
-            self.content_position = (x+1, y)
-        elif direction == self.RIGHT:
-            self.content_position = (x-1, y)
-
-        x_offset = count * (self.cell_width + self.cell_spacing)
-        y_offset = count * (self.cell_height + self.cell_spacing)
-#        if self.animate:
-#            x = self.itemgroup.get_x()
-#            y = self.itemgroup.get_y()
-#
-#            # Finish previous animation before new
-#            if self.content_timeline is not None and (
-#               self.content_timeline.is_playing():
-#                self.content_timeline.pause()
-#                self.content_timeline.advance(4)
-#
-#            self.content_timeline = clutter.Timeline(4, 26)
-#            alpha = clutter.Alpha(self.content_timeline,
-#                clutter.ramp_inc_func)
-#            if direction == self.UP:
-#                behaviour = clutter.BehaviourPath(alpha,
-#                                                  ((x,y),
-#                                                   (x,y - y_offset)))
-#            elif direction == self.DOWN:
-#                behaviour = clutter.BehaviourPath(alpha,
-#                                                  ((x,y),
-#                                                   (x,y + y_offset)))
-#            elif direction == self.RIGHT:
-#                behaviour = clutter.BehaviourPath(alpha,
-#                                                  ((x,y),
-#                                                   (x + x_offset,y)))
-#            elif direction == self.LEFT:
-#                behaviour = clutter.BehaviourPath(alpha,
-#                                                  ((x,y),
-#                                                   (x - x_offset,y)))
-#            behaviour.apply(self.itemgroup)
-#            self.content_timeline.start()
-#        else:
-        if direction == self.UP:
-            self.itemgroup.move_by(0, -y_offset)
-        elif direction == self.DOWN:
-            self.itemgroup.move_by(0, y_offset)
-        elif direction == self.RIGHT:
-            self.itemgroup.move_by(x_offset, 0)
-        elif direction == self.LEFT:
-            self.itemgroup.move_by(-x_offset, 0)
-
-    def _scale_menuitem(self, menuitem):
-        """
-        Scale menuitem to fit into one cell. Preserves actor's aspect ratio.
-        @param menuitem: clutter.Actor
-        """
-        w, h = menuitem.get_size()
-
-        if w == self.cell_width and h == self.cell_height:
-            return # Already correct size, no scale needed
-
-        x_ratio = self.cell_width / float(w)
-        y_ratio = self.cell_height / float(h)
-        if x_ratio > y_ratio:
-            menuitem.set_scale(self.cell_height /float(h),
-                               self.cell_height / float(h))
-        else:
-            menuitem.set_scale(self.cell_width / float(w),
-                               self.cell_width / float(w))
-
-    def _scale_cursor(self):
-        """
-        Scale cursor. Override this method if you want to use cursor that is
-        smaller or larger than menuitem. This default implementation scales
-        cursor into the size of cell of the grid. Aspect ratio is not
-        preserved!
-        """
-        x_ratio = self.cell_width / float(self.cursor.get_width())
-        y_ratio = self.cell_height / float(self.cursor.get_height())
-        self.cursor.set_scale(x_ratio, y_ratio)
-
-    def _update_menuitem_position(self, menuitem, logical_position):
-        """
-        Recalculate menuitem's position.
-        @param menuitem: Menuitem that is repositioned (clutter.Actor)
-        @param logical_position: Logical position of the menuitem
-        """
-        if logical_position == 0:
-            x = 0
-            y = 0
-        else:
-            row = (logical_position / self.row_count) # Item's row
-            col = logical_position % self.row_count   # Item's column
-            if self.orientation == self.VERTICAL:
-                x = col * (self.cell_width + self.cell_spacing)
-                y = row * (self.cell_height + self.cell_spacing)
-            elif self.orientation == self.HORIZONTAL:
-                y = col * (self.cell_height + self.cell_spacing)
-                x = row * (self.cell_width + self.cell_spacing)
-        menuitem.set_position(x, y)
-
-    def _update_selected_item(self, new_location, old_location=None):
-        """
-        This method allows to modify currently selected item. This can be
-        overriden in inherited widgets.
-        @param new_location: Logical location of current menuitem
-        @param old_location: Logical location of last menuitem
-        """
-        pass
-
-    def _animate_items_on_state_change(self):
-        """
-        This method is called when widget is set active or inactive. The method
-        allows widget to react this action. Method should be overriden in
-        inheriting classes. Default implementation doesn't do anything.
-        """
-        pass
+
+        self._item_width = item_width
+        self._item_height = item_height
+        self._item_width_abs = self.get_abs_x(item_width)
+        self._item_height_abs = self.get_abs_y(item_height)
+        self._dx = int(self._item_width_abs / 2)
+        self._dy = int(self._item_height_abs / 2)
+
+        self._selected_index = 0
+        self.items_per_row = 10
+        self.items_per_col = 10
+        self._visible_rows = 3
+        self._visible_cols = 5
+
+        self._moving_group_x = 0
+        self._moving_group_y = 0
+        self._moving_group = clutter.Group()
+        self.add(self._moving_group)
+
+        self._moving_group_timeline = clutter.Timeline(fps=200, duration=200)
+        moving_group_alpha = clutter.Alpha(self._moving_group_timeline,
+            clutter.smoothstep_inc_func)
+        self._moving_group_behaviour = clutter.BehaviourPath(moving_group_alpha)
+        self._moving_group_behaviour.apply(self._moving_group)
+
+        self._cursor_x = 0
+        self._cursor_y = 0
+        self._cursor = None
+        self._cursor_timeline = clutter.Timeline(fps=200, duration=200)
+        cursor_alpha = clutter.Alpha(self._cursor_timeline,
+            clutter.sine_inc_func)
+        self._cursor_behaviour = clutter.BehaviourPath(cursor_alpha)
+
+        self._event_rect = clutter.Rectangle()
+        self._event_rect.set_opacity(0)
+        self._event_rect.set_color(clutter.color_parse('Orange'))
+        self.add(self._event_rect)
+
+        self._motion_buffer = MotionBuffer()
+        self._event_mode = self.MODE_NONE
+        self._motion_handler = 0
+        self._seek_step_x = 0
+        self._seek_step_y = 0
+        gobject.timeout_add(200, self._internal_timer_callback)
+
+        #XXX: Samuel Buffet
+        # This rectangle is used to grab events as it turns out that their
+        # might be a bug in clutter 0.8 or python-clutter 0.8.
+        # It may be avoided with next release of clutter.
+        self._event_rect.set_reactive(True)
+        self._event_rect.connect('button-press-event',
+            self._on_button_press_event)
+        self._event_rect.connect('button-release-event',
+            self._on_button_release_event)
+        self._event_rect.connect('scroll-event', self._on_scroll_event)
+
+        self.set_position(self.get_abs_x(x), self.get_abs_y(y))
+
+    @property
+    def count(self):
+        """Return the number of items."""
+        return len(self.items)
+
+    @property
+    def on_top(self):
+        """Return True if the selected item is currently on the top."""
+        selected_row = self._index_to_xy(self._selected_index)[1]
+        if selected_row == 0:
+            return True
+        else:
+            return False
+
+    @property
+    def on_bottom(self):
+        """Return True if the selected item is currently on the bottom."""
+        selected_row = self._index_to_xy(self._selected_index)[1]
+        end_row = self._index_to_xy(self.count - 1)[1]
+        if self._is_vertical:
+            if selected_row == end_row:
+                return True
+            else:
+                return False
+        else:
+            if selected_row == self.items_per_col - 1:
+                return True
+            else:
+                return False
+
+    @property
+    def on_left(self):
+        """Return True if the selected item is currently on the left."""
+        selected_col = self._index_to_xy(self._selected_index)[0]
+        if selected_col == 0:
+            return True
+        else:
+            return False
+
+    @property
+    def on_right(self):
+        """Return True if the selected item is currently on the right."""
+        selected_col = self._index_to_xy(self._selected_index)[0]
+        end_col = self._index_to_xy(self.count - 1)[0]
+        if not self._is_vertical:
+            if selected_col == end_col:
+                return True
+            else:
+                return False
+        else:
+            if selected_col == self.items_per_row - 1:
+                return True
+            else:
+                return False
+
+    @property
+    def selected_item(self):
+        """Return the selected MenuItem."""
+        if self.count == 0:
+            return None
+        else:
+            return self.items[self._selected_index]
+
+    @property
+    def selected_userdata(self):
+        """Return userdata of the MenuItem."""
+        item = self.selected_item
+        if item is None:
+            return None
+        else:
+            return item.userdata
+
+    def _get_active(self):
+        """Active property getter."""
+        return self._active
+
+    def _set_active(self, boolean):
+        """Active property setter."""
+        if self._active == boolean:
+            return
+
+        self._active = boolean
+        if boolean:
+            if self._cursor is not None:
+                self._cursor.show()
+            if  self.selected_item is not None:
+                self.selected_item.animate_in()
+            self.emit('activated')
+            self.set_opacity(255)
+        else:
+            if self._cursor is not None:
+                self._cursor.hide()
+            if  self.selected_item is not None:
+                self.selected_item.animate_out()
+            self.set_opacity(128)
+
+    active = property(_get_active, _set_active)
+
+    def _get_horizontal(self):
+        """horizontal property getter."""
+        return not self._is_vertical
+
+    def _set_horizontal(self, boolean):
+        """horizontal property setter."""
+        self._is_vertical = not boolean
+
+    horizontal = property(_get_horizontal, _set_horizontal)
+
+    def _get_vertical(self):
+        """vertical property getter."""
+        return self._is_vertical
+
+    def _set_vertical(self, boolean):
+        """vertical property setter."""
+        self._is_vertical = boolean
+
+    vertical = property(_get_vertical, _set_vertical)
+
+    def _get_selected_index(self):
+        """selected_index property getter."""
+        return self._selected_index
+
+    def _set_selected_index(self, index, duration=None):
+        """selected_index property setter."""
+        # Xc, Yc : coordinates of the cursor relatively to the moving group.
+        # xc, yc : coordinates of the cursor relatively to the menu.
+        # xm, ym : coordinates of the moving_group relatively to the menu.
+        # Xc = xc - xm
+        # Yc = yc - ym
+
+        if self._selected_index == index or \
+           index < 0 or \
+           index > self.count - 1 or \
+           self._moving_group_timeline.is_playing() or \
+           self._cursor_timeline.is_playing():
+            return
+
+        #start select/unselect animations on both items
+        self.items[self._selected_index].animate_out()
+        self.items[index].animate_in()
+
+        (Xc, Yc) = self._index_to_xy(index)
+
+        xm = self._moving_group_x
+        ym = self._moving_group_y
+
+        xc = Xc + xm
+        yc = Yc + ym
+
+        if xc == self.visible_cols - 1 and \
+            xm > self.visible_cols -self.items_per_row:
+            xc -= 1
+            xm -= 1
+
+        if xc == 0 and xm < 0:
+            xc += 1
+            xm += 1
+
+        if yc == self.visible_rows - 1 and \
+            ym > self.visible_rows -self.items_per_col:
+            yc -= 1
+            ym -= 1
+
+        if yc == 0 and ym < 0:
+            yc += 1
+            ym += 1
+
+        if duration is None:
+            duration = self.motion_duration
+
+        self._move_cursor(xc, yc, duration)
+        self._move_moving_group(xm, ym, duration)
+        self._selected_index = index
+
+        self.emit('moved')
+
+    selected_index = property(_get_selected_index, _set_selected_index)
+
+    def _get_visible_rows(self):
+        """visible_rows property getter."""
+        return self._visible_rows
+
+    def _set_visible_rows(self, visible_rows):
+        """visible_rows property setter."""
+        self._visible_rows = visible_rows
+        self._clip()
+
+    visible_rows = property(_get_visible_rows, _set_visible_rows)
+
+    def _get_visible_cols(self):
+        """visible_cols property getter."""
+        return self._visible_cols
+
+    def _set_visible_cols(self, visible_cols):
+        """visible_cols property setter."""
+        self._visible_cols = visible_cols
+        self._clip()
+
+    visible_cols = property(_get_visible_cols, _set_visible_cols)
+
+    def _get_cursor(self):
+        """cursor property getter."""
+        return self._cursor
+
+    def _set_cursor(self, cursor):
+        """cursor property setter."""
+        if self._cursor is not None:
+            self.remove(self._cursor)
+
+        self._cursor = cursor
+
+        if self._cursor is not None:
+            self.add(self._cursor)
+            if self._active:
+                self._cursor.show()
+            else:
+                self._cursor.hide()
+
+            if self.cursor_below:
+                self._cursor.lower_bottom()
+            else:
+                self._cursor.raise_top()
+
+            self._cursor.set_size(int(self._item_width_abs),
+                int(self._item_height_abs))
+            self._cursor.set_anchor_point(self._dx, self._dy)
+            self._cursor.set_position(self._dx, self._dy)
+
+            self._cursor_behaviour.apply(self._cursor)
+
+    cursor = property(_get_cursor, _set_cursor)
+
+    def _clip(self):
+        """Updates the clipping region."""
+        self.set_clip(0, 0, self._visible_cols * self._item_width_abs,
+            self._visible_rows * self._item_height_abs)
+
+        self._event_rect.set_size(self._visible_cols * self._item_width_abs,
+            self._visible_rows * self._item_height_abs)
+
+    def raw_add_item(self, item):
+        """Add an item."""
+        self._moving_group.add(item)
+        self.items.append(item)
+
+        (x, y) = self._index_to_xy(self.count - 1)
+
+        if self.items_anchor_west:
+            item.set_position(x * self._item_width_abs,
+                y * self._item_height_abs + self._dy)
+        else:
+            item.move_anchor_point(self._dx, self._dy)
+            item.set_position(x * self._item_width_abs + self._dx,
+                y * self._item_height_abs + self._dy)
+
+        if self._is_vertical:
+            self.items_per_col = y + 1
+        else:
+            self.items_per_row = x + 1
+
+        if self.cursor_below:
+            item.raise_top()
+        else:
+            item.lower_bottom()
+
+    def _index_to_xy(self, index):
+        """Return the coordinates of an element associated to its index."""
+        if self._is_vertical:
+            r = index / float(self.items_per_row)
+            y = int(math.modf(r)[1])
+            x = int(index - y * self.items_per_row)
+        else:
+            r = index / float(self.items_per_col)
+            x = int(math.modf(r)[1])
+            y = int(index - x * self.items_per_col)
+
+        return (x, y)
+
+    def _move_moving_group(self, x, y, duration):
+        """Moves the moving_group to x, y coordinates."""
+        if (x, y) == (self._moving_group_x, self._moving_group_y):
+            return
+
+        self._moving_group_behaviour.clear()
+
+        start_knot = (self._moving_group_x * self._item_width_abs,
+            self._moving_group_y * self._item_height_abs)
+        stop_knot = (x * self._item_width_abs,
+            y * self._item_height_abs)
+
+        self._moving_group_behaviour.append_knots(start_knot, stop_knot)
+
+        self._moving_group_x, self._moving_group_y = x, y
+        self._moving_group_timeline.set_duration(duration)
+        self._moving_group_timeline.start()
+
+    def _move_cursor(self, x, y, duration):
+        """
+        Moves the cursor to x, y coordinates.
+        The motion is applied to the center of the cursor.
+        """
+        if (x, y) == (self._cursor_x, self._cursor_y):
+            return
+
+        self._cursor_behaviour.clear()
+
+        start_knot = (self._cursor_x * self._item_width_abs + self._dx,
+            self._cursor_y * self._item_height_abs + self._dy)
+        stop_knot = (x * self._item_width_abs + self._dx,
+            y * self._item_height_abs + self._dy)
+
+        self._cursor_behaviour.append_knots(start_knot, stop_knot)
+
+        self._cursor_x, self._cursor_y = x, y
+        self._cursor_timeline.set_duration(duration)
+        self._cursor_timeline.start()
+
+    def up(self):
+        """Move up."""
+        if not self.on_top:
+            if self._is_vertical:
+                self.selected_index -= self.items_per_row
+            else:
+                self.selected_index -= 1
+
+    def down(self):
+        """Move down."""
+        if not self.on_bottom:
+            if self._is_vertical:
+                self.selected_index += self.items_per_row
+            else:
+                self.selected_index += 1
+
+    def right(self):
+        """Move right."""
+        if not self.on_right:
+            if self._is_vertical:
+                self.selected_index += 1
+            else:
+                self.selected_index += self.items_per_col
+
+    def left(self):
+        """Move left."""
+        if not self.on_left:
+            if self._is_vertical:
+                self.selected_index -= 1
+            else:
+                self.selected_index -= self.items_per_col
+
+    def _internal_timer_callback(self):
+        """
+        This callback is used to move the cursor if the SEEK mode is activated.
+        """
+        if self._event_mode == self.MODE_SEEK:
+            if self._seek_step_x == 1:
+                self.right()
+            if self._seek_step_x == -1:
+                self.left()
+            if self._seek_step_y == 1:
+                self.down()
+            if self._seek_step_y == -1:
+                self.up()
+
+        return True
+
+    def _on_button_press_event(self, actor, event):
+        """button-press-event handler."""
+        clutter.grab_pointer(self._event_rect)
+        if not self._event_rect.handler_is_connected(self._motion_handler):
+            self._motion_handler = self._event_rect.connect('motion-event',
+            self._on_motion_event)
+
+        (x_menu, y_menu) = self.get_transformed_position()
+        (x_moving_group, y_moving_group) = self._moving_group.get_position()
+
+        # Events coordinates are relative to the stage.
+        # So they need to be computed relatively to the moving group.
+        x = event.x - x_menu - x_moving_group
+        y = event.y - y_menu - y_moving_group
+
+        x_grid = int(x / self._item_width_abs)
+        y_grid = int(y / self._item_height_abs)
+
+        if self._is_vertical:
+            new_index = y_grid * self.items_per_row + x_grid
+        else:
+            new_index = x_grid * self.items_per_col + y_grid
+
+        (delta_x, delta_y) = self._index_to_xy(self._selected_index)
+
+        delta_x -= x_grid
+        delta_y -= y_grid
+
+        # Correction factor due to the fact that items are not necessary square,
+        # but most probably rectangles. So the distance in the grid coordinates
+        # must be corrected by a factor to have a real distance in pixels on the
+        # screen.
+        correction = float(self._item_width_abs) / float(self._item_height_abs)
+        correction *= correction
+        distance = math.sqrt(delta_x ** 2 * correction + delta_y ** 2)
+
+        # Computation of the duration of animations, scaling pixels to ms.
+        duration = int(distance * 50)
+
+        if self.selected_index == new_index and \
+            self.active and \
+            not self._cursor_timeline.is_playing() and \
+            not self._moving_group_timeline.is_playing():
+            self._event_mode = self.MODE_SELECT
+        else:
+            self.active = True
+            self._event_mode = self.MODE_NONE
+
+        self._set_selected_index(new_index, duration)
+
+        self._motion_buffer.start(event)
+
+        return False
+
+    def _on_button_release_event(self, actor, event):
+        """button-release-event handler."""
+        clutter.ungrab_pointer()
+        if self._event_rect.handler_is_connected(self._motion_handler):
+            self._event_rect.disconnect_by_func(self._on_motion_event)
+
+        if self._event_mode == self.MODE_SELECT:
+            self.emit('selected')
+
+        self._event_mode = self.MODE_NONE
+
+        return True
+
+    def _on_motion_event(self, actor, event):
+        """motion-event handler"""
+        # threshold in pixels = the minimum distance we have to move before we
+        # consider a motion has started
+        motion_threshold = 20
+
+        self._seek_step_x = 0
+        self._seek_step_y = 0
+        self._motion_buffer.compute_from_start(event)
+        self._motion_buffer.compute_from_last_motion_event(event)
+
+        if self._motion_buffer.distance_from_start > motion_threshold:
+            self._event_mode = self.MODE_SEEK
+            self._motion_buffer.take_new_motion_event(event)
+            dx = self._motion_buffer.dx_from_last_motion_event
+            dy = self._motion_buffer.dy_from_last_motion_event
+
+            if math.fabs(dx) > math.fabs(dy):
+                self._seek_step_x = dx > 0 and 1 or -1
+            else:
+                self._seek_step_y = dy > 0 and 1 or -1
+
+        return False
+
+    def _on_scroll_event(self, actor, event):
+        """scroll-event handler (mouse's wheel)."""
+        if not self.active:
+            self.active = True
+            return
+
+        if event.direction == clutter.SCROLL_DOWN:
+            self.down()
+        else:
+            self.up()
+
+        return False
 
 
=== modified file 'entertainerlib/frontend/gui/widgets/image_menu.py'
--- entertainerlib/frontend/gui/widgets/image_menu.py	2009-05-06 03:40:22 +0000
+++ entertainerlib/frontend/gui/widgets/image_menu.py	2009-07-13 18:31:36 +0000
@@ -2,88 +2,160 @@
 '''Implements a grid menu that contains images'''
 
 import clutter
+import gtk
+import gobject
 
 from entertainerlib.frontend.gui.widgets.grid_menu import GridMenu
-from entertainerlib.utils.configuration import Configuration
+from entertainerlib.frontend.gui.widgets.menu_item import MenuItem
+from entertainerlib.frontend.gui.widgets.rounded_texture import RoundedTexture
+from entertainerlib.frontend.gui.widgets.texture import Texture
+
+class ImageMenuItem(MenuItem):
+    """A menuitem widget that contains a Texture."""
+
+    def __init__(self, width, height, texture):
+        MenuItem.__init__(self)
+
+        item_width = self.get_abs_x(width)
+        item_height = self.get_abs_y(height)
+
+        self.original_ratio = float(texture.get_width())
+        self.original_ratio /= texture.get_height()
+        item_ratio = float(item_width) / float(item_height)
+
+        margin = 0.95
+
+        if item_ratio >= self.original_ratio:
+            texture_width = self.original_ratio * item_height
+            texture_height = item_height
+            texture_width *= margin
+            texture_height *= margin
+            delta_width = item_width - texture_width
+            delta_height = item_height - texture_height
+        else:
+            texture_width = item_width
+            texture_height = item_width / self.original_ratio
+            texture_width *= margin
+            texture_height *= margin
+            delta_width = item_width - texture_width
+            delta_height = item_height - texture_height
+
+        item_x = delta_width / 2.0
+        item_y = delta_height / 2.0
+
+        texture.set_position(int(item_x), int(item_y))
+        texture.set_size(int(texture_width), int(texture_height))
+
+        self.add(texture)
+
 
 class ImageMenu(GridMenu):
-    """
-    ImageMenu widget
-
-    This widget inherits genral GridMenu widget and implements simple
-    imagemenu.
-    """
-
-    def __init__(self, theme):
-        """Initialize widget"""
-        GridMenu.__init__(self, self.HORIZONTAL)
-
-        #XXX: Joshua: This is to make sure the spaces in an image menu are the
-        #right size when the screen is not the default size of 1366x768
-        #This should eventually be replaced by proportional resizing.
-        config = Configuration()
-
-        width_ratio = config.get_stage_width() / 1366.0
-        height_ratio = config.get_stage_height() / 768.0
-
-        self.set_item_size(int(200 * width_ratio), int(150 * height_ratio))
-
-        #End of temporary code
-
-        self.set_row_count(3)
+    """A grid menu that contains images."""
+    __gsignals__ = {
+        'filled' : ( gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, () ),
+    }
+
+    def __init__(self, x=0, y=0, item_width=200, item_height=100):
+        GridMenu.__init__(self, x, y, item_width, item_height)
+
+        self.cursor_below = False
+        self.horizontal = True
+        self.items_per_col = 4
+        self.visible_rows = 3
+        self.visible_cols = 5
 
         c = clutter.Rectangle()
+        c.set_size(100, 100)
         c.set_color((255, 255, 255, 128))
-        self.set_cursor(c)
-
-    def set_animate(self, boolean):
-        """
-        Enable/disable widget animation.
-        @param boolean: True if widget should be animated, otherwise False
-        """
-        self.animate = boolean
-        #self.cursor.animate(boolean)
-
-    def _update_selected_item(self, new_location, old_location=None):
-        """
-        Overridden method! See GridMenu API reference.
-        @param new_location: Logical location of current menuitem
-        @param old_location: Logical location of last menuitem
-        """
-        if old_location is not None:
-            self.items[old_location].set_active(False)
-        self.items[new_location].set_active(True)
-
-    def _animate_items_on_state_change(self):
-        """
-        This method is called when widget is set active or inactive. This
-        method allows widget to react this action.
-        """
-        if len(self.items):
-            if self.active:
-                self.cursor.show()
-                self.items[self.logical_position].set_active(True)
-                self.set_opacity(255)
-            else:
-                self.cursor.hide()
-                self.items[self.logical_position].set_active(False)
-                self.set_opacity(128)
-
-    def _scale_menuitem(self, menuitem):
-        """
-        Scale menuitem to fit into one cell. Preserves actor's aspect ratio.
-        @param menuitem: clutter.Actor
-        """
-#        w, h = menuitem.get_size()
-#
-#        if w == self.cell_width and h == self.cell_height:
-#            return # Already correct size, no scale needed
-#
-#        x_ratio = self.cell_width / float(w)
-#        y_ratio = self.cell_height / float(h)
-#        if x_ratio > y_ratio:
-#            menuitem.set_scale(self.cell_height /float(h),
-#                               self.cell_height / float(h))
-#        else:
-#            menuitem.set_scale(self.cell_width / float(w),
-#                               self.cell_width / float(w))
+        self.cursor = c
+
+        pix_buffer = gtk.gdk.pixbuf_new_from_file(
+            self.config.theme.getImage("default_movie_art"))
+        self.movie_default = RoundedTexture(0.0, 0.0, 0.1, 0.25, pix_buffer)
+
+        self.album_default = Texture(
+            self.config.theme.getImage("default_album_art"))
+
+    def add_item(self, texture, data):
+        """Add a ImageMenuItem from a Texture."""
+        item = ImageMenuItem(self._item_width, self._item_height, texture)
+        item.userdata = data
+
+        self.raw_add_item(item)
+
+    def async_add(self, items):
+        """Add asynchronously ImageMenuItem using a list."""
+        if len(items) > 0:
+            item = items[0]
+            self.add_item(item[0], item[1])
+
+            # Recursive call, remove first element from the list
+            gobject.timeout_add(15, self.async_add, items[1:])
+        else:
+            self.emit("filled")
+
+        return False
+
+    def async_add_videos(self, items):
+        """
+        Add asynchronously ImageMenuItem using a list.
+        The created ImageMenuItem fits movies and series requirements.
+        """
+        if len(items) > 0:
+            item = items[0]
+            if item[1].has_cover_art():
+                pix_buffer = gtk.gdk.pixbuf_new_from_file(item[0])
+                texture = RoundedTexture(0.0, 0.0, 0.1, 0.25, pix_buffer)
+            else:
+                texture = clutter.CloneTexture(self.movie_default)
+
+            self.add_item(texture, item[1])
+
+            # Recursive call, remove first element from the list
+            gobject.timeout_add(10, self.async_add_videos, items[1:])
+        else:
+            self.emit("filled")
+
+        return False
+
+    def async_add_albums(self, items):
+        """
+        Add asynchronously ImageMenuItem using a list.
+        The created ImageMenuItem fits albums requirements.
+        """
+        if len(items) > 0:
+            item = items[0]
+            if item[1].has_album_art():
+                texture = Texture(item[0])
+            else:
+                texture = clutter.CloneTexture(self.album_default)
+
+            self.add_item(texture, item[1])
+
+            # Recursive call, remove first element from the list
+            gobject.timeout_add(10, self.async_add_albums, items[1:])
+        else:
+            self.emit("filled")
+
+        return False
+
+    def async_add_clips(self, items):
+        """
+        Add asynchronously ImageMenuItem using a list.
+        The created ImageMenuItem fits clips requirements.
+        """
+        if len(items) > 0:
+            item = items[0]
+            pix_buffer = gtk.gdk.pixbuf_new_from_file(item[0])
+            texture = RoundedTexture(0.0, 0.0, 0.23, self.y_for_x(0.23) * 0.7,
+                pix_buffer)
+
+            self.add_item(texture, item[1])
+
+            # Recursive call, remove first element from the list
+            gobject.timeout_add(10, self.async_add_clips, items[1:])
+        else:
+            self.emit("filled")
+
+        return False
+
 
=== removed file 'entertainerlib/frontend/gui/widgets/image_menu_item.py'
--- entertainerlib/frontend/gui/widgets/image_menu_item.py	2009-05-06 02:58:08 +0000
+++ entertainerlib/frontend/gui/widgets/image_menu_item.py	1970-01-01 00:00:00 +0000
@@ -1,34 +0,0 @@
-# Copyright (c) 2009 Entertainer Developers - See COPYING - GPLv2
-'''Menuitem that contains an image'''
-
-from entertainerlib.frontend.gui.widgets.menu_item import MenuItem
-
-class ImageMenuItem(MenuItem):
-    """
-    Simple Image MenuItem
-
-    This menu item contains one Texture that is scaled in such a way that the
-    texture fills the whole menu item area. Texture aspect ratio is not
-    preserved. ImageMenuItem is defined in terms of its width with a ratio
-    determining the height relative to width. This is so the image will scale
-    predictably on monitors of different aspect ratios.
-    """
-
-    def __init__(self, x_percent, y_to_x_ratio, texture):
-        """Initialize menuitem"""
-
-        MenuItem.__init__(self)
-
-        width = self.get_abs_x(x_percent)
-        height = self._calculate_height(width, y_to_x_ratio)
-
-        texture.set_size(width, height)
-
-        self.add(texture)
-
-    def _calculate_height(self, width, y_to_x_ratio):
-        """Calculate pixel height from the ratio of y to x"""
-        height = int(width * y_to_x_ratio)
-
-        return height
-
 
=== modified file 'entertainerlib/frontend/gui/widgets/label.py'
--- entertainerlib/frontend/gui/widgets/label.py	2009-04-28 22:30:06 +0000
+++ entertainerlib/frontend/gui/widgets/label.py	2009-05-31 15:00:01 +0000
@@ -22,7 +22,7 @@
         self._font_size = font_size
         self._set_font_size(font_size)
 
-        self.set_color(self.theme.get_color(color_name))
+        self.color = color_name
 
         self._position = None
         self._set_position((x_pos_percent, y_pos_percent))
@@ -32,33 +32,33 @@
         if name:
             self.set_name(name)
 
-        self._width = self._init_width()
-        self._height = self._init_height()
-
         self.set_line_wrap(True)
 
+    def _get_color(self):
+        """color property getter."""
+        return self._color
+
+    def _set_color(self, color_name):
+        """color property setter."""
+        self._color = color_name
+        self.set_color(self.theme.get_color(self._color))
+
+    color = property(_get_color, _set_color)
+
     def set_size(self, x_percent, y_percent):
         """Override clutter label set_size to calculate absolute size from a
         percentage"""
-        self._width = x_percent
-        self._height = y_percent
         clutter.Label.set_size(self,
             self.get_abs_x(x_percent),
             self.get_abs_y(y_percent))
 
-    def _init_width(self):
-        """Generate the width of the label initially before the width property
-        is set to ensure width has a value"""
-        return float(self.get_width()) / self.config.get_stage_width()
-
     def _get_width(self):
         """Return the width as a percent of the stage size"""
-        return self._width
+        return float(self.get_width()) / self.config.get_stage_width()
 
     def _set_width(self, x_percent):
         """Set the width based on a hozirontal percent of the stage size.
         Provide clutter label set_width the absolute size from the percentage"""
-        self._width = x_percent
         clutter.Label.set_width(self, self.get_abs_x(x_percent))
 
     width = property(_get_width, _set_width)
@@ -80,20 +80,14 @@
 
     position = property(_get_position, _set_position)
 
-    def _init_height(self):
-        """Generate the height of the label initially before the height property
-        is set to ensure height has a value"""
-        return float(self.get_height()) / self.config.get_stage_height()
-
     def _get_height(self):
         """Return the height as a percent of the stage size"""
-        return self._height
+        return float(self.get_height()) / self.config.get_stage_height()
 
     def _set_height(self, y_percent):
         """Set the height based on a vertical percent of the stage size.
         Provide clutter label set_height the absolute size from the percentage
         """
-        self._height = y_percent
         clutter.Label.set_height(self, self.get_abs_y(y_percent))
 
     height = property(_get_height, _set_height)
 
=== removed file 'entertainerlib/frontend/gui/widgets/menu.py'
--- entertainerlib/frontend/gui/widgets/menu.py	2009-05-06 03:40:22 +0000
+++ entertainerlib/frontend/gui/widgets/menu.py	1970-01-01 00:00:00 +0000
@@ -1,252 +0,0 @@
-# Copyright (c) 2009 Entertainer Developers - See COPYING - GPLv2
-'''Menu has a list of menuitems and it allows user to select one of them'''
-
-import clutter
-
-class Menu(clutter.Group):
-    """
-    Menu widget.
-
-    Blaa blaa...
-    """
-
-    def __init__(self):
-        """
-        Initialize menu widget.
-        """
-        clutter.Group.__init__(self)
-        self.__name = None        # Menu name
-        self.__active = False     # Is this menu active
-        self.__page_zize = 8      # How many items are displayed at the same
-                                  #   time
-        self.__loop = False       # Should menu loop from last to first
-        self.__selector = None    # Selector widget
-        self.__items = []         # List of MenuItems
-        self.__current = 0        # Current position of the menu
-        self.__item_width = 0     # Menuitem width
-        self.__item_height = 0    # Menuitem height
-
-    def is_active(self):
-        """
-        Is this menu active.
-        @return boolean, True if menu is currently active, otherwise False
-        """
-        return self.__active
-
-    def set_active(self, boolean):
-        """
-        Set this widget active or inactive
-        @param boolean: True to set widget active, False to set inactive
-        """
-        self.__active = boolean
-        if boolean:
-            if self.__selector is not None:
-                self.__selector.show()
-            self.get_current_menuitem().set_active(True)
-            self.set_opacity(255)
-        else:
-            if self.__selector is not None:
-                self.__selector.hide()
-            self.get_current_menuitem().set_active(False)
-            self.set_opacity(128)
-
-    def add(self, menuitem):
-        """
-        Add new menuitem to the menu.
-        @param menuitem: Add this menuitem (Menitem Widget)
-        """
-        # First menuitem determines the size of all menuitems (is it good?)
-        if len(self.__items) == 0:
-            self.__item_width = menuitem.get_width()
-            self.__item_height = menuitem.get_height()
-
-        menuitem.set_position(0, len(self.__items) * menuitem.get_height())
-        self.__items.append(menuitem)
-        clutter.Group.add(self, menuitem)
-        self.update_clip()
-
-    def remove(self, menuitem):
-        """
-        Remove menuitem from the menu.
-        @param menuitem: Remove this menuitem (Menitem Widget)
-        """
-        clutter.Group.remove(self, menuitem)
-        for item in self.__items:
-            if item is menuitem:
-                del item
-
-    def remove_all(self):
-        """
-        Remove all menuitems from the menu.
-        @param menuitem: Remove this menuitem (Clutter.Actor)
-        """
-        clutter.Group.remove_all(self)
-        self.__current = 0
-        del self.__selector
-        self.__selector = None
-        del self.__items
-        self.__items = []
-
-    def set_loop(self, boolean):
-        """
-        Set loop for menu. If loop is true then first menuitem comes after the
-        last one.
-        @param boolean: True if menu should loop, otherwise False
-        """
-        self.__loop = boolean
-
-    def is_loop(self):
-        """
-        Is menu in loop mode.
-        @return: Boolean value
-        """
-        return self.__loop
-
-    def set_menuitem_background(self, texture):
-        """
-        Set texture that is displayed under every menuitem. This is optional.
-        @param texture: Menuitem background texture. (clutter.Actor)
-        """
-        for index in range(len(self.__items)):
-            bg = clutter.CloneTexture(texture)
-            bg.set_size(self.get_width(), self.__item_height)
-            bg.set_position(0, index * self.__item_height)
-            bg.set_opacity(128)
-            bg.set_name("background")
-            clutter.Group.add(self, bg)
-            for item in self.__items:
-                clutter.Group.lower(self, bg, item)
-
-    def set_selector(self, selector):
-        """
-        Set selector texture. Selector is moved over menuitems when user
-        browses the menu.
-        @param selector: Selector texture (Clutter.Actor)
-        """
-        selector.set_position(0, 0)
-        x_scale = self.__item_width / float(selector.get_width())
-        y_scale = self.__item_height / float(selector.get_height())
-        selector.set_size(self.__item_width, self.__item_height)
-        selector.set_scale(x_scale, y_scale)
-        selector.set_name("selector")
-        self.__selector = selector
-        clutter.Group.add(self, self.__selector)
-        for item in self.__items:
-            if item.get_name() != "background":
-                clutter.Group.lower(self, selector, item)
-
-    def scroll_up(self):
-        """
-        Scroll menu up (one menuitem).
-        """
-        if self.__current > 0:
-            self.__items[self.__current].set_active(False)
-            self.__current = self.__current - 1
-            self.__items[self.__current].set_active(True)
-            if self.__selector is not None:
-                self.__selector.set_position(0,
-                    self.__current * self.__item_height)
-
-        # Loop from top to bottom
-        elif self.__current == 0 and self.__loop:
-            self.__items[self.__current].set_active(False)
-            self.__current = len(self.__items) - 1
-            self.__items[self.__current].set_active(True)
-            if self.__selector is not None:
-                self.__selector.set_position(0,
-                    self.__current * self.__item_height)
-
-    def scroll_down(self):
-        """
-        Scroll menu down (one menuitem).
-        """
-        if self.__current < len(self.__items) - 1:
-            self.__items[self.__current].set_active(False)
-            self.__current = self.__current + 1
-            self.__items[self.__current].set_active(True)
-            if self.__selector is not None:
-                self.__selector.set_position(0,
-                    self.__current * self.__item_height)
-
-        # Loop from bottom to top
-        elif self.__current == len(self.__items) - 1 and self.__loop:
-            self.__items[self.__current].set_active(False)
-            self.__current = 0
-            self.__items[self.__current].set_active(True)
-            if self.__selector is not None:
-                self.__selector.set_position(0,
-                    self.__current * self.__item_height)
-
-    def scroll_up_page(self):
-        """
-        Scroll menu up one page. One page is a number of visible items.
-        """
-
-    def scroll_down_page(self):
-        """
-        Scroll menu down one page. One page is a number of visible items.
-        """
-        # Set current menuitem
-        self.__items[self.__current].set_active(False)
-        self.__current = self.__current + 8
-        self.__items[self.__current].set_active(True)
-
-        # Set selector position
-        if self.__selector is not None:
-            self.__selector.set_position(0,
-                self.__current * self.__items[0].get_height())
-
-        # Clip to current position of the menu
-        #self.set_clip(0,)
-
-    def update_clip(self):
-        """
-        Update menu clipping. This method decides which partion of menu is
-        actually displayed on screen. If you have a long menu, not all items
-        fit into the window. This function checks what is the current position
-        of the menulist and then clips the widget in such a way that current
-        position is on screen.
-        """
-        if len(self.__items) <= self.__page_zize:
-            self.remove_clip()
-        else:
-            self.set_clip(0,
-                          self.__current * self.__item_height,
-                          self.__item_width,
-                          self.__item_height * self.__page_zize)
-            self.set_height(self.__item_height * self.__page_zize)
-
-    def get_current_position(self):
-        """
-        Get current position of the list. This position is under selector.
-        """
-        return self.__current
-
-    def get_current_menuitem(self):
-        """
-        Get Clutter.Actor object from the current postition.
-        """
-        if len(self.__items) == 0:
-            return None
-        return self.__items[self.__current]
-
-    def get_number_of_items(self):
-        """
-        Get number of menuitems in menu.
-        """
-        return len(self.__items)
-
-    def set_name(self, name):
-        """
-        Set menu name
-        @param name: Name of the menu (used to identify menu from others)
-        """
-        self.__name = name
-
-    def get_name(self):
-        """
-        Get name of the menu.
-        @return name as String
-        """
-        return self.__name
-
 
=== modified file 'entertainerlib/frontend/gui/widgets/menu_item.py'
--- entertainerlib/frontend/gui/widgets/menu_item.py	2009-05-06 03:40:22 +0000
+++ entertainerlib/frontend/gui/widgets/menu_item.py	2009-05-28 19:28:56 +0000
@@ -1,51 +1,34 @@
 # Copyright (c) 2009 Entertainer Developers - See COPYING - GPLv2
-'''Simple Menuitem'''
+"""Simple Menuitem."""
 
 import clutter
 
 from entertainerlib.frontend.gui.widgets.base import Base
 
 class MenuItem(Base, clutter.Group):
-    """
-    Simple menuitem widget.
-
-    This is a base class for all menuitem types. MenuItems are supposed to be
-    used in Menus which inherit GridMenu class.
-    """
+    """Simple menuitem widget."""
 
     def __init__(self):
-        """Initialize menuitem."""
-
         Base.__init__(self)
         clutter.Group.__init__(self)
-        self.active = False
-        self.data = None
-
-    def set_active(self, boolean):
-        """
-        Set menuitem active / inactive.
-        @param boolean: use True to set active and False to set inactive
-        """
-        self.active = boolean
-
-    def is_active(self):
-        """
-        Get widget status.
-        @return True if widget is active, otherwise False
-        """
-        return self.active
-
-    def set_userdata(self, data):
-        """
-        Set user data for this menuitem.
-        @param id: ID string
-        """
-        self.data = data
-
-    def get_userdata(self):
-        """
-        Get user data
-        @return: string
-        """
-        return self.data
+
+        self._userdata = None
+
+    def _get_userdata(self):
+        """userdata property getter."""
+        return self._userdata
+
+    def _set_userdata(self, userdata):
+        """userdata property getter."""
+        self._userdata = userdata
+
+    userdata = property (_get_userdata, _set_userdata)
+
+    def animate_in(self):
+        """Animation to be done when an item gets selected."""
+        pass
+
+    def animate_out(self):
+        """Animation to be done when an item gets unselected."""
+        pass
 
 
=== modified file 'entertainerlib/frontend/gui/widgets/scroll_menu.py'
--- entertainerlib/frontend/gui/widgets/scroll_menu.py	2009-05-09 17:03:51 +0000
+++ entertainerlib/frontend/gui/widgets/scroll_menu.py	2009-05-19 11:47:09 +0000
@@ -252,7 +252,6 @@
         if not self.handler_is_connected(self._motion_handler):
             self._motion_handler = self.connect('motion-event',
             self._on_motion_event)
-        self.active = True
 
         if self._timeline.is_playing():
             # before we stop the timeline, store its progression
@@ -281,6 +280,10 @@
             self.disconnect_by_func(self._on_motion_event)
         self._motion_buffer.compute_from_last_motion_event(event)
 
+        if not self.active:
+            self.active = True
+            return
+
         y = event.y - self.get_y()
 
         if self._event_mode == self.MODE_SELECTION:
 
=== modified file 'entertainerlib/frontend/gui/widgets/selector.py'
--- entertainerlib/frontend/gui/widgets/selector.py	2009-05-06 03:40:22 +0000
+++ entertainerlib/frontend/gui/widgets/selector.py	2009-05-19 18:57:18 +0000
@@ -17,7 +17,7 @@
     SMALL = 0
     LARGE = 1
 
-    def __init__(self, size, theme):
+    def __init__(self, theme):
         """
         Initialize Selector widget and start animation.
         @param size: Size of the selector. Use class constants SMALL and LARGE
@@ -26,19 +26,8 @@
         clutter.Group.__init__(self)
         self.animate_selector = False
 
-        # Get proper file names
-        # XXX Samuel Buffet : This maybe should be considered as technical debt
-        # because neither selector_small nor selector_glow_small
-        # are provided by Themes
-        if size == self.SMALL:
-            selector_filename = theme.getImage("selector_small")
-            glow_filename = theme.getImage("selector_glow_small")
-        elif size == self.LARGE:
-            selector_filename = theme.getImage("selector")
-            glow_filename = theme.getImage("selector_glow")
-        else:
-            raise Exception(
-                "Intializing Selector object failed. Unknown size!")
+        selector_filename = theme.getImage("selector")
+        glow_filename = theme.getImage("selector_glow")
 
         # Set selector base texture
         self.selector = Texture(selector_filename)
@@ -57,13 +46,10 @@
         self.behaviour = clutter.BehaviourOpacity(0, 255, self.alpha)
         self.behaviour.apply(self.glow)
 
-    def animate(self, boolean):
-        """
-        Animate widget when it's on screen.
-        @param boolean: True if widget should be animated, otherwise False
-        """
-        self.animate_selector = boolean
-        #self.stop_animation()
+    def set_size(self, width, height):
+        """Overrides clutter.Actor.set_size()"""
+        self.selector.set_size(width, height)
+        self.glow.set_size(width, height)
 
     def stop_animation(self):
         """Stop selector animation"""
@@ -83,18 +69,15 @@
     def show(self):
         """Overrides clutter.Actor.show()"""
         clutter.Group.show(self)
-        if self.animate_selector:
-            self.start_animation()
+        self.start_animation()
 
     def hide_all(self):
         """Overrides clutter.Actor.hide_all()"""
         clutter.Group.hide_all(self)
-        if self.animate_selector:
-            self.stop_animation()
+        self.stop_animation()
 
     def show_all(self):
         """Overrides clutter.Actor.show_all()"""
         clutter.Group.show_all(self)
-        if self.animate_selector:
-            self.start_animation()
+        self.start_animation()
 
 
=== modified file 'entertainerlib/frontend/gui/widgets/special_behaviours.py'
--- entertainerlib/frontend/gui/widgets/special_behaviours.py	2009-05-09 17:03:51 +0000
+++ entertainerlib/frontend/gui/widgets/special_behaviours.py	2009-05-28 19:20:31 +0000
@@ -51,3 +51,23 @@
         dy = self.end_knot[1] - self.start_knot[1]
         return math.sqrt(dx * dx + dy * dy)
 
+class FontSizeBehaviour(clutter.Behaviour):
+    """A custom Behaviour to change the `font-size` property of Labels."""
+    __gtype_name__ = 'FontSizeBehaviour'
+
+    def __init__(self, alpha=None):
+        clutter.Behaviour.__init__(self)
+        self.set_alpha(alpha)
+        self.start_size = 1.0
+        self.end_size = 1.0
+
+    def do_alpha_notify(self, alpha_value):
+        """Alpha function changing the `font-size` property of Labels."""
+        size = alpha_value * (self.end_size - self.start_size)
+        size /= clutter.MAX_ALPHA
+        size += self.start_size
+
+        for actor in self.get_actors():
+            actor.font_size = size
+            actor.update()
+
 
=== modified file 'entertainerlib/frontend/gui/widgets/tab_group.py'
--- entertainerlib/frontend/gui/widgets/tab_group.py	2009-05-12 17:18:10 +0000
+++ entertainerlib/frontend/gui/widgets/tab_group.py	2009-05-21 20:23:26 +0000
@@ -193,13 +193,12 @@
 
     def _on_tab_title_button_press(self, actor, event):
         '''Title Label button-press handler.'''
-        if self.active:
-            clicked_tab = self._tabs[actor.get_name()]
-            clicked_tab_index = self.tabs_list.index(clicked_tab)
-
-            if self.current_tab != clicked_tab_index:
-                self._activate_tab(clicked_tab_index)
-                self.current_tab = clicked_tab_index
-        else:
-            self.active = True
+        self.active = True
+
+        clicked_tab = self._tabs[actor.get_name()]
+        clicked_tab_index = self.tabs_list.index(clicked_tab)
+
+        if self.current_tab != clicked_tab_index:
+            self._activate_tab(clicked_tab_index)
+            self.current_tab = clicked_tab_index
 
 
=== modified file 'entertainerlib/frontend/gui/widgets/text_menu.py'
--- entertainerlib/frontend/gui/widgets/text_menu.py	2009-05-06 02:58:08 +0000
+++ entertainerlib/frontend/gui/widgets/text_menu.py	2009-07-13 18:31:36 +0000
@@ -1,65 +1,176 @@
 # Copyright (c) 2009 Entertainer Developers - See COPYING - GPLv2
-'''Implements basic menu that contains text labels as menuitems'''
-
+'''Implements a grid menu that contains one or two labels.'''
+
+import clutter
+import gobject
+import pango
+
+from entertainerlib.frontend.gui.widgets.grid_menu import GridMenu
+from entertainerlib.frontend.gui.widgets.label import Label
+from entertainerlib.frontend.gui.widgets.menu_item import MenuItem
 from entertainerlib.frontend.gui.widgets.selector import Selector
-from entertainerlib.frontend.gui.widgets.grid_menu import GridMenu
+from entertainerlib.frontend.gui.widgets.special_behaviours import (
+    FontSizeBehaviour)
+
+class TextMenuItem(MenuItem):
+    """A menuitem widget that contains one or two labels."""
+
+    def __init__(self, width, height, text, extra_text=None):
+        MenuItem.__init__(self)
+
+        self.width = width
+        self.height = height
+        self.theme = self.config.theme
+
+        self.text = text
+        self.extra_text = extra_text
+        self.color = "menuitem_inactive"
+        self.font_size = 0.03
+
+        self.label = Label(self.font_size, self.color, 0, 0, "",
+            "text_label")
+        self.add(self.label)
+
+        # Set extra text
+        self.extra_label = None
+        if extra_text is not None:
+            self.extra_label = Label(self.font_size, self.color, 0, 0,
+                "", "text_label")
+            self.add(self.extra_label)
+
+        self.update(text, extra_text)
+
+        self.timeline = clutter.Timeline(fps=100, duration=500)
+        alpha = clutter.Alpha(self.timeline, clutter.smoothstep_inc_func)
+        self.behaviour = FontSizeBehaviour(alpha)
+        self.behaviour.apply(self)
+
+    def animate_in(self):
+        """Set labels font-size and color when an item gets selected."""
+        self.font_size = 0.037
+        self.color = "menuitem_active"
+        self.update()
+
+    def animate_out(self):
+        """Set labels font-size and color when an item gets unselected."""
+        self.font_size = 0.03
+        self.color = "menuitem_inactive"
+        self.update()
+
+    def update(self, text=None, extra_text=None):
+        """Updates text and dimensions of a TextMenuItem."""
+        if text is None:
+            text = self.text
+        else:
+            self.text = text
+
+        if extra_text is None:
+            extra_text = self.extra_text
+        else:
+            self.extra_text = extra_text
+
+        try:
+            first_line = text[:text.index('\n')]
+        except ValueError:
+            first_line = text
+
+        self.label.font_size = self.font_size
+        self.label.set_text(first_line)
+        self.label.position = (0.01, (self.height - self.label.height) / 2)
+        self.label.set_ellipsize(pango.ELLIPSIZE_END)
+
+        # Set extra text
+        if extra_text is not None:
+            self.extra_label.font_size = self.font_size
+            self.extra_label.set_text(extra_text)
+            self.extra_label.position = ( \
+                self.width * 0.98 - self.extra_label.width,
+                (self.height - self.extra_label.height) / 2)
+
+            self.label.width = (self.width - self.extra_label.width) * 0.9
+        else:
+            self.label.width = self.width * 0.95
+
+        self.label.color = self.color
+        if self.extra_label:
+            self.extra_label.color = self.color
+
+
+class ArtistsMenuItem(TextMenuItem):
+    """A TextMenuItem dedicated implementing animate_in and animate_out."""
+
+    def __init__(self, width, height, text, extra_text=None):
+        TextMenuItem.__init__(self, width, height, text, extra_text)
+
+        self.move_anchor_point_from_gravity(clutter.GRAVITY_WEST)
+        self.font_size = 0.025
+        self.update()
+
+    def animate_in(self):
+        """Set labels font-size and color when an item gets selected."""
+        self.timeline.stop()
+        self.font_size = 0.05
+        self.color = "menuitem_active"
+        self.update()
+
+    def animate_out(self):
+        """Set labels font-size and color when an item gets unselected."""
+        self.color = "menuitem_inactive"
+        self.update()
+        self.behaviour.start_size = 0.05
+        self.behaviour.end_size = 0.025
+        self.timeline.start()
+
 
 class TextMenu(GridMenu):
-    """
-    TextMenu widget
-
-    This widget inherits general GridMenu widget and implements simple textmenu.
-    """
-
-    def __init__(self, theme, animate):
-        """
-        Initialize widget
-
-        @param theme: Theme object
-        @param animate: Animate this menu widget (boolean)
-        """
-        GridMenu.__init__(self)
-
-        self.animate = animate              # Animate this widget behaviour
-        self.set_item_size(570, 60)         # Default size for textmenu item
-
-        # Set Cursor
-        self.set_cursor_placement(self.BELOW)
-        c = Selector(Selector.LARGE, theme)
-        c.animate(animate)
-        self.set_cursor(c)
-
-    def _update_selected_item(self, new_location, old_location=None):
-        """
-        Overridden method! See GridMenu API reference.
-        @param new_location: Logical location of current menuitem
-        @param old_location: Logical location of last menuitem
-        """
-        if old_location is not None:
-            self.items[old_location].set_active(False)
-        self.items[new_location].set_active(True)
-
-    def _animate_items_on_state_change(self):
-        """
-        This method is called when widget is set active or inactive. This
-        method allows widget to react this action.
-        """
-        if len(self.items):
-            if self.active:
-                self.cursor.show()
-                self.items[self.logical_position].set_active(True)
-                self.set_opacity(255)
-            else:
-                self.cursor.hide()
-                self.items[self.logical_position].set_active(False)
-                self.set_opacity(128)
-
-    def get_index(self, text):
-        """
-        Returns index of label with the text as passed, returns -1 if not found
-        """
-        for item in self.items:
-            if item.label.get_text() == text:
-                return self.items.index(item)
-        return -1
+    """A grid menu that contains labels."""
+    __gsignals__ = {
+        'filled' : ( gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, () ),
+    }
+
+    def __init__(self, x=0, y=0, item_width=200, item_height=100):
+        GridMenu.__init__(self, x, y, item_width, item_height)
+
+        self.items_per_row = 1
+        self.visible_rows = 8
+        self.visible_cols = 1
+
+        self.cursor = Selector(self.config.theme)
+
+    def add_item(self, text, extra_text=None, data=None):
+        """Add a TextMenuItem."""
+        item = TextMenuItem(self._item_width, self._item_height, text,
+            extra_text)
+        item.userdata = data
+
+        self.raw_add_item(item)
+
+    def async_add(self, items):
+        """Add asynchronously TextMenuItem using a list."""
+        if len(items) > 0:
+            item = items[0]
+            self.add_item(item[0], item[1], item[2])
+
+            # Recursive call, remove first element from the list
+            gobject.timeout_add(10, self.async_add, items[1:])
+        else:
+            self.emit("filled")
+
+        return False
+
+    def async_add_artists(self, items):
+        """Add asynchronously ArtistsMenuItem using a list."""
+        if len(items) > 0:
+            item = items[0]