Merge lp:~canonical-dx-team/unity/unity.qlmenuitems into lp:unity

[Jay Taoko]

Quicklist:
  * label
  * check mark
  * separator
  * highlight on mouse over
  * mouse event hooks
  * Unit tests

Still missing: connection to real application indicators for the check mark and radio menu items.

[Neil J. Patel (njpatel)]

Good stuff, the tests look good and it runs, however I have some comments that I'd like to see addressed before approving:

- There's a conflict in po/unity.pot

- In + else
64 + {
65 + QuicklistMenuItemLabel* item = new QuicklistMenuItemLabel (newitem, NUX_TRACKER_LOCATION);
66 + quicklist->AddMenuItem (item);
67 + }

  I think you should explicitly check for label item, and in the "else" you should warn that we don't support item of type $type

- "// enable this once all proper QuicklistMenuitems are fully implemented" why is this code this here?

- You don't need #if defined (NUX_OS_LINUX), it's all we care about

- GetDPI () should get the DPI from GtkSettings

- Do const gchar * checks against NULL, not against 0. Return NULL for a method returning a char pointer, don't return 0

- QuicklistMenuItem::GetTextExtents and QuicklistMenuItem::UpdateTexture, do they need to be in trunk if they are commented out?

- Why do you need to cache _enabled & _active in QuicklistMenuItem?

- QuicklistMenuItem () with the debug constructor doesn't connect to thee menuitem's signals, so it won't stay up-to-date...

- Why aren't sub-classes using GetLabel() instead of getting information from dbusmenu themselves?

- Tons of commented out lines, if we dont' need them can we drop them?

- QuicklistMenuItemCheckmark::DrawText leaking Leaking PangoContext?

- Do we have multiple GetTextExtents? Should they not be in a utility file?

- What is SetFontWeight/Style etc for? Why are exposing this publicly right now?

- Waaay too much copy-and-pasted code, needs to be moved in to a Utils.h/cpp for clarity

- I *really* don't like having to use NStrings everywhere. dbusmenu is handing things to us as const gchar* and that's what we need to feed into cairo/pango, so why do we add NString in between? I'd like this changed to const char* like the rest of the plugin.

- Tests look great!

review: Needs Fixing

[Mirco Müller (macslow)]

I'm working on all these fixes now.

[Mirco Müller (macslow)]

> - In + else
> 64 + {
> 65 + QuicklistMenuItemLabel* item = new QuicklistMenuItemLabel
> (newitem, NUX_TRACKER_LOCATION);
> 66 + quicklist->AddMenuItem (item);
> 67 + }
>
> I think you should explicitly check for label item, and in the "else" you
> should warn that we don't support item of type $type

From what I've seen and tried with DBusMenu one can explicitly test for a "plain label"-item. Only can one distinguish between a separator, a checkmark-item and a radiobutton-item. Only when tests against these three fail one can implicitly assume one is dealing with a "plain label" item. I've looked at the DBusMenu-API in devhelp and also at the old unit-test test-dbusmenu-quicklist.vala. Nothing hints that there is a possibility for an explicit test. Only this exclusion-approach can be used.

[Mirco Müller (macslow)]

So branch is fixed now. Requesting another review.

review: Needs Resubmitting

[Neil J. Patel (njpatel)]

Looks much clearer, some remaining issues:

- Conflict with trunk (as discussed)

- Still multiple implementations of DrawText, should be one implementation in QuicklistMenuItem that has enough options that all the sub-classes can use it

- GetTextExtents has the same issue as DrawText, multiple implementations, should be in QuicklistMenuitem class

- Use GtkSettings to also get the current font name of the desktop

- There are multiple implementations of DrawRoundedRectangle too

review: Needs Fixing

[Mirco Müller (macslow)]

All remaining issues fixed now.

[Neil J. Patel (njpatel)]

Looks good! There are some architecture updates which we can work on next week, so as soon as I get a +1 that this fixes an issue for didrocks, I'll approve :)

=== modified file 'src/LauncherIcon.cpp' (properties changed: -x to +x)
--- src/LauncherIcon.cpp	2010-11-25 05:40:01 +0000
+++ src/LauncherIcon.cpp	2010-11-25 15:47:12 +0000
@@ -31,6 +31,12 @@
 #include "LauncherIcon.h"
 #include "Launcher.h"
 
+#include "QuicklistMenuItem.h"
+#include "QuicklistMenuItemLabel.h"
+#include "QuicklistMenuItemSeparator.h"
+#include "QuicklistMenuItemCheckmark.h"
+#include "QuicklistMenuItemRadio.h"
+
 #define DEFAULT_ICON "application-default-icon"
 
 nux::Tooltip *LauncherIcon::_current_tooltip = 0;
@@ -227,9 +233,7 @@
     std::list<DbusmenuClient *>::iterator it;
     for (it = menus_list.begin (); it != menus_list.end (); it++)
     {
-      g_signal_connect(G_OBJECT(*it), DBUSMENU_CLIENT_SIGNAL_ROOT_CHANGED, G_CALLBACK(&LauncherIcon::root_changed), _quicklist);
-      dbusmenu_client_add_type_handler (*it, DBUSMENU_CLIENT_TYPES_DEFAULT, (&LauncherIcon::label_handler));
-      dbusmenu_client_add_type_handler (*it, DBUSMENU_CLIENT_TYPES_SEPARATOR, (&LauncherIcon::separator_handler));
+      g_signal_connect(G_OBJECT(*it), DBUSMENU_CLIENT_SIGNAL_ROOT_CHANGED, G_CALLBACK(&LauncherIcon::RootChanged), _quicklist);
     }
     
     _quicklist_is_initialized = true;
@@ -257,45 +261,45 @@
   _tooltip->ShowWindow (false);
 }
 
-
-gboolean LauncherIcon::label_handler (DbusmenuMenuitem * newitem, DbusmenuMenuitem * parent, DbusmenuClient * client)
-{
-  //const gchar* s = dbusmenu_menuitem_property_get (newitem, DBUSMENU_MENUITEM_PROP_LABEL);
-  //printf ("label: %s\n", s);
-  
-  return true;
-}
-
-gboolean LauncherIcon::separator_handler (DbusmenuMenuitem * newitem, DbusmenuMenuitem * parent, DbusmenuClient * client)
-{
-  //const gchar* s = dbusmenu_menuitem_property_get (newitem, DBUSMENU_MENUITEM_PROP_LABEL);
-  //printf ("separator: %s\n", s);
-
-  return true;
-}
-
-void LauncherIcon::child_realized (DbusmenuMenuitem *newitem, QuicklistView *quicklist)
-{
-  const gchar* label = dbusmenu_menuitem_property_get (newitem, DBUSMENU_MENUITEM_PROP_LABEL);
+void LauncherIcon::ChildRealized (DbusmenuMenuitem *newitem, QuicklistView *quicklist)
+{
+  g_return_if_fail (newitem);
+
   const gchar* type = dbusmenu_menuitem_property_get (newitem, DBUSMENU_MENUITEM_PROP_TYPE);
+  const gchar* toggle_type = dbusmenu_menuitem_property_get (newitem, DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE);
   
   if (g_strcmp0 (type, DBUSMENU_CLIENT_TYPES_SEPARATOR) == 0)
   {
-    quicklist->AddMenuItem ("-----------------");
-  }
-  else
-  {
-    quicklist->AddMenuItem (label);
-  }
-    
+    QuicklistMenuItemSeparator* item = new QuicklistMenuItemSeparator (newitem, NUX_TRACKER_LOCATION);
+    quicklist->AddMenuItem (item);
+  }
+  else if (g_strcmp0 (toggle_type, DBUSMENU_MENUITEM_TOGGLE_CHECK) == 0)
+  {
+    QuicklistMenuItemCheckmark* item = new QuicklistMenuItemCheckmark (newitem, NUX_TRACKER_LOCATION);
+    quicklist->AddMenuItem (item);
+  }
+  else if (g_strcmp0 (toggle_type, DBUSMENU_MENUITEM_TOGGLE_RADIO) == 0)
+  {
+    QuicklistMenuItemRadio* item = new QuicklistMenuItemRadio (newitem, NUX_TRACKER_LOCATION);
+    quicklist->AddMenuItem (item);
+  }
+  else //(g_strcmp0 (type, DBUSMENU_MENUITEM_PROP_LABEL) == 0)
+  {
+    QuicklistMenuItemLabel* item = new QuicklistMenuItemLabel (newitem, NUX_TRACKER_LOCATION);
+    quicklist->AddMenuItem (item);
+  }
+//   else
+//   {
+//     g_warning ("Unknown menu item type in file %s at line %s", G_STRFUNC, G_STRLOC);
+//   }
 }
 
-void LauncherIcon::root_changed (DbusmenuClient * client, DbusmenuMenuitem * newroot, QuicklistView *quicklist)
+void LauncherIcon::RootChanged (DbusmenuClient * client, DbusmenuMenuitem * newroot, QuicklistView *quicklist)
 {
   GList * child = NULL;
   for (child = dbusmenu_menuitem_get_children(newroot); child != NULL; child = g_list_next(child))
   {
-    g_signal_connect(G_OBJECT(child->data), DBUSMENU_MENUITEM_SIGNAL_REALIZED, G_CALLBACK(child_realized), quicklist);    
+    g_signal_connect(G_OBJECT(child->data), DBUSMENU_MENUITEM_SIGNAL_REALIZED, G_CALLBACK(ChildRealized), quicklist);    
   }
 }
 

=== modified file 'src/LauncherIcon.h'
--- src/LauncherIcon.h	2010-11-25 05:40:01 +0000
+++ src/LauncherIcon.h	2010-11-25 15:47:12 +0000
@@ -157,12 +157,8 @@
     friend class LauncherController;
 
 private:
-  
-    static gboolean label_handler (DbusmenuMenuitem * newitem, DbusmenuMenuitem * parent, DbusmenuClient * client);
-    static gboolean separator_handler (DbusmenuMenuitem * newitem, DbusmenuMenuitem * parent, DbusmenuClient * client);
-    
-    static void child_realized (DbusmenuMenuitem *newitem, QuicklistView *quicklist);
-    static void root_changed (DbusmenuClient * client, DbusmenuMenuitem *newroot, QuicklistView *quicklist);
+    static void ChildRealized (DbusmenuMenuitem *newitem, QuicklistView *quicklist);
+    static void RootChanged (DbusmenuClient * client, DbusmenuMenuitem *newroot, QuicklistView *quicklist);
     static gboolean OnPresentTimeout (gpointer data);
     static gboolean OnCenterTimeout (gpointer data);
 

