Merge lp:~azzar1/unity/shortcut-hint into lp:unity

[Andrea Azzarone]

Display a shortcut hints overlay during the super key pressing.

It includes two unit tests and a standalone test.

Mockup: https://launchpadlibrarian.net/85352653/Super_key_shutcuts_overlay.png
Branch: http://ubuntuone.com/7cqBbWAbvXTRCT4ySFj7z4

Visual diff: http://ubuntuone.com/014zDKCoxaQYmtm8mS5pp8

Keep in mind that something is different because the shortcuts values are not hardcoded.

[Marco Trevisan (Treviño) (3v1n0)]

I've just looked at few things but it seem good, however remember to unregister the ubus controller (i.e as done in lp:~vanvugt/unity/fix-887465-trunk ) in ~Controller and to use g_markup_escape_text ;).

[Andrea Azzarone (azzar1)]

Marco you should not review a WIP :P

> I've just looked at few things but it seem good, however remember to unregister the ubus controller (i.e as done in lp:~vanvugt/unity/fix-887465-trunk )

Thanks for tip.

> and to use g_markup_escape_text ;).

We no longer need it ;)

[Marco Trevisan (Treviño) (3v1n0)]

That was not a review, just a comment! :)

[Jeremy Bícha (jbicha)]

Hi, I hope you don't mind me giving feedback on the wording choices since it's still WIP...

Please use Trash instead of Rubbish Bin; the en_GB translation can change it back to Rubbish Bin.

The verb should consistently add the trailing "s" or not. In other words, "open" or "opens". For the Ubuntu system help, we left off the "s" but it could just as easily go the other way.

I'd like to see the keyboard keys always capitalized; I think some are stored as lowercase in metacity or whatever, but for display you should be able to upper-case them. ("Super + s" should be "Super + S").

How about "arrow keys" instead of "cursor keys"?

I believe menu bar is slightly preferred over top bar.

[Andrea Azzarone (azzar1)]

It's a WIP btw here's the mockup: https://launchpadlibrarian.net/85352653/Super_key_shutcuts_overlay.png.

[Marco Biscaro (marcobiscaro2112)]

Another comment :) there is a typo here:

+ hints_.push_back(new shortcut::Hint(_("Switching"), "", "", _("Moves the foucs."), shortcut::HARDCODED_OPTION, _("Cursor Left & Right")));

[Tim Penhey (thumper)]

another comment, since this isn't yet a review :-)

properties should be lower case.

[Tim Penhey (thumper)]

Hi Andy,

Can you add links for the design mockup, and a picture of what is
rendered with this branch?

Cheers,
Tim

[Tim Penhey (thumper)]

Purely visual review:

The mockup lines are not white, but either transparent white or
transparent grey. The headings of each group are also not white.

The lines in the mockup are 1px thin grey with distinct ends. The view
has thicker lines that are brighter that taper at the ends.

The white-space above the "Windows" header is greater than the rest.

Some of the key-bindings are lower case, why is that?

Why are we missing some of the key bindings, like moving the focused
window to other workspaces?

Tim

review: Needs Information

[Andrea Azzarone (azzar1)]

> Purely visual review:
>
> The mockup lines are not white, but either transparent white or
> transparent grey. The headings of each group are also not white.
>
> The lines in the mockup are 1px thin grey with distinct ends. The view
> has thicker lines that are brighter that taper at the ends.
>

I'll look to it.

>
> The white-space above the "Windows" header is greater than the rest.
>

Yeah, because i've commented a couple of key bindings because they are not yet implemented.

>
> Some of the key-bindings are lower case, why is that?
>

Because Compiz CompOption gives me something like that: <Super>f... I've writed a very simple function to change it in "Super + f". I think the best solution is to capitalize each word of the shortcut.

> Why are we missing some of the key bindings, like moving the focused
> window to other workspaces?

As said, some options are not yet implmented. For example, regarding "Move focused window to different workspace" I can't find it in CCSM.

[John Lea (johnlea)]

Looking great! ;-) However there are a few minor issues that need to be fixed before this lands.

The feedback below is based on comparing the implementation screenshot posted with the following designs:
- https://launchpadlibrarian.net/85352653/Super_key_shutcuts_overlay.png (the design itself)
- https://launchpadlibrarian.net/86861725/keyboard_shortcuts_sizes.png (the grid the design is build on)

Items in need of fixing:

1. The divider lines should by 10% opacity (while remaining 100% white)

2. The divider should start flush with text, and end flush with grid (see grid design above)

3. The divider lines should have flat ends

4. The spacing of the title "Keyboard Shortcuts" is slightly out, should have slightly more space above than below (see design)

5. The spacing of the section titles is slightly out, should have slightly more space above each title than below (see design)

6. The shortcuts need updating to exactly match those specified in the following document https://docs.google.com/a/canonical.com/document/d/1jqeKtIJwqLtl58Wk_fqjr9Rrgxn9zsouCYOo-cZsLSE/edit?authkey=CLGG9NkJ&hl=en_GB

Once these are fixed we are good to go, thx!

review: Needs Fixing (design)

[Marco Trevisan (Treviño) (3v1n0)]

> > Why are we missing some of the key bindings, like moving the focused
> > window to other workspaces?
>
> As said, some options are not yet implmented. For example, regarding "Move
> focused window to different workspace" I can't find it in CCSM.

It's under desktop wall -> bindings -> Move with window within wall

Plus, I put here for reference as well, the bottom edge has some issues here:
 - http://ubuntuone.com/5bB2px39meddmAtL4bomM2

review: Needs Fixing

[Marco Trevisan (Treviño) (3v1n0)]

> 6. The shortcuts need updating to exactly match those specified in the
> following document https://docs.google.com/a/canonical.com/document/d
> /1jqeKtIJwqLtl58Wk_fqjr9Rrgxn9zsouCYOo-cZsLSE/edit?authkey=CLGG9NkJ&hl=en_GB

