Merge lp:~mandel/unity/add-action-link into lp:unity

[Manuel de la Peña]

- Provide a re-usable UI element that looks and behaves like a url link (LP: #1067705).

- Provide a re-usable UI element that looks and behaves like a url link (LP: #1067705).

[Nick Dedekind (nick-dedekind)]

Firstly, you need to watch out when copying classes. You should do a full code check to make sure there is nothing left over that isn't used in the new class, and anything (defs/comment) that references the old class.

I don't think this belongs to the AbstractButton scope; it's more in the StaticCairoText area, seeing as that's all a link really is as far as I'm aware (a label which you can click). You can then put the mouse/keyboard activation into the overriding class.

Other than that, here are a few code comments.

34 +namespace
35 +{
36 +
37 +
38 +nux::logging::Logger logger("unity.dash.actionlink");
39 +}

remove extra white-space

99 +void ActionLink::BuildLayout(std::string const& label, std::string const& extra_hint)

no extra_hint in an action link.

94 + cr_normal_.reset(new nux::CairoWrapper(geo,
95 + [](nux::Geometry const& geom, cairo_t* cr) {}));

You're not using the texture, so remove it from the class/drawing. (left over from ActionButton)

Underline: Can you not use font/markup to do the underlining instead of a fairly hacky hseparator?

review: Needs Fixing

[Nick Dedekind (nick-dedekind)]

apon furthur inspection, looks OK to leave it as a button.
Thought there was a bit more to a abstract button than there is.

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

Please, add tests too.

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

56 +ActionLink::~ActionLink()
57 +{
58 +}

Get rid of it

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

Please get rid of the magic numbers in GetLinkAlpha replacing them with const values into an anonymous namespace, however that's globally nice, thanks! ;)

review: Approve

[Nick Dedekind (nick-dedekind)]

50 + SetAcceptKeyNavFocusOnMouseDown(false);
51 + SetAcceptKeyNavFocusOnMouseEnter(true);

Since you have an Init function, you should put these in there.

73 + SetMinimumHeight(40);

MAGIC. Is there a reason you need a minimum height and are not just using the layout's height calculated from the contents? If you do need it, use a const in anon namespace.

105 + static_text_->SetTextAlignment(nux::StaticCairoText::NUX_ALIGN_CENTRE);
106 + static_text_->SetUnderline(nux::StaticCairoText::NUX_UNDERLINE_SINGLE)

Since this is a general control these should be options on the action link, which are defaulted to these values. (SetTextAlignment/SetTextUnderline)

139 + if (cached_geometry_ != geo && geo.width > 0 && geo.height > 0)
140 + {
141 + cached_geometry_ = geo;
142 + }

There doesn't seem to be a purpose for the geometry caching that I can see, in which case you should be able to remove the ComputeContentSize override.

179 + nux::Geometry clip_geo = geo;

No need to make a copy of the geometry ref unless you're modifying it.

review: Needs Fixing

[Nick Dedekind (nick-dedekind)]

LGTM.
All tests run successfully.

review: Approve

=== added file 'dash/previews/ActionLink.cpp'
--- dash/previews/ActionLink.cpp	1970-01-01 00:00:00 +0000
+++ dash/previews/ActionLink.cpp	2012-11-28 10:01:36 +0000
@@ -0,0 +1,248 @@
+/*
+ * Copyright 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 applicable version of the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of both the GNU Lesser General Public
+ * License version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Manuel de la Pena <[e-mail]>
+ *
+ */
+
+#include "ActionLink.h"
+#include <NuxCore/Logger.h>
+#include <Nux/VLayout.h>
+#include <UnityCore/Variant.h>
+#include "unity-shared/DashStyle.h"
+#include "unity-shared/IconTexture.h"
+#include "unity-shared/StaticCairoText.h"
+
+namespace
+{
+nux::logging::Logger logger("unity.dash.actionlink");
+const double LINK_NORMAL_ALPHA_VALUE = 4;
+const double LINK_HIGHLIGHTED_ALPHA_VALUE = 1;
+}
+
+namespace unity
+{
+namespace dash
+{
+
+ActionLink::ActionLink(std::string const& action_hint, std::string const& label, NUX_FILE_LINE_DECL)
+  : nux::AbstractButton(NUX_FILE_LINE_PARAM)
+  , action_hint_(action_hint)
+  , aligment_(nux::StaticCairoText::NUX_ALIGN_CENTRE)
+  , underline_(nux::StaticCairoText::NUX_UNDERLINE_SINGLE)
+{
+  Init();
+  BuildLayout(label);
+}
+
+std::string ActionLink::GetName() const
+{
+  return "ActionLink";
+}
+
+void ActionLink::AddProperties(GVariantBuilder* builder)
+{
+  variant::BuilderWrapper(builder)
+    .add(GetAbsoluteGeometry())
+    .add("action", action_hint_)
+    .add("label", label_)
+    .add("font-hint", font_hint)
+    .add("active", active_)
+    .add("text-aligment", text_aligment)
+    .add("underline-state", underline_state);
+}
+
+void ActionLink::Init()
+{
+  SetAcceptKeyNavFocusOnMouseDown(false);
+  SetAcceptKeyNavFocusOnMouseEnter(true);
+
+  // set properties to ensure that we do redraw when one of them changes
+  text_aligment.SetSetterFunction(sigc::mem_fun(this, &ActionLink::set_aligment));
+  text_aligment.SetGetterFunction(sigc::mem_fun(this, &ActionLink::get_aligment));
+
+  underline_state.SetSetterFunction(sigc::mem_fun(this, &ActionLink::set_underline));
+  underline_state.SetGetterFunction(sigc::mem_fun(this, &ActionLink::get_underline));
+
+  font_hint.SetSetterFunction(sigc::mem_fun(this, &ActionLink::set_font_hint));
+  font_hint.SetGetterFunction(sigc::mem_fun(this, &ActionLink::get_font_hint));
+
+  key_nav_focus_change.connect([&] (nux::Area*, bool, nux::KeyNavDirection)
+  {
+    QueueDraw();
+  });
+
+  key_nav_focus_activate.connect([&](nux::Area*)
+  {
+    if (GetInputEventSensitivity())
+      activate.emit(this, action_hint_);
+  });
+}
+
+void ActionLink::BuildLayout(std::string const& label)
+{
+
+  if (label != label_)
+  {
+    label_ = label;
+    if (static_text_)
+    {
+      static_text_.Release();
+      static_text_ = NULL;
+    }
+
+    if (!label_.empty())
+    {
+      static_text_ = new nux::StaticCairoText(label_, true, NUX_TRACKER_LOCATION);
+      if (!font_hint_.empty())
+        static_text_->SetFont(font_hint_);
+      static_text_->SetInputEventSensitivity(false);
+      static_text_->SetTextAlignment(aligment_);
+      static_text_->SetUnderline(underline_);
+    }
+  }
+
+  RemoveLayout();
+
+  nux::VLayout* layout = new nux::VLayout();
+  if (static_text_)
+  {
+    layout->AddView(static_text_.GetPointer(),
+                    1, nux::MINOR_POSITION_START, nux::MINOR_SIZE_FULL,
+                    100.0f, nux::NUX_LAYOUT_END);
+  }
+  SetLayout(layout);
+
+  ComputeContentSize();
+  QueueDraw();
+}
+
+int ActionLink::GetLinkAlpha(nux::ButtonVisualState state)
+{
+  if (state == nux::ButtonVisualState::VISUAL_STATE_PRELIGHT)
+    return LINK_HIGHLIGHTED_ALPHA_VALUE;
+  else
+    return LINK_NORMAL_ALPHA_VALUE;
+}
+
+void ActionLink::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
+{
+  nux::Geometry const& geo = GetGeometry();
+
+  gPainter.PaintBackground(GfxContext, geo);
+  // set up our texture mode
+  nux::TexCoordXForm texxform;
+  texxform.SetWrap(nux::TEXWRAP_REPEAT, nux::TEXWRAP_REPEAT);
+  texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
+
+  // clear what is behind us
+  unsigned int alpha = 0, src = 0, dest = 0;
+
+  // set the alpha of the text according to its state
+  static_text_->SetTextAlpha(GetLinkAlpha(GetVisualState()));
+
+  GfxContext.GetRenderStates().GetBlend(alpha, src, dest);
+  GfxContext.GetRenderStates().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+
+  nux::Color col = nux::color::Black;
+  col.alpha = 0;
+  GfxContext.QRP_Color(geo.x,
+                       geo.y,
+                       geo.width,
+                       geo.height,
+                       col);
+
+  GfxContext.GetRenderStates().SetBlend(alpha, src, dest);
+
+  if (GetCompositionLayout())
+  {
+    gPainter.PushPaintLayerStack();
+    {
+
+      GfxContext.PushClippingRectangle(geo);
+      gPainter.PushPaintLayerStack();
+      GetCompositionLayout()->ProcessDraw(GfxContext, force_draw);
+      gPainter.PopPaintLayerStack();
+      GfxContext.PopClippingRectangle();
+    }
+    gPainter.PopPaintLayerStack();
+  }
+}
+
+void ActionLink::RecvClick(int x, int y, unsigned long button_flags, unsigned long key_flags)
+{
+  activate.emit(this, action_hint_);
+}
+
+bool ActionLink::set_aligment(nux::StaticCairoText::AlignState aligment)
+{
+  if(static_text_ && aligment_ != aligment)
+  {
+    static_text_->SetTextAlignment(aligment_);
+    aligment_ = aligment;
+    ComputeContentSize();
+    QueueDraw();
+  }
+  return true;
+}
+
+nux::StaticCairoText::AlignState ActionLink::get_aligment()
+{
+  return aligment_;
+}
+
+bool ActionLink::set_underline(nux::StaticCairoText::UnderlineState underline)
+{
+  if(static_text_ && underline_ != underline)
+  {
+    static_text_->SetUnderline(underline_);
+    underline_ = underline;
+    ComputeContentSize();
+    QueueDraw();
+  }
+  return true;
+}
+
+nux::StaticCairoText::UnderlineState ActionLink::get_underline()
+{
+  return underline_;
+}
+
+bool ActionLink::set_font_hint(std::string font_hint)
+{
+  if(static_text_ && font_hint_ != font_hint)
+  {
+    static_text_->SetFont(font_hint_);
+    font_hint_ = font_hint;
+    ComputeContentSize();
+    QueueDraw();
+  }
+  return true;
+}
+
+std::string ActionLink::get_font_hint()
+{
+  return font_hint_;
+}
+
+std::string ActionLink::GetLabel() const
+{
+  return label_;
+}
+
+} // namespace dash
+} // namespace unity

=== added file 'dash/previews/ActionLink.h'
--- dash/previews/ActionLink.h	1970-01-01 00:00:00 +0000
+++ dash/previews/ActionLink.h	2012-11-28 10:01:36 +0000
@@ -0,0 +1,100 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 applicable version of the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of both the GNU Lesser General Public
+ * License version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Manuel de la Pena <[e-mail]>
+ *
+ */
+
+#ifndef ACTIONLINK_H
+#define ACTIONLINK_H
+
+#include <Nux/Nux.h>
+#include <Nux/CairoWrapper.h>
+#include <Nux/AbstractButton.h>
+#include "unity-shared/Introspectable.h"
+#include "unity-shared/StaticCairoText.h"
+
+
+namespace unity
+{
+class IconTexture;
+
+namespace dash
+{
+
+class ActionLink : public nux::AbstractButton, public debug::Introspectable
+{
+public:
+  ActionLink(std::string const& action_hint, std::string const& label, NUX_FILE_LINE_PROTO);
+
+  sigc::signal<void, ActionLink*, std::string const&> activate;
+
+  nux::RWProperty<nux::StaticCairoText::AlignState> text_aligment;
+  nux::RWProperty<nux::StaticCairoText::UnderlineState> underline_state;
+  nux::RWProperty<std::string> font_hint;
+
+  void Activate() {}
+  void Deactivate() {}
+
+  virtual bool AcceptKeyNavFocus() const { return true; }
+
+  std::string GetLabel() const;
+  std::string GetExtraText() const;
+
+protected:
+  nux::ObjectPtr<nux::StaticCairoText> static_text_;
+
+  int GetLinkAlpha(nux::ButtonVisualState state);
+
+  void Draw(nux::GraphicsEngine& GfxContext, bool force_draw);
+  void DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw) {}
+  void RecvClick(int x, int y, unsigned long button_flags, unsigned long key_flags);
+
+  void Init();
+
+  void BuildLayout(std::string const& label);
+
+  // From debug::Introspectable
+  std::string GetName() const;
+  void AddProperties(GVariantBuilder* builder);
+
+  // this methods/vars could be private but are protected to make testing
+  //  easier
+  bool set_aligment(nux::StaticCairoText::AlignState aligment);
+  nux::StaticCairoText::AlignState get_aligment();
+
+  bool set_underline(nux::StaticCairoText::UnderlineState underline);
+  nux::StaticCairoText::UnderlineState get_underline();
+
+  bool set_font_hint(std::string font_hint);
+  std::string get_font_hint();
+
+  std::string action_hint_;
+  std::string font_hint_;
+  nux::StaticCairoText::AlignState aligment_;
+  nux::StaticCairoText::UnderlineState underline_;
+private:
+  typedef std::unique_ptr<nux::CairoWrapper> NuxCairoPtr;
+
+
+};
+
+} // namespace dash
+} // namespace unity
+
+#endif // ACTIONLINK_H

=== modified file 'dash/previews/CMakeLists.txt'
--- dash/previews/CMakeLists.txt	2012-11-26 16:09:53 +0000
+++ dash/previews/CMakeLists.txt	2012-11-28 10:01:36 +0000
@@ -26,6 +26,7 @@
 #
 set (PREVIEWS_SOURCES
      ActionButton.cpp
+     ActionLink.cpp
      ApplicationPreview.cpp
      GenericPreview.cpp
      MusicPreview.cpp

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2012-11-24 15:34:32 +0000
+++ tests/CMakeLists.txt	2012-11-28 10:01:36 +0000
@@ -206,6 +206,7 @@
 # Tests that require X
   add_executable(test-gtest
                  test_main.cpp
+                 test_action_link.cpp
                  test_application_launcher_icon.cpp
                  test_bfb_launcher_icon.cpp
                  test_dashview_impl.cpp

=== added file 'tests/test_action_link.cpp'
--- tests/test_action_link.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_action_link.cpp	2012-11-28 10:01:36 +0000
@@ -0,0 +1,188 @@
+/*
+ * Copyright 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 applicable version of the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of both the GNU Lesser General Public
+ * License version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Manuel de la Pena <[e-mail]>
+ *
+ */
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <unity-shared/StaticCairoText.h>
+
+#include "dash/previews/ActionLink.cpp"
+#include "test_utils.h"
+
+using namespace nux;
+using namespace unity;
+using namespace unity::dash;
+
+namespace unity
+{
+
+namespace dash
+{
+
+class ActionLinkMock : public ActionLink
+{
+  public:
+    MOCK_METHOD0(QueueDraw, void());
+    MOCK_METHOD0(ComputeContentSize, long());
+    MOCK_METHOD2(CalculateBar, void(nux::GraphicsEngine&, bool));
+
+    ActionLinkMock(std::string const& action_hint, std::string const& label, NUX_FILE_LINE_PROTO)
+      : ActionLink(action_hint, label){}
+    ~ActionLinkMock(){}
+
+    nux::ObjectPtr<nux::StaticCairoText> GetText() { return static_text_; }
+
+    using ActionLink::GetLinkAlpha;
+    using ActionLink::Draw;
+    using ActionLink::DrawContent;
+    using ActionLink::RecvClick;
+    using ActionLink::GetName;
+    using ActionLink::AddProperties;
+    using ActionLink::set_aligment;
+    using ActionLink::get_aligment;
+    using ActionLink::set_underline;
+    using ActionLink::get_underline;
+    using ActionLink::set_font_hint;
+    using ActionLink::get_font_hint;
+    using ActionLink::action_hint_;
+    using ActionLink::font_hint_;
+    using ActionLink::aligment_;
+    using ActionLink::underline_;
+};
+
+class TestActionLink : public ::testing::Test
+{
+  protected:
+    TestActionLink() : Test()
+    {
+      action_link = new ActionLinkMock("action_id", "display_name");
+    }
+    nux::ObjectPtr<ActionLinkMock> action_link;
+};
+
+TEST_F(TestActionLink, AligmentCorrectlySetDifferent)
+{
+  ActionLinkMock link("test", "test");
+
+  EXPECT_CALL(link, ComputeContentSize()).Times(1);
+  EXPECT_CALL(link, QueueDraw()).Times(1);
+
+  link.text_aligment.Set(nux::StaticCairoText::NUX_ALIGN_RIGHT);
+}
+
+TEST_F(TestActionLink, AligmentCorrectlySetSame)
+{
+  ActionLinkMock link("test", "test");
+
+  EXPECT_CALL(link, ComputeContentSize()).Times(0);
+  EXPECT_CALL(link, QueueDraw()).Times(0);
+
+  link.text_aligment.Set(link.text_aligment.Get());
+}
+
+TEST_F(TestActionLink, AligmentCorrectlyRetrieved)
+{
+  nux::StaticCairoText::AlignState aligment =
+    nux::StaticCairoText::NUX_ALIGN_RIGHT;
+  action_link->aligment_ = aligment;
+  EXPECT_EQ(aligment, action_link->text_aligment.Get());
+}
+
+TEST_F(TestActionLink, UnderlineCorrectlySetDifferent)
+{
+  ActionLinkMock link("test", "test");
+
+  EXPECT_CALL(link, ComputeContentSize()).Times(1);
+  EXPECT_CALL(link, QueueDraw()).Times(1);
+  link.underline_state.Set(nux::StaticCairoText::NUX_UNDERLINE_NONE);
+}
+
+TEST_F(TestActionLink, UnderlineCorrectlySetSame)
+{
+  ActionLinkMock link("test", "test");
+
+  EXPECT_CALL(link, ComputeContentSize()).Times(0);
+  EXPECT_CALL(link, QueueDraw()).Times(0);
+  link.underline_state.Set(link.underline_state.Get());
+}
+
+TEST_F(TestActionLink, UnderlineCorrectlyRetrieved)
+{
+  nux::StaticCairoText::UnderlineState underline =
+    nux::StaticCairoText::NUX_UNDERLINE_DOUBLE;
+  action_link->underline_ = underline;
+  EXPECT_EQ(underline, action_link->underline_state.Get());
+}
+
+TEST_F(TestActionLink, FontCorrectlySetDifferent)
+{
+  ActionLinkMock link("test", "test");
+  link.font_hint_ = "Ubuntu 10";
+
+  EXPECT_CALL(link, ComputeContentSize()).Times(1);
+  EXPECT_CALL(link, QueueDraw()).Times(1);
+  link.font_hint.Set("Ubuntu 11");
+}
+
+TEST_F(TestActionLink, FontCorrectlySetSame)
+{
+  ActionLinkMock link("test", "test");
+  link.font_hint_ = "Ubuntu 10";
+
+  EXPECT_CALL(link, ComputeContentSize()).Times(0);
+  EXPECT_CALL(link, QueueDraw()).Times(0);
+  link.font_hint.Set(link.font_hint.Get());
+}
+
+TEST_F(TestActionLink, FontCorrectlyRetrieved)
+{
+  std::string font_hint = "Ubuntu 11";
+  action_link->font_hint_ = font_hint;
+  EXPECT_EQ(font_hint, action_link->font_hint.Get());
+}
+
+TEST_F(TestActionLink, LinkAlphaOnPressed)
+{
+   ButtonVisualState state = ButtonVisualState::VISUAL_STATE_PRESSED;
+   EXPECT_EQ(4, action_link->GetLinkAlpha(state));
+}
+
+TEST_F(TestActionLink, LinkAlphaOnNormal)
+{
+   ButtonVisualState state = ButtonVisualState::VISUAL_STATE_NORMAL;
+   EXPECT_EQ(4, action_link->GetLinkAlpha(state));
+}
+
+TEST_F(TestActionLink, LinkAlphaOnPrelight)
+{
+   ButtonVisualState state = ButtonVisualState::VISUAL_STATE_PRELIGHT;
+   EXPECT_EQ(1, action_link->GetLinkAlpha(state));
+}
+
+TEST_F(TestActionLink, LinkAlphaOnDisabled)
+{
+   ButtonVisualState state = ButtonVisualState::VISUAL_STATE_DISABLED;
+   EXPECT_EQ(4, action_link->GetLinkAlpha(state));
+}
+
+}
+
+}

=== modified file 'unity-shared/StaticCairoText.cpp'
--- unity-shared/StaticCairoText.cpp	2012-11-22 10:46:13 +0000
+++ unity-shared/StaticCairoText.cpp	2012-11-28 10:01:36 +0000
@@ -54,6 +54,7 @@
   std::string GetEffectiveFont() const;
   Size GetTextExtents() const;
 
+  void SetAttributes(PangoLayout* layout);
   void DrawText(cairo_t* cr, int width, int height, int line_spacing, Color const& color);
 
   void UpdateTexture();
@@ -75,6 +76,7 @@
   EllipsizeState ellipsize_;
   AlignState align_;
   AlignState valign_;
+  UnderlineState underline_; 
 
   std::string font_;
 
@@ -97,6 +99,7 @@
   , ellipsize_(NUX_ELLIPSIZE_END)
   , align_(NUX_ALIGN_LEFT)
   , valign_(NUX_ALIGN_TOP)
+  , underline_(NUX_UNDERLINE_NONE)
   , lines_(-2)  // should find out why -2...
     // the desired height of the layout in Pango units if positive, or desired
     // number of lines if negative.
@@ -312,6 +315,16 @@
   }
 }
 
+void StaticCairoText::SetTextAlpha(unsigned int alpha)
+{
+  if (pimpl->text_color_.alpha != alpha)
+  {
+    pimpl->text_color_.alpha = alpha;
+    pimpl->UpdateTexture();
+    QueueDraw();
+  }
+}
+
 void StaticCairoText::SetMaximumSize(int w, int h)
 {
   if (w != GetMaximumWidth())
@@ -320,7 +333,7 @@
     View::SetMaximumSize(w, h);
     pimpl->UpdateTexture();
     return;
-  } 
+  }
 
   View::SetMaximumSize(w, h);
 }