=== added file 'src/QuicklistMenuItem.cpp'
--- src/QuicklistMenuItem.cpp	1970-01-01 00:00:00 +0000
+++ src/QuicklistMenuItem.cpp	2010-11-25 15:47:12 +0000
@@ -0,0 +1,442 @@
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Mirco Müller <[e-mail]>
+ * Authored by: Jay Taoko <[e-mail]>
+ */
+
+#include <gdk/gdk.h>
+#include <gtk/gtk.h>
+
+#include "Nux/Nux.h"
+#include "QuicklistMenuItem.h"
+
+#include <X11/Xlib.h>
+
+#define ITEM_INDENT_ABS        20
+#define ITEM_CORNER_RADIUS_ABS 4
+
+static void
+OnPropertyChanged (gchar*             property,
+                   GValue*            value,
+                   QuicklistMenuItem* self);
+
+static void
+OnItemActivated (guint              timestamp,
+                 QuicklistMenuItem* self);
+
+QuicklistMenuItem::QuicklistMenuItem (DbusmenuMenuitem* item,
+                                      NUX_FILE_LINE_DECL) :
+View (NUX_FILE_LINE_PARAM)
+{
+  if (item == 0)
+  {
+    g_warning ("Invalid DbusmenuMenuitem in file %s at line %s.", G_STRFUNC, G_STRLOC);
+  }
+  
+  _text       = 0;
+  _color      = nux::Color (1.0f, 1.0f, 1.0f, 1.0f);
+  _menuItem   = item;
+  _debug      = false;
+  _item_type  = MENUITEM_TYPE_UNKNOWN;
+  
+  _normalTexture[0]   = NULL;
+  _normalTexture[1]   = NULL;
+  _prelightTexture[0] = NULL;
+  _prelightTexture[1] = NULL;
+  
+  if (_menuItem)
+  {
+    g_signal_connect (_menuItem,
+                    "property-changed",
+                    G_CALLBACK (OnPropertyChanged),
+                    this);
+    g_signal_connect (_menuItem,
+                    "item-activated",
+                    G_CALLBACK (OnItemActivated),
+                    this);
+  }
+  
+  OnMouseDown.connect (sigc::mem_fun (this, &QuicklistMenuItem::RecvMouseDown));
+  OnMouseUp.connect (sigc::mem_fun (this, &QuicklistMenuItem::RecvMouseUp));
+  OnMouseClick.connect (sigc::mem_fun (this, &QuicklistMenuItem::RecvMouseClick));
+  OnMouseMove.connect (sigc::mem_fun (this, &QuicklistMenuItem::RecvMouseMove));
+  OnMouseDrag.connect (sigc::mem_fun (this, &QuicklistMenuItem::RecvMouseDrag));
+  OnMouseEnter.connect (sigc::mem_fun (this, &QuicklistMenuItem::RecvMouseEnter));
+  OnMouseLeave.connect (sigc::mem_fun (this, &QuicklistMenuItem::RecvMouseLeave));
+
+  _prelight = false;
+}
+
+QuicklistMenuItem::QuicklistMenuItem (DbusmenuMenuitem* item,
+                                      bool              debug,
+                                      NUX_FILE_LINE_DECL) :
+View (NUX_FILE_LINE_PARAM)
+{
+  _text       = 0;
+  _color      = nux::Color (1.0f, 1.0f, 1.0f, 1.0f);
+  _menuItem   = item;
+  _debug      = debug;
+  _item_type  = MENUITEM_TYPE_UNKNOWN;
+  
+  _normalTexture[0]   = NULL;
+  _normalTexture[1]   = NULL;
+  _prelightTexture[0] = NULL;
+  _prelightTexture[1] = NULL;
+  
+  if (_menuItem)
+  {
+    g_signal_connect (_menuItem,
+                    "property-changed",
+                    G_CALLBACK (OnPropertyChanged),
+                    this);
+    g_signal_connect (_menuItem,
+                    "item-activated",
+                    G_CALLBACK (OnItemActivated),
+                    this);
+  }
+  
+  OnMouseDown.connect (sigc::mem_fun (this, &QuicklistMenuItem::RecvMouseDown));
+  OnMouseUp.connect (sigc::mem_fun (this, &QuicklistMenuItem::RecvMouseUp));
+  OnMouseClick.connect (sigc::mem_fun (this, &QuicklistMenuItem::RecvMouseClick));
+  OnMouseMove.connect (sigc::mem_fun (this, &QuicklistMenuItem::RecvMouseMove));
+  OnMouseDrag.connect (sigc::mem_fun (this, &QuicklistMenuItem::RecvMouseDrag));
+  OnMouseEnter.connect (sigc::mem_fun (this, &QuicklistMenuItem::RecvMouseEnter));
+  OnMouseLeave.connect (sigc::mem_fun (this, &QuicklistMenuItem::RecvMouseLeave));
+
+  _prelight = false;
+}
+
+QuicklistMenuItem::~QuicklistMenuItem ()
+{
+  if (_text)
+    g_free (_text);
+}
+
+QuicklistMenuItemType QuicklistMenuItem::GetItemType ()
+{
+  return _item_type;
+}
+
+void
+QuicklistMenuItem::PreLayoutManagement ()
+{
+  View::PreLayoutManagement ();
+}
+
+long
+QuicklistMenuItem::PostLayoutManagement (long layoutResult)
+{
+  long result = View::PostLayoutManagement (layoutResult);
+
+  return result;
+}
+
+long
+QuicklistMenuItem::ProcessEvent (nux::IEvent& event,
+                                 long         traverseInfo,
+                                 long         processEventInfo)
+{
+  long result = traverseInfo;
+
+  result = nux::View::PostProcessEvent2 (event, result, processEventInfo);
+  return result;
+
+}
+
+void
+QuicklistMenuItem::Draw (nux::GraphicsEngine& gfxContext,
+                         bool                 forceDraw)
+{
+}
+
+void
+QuicklistMenuItem::DrawContent (nux::GraphicsEngine& gfxContext,
+                                bool                 forceDraw)
+{
+}
+
+void
+QuicklistMenuItem::PostDraw (nux::GraphicsEngine& gfxContext,
+                             bool                 forceDraw)
+{
+}
+
+const gchar*
+QuicklistMenuItem::GetLabel ()
+{
+  if (_menuItem == 0)
+    return 0;
+  return dbusmenu_menuitem_property_get (_menuItem,
+                                         DBUSMENU_MENUITEM_PROP_LABEL);
+}
+
+bool
+QuicklistMenuItem::GetEnabled ()
+{
+  if (_menuItem == 0)
+    return false;
+  return dbusmenu_menuitem_property_get_bool (_menuItem,
+                                              DBUSMENU_MENUITEM_PROP_ENABLED);
+}
+
+bool
+QuicklistMenuItem::GetActive ()
+{
+  if (_menuItem == 0)
+    return false;
+  return dbusmenu_menuitem_property_get_bool (_menuItem,
+                                              DBUSMENU_MENUITEM_PROP_TOGGLE_STATE);
+}
+
+void QuicklistMenuItem::ItemActivated ()
+{
+  if (_debug)
+    sigChanged.emit (*this);
+
+  std::cout << "ItemActivated() called" << std::endl;
+}
+
+void QuicklistMenuItem::GetTextExtents (int &width, int &height)
+{
+  GtkSettings* settings = gtk_settings_get_default (); // not ref'ed
+  gchar*       fontName = NULL;
+
+  g_object_get (settings, "gtk-font-name", &fontName, NULL);
+  GetTextExtents (fontName, width, height);
+  g_free (fontName);
+}
+
+void QuicklistMenuItem::GetTextExtents (const gchar* font,
+                                        int&         width,
+                                        int&         height)
+{
+  cairo_surface_t*      surface  = NULL;
+  cairo_t*              cr       = NULL;
+  PangoLayout*          layout   = NULL;
+  PangoFontDescription* desc     = NULL;
+  PangoContext*         pangoCtx = NULL;
+  PangoRectangle        logRect  = {0, 0, 0, 0};
+  int                   dpi      = 0;
+  GdkScreen*            screen   = gdk_screen_get_default ();   // is not ref'ed
+  GtkSettings*          settings = gtk_settings_get_default (); // is not ref'ed
+
+  // sanity check
+  if (!font)
+    return;
+
+  surface = cairo_image_surface_create (CAIRO_FORMAT_A1, 1, 1);
+  cr = cairo_create (surface);
+  cairo_set_font_options (cr, gdk_screen_get_font_options (screen));
+  layout = pango_cairo_create_layout (cr);
+  desc = pango_font_description_from_string (font);
+  pango_font_description_set_weight (desc, PANGO_WEIGHT_NORMAL);
+  pango_layout_set_font_description (layout, desc);
+  pango_layout_set_wrap (layout, PANGO_WRAP_WORD_CHAR);
+  pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_END);
+  pango_layout_set_markup (layout, _text, -1);
+  pangoCtx = pango_layout_get_context (layout); // is not ref'ed
+  pango_cairo_context_set_font_options (pangoCtx,
+                                        gdk_screen_get_font_options (screen));
+  g_object_get (settings, "gtk-xft-dpi", &dpi, NULL);
+  if (dpi == -1)
+  {
+    // use some default DPI-value
+    pango_cairo_context_set_resolution (pangoCtx, 96.0f);
+  }
+  else
+  {
+    pango_cairo_context_set_resolution (pangoCtx,
+                                        (float) dpi / (float) PANGO_SCALE);
+  }
+  pango_layout_context_changed (layout);
+  pango_layout_get_extents (layout, NULL, &logRect);
+
+  width  = logRect.width / PANGO_SCALE;
+  height = logRect.height / PANGO_SCALE;
+
+  // clean up
+  pango_font_description_free (desc);
+  g_object_unref (layout);
+  cairo_destroy (cr);
+  cairo_surface_destroy (surface);
+}
+
+static void
+OnPropertyChanged (gchar*             property,
+                   GValue*            value,
+                   QuicklistMenuItem* self)
+{
+  //todo
+  //self->UpdateTexture ();
+}
+
+static void
+OnItemActivated (guint              timestamp,
+                 QuicklistMenuItem* self)
+{
+  //todo:
+  //self->ItemActivated ();
+}
+
+void QuicklistMenuItem::RecvMouseDown (int x, int y, unsigned long button_flags, unsigned long key_flags)
+{
+
+}
+
+void QuicklistMenuItem::RecvMouseUp (int x, int y, unsigned long button_flags, unsigned long key_flags)
+{
+  sigMouseReleased.emit (this);
+}
+
+void QuicklistMenuItem::RecvMouseClick (int x, int y, unsigned long button_flags, unsigned long key_flags)
+{
+  if (!GetEnabled ())
+  {
+    sigMouseClick.emit (this);
+    return;
+  }
+  sigMouseClick.emit (this);
+}
+
+void QuicklistMenuItem::RecvMouseMove (int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags)
+{
+  
+}
+
+void QuicklistMenuItem::RecvMouseDrag (int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags)
+{
+  
+}
+
+void QuicklistMenuItem::RecvMouseEnter (int x, int y, unsigned long button_flags, unsigned long key_flags)
+{
+  _prelight = true;
+  sigMouseEnter.emit (this);
+}
+
+void QuicklistMenuItem::RecvMouseLeave (int x, int y, unsigned long button_flags, unsigned long key_flags)
+{
+  _prelight = false;
+  sigMouseLeave.emit (this);
+}
+
+void
+QuicklistMenuItem::DrawRoundedRectangle (cairo_t* cr,
+                                         double   aspect,
+                                         double   x,
+                                         double   y,
+                                         double   cornerRadius,
+                                         double   width,
+                                         double   height)
+{
+    double radius = cornerRadius / aspect;
+
+    // top-left, right of the corner
+    cairo_move_to (cr, x + radius, y);
+
+    // top-right, left of the corner
+    cairo_line_to (cr, x + width - radius, y);
+
+    // top-right, below the corner
+    cairo_arc (cr,
+               x + width - radius,
+               y + radius,
+               radius,
+               -90.0f * G_PI / 180.0f,
+               0.0f * G_PI / 180.0f);
+
+    // bottom-right, above the corner
+    cairo_line_to (cr, x + width, y + height - radius);
+
+    // bottom-right, left of the corner
+    cairo_arc (cr,
+               x + width - radius,
+               y + height - radius,
+               radius,
+               0.0f * G_PI / 180.0f,
+               90.0f * G_PI / 180.0f);
+
+    // bottom-left, right of the corner
+    cairo_line_to (cr, x + radius, y + height);
+
+    // bottom-left, above the corner
+    cairo_arc (cr,
+               x + radius,
+               y + height - radius,
+               radius,
+               90.0f * G_PI / 180.0f,
+               180.0f * G_PI / 180.0f);
+
+    // top-left, right of the corner
+    cairo_arc (cr,
+               x + radius,
+               y + radius,
+               radius,
+               180.0f * G_PI / 180.0f,
+               270.0f * G_PI / 180.0f);
+}
+
+void
+QuicklistMenuItem::DrawText (cairo_t*   cr,
+                             int        width,
+                             int        height,
+                             nux::Color color)
+{
+  int                   textWidth  = 0;
+  int                   textHeight = 0;
+  PangoLayout*          layout     = NULL;
+  PangoFontDescription* desc       = NULL;
+  PangoContext*         pangoCtx   = NULL;
+  int                   dpi        = 0;
+  GdkScreen*            screen     = gdk_screen_get_default ();   // not ref'ed
+  GtkSettings*          settings   = gtk_settings_get_default (); // not ref'ed
+  gchar*                fontName   = NULL;
+
+  g_object_get (settings, "gtk-font-name", &fontName, NULL);
+  GetTextExtents (fontName, textWidth, textHeight);
+
+  cairo_set_font_options (cr, gdk_screen_get_font_options (screen));
+  layout = pango_cairo_create_layout (cr);
+  desc = pango_font_description_from_string (fontName);
+  pango_layout_set_font_description (layout, desc);
+  pango_layout_set_wrap (layout, PANGO_WRAP_WORD_CHAR);
+  pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_END);
+  pango_layout_set_markup (layout, _text, -1);
+  pangoCtx = pango_layout_get_context (layout); // is not ref'ed
+  pango_cairo_context_set_font_options (pangoCtx,
+                                        gdk_screen_get_font_options (screen));
+  g_object_get (settings, "gtk-xft-dpi", &dpi, NULL);
+  if (dpi == -1)
+  {
+    // use some default DPI-value
+    pango_cairo_context_set_resolution (pangoCtx, 96.0f);
+  }
+  else
+  {
+    pango_cairo_context_set_resolution (pangoCtx,
+                                        (float) dpi / (float) PANGO_SCALE);
+  }
+
+  pango_layout_context_changed (layout);
+
+  cairo_move_to (cr, ITEM_INDENT_ABS, (float) (height - textHeight) / 2.0f);
+  pango_cairo_show_layout (cr, layout);
+
+  // clean up
+  pango_font_description_free (desc);
+  g_free (fontName);
+  g_object_unref (layout);
+}

=== added file 'src/QuicklistMenuItem.h'
--- src/QuicklistMenuItem.h	1970-01-01 00:00:00 +0000
+++ src/QuicklistMenuItem.h	2010-11-25 15:47:12 +0000
@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Mirco Müller <[e-mail]>
+ * Authored by: Jay Taoko <[e-mail]>
+ */
+
+#ifndef QUICKLISTMENUITEM_H
+#define QUICKLISTMENUITEM_H
+
+#include <libdbusmenu-glib/menuitem.h>
+#include <libdbusmenu-glib/client.h>
+
+#include "Nux/Nux.h"
+#include "Nux/View.h"
+#include "NuxImage/CairoGraphics.h"
+
+#include <pango/pango.h>
+#include <pango/pangocairo.h>
+
+typedef enum
+{
+  MENUITEM_TYPE_UNKNOWN    = 0,
+  MENUITEM_TYPE_LABEL,
+  MENUITEM_TYPE_SEPARATOR,
+  MENUITEM_TYPE_CHECK,
+  MENUITEM_TYPE_RADIO,
+} QuicklistMenuItemType;
+
+class QuicklistMenuItem : public nux::View
+{
+  public:
+    QuicklistMenuItem (DbusmenuMenuitem* item,
+                       NUX_FILE_LINE_PROTO);
+
+    QuicklistMenuItem (DbusmenuMenuitem* item,
+                       bool              debug,
+                       NUX_FILE_LINE_PROTO);
+
+    virtual ~QuicklistMenuItem ();
+
+    void PreLayoutManagement ();
+
+    long PostLayoutManagement (long layoutResult);
+
+    long ProcessEvent (nux::IEvent& event,
+                       long         traverseInfo,
+                       long         processEventInfo);
+
+    void Draw (nux::GraphicsEngine& gfxContext,
+               bool                 forceDraw);
+
+    void DrawContent (nux::GraphicsEngine& gfxContext,
+                      bool                 forceDraw);
+
+    void PostDraw (nux::GraphicsEngine& gfxContext,
+                   bool                 forceDraw);
+
+    QuicklistMenuItemType GetItemType ();
+    
+    void ItemActivated ();
+
+    sigc::signal<void, QuicklistMenuItem&> sigChanged;
+    sigc::signal<void, QuicklistMenuItem*> sigTextChanged;
+    sigc::signal<void, QuicklistMenuItem*> sigColorChanged;
+    
+    virtual const gchar* GetLabel ();
+
+    virtual bool GetEnabled ();
+
+    virtual bool GetActive ();
+    
+  protected:
+    
+    gchar*                _text;
+    nux::Color            _textColor;
+    int                   _pre_layout_width;
+    int                   _pre_layout_height;
+    nux::CairoGraphics*   _cairoGraphics;
+    
+    nux::BaseTexture*     _normalTexture[2];
+    nux::BaseTexture*     _prelightTexture[2];
+    
+    //! Return the size of the text + size of associated radio button or check box
+    void GetTextExtents (int &width, int &height);
+    void GetTextExtents (const gchar* font, int& width, int& height);
+    virtual void UpdateTexture () = 0;
+    virtual int CairoSurfaceWidth () = 0;
+
+    void RecvMouseEnter (int x, int y, unsigned long button_flags, unsigned long key_flags);
+    void RecvMouseLeave (int x, int y, unsigned long button_flags, unsigned long key_flags);
+    void RecvMouseDown (int x, int y, unsigned long button_flags, unsigned long key_flags);
+    void RecvMouseUp (int x, int y, unsigned long button_flags, unsigned long key_flags);
+    void RecvMouseClick (int x, int y, unsigned long button_flags, unsigned long key_flags);
+    void RecvMouseMove (int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags);
+    void RecvMouseDrag (int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags);
+    
+    sigc::signal<void, QuicklistMenuItem*> sigMouseEnter;
+    sigc::signal<void, QuicklistMenuItem*> sigMouseLeave;
+    sigc::signal<void, QuicklistMenuItem*> sigMouseReleased;
+    sigc::signal<void, QuicklistMenuItem*> sigMouseClick;
+    
+    DbusmenuMenuitem* _menuItem;
+    QuicklistMenuItemType _item_type;
+    
+    nux::Color        _color;   //!< Item rendering color factor.
+    bool              _debug;
+    
+    
+    bool _prelight;   //!< True when the mouse is over the item.
+
+    void DrawRoundedRectangle (cairo_t* cr,
+                               double   aspect,
+                               double   x,
+                               double   y,
+                               double   cornerRadius,
+                               double   width,
+                               double   height);
+
+    void DrawText (cairo_t*   cr,
+                   int        width,
+                   int        height,
+                   nux::Color color);
+
+    friend class QuicklistView;
+};
+
+#endif // QUICKLISTMENUITEM_H