About the Alt+` shortcut... As it depends to the keyboard layout (i.e. in the Italian we have Alt+\ in fact), I guess that it should be localized...

[Andrea Azzarone (azzar1)]

> Looking great! ;-) However there are a few minor issues that need to be fixed
> before this lands.
>
> The feedback below is based on comparing the implementation screenshot posted
> with the following designs:
> - https://launchpadlibrarian.net/85352653/Super_key_shutcuts_overlay.png (the
> design itself)
> - https://launchpadlibrarian.net/86861725/keyboard_shortcuts_sizes.png (the
> grid the design is build on)
>
> Items in need of fixing:
>
> 1. The divider lines should by 10% opacity (while remaining 100% white)
>

Done.

> 2. The divider should start flush with text, and end flush with grid (see grid
> design above)

Done.

>
> 3. The divider lines should have flat ends

Done.

>
> 4. The spacing of the title "Keyboard Shortcuts" is slightly out, should have
> slightly more space above than below (see design)
>

Done.

> 5. The spacing of the section titles is slightly out, should have slightly
> more space above each title than below (see design)

Done.

>
> 6. The shortcuts need updating to exactly match those specified in the
> following document https://docs.google.com/a/canonical.com/document/d
> /1jqeKtIJwqLtl58Wk_fqjr9Rrgxn9zsouCYOo-cZsLSE/edit?authkey=CLGG9NkJ&hl=en_GB
>
> Once these are fixed we are good to go, thx!

I'll do it tomorrow.

[Andrea Azzarone (azzar1)]

Ok ready for the review. I've fixed something in the layout but I don't know if I've fixed the Marco's problem. Marco can you test it please? If you still have the same problem, can you check your DPI?

[Tim Penhey (thumper)]

A general pass over the code and it seems OK, but nothing in UnityCore.

review: Approve

[John Lea (johnlea)]

awesome, everything perfect, great to see a attached .png with the visual design matched up against the implementation.

thanks!

review: Approve (design)

[Marco Trevisan (Treviño) (3v1n0)]

I've just checked again this branch, but I still get that visual issue that I've already mentioned :(

[Marco Trevisan (Treviño) (3v1n0)]

I'm working on a branch dependent on this (lp:~3v1n0/unity/unity-dialog), working to fix the issue I got.

So, approving.

review: Approve

[Unity Merger (unity-merger)]

Attempt to merge into lp:unity failed due to conflicts:

text conflict in standalone-clients/CMakeLists.txt

=== added file 'plugins/unityshell/src/AbstractSeparator.cpp'
--- plugins/unityshell/src/AbstractSeparator.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/AbstractSeparator.cpp	2012-01-13 15:39:27 +0000
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2011 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: Jay Taoko <[e-mail]>
+ *
+ */
+
+#include "AbstractSeparator.h"
+
+#include "Nux/Nux.h"
+
+namespace unity
+{
+
+AbstractSeparator::AbstractSeparator(NUX_FILE_LINE_DECL)
+  : nux::View(NUX_FILE_LINE_PARAM)
+  , color_(nux::color::White)
+  , alpha0_(0.0f)
+  , alpha1_(0.10f)
+  , border_size_(0)
+{
+}
+
+// Maybe it's better to use default arguments?
+AbstractSeparator::AbstractSeparator(nux::Color const& color, float alpha0, 
+                                     float alpha1, int border, NUX_FILE_LINE_DECL)
+  : nux::View(NUX_FILE_LINE_PARAM)
+  , color_(color)
+  , alpha0_(alpha0)
+  , alpha1_(alpha1)
+  , border_size_(border)
+{
+}
+
+AbstractSeparator::~AbstractSeparator()
+{
+
+}
+
+void AbstractSeparator::SetColor(nux::Color const &color)
+{
+  color_ = color;
+}
+
+void AbstractSeparator::SetAlpha(float alpha0, float alpha1)
+{
+  alpha0_ = alpha0;
+  alpha1_ = alpha1;
+}
+
+void AbstractSeparator::SetBorderSize(int border)
+{
+  border_size_ = border;
+}
+
+} // namespace unity

=== added file 'plugins/unityshell/src/AbstractSeparator.h'
--- plugins/unityshell/src/AbstractSeparator.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/AbstractSeparator.h	2012-01-13 15:39:27 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2011 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: Jay Taoko <[e-mail]>
+ *
+ */
+
+#ifndef UNITYSHELL_ABSTRACTSEPARATOR_H
+#define UNITYSHELL_ABSTRACTSEPARATOR_H
+
+#include <Nux/Nux.h>
+#include <Nux/View.h>
+
+namespace unity
+{
+  
+class AbstractSeparator: public nux::View
+{
+public:
+  AbstractSeparator(NUX_FILE_LINE_PROTO);
+  AbstractSeparator(nux::Color const& color, float alpha0, float alpha1, int vorder, NUX_FILE_LINE_PROTO);
+  ~AbstractSeparator();
+  
+  void SetColor(nux::Color const& color);
+  void SetAlpha(float alpha0, float alpha1);
+  void SetBorderSize(int border);
+
+protected:
+  nux::Color color_;
+  float alpha0_;
+  float alpha1_;
+  int border_size_;
+};
+
+} // namespace unity
+
+#endif // UNITYSHELL_ABSTRACTSEPARATOR_H

=== added file 'plugins/unityshell/src/AbstractShortcutHint.h'
--- plugins/unityshell/src/AbstractShortcutHint.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/AbstractShortcutHint.h	2012-01-13 15:39:27 +0000
@@ -0,0 +1,102 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011 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: Andrea Azzarone <[e-mail]>
+ */
+
+#ifndef UNITYSHELL_ABSTRACT_SHORTCUT_ICON_H
+#define UNITYSHELL_ABSTRACT_SHORTCUT_ICON_H
+
+#include <string>
+
+#include <Nux/Nux.h>
+#include <NuxCore/Property.h>
+
+namespace unity
+{
+namespace shortcut
+{
+
+enum OptionType
+{
+  COMPIZ_KEY_OPTION = 0,
+  COMPIZ_MOUSE_OPTION,
+  HARDCODED_OPTION
+  /* GSETTINGS_OPTION,
+   * GCONF_OPTION */
+};
+
+class AbstractHint
+{
+public:
+  // Ctor
+  AbstractHint(std::string const& category, 
+               std::string const& prefix,
+               std::string const& postfix,
+               std::string const& description,
+               OptionType const type,
+               std::string const& arg1, 
+               std::string const& arg2 = "",
+               std::string const& arg3 = "")
+    : category(category)
+    , prefix(prefix)
+    , postfix(postfix)
+    , description(description)
+    , type(type)
+    , arg1(arg1)
+    , arg2(arg2)
+    , arg3(arg3)
+  {
+  }
+  
+  // Copy ctor
+  AbstractHint(unity::shortcut::AbstractHint const& obj)
+    : category(obj.category())
+    , prefix(obj.prefix())
+    , postfix(obj.postfix())
+    , description(obj.description())
+    , type(obj.type())
+    , arg1(obj.arg1())
+    , arg2(obj.arg2())
+    , arg3(obj.arg3())
+    , value(obj.value())
+    , shortkey(obj.shortkey())
+  {
+  }
+  
+  // Dtor
+  virtual ~AbstractHint(){};
+  
+  // Public Methods
+  virtual bool Fill() = 0;
+  
+  // Properties
+  nux::Property<std::string> category;
+  nux::Property<std::string> prefix;
+  nux::Property<std::string> postfix;
+  nux::Property<std::string> description;
+  nux::Property<OptionType> type;
+  nux::Property<std::string> arg1;
+  nux::Property<std::string> arg2;
+  nux::Property<std::string> arg3;
+  nux::Property<std::string> value;
+  nux::Property<std::string> shortkey;
+};
+
+} // namespace shortcut
+} // namespace unity
+
+#endif // UNITYSHELL_ABSTRACT_SHORTCUT_ICON_H

=== modified file 'plugins/unityshell/src/BackgroundEffectHelper.cpp'
--- plugins/unityshell/src/BackgroundEffectHelper.cpp	2012-01-05 02:47:09 +0000
+++ plugins/unityshell/src/BackgroundEffectHelper.cpp	2012-01-13 15:39:27 +0000
@@ -72,7 +72,7 @@
 {
   for (BackgroundEffectHelper * bg_effect_helper : registered_list_)
   {
-    if (bg_effect_helper->cache_dirty || !bg_effect_helper->owner)
+    if (bg_effect_helper->cache_dirty || !bg_effect_helper->owner || !bg_effect_helper->enabled)
       continue;
 
     if (!geo.Intersect (bg_effect_helper->blur_geometry_).IsNull())

=== added file 'plugins/unityshell/src/LineSeparator.cpp'
--- plugins/unityshell/src/LineSeparator.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/LineSeparator.cpp	2012-01-13 15:39:27 +0000
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2011 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: Jay Taoko <[e-mail]>
+ *
+ */
+
+#include "LineSeparator.h"
+
+#include "Nux/Nux.h"
+
+namespace unity
+{
+  
+HSeparator::HSeparator()
+{
+  SetMinimumHeight(1);
+  SetMaximumHeight(1);
+}
+
+HSeparator::HSeparator(nux::Color const& color, float alpha0, float alpha1, int border)
+  : AbstractSeparator(color, alpha0, alpha1, border)
+{
+  SetMinimumHeight(1);
+  SetMaximumHeight(1);
+}
+
+HSeparator::~HSeparator()
+{
+}
+
+void HSeparator::Draw(nux::GraphicsEngine &GfxContext, bool force_draw)
+{
+  nux::Geometry base = GetGeometry();
+  base.OffsetPosition(3, 0);
+  base.OffsetSize(-6, 0);
+  int y0 = base.y + base.GetHeight() / 2;
+
+  nux::GetGraphicsDisplay()->GetGraphicsEngine()->GetRenderStates().SetBlend(TRUE, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+  if (base.GetWidth() - 2 * border_size_ > 0)
+  {
+    nux::Color color0 = color_;
+    nux::Color color1 = color_;
+    color0.alpha = alpha0_;
+    color1.alpha = alpha1_;
+    nux::GetPainter().Draw2DLine(GfxContext, base.x, y0, base.x + border_size_, y0, color0, color1);
+    nux::GetPainter().Draw2DLine(GfxContext, base.x + border_size_, y0, base.x + base.GetWidth() - border_size_, y0, color1, color1);
+    nux::GetPainter().Draw2DLine(GfxContext, base.x + base.GetWidth() - border_size_, y0, base.x + base.GetWidth(), y0, color1, color0);
+  }
+  else
+  {
+    nux::Color color1 = color_;
+    color1.alpha = alpha1_;
+    nux::GetPainter().Draw2DLine(GfxContext, base.x, y0, base.x + base.GetWidth(), y0, color1, color1);
+  }
+
+  nux::GetGraphicsDisplay()->GetGraphicsEngine()->GetRenderStates().SetBlend(FALSE);
+}
+
+} // namespace unity

=== added file 'plugins/unityshell/src/LineSeparator.h'
--- plugins/unityshell/src/LineSeparator.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/LineSeparator.h	2012-01-13 15:39:27 +0000
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2011 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: Jay Taoko <[e-mail]>
+ *
+ */
+
+#ifndef UNITYSHELL_HSEPARATOR_H
+#define UNITYSHELL_HSEPARATOR_H
+
+#include "AbstractSeparator.h"
+
+namespace unity
+{
+
+class HSeparator: public AbstractSeparator
+{
+public:
+  HSeparator();
+  HSeparator(nux::Color const& color, float alpha0, float alpha1, int border);
+
+  ~HSeparator();
+
+protected:
+  virtual void Draw(nux::GraphicsEngine& GfxContext, bool force_draw);
+  virtual void DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw) {};
+
+};
+
+} // namespace unity
+
+#endif // UNITYSHELL_HSEPARATOR_H

=== added file 'plugins/unityshell/src/MockShortcutHint.h'
--- plugins/unityshell/src/MockShortcutHint.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/MockShortcutHint.h	2012-01-13 15:39:27 +0000
@@ -0,0 +1,72 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011 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: Andrea Azzarone <[e-mail]>
+ */
+
+#ifndef UNITYSHELL_MOCK_SHORTCUT_HINT_H
+#define UNITYSHELL_MOCK_SHORTCUT_HINT_H
+
+#include "AbstractShortcutHint.h"
+
+namespace unity
+{
+namespace shortcut
+{
+
+class MockHint : public AbstractHint
+{
+public:
+   // Ctor and dtor
+  MockHint(std::string const& category,
+           std::string const& prefix,
+           std::string const& postfix,
+           std::string const& description,
+           OptionType const type,
+           std::string const& arg1, 
+           std::string const& arg2 = "",
+           std::string const& arg3 = "")
+    : AbstractHint(category, prefix, postfix, description, type, arg1, arg2, arg3)
+  {
+  }
+  
+  ~MockHint() {};
+  
+  // Methods...
+  bool Fill()
+  {
+    switch (type())
+    {
+      case COMPIZ_MOUSE_OPTION:
+      case COMPIZ_KEY_OPTION:
+        value = arg1() + "-" + arg2();
+        shortkey = prefix() + value() + postfix();
+        return true;
+      
+      case HARDCODED_OPTION:
+        value = arg1();
+        shortkey = prefix() + value() + postfix();
+        return true;
+    }
+    
+    return false;
+  }
+};
+  
+} // shortcut hint
+} // namespace unity
+
+#endif // UNITYSHELL_MOCK_SHORTCUT_HINT_H

=== added file 'plugins/unityshell/src/ShortcutController.cpp'
--- plugins/unityshell/src/ShortcutController.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/ShortcutController.cpp	2012-01-13 15:39:27 +0000
@@ -0,0 +1,194 @@
+/*
+ * Copyright (C) 2011 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: Andrea Azzarone <[e-mail]>
+ */
+
+#include "ShortcutController.h"
+
+#include "UBusMessages.h"
+#include "ubus-server.h"
+#include "WindowManager.h"
+
+namespace unity
+{
+namespace shortcut
+{
+namespace
+{
+const unsigned int SUPER_TAP_DURATION = 650;
+} // anonymouse namespace;
+  
+Controller::Controller(std::list<AbstractHint*>& hints)
+  : view_window_(0)
+  , visible_(false)
+  , show_timer_(0)
+  , fade_in_animator_(new Animator(100))
+  , fade_out_animator_(new Animator(100))
+
+{
+  bg_color_ = nux::Color(0.0, 0.0, 0.0, 0.5);
+
+  UBusServer *ubus = ubus_server_get_default();
+  bg_update_handle_ = ubus_server_register_interest(ubus, UBUS_BACKGROUND_COLOR_CHANGED,
+                                                    (UBusCallback)&Controller::OnBackgroundUpdate,
+                                                    this);
+
+  model_.reset(new Model(hints));
+  
+  model_->Fill();
+  ConstructView();
+
+  fade_in_animator_->animation_updated.connect(sigc::mem_fun(this, &Controller::OnFadeInUpdated));
+  fade_in_animator_->animation_ended.connect(sigc::mem_fun(this, &Controller::OnFadeInEnded));
+  fade_out_animator_->animation_updated.connect(sigc::mem_fun(this, &Controller::OnFadeOutUpdated));
+  fade_out_animator_->animation_ended.connect(sigc::mem_fun(this, &Controller::OnFadeOutEnded));
+}
+
+Controller::~Controller()
+{
+  ubus_server_unregister_interest(ubus_server_get_default(), bg_update_handle_);
+  
+  if (fade_in_animator_)
+    delete fade_in_animator_;
+
+  if (fade_out_animator_)
+    delete fade_out_animator_;
+  
+  if (view_window_)
+    view_window_->UnReference();
+    
+  view_.Release();
+}
+
+
+void Controller::OnFadeInUpdated(double opacity)
+{
+  view_window_->SetOpacity(opacity);
+}
+
+void Controller::OnFadeInEnded()
+{
+  view_window_->SetOpacity(1.0);
+}
+
+void Controller::OnFadeOutUpdated(double progress)
+{
+  double opacity = CLAMP(1.0f - progress, 0.0f, 1.0f);
+  view_window_->SetOpacity(opacity);
+}
+
+void Controller::OnFadeOutEnded()
+{
+  view_window_->SetOpacity(0.0);
+}
+
+
+void Controller::OnBackgroundUpdate(GVariant* data, Controller* self)
+{
+  gdouble red, green, blue, alpha;
+  g_variant_get(data, "(dddd)", &red, &green, &blue, &alpha);
+  self->bg_color_ = nux::Color(red, green, blue, alpha);
+
+  if (self->view_)
+    self->view_->background_color = self->bg_color_;
+}
+
+void Controller::Show()
+{
+  if (show_timer_)
+    g_source_remove (show_timer_);
+  show_timer_ = g_timeout_add(SUPER_TAP_DURATION, &Controller::OnShowTimer, this);
+
+  model_->Fill();
+  visible_ = true;
+}
+
+gboolean Controller::OnShowTimer(gpointer data)
+{
+  Controller* self = static_cast<Controller*>(data);
+  
+  ubus_server_send_message(ubus_server_get_default(),
+                           UBUS_PLACE_VIEW_CLOSE_REQUEST,
+                           NULL);
+
+  if (self->visible_)
+  {
+    self->view_->SetupBackground(true);
+    self->fade_out_animator_->Stop();
+    self->fade_in_animator_->Start(self->view_window_->GetOpacity());
+  }
+
+  self->show_timer_ = 0;
+  return FALSE;
+}
+
+void Controller::ConstructView()
+{
+  view_ = View::Ptr(new View());
+  view_->SetModel(model_);
+  view_->background_color = bg_color_;
+
+  if (!view_window_)
+  {
+    main_layout_ = new nux::HLayout(NUX_TRACKER_LOCATION);
+    main_layout_->SetVerticalExternalMargin(0);
+    main_layout_->SetHorizontalExternalMargin(0);
+
+    view_window_ = new nux::BaseWindow("ShortcutHint");
+    view_window_->SinkReference();
+    view_window_->SetLayout(main_layout_);
+    view_window_->SetBackgroundColor(nux::Color(0x00000000));
+  }
+
+  main_layout_->AddView(view_.GetPointer(), 1);
+
+  view_->SetupBackground(false);
+  view_window_->SetOpacity(0.0);
+  view_window_->ShowWindow(true);
+}
+
+void Controller::SetWorkspace(nux::Geometry const& geo)
+{
+  workarea_ = geo;
+  view_window_->SetGeometry(workarea_);
+}
+
+void Controller::Hide()
+{
+  if (!visible_)
+    return;
+    
+  visible_ = false;
+
+  if (view_window_)
+  {
+    view_->SetupBackground(false);
+    fade_in_animator_->Stop();
+    fade_out_animator_->Start(1.0 - view_window_->GetOpacity());
+  }
+
+  if (show_timer_)
+    g_source_remove(show_timer_);
+  show_timer_ = 0;
+}
+
+bool Controller::Visible()
+{
+  return visible_;
+}
+
+} // namespace shortcut
+} // namespace unity

=== added file 'plugins/unityshell/src/ShortcutController.h'
--- plugins/unityshell/src/ShortcutController.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/ShortcutController.h	2012-01-13 15:39:27 +0000
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2011 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: Andrea Azzarone <[e-mail]>
+ */
+
+#ifndef UNITYSHELL_SHORTCUTCONTROLLER_H
+#define UNITYSHELL_SHORTCUTCONTROLLER_H
+
+#include <boost/shared_ptr.hpp>
+
+#include <Nux/Nux.h>
+#include <Nux/BaseWindow.h>
+#include <Nux/HLayout.h>
+#include <NuxCore/Color.h>
+
+#include "Animator.h"
+#include "ShortcutModel.h"
+#include "ShortcutView.h"
+
+namespace unity
+{
+namespace shortcut
+{
+
+class Controller
+{
+public:
+  typedef std::shared_ptr<Controller> Ptr;
+  
+  // Ctor and dtor
+  Controller(std::list<AbstractHint*>& hints);
+  ~Controller();  
+  
+  // Public Methods
+  void Show();
+  void Hide();
+  
+  bool Visible();
+
+  void SetWorkspace(nux::Geometry const& geo);
+
+private:
+  // Private Methods
+  void ConstructView();
+  static void OnBackgroundUpdate(GVariant* data, Controller* self);
+  void OnFadeInUpdated(double opacity);
+  void OnFadeInEnded();
+  void OnFadeOutUpdated(double opacity);
+  void OnFadeOutEnded();
+
+  static gboolean OnShowTimer(gpointer data);
+  
+  // Private Members
+  View::Ptr view_;
+  Model::Ptr model_;
+   
+  nux::Geometry workarea_;
+  nux::BaseWindow* view_window_;
+  nux::HLayout* main_layout_;
+  
+  bool visible_;
+  nux::Color bg_color_;
+  guint show_timer_;
+  guint bg_update_handle_;
+  
+  Animator* fade_in_animator_;
+  Animator* fade_out_animator_;
+}; 
+
+} // namespace shortcut
+} // namespace unity
+
+#endif //UNITYSHELL_SHORTCUTHINTCONTROLLER_H
+

=== added file 'plugins/unityshell/src/ShortcutHint.cpp'
--- plugins/unityshell/src/ShortcutHint.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/ShortcutHint.cpp	2012-01-13 15:39:27 +0000
@@ -0,0 +1,137 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011 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: Andrea Azzarone <[e-mail]>
+ */
+
+#include "ShortcutHint.h"
+
+#include <core/core.h> // Compiz...
+#include <NuxCore/Logger.h>
+
+#include "ShortcutHintPrivate.h"
+
+namespace unity
+{
+namespace shortcut
+{
+namespace
+{
+  nux::logging::Logger logger("unity.shortcut");
+} // anonymouse namespace 
+
+// Ctor
+Hint::Hint(std::string const& category,
+           std::string const& prefix,
+           std::string const& postfix,
+           std::string const& description,
+           OptionType const type,
+           std::string const& arg1, 
+           std::string const& arg2,
+           std::string const& arg3)
+  : AbstractHint(category, prefix, postfix, description, type, arg1, arg2, arg3)
+{
+}
+
+// Dtor
+Hint::~Hint()
+{
+}
+
+/*
+ * Gets and fills the shortcut value. 
+ * Returns true if everything was OK, returns false otherwise.
+ * Use member property Value to get it.
+ */
+bool Hint::Fill()
+{
+  switch(type())
+  {
+    case COMPIZ_MOUSE_OPTION:
+    {
+      // Arg1 = Plugin name
+      // Arg2 = key Option name
+      CompPlugin* p = CompPlugin::find(arg1().c_str());
+
+      if (!p) 
+        return false;
+
+      foreach (CompOption &opt, p->vTable->getOptions())
+      {
+          if (opt.name() == arg2())
+          {
+            std::string temp = impl::FixMouseShortcut(impl::FixShortcutFormat(opt.value().action().buttonToString()));
+            temp = impl::ProperCase(temp);
+            
+            if (value() != temp)
+            {
+              value = temp;
+              shortkey = prefix() + value() + postfix();
+            }
+              
+            return true;
+          }
+      }
+
+      break;
+    }
+    break;
+    
+    case COMPIZ_KEY_OPTION:
+    {
+      // Arg1 = Plugin name
+      // Arg2 = key Option name
+      CompPlugin* p = CompPlugin::find(arg1().c_str());
+
+      if (!p) 
+        return false;
+
+      foreach (CompOption &opt, p->vTable->getOptions())
+      {
+          if (opt.name() == arg2())
+          {
+            std::string temp = impl::FixShortcutFormat(opt.value().action().keyToString());
+            temp = impl::ProperCase(temp);
+            
+            if (value() != temp)
+            {
+              value = temp;
+              shortkey = prefix() + value() + postfix();
+            }
+              
+            return true;
+          }
+      }
+
+      break;
+    }
+    case HARDCODED_OPTION:
+      if (value != arg1())
+      {
+        value = arg1();
+        shortkey = prefix() + value() + postfix();
+      }
+      return true;
+
+    default:
+      LOG_WARNING(logger) << "Unable to find the option type" << type(); 
+  }
+
+  return false;
+}
+
+} // namespace shortcut
+} // namespace unity

=== added file 'plugins/unityshell/src/ShortcutHint.h'
--- plugins/unityshell/src/ShortcutHint.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/ShortcutHint.h	2012-01-13 15:39:27 +0000
@@ -0,0 +1,53 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011 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: Andrea Azzarone <[e-mail]>
+ */
+ 
+#ifndef UNITYSHELL_SHORTCUTHINT_H
+#define UNITYSHELL_SHORTCUTHINT_H
+
+#include "AbstractShortcutHint.h"
+
+namespace unity
+{
+namespace shortcut
+{
+
+class Hint : public AbstractHint
+{
+public:
+  // Ctor
+  Hint(std::string const& category,
+       std::string const& prefix,
+       std::string const& postfix,
+       std::string const& description,
+       OptionType const type,
+       std::string const& arg1, 
+       std::string const& arg2 = "",
+       std::string const& arg3 = "");
+  
+  // Dtor
+  ~Hint();
+
+  // Public methods
+  bool Fill();
+};
+
+} // namespace shortcut
+} // namespace unity
+
+ #endif // UNITYSHELL_SHORTCUTHINT_H

=== added file 'plugins/unityshell/src/ShortcutHintPrivate.cpp'
--- plugins/unityshell/src/ShortcutHintPrivate.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/ShortcutHintPrivate.cpp	2012-01-13 15:39:27 +0000
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2011 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: Andrea Azzarone <[e-mail]>
+ */
+
+#include "ShortcutHintPrivate.h"
+
+#include <boost/algorithm/string/replace.hpp>
+
+namespace unity
+{
+namespace shortcut
+{
+namespace impl
+{
+
+std::string FixShortcutFormat(std::string const& scut)
+{
+  std::string ret(scut.begin(), scut.end() - 1);
+  
+  boost::replace_all(ret, "<", "");
+  boost::replace_all(ret, ">", " + ");
+  
+  if (scut[scut.size()-1] != '>')
+    ret += scut[scut.size()-1];
+    
+  return ret;
+}
+
+std::string FixMouseShortcut(std::string const& scut)
+{
+  std::string ret(scut);
+  
+  boost::replace_all(ret, "Button1", "Left Mouse");
+  boost::replace_all(ret, "Button2", "Middle Mouse");
+  boost::replace_all(ret, "Button3", "Right Mouse");
+      
+  return ret;
+}
+
+std::string ProperCase(std::string const& str)
+{
+  std::string ret = str;
+  
+	bool cap_next = true;
+
+	for (unsigned int i = 0; i < ret.length(); ++i)
+  {
+    if (cap_next and isalpha(ret[i]))
+    {
+      ret[i]=toupper(ret[i]);
+      cap_next = false;
+    }
+    else
+    {
+      cap_next = ispunct(ret[i]) || isspace(ret[i]);
+    }
+  }
+  
+  return ret;
+}
+
+} // namespace impl
+} // namespace shortcut
+} // namespace unity
+

=== added file 'plugins/unityshell/src/ShortcutHintPrivate.h'
--- plugins/unityshell/src/ShortcutHintPrivate.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/ShortcutHintPrivate.h	2012-01-13 15:39:27 +0000
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2011 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: Andrea Azzarone <[e-mail]>
+ */
+
+#ifndef UNITYSHELL_SHORTCUT_HINT_PRIVATE_H
+#define UNITYSHELL_SHORTCUT_HINT_PRIVATE_H
+
+#include <string>
+
+namespace unity
+{
+namespace shortcut
+{
+namespace impl
+{
+
+std::string FixShortcutFormat(std::string const& scut);
+std::string FixMouseShortcut(std::string const& scut);
+std::string ProperCase(std::string const& str);
+
+} // namespace impl
+} // namespace shortcut
+} // namespace unity
+
+#endif // UNITYSHELL_SHORTCUT_HINT_PRIVATE_H

=== added file 'plugins/unityshell/src/ShortcutModel.cpp'
--- plugins/unityshell/src/ShortcutModel.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/ShortcutModel.cpp	2012-01-13 15:39:27 +0000
@@ -0,0 +1,60 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011 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: Andrea Azzarone <[e-mail]>
+ */
+
+#include "ShortcutModel.h"
+
+namespace unity
+{
+namespace shortcut
+{
+
+// Ctor
+Model::Model(std::list<AbstractHint*>& hints)
+{
+  for (auto hint : hints)
+    AddHint(hint);
+}
+
+// Dtor
+Model::~Model()
+{
+}
+
+
+void Model::AddHint(AbstractHint* hint)
+{
+  if (!hint)
+    return;
+    
+  if (hints_.find(hint->category()) == hints_.end())
+    categories_.push_back(hint->category());
+    
+  hints_[hint->category()].push_back(hint);
+}
+
+
+void Model::Fill()
+{
+  for (auto category : categories_)
+    for (auto item : hints_[category])
+      item->Fill();
+}
+
+} // namespace shortcut
+} // namespace unity

=== added file 'plugins/unityshell/src/ShortcutModel.h'
--- plugins/unityshell/src/ShortcutModel.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/ShortcutModel.h	2012-01-13 15:39:27 +0000
@@ -0,0 +1,64 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011 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: Andrea Azzarone <[e-mail]>
+ */
+ 
+#ifndef UNITYSHELL_SHORTCUSMODEL_H
+#define UNITYSHELL_SHORTCUSMODEL_H
+
+#include <boost/noncopyable.hpp>
+#include <map>
+#include <memory>
+#include <list>
+#include <string>
+#include <vector>
+
+#include "AbstractShortcutHint.h"
+
+namespace unity
+{
+namespace shortcut
+{
+
+class Model : boost::noncopyable
+{
+public:
+  typedef std::shared_ptr<Model> Ptr;
+
+  // Ctor and dtor  
+  Model(std::list<AbstractHint*>& hints);
+  ~Model();
+               
+  // Accessors
+  std::vector<std::string>& categories() { return categories_; }
+  std::map<std::string, std::list<AbstractHint*>>& hints() { return hints_; }
+  
+  void Fill();       
+        
+private:
+  // Private functions
+  void AddHint(AbstractHint* hint);
+
+  // Private members
+  std::vector<std::string> categories_;
+  std::map<std::string, std::list<AbstractHint*>> hints_;
+};
+
+} // shortcut
+} // unity
+
+#endif // UNITYSHELL_SHORTCUTS_H

=== added file 'plugins/unityshell/src/ShortcutView.cpp'
--- plugins/unityshell/src/ShortcutView.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/ShortcutView.cpp	2012-01-13 15:39:27 +0000
@@ -0,0 +1,424 @@
+/*
+ * Copyright (C) 2011 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: Andrea Azzarone <[e-mail]>
+ *              Jay Taoko <[e-mail]>
+ */
+ 
+#include "ShortcutView.h"
+
+#include <glib/gi18n-lib.h>
+#include <boost/algorithm/string.hpp>
+#include <UnityCore/GLibWrapper.h>
+
+#include "LineSeparator.h"
+#include "StaticCairoText.h"
+
+namespace unity
+{
+namespace shortcut
+{
+namespace
+{
+  int SECTION_NAME_FONT_SIZE = 17/1.33;
+  int SHORTKEY_ENTRY_FONT_SIZE = 13/1.33;
+  int INTER_SPACE_SHORTKEY_DESCRIPTION = 10;
+  int SHORTKEY_COLUMN_WIDTH = 150;
+  int DESCRIPTION_COLUMN_WIDTH = 265;
+  int LINE_SPACING = 5;
+} // namespace anonymouse
+
+NUX_IMPLEMENT_OBJECT_TYPE(View);
+
+View::View(NUX_FILE_LINE_DECL)
+  : nux::View(NUX_FILE_LINE_PARAM)
+{
+  layout_ = new nux::VLayout();
+  layout_->SetPadding(50, 38);
+  layout_->SetSpaceBetweenChildren(20);
+  SetLayout(layout_);
+
+  background_top_ = nux::CreateTexture2DFromFile(PKGDATADIR"/switcher_top.png", -1, true);
+  background_left_ = nux::CreateTexture2DFromFile(PKGDATADIR"/switcher_left.png", -1, true);
+  background_corner_ = nux::CreateTexture2DFromFile(PKGDATADIR"/switcher_corner.png", -1, true);
+  rounding_texture_ = nux::CreateTexture2DFromFile(PKGDATADIR"/switcher_round_rect.png", -1, true);
+
+  std::string header = "<b>";
+  header += _("Keyboard Shortcuts");
+  header += "</b>";
+  
+  nux::StaticText* header_view = new nux::StaticText(header.c_str(), NUX_TRACKER_LOCATION);
+  header_view->SetTextPointSize(20/1.33);
+  header_view->SetFontName("Ubuntu");
+  layout_->AddView(header_view, 1 , nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FULL);
+  
+  layout_->AddView(new HSeparator(), 0, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FULL);  
+    
+  columns_layout_ = new nux::HLayout();  
+  columns_layout_->SetSpaceBetweenChildren(30);
+  layout_->AddLayout(columns_layout_, 1, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FULL);
+  
+  // Column 1...
+  columns_.push_back(new nux::VLayout());
+  columns_layout_->AddLayout(columns_[0], 1, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FULL);
+  
+  // Column 2...
+  columns_.push_back(new nux::VLayout());
+  columns_layout_->AddLayout(columns_[1], 1, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FULL);
+  
+  bg_effect_helper_.owner = this;
+}
+
+View::~View()
+{
+  if (background_top_ != NULL)
+    background_top_->UnReference();
+  
+  if (background_left_ != NULL)  
+    background_left_->UnReference();
+  
+  if (background_corner_ != NULL)
+    background_corner_->UnReference();
+  
+  if (rounding_texture_ != NULL)
+    rounding_texture_->UnReference();
+}
+
+void View::SetModel(Model::Ptr model)
+{
+  model_ = model;
+
+  // Fills the columns...
+  RenderColumns();
+}
+
+Model::Ptr View::GetModel()
+{
+  return model_;
+}
+
+void View::SetupBackground(bool enabled)
+{
+  bg_effect_helper_.enabled = enabled;
+}
+
+nux::LinearLayout* View::CreateSectionLayout(const char* section_name)
+{
+  nux::VLayout* layout = new nux::VLayout(NUX_TRACKER_LOCATION);
+  
+  std::string name = "<b>";
+  name += std::string(section_name);
+  name += "</b>";
+
+
+  nux::StaticText* section_name_view = new nux::StaticText(name.c_str(), NUX_TRACKER_LOCATION);
+  section_name_view->SetTextPointSize(SECTION_NAME_FONT_SIZE);
+  section_name_view->SetFontName("Ubuntu");
+  layout->AddView(new nux::SpaceLayout(10, 10, 10, 10), 0, nux::MINOR_POSITION_START, nux::MINOR_SIZE_MATCHCONTENT);
+  layout->AddView(section_name_view, 0, nux::MINOR_POSITION_START, nux::MINOR_SIZE_MATCHCONTENT);
+  layout->AddView(new nux::SpaceLayout(15, 15, 15, 15), 0, nux::MINOR_POSITION_START, nux::MINOR_SIZE_MATCHCONTENT);
+
+  return layout;
+}
+
+nux::LinearLayout* View::CreateShortKeyEntryLayout(AbstractHint* hint)
+{
+  nux::HLayout* layout = new nux::HLayout("EntryLayout", NUX_TRACKER_LOCATION);
+  nux::HLayout* shortkey_layout = new nux::HLayout(NUX_TRACKER_LOCATION);
+  nux::HLayout* description_layout = new nux::HLayout(NUX_TRACKER_LOCATION);
+
+  glib::String shortkey(g_markup_escape_text(hint->shortkey().c_str(), -1));
+  
+  std::string skey = "<b>";
+  skey += shortkey.Str();
+  skey += "</b>";
+
+  nux::StaticText* shortkey_view = new nux::StaticText(skey, NUX_TRACKER_LOCATION);
+  shortkey_view->SetTextAlignment(nux::StaticText::ALIGN_LEFT);
+  shortkey_view->SetFontName("Ubuntu");
+  shortkey_view->SetTextPointSize(SHORTKEY_ENTRY_FONT_SIZE);
+  shortkey_view->SetMinimumWidth(SHORTKEY_COLUMN_WIDTH);
+  shortkey_view->SetMaximumWidth(SHORTKEY_COLUMN_WIDTH);
+  
+  glib::String es_desc(g_markup_escape_text(hint->description().c_str(), -1));
+
+  nux::StaticText* description_view = new nux::StaticText(es_desc.Value(), NUX_TRACKER_LOCATION);
+  description_view->SetTextAlignment(nux::StaticText::ALIGN_LEFT);
+  shortkey_view->SetFontName("Ubuntu");
+  description_view->SetTextPointSize(SHORTKEY_ENTRY_FONT_SIZE);
+  description_view->SetMinimumWidth(DESCRIPTION_COLUMN_WIDTH);
+  description_view->SetMaximumWidth(DESCRIPTION_COLUMN_WIDTH);
+
+  shortkey_layout->AddView(shortkey_view, 0, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_MATCHCONTENT);
+  shortkey_layout->SetContentDistribution(nux::MAJOR_POSITION_START);
+  shortkey_layout->SetMinimumWidth(SHORTKEY_COLUMN_WIDTH);
+  shortkey_layout->SetMaximumWidth(SHORTKEY_COLUMN_WIDTH);
+
+  description_layout->AddView(description_view, 0, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_MATCHCONTENT);
+  description_layout->SetContentDistribution(nux::MAJOR_POSITION_START);
+  description_layout->SetMinimumWidth(DESCRIPTION_COLUMN_WIDTH);
+  description_layout->SetMaximumWidth(DESCRIPTION_COLUMN_WIDTH);
+
+  layout->AddLayout(shortkey_layout, 1, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_MATCHCONTENT);
+  layout->AddLayout(description_layout, 1, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_MATCHCONTENT);
+  layout->SetSpaceBetweenChildren(INTER_SPACE_SHORTKEY_DESCRIPTION);
+  description_layout->SetContentDistribution(nux::MAJOR_POSITION_START);
+  
+   auto on_shortkey_changed = [](std::string const& new_shortkey, nux::StaticText* view) {
+      std::string skey = "<b>";
+      skey += new_shortkey;
+      skey += "</b>";
+      
+      view->SetText(skey);
+   };
+  
+  hint->shortkey.changed.connect(sigc::bind(sigc::slot<void, std::string const&, nux::StaticText*>(on_shortkey_changed), shortkey_view));
+
+  return layout;
+}
+
+nux::LinearLayout* View::CreateIntermediateLayout()
+{
+  nux::VLayout* layout = new nux::VLayout(NUX_TRACKER_LOCATION);
+  layout->SetSpaceBetweenChildren(LINE_SPACING);
+
+  return layout;
+}
+
+void View::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
+{
+  return;
+}
+
+void View::DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw)
+{  
+  nux::Geometry base = GetGeometry();
+  GfxContext.PushClippingRectangle(base);
+
+  // clear region
+  gPainter.PaintBackground(GfxContext, base);
+
+  nux::Geometry background_geo;
+  
+  background_geo.width = base.width;
+  background_geo.height = base.height;
+  background_geo.x = (base.width - background_geo.width)/2;
+  background_geo.y = (base.height - background_geo.height)/2;
+
+  // magic constant comes from texture contents (distance to cleared area)
+  const int internal_offset = 20;
+  nux::Geometry internal_clip(background_geo.x + internal_offset, 
+                              background_geo.y + internal_offset, 
+                              background_geo.width - internal_offset * 2, 
+                              background_geo.height - internal_offset * 2);
+  GfxContext.PushClippingRectangle(internal_clip);
+
+  nux::Geometry geo_absolute = GetAbsoluteGeometry();
+  if (BackgroundEffectHelper::blur_type != BLUR_NONE)
+  {
+    nux::Geometry blur_geo(geo_absolute.x, geo_absolute.y, base.width, base.height);
+    auto blur_texture = bg_effect_helper_.GetBlurRegion(blur_geo);
+
+    if (blur_texture.IsValid())
+    {
+      nux::TexCoordXForm texxform_blur_bg;
+      texxform_blur_bg.flip_v_coord = true;
+      texxform_blur_bg.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
+      texxform_blur_bg.uoffset = ((float) base.x) / geo_absolute.width;
+      texxform_blur_bg.voffset = ((float) base.y) / geo_absolute.height;
+
+      nux::ROPConfig rop;
+      rop.Blend = false;
+      rop.SrcBlend = GL_ONE;
+      rop.DstBlend = GL_ONE_MINUS_SRC_ALPHA;
+
+      gPainter.PushDrawTextureLayer(GfxContext, base,
+                                    blur_texture,
+                                    texxform_blur_bg,
+                                    nux::color::White,
+                                    true,
+                                    rop);
+    }
+  }
+
+  nux::ROPConfig rop;
+  rop.Blend = true;
+  rop.SrcBlend = GL_ONE;
+  rop.DstBlend = GL_ONE_MINUS_SRC_ALPHA;
+  gPainter.PushDrawColorLayer(GfxContext, internal_clip, background_color, false, rop);
+
+  // Make round corners
+  rop.Blend = true;
+  rop.SrcBlend = GL_ZERO;
+  rop.DstBlend = GL_SRC_ALPHA;
+  gPainter.PaintShapeCornerROP(GfxContext,
+                               internal_clip,
+                               nux::color::White,
+                               nux::eSHAPE_CORNER_ROUND4,
+                               nux::eCornerTopLeft | nux::eCornerTopRight |
+                               nux::eCornerBottomLeft | nux::eCornerBottomRight,
+                               true,
+                               rop);
+
+  GfxContext.GetRenderStates().SetPremultipliedBlend(nux::SRC_OVER);
+
+  GfxContext.PopClippingRectangle();
+  GfxContext.PopClippingRectangle();
+
+  DrawBackground(GfxContext, background_geo);
+
+
+  layout_->ProcessDraw(GfxContext, force_draw);
+}
+
+
+void View::DrawBackground(nux::GraphicsEngine& GfxContext, nux::Geometry const& geo)
+{
+  int border = 30;
+
+  GfxContext.GetRenderStates().SetBlend(TRUE, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+
+  nux::TexCoordXForm texxform;
+  texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
+  texxform.SetWrap(nux::TEXWRAP_REPEAT, nux::TEXWRAP_REPEAT);
+
+  // Draw TOP-LEFT CORNER
+  texxform.u0 = 0;
+  texxform.v0 = 0;
+  texxform.u1 = border;
+  texxform.v1 = border;
+  GfxContext.QRP_1Tex(geo.x, geo.y, 
+                      border, border, background_corner_->GetDeviceTexture(), texxform, nux::color::White);
+  
+  // Draw TOP-RIGHT CORNER
+  texxform.u0 = 0;
+  texxform.v0 = 0;
+  texxform.u1 = border;
+  texxform.v1 = border;
+  texxform.flip_u_coord = true;
+  texxform.flip_v_coord = false;
+  GfxContext.QRP_1Tex(geo.x + geo.width - border, geo.y, 
+                      border, border, background_corner_->GetDeviceTexture(), texxform, nux::color::White);
+  
+  // Draw BOTTOM-LEFT CORNER
+  texxform.u0 = 0;
+  texxform.v0 = 0;
+  texxform.u1 = border;
+  texxform.v1 = border;
+  texxform.flip_u_coord = false;
+  texxform.flip_v_coord = true;
+  GfxContext.QRP_1Tex(geo.x, geo.y + geo.height - border, 
+                      border, border, background_corner_->GetDeviceTexture(), texxform, nux::color::White);
+  
+  // Draw BOTTOM-RIGHT CORNER
+  texxform.u0 = 0;
+  texxform.v0 = 0;
+  texxform.u1 = border;
+  texxform.v1 = border;
+  texxform.flip_u_coord = true;
+  texxform.flip_v_coord = true;
+  GfxContext.QRP_1Tex(geo.x + geo.width - border, geo.y + geo.height - border, 
+                      border, border, background_corner_->GetDeviceTexture(), texxform, nux::color::White);
+  
+  int top_width = background_top_->GetWidth();
+  int top_height = background_top_->GetHeight();
+
+  // Draw TOP BORDER
+  texxform.u0 = 0;
+  texxform.v0 = 0;
+  texxform.u1 = top_width;
+  texxform.v1 = top_height;
+  texxform.flip_u_coord = false;
+  texxform.flip_v_coord = false;
+  GfxContext.QRP_1Tex(geo.x + border, geo.y, geo.width - border - border, border, background_top_->GetDeviceTexture(), texxform, nux::color::White);
+  
+  // Draw BOTTOM BORDER
+  texxform.u0 = 0;
+  texxform.v0 = 0;
+  texxform.u1 = top_width;
+  texxform.v1 = top_height;
+  texxform.flip_u_coord = false;
+  texxform.flip_v_coord = true;
+  GfxContext.QRP_1Tex(geo.x + border, geo.y + geo.height - border, geo.width - border - border, border, background_top_->GetDeviceTexture(), texxform, nux::color::White);
+  
+
+  int left_width = background_left_->GetWidth();
+  int left_height = background_left_->GetHeight();
+
+  // Draw LEFT BORDER
+  texxform.u0 = 0;
+  texxform.v0 = 0;
+  texxform.u1 = left_width;
+  texxform.v1 = left_height;
+  texxform.flip_u_coord = false;
+  texxform.flip_v_coord = false;
+  GfxContext.QRP_1Tex(geo.x, geo.y + border, border, geo.height - border - border, background_left_->GetDeviceTexture(), texxform, nux::color::White);
+  
+  // Draw RIGHT BORDER
+  texxform.u0 = 0;
+  texxform.v0 = 0;
+  texxform.u1 = left_width;
+  texxform.v1 = left_height;
+  texxform.flip_u_coord = true;
+  texxform.flip_v_coord = false;
+  GfxContext.QRP_1Tex(geo.x + geo.width - border, geo.y + border, border, geo.height - border - border, background_left_->GetDeviceTexture(), texxform, nux::color::White);
+
+  GfxContext.GetRenderStates().SetBlend(FALSE);
+}
+
+void View::RenderColumns()
+{
+  int i = 0;
+  int column = 0;
+  
+  for (auto category : model_->categories())
+  {
+    // Three sections in the fist column...
+    if (i > 2)
+      column = 1;
+      
+    nux::LinearLayout* section_layout = CreateSectionLayout(category.c_str());
+    nux::LinearLayout* intermediate_layout = CreateIntermediateLayout();
+    intermediate_layout->SetContentDistribution(nux::MAJOR_POSITION_START);
+    
+    for (auto hint : model_->hints()[category])
+    {
+      //std::string str_value = hint->prefix() + hint->value() + hint->postfix();
+      //boost::replace_all(str_value, "&", "&amp;");
+      //boost::replace_all(str_value, "<", "&lt;");
+      //boost::replace_all(str_value, ">", "&gt;");
+      
+      intermediate_layout->AddLayout(CreateShortKeyEntryLayout(hint), 0, nux::MINOR_POSITION_START, nux::MINOR_SIZE_FULL);
+    }
+    
+    section_layout->AddLayout(intermediate_layout, 0, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FULL);
+
+    if (i == 0 or i==1 or i==3 or i==4)
+    {
+      // Add space before the line
+      section_layout->AddView(new nux::SpaceLayout(23, 23, 23, 23), 0, nux::MINOR_POSITION_START, nux::MINOR_SIZE_MATCHCONTENT);
+      section_layout->AddView(new HSeparator(), 0, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FULL);
+      // Add space after the line
+      section_layout->AddView(new nux::SpaceLayout(20, 20, 20, 20), 0, nux::MINOR_POSITION_START, nux::MINOR_SIZE_MATCHCONTENT);
+    }
+
+    columns_[column]->AddView(section_layout, 1, nux::MINOR_POSITION_START, nux::MINOR_SIZE_FULL);
+      
+    i++;
+  }
+}
+  
+} // namespace shortcut
+} // namespace unity

=== added file 'plugins/unityshell/src/ShortcutView.h'
--- plugins/unityshell/src/ShortcutView.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/ShortcutView.h	2012-01-13 15:39:27 +0000
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2011 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: Andrea Azzarone <[e-mail]>
+ */
+
+#ifndef UNITYSHELL_SHORTCUTVIEW_H
+#define UNITYSHELL_SHORTCUTVIEW_H
+
+#include <Nux/Nux.h>
+#include <Nux/GridHLayout.h>
+#include <Nux/HLayout.h>
+#include <NuxCore/ObjectPtr.h>
+#include <NuxCore/Property.h>
+#include <Nux/StaticText.h>
+#include <Nux/View.h>
+#include <Nux/VLayout.h>
+
+#include "BackgroundEffectHelper.h"
+#include "ShortcutModel.h"
+
+namespace unity
+{
+namespace shortcut
+{
+
+class View : public nux::View
+{
+  NUX_DECLARE_OBJECT_TYPE(View, nux::View);
+public:
+  typedef nux::ObjectPtr<View> Ptr;
+
+  // Ctor and dtor
+  View(NUX_FILE_LINE_PROTO);
+  ~View();
+  
+  // Public methods
+  void SetModel(Model::Ptr model);
+  Model::Ptr GetModel();
+
+  void SetupBackground(bool enabled);
+
+  // Properties  
+  nux::Property<nux::Color> background_color;
+  
+protected:
+  // Protected methods
+  void Draw(nux::GraphicsEngine& GfxContext, bool force_draw);
+  void DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw);
+
+private:
+  // Private methods
+  nux::LinearLayout* CreateSectionLayout(const char* section_name);
+  nux::LinearLayout* CreateShortKeyEntryLayout(AbstractHint* hint);
+  nux::LinearLayout* CreateIntermediateLayout();
+
+  void DrawBackground(nux::GraphicsEngine& GfxContext, nux::Geometry const& geo);
+  void RenderColumns();
+    
+  // Private members
+  Model::Ptr model_;
+
+  nux::BaseTexture* background_top_;
+  nux::BaseTexture* background_left_;
+  nux::BaseTexture* background_corner_;
+  nux::BaseTexture* rounding_texture_;
+
+  nux::VLayout* layout_;
+  nux::HLayout* columns_layout_;
+  std::vector<nux::VLayout*> columns_;
+  
+  BackgroundEffectHelper bg_effect_helper_;
+  
+};
+
+} // namespace shortcut
+
+} // namespace unity
+
+#endif // UNITYSHELL_SHORTCUTVIEW_H
+

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2012-01-09 16:49:50 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-01-13 15:39:27 +0000
@@ -97,6 +97,7 @@
   , screen(screen)
   , cScreen(CompositeScreen::get(screen))
   , gScreen(GLScreen::get(screen))
+  , enable_shortcut_overlay_(true)
   , gestureEngine(nullptr)
   , wt(nullptr)
   , panelWindow(nullptr)
@@ -258,7 +259,8 @@
      optionSetIconSizeNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetAutohideAnimationNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetDashBlurExperimentalNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
-     optionSetDevicesOptionNotify(boost::bind (&UnityScreen::optionChanged, this, _1, _2));
+     optionSetDevicesOptionNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
+     optionSetShortcutOverlayNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetShowDesktopIconNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetShowLauncherInitiate(boost::bind(&UnityScreen::showLauncherKeyInitiate, this, _1, _2, _3));
      optionSetShowLauncherTerminate(boost::bind(&UnityScreen::showLauncherKeyTerminate, this, _1, _2, _3));
@@ -1120,6 +1122,7 @@
         // thing that could possibly make sense here.
         key_string[result] = 0;
         if (super_keypressed_) {
+          shortcut_controller_->Hide();
           skip_other_plugins = launcher.CheckSuperShortcutPressed(screen->dpy(), key_sym, event->xkey.keycode, event->xkey.state, key_string);
           if (!skip_other_plugins) {
             skip_other_plugins = dash_controller_->CheckShortcutActivation(key_string);
@@ -1234,6 +1237,33 @@
   super_keypressed_ = true;
   launcher_controller_->launcher().StartKeyShowLauncher();
   EnsureSuperKeybindings ();
+  
+  if (enable_shortcut_overlay_ and !shortcut_controller_->Visible())
+  {
+    static nux::Geometry last_geo;
+    UScreen* uscreen = UScreen::GetDefault();
+    int primary_monitor = uscreen->GetPrimaryMonitor();
+    auto monitor_geo = uscreen->GetMonitorGeometry(primary_monitor);
+        
+    int width = 970;
+    int height =  680;
+    int launcher_width = optionGetIconSize() + 18;
+    int panel_height = 24;
+    int x = monitor_geo.x + launcher_width + (monitor_geo.width - launcher_width- width) / 2;
+    int y = monitor_geo.y + panel_height + (monitor_geo.height - panel_height - height) / 2;
+    
+    nux::Geometry geo (x, y, width, height);
+    
+    if (last_geo != geo)
+    {
+      shortcut_controller_->SetWorkspace(geo);
+      last_geo = geo;
+    }
+    
+    if (last_geo.x > monitor_geo.x and last_geo.y > monitor_geo.y)
+      shortcut_controller_->Show();
+   }
+  
   return false;
 }
 
@@ -1243,6 +1273,7 @@
 {
   super_keypressed_ = false;
   launcher_controller_->launcher().EndKeyShowLauncher();
+  shortcut_controller_->Hide();
   return false;
 }
 
@@ -2176,6 +2207,9 @@
       screen->enterShowDesktopModeSetEnabled (this, optionGetShowMinimizedWindows ());
       screen->leaveShowDesktopModeSetEnabled (this, optionGetShowMinimizedWindows ());
       break;
+    case UnityshellOptions::ShortcutOverlay:
+      enable_shortcut_overlay_ = optionGetShortcutOverlay();
+      break;
     case UnityshellOptions::ShowDesktopIcon:
       launcher_controller_->SetShowDesktopIcon(optionGetShowDesktopIcon());
       break;
@@ -2304,6 +2338,10 @@
   /* Setup Places */
   dash_controller_.reset(new dash::Controller());
   dash_controller_->on_realize.connect(sigc::mem_fun(this, &UnityScreen::OnDashRealized));
+  
+  // Setup Shortcut Hint
+  InitHints();
+  shortcut_controller_.reset(new shortcut::Controller(hints_));
 
   AddChild(dash_controller_.get());
 
@@ -2316,6 +2354,66 @@
   OnLauncherHiddenChanged();
 }
 
+void UnityScreen::InitHints()
+{
+  // TODO move category text into a vector...
+  
+  // Launcher...
+  std::string const launcher = _("Launcher");
+  
+  hints_.push_back(new shortcut::Hint(launcher, "", _(" (Press)"), _("Open Launcher, displays shortcuts."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "show_launcher" ));
+  hints_.push_back(new shortcut::Hint(launcher, "", "", _("Open Launcher keyboard navigation mode."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "keyboard_focus"));
+  hints_.push_back(new shortcut::Hint(launcher, "", "", _("Switch applications via Launcher."), shortcut::HARDCODED_OPTION, "Super + Tab"));
+  hints_.push_back(new shortcut::Hint(launcher, "", _(" + 1 to 9"), _("Same as clicking on a Launcher icon."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "show_launcher"));
+  hints_.push_back(new shortcut::Hint(launcher, "", _(" + Shift + 1 to 9"), _("Open new window of the app."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "show_launcher"));
+  hints_.push_back(new shortcut::Hint(launcher, "", " + T", _("Open the Rubbish Bin."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "show_launcher")); 
+
+  // Dash...
+  std::string const dash = _("Dash");
+
+  hints_.push_back(new shortcut::Hint(dash, "", _(" (Tap)"), _("Open the Dash Home."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "show_launcher"));
+  hints_.push_back(new shortcut::Hint(dash, "", " + A", _("Open the Dash App Lens."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "show_launcher"));
+  hints_.push_back(new shortcut::Hint(dash, "", " + F", _("Open the Dash Files Lens."), shortcut::COMPIZ_KEY_OPTION,"unityshell", "show_launcher"));
+  hints_.push_back(new shortcut::Hint(dash, "", " + M", _("Open the Dash Music Lens."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "show_launcher"));
+  hints_.push_back(new shortcut::Hint(dash, "", "", _("Switches between Lenses."), shortcut::HARDCODED_OPTION, "Ctrl + Tab"));
+  hints_.push_back(new shortcut::Hint(dash, "", "", _("Moves the focus."), shortcut::HARDCODED_OPTION, _("Cursor Keys")));
+  hints_.push_back(new shortcut::Hint(dash, "", "", _("Open currently focused item."), shortcut::HARDCODED_OPTION, _("Enter & Return")));
+  hints_.push_back(new shortcut::Hint(dash, "", "", _("'Run Command' mode."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "execute_command"));
+ 
+  // Top Bar
+  std::string const topbar = _("Top Bar");
+  
+  hints_.push_back(new shortcut::Hint(topbar, "", "", _("Reveals application menu."), shortcut::HARDCODED_OPTION, "Alt"));
+  hints_.push_back(new shortcut::Hint(topbar, "", "", _("Opens the indicator menu."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "panel_first_menu"));
+  hints_.push_back(new shortcut::Hint(topbar, "", "", _("Moves focus between indicators."), shortcut::HARDCODED_OPTION, _("Cursor Left or Right")));
+
+  // Switching
+  std::string const switching = _("Switching");
+  
+  hints_.push_back(new shortcut::Hint(switching, "", "", _("Switch between applications."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "alt_tab_forward"));
+  hints_.push_back(new shortcut::Hint(switching, "", "", _("Switch windows of current application."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "alt_tab_next_window"));
+  hints_.push_back(new shortcut::Hint(switching, "", "", _("Moves the focus."), shortcut::HARDCODED_OPTION, _("Cursor Left or Right")));
+
+  // Workspaces
+  std::string const workspaces = _("Workspaces");
+  hints_.push_back(new shortcut::Hint(workspaces, "", "", _("Spread workspaces."), shortcut::COMPIZ_KEY_OPTION, "expo", "expo_key"));
+  hints_.push_back(new shortcut::Hint(workspaces, "", "", _("Switch workspaces."), shortcut::HARDCODED_OPTION, _("Super + Cursor Keys")));
+  hints_.push_back(new shortcut::Hint(workspaces, "", " or Right", _("Move focused window to different workspace."), shortcut::HARDCODED_OPTION, _("Super + Alt + Cursor Keys")));
+
+  // Windows
+  std::string const windows = _("Windows");
+  hints_.push_back(new shortcut::Hint(windows, "", "", _("Spreads all windows in the current workspace."), shortcut::COMPIZ_KEY_OPTION, "scale", "initiate_all_key"));
+  hints_.push_back(new shortcut::Hint(windows, "", "", _("Minimises all windows."), shortcut::COMPIZ_KEY_OPTION, "core", "show_desktop_key"));
+  hints_.push_back(new shortcut::Hint(windows, "", "", _("Maximises the current window."), shortcut::COMPIZ_KEY_OPTION, "core", "maximize_window_key"));
+  hints_.push_back(new shortcut::Hint(windows, "", "", _("Restores or minimises current window."), shortcut::COMPIZ_KEY_OPTION, "core", "unmaximize_window_key"));
+  hints_.push_back(new shortcut::Hint(windows, "", " or Right", _("Semi-maximises current window."), shortcut::COMPIZ_KEY_OPTION, "grid", "put_left_key"));
+  hints_.push_back(new shortcut::Hint(windows, "", "", _("Closes current window."), shortcut::COMPIZ_KEY_OPTION, "core", "close_window_key"));
+  hints_.push_back(new shortcut::Hint(windows, "", "", _("Opens window accessibility menu."), shortcut::HARDCODED_OPTION, "Alt + Space"));
+  hints_.push_back(new shortcut::Hint(windows, "", "", _("Places window in corresponding positions."), shortcut::HARDCODED_OPTION, "Ctrl + Alt + Num"));
+  hints_.push_back(new shortcut::Hint(windows, "", " Drag", _("Move window."), shortcut::COMPIZ_MOUSE_OPTION, "move", "initiate_button"));
+  hints_.push_back(new shortcut::Hint(windows, "", " Drag", _("Resize window."), shortcut::COMPIZ_MOUSE_OPTION, "resize", "initiate_button"));
+}
+
 /* Window init */
 UnityWindow::UnityWindow(CompWindow* window)
   : BaseSwitchWindow (dynamic_cast<BaseSwitchScreen *> (UnityScreen::get (screen)), window)

=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2012-01-06 04:53:09 +0000
+++ plugins/unityshell/src/unityshell.h	2012-01-13 15:39:27 +0000
@@ -39,6 +39,8 @@
 #include "DashSettings.h"
 #include "DashStyle.h"
 #include "FontSettings.h"
+#include "ShortcutController.h"
+#include "ShortcutHint.h"
 #include "LauncherController.h"
 #include "PanelController.h"
 #include "PanelStyle.h"
@@ -242,6 +244,8 @@
   static void OnQuicklistEndKeyNav(GVariant* data, void* value);
   static void OnLauncherStartKeyNav(GVariant* data, void* value);
   static void OnLauncherEndKeyNav(GVariant* data, void* value);
+  
+  void InitHints();
 
   dash::Settings dash_settings_;
   dash::Style    dash_style_;
@@ -253,6 +257,10 @@
   panel::Controller::Ptr    panel_controller_;
   switcher::Controller::Ptr switcher_controller_;
 
+  shortcut::Controller::Ptr shortcut_controller_;
+  std::list<shortcut::AbstractHint*> hints_;
+  bool enable_shortcut_overlay_;
+
   GestureEngine*                        gestureEngine;
   nux::WindowThread*                    wt;
   nux::BaseWindow*                      panelWindow;
@@ -266,7 +274,7 @@
   guint32                               _redraw_handle;
   gint                                  _edge_pointerY;
   guint                                 _ubus_handles[3];
-
+  
   typedef std::shared_ptr<CompAction> CompActionPtr;
   typedef std::vector<CompActionPtr> ShortcutActions;
   ShortcutActions _shortcut_actions;

=== modified file 'plugins/unityshell/unityshell.xml.in'
--- plugins/unityshell/unityshell.xml.in	2011-12-08 21:16:50 +0000
+++ plugins/unityshell/unityshell.xml.in	2012-01-13 15:39:27 +0000
@@ -341,6 +341,12 @@
                         <_name>Always</_name>
                     </desc>
                 </option>
+                
+                <option name="shortcut_overlay" type="bool">
+                  <_short>Enable Shortcut Hints Overlay</_short>
+                  <_long>Enable Shortcut Hints Overlay</_long>
+                  <default>true</default>
+                </option>
 
                 <option name="show_desktop_icon" type="bool">
                     <_short>Show "Desktop Icon" in the launcher</_short>

=== modified file 'standalone-clients/CMakeLists.txt'
--- standalone-clients/CMakeLists.txt	2012-01-06 13:10:01 +0000
+++ standalone-clients/CMakeLists.txt	2012-01-13 15:39:27 +0000
@@ -452,8 +452,32 @@
                )
 add_dependencies (bg-hash unity-core-${UNITY_API_VERSION})
 
+add_executable (test-shortcut
+                TestShortcut.cpp
+                ${UNITY_SRC}/AbstractSeparator.cpp
+                ${UNITY_SRC}/AbstractSeparator.h
+                ${UNITY_SRC}/AbstractShortcutHint.h
+                ${UNITY_SRC}/Animator.cpp
+                ${UNITY_SRC}/Animator.h
+                ${UNITY_SRC}/BackgroundEffectHelper.cpp
+                ${UNITY_SRC}/BackgroundEffectHelper.h
+                ${UNITY_SRC}/LineSeparator.cpp
+                ${UNITY_SRC}/LineSeparator.h
+                ${UNITY_SRC}/MockShortcutHint.h
+                ${UNITY_SRC}/ShortcutController.cpp
+                ${UNITY_SRC}/ShortcutController.h
+                ${UNITY_SRC}/ShortcutModel.cpp
+                ${UNITY_SRC}/ShortcutModel.h
+                ${UNITY_SRC}/ShortcutView.cpp
+                ${UNITY_SRC}/ShortcutView.h
+                ${UNITY_SRC}/StaticCairoText.cpp
+                ${UNITY_SRC}/StaticCairoText.h
+                ${UNITY_SRC}/UBusMessages.h
+                ${UNITY_SRC}/ubus-server.cpp
+                ${UNITY_SRC}/ubus-server.h
+                )            
+
 find_package (OpenGL)
-
 include_directories (${OPENGL_gl_INCDIRS})
 add_library (glfuncloader SHARED
 	     ${CMAKE_CURRENT_SOURCE_DIR}/GLFuncLoader.cpp)
@@ -467,9 +491,8 @@
 target_link_libraries (screen-effect-fbo glfuncloader ${OPENGL_gl_LIBRARY})
 add_dependencies (screen-effect-fbo ${UNITY_API_VERSION})
 
-
 # Custom target to make all the other targets here, add your test to this list
-add_custom_target(standalone-clients DEPENDS dash panel launcher switcher keyutil quicklist quicklist-visuals filters filter-bar preview-applicaiton preview-generic preview-music result-view dash-style bg-hash)
+add_custom_target(standalone-clients DEPENDS dash panel launcher switcher keyutil quicklist quicklist-visuals filters filter-bar preview-applicaiton preview-generic preview-music result-view dash-style bg-hash shortcut-view)
 
 
 

=== added file 'standalone-clients/TestShortcut.cpp'
--- standalone-clients/TestShortcut.cpp	1970-01-01 00:00:00 +0000
+++ standalone-clients/TestShortcut.cpp	2012-01-13 15:39:27 +0000
@@ -0,0 +1,109 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011 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: Andrea Azzarone <[e-mail]>
+ */
+ 
+#include <dbus/dbus-glib.h>
+#include <glib/gi18n-lib.h>
+#include <gtk/gtk.h>
+#include <Nux/Nux.h>
+#include <Nux/WindowThread.h>
+
+#include "BackgroundEffectHelper.h"
+#include "MockShortcutHint.h"
+#include "ShortcutController.h"
+
+using namespace unity;
+
+static shortcut::Controller::Ptr controller;
+
+void ThreadWidgetInit(nux::NThread* thread, void* InitData)
+{
+  std::list<shortcut::AbstractHint*> hints;
+  
+  // Launcher...
+  hints.push_back(new shortcut::MockHint(_("Launcher"), "", _(" (Press)"), _("Open Launcher, displays shortcuts."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "show_launcher" ));
+  hints.push_back(new shortcut::MockHint(_("Launcher"), "", "", _("Open Launcher keyboard navigation mode."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "keyboard_focus"));
+  // FIXME: Implement it...
+  hints.push_back(new shortcut::MockHint(_("Launcher"), "", "", _("Switch application via Launcher."), shortcut::HARDCODED_OPTION, "Super + Tab"));
+  hints.push_back(new shortcut::MockHint(_("Launcher"), "", _(" + 1 to 9"), _("Same as clicking on a Launcher icon."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "show_launcher"));
+  hints.push_back(new shortcut::MockHint(_("Launcher"), "", _(" + Shift + 1 to 9"), _("Open a new window of the app."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "show_launcher"));
+  hints.push_back(new shortcut::MockHint(_("Launcher"), "", " + T", _("Open the Rubbish Bin."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "show_launcher")); 
+
+  // Dash...
+  hints.push_back(new shortcut::MockHint(_("Dash"), "", _(" (Tap)"), _("Open the Dash Home."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "show_launcher"));
+  // These are not really hardcoded...
+  hints.push_back(new shortcut::MockHint(_("Dash"), "", " + A", _("Open the Dash App Lens."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "show_launcher"));
+  hints.push_back(new shortcut::MockHint(_("Dash"), "", " + F", _("Open the Dash Files Lens."), shortcut::COMPIZ_KEY_OPTION,"unityshell", "show_launcher"));
+  hints.push_back(new shortcut::MockHint(_("Dash"), "", " + M", _("Open the Dash Music Lens."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "show_launcher"));
+  hints.push_back(new shortcut::MockHint(_("Dash"), "", "", _("Switches between Lenses."), shortcut::HARDCODED_OPTION, "Ctrl + Tab"));
+  hints.push_back(new shortcut::MockHint(_("Dash"), "", "", _("Moves the focus."), shortcut::HARDCODED_OPTION, _("Cursor Keys")));
+  hints.push_back(new shortcut::MockHint(_("Dash"), "", "", _("Open currently focused item."), shortcut::HARDCODED_OPTION, _("Enter / Return")));
+  hints.push_back(new shortcut::MockHint(_("Dash"), "", "", _("'Run Command' mode."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "execute_command"));
+ 
+  // Top Bar
+  // Is it really hard coded?
+  hints.push_back(new shortcut::MockHint(_("Top Bar"), "", "", _("Reveals application menu."), shortcut::HARDCODED_OPTION, "Alt"));
+  hints.push_back(new shortcut::MockHint(_("Top Bar"), "", "", _("Opens the indicator menu."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "panel_first_menu"));
+  hints.push_back(new shortcut::MockHint(_("Top Bar"), "", "", _("Moves focus between indicators."), shortcut::HARDCODED_OPTION, _("Cursor Left & Right")));
+
+  // Switching
+  hints.push_back(new shortcut::MockHint(_("Switching"), "", "", _("Switch between applications."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "alt_tab_forward"));
+  hints.push_back(new shortcut::MockHint(_("Switching"), "", "", _("Switch windows of current application."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "alt_tab_next_window"));
+  hints.push_back(new shortcut::MockHint(_("Switching"), "", "", _("Close window switch, return to app switch."), shortcut::COMPIZ_KEY_OPTION, "unityshell", "alt_tab_detail_stop"));
+  hints.push_back(new shortcut::MockHint(_("Switching"), "", "", _("Moves the foucs."), shortcut::HARDCODED_OPTION, _("Cursor Left & Right")));
+
+  // Workspaces
+  hints.push_back(new shortcut::MockHint(_("Workspaces"), "", "", _("Spread workspaces."), shortcut::COMPIZ_KEY_OPTION, "expo", "expo_key"));
+  hints.push_back(new shortcut::MockHint(_("Workspaces"), "", "", _("Switch workspaces."), shortcut::HARDCODED_OPTION, _("Cursor Keys")));
+  //hints.push_back(new shortcut::MockHint(_("Workspaces"), "", "", _("Move focused window to other workspace."), ...)
+
+  // Windows
+  hints.push_back(new shortcut::MockHint(_("Windows"), "", "", _("Spreads all windows in current workspace."), shortcut::COMPIZ_KEY_OPTION, "scale", "initiate_output_key"));
+  hints.push_back(new shortcut::MockHint(_("Windows"), "", "", _("Minimises all windows."), shortcut::COMPIZ_KEY_OPTION, "core", "show_desktop_key"));
+  // I don't know if it is really hardcoded, but I can't find where this option is stored.
+  hints.push_back(new shortcut::MockHint(_("Windows"), "", "", _("Open window accessibility menu."), shortcut::HARDCODED_OPTION, "Alt+Space"));
+  hints.push_back(new shortcut::MockHint(_("Windows"), "", "", _("Maximises current window."), shortcut::COMPIZ_KEY_OPTION, "core", "maximize_window_key"));
+  hints.push_back(new shortcut::MockHint(_("Windows"), "", "", _("Un-maximises current window."), shortcut::COMPIZ_KEY_OPTION, "core", "unmaximize_window_key"));
+  hints.push_back(new shortcut::MockHint(_("Windows"), "", "", _("Minimises current window."), shortcut::COMPIZ_KEY_OPTION, "core", "minimize_window_key"));
+  hints.push_back(new shortcut::MockHint(_("Windows"), "", "", _("Resizes current window."), shortcut::COMPIZ_KEY_OPTION, "resize", "initiate_key"));
+  hints.push_back(new shortcut::MockHint(_("Windows"), "", "", _("Closes current window."), shortcut::COMPIZ_KEY_OPTION, "core", "close_window_key"));
+  hints.push_back(new shortcut::MockHint(_("Windows"), "", "", _("Places window in corresponding positions."), shortcut::HARDCODED_OPTION, "Ctrl + Alt + Num"));
+  hints.push_back(new shortcut::MockHint(_("Windows"), "", "", _("Move window."), shortcut::COMPIZ_KEY_OPTION, "move", "initiate_key"));
+      
+  controller.reset(new shortcut::Controller(hints));
+  controller->SetWorkspace(nux::Geometry(25, 17, 1200 - 50, 720 - 35));
+  controller->Show();
+}
+
+int main(int argc, char** argv)
+{
+  g_type_init();
+  //g_thread_init(NULL);
+  gtk_init(&argc, &argv);
+
+  dbus_g_thread_init();
+
+  nux::NuxInitialize(0);
+  
+  BackgroundEffectHelper::blur_type = BLUR_NONE;
+  nux::WindowThread* wt = nux::CreateGUIThread(TEXT("Unity Shortcut Hint Overlay"), 1200, 720, 0, &ThreadWidgetInit, 0);
+
+  wt->Run(NULL);
+  delete wt;
+  return 0;
+}

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2011-12-22 06:27:26 +0000
+++ tests/CMakeLists.txt	2012-01-13 15:39:27 +0000
@@ -70,7 +70,6 @@
                 ${UNITY_SRC}/
                 )
 add_dependencies (test-unit unity-core-${UNITY_API_VERSION})
-
 add_subdirectory (test-input-remover)
 add_subdirectory (test-minimize-window-handler)
 add_subdirectory (test-get-transients)
@@ -107,6 +106,7 @@
                  test_service_model.h)
   add_dependencies (test-gtest-service unity-core-${UNITY_API_VERSION})
 
+
 # The actual test executable (xless) - do not put anything that requires X in here
   add_executable(test-gtest-xless
                  test_animator.cpp
@@ -118,10 +118,13 @@
                  test_glib_signals_utils.h
                  ${CMAKE_CURRENT_BINARY_DIR}/test_glib_signals_utils_marshal.cpp
                  test_favorite_store_gsettings.cpp
+                 test_shortcut_model.cpp
+                 test_shortcut_private.cpp
                  test_introspection.cpp
                  test_main_xless.cpp
 		 test_grabhandle.cpp
                  ${UNITY_SRC}/AbstractLauncherIcon.h
+                 ${UNITY_SRC}/AbstractShortcutHint.h
                  ${UNITY_SRC}/Animator.cpp
                  ${UNITY_SRC}/Animator.h
                  ${UNITY_SRC}/DebugDBusInterface.h
@@ -133,6 +136,11 @@
                  ${UNITY_SRC}/FavoriteStoreGSettings.cpp
                  ${UNITY_SRC}/FavoriteStoreGSettings.h
                  ${UNITY_SRC}/MockLauncherIcon.h
+                 ${UNITY_SRC}/MockShortcutHint.h
+                 ${UNITY_SRC}/ShortcutModel.cpp
+                 ${UNITY_SRC}/ShortcutModel.h
+                 ${UNITY_SRC}/ShortcutHintPrivate.cpp
+                 ${UNITY_SRC}/ShortcutHintPrivate.h
                  ${UNITY_SRC}/SwitcherModel.cpp
                  ${UNITY_SRC}/SwitcherModel.h
                  ${UNITY_SRC}/Introspectable.cpp

=== added file 'tests/test_shortcut_model.cpp'
--- tests/test_shortcut_model.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_shortcut_model.cpp	2012-01-13 15:39:27 +0000
@@ -0,0 +1,84 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011 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: Andrea Azzarone <[e-mail]>
+ */
+
+#include <gtest/gtest.h>
+
+#include "MockShortcutHint.h"
+#include "ShortcutModel.h"
+
+using namespace unity::shortcut;
+
+namespace {
+
+TEST(TestShortcutModel, TestConstruction)
+{
+  std::list<AbstractHint*> hints;
+  
+  hints.push_back(new MockHint("Launcher", "", "", "Description 1", COMPIZ_KEY_OPTION, "Plugin 1", "key_option_1"));
+  hints.push_back(new MockHint("Launcher", "", "", "Description 2", HARDCODED_OPTION, "Value 2"));
+  hints.push_back(new MockHint("Dash", "Prefix", "Postfix", "Description 3", COMPIZ_KEY_OPTION, "Plugin 3", "key_option_3"));
+  hints.push_back(new MockHint("Top Bar", "Prefix", "Postfix", "Description 4", HARDCODED_OPTION, "Value4"));
+  
+  Model model(hints);
+  
+  EXPECT_EQ(model.categories().size(), 3);
+  EXPECT_EQ(model.hints()["Launcher"].size(), 2);
+  EXPECT_EQ(model.hints()["Dash"].size(), 1);
+  EXPECT_EQ(model.hints()["Top Bar"].size(), 1);
+  EXPECT_EQ(model.hints()["Unity"].size(), 0);
+}
+
+TEST(TestShortcutModel, TestFill)
+{
+  std::list<AbstractHint*> hints;
+  
+  hints.push_back(new MockHint("Launcher", "", "", "Description 1", COMPIZ_KEY_OPTION, "Plugin 1", "key_option_1"));
+  hints.push_back(new MockHint("Launcher", "", "", "Description 2", HARDCODED_OPTION, "Value 2"));
+  hints.push_back(new MockHint("Dash", "Prefix", "Postfix", "Description 3", COMPIZ_KEY_OPTION, "Plugin 3", "key_option_3"));
+  hints.push_back(new MockHint("Top Bar", "Prefix", "Postfix", "Description 4", HARDCODED_OPTION, "Value 4"));
+  
+  Model model(hints);
+  
+  model.Fill();
+  
+  // We cannot test CompOption here... :/
+  EXPECT_EQ(model.hints()["Launcher"].front()->value(), "Plugin 1-key_option_1");
+  EXPECT_EQ(model.hints()["Launcher"].back()->value(), "Value 2");
+  EXPECT_EQ(model.hints()["Dash"].front()->value(),"Plugin 3-key_option_3");
+  EXPECT_EQ(model.hints()["Top Bar"].front()->value(), "Value 4");
+}
+
+TEST(TestShortcutModel, TestProperty)
+{
+  std::list<AbstractHint*> hints;
+  
+  hints.push_back(new MockHint("Launcher", "Prefix1", "Postfix1", "Description1", COMPIZ_KEY_OPTION, "Plugin1", "key_option1"));
+  
+  Model model(hints);
+  
+  EXPECT_EQ(model.hints()["Launcher"].front()->category(), "Launcher");
+  EXPECT_EQ(model.hints()["Launcher"].front()->prefix(), "Prefix1");
+  EXPECT_EQ(model.hints()["Launcher"].front()->postfix(), "Postfix1");
+  EXPECT_EQ(model.hints()["Launcher"].front()->description(), "Description1");
+  EXPECT_EQ(model.hints()["Launcher"].front()->type(), COMPIZ_KEY_OPTION);
+  EXPECT_EQ(model.hints()["Launcher"].front()->arg1(), "Plugin1");
+  EXPECT_EQ(model.hints()["Launcher"].front()->arg2(), "key_option1");  
+}
+
+} // anonymouse namespace

=== added file 'tests/test_shortcut_private.cpp'
--- tests/test_shortcut_private.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_shortcut_private.cpp	2012-01-13 15:39:27 +0000
@@ -0,0 +1,74 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011 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: Andrea Azzarone <[e-mail]>
+ */
+
+#include <gtest/gtest.h>
+
+#include "ShortcutHintPrivate.h"
+
+using namespace unity::shortcut::impl;
+
+namespace {
+
+TEST(TestShortcutHintPrivate, TestFixShortcutFormatCorrect)
+{
+  EXPECT_EQ(FixShortcutFormat("Super"), "Super");
+  EXPECT_EQ(FixShortcutFormat("Super + A"), "Super + A");
+}
+
+
+TEST(TestShortcutHintPrivate, TestFixShortcutFormatLT)
+{
+  EXPECT_EQ(FixShortcutFormat("<Super"), "Super");
+  EXPECT_EQ(FixShortcutFormat("<Super + <Alt"), "Super + Alt");
+}
+
+TEST(TestShortcutHintPrivate, TestFixShortcutFormatGT)
+{
+  EXPECT_EQ(FixShortcutFormat("Super>"), "Super");
+  EXPECT_EQ(FixShortcutFormat("Super>A"), "Super + A");
+  EXPECT_EQ(FixShortcutFormat("Super>Alt>A"), "Super + Alt + A");
+}
+
+TEST(TestShortcutHintPrivate, TestFixShortcutComplete)
+{
+  EXPECT_EQ(FixShortcutFormat("Super"), "Super");
+  EXPECT_EQ(FixShortcutFormat("Super + A"), "Super + A");
+  EXPECT_EQ(FixShortcutFormat("<Super>"), "Super");
+  EXPECT_EQ(FixShortcutFormat("<Super>A"), "Super + A");
+  EXPECT_EQ(FixShortcutFormat("<Super><Alt>A"), "Super + Alt + A");
+}
+
+TEST(TestShortcutHintPrivate, TestProperCase)
+{
+  EXPECT_EQ(ProperCase("super"), "Super");
+  EXPECT_EQ(ProperCase("sUper"), "SUper");
+  EXPECT_EQ(ProperCase("super + a"), "Super + A");
+  EXPECT_EQ(ProperCase("super+a"), "Super+A");
+  EXPECT_EQ(ProperCase("<super><alt>a"), "<Super><Alt>A");
+}
+
+TEST(TestShortcutHintPrivate, TestFixMouseShortcut)
+{
+  EXPECT_EQ(FixMouseShortcut("Super<Button1>"), "Super<Left Mouse>");
+  EXPECT_EQ(FixMouseShortcut("Super<Button2>"), "Super<Middle Mouse>");
+  EXPECT_EQ(FixMouseShortcut("Super<Button3>"), "Super<Right Mouse>");
+
+}
+
+} // anonymouse namespace