@@ -380,6 +393,18 @@
   return pimpl->font_;
 }
 
+void StaticCairoText::SetUnderline(UnderlineState underline)
+{
+  if (pimpl->underline_ != underline)
+  {
+    pimpl->underline_ = underline;
+    pimpl->need_new_extent_cache_ = true;
+    Size s = GetTextExtents();
+    SetMinimumHeight(s.height);
+    NeedRedraw();
+  }
+}
+
 int StaticCairoText::GetLineCount() const
 {
   return pimpl->actual_lines_;
@@ -489,6 +514,37 @@
   return result;
 }
 
+void StaticCairoText::Impl::SetAttributes(PangoLayout *layout)
+{
+  PangoAttrList* attr_list  = NULL;
+  PangoAttribute* underline_attr = NULL;
+
+  attr_list = pango_layout_get_attributes(layout);
+  if(!attr_list)
+  {
+    attr_list = pango_attr_list_new();
+  }
+
+  PangoUnderline underline_type;
+
+  switch(underline_){
+    case(NUX_UNDERLINE_SINGLE):
+      underline_type = PANGO_UNDERLINE_SINGLE;
+      break;
+    case(NUX_UNDERLINE_DOUBLE):
+      underline_type = PANGO_UNDERLINE_DOUBLE;
+      break;
+    case(NUX_UNDERLINE_LOW):
+      underline_type = PANGO_UNDERLINE_LOW;
+      break;
+    default:
+      underline_type = PANGO_UNDERLINE_NONE;
+  }
+  underline_attr = pango_attr_underline_new(underline_type);
+  pango_attr_list_insert(attr_list, underline_attr);
+  pango_layout_set_attributes(layout, attr_list);
+}
+
 void StaticCairoText::Impl::DrawText(cairo_t* cr,
                                      int width,
                                      int height,
@@ -506,8 +562,9 @@
 
   cairo_set_font_options(cr, gdk_screen_get_font_options(screen));
   layout = pango_cairo_create_layout(cr);
+
+  
   desc = pango_font_description_from_string(font.c_str());
-
   pango_layout_set_font_description(layout, desc);
   pango_layout_set_wrap(layout, PANGO_WRAP_WORD_CHAR);
   pango_layout_set_ellipsize(layout, GetPangoEllipsizeMode());
@@ -518,6 +575,9 @@
   pango_layout_set_spacing(layout, line_spacing * PANGO_SCALE);
 
   pango_layout_set_height(layout, lines_);
+
+  SetAttributes(layout);
+
   pangoCtx = pango_layout_get_context(layout);  // is not ref'ed
   pango_cairo_context_set_font_options(pangoCtx,
                                        gdk_screen_get_font_options(screen));

=== modified file 'unity-shared/StaticCairoText.h'
--- unity-shared/StaticCairoText.h	2012-11-22 10:46:13 +0000
+++ unity-shared/StaticCairoText.h	2012-11-28 10:01:36 +0000
@@ -51,6 +51,14 @@
     NUX_ALIGN_BOTTOM = NUX_ALIGN_RIGHT
   };
 
+  enum UnderlineState
+  {
+    NUX_UNDERLINE_NONE,
+    NUX_UNDERLINE_SINGLE,
+    NUX_UNDERLINE_DOUBLE,
+    NUX_UNDERLINE_LOW
+  };
+
   StaticCairoText(std::string const& text, NUX_FILE_LINE_PROTO);
   StaticCairoText(std::string const& text, bool escape_text, NUX_FILE_LINE_PROTO);
   ~StaticCairoText();
@@ -67,12 +75,14 @@
 
   // public API
   void SetText(std::string const& text, bool escape_text = false);
+  void SetTextAlpha(unsigned int alpha);
   void SetTextColor(Color const& textColor);
   void SetTextEllipsize(EllipsizeState state);
   void SetTextAlignment(AlignState state);
   void SetTextVerticalAlignment(AlignState state);
   void SetFont(std::string const& font);
   std::string GetFont();
+  void SetUnderline(UnderlineState underline);
   void SetLines(int maximum_lines);
   void SetLineSpacing(float line_spacing);