=== added file 'src/QuicklistMenuItemCheckmark.cpp'
--- src/QuicklistMenuItemCheckmark.cpp	1970-01-01 00:00:00 +0000
+++ src/QuicklistMenuItemCheckmark.cpp	2010-11-25 15:47:12 +0000
@@ -0,0 +1,376 @@
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Mirco Müller <[e-mail]>
+ * Authored by: Jay Taoko <[e-mail]>
+ */
+
+#include <gdk/gdk.h>
+#include <gtk/gtk.h>
+
+#include "Nux/Nux.h"
+#include "QuicklistMenuItemCheckmark.h"
+
+#define ITEM_INDENT_ABS        20
+#define ITEM_CORNER_RADIUS_ABS 4
+
+static double
+_align (double val)
+{
+  double fract = val - (int) val;
+
+  if (fract != 0.5f)
+    return (double) ((int) val + 0.5f);
+  else
+    return val;
+}
+
+QuicklistMenuItemCheckmark::QuicklistMenuItemCheckmark (DbusmenuMenuitem* item,
+                                                        NUX_FILE_LINE_DECL) :
+QuicklistMenuItem (item,
+                   NUX_FILE_LINE_PARAM)
+{
+  Initialize (item);
+}
+
+QuicklistMenuItemCheckmark::QuicklistMenuItemCheckmark (DbusmenuMenuitem* item,
+                                                        bool              debug,
+                                                        NUX_FILE_LINE_DECL) :
+QuicklistMenuItem (item,
+                   debug,
+                   NUX_FILE_LINE_PARAM)
+{
+  Initialize (item);
+}
+
+void
+QuicklistMenuItemCheckmark::Initialize (DbusmenuMenuitem* item)
+{
+  _item_type  = MENUITEM_TYPE_CHECK;
+  
+  if (item)
+    _text = g_strdup (dbusmenu_menuitem_property_get (item, DBUSMENU_MENUITEM_PROP_LABEL));
+  else
+    _text = g_strdup ("Check Mark");
+
+  int textWidth = 1;
+  int textHeight = 1;
+  GetTextExtents (textWidth, textHeight);
+  SetMinimumSize (textWidth + ITEM_INDENT_ABS, textHeight);
+}
+
+QuicklistMenuItemCheckmark::~QuicklistMenuItemCheckmark ()
+{
+  if (_normalTexture[0])
+    _normalTexture[0]->UnReference ();
+
+  if (_normalTexture[1])
+    _normalTexture[1]->UnReference ();
+
+  if (_prelightTexture[0])
+    _prelightTexture[0]->UnReference ();
+
+  if (_prelightTexture[1])
+    _prelightTexture[1]->UnReference ();
+}
+
+void
+QuicklistMenuItemCheckmark::PreLayoutManagement ()
+{
+  _pre_layout_width = GetBaseWidth ();
+  _pre_layout_height = GetBaseHeight ();
+
+  if (_normalTexture[0] == 0)
+  {
+    UpdateTexture ();
+  }
+
+  QuicklistMenuItem::PreLayoutManagement ();
+}
+
+long
+QuicklistMenuItemCheckmark::PostLayoutManagement (long layoutResult)
+{
+  int w = GetBaseWidth();
+  int h = GetBaseHeight();
+
+  long result = 0;
+  
+  if (_pre_layout_width < w)
+    result |= nux::eLargerWidth;
+  else if (_pre_layout_width > w)
+    result |= nux::eSmallerWidth;
+  else
+    result |= nux::eCompliantWidth;
+
+  if (_pre_layout_height < h)
+    result |= nux::eLargerHeight;
+  else if (_pre_layout_height > h)
+    result |= nux::eSmallerHeight;
+  else
+    result |= nux::eCompliantHeight;
+
+  return result;
+}
+
+long
+QuicklistMenuItemCheckmark::ProcessEvent (nux::IEvent& event,
+                                          long         traverseInfo,
+                                          long         processEventInfo)
+{
+  long result = traverseInfo;
+
+  result = nux::View::PostProcessEvent2 (event, result, processEventInfo);
+  return result;
+}
+
+void
+QuicklistMenuItemCheckmark::Draw (nux::GraphicsEngine& gfxContext,
+                                  bool                 forceDraw)
+{
+  nux::IntrusiveSP<nux::IOpenGLBaseTexture> texture;
+
+  nux::Geometry base = GetGeometry ();
+
+  gfxContext.PushClippingRectangle (base);
+
+  nux::TexCoordXForm texxform;
+  texxform.SetWrap (nux::TEXWRAP_REPEAT, nux::TEXWRAP_REPEAT);
+  texxform.SetTexCoordType (nux::TexCoordXForm::OFFSET_COORD);
+
+  gfxContext.GetRenderStates().SetBlend (true,
+                                         GL_ONE,
+                                         GL_ONE_MINUS_SRC_ALPHA);
+  
+  if (GetEnabled ())
+  {
+    if (GetActive () && _prelight)
+    {
+      texture = _prelightTexture[0]->GetDeviceTexture ();
+    }
+    else if (GetActive ())
+    {
+      texture = _normalTexture[0]->GetDeviceTexture ();
+    }
+
+    if ((!GetActive ()) && _prelight)
+    {
+      texture = _prelightTexture[1]->GetDeviceTexture ();
+    }
+    else if (!GetActive ())
+    {
+      texture = _normalTexture[1]->GetDeviceTexture ();
+    }
+
+    _color = nux::Color::White;
+  }
+  else
+  {
+    if (GetActive ())
+    {
+      texture = _prelightTexture[0]->GetDeviceTexture ();
+    }
+    else
+    {
+      texture = _normalTexture[0]->GetDeviceTexture ();
+    }
+
+    _color = nux::Color::DarkGray;
+  }
+  
+  gfxContext.QRP_GLSL_1Tex (base.x,
+                            base.y,
+                            base.width,
+                            base.height,
+                            texture,
+                            texxform,
+                            _color);
+
+  gfxContext.GetRenderStates().SetBlend (false);
+
+  gfxContext.PopClippingRectangle ();
+}
+
+void QuicklistMenuItemCheckmark::DrawContent (nux::GraphicsEngine& gfxContext,
+                                         bool                 forceDraw)
+{
+}
+
+void QuicklistMenuItemCheckmark::PostDraw (nux::GraphicsEngine& gfxContext,
+                                      bool                 forceDraw)
+{
+}
+
+void
+QuicklistMenuItemCheckmark::UpdateTexture ()
+{
+  nux::Color transparent = nux::Color (0.0f, 0.0f, 0.0f, 0.0f);
+  int        width       = GetBaseWidth ();
+  int        height      = GetBaseHeight ();
+  
+  _cairoGraphics = new nux::CairoGraphics (CAIRO_FORMAT_ARGB32, width, height);
+  cairo_t *cr = _cairoGraphics->GetContext ();
+
+  // draw normal, unchecked version
+  cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
+  cairo_paint (cr);
+
+  cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
+  cairo_scale (cr, 1.0f, 1.0f);
+  cairo_set_source_rgba (cr, 1.0f, 1.0f, 1.0f, 1.0f);
+  cairo_set_line_width (cr, 1.0f);
+
+  DrawText (cr, width, height, nux::Color::White);
+
+  nux::NBitmapData* bitmap = _cairoGraphics->GetBitmap ();
+
+  if (_normalTexture[0])
+    _normalTexture[0]->UnReference ();
+
+  _normalTexture[0] = nux::GetThreadGLDeviceFactory()->CreateSystemCapableTexture ();
+  _normalTexture[0]->Update (bitmap);
+
+  // draw normal, checked version
+  cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
+  cairo_paint (cr);
+
+  cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
+  cairo_scale (cr, 1.0f, 1.0f);
+  cairo_set_source_rgba (cr, 1.0f, 1.0f, 1.0f, 1.0f);
+  cairo_set_line_width (cr, 1.0f);
+
+  cairo_save (cr);
+  cairo_translate (cr,
+                   _align ((ITEM_INDENT_ABS - 16.0f) / 2.0f),
+                   _align (((double) height - 16.0f)/ 2.0f));
+
+  cairo_set_source_rgba (cr, 1.0f, 1.0f, 1.0f, 1.0f);
+
+  cairo_translate (cr, 3.0f, 1.0f);
+  cairo_move_to (cr, 0.0f, 6.0f);
+  cairo_line_to (cr, 0.0f, 8.0f);
+  cairo_line_to (cr, 4.0f, 12.0f);
+  cairo_line_to (cr, 6.0f, 12.0f);
+  cairo_line_to (cr, 15.0f, 1.0f);
+  cairo_line_to (cr, 15.0f, 0.0f);
+  cairo_line_to (cr, 14.0f, 0.0f);
+  cairo_line_to (cr, 5.0f, 9.0f);
+  cairo_line_to (cr, 1.0f, 5.0f);
+  cairo_close_path (cr);
+  cairo_fill (cr);
+
+  cairo_restore (cr);
+
+  DrawText (cr, width, height, nux::Color::White);
+
+  bitmap = _cairoGraphics->GetBitmap ();
+
+  if (_normalTexture[1])
+    _normalTexture[1]->UnReference ();
+
+  _normalTexture[1] = nux::GetThreadGLDeviceFactory()->CreateSystemCapableTexture ();
+  _normalTexture[1]->Update (bitmap);
+
+  // draw active/prelight, unchecked version
+  cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
+  cairo_paint (cr);
+
+  cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
+  cairo_scale (cr, 1.0f, 1.0f);
+  cairo_set_source_rgba (cr, 1.0f, 1.0f, 1.0f, 1.0f);
+  cairo_set_line_width (cr, 1.0f);
+
+  DrawRoundedRectangle (cr,
+                        1.0f,
+                        0.5f,
+                        0.5f,
+                        ITEM_CORNER_RADIUS_ABS,
+                        width - 1.0f,
+                        height - 1.0f);
+  cairo_fill (cr);
+
+  cairo_set_source_rgba (cr, 0.0f, 0.0f, 0.0f, 0.0f);
+
+  DrawText (cr, width, height, transparent);
+
+  bitmap = _cairoGraphics->GetBitmap ();
+
+  if (_prelightTexture[0])
+    _prelightTexture[0]->UnReference ();
+
+  _prelightTexture[0] = nux::GetThreadGLDeviceFactory()->CreateSystemCapableTexture ();
+  _prelightTexture[0]->Update (bitmap);
+
+  // draw active/prelight, unchecked version
+  cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
+  cairo_paint (cr);
+
+  cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
+  cairo_scale (cr, 1.0f, 1.0f);
+  cairo_set_source_rgba (cr, 1.0f, 1.0f, 1.0f, 1.0f);
+  cairo_set_line_width (cr, 1.0f);
+
+  DrawRoundedRectangle (cr,
+                        1.0f,
+                        0.5f,
+                        0.5f,
+                        ITEM_CORNER_RADIUS_ABS,
+                        width - 1.0f,
+                        height - 1.0f);
+  cairo_fill (cr);
+
+  cairo_set_source_rgba (cr, 0.0f, 0.0f, 0.0f, 0.0f);
+
+  cairo_save (cr);
+  cairo_translate (cr,
+                   _align ((ITEM_INDENT_ABS - 16.0f) / 2.0f),
+                   _align (((double) height - 16.0f) / 2.0f));
+
+  cairo_translate (cr, 3.0f, 1.0f);
+  cairo_move_to (cr, 0.0f, 6.0f);
+  cairo_line_to (cr, 0.0f, 8.0f);
+  cairo_line_to (cr, 4.0f, 12.0f);
+  cairo_line_to (cr, 6.0f, 12.0f);
+  cairo_line_to (cr, 15.0f, 1.0f);
+  cairo_line_to (cr, 15.0f, 0.0f);
+  cairo_line_to (cr, 14.0f, 0.0f);
+  cairo_line_to (cr, 5.0f, 9.0f);
+  cairo_line_to (cr, 1.0f, 5.0f);
+  cairo_close_path (cr);
+  cairo_fill (cr);
+
+  cairo_restore (cr);
+
+  DrawText (cr, width, height, transparent);
+
+  bitmap = _cairoGraphics->GetBitmap ();
+
+  if (_prelightTexture[1])
+    _prelightTexture[1]->UnReference ();
+
+  _prelightTexture[1] = nux::GetThreadGLDeviceFactory()->CreateSystemCapableTexture ();
+  _prelightTexture[1]->Update (bitmap);
+
+  // finally clean up
+  delete _cairoGraphics;
+}
+
+int QuicklistMenuItemCheckmark::CairoSurfaceWidth ()
+{
+  if (_normalTexture[0])
+    return _normalTexture[0]->GetWidth ();
+
+  return 0;
+}

=== added file 'src/QuicklistMenuItemCheckmark.h'
--- src/QuicklistMenuItemCheckmark.h	1970-01-01 00:00:00 +0000
+++ src/QuicklistMenuItemCheckmark.h	2010-11-25 15:47:12 +0000
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Mirco Müller <[e-mail]>
+ * Authored by: Jay Taoko <[e-mail]>
+ */
+
+#ifndef QUICKLISTMENUITEMCHECKMARK_H
+#define QUICKLISTMENUITEMCHECKMARK_H
+
+#include "Nux/Nux.h"
+#include "Nux/View.h"
+#include "NuxImage/CairoGraphics.h"
+
+#include "QuicklistMenuItem.h"
+
+#include <X11/Xlib.h>
+
+class QuicklistMenuItemCheckmark : public QuicklistMenuItem
+{
+  public:
+    QuicklistMenuItemCheckmark (DbusmenuMenuitem* item,
+                                NUX_FILE_LINE_PROTO);
+
+    QuicklistMenuItemCheckmark (DbusmenuMenuitem* item,
+                                bool              debug,
+                                NUX_FILE_LINE_PROTO);
+
+    ~QuicklistMenuItemCheckmark ();
+    
+  protected:
+    
+    void PreLayoutManagement ();
+
+    long PostLayoutManagement (long layoutResult);
+
+    long ProcessEvent (nux::IEvent& event, long traverseInfo, long processEventInfo);
+
+    void Draw (nux::GraphicsEngine& gfxContext, bool forceDraw);
+
+    void DrawContent (nux::GraphicsEngine& gfxContext, bool forceDraw);
+
+    void PostDraw (nux::GraphicsEngine& gfxContext, bool forceDraw);
+    
+    void Initialize (DbusmenuMenuitem* item);
+
+    virtual void UpdateTexture ();
+    virtual int CairoSurfaceWidth ();
+};
+
+#endif // QUICKLISTMENUITEMCHECKMARK_H

=== added file 'src/QuicklistMenuItemLabel.cpp'
--- src/QuicklistMenuItemLabel.cpp	1970-01-01 00:00:00 +0000
+++ src/QuicklistMenuItemLabel.cpp	2010-11-25 15:47:12 +0000
@@ -0,0 +1,258 @@
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Mirco Müller <[e-mail]>
+ * Authored by: Jay Taoko <[e-mail]>
+ */
+
+#include <gdk/gdk.h>
+#include <gtk/gtk.h>
+
+#include "Nux/Nux.h"
+#include "QuicklistMenuItemLabel.h"
+
+#define ITEM_INDENT_ABS        20
+#define ITEM_CORNER_RADIUS_ABS 4
+
+QuicklistMenuItemLabel::QuicklistMenuItemLabel (DbusmenuMenuitem* item,
+                                                        NUX_FILE_LINE_DECL) :
+QuicklistMenuItem (item,
+                   NUX_FILE_LINE_PARAM)
+{
+  Initialize (item);
+}
+
+QuicklistMenuItemLabel::QuicklistMenuItemLabel (DbusmenuMenuitem* item,
+                                                        bool              debug,
+                                                        NUX_FILE_LINE_DECL) :
+QuicklistMenuItem (item,
+                   debug,
+                   NUX_FILE_LINE_PARAM)
+{
+  Initialize (item);
+}
+
+void
+QuicklistMenuItemLabel::Initialize (DbusmenuMenuitem* item)
+{
+  _item_type  = MENUITEM_TYPE_LABEL;
+  
+  if (item)
+    _text = g_strdup (dbusmenu_menuitem_property_get (item, DBUSMENU_MENUITEM_PROP_LABEL));
+  else
+    _text = g_strdup ("Label");
+
+  int textWidth = 1;
+  int textHeight = 1;
+  GetTextExtents (textWidth, textHeight);
+  SetMinimumSize (textWidth + ITEM_INDENT_ABS, textHeight);
+}
+
+QuicklistMenuItemLabel::~QuicklistMenuItemLabel ()
+{ 
+  if (_normalTexture[0])
+    _normalTexture[0]->UnReference ();
+
+  if (_normalTexture[1])
+    _normalTexture[1]->UnReference ();
+
+  if (_prelightTexture[0])
+    _prelightTexture[0]->UnReference ();
+
+  if (_prelightTexture[1])
+    _prelightTexture[1]->UnReference ();
+}
+
+void
+QuicklistMenuItemLabel::PreLayoutManagement ()
+{
+  _pre_layout_width = GetBaseWidth ();
+  _pre_layout_height = GetBaseHeight ();
+
+  if (_normalTexture[0] == 0)
+  {
+    UpdateTexture ();
+  }
+
+  QuicklistMenuItem::PreLayoutManagement ();
+}
+
+long
+QuicklistMenuItemLabel::PostLayoutManagement (long layoutResult)
+{
+  int w = GetBaseWidth();
+  int h = GetBaseHeight();
+
+  long result = 0;
+  
+  if (_pre_layout_width < w)
+    result |= nux::eLargerWidth;
+  else if (_pre_layout_width > w)
+    result |= nux::eSmallerWidth;
+  else
+    result |= nux::eCompliantWidth;
+
+  if (_pre_layout_height < h)
+    result |= nux::eLargerHeight;
+  else if (_pre_layout_height > h)
+    result |= nux::eSmallerHeight;
+  else
+    result |= nux::eCompliantHeight;
+
+  return result;
+}
+
+long
+QuicklistMenuItemLabel::ProcessEvent (nux::IEvent& event,
+                                          long         traverseInfo,
+                                          long         processEventInfo)
+{
+  long result = traverseInfo;
+
+  result = nux::View::PostProcessEvent2 (event, result, processEventInfo);
+  return result;
+}
+
+void
+QuicklistMenuItemLabel::Draw (nux::GraphicsEngine& gfxContext,
+                                  bool                 forceDraw)
+{
+  nux::IntrusiveSP<nux::IOpenGLBaseTexture> texture;
+
+  nux::Geometry base = GetGeometry ();
+
+  gfxContext.PushClippingRectangle (base);
+
+  nux::TexCoordXForm texxform;
+  texxform.SetWrap (nux::TEXWRAP_REPEAT, nux::TEXWRAP_REPEAT);
+  texxform.SetTexCoordType (nux::TexCoordXForm::OFFSET_COORD);
+
+  gfxContext.GetRenderStates().SetBlend (true,
+                                         GL_ONE,
+                                         GL_ONE_MINUS_SRC_ALPHA);
+  
+  if (GetEnabled ())
+  {
+    if (_prelight)
+    {
+      texture = _prelightTexture[0]->GetDeviceTexture ();
+    }
+    else
+    {
+      texture = _normalTexture[0]->GetDeviceTexture ();
+    }
+    _color = nux::Color::White;
+  }
+  else
+  {
+    texture = _normalTexture[0]->GetDeviceTexture ();
+    _color = nux::Color::DarkGray;
+  }
+  
+  gfxContext.QRP_GLSL_1Tex (base.x,
+                            base.y,
+                            base.width,
+                            base.height,
+                            texture,
+                            texxform,
+                            _color);
+
+  gfxContext.GetRenderStates().SetBlend (false);
+
+  gfxContext.PopClippingRectangle ();
+}
+
+void
+QuicklistMenuItemLabel::DrawContent (nux::GraphicsEngine& gfxContext,
+                                         bool                 forceDraw)
+{
+}
+
+void
+QuicklistMenuItemLabel::PostDraw (nux::GraphicsEngine& gfxContext,
+                                      bool                 forceDraw)
+{
+}
+
+void
+QuicklistMenuItemLabel::UpdateTexture ()
+{
+  nux::Color transparent = nux::Color (0.0f, 0.0f, 0.0f, 0.0f);
+  int        width       = GetBaseWidth ();
+  int        height      = GetBaseHeight ();
+  
+  _cairoGraphics = new nux::CairoGraphics (CAIRO_FORMAT_ARGB32, width, height);
+  cairo_t *cr = _cairoGraphics->GetContext ();
+
+  // draw normal, unchecked version
+  cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
+  cairo_paint (cr);
+
+  cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
+  cairo_scale (cr, 1.0f, 1.0f);
+  cairo_set_source_rgba (cr, 1.0f, 1.0f, 1.0f, 1.0f);
+  cairo_set_line_width (cr, 1.0f);
+
+  DrawText (cr, width, height, nux::Color::White);
+
+  nux::NBitmapData* bitmap = _cairoGraphics->GetBitmap ();
+
+  if (_normalTexture[0])
+    _normalTexture[0]->UnReference ();
+
+  _normalTexture[0] = nux::GetThreadGLDeviceFactory()->CreateSystemCapableTexture ();
+  _normalTexture[0]->Update (bitmap);
+
+  // draw active/prelight, unchecked version
+  cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
+  cairo_paint (cr);
+
+  cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
+  cairo_scale (cr, 1.0f, 1.0f);
+  cairo_set_source_rgba (cr, 1.0f, 1.0f, 1.0f, 1.0f);
+  cairo_set_line_width (cr, 1.0f);
+
+  DrawRoundedRectangle (cr,
+                        1.0f,
+                        0.5f,
+                        0.5f,
+                        ITEM_CORNER_RADIUS_ABS,
+                        width - 1.0f,
+                        height - 1.0f);
+  cairo_fill (cr);
+
+  cairo_set_source_rgba (cr, 0.0f, 0.0f, 0.0f, 0.0f);
+
+  DrawText (cr, width, height, transparent);
+
+  bitmap = _cairoGraphics->GetBitmap ();
+
+  if (_prelightTexture[0])
+    _prelightTexture[0]->UnReference ();
+
+  _prelightTexture[0] = nux::GetThreadGLDeviceFactory()->CreateSystemCapableTexture ();
+  _prelightTexture[0]->Update (bitmap);
+
+  // finally clean up
+  delete _cairoGraphics;
+}
+
+int QuicklistMenuItemLabel::CairoSurfaceWidth ()
+{
+  if (_normalTexture[0])
+    return _normalTexture[0]->GetWidth ();
+
+  return 0;
+}

=== added file 'src/QuicklistMenuItemLabel.h'
--- src/QuicklistMenuItemLabel.h	1970-01-01 00:00:00 +0000
+++ src/QuicklistMenuItemLabel.h	2010-11-25 15:47:12 +0000
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Mirco Müller <[e-mail]>
+ * Authored by: Jay Taoko <[e-mail]>
+ */
+
+#ifndef QUICKLISTMENUITEMLABEL_H
+#define QUICKLISTMENUITEMLABEL_H
+
+#include "Nux/Nux.h"
+#include "Nux/View.h"
+#include "NuxImage/CairoGraphics.h"
+
+#include "QuicklistMenuItem.h"
+
+#include <X11/Xlib.h>
+
+class QuicklistMenuItemLabel : public QuicklistMenuItem
+{
+  public:
+    QuicklistMenuItemLabel (DbusmenuMenuitem* item,
+                                NUX_FILE_LINE_PROTO);
+
+    QuicklistMenuItemLabel (DbusmenuMenuitem* item,
+                                bool              debug,
+                                NUX_FILE_LINE_PROTO);
+
+    ~QuicklistMenuItemLabel ();
+    
+  protected:
+    
+    void PreLayoutManagement ();
+
+    long PostLayoutManagement (long layoutResult);
+
+    long ProcessEvent (nux::IEvent& event, long traverseInfo, long processEventInfo);
+
+    void Draw (nux::GraphicsEngine& gfxContext, bool forceDraw);
+
+    void DrawContent (nux::GraphicsEngine& gfxContext, bool forceDraw);
+
+    void PostDraw (nux::GraphicsEngine& gfxContext, bool forceDraw);
+
+    void Initialize (DbusmenuMenuitem* item);
+
+    virtual void UpdateTexture ();
+    virtual int CairoSurfaceWidth ();
+};
+
+#endif // QUICKLISTMENUITEMLABEL_H

=== added file 'src/QuicklistMenuItemRadio.cpp'
--- src/QuicklistMenuItemRadio.cpp	1970-01-01 00:00:00 +0000
+++ src/QuicklistMenuItemRadio.cpp	2010-11-25 15:47:12 +0000
@@ -0,0 +1,315 @@
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Mirco Müller <[e-mail]>
+ */
+
+#include <gdk/gdk.h>
+#include <gtk/gtk.h>
+
+#include "Nux/Nux.h"
+#include "QuicklistMenuItemRadio.h"
+
+#define ITEM_INDENT_ABS        20.0f
+#define ITEM_CORNER_RADIUS_ABS 4.0f
+
+static double
+_align (double val)
+{
+  double fract = val - (int) val;
+
+  if (fract != 0.5f)
+    return (double) ((int) val + 0.5f);
+  else
+    return val;
+}
+
+QuicklistMenuItemRadio::QuicklistMenuItemRadio (DbusmenuMenuitem* item,
+                                                NUX_FILE_LINE_DECL) :
+QuicklistMenuItem (item,
+                   NUX_FILE_LINE_PARAM)
+{
+  Initialize (item);
+}
+
+QuicklistMenuItemRadio::QuicklistMenuItemRadio (DbusmenuMenuitem* item,
+                                                bool              debug,
+                                                NUX_FILE_LINE_DECL) :
+QuicklistMenuItem (item,
+                   debug,
+                   NUX_FILE_LINE_PARAM)
+{
+  Initialize (item);
+}
+
+void
+QuicklistMenuItemRadio::Initialize (DbusmenuMenuitem* item)
+{
+  _item_type  = MENUITEM_TYPE_LABEL;
+  
+  if (item)
+    _text = dbusmenu_menuitem_property_get (item, DBUSMENU_MENUITEM_PROP_LABEL);
+  else
+    _text = "QuicklistItem";
+  
+  _normalTexture[0]   = NULL;
+  _normalTexture[1]   = NULL;
+  _prelightTexture[0] = NULL;
+  _prelightTexture[1] = NULL;
+
+  SetMinimumSize (1, 1);
+  // make sure _dpiX and _dpiY are initialized correctly
+}
+
+QuicklistMenuItemRadio::~QuicklistMenuItemRadio ()
+{
+  if (_normalTexture[0])
+    _normalTexture[0]->UnReference ();
+
+  if (_normalTexture[1])
+    _normalTexture[1]->UnReference ();
+
+  if (_prelightTexture[0])
+    _prelightTexture[0]->UnReference ();
+
+  if (_prelightTexture[1])
+    _prelightTexture[1]->UnReference ();
+}
+
+void
+QuicklistMenuItemRadio::PreLayoutManagement ()
+{
+}
+
+long
+QuicklistMenuItemRadio::PostLayoutManagement (long layoutResult)
+{
+  int w = GetBaseWidth();
+  int h = GetBaseHeight();
+
+  long result = 0;
+  
+  if (_pre_layout_width < w)
+    result |= nux::eLargerWidth;
+  else if (_pre_layout_width > w)
+    result |= nux::eSmallerWidth;
+  else
+    result |= nux::eCompliantWidth;
+
+  if (_pre_layout_height < h)
+    result |= nux::eLargerHeight;
+  else if (_pre_layout_height > h)
+    result |= nux::eSmallerHeight;
+  else
+    result |= nux::eCompliantHeight;
+
+  return result;
+}
+
+long
+QuicklistMenuItemRadio::ProcessEvent (nux::IEvent& event,
+                                      long         traverseInfo,
+                                      long         processEventInfo)
+{
+  long result = traverseInfo;
+
+  result = nux::View::PostProcessEvent2 (event, result, processEventInfo);
+  return result;
+}
+
+void
+QuicklistMenuItemRadio::Draw (nux::GraphicsEngine& gfxContext,
+                              bool                 forceDraw)
+{
+  nux::IntrusiveSP<nux::IOpenGLBaseTexture> texture;
+
+  nux::Geometry base = GetGeometry ();
+
+  gfxContext.PushClippingRectangle (base);
+
+  nux::TexCoordXForm texxform;
+  texxform.SetWrap (nux::TEXWRAP_REPEAT, nux::TEXWRAP_REPEAT);
+  texxform.SetTexCoordType (nux::TexCoordXForm::OFFSET_COORD);
+
+  gfxContext.GetRenderStates().SetBlend (true,
+                                         GL_ONE,
+                                         GL_ONE_MINUS_SRC_ALPHA);
+
+  if (GetActive ())
+    if (GetEnabled ())
+      texture = _prelightTexture[1]->GetDeviceTexture ();
+    else
+      texture = _prelightTexture[0]->GetDeviceTexture ();
+  else
+    if (GetEnabled ())
+      texture = _normalTexture[1]->GetDeviceTexture ();
+    else
+      texture = _normalTexture[0]->GetDeviceTexture ();
+
+  gfxContext.QRP_GLSL_1Tex (base.x,
+                            base.y,
+                            base.width,
+                            base.height,
+                            texture,
+                            texxform,
+                            _color);
+
+  gfxContext.GetRenderStates().SetBlend (false);
+
+  gfxContext.PopClippingRectangle ();
+}
+
+void
+QuicklistMenuItemRadio::DrawContent (nux::GraphicsEngine& gfxContext,
+                                     bool                 forceDraw)
+{
+}
+
+void
+QuicklistMenuItemRadio::PostDraw (nux::GraphicsEngine& gfxContext,
+                                  bool                 forceDraw)
+{
+}
+
+void
+QuicklistMenuItemRadio::UpdateTexture ()
+{
+  int width  = GetBaseWidth ();
+  int height = GetBaseHeight ();
+
+  _cairoGraphics = new nux::CairoGraphics (CAIRO_FORMAT_ARGB32, width, height);
+  cairo_t *cr = _cairoGraphics->GetContext ();
+
+  // draw normal, disabled version
+  cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
+  cairo_paint (cr);
+
+  cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
+  cairo_scale (cr, 1.0f, 1.0f);
+  cairo_set_source_rgba (cr, 1.0f, 1.0f, 1.0f, 1.0f);
+  cairo_set_line_width (cr, 1.0f);
+
+  DrawText (cr, width, height, _textColor);
+
+  nux::NBitmapData* bitmap = _cairoGraphics->GetBitmap ();
+
+  if (_normalTexture[0])
+    _normalTexture[0]->UnReference ();
+
+  _normalTexture[0] = nux::GetThreadGLDeviceFactory()->CreateSystemCapableTexture ();
+  _normalTexture[0]->Update (bitmap);
+
+  // draw normal, enabled version
+  cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
+  cairo_paint (cr);
+
+  cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
+  cairo_scale (cr, 1.0f, 1.0f);
+  cairo_set_source_rgba (cr, 1.0f, 1.0f, 1.0f, 1.0f);
+  cairo_set_line_width (cr, 1.0f);
+
+  double x      = _align (ITEM_INDENT_ABS / 2.0f);
+  double y      = _align ((double) height / 2.0f);
+  double radius = 3.5f;
+
+  cairo_set_source_rgba (cr, 1.0f, 1.0f, 1.0f, 1.0f);
+  cairo_arc (cr, x, y, radius, 0.0f * (G_PI / 180.0f), 360.0f * (G_PI / 180.0f));
+  cairo_fill (cr);
+
+  cairo_set_source_rgba (cr, 1.0f, 1.0f, 1.0f, 1.0f);
+  DrawText (cr, width, height, _textColor);
+
+  bitmap = _cairoGraphics->GetBitmap ();
+
+  if (_normalTexture[1])
+    _normalTexture[1]->UnReference ();
+
+  _normalTexture[1] = nux::GetThreadGLDeviceFactory()->CreateSystemCapableTexture ();
+  _normalTexture[1]->Update (bitmap);
+
+  // draw active/prelight, unchecked version
+  cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
+  cairo_paint (cr);
+
+  cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
+  cairo_scale (cr, 1.0f, 1.0f);
+  cairo_set_source_rgba (cr, 1.0f, 1.0f, 1.0f, 1.0f);
+  cairo_set_line_width (cr, 1.0f);
+
+  DrawRoundedRectangle (cr,
+                        1.0f,
+                        0.5f,
+                        0.5f,
+                        ITEM_CORNER_RADIUS_ABS,
+                        width - 1.0f,
+                        height - 1.0f);
+  cairo_fill (cr);
+
+  cairo_set_source_rgba (cr, 0.0f, 0.0f, 0.0f, 0.0f);
+
+  DrawText (cr, width, height, _textColor);
+
+  bitmap = _cairoGraphics->GetBitmap ();
+
+  if (_prelightTexture[0])
+    _prelightTexture[0]->UnReference ();
+
+  _prelightTexture[0] = nux::GetThreadGLDeviceFactory()->CreateSystemCapableTexture ();
+  _prelightTexture[0]->Update (bitmap);
+
+  // draw active/prelight, unchecked version
+  cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
+  cairo_paint (cr);
+
+  cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
+  cairo_scale (cr, 1.0f, 1.0f);
+  cairo_set_source_rgba (cr, 1.0f, 1.0f, 1.0f, 1.0f);
+  cairo_set_line_width (cr, 1.0f);
+
+  DrawRoundedRectangle (cr,
+                        1.0f,
+                        0.5f,
+                        0.5f,
+                        ITEM_CORNER_RADIUS_ABS,
+                        width - 1.0f,
+                        height - 1.0f);
+  cairo_fill (cr);
+
+  cairo_set_source_rgba (cr, 0.0f, 0.0f, 0.0f, 0.0f);
+
+  cairo_arc (cr, x, y, radius, 0.0f * (G_PI / 180.0f), 360.0f * (G_PI / 180.0f));
+  cairo_fill (cr);
+
+  DrawText (cr, width, height, _textColor);
+
+  bitmap = _cairoGraphics->GetBitmap ();
+
+  if (_prelightTexture[1])
+    _prelightTexture[1]->UnReference ();
+
+  _prelightTexture[1] = nux::GetThreadGLDeviceFactory()->CreateSystemCapableTexture ();
+  _prelightTexture[1]->Update (bitmap);
+
+  // finally clean up
+  delete _cairoGraphics;
+}
+
+int QuicklistMenuItemRadio::CairoSurfaceWidth ()
+{
+  if (_normalTexture[0])
+    return _normalTexture[0]->GetWidth ();
+
+  return 0;
+}
\ No newline at end of file

=== added file 'src/QuicklistMenuItemRadio.h'
--- src/QuicklistMenuItemRadio.h	1970-01-01 00:00:00 +0000
+++ src/QuicklistMenuItemRadio.h	2010-11-25 15:47:12 +0000
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Mirco Müller <[e-mail]>
+ */
+
+#ifndef QUICKLISTMENUITEMRADIO_H
+#define QUICKLISTMENUITEMRADIO_H
+
+#include "Nux/Nux.h"
+#include "Nux/View.h"
+#include "NuxImage/CairoGraphics.h"
+
+#include "QuicklistMenuItem.h"
+
+#include <X11/Xlib.h>
+
+class QuicklistMenuItemRadio : public QuicklistMenuItem
+{
+  public:
+    QuicklistMenuItemRadio (DbusmenuMenuitem* item,
+                            NUX_FILE_LINE_PROTO);
+
+    QuicklistMenuItemRadio (DbusmenuMenuitem* item,
+                            bool              debug,
+                            NUX_FILE_LINE_PROTO);
+
+    ~QuicklistMenuItemRadio ();
+
+    void PreLayoutManagement ();
+
+    long PostLayoutManagement (long layoutResult);
+
+    long ProcessEvent (nux::IEvent& event,
+                       long         traverseInfo,
+                       long         processEventInfo);
+
+    void Draw (nux::GraphicsEngine& gfxContext,
+               bool                 forceDraw);
+
+    void DrawContent (nux::GraphicsEngine& gfxContext,
+                      bool                 forceDraw);
+
+    void PostDraw (nux::GraphicsEngine& gfxContext,
+                   bool                 forceDraw);
+
+  private:
+    nux::NString          _text;
+    nux::Color            _textColor;
+    int                   _pre_layout_width;
+    int                   _pre_layout_height;
+    nux::CairoGraphics*   _cairoGraphics;
+
+    nux::BaseTexture* _normalTexture[2];
+    nux::BaseTexture* _prelightTexture[2];
+
+    void Initialize (DbusmenuMenuitem* item);
+    
+    void UpdateTexture ();
+    virtual int CairoSurfaceWidth ();
+};
+
+#endif // QUICKLISTMENUITEMRADIO_H

=== added file 'src/QuicklistMenuItemSeparator.cpp'
--- src/QuicklistMenuItemSeparator.cpp	1970-01-01 00:00:00 +0000
+++ src/QuicklistMenuItemSeparator.cpp	2010-11-25 15:47:12 +0000
@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Mirco Müller <[e-mail]>
+ */
+
+#include "Nux/Nux.h"
+#include "QuicklistMenuItemSeparator.h"
+
+QuicklistMenuItemSeparator::QuicklistMenuItemSeparator (DbusmenuMenuitem* item,
+                                                        NUX_FILE_LINE_DECL) :
+QuicklistMenuItem (item,
+                   NUX_FILE_LINE_PARAM)
+{
+  SetMinimumHeight (3);
+  SetBaseSize (64, 3);
+  _normalTexture = NULL;
+  _item_type  = MENUITEM_TYPE_SEPARATOR;
+}
+
+QuicklistMenuItemSeparator::QuicklistMenuItemSeparator (DbusmenuMenuitem* item,
+                                                        bool              debug,
+                                                        NUX_FILE_LINE_DECL) :
+QuicklistMenuItem (item,
+                   debug,
+                   NUX_FILE_LINE_PARAM)
+{
+  SetMinimumHeight (3);
+  SetBaseSize (64, 3);
+  _normalTexture = NULL;
+  _item_type  = MENUITEM_TYPE_SEPARATOR;
+}
+
+QuicklistMenuItemSeparator::~QuicklistMenuItemSeparator ()
+{
+}
+
+void
+QuicklistMenuItemSeparator::PreLayoutManagement ()
+{
+  _pre_layout_width = GetBaseWidth ();
+  _pre_layout_height = GetBaseHeight ();
+
+  if((_normalTexture == 0) )
+  {
+    UpdateTexture ();
+  }
+
+  QuicklistMenuItem::PreLayoutManagement ();
+}
+
+long
+QuicklistMenuItemSeparator::PostLayoutManagement (long layoutResult)
+{
+  int w = GetBaseWidth();
+  int h = GetBaseHeight();
+
+  long result = 0;
+  
+  if (_pre_layout_width < w)
+    result |= nux::eLargerWidth;
+  else if (_pre_layout_width > w)
+    result |= nux::eSmallerWidth;
+  else
+    result |= nux::eCompliantWidth;
+
+  if (_pre_layout_height < h)
+    result |= nux::eLargerHeight;
+  else if (_pre_layout_height > h)
+    result |= nux::eSmallerHeight;
+  else
+    result |= nux::eCompliantHeight;
+
+  return result;
+}
+
+long
+QuicklistMenuItemSeparator::ProcessEvent (nux::IEvent& event,
+                                          long         traverseInfo,
+                                          long         processEventInfo)
+{
+  long result = traverseInfo;
+
+  result = nux::View::PostProcessEvent2 (event, result, processEventInfo);
+  return result;
+
+}
+
+void
+QuicklistMenuItemSeparator::Draw (nux::GraphicsEngine& gfxContext,
+                                  bool                 forceDraw)
+{
+  nux::Geometry base = GetGeometry ();
+
+  gfxContext.PushClippingRectangle (base);
+
+  nux::TexCoordXForm texxform;
+  texxform.SetWrap (nux::TEXWRAP_REPEAT, nux::TEXWRAP_REPEAT);
+  texxform.SetTexCoordType (nux::TexCoordXForm::OFFSET_COORD);
+
+  gfxContext.GetRenderStates().SetBlend (true,
+                                         GL_ONE,
+                                         GL_ONE_MINUS_SRC_ALPHA);
+
+  gfxContext.QRP_GLSL_1Tex (base.x,
+                            base.y,
+                            base.width,
+                            base.height,
+                            _normalTexture->GetDeviceTexture(),
+                            texxform,
+                            _color);
+
+  gfxContext.GetRenderStates().SetBlend (false);
+
+  gfxContext.PopClippingRectangle ();
+}
+
+void
+QuicklistMenuItemSeparator::DrawContent (nux::GraphicsEngine& gfxContext,
+                                         bool                 forceDraw)
+{
+}
+
+void
+QuicklistMenuItemSeparator::PostDraw (nux::GraphicsEngine& gfxContext,
+                                      bool                 forceDraw)
+{
+}
+
+void
+QuicklistMenuItemSeparator::UpdateTexture ()
+{
+  int width  = GetBaseWidth ();
+  
+  _cairoGraphics = new nux::CairoGraphics (CAIRO_FORMAT_ARGB32,
+                                           GetBaseWidth (),
+                                           GetBaseHeight ());
+  cairo_t *cr = _cairoGraphics->GetContext ();
+
+  cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
+  cairo_set_source_rgba (cr, 0.0f, 0.0f, 0.0f, 0.0f);
+  cairo_paint (cr);
+  cairo_set_source_rgba (cr, _color.R (), _color.G (), _color.B (), _color.A ());
+  cairo_set_line_width (cr, 1.0f);
+  cairo_move_to (cr, 0.5f, 1.5f);
+  cairo_line_to (cr, width - 0.5f, 1.5f);
+  cairo_stroke (cr);
+
+  nux::NBitmapData* bitmap = _cairoGraphics->GetBitmap ();
+
+  if (_normalTexture)
+    _normalTexture->UnReference ();
+
+  _normalTexture = nux::GetThreadGLDeviceFactory()->CreateSystemCapableTexture ();
+  _normalTexture->Update (bitmap);
+
+  delete _cairoGraphics;
+}
+
+int QuicklistMenuItemSeparator::CairoSurfaceWidth ()
+{
+  if (_normalTexture)
+    return _normalTexture->GetWidth ();
+  
+  return 0;
+}
\ No newline at end of file

=== added file 'src/QuicklistMenuItemSeparator.h'
--- src/QuicklistMenuItemSeparator.h	1970-01-01 00:00:00 +0000
+++ src/QuicklistMenuItemSeparator.h	2010-11-25 15:47:12 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Mirco Müller <[e-mail]>
+ */
+
+#ifndef QUICKLISTMENUITEMSEPARATOR_H
+#define QUICKLISTMENUITEMSEPARATOR_H
+
+#include "Nux/Nux.h"
+#include "Nux/View.h"
+#include "NuxImage/CairoGraphics.h"
+#include "QuicklistMenuItem.h"
+
+#include <X11/Xlib.h>
+
+class QuicklistMenuItemSeparator : public QuicklistMenuItem
+{
+  public:
+    QuicklistMenuItemSeparator (DbusmenuMenuitem* item,
+                                NUX_FILE_LINE_PROTO);
+
+    QuicklistMenuItemSeparator (DbusmenuMenuitem* item,
+                                bool              debug,
+                                NUX_FILE_LINE_PROTO);
+
+    ~QuicklistMenuItemSeparator ();
+
+  protected:
+    
+    void PreLayoutManagement ();
+
+    long PostLayoutManagement (long layoutResult);
+
+    long ProcessEvent (nux::IEvent& event, long traverseInfo, long processEventInfo);
+
+    void Draw (nux::GraphicsEngine& gfxContext, bool forceDraw);
+
+    void DrawContent (nux::GraphicsEngine& gfxContext, bool forceDraw);
+
+    void PostDraw (nux::GraphicsEngine& gfxContext, bool forceDraw);
+    
+    nux::BaseTexture*   _normalTexture;
+
+    virtual void UpdateTexture ();
+    
+    //! Returns the width of the separator line as defined by the size of the _normalTexture.
+    virtual int CairoSurfaceWidth ();
+    
+    friend class QuicklistView;
+};
+
+#endif // QUICKLISTMENUITEMSEPARATOR_H

=== modified file 'src/QuicklistView.cpp' (properties changed: -x to +x)
--- src/QuicklistView.cpp	2010-11-18 04:09:12 +0000
+++ src/QuicklistView.cpp	2010-11-25 15:47:12 +0000
@@ -29,7 +29,11 @@
 #include "NuxImage/CairoGraphics.h"
 
 #include "QuicklistView.h"
-
+#include "QuicklistMenuItem.h"
+#include "QuicklistMenuItemLabel.h"
+#include "QuicklistMenuItemSeparator.h"
+#include "QuicklistMenuItemCheckmark.h"
+#include "QuicklistMenuItemRadio.h"
 
 NUX_IMPLEMENT_OBJECT_TYPE (QuicklistView);
 
@@ -50,6 +54,7 @@
   _padding        = 13;
   _top_size       = 4;
 
+  SetGeometry (nux::Geometry (0, 0, 1, 1));
   _hlayout         = new nux::HLayout (TEXT(""), NUX_TRACKER_LOCATION);
   _vlayout         = new nux::VLayout (TEXT(""), NUX_TRACKER_LOCATION);
   _item_layout     = new nux::VLayout (TEXT(""), NUX_TRACKER_LOCATION);
@@ -67,22 +72,12 @@
   
   _vlayout->AddLayout (_default_item_layout, 0);
   
-  for (int i = 0; i < 2; i++)
-  {
-    nux::StaticCairoText* item_text;
-    item_text = new nux::StaticCairoText (TEXT ("Default Item"), NUX_TRACKER_LOCATION);
-
-    item_text->sigTextChanged.connect (sigc::mem_fun (this, &QuicklistView::RecvCairoTextChanged));
-    item_text->sigTextColorChanged.connect (sigc::mem_fun (this, &QuicklistView::RecvCairoTextColorChanged));
-    _default_item_layout->AddView(item_text, 1, nux::eCenter, nux::eFull);
-    _default_item_list.push_back (item_text);
-    item_text->Reference();
-  }
+  FillInDefaultItems ();
 
   _vlayout->AddLayout (_bottom_space, 0);
 
   _hlayout->AddLayout (_left_space, 0);
-  _hlayout->AddLayout (_vlayout, 1, nux::eCenter, nux::eFull);
+  _hlayout->AddLayout (_vlayout, 0, nux::eCenter, nux::eFull);
   _hlayout->AddLayout (_right_space, 0);
 
   SetWindowSizeMatchLayout (true);
@@ -95,21 +90,81 @@
   OnMouseMove.connect (sigc::mem_fun (this, &QuicklistView::RecvMouseMove));
   OnMouseDrag.connect (sigc::mem_fun (this, &QuicklistView::RecvMouseDrag));
   
+  _mouse_down = false;
 }
 
 QuicklistView::~QuicklistView ()
 {
   if (_texture_bg)
     _texture_bg->UnReference ();
-
-  std::list<nux::StaticCairoText*>::iterator it;
+  
+  if (_texture_outline)
+    _texture_outline->UnReference ();
+  
+    if (_texture_mask)
+    _texture_mask->UnReference ();
+  
+  std::list<QuicklistMenuItem*>::iterator it;
   for (it = _item_list.begin(); it != _item_list.end(); it++)
   {
     (*it)->UnReference();
   }
+
+  for (it = _default_item_list.begin(); it != _default_item_list.end(); it++)
+  {
+    (*it)->UnReference();
+  }
+  
+  _default_item_list.clear ();
   _item_list.clear ();
 }
 
+// This function is for testing. It will go eventually
+void QuicklistView::FillInDefaultItems ()
+{
+  QuicklistMenuItemCheckmark* item = 0;
+  DbusmenuMenuitem* dbus_item = 0;
+  // Enabled and Active Checkmark 
+  dbus_item = dbusmenu_menuitem_new ();
+  dbusmenu_menuitem_property_set (dbus_item, DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE, DBUSMENU_MENUITEM_TOGGLE_CHECK);
+  dbusmenu_menuitem_property_set (dbus_item, DBUSMENU_MENUITEM_PROP_LABEL, "check mark 0");
+  dbusmenu_menuitem_property_set_bool (dbus_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
+  dbusmenu_menuitem_property_set_int (dbus_item, DBUSMENU_MENUITEM_PROP_TOGGLE_STATE, DBUSMENU_MENUITEM_TOGGLE_STATE_UNCHECKED);
+
+  item = new QuicklistMenuItemCheckmark (dbus_item, NUX_TRACKER_LOCATION);
+
+  item->sigTextChanged.connect (sigc::mem_fun (this, &QuicklistView::RecvCairoTextChanged));
+  item->sigColorChanged.connect (sigc::mem_fun (this, &QuicklistView::RecvCairoTextColorChanged));
+  item->sigMouseClick.connect (sigc::mem_fun (this, &QuicklistView::RecvItemMouseClick));
+  item->sigMouseReleased.connect (sigc::mem_fun (this, &QuicklistView::RecvItemMouseRelease));
+  item->sigMouseEnter.connect (sigc::mem_fun (this, &QuicklistView::RecvItemMouseEnter));
+  item->sigMouseLeave.connect (sigc::mem_fun (this, &QuicklistView::RecvItemMouseLeave));
+  
+  _default_item_layout->AddView(item, 1, nux::eCenter, nux::eFull);
+  _default_item_list.push_back (item);
+  item->Reference();
+
+  // Disabled and Active Checkmark 
+  dbus_item = dbusmenu_menuitem_new ();
+  dbusmenu_menuitem_property_set (dbus_item, DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE, DBUSMENU_MENUITEM_TOGGLE_CHECK);
+  dbusmenu_menuitem_property_set (dbus_item, DBUSMENU_MENUITEM_PROP_LABEL, "check mark disabled");
+  dbusmenu_menuitem_property_set_bool (dbus_item, DBUSMENU_MENUITEM_PROP_ENABLED, false);
+  dbusmenu_menuitem_property_set_int (dbus_item, DBUSMENU_MENUITEM_PROP_TOGGLE_STATE, DBUSMENU_MENUITEM_TOGGLE_STATE_UNCHECKED);
+
+  item = new QuicklistMenuItemCheckmark (dbus_item, NUX_TRACKER_LOCATION);
+
+  item->sigTextChanged.connect (sigc::mem_fun (this, &QuicklistView::RecvCairoTextChanged));
+  item->sigColorChanged.connect (sigc::mem_fun (this, &QuicklistView::RecvCairoTextColorChanged));
+  item->sigMouseClick.connect (sigc::mem_fun (this, &QuicklistView::RecvItemMouseClick));
+  item->sigMouseReleased.connect (sigc::mem_fun (this, &QuicklistView::RecvItemMouseRelease));
+  item->sigMouseEnter.connect (sigc::mem_fun (this, &QuicklistView::RecvItemMouseEnter));
+  item->sigMouseLeave.connect (sigc::mem_fun (this, &QuicklistView::RecvItemMouseLeave));
+  
+  _default_item_layout->AddView(item, 1, nux::eCenter, nux::eFull);
+  _default_item_list.push_back (item);
+  item->Reference();
+}
+
 void QuicklistView::ShowQuicklistWithTipAt (int anchor_tip_x, int anchor_tip_y)
 {
   int window_width;
@@ -133,13 +188,6 @@
 void QuicklistView::ShowWindow (bool b, bool start_modal)
 {
   BaseWindow::ShowWindow (b, start_modal);
-  
-  // Reset all colors to white
-  std::list<nux::StaticCairoText*>::iterator it;
-  for (it = _item_list.begin(); it != _item_list.end(); it++)
-  {
-    (*it)->SetTextColor (nux::Color::White);
-  }
 }
 
 long QuicklistView::ProcessEvent (nux::IEvent& ievent, long TraverseInfo, long ProcessEventInfo)
@@ -164,15 +212,50 @@
   }
 
   // We choose to test the quicklist items ourselves instead of processing them as it is usual in nux.
-  // This is meantto be easier since the quicklist has a atypical way of working.
-  // if (m_layout)
-  // ret = m_layout->ProcessEvent (window_event, ret, ProcEvInfo);
+  // This is meant to be easier since the quicklist has a atypical way of working.
+  if (m_layout)
+    ret = m_layout->ProcessEvent (window_event, ret, ProcEvInfo);
 
+  if (ievent.e_event == nux::NUX_MOUSE_PRESSED)
+  {
+    if (GetGeometry ().IsPointInside (ievent.e_x, ievent.e_y))
+    {
+      _mouse_down = true;
+    }
+    else
+    {
+      _mouse_down = false;
+      if (IsVisible ())
+      {
+        CaptureMouseDownAnyWhereElse (false);
+        ForceStopFocus (1, 1);
+        UnGrabPointer ();
+        EnableInputWindow (false);
+        ShowWindow (false);
+      }
+      return nux::eMouseEventSolved;
+    }
+  }
+  else if ((ievent.e_event == nux::NUX_MOUSE_RELEASED) && _mouse_down)
+  {
+    
+    _mouse_down = false;
+    if (IsVisible ())
+    {
+      CaptureMouseDownAnyWhereElse (false);
+      ForceStopFocus (1, 1);
+      UnGrabPointer ();
+      EnableInputWindow (false);
+      ShowWindow (false);
+    }
+    return nux::eMouseEventSolved;
+  }
+  
   // PostProcessEvent2 must always have its last parameter set to 0
   // because the m_BackgroundArea is the real physical limit of the window.
   // So the previous test about IsPointInside do not prevail over m_BackgroundArea
   // testing the event by itself.
-  ret = PostProcessEvent2 (ievent, ret, 0);
+  //ret = PostProcessEvent2 (ievent, ret, 0);
   return ret;    
 }
 
@@ -224,7 +307,7 @@
 
   nux::GetGraphicsEngine().GetRenderStates().SetBlend (false);
 
-  std::list<nux::StaticCairoText*>::iterator it;
+  std::list<QuicklistMenuItem*>::iterator it;
   for (it = _item_list.begin(); it != _item_list.end(); it++)
   {
     (*it)->ProcessDraw(gfxContext, forceDraw);
@@ -234,7 +317,6 @@
   {
     (*it)->ProcessDraw(gfxContext, forceDraw);
   }
-  
 
   gfxContext.PopClippingRectangle ();
 }
@@ -249,7 +331,7 @@
   int MaxItemWidth = 0;
   int TotalItemHeight = 0;
   
-  std::list<nux::StaticCairoText*>::iterator it;
+  std::list<QuicklistMenuItem*>::iterator it;
   for (it = _item_list.begin(); it != _item_list.end(); it++)
   {
     int  textWidth  = 0;
@@ -269,12 +351,20 @@
       MaxItemWidth = textWidth;
     TotalItemHeight += textHeight;
   }
-  
+
   if(TotalItemHeight < _anchor_height)
   {
     _top_space->SetMinMaxSize(1, (_anchor_height - TotalItemHeight)/2 +1 + _padding + _corner_radius);
     _bottom_space->SetMinMaxSize(1, (_anchor_height - TotalItemHeight)/2 +1 + _padding + _corner_radius);
   }
+  else
+  {
+    _top_space->SetMinMaxSize(_padding + _corner_radius, _padding + _corner_radius);
+    _bottom_space->SetMinMaxSize(_padding + _corner_radius, _padding + _corner_radius);
+   }
+
+  _item_layout->SetMinimumWidth(MaxItemWidth);
+  _default_item_layout->SetMinimumWidth(MaxItemWidth);
 
   BaseWindow::PreLayoutManagement ();
 }
@@ -282,37 +372,101 @@
 long QuicklistView::PostLayoutManagement (long LayoutResult)
 {
   long result = BaseWindow::PostLayoutManagement (LayoutResult);
+  
   UpdateTexture ();
 
   int x = _padding + _anchor_width + _corner_radius;
   int y = _padding + _corner_radius;
 
-  std::list<nux::StaticCairoText*>::iterator it;
-  for (it = _item_list.begin(); it != _item_list.end(); it++)
-  {
-    (*it)->SetBaseX (x);
-    (*it)->SetBaseY (y);
-
-    y += (*it)->GetBaseHeight ();
-  }
-
-  for (it = _default_item_list.begin(); it != _default_item_list.end(); it++)
-  {
-    (*it)->SetBaseX (x);
-    (*it)->SetBaseY (y);
-
-    y += (*it)->GetBaseHeight ();
-  }
-  
+  std::list<QuicklistMenuItem*>::iterator it;
+  for (it = _item_list.begin(); it != _item_list.end(); it++)
+  {
+    (*it)->SetBaseX (x);
+    (*it)->SetBaseY (y);
+
+    y += (*it)->GetBaseHeight ();
+  }
+
+  for (it = _default_item_list.begin(); it != _default_item_list.end(); it++)
+  {
+    (*it)->SetBaseX (x);
+    (*it)->SetBaseY (y);
+
+    y += (*it)->GetBaseHeight ();
+  }
+
+  // We must correct the width of line separators. The rendering of the separator can be smaller than the width of the
+  // quicklist. The reason for that is, the quicklist width is determined by the largest entry it contains. That size is 
+  // only after MaxItemWidth is computed in QuicklistView::PreLayoutManagement.
+  // The setting of the separator width is done here after the Layout cycle for this widget is over. The width of the separator 
+  // has bee set correctly during the layout cycle, but the cairo rendering still need to be adjusted.
+  int separator_width = nux::Max<int>(_default_item_layout->GetBaseWidth (), _item_layout->GetBaseWidth ());
+  
+  for (it = _item_list.begin(); it != _item_list.end(); it++)
+  {
+    QuicklistMenuItem* item = (QuicklistMenuItem*) (*it);
+    if (item->CairoSurfaceWidth () != separator_width)
+    {
+      // Compute textures of the item.
+      item->UpdateTexture ();
+    }
+  }
+  
+  for (it = _default_item_list.begin(); it != _default_item_list.end(); it++)
+  {
+    QuicklistMenuItem* item = (QuicklistMenuItem*) (*it);
+    if (item->CairoSurfaceWidth () != separator_width)
+    {
+      // Compute textures of the item.
+      item->UpdateTexture ();
+    }
+  }
+
   return result;
 }
 
-void QuicklistView::RecvCairoTextChanged (nux::StaticCairoText& cairo_text)
+void QuicklistView::RecvCairoTextChanged (QuicklistMenuItem* cairo_text)
 {
   _cairo_text_has_changed = true;
 }
 
-void QuicklistView::RecvCairoTextColorChanged (nux::StaticCairoText& cairo_text)
+void QuicklistView::RecvCairoTextColorChanged (QuicklistMenuItem* cairo_text)
+{
+  NeedRedraw ();
+}
+
+void QuicklistView::RecvItemMouseClick (QuicklistMenuItem* item)
+{
+  _mouse_down = false;
+  if (IsVisible ())
+  {
+    CaptureMouseDownAnyWhereElse (false);
+    ForceStopFocus (1, 1);
+    UnGrabPointer ();
+    EnableInputWindow (false);
+    ShowWindow (false);
+  }
+}
+
+void QuicklistView::RecvItemMouseRelease (QuicklistMenuItem* item)
+{
+  _mouse_down = false;
+  if (IsVisible ())
+  {
+    CaptureMouseDownAnyWhereElse (false);
+    ForceStopFocus (1, 1);
+    UnGrabPointer ();
+    EnableInputWindow (false);
+    ShowWindow (false);
+  }  
+}
+
+void QuicklistView::RecvItemMouseEnter (QuicklistMenuItem* item)
+{
+  NeedRedraw ();
+}
+
+void QuicklistView::RecvItemMouseLeave (QuicklistMenuItem* item)
 {
   NeedRedraw ();
 }
@@ -348,58 +502,12 @@
 
 void QuicklistView::RecvMouseMove (int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags)
 {
-  std::list<nux::StaticCairoText*>::iterator it;
-  for (it = _item_list.begin(); it != _item_list.end(); it++)
-  {
-    if ((*it)->GetGeometry ().IsPointInside (x, y))
-    {
-      (*it)->SetTextColor (nux::Color::DarkGray);
-    }
-    else
-    {
-      (*it)->SetTextColor (nux::Color::White);
-    }
-  }
-  
-  for (it = _default_item_list.begin(); it != _default_item_list.end(); it++)
-  {
-    if ((*it)->GetGeometry ().IsPointInside (x, y))
-    {
-      (*it)->SetTextColor (nux::Color::DarkGray);
-    }
-    else
-    {
-      (*it)->SetTextColor (nux::Color::White);
-    }
-  }  
+
 }
 
 void QuicklistView::RecvMouseDrag (int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags)
 {
-  std::list<nux::StaticCairoText*>::iterator it;
-  for (it = _item_list.begin(); it != _item_list.end(); it++)
-  {
-    if ((*it)->GetGeometry ().IsPointInside (x, y))
-    {
-      (*it)->SetTextColor (nux::Color::DarkGray);
-    }
-    else
-    {
-      (*it)->SetTextColor (nux::Color::White);
-    }
-  }
-  
-  for (it = _default_item_list.begin(); it != _default_item_list.end(); it++)
-  {
-    if ((*it)->GetGeometry ().IsPointInside (x, y))
-    {
-      (*it)->SetTextColor (nux::Color::DarkGray);
-    }
-    else
-    {
-      (*it)->SetTextColor (nux::Color::White);
-    }
-  }  
+
 }
   
 void QuicklistView::RecvMouseDownOutsideOfQuicklist (int x, int y, unsigned long button_flags, unsigned long key_flags)
@@ -417,21 +525,29 @@
 void QuicklistView::RemoveAllMenuItem ()
 {
   _item_list.clear ();
+  _default_item_list.clear ();
+  
   _item_layout->Clear ();
+  _default_item_layout->Clear ();
   _cairo_text_has_changed = true;
   nux::GetGraphicsThread ()->AddObjectToRefreshList (this);
 }
 
-void QuicklistView::AddMenuItem (nux::NString str)
+void QuicklistView::AddMenuItem (QuicklistMenuItem* item)
 {
-  nux::StaticCairoText* item_text;
-  item_text = new nux::StaticCairoText (str.GetTCharPtr (), NUX_TRACKER_LOCATION);
+  if (item == 0)
+    return;
 
-  item_text->sigTextChanged.connect (sigc::mem_fun (this, &QuicklistView::RecvCairoTextChanged));
-  item_text->sigTextColorChanged.connect (sigc::mem_fun (this, &QuicklistView::RecvCairoTextColorChanged));
-  _item_layout->AddView(item_text, 1, nux::eCenter, nux::eFull);
-  _item_list.push_back (item_text);
-  item_text->Reference();
+  item->sigTextChanged.connect (sigc::mem_fun (this, &QuicklistView::RecvCairoTextChanged));
+  item->sigColorChanged.connect (sigc::mem_fun (this, &QuicklistView::RecvCairoTextColorChanged));
+  item->sigMouseClick.connect (sigc::mem_fun (this, &QuicklistView::RecvItemMouseClick));
+  item->sigMouseReleased.connect (sigc::mem_fun (this, &QuicklistView::RecvItemMouseRelease));
+  item->sigMouseEnter.connect (sigc::mem_fun (this, &QuicklistView::RecvItemMouseEnter));
+  item->sigMouseLeave.connect (sigc::mem_fun (this, &QuicklistView::RecvItemMouseLeave));
+   
+  _item_layout->AddView(item, 1, nux::eCenter, nux::eFull);
+  _item_list.push_back (item);
+  item->Reference();
   
   _cairo_text_has_changed = true;
   nux::GetGraphicsThread ()->AddObjectToRefreshList (this);
@@ -442,10 +558,54 @@
 {
   
 }
-  
-/////////////////////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////////////////////////
+
+int QuicklistView::GetNumItems ()
+{
+  return _item_list.size () + _default_item_list.size ();
+}
+
+QuicklistMenuItem* QuicklistView::GetNthItems (int index)
+{
+  if (index < (int)_item_list.size ())
+  {
+    int i = 0;
+    std::list<QuicklistMenuItem*>::iterator it;
+    for (i = 0, it = _item_list.begin(); it != _item_list.end(); i++, it++)
+    {
+      if (i == index)
+        return *it;
+    }
+  }
+
+  if (index < (int)_item_list.size () + (int)_default_item_list.size ())
+  {
+    int i = 0;
+    if (_item_list.size () > 0)
+      i = _item_list.size () -1;
+    std::list<QuicklistMenuItem*>::iterator it;
+    for (it = _item_list.begin(); it != _item_list.end(); i++, it++)
+    {
+      if (i == index)
+        return *it;
+    }
+  }
+
+  return 0;
+}
+
+QuicklistMenuItemType QuicklistView::GetNthType  (int index)
+{
+  QuicklistMenuItem* item = GetNthItems (index);
+  if (item)
+    return item->GetItemType ();
+  return MENUITEM_TYPE_UNKNOWN;
+}
+
+std::list<QuicklistMenuItem*> QuicklistView::GetChildren ()
+{
+  std::list<QuicklistMenuItem*> l;
+  return l;
+}
 
 static inline void ql_blurinner (guchar* pixel,
   gint   *zR,
@@ -1152,3 +1312,40 @@
   _labelText = text;
   UpdateTexture ();
 }
+
+void QuicklistView::TestMenuItems (DbusmenuMenuitem* root)
+{
+  RemoveAllMenuItem ();
+  
+  if (root == 0)
+    return;
+  
+  GList * child = NULL;
+  for (child = dbusmenu_menuitem_get_children(root); child != NULL; child = g_list_next(child))
+  {
+    const gchar* type = dbusmenu_menuitem_property_get ((DbusmenuMenuitem*)child->data, DBUSMENU_MENUITEM_PROP_TYPE);
+    const gchar* toggle_type = dbusmenu_menuitem_property_get ((DbusmenuMenuitem*)child->data, DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE);
+    
+    if (g_strcmp0 (type, DBUSMENU_CLIENT_TYPES_SEPARATOR) == 0)
+    {
+      QuicklistMenuItemSeparator* item = new QuicklistMenuItemSeparator ((DbusmenuMenuitem*)child->data, NUX_TRACKER_LOCATION);
+      AddMenuItem (item);
+    }
+    else if (g_strcmp0 (toggle_type, DBUSMENU_MENUITEM_TOGGLE_CHECK) == 0)    
+    {
+      QuicklistMenuItemCheckmark* item = new QuicklistMenuItemCheckmark ((DbusmenuMenuitem*)child->data, NUX_TRACKER_LOCATION);
+      AddMenuItem (item);
+    }
+    else if (g_strcmp0 (toggle_type, DBUSMENU_MENUITEM_TOGGLE_RADIO) == 0)    
+    {
+      QuicklistMenuItemRadio* item = new QuicklistMenuItemRadio ((DbusmenuMenuitem*)child->data, NUX_TRACKER_LOCATION);
+      AddMenuItem (item);
+    }
+    else //if (g_strcmp0 (type, DBUSMENU_MENUITEM_PROP_LABEL) == 0)    
+    {
+      QuicklistMenuItemLabel* item = new QuicklistMenuItemLabel ((DbusmenuMenuitem*)child->data, NUX_TRACKER_LOCATION);
+      AddMenuItem (item);
+    }
+  }
+}
+

=== modified file 'src/QuicklistView.h' (properties changed: -x to +x)
--- src/QuicklistView.h	2010-11-18 03:39:39 +0000
+++ src/QuicklistView.h	2010-11-25 15:47:12 +0000
@@ -25,14 +25,11 @@
 #include "NuxGraphics/GraphicsEngine.h"
 #include "Nux/TextureArea.h"
 #include "NuxImage/CairoGraphics.h"
-#include "StaticCairoText.h"
 
 #include <pango/pango.h>
 #include <pango/pangocairo.h>
 
-#if defined(NUX_OS_LINUX)
-#include <X11/Xlib.h>
-#endif
+#include "QuicklistMenuItem.h"
 
 #define ANCHOR_WIDTH         10.0f
 #define ANCHOR_HEIGHT        18.0f
@@ -50,6 +47,8 @@
 class VLayout;
 class HLayout;
 class SpaceLayout;
+class QuicklistMenuItem;
+class QuicklistMenuItemLabel;
 
 class QuicklistView : public nux::BaseWindow
 {
@@ -72,15 +71,28 @@
   void SetText (nux::NString text);
   
   void RemoveAllMenuItem ();
-  void AddMenuItem (nux::NString str);
+  
+  void AddMenuItem (QuicklistMenuItem* item);
+  
   void RenderQuicklistView ();
 
   void ShowQuicklistWithTipAt (int anchor_tip_x, int anchor_tip_y);
   virtual void ShowWindow (bool b, bool StartModal = false);
   
+  int GetNumItems ();
+  QuicklistMenuItem* GetNthItems (int index);
+  QuicklistMenuItemType GetNthType  (int index);
+  std::list<QuicklistMenuItem*> GetChildren ();
+  
+  void TestMenuItems (DbusmenuMenuitem* root);
+  
 private:
-  void RecvCairoTextChanged (nux::StaticCairoText& cairo_text);
-  void RecvCairoTextColorChanged (nux::StaticCairoText& cairo_text);
+  void RecvCairoTextChanged (QuicklistMenuItem* item);
+  void RecvCairoTextColorChanged (QuicklistMenuItem* item);
+  void RecvItemMouseClick (QuicklistMenuItem* item);
+  void RecvItemMouseRelease (QuicklistMenuItem* item);
+  void RecvItemMouseEnter (QuicklistMenuItem* item);
+  void RecvItemMouseLeave (QuicklistMenuItem* item);
   
   void RecvMouseDown (int x, int y, unsigned long button_flags, unsigned long key_flags);
   void RecvMouseUp (int x, int y, unsigned long button_flags, unsigned long key_flags);
@@ -99,6 +111,9 @@
 
   void NotifyConfigurationChange (int width, int height);
 
+  //! A convenience function to fill in the default quicklist with some random items.
+  void FillInDefaultItems ();
+  
   //nux::CairoGraphics*   _cairo_graphics;
   int                   _anchorX;
   int                   _anchorY;
@@ -107,9 +122,10 @@
   int                   _dpiY;
   int                   _top_size; // size of the segment from point 13 to 14. See figure in ql_compute_full_mask_path.
 
+  bool                  _mouse_down;
+  
   cairo_font_options_t* _fontOpts;
 
-  nux::StaticCairoText* _tooltip_text;
   nux::BaseTexture*     _texture_bg;
   nux::BaseTexture*     _texture_mask;
   nux::BaseTexture*     _texture_outline;
@@ -129,8 +145,8 @@
 
   bool _cairo_text_has_changed;
   void UpdateTexture ();
-  std::list<nux::StaticCairoText*> _item_list;
-  std::list<nux::StaticCairoText*> _default_item_list;
+  std::list<QuicklistMenuItem*> _item_list;
+  std::list<QuicklistMenuItem*> _default_item_list;
 };
 
 #endif // QUICKLISTVIEW_H

=== modified file 'src/StaticCairoText.cpp'
--- src/StaticCairoText.cpp	2010-11-17 04:45:59 +0000
+++ src/StaticCairoText.cpp	2010-11-25 15:47:12 +0000
@@ -17,6 +17,9 @@
  * Authored by: Mirco Müller <[e-mail]
  */
 
+#include <gdk/gdk.h>
+#include <gtk/gtk.h>
+
 #include "Nux/Nux.h"
 #include "Nux/Layout.h"
 #include "Nux/HLayout.h"
@@ -27,76 +30,32 @@
 namespace nux
 {
   StaticCairoText::StaticCairoText (const TCHAR* text,
-                                       NUX_FILE_LINE_DECL) :
+                                    NUX_FILE_LINE_DECL) :
   View (NUX_FILE_LINE_PARAM)
 {
-#if defined(NUX_OS_WINDOWS)
-  _fontName   = TEXT ("Arial");
-#elif defined(NUX_OS_LINUX)
-  _fontName   = TEXT ("Ubuntu");
-#endif
-  _fontSize   = 12;
-  _fontStyle  = eNormalStyle;
-  _fontWeight = eNormalWeight;
   _textColor  = Color(1.0f, 1.0f, 1.0f, 1.0f);
   _text       = TEXT (text);
-  _fontOpts   = cairo_font_options_create ();
   _texture2D  = 0;
 
-  // FIXME: hard-coding these for the moment, as we don't have
-  // gsettings-support in place right now
-  cairo_font_options_set_antialias (_fontOpts, CAIRO_ANTIALIAS_SUBPIXEL);
-  cairo_font_options_set_hint_metrics (_fontOpts, CAIRO_HINT_METRICS_ON);
-  cairo_font_options_set_hint_style (_fontOpts, CAIRO_HINT_STYLE_SLIGHT);
-  cairo_font_options_set_subpixel_order (_fontOpts, CAIRO_SUBPIXEL_ORDER_RGB);
-
   SetMinimumSize (1, 1);
-  // make sure _dpiX and _dpiY are initialized correctly
-  GetDPI ();
-}
-
-  StaticCairoText::StaticCairoText (const TCHAR* text,
-                                       NString      fontName,
-                                       float        fontSize,
-                                       eFontStyle   fontStyle,
-                                       eFontWeight  fontWeight,
-                                       Color        textColor,
-                                       NUX_FILE_LINE_DECL) :
-  View (NUX_FILE_LINE_PARAM)
-{
-  _text = TEXT (text);
-  _fontName = fontName;
-  _fontSize = fontSize;
-  _fontStyle = fontStyle;
-  _fontWeight = fontWeight;
-  _textColor = textColor;
-  _fontOpts  = cairo_font_options_create ();
-
-  // FIXME: hard-coding these for the moment, as we don't have
-  // gsettings-support in place right now
-  cairo_font_options_set_antialias (_fontOpts, CAIRO_ANTIALIAS_SUBPIXEL);
-  cairo_font_options_set_hint_metrics (_fontOpts, CAIRO_HINT_METRICS_ON);
-  cairo_font_options_set_hint_style (_fontOpts, CAIRO_HINT_STYLE_SLIGHT);
-  cairo_font_options_set_subpixel_order (_fontOpts, CAIRO_SUBPIXEL_ORDER_RGB);
-
-  // make sure _dpiX and _dpiY are initialized correctly
-  GetDPI ();
 }
 
 StaticCairoText::~StaticCairoText ()
 {
-  cairo_font_options_destroy (_fontOpts);
   delete (_cairoGraphics);
   delete (_texture2D);
 }
 
 void StaticCairoText::PreLayoutManagement ()
 {
-  int textWidth  = 0;
-  int textHeight = 0;
+  int          textWidth  = 0;
+  int          textHeight = 0;
+  GtkSettings* settings   = gtk_settings_get_default (); // not ref'ed
+  gchar*       fontName   = NULL;
 
-  NString str = NString::Printf(TEXT("%s %.2f"), _fontName.GetTCharPtr (), _fontSize);
-  GetTextExtents (str.GetTCharPtr (), textWidth, textHeight);
+  g_object_get (settings, "gtk-font-name", &fontName, NULL);
+  GetTextExtents (fontName, textWidth, textHeight);
+  g_free (fontName);
 
   _pre_layout_width = GetBaseWidth ();
   _pre_layout_height = GetBaseHeight ();
@@ -198,51 +157,7 @@
   {
     _text = text;
     UpdateTexture ();
-    sigTextChanged.emit (*this);
-  }
-}
-
-void
-StaticCairoText::SetFontName (NString fontName)
-{
-  if (_fontName != fontName)
-  {
-    _fontName = fontName;
-    UpdateTexture ();
-    sigTextChanged.emit (*this);
-  }
-}
-
-void
-StaticCairoText::SetFontSize (float fontSize)
-{
-  if (_fontSize != fontSize)
-  {
-    _fontSize = fontSize;
-    UpdateTexture ();
-    sigTextChanged.emit (*this);
-  }
-}
-
-void
-StaticCairoText::SetFontWeight (eFontWeight fontWeight)
-{
-  if (_fontWeight != fontWeight)
-  {
-    _fontWeight = fontWeight;
-    UpdateTexture ();
-    sigTextChanged.emit (*this);
-  }
-}
-
-void
-StaticCairoText::SetFontStyle (eFontStyle fontStyle)
-{
-  if (_fontStyle != fontStyle)
-  {
-    _fontStyle = fontStyle;
-    UpdateTexture ();
-    sigTextChanged.emit (*this);
+    sigTextChanged.emit (this);
   }
 }
 
@@ -252,48 +167,18 @@
   if (_textColor != textColor)
   {
     _textColor = textColor;
-    sigTextColorChanged.emit (*this);
+    sigTextColorChanged.emit (this);
   }
 }
 
-void
-StaticCairoText::GetDPI ()
-{
-#if defined(NUX_OS_LINUX)
-  Display* display     = NULL;
-  int      screen      = 0;
-  double   dpyWidth    = 0.0;
-  double   dpyHeight   = 0.0;
-  double   dpyWidthMM  = 0.0;
-  double   dpyHeightMM = 0.0;
-  double   dpiX        = 0.0;
-  double   dpiY        = 0.0;
-
-  display = XOpenDisplay (NULL);
-  screen = DefaultScreen (display);
-
-  dpyWidth    = (double) DisplayWidth (display, screen);
-  dpyHeight   = (double) DisplayHeight (display, screen);
-  dpyWidthMM  = (double) DisplayWidthMM (display, screen);
-  dpyHeightMM = (double) DisplayHeightMM (display, screen);
-
-  dpiX = dpyWidth * 25.4 / dpyWidthMM;
-  dpiY = dpyHeight * 25.4 / dpyHeightMM;
-
-  _dpiX = (int) (dpiX + 0.5);
-  _dpiY = (int) (dpiY + 0.5);
-
-  XCloseDisplay (display);
-#elif defined(NUX_OS_WINDOWS)
-  _dpiX = 72;
-  _dpiY = 72;
-#endif
-}
-
 void StaticCairoText::GetTextExtents (int &width, int &height)
 {
-  NString str = NString::Printf(TEXT("%s %.2f"), _fontName.GetTCharPtr (), _fontSize);
-  GetTextExtents (str.GetTCharPtr (), width, height);
+  GtkSettings* settings = gtk_settings_get_default (); // not ref'ed
+  gchar*       fontName = NULL;
+
+  g_object_get (settings, "gtk-font-name", &fontName, NULL);
+  GetTextExtents (fontName, width, height);
+  g_free (fontName);
 }
 
 void StaticCairoText::GetTextExtents (const TCHAR* font,
@@ -306,6 +191,9 @@
   PangoFontDescription* desc     = NULL;
   PangoContext*         pangoCtx = NULL;
   PangoRectangle        logRect  = {0, 0, 0, 0};
+  int                   dpi      = 0;
+  GdkScreen*            screen   = gdk_screen_get_default ();   // is not ref'ed
+  GtkSettings*          settings = gtk_settings_get_default (); // is not ref'ed
 
   // sanity check
   if (!font)
@@ -313,6 +201,7 @@
 
   surface = cairo_image_surface_create (CAIRO_FORMAT_A1, 1, 1);
   cr = cairo_create (surface);
+  cairo_set_font_options (cr, gdk_screen_get_font_options (screen));
   layout = pango_cairo_create_layout (cr);
   desc = pango_font_description_from_string (font);
   pango_font_description_set_weight (desc, PANGO_WEIGHT_NORMAL);
@@ -321,8 +210,19 @@
   pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_END);
   pango_layout_set_markup (layout, _text.GetTCharPtr(), -1);
   pangoCtx = pango_layout_get_context (layout); // is not ref'ed
-  pango_cairo_context_set_font_options (pangoCtx, _fontOpts);
-  pango_cairo_context_set_resolution (pangoCtx, _dpiX);
+  pango_cairo_context_set_font_options (pangoCtx,
+                                        gdk_screen_get_font_options (screen));
+  g_object_get (settings, "gtk-xft-dpi", &dpi, NULL);
+  if (dpi == -1)
+  {
+    // use some default DPI-value
+    pango_cairo_context_set_resolution (pangoCtx, 96.0f);
+  }
+  else
+  {
+    pango_cairo_context_set_resolution (pangoCtx,
+                                        (float) dpi / (float) PANGO_SCALE);
+  }
   pango_layout_context_changed (layout);
   pango_layout_get_extents (layout, NULL, &logRect);
 
@@ -346,22 +246,35 @@
   PangoLayout*          layout     = NULL;
   PangoFontDescription* desc       = NULL;
   PangoContext*         pangoCtx   = NULL;
-
-  NString str = NString::Printf(TEXT("%s %.2f"), _fontName.GetTCharPtr (), _fontSize);
-  GetTextExtents (str.GetTCharPtr (), textWidth, textHeight);
-
-  cairo_set_font_options (cr, _fontOpts);
+  int                   dpi        = 0;
+  GdkScreen*            screen     = gdk_screen_get_default ();   // not ref'ed
+  GtkSettings*          settings   = gtk_settings_get_default (); // not ref'ed
+  gchar*                fontName   = NULL;
+
+  g_object_get (settings, "gtk-font-name", &fontName, NULL);
+  GetTextExtents (fontName, textWidth, textHeight);
+
+  cairo_set_font_options (cr, gdk_screen_get_font_options (screen));
   layout = pango_cairo_create_layout (cr);
-  //desc = pango_font_description_from_string ((char*) FONT_FACE);
-  desc = pango_font_description_from_string (str.GetTCharPtr ());
-  pango_font_description_set_weight (desc, (PangoWeight) _fontWeight);
+  desc = pango_font_description_from_string (fontName);
   pango_layout_set_font_description (layout, desc);
   pango_layout_set_wrap (layout, PANGO_WRAP_WORD_CHAR);
   pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_END);
   pango_layout_set_markup (layout, _text.GetTCharPtr(), -1);
   pangoCtx = pango_layout_get_context (layout); // is not ref'ed
-  pango_cairo_context_set_font_options (pangoCtx, _fontOpts);
-  pango_cairo_context_set_resolution (pangoCtx, (double) _dpiX);
+  pango_cairo_context_set_font_options (pangoCtx,
+                                        gdk_screen_get_font_options (screen));
+  g_object_get (settings, "gtk-xft-dpi", &dpi, NULL);
+  if (dpi == -1)
+  {
+    // use some default DPI-value
+    pango_cairo_context_set_resolution (pangoCtx, 96.0f);
+  }
+  else
+  {
+    pango_cairo_context_set_resolution (pangoCtx,
+                                        (float) dpi / (float) PANGO_SCALE);
+  }
 
   cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
   cairo_set_source_rgba (cr, 0.0f, 0.0f, 0.0f, 0.0f);
@@ -376,6 +289,7 @@
   // clean up
   pango_font_description_free (desc);
   g_object_unref (layout);
+  g_free (fontName);
 }
 
 void StaticCairoText::UpdateTexture ()

=== modified file 'src/StaticCairoText.h'
--- src/StaticCairoText.h	2010-11-17 04:45:59 +0000
+++ src/StaticCairoText.h	2010-11-25 15:47:12 +0000
@@ -14,7 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Jay Taoko <[e-mail]>
- * Authored by: Mirco Müller <[e-mail]
+ * Authored by: Mirco Müller <[e-mail]>
  */
 
 #ifndef STATICCAIROTEXT_H
@@ -35,20 +35,6 @@
 
 namespace nux
 {
-  enum eFontStyle
-  {
-    eNormalStyle  = PANGO_STYLE_NORMAL,
-    eObliqueStyle = PANGO_STYLE_OBLIQUE,
-    eItalicStyle  = PANGO_STYLE_ITALIC,
-  };
-
-  enum eFontWeight
-  {
-    eLightWeight  = PANGO_WEIGHT_LIGHT,
-    eNormalWeight = PANGO_WEIGHT_NORMAL,
-    eBoldWeight   = PANGO_WEIGHT_BOLD,
-  };
-
   class Validator;
 
   class StaticCairoText : public View
@@ -56,14 +42,6 @@
     public:
       StaticCairoText (const TCHAR* text, NUX_FILE_LINE_PROTO);
 
-      StaticCairoText (const TCHAR*     text,
-                       NString     fontName,
-                       float            fontSize,
-                       eFontStyle  fontStyle,
-                       eFontWeight fontWeight,
-                       Color       textColor,
-                       NUX_FILE_LINE_PROTO);
-
       ~StaticCairoText ();
 
       void PreLayoutManagement ();
@@ -71,59 +49,45 @@
       long PostLayoutManagement (long layoutResult);
 
       long ProcessEvent (IEvent& event,
-        long    traverseInfo,
-        long    processEventInfo);
+                         long    traverseInfo,
+                         long    processEventInfo);
 
       void Draw (GraphicsEngine& gfxContext,
-            bool             forceDraw);
+                 bool             forceDraw);
 
       void DrawContent (GraphicsEngine& gfxContext,
-                   bool             forceDraw);
+                        bool             forceDraw);
 
       void PostDraw (GraphicsEngine& gfxContext,
-                bool             forceDraw);
+                     bool             forceDraw);
 
       // public API
       void SetText (NString text);
 
-      void SetFontName (NString fontName);
-
-      void SetFontSize (float fontSize);
-
-      void SetFontWeight (eFontWeight fontWeight);
-
-      void SetFontStyle (eFontStyle fontStyle);
-
       void SetTextColor (Color textColor);
 
       void GetTextExtents (int &width, int &height);
 
-      sigc::signal<void, StaticCairoText&> sigTextChanged;
-      sigc::signal<void, StaticCairoText&> sigTextColorChanged;
+      sigc::signal<void, StaticCairoText*> sigTextChanged;
+      sigc::signal<void, StaticCairoText*> sigTextColorChanged;
 
-    protected:
-	  
     private:
-      NString          _text;
-      NString          _fontName;
-      float                 _fontSize;
-      eFontStyle       _fontStyle;
-      eFontWeight      _fontWeight;
-      Color            _textColor;
-
-      CairoGraphics*   _cairoGraphics;
-      BaseTexture*     _texture2D;
-      int                   _dpiX;
-      int                   _dpiY;
-      cairo_font_options_t* _fontOpts;
-
-      int _pre_layout_width;
-      int _pre_layout_height;
-
-      void GetDPI ();
-
-      void GetTextExtents (const TCHAR* font, int &width, int &height);
-      void DrawText (cairo_t*   cr, int width, int height, Color color);
+      NString        _text;
+      Color          _textColor;
+
+      CairoGraphics* _cairoGraphics;
+      BaseTexture*   _texture2D;
+
+      int            _pre_layout_width;
+      int            _pre_layout_height;
+
+      void GetTextExtents (const TCHAR* font,
+                           int&         width,
+                           int&         height);
+      void DrawText (cairo_t* cr,
+                     int      width,
+                     int      height,
+                     Color    color);
 
       void UpdateTexture ();
   };

=== modified file 'src/Tooltip.cpp'
--- src/Tooltip.cpp	2010-11-18 15:13:23 +0000
+++ src/Tooltip.cpp	2010-11-25 15:47:12 +0000
@@ -28,6 +28,8 @@
 #include "Nux/TextureArea.h"
 #include "NuxImage/CairoGraphics.h"
 
+#include "QuicklistMenuItem.h"
+
 #include "Tooltip.h"
 
 namespace nux
@@ -211,7 +213,7 @@
     return result;
   }
 
-  void Tooltip::RecvCairoTextChanged (StaticCairoText& cairo_text)
+  void Tooltip::RecvCairoTextChanged (StaticCairoText* cairo_text)
   {
     _cairo_text_has_changed = true;
   }

=== modified file 'src/Tooltip.h'
--- src/Tooltip.h	2010-11-18 03:39:39 +0000
+++ src/Tooltip.h	2010-11-25 15:47:12 +0000
@@ -47,12 +47,14 @@
 #define V_MARGIN             4
 #define FONT_FACE            "Ubuntu 13"
 
+class QuicklistMenuItem;
+  
 namespace nux
 {
   class VLayout;
   class HLayout;
   class SpaceLayout;
-  
+
   class Tooltip : public BaseWindow
   {
     NUX_DECLARE_OBJECT_TYPE (Tooltip, BaseWindow);
@@ -75,7 +77,7 @@
 
     void ShowTooltipWithTipAt (int anchor_tip_x, int anchor_tip_y);
   private:
-    void RecvCairoTextChanged (StaticCairoText& cairo_text);
+    void RecvCairoTextChanged (StaticCairoText* cairo_text);
 
     void PreLayoutManagement ();
 

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2010-11-25 12:09:08 +0000
+++ tests/CMakeLists.txt	2010-11-25 15:47:12 +0000
@@ -34,6 +34,7 @@
 add_executable (test-unit
                 unit/TestFavoriteStoreGSettings.cpp
                 unit/TestPanelService.cpp
+                unit/TestQuicklistMenuitems.cpp
                 unit/TestMain.cpp
                 unit/TestUBus.cpp
                 ../libunity/ubus-server.c
@@ -44,6 +45,18 @@
                 ../src/FavoriteStore.h
                 ../src/FavoriteStoreGSettings.cpp
                 ../src/FavoriteStoreGSettings.h
+                ../src/QuicklistMenuItem.cpp
+                ../src/QuicklistMenuItem.h
+                ../src/QuicklistMenuItemCheckmark.cpp
+                ../src/QuicklistMenuItemCheckmark.h
+                ../src/QuicklistMenuItemLabel.cpp
+                ../src/QuicklistMenuItemLabel.h
+                ../src/QuicklistMenuItemRadio.cpp
+                ../src/QuicklistMenuItemRadio.h
+                ../src/QuicklistMenuItemSeparator.cpp
+                ../src/QuicklistMenuItemSeparator.h
+                ../src/QuicklistView.cpp
+                ../src/QuicklistView.h
                 )
 
 add_executable (test-panel

=== modified file 'tests/unit/TestMain.cpp' (properties changed: -x to +x)
--- tests/unit/TestMain.cpp	2010-11-25 12:08:52 +0000
+++ tests/unit/TestMain.cpp	2010-11-25 15:47:12 +0000
@@ -21,10 +21,44 @@
 #include "config.h"
 #include <glib.h>
 #include <glib-object.h>
+#include "Nux/Nux.h"
+#include "Nux/WindowThread.h"
 
 void TestFavoriteStoreGSettingsCreateSuite (void);
 void TestPanelServiceCreateSuite (void);
+<<<<<<< TREE
 void TestUBusCreateSuite (void);
+=======
+void TestQuicklistMenuitemsCreateSuite (void);
+
+nux::WindowThread*
+createThread ()
+{
+  nux::WindowThread* thread = NULL;
+
+  nux::NuxInitialize (0);
+  thread = nux::CreateGUIThread (TEXT ("Unit-Test Dummy Window"),
+                                 320,
+                                 240,
+                                 0,
+                                 NULL,
+                                 0);
+  return thread;
+}
+
+void
+runThread (nux::WindowThread* thread)
+{
+  thread->Run (NULL);
+}
+
+void
+stopThread (nux::WindowThread* thread)
+{
+  thread->TerminateThread ();
+  delete thread;
+}
+>>>>>>> MERGE-SOURCE
 
 int
 main (int argc, char **argv)
@@ -39,7 +73,20 @@
   //Keep alphabetical please
   TestFavoriteStoreGSettingsCreateSuite ();
   TestPanelServiceCreateSuite ();
+<<<<<<< TREE
   TestUBusCreateSuite ();
 
   return g_test_run ();
+=======
+  TestQuicklistMenuitemsCreateSuite ();
+
+  nux::WindowThread* thread = createThread ();
+
+  int ret = g_test_run ();
+
+  stopThread (thread);
+
+  return ret;
+
+>>>>>>> MERGE-SOURCE
 }

=== added file 'tests/unit/TestQuicklistMenuitems.cpp'
--- tests/unit/TestQuicklistMenuitems.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit/TestQuicklistMenuitems.cpp	2010-11-25 15:47:12 +0000
@@ -0,0 +1,238 @@
+/*
+ * Copyright 2010 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the  Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Mirco Müller <[e-mail]>
+ *
+ */
+
+#include "config.h"
+
+#include "QuicklistMenuItem.h"
+#include "QuicklistMenuItemCheckmark.h"
+#include "QuicklistMenuItemLabel.h"
+#include "QuicklistMenuItemRadio.h"
+#include "QuicklistMenuItemSeparator.h"
+
+#include "Nux/Nux.h"
+#include "Nux/VLayout.h"
+#include "Nux/HLayout.h"
+#include "Nux/WindowThread.h"
+#include "Nux/WindowCompositor.h"
+#include "Nux/BaseWindow.h"
+
+#include "QuicklistView.h"
+#include "TestThreadHelper.h"
+
+static void TestMenuItemCheckmark (void);
+static void TestMenuItemLabel     (void);
+static void TestMenuItemRadio     (void);
+static void TestMenuItemSeparator (void);
+static void TestQuicklistMenuItem (void);
+
+nux::WindowThread* thread = NULL;
+
+void
+TestQuicklistMenuitemsCreateSuite ()
+{
+#define _DOMAIN "/Unit/QuicklistMenuitems"
+
+  g_test_add_func (_DOMAIN"/MenuItemCheckmark", TestMenuItemCheckmark);
+  g_test_add_func (_DOMAIN"/MenuItemLabel",     TestMenuItemLabel);
+  g_test_add_func (_DOMAIN"/MenuItemRadio",     TestMenuItemRadio);
+  g_test_add_func (_DOMAIN"/MenuItemSeparator", TestMenuItemSeparator);
+  g_test_add_func (_DOMAIN"/QuicklistMenuItem", TestQuicklistMenuItem);
+}
+
+static void
+TestMenuItemCheckmark ()
+{
+  DbusmenuMenuitem* item = NULL;
+
+
+  item = dbusmenu_menuitem_new ();
+
+  dbusmenu_menuitem_property_set (item,
+                                  DBUSMENU_MENUITEM_PROP_LABEL,
+                                  "Unchecked");
+
+  dbusmenu_menuitem_property_set (item,
+                                  DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE,
+                                  DBUSMENU_MENUITEM_TOGGLE_CHECK);
+
+  dbusmenu_menuitem_property_set_bool (item,
+                                       DBUSMENU_MENUITEM_PROP_ENABLED,
+                                       false);
+
+  dbusmenu_menuitem_property_set_int (item,
+                                      DBUSMENU_MENUITEM_PROP_TOGGLE_STATE,
+                                      DBUSMENU_MENUITEM_TOGGLE_STATE_UNCHECKED);
+
+  QuicklistMenuItemCheckmark* qlCheckmarkItem = NULL;
+
+  qlCheckmarkItem = new QuicklistMenuItemCheckmark (item, true);
+
+  g_assert_cmpstr (qlCheckmarkItem->GetLabel (), ==, "Unchecked");
+  g_assert_cmpint (qlCheckmarkItem->GetEnabled (), ==, false);
+  g_assert_cmpint (qlCheckmarkItem->GetActive (), ==, false);
+
+  //qlCheckmarkItem->sigChanged.connect (sigc::mem_fun (pointerToCallerClass,
+  //                                                    &CallerClass::RecvChanged));
+
+
+  qlCheckmarkItem->Dispose ();
+  g_object_unref (item);
+}
+
+static void
+TestMenuItemLabel ()
+{
+  DbusmenuMenuitem* item = NULL;
+
+  item = dbusmenu_menuitem_new ();
+
+  dbusmenu_menuitem_property_set (item,
+                                  DBUSMENU_MENUITEM_PROP_LABEL,
+                                  "A Label");
+
+  dbusmenu_menuitem_property_set_bool (item,
+                                       DBUSMENU_MENUITEM_PROP_ENABLED,
+                                       true);
+
+  QuicklistMenuItemLabel* qlLabelItem = NULL;
+
+  qlLabelItem = new QuicklistMenuItemLabel (item, true);
+
+  g_assert_cmpstr (qlLabelItem->GetLabel (), ==, "A Label");
+  g_assert_cmpint (qlLabelItem->GetEnabled (), ==, true);
+
+  //qlLabelItem->sigChanged.connect (sigc::mem_fun (pointerToCallerClass,
+  //                                                &CallerClass::RecvChanged));
+    
+  qlLabelItem->Dispose ();
+  g_object_unref (item);
+}
+
+static void
+TestMenuItemRadio ()
+{
+  DbusmenuMenuitem* item = NULL;
+
+  item = dbusmenu_menuitem_new ();
+
+  dbusmenu_menuitem_property_set (item,
+                                  DBUSMENU_MENUITEM_PROP_LABEL,
+                                  "Radio Active");
+
+  dbusmenu_menuitem_property_set (item,
+                                  DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE,
+                                  DBUSMENU_MENUITEM_TOGGLE_RADIO);
+
+  dbusmenu_menuitem_property_set_bool (item,
+                                       DBUSMENU_MENUITEM_PROP_ENABLED,
+                                       true);
+
+  dbusmenu_menuitem_property_set_int (item,
+                                      DBUSMENU_MENUITEM_PROP_TOGGLE_STATE,
+                                      DBUSMENU_MENUITEM_TOGGLE_STATE_CHECKED);
+
+  QuicklistMenuItemRadio* qlRadioItem = NULL;
+
+  qlRadioItem = new QuicklistMenuItemRadio (item, true);
+
+  g_assert_cmpstr (qlRadioItem->GetLabel (), ==, "Radio Active");
+  g_assert_cmpint (qlRadioItem->GetEnabled (), ==, true);
+  g_assert_cmpint (qlRadioItem->GetActive (), ==, true);
+
+  //qlRadioItem->sigChanged.connect (sigc::mem_fun (pointerToCallerClass,
+  //                                                &CallerClass::RecvChanged));
+    
+  qlRadioItem->Dispose ();
+  g_object_unref (item);
+}
+
+static void
+TestMenuItemSeparator ()
+{
+  DbusmenuMenuitem* item = NULL;
+
+  item = dbusmenu_menuitem_new ();
+
+  dbusmenu_menuitem_property_set (item,
+                                  "type",
+                                  DBUSMENU_CLIENT_TYPES_SEPARATOR);
+
+  dbusmenu_menuitem_property_set_bool (item,
+                                       DBUSMENU_MENUITEM_PROP_ENABLED,
+                                       true);
+
+  QuicklistMenuItemSeparator* qlSeparatorItem = NULL;
+
+  qlSeparatorItem = new QuicklistMenuItemSeparator (item, true);
+
+  g_assert_cmpint (qlSeparatorItem->GetEnabled (), ==, true);
+
+  qlSeparatorItem->Dispose ();
+  g_object_unref (item);
+}
+
+static void
+TestQuicklistMenuItem ()
+{
+  DbusmenuMenuitem* root = dbusmenu_menuitem_new ();
+  
+  dbusmenu_menuitem_set_root (root, true);
+
+  DbusmenuMenuitem* child = dbusmenu_menuitem_new ();
+  dbusmenu_menuitem_property_set (child, DBUSMENU_MENUITEM_PROP_TYPE, DBUSMENU_MENUITEM_PROP_LABEL);
+  dbusmenu_menuitem_property_set (child, DBUSMENU_MENUITEM_PROP_LABEL, "label 0");
+  dbusmenu_menuitem_property_set_bool (child, DBUSMENU_MENUITEM_PROP_ENABLED, true);
+  dbusmenu_menuitem_child_append (root, child);
+  
+  child = dbusmenu_menuitem_new ();
+  dbusmenu_menuitem_property_set (child, DBUSMENU_MENUITEM_PROP_TYPE, DBUSMENU_CLIENT_TYPES_SEPARATOR);
+  dbusmenu_menuitem_property_set_bool (child, DBUSMENU_MENUITEM_PROP_ENABLED, true);
+  dbusmenu_menuitem_child_append (root, child);
+  
+  child = dbusmenu_menuitem_new ();
+  dbusmenu_menuitem_property_set (child, DBUSMENU_MENUITEM_PROP_TYPE, DBUSMENU_MENUITEM_PROP_LABEL);
+  dbusmenu_menuitem_property_set (child, DBUSMENU_MENUITEM_PROP_LABEL, "label 1");
+  dbusmenu_menuitem_property_set_bool (child, DBUSMENU_MENUITEM_PROP_ENABLED, true);
+  dbusmenu_menuitem_child_append (root, child);
+  
+  child = dbusmenu_menuitem_new ();
+  dbusmenu_menuitem_property_set (child, DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE, DBUSMENU_MENUITEM_TOGGLE_CHECK);
+  dbusmenu_menuitem_property_set (child, DBUSMENU_MENUITEM_PROP_LABEL, "check mark 0");
+  dbusmenu_menuitem_property_set_bool (child, DBUSMENU_MENUITEM_PROP_ENABLED, true);
+  dbusmenu_menuitem_property_set_int (child, DBUSMENU_MENUITEM_PROP_TOGGLE_STATE, DBUSMENU_MENUITEM_TOGGLE_STATE_UNCHECKED);
+  dbusmenu_menuitem_child_append (root, child);
+
+  QuicklistView* quicklist = new QuicklistView ();
+  
+  quicklist->TestMenuItems (root);
+  
+  g_assert_cmpint (quicklist->GetNumItems (), ==, 4);
+  g_assert_cmpint (quicklist->GetNthType (0), ==, MENUITEM_TYPE_LABEL);
+  g_assert_cmpint (quicklist->GetNthType (1), ==, MENUITEM_TYPE_SEPARATOR);
+  g_assert_cmpint (quicklist->GetNthType (2), ==, MENUITEM_TYPE_LABEL);
+  g_assert_cmpint (quicklist->GetNthType (3), ==, MENUITEM_TYPE_CHECK);
+  
+  g_assert_cmpstr (quicklist->GetNthItems (0)->GetLabel (), ==, "label 0");
+  g_assert_cmpstr (quicklist->GetNthItems (2)->GetLabel (), ==, "label 1");
+  g_assert_cmpstr (quicklist->GetNthItems (3)->GetLabel (), ==, "check mark 0");
+  
+  
+  quicklist->Dispose ();  
+}

=== added file 'tests/unit/TestThreadHelper.h'
--- tests/unit/TestThreadHelper.h	1970-01-01 00:00:00 +0000
+++ tests/unit/TestThreadHelper.h	2010-11-25 15:47:12 +0000
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2010 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the  Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Mirco Müller <[e-mail]>
+ *
+ */
+
+extern nux::WindowThread* createThread (void);
+extern void               runThread (nux::WindowThread* thread);
+extern void               stopThread (nux::WindowThread* thread);