Merge lp:~feng-kylin/unity/ExtendLockscreenTheme into lp:unity

[handsome_feng]

Extend the lockscreen theme for kylin.

Extend the lockscreen theme.

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

As a first thing (i'm going into details soon), I think you should properly re-base your changes with trunk because this branch is reverting many changes happened upstream.

Looking at what changed, I think you should probably uncommit your last revision (4040, which is the one causing troubles), and push here again.

So:
bzr shelve --all -m tmp
bzr uncommit
bzr revert
bzr push --overwrite lp:~feng-kylin/unity/ExtendLockscreenTheme
bzr unshelve

If you need to revert 4038, use:
bzr merge -r 4038..4037 .

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

review: Needs Fixing

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

Ah, also revert the changes applied at po files at revision 4022

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

Looks nice and works well, there are some improvements to do, though.

See the inline comments I wrote.

Let's try to share the most of the code we can, and to make things to be more customizable.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:4041
http://jenkins.qa.ubuntu.com/job/unity-ci/1352/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-xenial-amd64-ci/4
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-xenial-armhf-ci/4
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-xenial-i386-ci/4

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-ci/1352/rebuild

review: Approve (continuous-integration)

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

I would prefer to call LockScreenAbstractShield as LockScreenBaseShield and moving the implementation in a cpp file.

I can do this kind of work, so I can double-check that both implementations keep the things together.
Let me know if it's fine if I provide a branch that you can merge with this.

[handsome_feng (feng-kylin)]

> I would prefer to call LockScreenAbstractShield as LockScreenBaseShield and
> moving the implementation in a cpp file.
>
> I can do this kind of work, so I can double-check that both implementations
> keep the things together.
> Let me know if it's fine if I provide a branch that you can merge with this.

Sure, It's fine.

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

So, I've done some cleanup to this, adding the LockScreenBaseShield class, you can merge with lp:~3v1n0/unity/kylin-lockscreen-cleanup

See the merge proposal at lp:~3v1n0/unity/kylin-lockscreen-cleanup/+merge/279546 for the diff.

[handsome_feng (feng-kylin)]

> So, I've done some cleanup to this, adding the LockScreenBaseShield class, you
> can merge with lp:~3v1n0/unity/kylin-lockscreen-cleanup
>
> See the merge proposal at lp:~3v1n0/unity/kylin-lockscreen-
> cleanup/+merge/279546 for the diff.

I have merged your branch, it works well. thank you!
and I modified some copyright notices in some file（not sure whether it's right，
If there is anything wrong, please point it out ：） ).

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:4047
http://jenkins.qa.ubuntu.com/job/unity-ci/1365/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-xenial-amd64-ci/17
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-xenial-armhf-ci/17
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-xenial-i386-ci/17

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-ci/1365/rebuild

review: Approve (continuous-integration)

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

Ok, I can say it looks good now...

Thanks a lot!

review: Approve

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

This branch doesn't build anymore now when merged to trunk:

/«BUILDDIR»/unity-7.4.0+16.04.20160114/lockscreen/KylinUserPromptView.cpp: In member function 'void unity::lockscreen::KylinUserPromptView::AddPrompt(const string&, bool, const PromiseAuthCodePtr&)':
/«BUILDDIR»/unity-7.4.0+16.04.20160114/lockscreen/KylinUserPromptView.cpp:299:15: error: 'class unity::TextInput' has no member named 'show_caps_lock'
   text_input->show_caps_lock = true;

Can you please fix this by replacing "show_caps_lock" with "show_lock_warnings" ?

Thanks

[handsome_feng (feng-kylin)]

> This branch doesn't build anymore now when merged to trunk:
>
> /«BUILDDIR»/unity-7.4.0+16.04.20160114/lockscreen/KylinUserPromptView.cpp: In
> member function 'void unity::lockscreen::KylinUserPromptView::AddPrompt(const
> string&, bool, const PromiseAuthCodePtr&)':
> /«BUILDDIR»/unity-7.4.0+16.04.20160114/lockscreen/KylinUserPromptView.cpp:299:
> 15: error: 'class unity::TextInput' has no member named 'show_caps_lock'
> text_input->show_caps_lock = true;
>
> Can you please fix this by replacing "show_caps_lock" with
> "show_lock_warnings" ?
>
> Thanks

Done.

=== modified file 'UnityCore/GnomeSessionManager.cpp'
--- UnityCore/GnomeSessionManager.cpp	2015-09-10 15:37:07 +0000
+++ UnityCore/GnomeSessionManager.cpp	2016-01-15 01:41:44 +0000
@@ -155,6 +155,13 @@
     });
   }
 
+  {
+    dm_seat_proxy_ = std::make_shared<glib::DBusProxy>("org.freedesktop.Accounts",
+                                                       ("/org/freedesktop/Accounts/User" + std::to_string(getuid())).c_str(),
+                                                       "org.freedesktop.Accounts.User",
+                                                       G_BUS_TYPE_SYSTEM);
+  }
+
   CallLogindMethod("CanHibernate", nullptr, [this] (GVariant* variant, glib::Error const& err) {
     if (err)
     {
@@ -429,6 +436,22 @@
   });
 }
 
+void GnomeManager::Impl::CallDisplayManagerSeatMethod(std::string const& method, GVariant* parameters)
+{
+  const char* xdg_seat_path = test_mode_ ? "/org/freedesktop/DisplayManager/Seat0" : g_getenv("XDG_SEAT_PATH");
+
+  auto proxy = std::make_shared<glib::DBusProxy>(test_mode_ ? testing::DBUS_NAME : "org.freedesktop.DisplayManager",
+                                                 glib::gchar_to_string(xdg_seat_path),
+                                                 "org.freedesktop.DisplayManager.Seat",
+                                                 test_mode_ ? G_BUS_TYPE_SESSION : G_BUS_TYPE_SYSTEM);
+  proxy->CallBegin(method, parameters, [this, proxy] (GVariant*, glib::Error const& e) {
+    if (e)
+    {
+      LOG_ERROR(logger) << "DisplayManager Seat call failed: " << e.Message();
+    }
+  });
+}
+
 void GnomeManager::Impl::LockScreen(bool prompt)
 {
   EnsureCancelPendingAction();
@@ -490,6 +513,13 @@
   return inhibitors.GetBool();
 }
 
+void GnomeManager::Impl::UserIconFile(std::function<void(std::string const&)> const& callback)
+{
+  dm_seat_proxy_->GetProperty("IconFile", [this, callback] (GVariant *value) {
+    callback(glib::Variant(value).GetString());
+  });
+}
+
 bool GnomeManager::Impl::IsUserInGroup(std::string const& user_name, std::string const& group_name)
 {
   auto group = getgrnam(group_name.c_str());
@@ -535,6 +565,11 @@
   return glib::gchar_to_string(g_get_host_name());
 }
 
+void GnomeManager::UserIconFile(std::function<void(std::string const&)> const& callback) const
+{
+  impl_->UserIconFile(callback);
+}
+
 void GnomeManager::ScreenSaverActivate()
 {
   screensaver_requested.emit(true);
@@ -665,6 +700,11 @@
   });
 }
 
+void GnomeManager::SwitchToGreeter()
+{
+  impl_->CallDisplayManagerSeatMethod("SwitchToGreeter");
+}
+
 bool GnomeManager::CanLock() const
 {
   if (is_locked())

=== modified file 'UnityCore/GnomeSessionManager.h'
--- UnityCore/GnomeSessionManager.h	2014-05-16 04:24:05 +0000
+++ UnityCore/GnomeSessionManager.h	2016-01-15 01:41:44 +0000
@@ -36,6 +36,7 @@
   std::string RealName() const;
   std::string UserName() const;
   std::string HostName() const;
+  void UserIconFile(std::function<void(std::string const&)> const&) const;
 
   void ScreenSaverActivate();
   void ScreenSaverDeactivate();
@@ -46,6 +47,7 @@
   void Shutdown();
   void Suspend();
   void Hibernate();
+  void SwitchToGreeter();
 
   bool CanLock() const;
   bool CanShutdown() const;

=== modified file 'UnityCore/GnomeSessionManagerImpl.h'
--- UnityCore/GnomeSessionManagerImpl.h	2015-01-24 00:56:37 +0000
+++ UnityCore/GnomeSessionManagerImpl.h	2016-01-15 01:41:44 +0000
@@ -54,6 +54,7 @@
   bool HasInhibitors();
   void EnsureCancelPendingAction();
   void LockScreen(bool prompt);
+  void UserIconFile(std::function<void(std::string const&)> const& callback);
 
   GVariant* OnShellMethodCall(std::string const& method, GVariant* parameters);
   void CallGnomeSessionMethod(std::string const& method, GVariant* parameters = nullptr,
@@ -61,6 +62,7 @@
   void CallUPowerMethod(std::string const& method, glib::DBusProxy::ReplyCallback const& cb = nullptr);
   void CallLogindMethod(std::string const& method, GVariant* parameters = nullptr, glib::DBusProxy::CallFinishedCallback const& cb = nullptr);
   void CallConsoleKitMethod(std::string const& method, GVariant* parameters = nullptr);
+  void CallDisplayManagerSeatMethod(std::string const& method, GVariant* parameters = nullptr);
   bool InteractiveMode();
   void UpdateHaveOtherOpenSessions();
 
@@ -78,6 +80,7 @@
   glib::DBusProxy::Ptr login_proxy_;
   glib::DBusProxy::Ptr presence_proxy_;
   glib::DBusProxy::Ptr dm_proxy_;
+  glib::DBusProxy::Ptr dm_seat_proxy_;
 
   int open_sessions_;
 };

=== modified file 'UnityCore/SessionManager.h'
--- UnityCore/SessionManager.h	2014-05-16 04:24:05 +0000
+++ UnityCore/SessionManager.h	2016-01-15 01:41:44 +0000
@@ -44,6 +44,7 @@
   virtual std::string RealName() const = 0;
   virtual std::string UserName() const = 0;
   virtual std::string HostName() const = 0;
+  virtual void UserIconFile(std::function<void(std::string const&)> const&) const = 0;
 
   virtual void ScreenSaverActivate() = 0;
   virtual void ScreenSaverDeactivate() = 0;
@@ -54,6 +55,7 @@
   virtual void Shutdown() = 0;
   virtual void Suspend() = 0;
   virtual void Hibernate() = 0;
+  virtual void SwitchToGreeter() = 0;
 
   virtual bool CanLock() const = 0;
   virtual bool CanShutdown() const = 0;

=== modified file 'com.canonical.Unity.gschema.xml'
--- com.canonical.Unity.gschema.xml	2015-09-17 16:44:26 +0000
+++ com.canonical.Unity.gschema.xml	2016-01-15 01:41:44 +0000
@@ -9,6 +9,10 @@
     <value nick="Not Expanded" value="0" />
     <value nick="Expanded" value="1" />
   </enum>
+  <enum id="desktop-type-enum">
+    <value nick="Ubuntu" value="0" />
+    <value nick="UbuntuKylin" value="1" />
+  </enum>
 
   <schema path="/com/canonical/unity/" id="com.canonical.Unity" gettext-domain="unity">
     <key enum="form-factor-enum" name="form-factor">
@@ -21,6 +25,11 @@
       <summary>Whether the home screen should be expanded.</summary>
       <description>Whether the home screen should be expanded.</description>
     </key>
+    <key enum="desktop-type-enum" name="desktop-type">
+      <default>"Ubuntu"</default>
+      <summary>The current desktop name.</summary>
+      <description>The current desktop name.</description>
+    </key>
     <key type="i" name="minimize-count">
       <default>0</default>
       <summary>Number of times a normal window has been minimized.</summary>

=== modified file 'lockscreen/CMakeLists.txt'
--- lockscreen/CMakeLists.txt	2015-07-31 12:16:54 +0000
+++ lockscreen/CMakeLists.txt	2016-01-15 01:41:44 +0000
@@ -19,11 +19,15 @@
 set (LOCKSCREEN_SOURCES
      BackgroundSettings.cpp
      CofView.cpp
+     KylinUserPromptView.cpp
+     KylinLockScreenShield.cpp
      LockScreenController.cpp
+     LockScreenBaseShield.cpp
      LockScreenSettings.cpp
      LockScreenShield.cpp
      LockScreenShieldFactory.cpp
      LockScreenPanel.cpp
+     LockScreenPromptFactory.cpp
      LockScreenAcceleratorController.cpp
      LockScreenAccelerators.cpp
      ScreenSaverDBusManager.cpp

=== added file 'lockscreen/KylinLockScreenShield.cpp'
--- lockscreen/KylinLockScreenShield.cpp	1970-01-01 00:00:00 +0000
+++ lockscreen/KylinLockScreenShield.cpp	2016-01-15 01:41:44 +0000
@@ -0,0 +1,99 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+* Copyright (C) 2015 Canonical Ltd
+*               2015, National University of Defense Technology(NUDT) & Kylin 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: Marco Trevisan <[e-mail]>
+*              handsome_feng <[e-mail]>
+*/
+
+#include "KylinLockScreenShield.h"
+
+#include <Nux/VLayout.h>
+#include <Nux/HLayout.h>
+
+#include "CofView.h"
+#include "LockScreenSettings.h"
+#include "LockScreenAbstractPromptView.h"
+
+namespace unity
+{
+namespace lockscreen
+{
+
+KylinShield::KylinShield(session::Manager::Ptr const& session_manager,
+               Accelerators::Ptr const& accelerators,
+               nux::ObjectPtr<AbstractUserPromptView> const& prompt_view,
+               int monitor_num, bool is_primary)
+  : BaseShield(session_manager, nullptr, accelerators, prompt_view, monitor_num, is_primary)
+{
+  is_primary ? ShowPrimaryView() : ShowSecondaryView();
+  EnableInputWindow(true);
+}
+
+void KylinShield::ShowPrimaryView()
+{
+  if (primary_layout_)
+  {
+    if (prompt_view_)
+    {
+      prompt_view_->scale = scale();
+      prompt_layout_->AddView(prompt_view_.GetPointer());
+    }
+
+    GrabScreen(false);
+    SetLayout(primary_layout_.GetPointer());
+    return;
+  }
+
+  GrabScreen(true);
+  nux::Layout* main_layout = new nux::VLayout();
+  primary_layout_ = main_layout;
+  SetLayout(primary_layout_.GetPointer());
+
+  prompt_layout_ = new nux::HLayout();
+
+  if (prompt_view_)
+  {
+    prompt_view_->scale = scale();
+    prompt_layout_->AddView(prompt_view_.GetPointer());
+  }
+
+  // 10 is just a random number to center the prompt view.
+  main_layout->AddSpace(0, 10);
+  main_layout->AddLayout(prompt_layout_.GetPointer(), 0, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FIX);
+  main_layout->AddSpace(0, 10);
+}
+
+nux::Area* KylinShield::FindKeyFocusArea(unsigned etype, unsigned long keysym, unsigned long modifiers)
+{
+  if (primary)
+  {
+    grab_key.emit(modifiers, keysym);
+
+    if (prompt_view_)
+    {
+      auto* focus_view = prompt_view_->focus_view();
+
+      if (focus_view && focus_view->GetInputEventSensitivity())
+        return focus_view;
+    }
+  }
+
+  return nullptr;
+}
+
+}
+}

=== added file 'lockscreen/KylinLockScreenShield.h'
--- lockscreen/KylinLockScreenShield.h	1970-01-01 00:00:00 +0000
+++ lockscreen/KylinLockScreenShield.h	2016-01-15 01:41:44 +0000
@@ -0,0 +1,54 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+* Copyright (C) 2015 Canonical Ltd
+*               2015, National University of Defense Technology(NUDT) & Kylin 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: Marco Trevisan <[e-mail]>
+*              handsome_feng <[e-mail]>
+*/
+
+#ifndef UNITY_KYLIN_LOCKSCREEN_SHIELD_H
+#define UNITY_KYLIN_LOCKSCREEN_SHIELD_H
+
+#include <UnityCore/ConnectionManager.h>
+#include <UnityCore/GLibSource.h>
+#include "LockScreenBaseShield.h"
+
+namespace unity
+{
+namespace lockscreen
+{
+
+class AbstractUserPromptView;
+
+class KylinShield : public BaseShield
+{
+public:
+  KylinShield(session::Manager::Ptr const&,
+         Accelerators::Ptr const&,
+         nux::ObjectPtr<AbstractUserPromptView> const&,
+         int monitor, bool is_primary);
+
+protected:
+  nux::Area* FindKeyFocusArea(unsigned int, unsigned long, unsigned long) override;
+
+private:
+  void ShowPrimaryView() override;
+};
+
+}
+}
+
+#endif

=== added file 'lockscreen/KylinUserPromptView.cpp'
--- lockscreen/KylinUserPromptView.cpp	1970-01-01 00:00:00 +0000
+++ lockscreen/KylinUserPromptView.cpp	2016-01-15 01:41:44 +0000
@@ -0,0 +1,402 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+* Copyright (C) 2015 Canonical Ltd
+*               2015, National University of Defense Technology(NUDT) & Kylin 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]>
+*              handsome_feng <[e-mail]>
+*/
+
+#include "KylinUserPromptView.h"
+
+#include "config.h"
+#include <gtk/gtk.h>
+#include <glib/gi18n-lib.h>
+
+#include <boost/algorithm/string/trim.hpp>
+#include <Nux/VLayout.h>
+#include <Nux/HLayout.h>
+#include <NuxCore/Logger.h>
+#include "Variant.h"
+
+#include "LockScreenSettings.h"
+#include "unity-shared/CairoTexture.h"
+#include "unity-shared/TextInput.h"
+#include "unity-shared/StaticCairoText.h"
+#include "unity-shared/RawPixel.h"
+#include "unity-shared/IconTexture.h"
+#include "unity-shared/TextureCache.h"
+
+namespace unity
+{
+namespace lockscreen
+{
+namespace
+{
+const RawPixel AVATAR_SIZE          = 128_em;
+const RawPixel ACTIVATOR_ICON_SIZE  = 34_em;
+const RawPixel LAYOUT_MARGIN        = 20_em;
+const RawPixel MSG_LAYOUT_MARGIN    = 15_em;
+const RawPixel MSG_LAYOUT_PADDING   = 33_em;
+const RawPixel PROMPT_LAYOUT_MARGIN =  5_em;
+const RawPixel SWITCH_ICON_SIZE     = 34_em;
+const RawPixel TEXT_INPUT_HEIGHT    =  36_em;
+const RawPixel TEXT_INPUT_WIDTH     = 320_em;
+const int PROMPT_FONT_SIZE = 14;
+
+const std::string ACTIVATOR_ICON = "login.svg";
+
+std::string SanitizeMessage(std::string const& message)
+{
+  std::string msg = boost::algorithm::trim_copy(message);
+
+  if (msg.empty())
+    return msg;
+
+  if (msg[msg.size()-1] == ':')
+    msg = msg.substr(0, msg.size()-1);
+
+  if (msg == "Password")
+    return _("Password");
+
+  if (msg == "login")
+    return _("Username");
+
+  return msg;
+}
+
+}
+
+KylinUserPromptView::KylinUserPromptView(session::Manager::Ptr const& session_manager)
+  : AbstractUserPromptView(session_manager)
+  , scale(1.0)
+  , session_manager_(session_manager)
+  , username_(nullptr)
+  , msg_layout_(nullptr)
+  , prompt_layout_(nullptr)
+  , avatar_layout_(nullptr)
+  , switch_icon_(nullptr)
+  , avatar_(nullptr)
+  , avatar_icon_file("")
+{
+    user_authenticator_.echo_on_requested.connect([this](std::string const& message, PromiseAuthCodePtr const& promise){
+        AddPrompt(message, true, promise);
+    });
+
+    user_authenticator_.echo_off_requested.connect([this](std::string const& message, PromiseAuthCodePtr const& promise){
+        AddPrompt(message, false, promise);
+    });
+
+    user_authenticator_.message_requested.connect([this](std::string const& message){
+        AddMessage(message, nux::color::White);
+    });
+
+    user_authenticator_.error_requested.connect([this](std::string const& message){
+        AddMessage(message, nux::color::Red);
+    });
+
+    user_authenticator_.clear_prompts.connect([this](){
+        ResetLayout();
+    });
+
+    scale.changed.connect(sigc::hide(sigc::mem_fun(this, &KylinUserPromptView::UpdateSize)));
+
+    session_manager_->UserIconFile([this] (std::string const& value) {
+        avatar_icon_file = value;
+        AddAvatar(value, AVATAR_SIZE.CP(scale));
+    });
+
+    UpdateSize();
+    ResetLayout();
+
+    user_authenticator_.AuthenticateStart(session_manager_->UserName(),
+                                          sigc::mem_fun(this, &KylinUserPromptView::AuthenticationCb));
+}
+
+void KylinUserPromptView::ResetLayout()
+{
+  focus_queue_.clear();
+
+  SetLayout(new nux::HLayout());
+
+  static_cast<nux::HLayout*>(GetLayout())->SetHorizontalInternalMargin(LAYOUT_MARGIN.CP(scale));
+
+  if (g_getenv("XDG_SEAT_PATH"))
+  {
+    nux::Layout* switch_layout = new nux::HLayout();
+
+    TextureCache& cache = TextureCache::GetDefault();
+    switch_icon_ = new IconTexture(cache.FindTexture("switch_user.svg", SWITCH_ICON_SIZE.CP(scale), SWITCH_ICON_SIZE.CP(scale)));
+    switch_layout->AddView(switch_icon_);
+    switch_icon_->mouse_click.connect([this](int x, int y, unsigned long button_flags, unsigned long key_flags) {
+      session_manager_->SwitchToGreeter();
+    });
+    switch_layout->SetMaximumSize(SWITCH_ICON_SIZE.CP(scale), SWITCH_ICON_SIZE.CP(scale));
+    GetLayout()->AddLayout(switch_layout);
+  }
+
+  avatar_layout_ = new nux::VLayout();
+  if (!avatar_icon_file().empty())
+    AddAvatar(avatar_icon_file(), AVATAR_SIZE.CP(scale));
+  GetLayout()->AddLayout(avatar_layout_);
+
+  nux::Layout* prompt_layout = new nux::VLayout();
+
+  auto const& real_name = session_manager_->RealName();
+  auto const& name = (real_name.empty() ? session_manager_->UserName() : real_name);
+
+  username_ = new unity::StaticCairoText(name);
+  username_->SetScale(scale);
+  username_->SetFont("Ubuntu "+std::to_string(PROMPT_FONT_SIZE));
+  prompt_layout->AddView(username_);
+
+  msg_layout_ = new nux::VLayout();
+  msg_layout_->SetVerticalInternalMargin(MSG_LAYOUT_MARGIN.CP(scale));
+  msg_layout_->SetTopAndBottomPadding(MSG_LAYOUT_PADDING.CP(scale), 0);
+  prompt_layout->AddLayout(msg_layout_);
+
+  prompt_layout_ = new nux::VLayout();
+  prompt_layout_->SetVerticalInternalMargin(PROMPT_LAYOUT_MARGIN.CP(scale));
+  prompt_layout->AddLayout(prompt_layout_);
+
+  GetLayout()->AddLayout(prompt_layout);
+  QueueRelayout();
+  QueueDraw();
+}
+
+void KylinUserPromptView::UpdateSize()
+{
+  auto width = 13 * Settings::GRID_SIZE.CP(scale);
+  auto height = 3 * Settings::GRID_SIZE.CP(scale);
+
+  SetMinimumWidth(width);
+  SetMaximumWidth(width);
+  SetMinimumHeight(height);
+
+  if (username_)
+    username_->SetScale(scale);
+
+  if (msg_layout_)
+  {
+    msg_layout_->SetVerticalInternalMargin(MSG_LAYOUT_MARGIN.CP(scale));
+
+    for (auto* area : msg_layout_->GetChildren())
+    {
+      area->SetMaximumWidth(TEXT_INPUT_WIDTH);
+      static_cast<StaticCairoText*>(area)->SetScale(scale);
+    }
+  }
+
+  if (prompt_layout_)
+  {
+    prompt_layout_->SetVerticalInternalMargin(PROMPT_LAYOUT_MARGIN.CP(scale));
+
+    for (auto* area : prompt_layout_->GetChildren())
+    {
+      auto* text_input = static_cast<TextInput*>(area);
+      text_input->SetMinimumHeight(TEXT_INPUT_HEIGHT.CP(scale));
+      text_input->SetMaximumHeight(TEXT_INPUT_HEIGHT.CP(scale));
+      text_input->SetMinimumWidth(TEXT_INPUT_WIDTH.CP(scale));
+      text_input->SetMaximumWidth(TEXT_INPUT_WIDTH.CP(scale));
+      text_input->scale = scale();
+    }
+  }
+
+  ComputeContentSize();
+  QueueRelayout();
+  QueueDraw();
+}
+
+bool KylinUserPromptView::InspectKeyEvent(unsigned int eventType, unsigned int key_sym, const char* character)
+{
+  if ((eventType == nux::NUX_KEYDOWN) && (key_sym == NUX_VK_ESCAPE))
+  {
+    if (!focus_queue_.empty())
+      focus_queue_.front()->text_entry()->SetText("");
+
+    return true;
+  }
+
+  return false;
+}
+
+void KylinUserPromptView::AuthenticationCb(bool authenticated)
+{
+  ResetLayout();
+
+  if (authenticated)
+  {
+    session_manager_->unlock_requested.emit();
+  }
+  else
+  {
+    AddMessage(_("Invalid password, please try again"), nux::color::Red);
+
+    user_authenticator_.AuthenticateStart(session_manager_->UserName(),
+                                          sigc::mem_fun(this, &KylinUserPromptView::AuthenticationCb));
+  }
+}
+
+void KylinUserPromptView::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
+{
+  nux::Geometry const& geo = GetGeometry();
+
+  graphics_engine.PushClippingRectangle(geo);
+  nux::GetPainter().PaintBackground(graphics_engine, geo);
+
+  graphics_engine.PopClippingRectangle();
+}
+
+void KylinUserPromptView::DrawContent(nux::GraphicsEngine& graphics_engine, bool force_draw)
+{
+  nux::Geometry const& geo = GetGeometry();
+  graphics_engine.PushClippingRectangle(geo);
+
+  if (GetLayout())
+    GetLayout()->ProcessDraw(graphics_engine, force_draw);
+
+  graphics_engine.PopClippingRectangle();
+}
+
+nux::View* KylinUserPromptView::focus_view()
+{
+  if (focus_queue_.empty())
+    return nullptr;
+
+  for (auto* view : focus_queue_)
+    if (view->text_entry()->HasKeyboardFocus())
+      return view;
+
+  return focus_queue_.front()->text_entry();
+}
+
+void KylinUserPromptView::AddPrompt(std::string const& message, bool visible, PromiseAuthCodePtr const& promise)
+{
+  auto* text_input = new unity::TextInput();
+  auto* text_entry = text_input->text_entry();
+
+  text_input->scale = scale();
+  text_input->activator_icon = ACTIVATOR_ICON;
+  text_input->activator_icon_size = ACTIVATOR_ICON_SIZE;
+  text_input->background_color = nux::Color(1.0f, 1.0f, 1.0f, 0.8f);
+  text_input->border_color = nux::Color(0.0f, 0.0f, 0.0f, 0.0f);
+  text_input->border_radius = 0;
+  text_input->hint_color = nux::Color(0.0f, 0.0f, 0.0f, 0.5f);
+  text_input->input_hint = SanitizeMessage(message);
+  text_input->hint_font_size = PROMPT_FONT_SIZE;
+  text_input->show_lock_warnings = true;
+  text_input->show_activator = true;
+  text_entry->SetPasswordMode(!visible);
+  text_entry->SetPasswordChar("•");
+  text_entry->SetToggleCursorVisibilityOnKeyFocus(true);
+  text_entry->clipboard_enabled = false;
+  text_entry->SetTextColor(nux::color::Black);
+
+  text_input->SetMinimumHeight(TEXT_INPUT_HEIGHT.CP(scale));
+  text_input->SetMaximumHeight(TEXT_INPUT_HEIGHT.CP(scale));
+  text_input->SetMinimumWidth(TEXT_INPUT_WIDTH.CP(scale));
+  text_input->SetMaximumWidth(TEXT_INPUT_WIDTH.CP(scale));
+  prompt_layout_->AddView(text_input, 1);
+  focus_queue_.push_back(text_input);
+
+  // Don't remove it, it helps with a11y.
+  if (focus_queue_.size() == 1)
+    nux::GetWindowCompositor().SetKeyFocusArea(text_entry);
+
+  text_entry->activated.connect([this, text_input, promise](){
+    auto* text_entry = text_input->text_entry();
+
+    if (!text_entry->GetInputEventSensitivity())
+      return;
+
+    if (focus_queue_.size() == 1)
+    {
+      text_input->SetSpinnerVisible(true);
+      text_input->SetSpinnerState(STATE_SEARCHING);
+    }
+
+    focus_queue_.pop_front();
+    cached_focused_geo_ = text_entry->GetGeometry();
+    text_entry->SetInputEventSensitivity(false);
+    QueueRelayout();
+    QueueDraw();
+
+    std::string const& password = text_entry->GetText();
+    if (promise)
+      promise->set_value(password);
+  });
+
+  GetLayout()->ComputeContentPosition(0, 0);
+  ComputeContentSize();
+  QueueRelayout();
+  QueueDraw();
+}
+
+void KylinUserPromptView::AddMessage(std::string const& message, nux::Color const& color)
+{
+  auto* view = new unity::StaticCairoText("");
+  view->SetScale(scale);
+  view->SetFont(Settings::Instance().font_name());
+  view->SetTextColor(color);
+  view->SetText(message);
+  view->SetMaximumWidth(TEXT_INPUT_WIDTH.CP(scale));
+  msg_layout_->AddView(view);
+
+  GetLayout()->ComputeContentPosition(0, 0);
+  ComputeContentSize();
+  QueueRelayout();
+  QueueDraw();
+}
+
+void KylinUserPromptView::AddAvatar(std::string const& icon_file, int icon_size)
+{
+  avatar_ = new IconTexture(LoadUserIcon(icon_file, icon_size));
+  avatar_->SetMinimumWidth(icon_size);
+  avatar_->SetMaximumWidth(icon_size);
+  avatar_layout_->AddView(avatar_);
+
+  GetLayout()->ComputeContentPosition(0, 0);
+  ComputeContentSize();
+  QueueRelayout();
+  QueueDraw();
+}
+
+nux::ObjectPtr<nux::BaseTexture> KylinUserPromptView::LoadUserIcon(std::string const& icon_file, int icon_size)
+{
+  glib::Error error;
+  glib::Object<GdkPixbuf> pixbuf(gdk_pixbuf_new_from_file_at_size(icon_file.c_str(), icon_size, icon_size, &error));
+  if (!pixbuf)
+  {
+    auto* theme = gtk_icon_theme_get_default();
+    GtkIconLookupFlags flags = GTK_ICON_LOOKUP_FORCE_SIZE;
+    pixbuf = gtk_icon_theme_load_icon(theme, "avatar-default-kylin", icon_size, flags, &error);
+    if (!pixbuf)
+      pixbuf = gtk_icon_theme_load_icon(theme, "avatar-default", icon_size, flags, &error);
+  }
+  nux::CairoGraphics cg(CAIRO_FORMAT_ARGB32, gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf));
+  cairo_t* cr = cg.GetInternalContext();
+
+  gdk_cairo_set_source_pixbuf(cr, pixbuf, 0, 0);
+  cairo_paint_with_alpha(cr, 1.0);
+  cairo_set_source_rgba(cr, 1.0f, 1.0f, 1.0f, 1.0f);
+  cairo_rectangle(cr, 0, 0, gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf));
+  cairo_set_line_width(cr, 3);
+  cairo_stroke(cr);
+
+  return texture_ptr_from_cairo_graphics(cg);
+}
+
+}
+}

=== added file 'lockscreen/KylinUserPromptView.h'
--- lockscreen/KylinUserPromptView.h	1970-01-01 00:00:00 +0000
+++ lockscreen/KylinUserPromptView.h	2016-01-15 01:41:44 +0000
@@ -0,0 +1,84 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+* Copyright (C) 2015 Canonical Ltd
+*               2015, National University of Defense Technology(NUDT) & Kylin 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]>
+*              handsome_feng <[e-mail]>
+*/
+
+#ifndef UNITY_KYLIN_USER_PROMPT_BOX
+#define UNITY_KYLIN_USER_PROMPT_BOX
+
+#include "LockScreenAbstractPromptView.h"
+
+namespace nux
+{
+class VLayout;
+class HLayout;
+}
+
+namespace unity
+{
+
+class StaticCairoText;
+class TextInput;
+class IconTexture;
+class RawPixel;
+
+namespace lockscreen
+{
+
+class KylinUserPromptView : public AbstractUserPromptView
+{
+public:
+  KylinUserPromptView(session::Manager::Ptr const& session_manager);
+
+  nux::Property<double> scale;
+
+  nux::View* focus_view();
+
+  void AddAvatar(std::string const& avatar_icon, int avatar_size);
+  void AddPrompt(std::string const& message, bool visible, PromiseAuthCodePtr const&);
+  void AddMessage(std::string const& message, nux::Color const& color);
+  void AuthenticationCb(bool authenticated);
+
+protected:
+  void Draw(nux::GraphicsEngine& graphics_engine, bool force_draw);
+  void DrawContent(nux::GraphicsEngine& graphics_engine, bool force_draw);
+  void ResetLayout();
+  void UpdateSize();
+  bool InspectKeyEvent(unsigned int eventType, unsigned int key_sym, const char* character);
+  nux::ObjectPtr<nux::BaseTexture> LoadUserIcon(std::string const& icon_file, int icon_size);
+
+private:
+  session::Manager::Ptr session_manager_;
+  UserAuthenticatorPam user_authenticator_;
+  StaticCairoText* username_;
+  nux::VLayout* msg_layout_;
+  nux::VLayout* prompt_layout_;
+  nux::VLayout* avatar_layout_;
+  std::deque<TextInput*> focus_queue_;
+  IconTexture* switch_icon_;
+  IconTexture* avatar_;
+  nux::Property<std::string> avatar_icon_file;
+
+  nux::Geometry cached_focused_geo_;
+};
+
+}
+}
+
+#endif

=== added file 'lockscreen/LockScreenAbstractPromptView.h'
--- lockscreen/LockScreenAbstractPromptView.h	1970-01-01 00:00:00 +0000
+++ lockscreen/LockScreenAbstractPromptView.h	2016-01-15 01:41:44 +0000
@@ -0,0 +1,79 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *               2015, National University of Defense Technology(NUDT) & Kylin 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: handsome_feng <[e-mail]>
+ */
+
+#ifndef UNITY_LOCKSCREEN_ABSTRACT_USER_PROMPT_H
+#define UNITY_LOCKSCREEN_ABSTRACT_USER_PROMPT_H
+
+#include <memory>
+#include <deque>
+
+#include <Nux/Nux.h>
+#include <Nux/View.h>
+#include <Nux/VLayout.h>
+#include <UnityCore/SessionManager.h>
+
+#include "UserAuthenticatorPam.h"
+#include "unity-shared/IMTextEntry.h"
+
+namespace nux
+{
+class VLayout;
+}
+namespace unity
+{
+
+class StaticCairoText;
+class TextInput;
+
+namespace lockscreen
+{
+
+class AbstractUserPromptView : public nux::View
+{
+public:
+  AbstractUserPromptView(session::Manager::Ptr const& session_manager)
+    : nux::View(NUX_TRACKER_LOCATION)
+    , session_manager_(session_manager)
+  {}
+
+  nux::Property<double> scale;
+
+  virtual nux::View* focus_view() = 0;
+
+  virtual void AuthenticationCb(bool authenticated) = 0;
+  virtual void ResetLayout() = 0;
+  virtual void UpdateSize() = 0;
+
+protected:
+  session::Manager::Ptr session_manager_;
+  UserAuthenticatorPam user_authenticator_;
+  std::shared_ptr<nux::AbstractPaintLayer> bg_layer_;
+  StaticCairoText* username_;
+  nux::VLayout* msg_layout_;
+  nux::VLayout* prompt_layout_;
+  std::deque<TextInput*> focus_queue_;
+
+  nux::Geometry cached_focused_geo_;
+};
+
+} // lockscreen
+} // unity
+
+#endif // UNITY_LOCKSCREEN_ABSTRACT_USER_PROMPT_H

=== added file 'lockscreen/LockScreenBaseShield.cpp'
--- lockscreen/LockScreenBaseShield.cpp	1970-01-01 00:00:00 +0000
+++ lockscreen/LockScreenBaseShield.cpp	2016-01-15 01:41:44 +0000
@@ -0,0 +1,173 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2015 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: Marco Trevisan <[e-mail]>
+ */
+
+#include "LockScreenBaseShield.h"
+
+#include "BackgroundSettings.h"
+#include "CofView.h"
+#include "LockScreenAbstractPromptView.h"
+#include "LockScreenSettings.h"
+#include "unity-shared/MockableBaseWindow.h"
+#include "unity-shared/UnitySettings.h"
+#include "unity-shared/UScreen.h"
+#include "unity-shared/WindowManager.h"
+
+namespace unity
+{
+namespace lockscreen
+{
+namespace
+{
+const unsigned MAX_GRAB_WAIT = 100;
+}
+
+BaseShield::BaseShield(session::Manager::Ptr const& session,
+                       indicator::Indicators::Ptr const& indicators,
+                       Accelerators::Ptr const& accelerators,
+                       nux::ObjectPtr<AbstractUserPromptView> const& prompt_view,
+                       int monitor_num, bool is_primary)
+  : MockableBaseWindow("Unity Lockscreen")
+  , primary(is_primary)
+  , monitor(monitor_num)
+  , scale(1.0)
+  , session_manager_(session)
+  , indicators_(indicators)
+  , accelerators_(accelerators)
+  , prompt_view_(prompt_view)
+  , bg_settings_(std::make_shared<BackgroundSettings>())
+  , cof_view_(nullptr)
+{
+  UpdateScale();
+
+  unity::Settings::Instance().dpi_changed.connect(sigc::mem_fun(this, &BaseShield::UpdateScale));
+  geometry_changed.connect([this] (nux::Area*, nux::Geometry&) { UpdateBackgroundTexture();});
+
+  monitor.changed.connect([this] (int monitor) {
+    UpdateScale();
+    UpdateBackgroundTexture();
+  });
+
+  primary.changed.connect([this] (bool is_primary) {
+    regrab_conn_->disconnect();
+    is_primary ? ShowPrimaryView() : ShowSecondaryView();
+    QueueRelayout();
+    QueueDraw();
+  });
+
+  scale.changed.connect([this] (double scale) {
+    if (prompt_view_ && primary())
+      prompt_view_->scale = scale;
+
+    if (cof_view_)
+      cof_view_->scale = scale;
+
+    if (prompt_layout_)
+      prompt_layout_->SetLeftAndRightPadding(2 * Settings::GRID_SIZE.CP(scale));
+
+    background_layer_.reset();
+    UpdateBackgroundTexture();
+  });
+
+  mouse_move.connect([this] (int x, int y, int, int, unsigned long, unsigned long) {
+    auto const& abs_geo = GetAbsoluteGeometry();
+    grab_motion.emit(abs_geo.x + x, abs_geo.y + y);
+  });
+}
+
+bool BaseShield::HasGrab() const
+{
+  auto& wc = nux::GetWindowCompositor();
+  return (wc.GetPointerGrabArea() == this && wc.GetKeyboardGrabArea() == this);
+}
+
+nux::Area* BaseShield::FindAreaUnderMouse(nux::Point const& mouse, nux::NuxEventType event_type)
+{
+  nux::Area* area = BaseWindow::FindAreaUnderMouse(mouse, event_type);
+
+  if (!area && primary)
+    return this;
+
+  return area;
+}
+
+void BaseShield::GrabScreen(bool cancel_on_failure)
+{
+  auto& wc = nux::GetWindowCompositor();
+
+  if (wc.GrabPointerAdd(this) && wc.GrabKeyboardAdd(this))
+  {
+    regrab_conn_->disconnect();
+    regrab_timeout_.reset();
+    grabbed.emit();
+  }
+  else
+  {
+    auto const& retry_cb = sigc::bind(sigc::mem_fun(this, &BaseShield::GrabScreen), false);
+    regrab_conn_ = WindowManager::Default().screen_ungrabbed.connect(retry_cb);
+
+    if (cancel_on_failure)
+    {
+      regrab_timeout_.reset(new glib::Timeout(MAX_GRAB_WAIT, [this] {
+        grab_failed.emit();
+        return false;
+      }));
+    }
+  }
+}
+
+void BaseShield::UpdateBackgroundTexture()
+{
+  auto const& monitor_geo = UScreen::GetDefault()->GetMonitorGeometry(monitor);
+
+  if (!background_layer_ || monitor_geo != background_layer_->GetGeometry())
+  {
+    auto background_texture = bg_settings_->GetBackgroundTexture(monitor);
+    background_layer_.reset(new nux::TextureLayer(background_texture->GetDeviceTexture(), nux::TexCoordXForm(), nux::color::White, true));
+    SetBackgroundLayer(background_layer_.get());
+  }
+}
+
+void BaseShield::UpdateScale()
+{
+  scale = unity::Settings::Instance().em(monitor)->DPIScale();
+}
+
+void BaseShield::ShowSecondaryView()
+{
+  if (prompt_layout_)
+    prompt_layout_->RemoveChildObject(prompt_view_.GetPointer());
+
+  if (cof_layout_)
+  {
+    SetLayout(cof_layout_.GetPointer());
+    return;
+  }
+
+  nux::Layout* main_layout = new nux::VLayout();
+  cof_layout_ = main_layout;
+  SetLayout(cof_layout_.GetPointer());
+
+  // The circle of friends
+  cof_view_ = new CofView();
+  cof_view_->scale = scale();
+  main_layout->AddView(cof_view_);
+}
+
+} // lockscreen
+} // unity

=== renamed file 'lockscreen/LockScreenAbstractShield.h' => 'lockscreen/LockScreenBaseShield.h'
--- lockscreen/LockScreenAbstractShield.h	2014-09-19 18:02:37 +0000
+++ lockscreen/LockScreenBaseShield.h	2016-01-15 01:41:44 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2014 Canonical Ltd
+ * Copyright (C) 2014-2015 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
@@ -17,49 +17,40 @@
  * Authored by: Marco Trevisan <[e-mail]>
  */
 
-#ifndef UNITY_LOCKSCREEN_ABSTRACT_SHIELD_H
-#define UNITY_LOCKSCREEN_ABSTRACT_SHIELD_H
+#ifndef UNITY_LOCKSCREEN_BASE_SHIELD_H
+#define UNITY_LOCKSCREEN_BASE_SHIELD_H
 
 #include <NuxCore/Property.h>
 #include <UnityCore/SessionManager.h>
 #include <UnityCore/Indicators.h>
-
+#include <UnityCore/GLibSource.h>
 #include "unity-shared/MockableBaseWindow.h"
+
 #include "LockScreenAccelerators.h"
 
 namespace unity
 {
 namespace lockscreen
 {
-
-class UserPromptView;
-
-class AbstractShield : public MockableBaseWindow
+class BackgroundSettings;
+class AbstractUserPromptView;
+class CofView;
+
+class BaseShield : public MockableBaseWindow
 {
 public:
-  AbstractShield(session::Manager::Ptr const& session,
-                 indicator::Indicators::Ptr const& indicators,
-                 Accelerators::Ptr const& accelerators,
-                 nux::ObjectPtr<UserPromptView> const& prompt_view,
-                 int monitor_num, bool is_primary)
-    : MockableBaseWindow("Unity Lockscreen")
-    , primary(is_primary)
-    , monitor(monitor_num)
-    , scale(1.0)
-    , session_manager_(session)
-    , indicators_(indicators)
-    , accelerators_(accelerators)
-    , prompt_view_(prompt_view)
-  {}
+  BaseShield(session::Manager::Ptr const&, indicator::Indicators::Ptr const&,
+             Accelerators::Ptr const&, nux::ObjectPtr<AbstractUserPromptView> const&,
+             int monitor_num, bool is_primary);
 
   nux::Property<bool> primary;
   nux::Property<int> monitor;
   nux::Property<double> scale;
 
+  bool HasGrab() const;
+  virtual bool IsIndicatorOpen() const { return false; }
+  virtual void ActivatePanel() {}
   using MockableBaseWindow::RemoveLayout;
-  virtual bool HasGrab() const = 0;
-  virtual bool IsIndicatorOpen() const = 0;
-  virtual void ActivatePanel() = 0;
 
   sigc::signal<void> grabbed;
   sigc::signal<void> grab_failed;
@@ -67,13 +58,31 @@
   sigc::signal<void, unsigned long, unsigned long> grab_key;
 
 protected:
+  virtual bool AcceptKeyNavFocus() { return false; }
+  virtual void ShowPrimaryView() = 0;
+  virtual void ShowSecondaryView();
+
+  nux::Area* FindAreaUnderMouse(nux::Point const& mouse, nux::NuxEventType event_type) override;
+
+  void GrabScreen(bool cancel_on_failure);
+  void UpdateBackgroundTexture();
+  void UpdateScale();
+
   session::Manager::Ptr session_manager_;
   indicator::Indicators::Ptr indicators_;
   Accelerators::Ptr accelerators_;
-  nux::ObjectPtr<UserPromptView> prompt_view_;
+  nux::ObjectPtr<AbstractUserPromptView> prompt_view_;
+  std::shared_ptr<BackgroundSettings> bg_settings_;
+  std::unique_ptr<nux::AbstractPaintLayer> background_layer_;
+  nux::ObjectPtr<nux::Layout> primary_layout_;
+  nux::ObjectPtr<nux::Layout> prompt_layout_;
+  nux::ObjectPtr<nux::Layout> cof_layout_;
+  CofView* cof_view_;
+  connection::Wrapper regrab_conn_;
+  glib::Source::UniquePtr regrab_timeout_;
 };
 
 } // lockscreen
 } // unity
 
-#endif // UNITY_LOCKSCREEN_ABSTRACT_SHIELD_H
+#endif // UNITY_LOCKSCREEN_BASE_SHIELD_H

=== modified file 'lockscreen/LockScreenController.cpp'
--- lockscreen/LockScreenController.cpp	2015-03-24 19:25:26 +0000
+++ lockscreen/LockScreenController.cpp	2016-01-15 01:41:44 +0000
@@ -23,6 +23,8 @@
 #include <UnityCore/GLibDBusProxy.h>
 #include <NuxCore/Logger.h>
 
+#include "LockScreenAbstractPromptView.h"
+#include "LockScreenPromptFactory.h"
 #include "LockScreenShield.h"
 #include "LockScreenSettings.h"
 #include "unity-shared/AnimationUtils.h"
@@ -218,13 +220,13 @@
   int primary = UScreen::GetDefault()->GetMonitorWithMouse();
 
   // Keep a reference of the old prompt_view
-  nux::ObjectPtr<UserPromptView> prompt_view(prompt_view_.GetPointer());
+  nux::ObjectPtr<AbstractUserPromptView> prompt_view(prompt_view_.GetPointer());
 
   shields_.resize(num_monitors);
 
   if (!prompt_view)
   {
-    prompt_view = test_mode_ ? nullptr : new UserPromptView(session_manager_);
+    prompt_view = test_mode_ ? nux::ObjectPtr<AbstractUserPromptView>() : PromptFactory::CreatePrompt(session_manager_);
     prompt_view_ = prompt_view.GetPointer();
   }
 

=== modified file 'lockscreen/LockScreenController.h'
--- lockscreen/LockScreenController.h	2014-10-21 15:31:27 +0000
+++ lockscreen/LockScreenController.h	2016-01-15 01:41:44 +0000
@@ -24,12 +24,12 @@
 #include <UnityCore/ConnectionManager.h>
 #include <UnityCore/GLibSource.h>
 
+#include "LockScreenBaseShield.h"
 #include "LockScreenShieldFactory.h"
 #include "LockScreenAcceleratorController.h"
 #include "ScreenSaverDBusManager.h"
 #include "ShutdownNotifier.h"
 #include "SuspendNotifier.h"
-#include "UserPromptView.h"
 #include "unity-shared/BackgroundEffectHelper.h"
 #include "unity-shared/UpstartWrapper.h"
 
@@ -38,7 +38,7 @@
 namespace lockscreen
 {
 
-class UserPromptView;
+class AbstractUserPromptView;
 
 class Controller : public sigc::trackable
 {
@@ -77,9 +77,9 @@
   void OnScreenSaverActivationRequest(bool activate);
   void OnPrimaryShieldMotion(int x, int y);
 
-  std::vector<nux::ObjectPtr<AbstractShield>> shields_;
-  nux::ObjectWeakPtr<AbstractShield> primary_shield_;
-  nux::ObjectWeakPtr<UserPromptView> prompt_view_;
+  std::vector<nux::ObjectPtr<BaseShield>> shields_;
+  nux::ObjectWeakPtr<BaseShield> primary_shield_;
+  nux::ObjectWeakPtr<AbstractUserPromptView> prompt_view_;
   nux::ObjectPtr<nux::BaseWindow> blank_window_;
 
   DBusManager::Ptr dbus_manager_;

=== added file 'lockscreen/LockScreenPromptFactory.cpp'
--- lockscreen/LockScreenPromptFactory.cpp	1970-01-01 00:00:00 +0000
+++ lockscreen/LockScreenPromptFactory.cpp	2016-01-15 01:41:44 +0000
@@ -0,0 +1,42 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+* Copyright (C) 2015 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: Marco Trevisan <[e-mail]>
+*/
+
+#include "LockScreenPromptFactory.h"
+#include "KylinUserPromptView.h"
+#include "UserPromptView.h"
+#include "unity-shared/UnitySettings.h"
+
+namespace unity
+{
+namespace lockscreen
+{
+nux::ObjectPtr<AbstractUserPromptView> PromptFactory::CreatePrompt(session::Manager::Ptr const& sm)
+{
+  nux::ObjectPtr<AbstractUserPromptView> prompt;
+
+  if (unity::Settings::Instance().desktop_type() == DesktopType::UBUNTUKYLIN)
+    prompt = new KylinUserPromptView(sm);
+  else
+    prompt = new UserPromptView(sm);
+
+  return prompt;
+}
+
+}
+}

=== added file 'lockscreen/LockScreenPromptFactory.h'
--- lockscreen/LockScreenPromptFactory.h	1970-01-01 00:00:00 +0000
+++ lockscreen/LockScreenPromptFactory.h	2016-01-15 01:41:44 +0000
@@ -0,0 +1,42 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+* Copyright (C) 2015 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: Marco Trevisan <[e-mail]>
+*/
+
+#ifndef UNITY_LOCKSCREEN_PROMPT_FACTORY
+#define UNITY_LOCKSCREEN_PROMPT_FACTORY
+
+#include <NuxCore/NuxCore.h>
+#include <UnityCore/SessionManager.h>
+
+namespace unity
+{
+class MockableBaseWindow;
+
+namespace lockscreen
+{
+class AbstractUserPromptView;
+
+struct PromptFactory
+{
+  static nux::ObjectPtr<AbstractUserPromptView> CreatePrompt(session::Manager::Ptr const&);
+};
+
+}
+}
+
+#endif // UNITY_LOCKSCREEN_PROMPT_FACTORY

=== modified file 'lockscreen/LockScreenShield.cpp'
--- lockscreen/LockScreenShield.cpp	2014-09-19 20:44:05 +0000
+++ lockscreen/LockScreenShield.cpp	2016-01-15 01:41:44 +0000
@@ -21,127 +21,35 @@
 
 #include <Nux/VLayout.h>
 #include <Nux/HLayout.h>
-#include <Nux/PaintLayer.h>
 
-#include "BackgroundSettings.h"
-#include "CofView.h"
 #include "LockScreenPanel.h"
 #include "LockScreenSettings.h"
-#include "UserPromptView.h"
-#include "unity-shared/UScreen.h"
-#include "unity-shared/UnitySettings.h"
-#include "unity-shared/WindowManager.h"
+#include "LockScreenAbstractPromptView.h"
 
 namespace unity
 {
 namespace lockscreen
 {
-namespace
-{
-const unsigned MAX_GRAB_WAIT = 100;
-}
 
 Shield::Shield(session::Manager::Ptr const& session_manager,
                indicator::Indicators::Ptr const& indicators,
                Accelerators::Ptr const& accelerators,
-               nux::ObjectPtr<UserPromptView> const& prompt_view,
+               nux::ObjectPtr<AbstractUserPromptView> const& prompt_view,
                int monitor_num, bool is_primary)
-  : AbstractShield(session_manager, indicators, accelerators, prompt_view, monitor_num, is_primary)
-  , bg_settings_(std::make_shared<BackgroundSettings>())
+  : BaseShield(session_manager, indicators, accelerators, prompt_view, monitor_num, is_primary)
   , panel_view_(nullptr)
-  , cof_view_(nullptr)
 {
-  UpdateScale();
   is_primary ? ShowPrimaryView() : ShowSecondaryView();
-
   EnableInputWindow(true);
 
-  unity::Settings::Instance().dpi_changed.connect(sigc::mem_fun(this, &Shield::UpdateScale));
-  geometry_changed.connect([this] (nux::Area*, nux::Geometry&) { UpdateBackgroundTexture();});
-
   monitor.changed.connect([this] (int monitor) {
-    UpdateScale();
-
     if (panel_view_)
       panel_view_->monitor = monitor;
-
-    UpdateBackgroundTexture();
   });
 
   primary.changed.connect([this] (bool is_primary) {
-    regrab_conn_->disconnect();
-    is_primary ? ShowPrimaryView() : ShowSecondaryView();
     if (panel_view_) panel_view_->SetInputEventSensitivity(is_primary);
-    QueueRelayout();
-    QueueDraw();
-  });
-
-  scale.changed.connect([this] (double scale) {
-    if (prompt_view_ && primary())
-      prompt_view_->scale = scale;
-
-    if (cof_view_)
-      cof_view_->scale = scale;
-
-    if (prompt_layout_)
-      prompt_layout_->SetLeftAndRightPadding(2 * Settings::GRID_SIZE.CP(scale));
-
-    background_layer_.reset();
-    UpdateBackgroundTexture();
-  });
-
-  mouse_move.connect([this] (int x, int y, int, int, unsigned long, unsigned long) {
-    auto const& abs_geo = GetAbsoluteGeometry();
-    grab_motion.emit(abs_geo.x + x, abs_geo.y + y);
-  });
-}
-
-void Shield::UpdateScale()
-{
-  scale = unity::Settings::Instance().em(monitor)->DPIScale();
-}
-
-void Shield::UpdateBackgroundTexture()
-{
-  auto const& monitor_geo = UScreen::GetDefault()->GetMonitorGeometry(monitor);
-
-  if (!background_layer_ || monitor_geo != background_layer_->GetGeometry())
-  {
-    auto background_texture = bg_settings_->GetBackgroundTexture(monitor);
-    background_layer_.reset(new nux::TextureLayer(background_texture->GetDeviceTexture(), nux::TexCoordXForm(), nux::color::White, true));
-    SetBackgroundLayer(background_layer_.get());
-  }
-}
-
-void Shield::GrabScreen(bool cancel_on_failure)
-{
-  auto& wc = nux::GetWindowCompositor();
-
-  if (wc.GrabPointerAdd(this) && wc.GrabKeyboardAdd(this))
-  {
-    regrab_conn_->disconnect();
-    regrab_timeout_.reset();
-    grabbed.emit();
-  }
-  else
-  {
-    auto const& retry_cb = sigc::bind(sigc::mem_fun(this, &Shield::GrabScreen), false);
-    regrab_conn_ = WindowManager::Default().screen_ungrabbed.connect(retry_cb);
-
-    if (cancel_on_failure)
-    {
-      regrab_timeout_.reset(new glib::Timeout(MAX_GRAB_WAIT, [this] {
-        grab_failed.emit();
-        return false;
-      }));
-    }
-  }
-}
-
-bool Shield::HasGrab() const
-{
-  auto& wc = nux::GetWindowCompositor();
-  return (wc.GetPointerGrabArea() == this && wc.GetKeyboardGrabArea() == this);
+  });
 }
 
 void Shield::ShowPrimaryView()
@@ -181,27 +89,6 @@
   main_layout->AddSpace(0, 10);
 }
 
-void Shield::ShowSecondaryView()
-{
-  if (prompt_layout_)
-    prompt_layout_->RemoveChildObject(prompt_view_.GetPointer());
-
-  if (cof_layout_)
-  {
-    SetLayout(cof_layout_.GetPointer());
-    return;
-  }
-
-  nux::Layout* main_layout = new nux::VLayout();
-  cof_layout_ = main_layout;
-  SetLayout(cof_layout_.GetPointer());
-
-  // The circle of friends
-  cof_view_ = new CofView();
-  cof_view_->scale = scale();
-  main_layout->AddView(cof_view_);
-}
-
 Panel* Shield::CreatePanel()
 {
   if (!indicators_ || !session_manager_)
@@ -259,21 +146,6 @@
   return nullptr;
 }
 
-bool Shield::AcceptKeyNavFocus()
-{
-  return false;
-}
-
-nux::Area* Shield::FindAreaUnderMouse(nux::Point const& mouse, nux::NuxEventType event_type)
-{
-  nux::Area* area = BaseWindow::FindAreaUnderMouse(mouse, event_type);
-
-  if (!area && primary)
-    return this;
-
-  return area;
-}
-
 bool Shield::IsIndicatorOpen() const
 {
   return panel_view_ ? panel_view_->active() : false;

=== modified file 'lockscreen/LockScreenShield.h'
--- lockscreen/LockScreenShield.h	2014-09-19 18:02:37 +0000
+++ lockscreen/LockScreenShield.h	2016-01-15 01:41:44 +0000
@@ -21,56 +21,37 @@
 #define UNITY_LOCKSCREEN_SHIELD_H
 
 #include <UnityCore/ConnectionManager.h>
-#include <UnityCore/GLibSource.h>
-#include "LockScreenAbstractShield.h"
+#include "LockScreenBaseShield.h"
 
 namespace unity
 {
 namespace lockscreen
 {
 
-class BackgroundSettings;
-class UserAuthenticator;
-class UserPromptView;
+class AbstractUserPromptView;
 class Panel;
-class CofView;
 
-class Shield : public AbstractShield
+class Shield : public BaseShield
 {
 public:
   Shield(session::Manager::Ptr const&,
          indicator::Indicators::Ptr const&,
          Accelerators::Ptr const&,
-         nux::ObjectPtr<UserPromptView> const&,
+         nux::ObjectPtr<AbstractUserPromptView> const&,
          int monitor, bool is_primary);
 
-  bool HasGrab() const override;
   bool IsIndicatorOpen() const override;
   void ActivatePanel() override;
 
 protected:
-  bool AcceptKeyNavFocus() override;
   nux::Area* FindKeyFocusArea(unsigned int, unsigned long, unsigned long) override;
-  nux::Area* FindAreaUnderMouse(nux::Point const&, nux::NuxEventType) override;
 
 private:
-  void UpdateBackgroundTexture();
-  void GrabScreen(bool cancel_on_failure);
-  void ShowPrimaryView();
-  void ShowSecondaryView();
-  void UpdateScale();
+  void ShowPrimaryView() override;
   Panel* CreatePanel();
 
-  std::shared_ptr<BackgroundSettings> bg_settings_;
-  std::unique_ptr<nux::AbstractPaintLayer> background_layer_;
-  nux::ObjectPtr<nux::Layout> primary_layout_;
-  nux::ObjectPtr<nux::Layout> prompt_layout_;
-  nux::ObjectPtr<nux::Layout> cof_layout_;
   connection::Wrapper panel_active_conn_;
-  connection::Wrapper regrab_conn_;
-  glib::Source::UniquePtr regrab_timeout_;
   Panel* panel_view_;
-  CofView* cof_view_;
 };
 
 }

=== modified file 'lockscreen/LockScreenShieldFactory.cpp'
--- lockscreen/LockScreenShieldFactory.cpp	2014-07-11 17:45:39 +0000
+++ lockscreen/LockScreenShieldFactory.cpp	2016-01-15 01:41:44 +0000
@@ -19,20 +19,28 @@
 
 #include "LockScreenShieldFactory.h"
 #include "LockScreenShield.h"
-#include "UserPromptView.h"
+#include "KylinLockScreenShield.h"
+#include "unity-shared/UnitySettings.h"
 
 namespace unity
 {
 namespace lockscreen
 {
 
-nux::ObjectPtr<AbstractShield> ShieldFactory::CreateShield(session::Manager::Ptr const& session_manager,
-                                                           indicator::Indicators::Ptr const& indicators,
-                                                           Accelerators::Ptr const& accelerators,
-                                                           nux::ObjectPtr<UserPromptView> const& prompt_view,
-                                                           int monitor, bool is_primary)
+nux::ObjectPtr<BaseShield> ShieldFactory::CreateShield(session::Manager::Ptr const& session_manager,
+                                                       indicator::Indicators::Ptr const& indicators,
+                                                       Accelerators::Ptr const& accelerators,
+                                                       nux::ObjectPtr<AbstractUserPromptView> const& prompt_view,
+                                                       int monitor, bool is_primary)
 {
-  return nux::ObjectPtr<Shield>(new Shield(session_manager, indicators, accelerators, prompt_view,  monitor, is_primary));
+  nux::ObjectPtr<BaseShield> shield;
+
+  if (Settings::Instance().desktop_type() == DesktopType::UBUNTUKYLIN)
+    shield = new KylinShield(session_manager, accelerators, prompt_view, monitor, is_primary);
+  else
+    shield = new Shield(session_manager, indicators, accelerators, prompt_view,  monitor, is_primary);
+
+  return shield;
 }
 
 }

=== modified file 'lockscreen/LockScreenShieldFactory.h'
--- lockscreen/LockScreenShieldFactory.h	2014-07-11 17:45:39 +0000
+++ lockscreen/LockScreenShieldFactory.h	2016-01-15 01:41:44 +0000
@@ -20,18 +20,19 @@
 #ifndef UNITY_LOCKSCREEN_SHIELD_FACTORY
 #define UNITY_LOCKSCREEN_SHIELD_FACTORY
 
-#include <Nux/Nux.h>
-#include "LockScreenAbstractShield.h"
+#include <NuxCore/NuxCore.h>
+#include <UnityCore/SessionManager.h>
+#include <UnityCore/Indicators.h>
+#include "LockScreenAccelerators.h"
 
 namespace unity
 {
-
 class MockableBaseWindow;
 
 namespace lockscreen
 {
-
-class UserPromptView;
+class AbstractUserPromptView;
+class BaseShield;
 
 struct ShieldFactoryInterface
 {
@@ -39,23 +40,23 @@
 
   virtual ~ShieldFactoryInterface() = default;
 
-  virtual nux::ObjectPtr<AbstractShield> CreateShield(session::Manager::Ptr const&,
-                                                      indicator::Indicators::Ptr const&,
-                                                      Accelerators::Ptr const&,
-                                                      nux::ObjectPtr<UserPromptView> const&,
-                                                      int monitor, bool is_primary) = 0;
+  virtual nux::ObjectPtr<BaseShield> CreateShield(session::Manager::Ptr const&,
+                                                  indicator::Indicators::Ptr const&,
+                                                  Accelerators::Ptr const&,
+                                                  nux::ObjectPtr<AbstractUserPromptView> const&,
+                                                  int monitor, bool is_primary) = 0;
 };
 
 struct ShieldFactory : ShieldFactoryInterface
 {
-  nux::ObjectPtr<AbstractShield> CreateShield(session::Manager::Ptr const&,
-                                              indicator::Indicators::Ptr const&,
-                                              Accelerators::Ptr const&,
-                                              nux::ObjectPtr<UserPromptView> const&,
-                                              int monitor, bool is_primary) override;
+  nux::ObjectPtr<BaseShield> CreateShield(session::Manager::Ptr const&,
+                                          indicator::Indicators::Ptr const&,
+                                          Accelerators::Ptr const&,
+                                          nux::ObjectPtr<AbstractUserPromptView> const&,
+                                          int monitor, bool is_primary) override;
 };
 
 }
 }
 
-#endif
+#endif // UNITY_LOCKSCREEN_SHIELD_FACTORY

=== modified file 'lockscreen/UserPromptView.cpp'
--- lockscreen/UserPromptView.cpp	2015-11-06 13:50:59 +0000
+++ lockscreen/UserPromptView.cpp	2016-01-15 01:41:44 +0000
@@ -100,7 +100,7 @@
 }
 
 UserPromptView::UserPromptView(session::Manager::Ptr const& session_manager)
-  : nux::View(NUX_TRACKER_LOCATION)
+  : AbstractUserPromptView(session_manager)
   , scale(1.0)
   , session_manager_(session_manager)
   , username_(nullptr)

=== modified file 'lockscreen/UserPromptView.h'
--- lockscreen/UserPromptView.h	2014-07-28 16:58:13 +0000
+++ lockscreen/UserPromptView.h	2016-01-15 01:41:44 +0000
@@ -27,6 +27,7 @@
 #include <Nux/View.h>
 #include <UnityCore/SessionManager.h>
 
+#include "LockScreenAbstractPromptView.h"
 #include "UserAuthenticatorPam.h"
 #include "unity-shared/IMTextEntry.h"
 
@@ -44,7 +45,7 @@
 namespace lockscreen
 {
 
-class UserPromptView : public nux::View
+class UserPromptView : public AbstractUserPromptView
 {
 public:
   UserPromptView(session::Manager::Ptr const& session_manager);

=== added file 'resources/login.svg'
--- resources/login.svg	1970-01-01 00:00:00 +0000
+++ resources/login.svg	2016-01-15 01:41:44 +0000
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 18.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" id="图层_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 34 34" enable-background="new 0 0 34 34" xml:space="preserve">
+<rect x="0" display="none" fill="#CABADA" width="34" height="34"/>
+<polygon fill="#1A2A7C" points="7,16 21.6,16 16,10 20,10 26.9,17.5 20,25 16,25 21.5,19 7,19 "/>
+</svg>

=== added file 'resources/switch_user.svg'
--- resources/switch_user.svg	1970-01-01 00:00:00 +0000
+++ resources/switch_user.svg	2016-01-15 01:41:44 +0000
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 18.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" id="图层_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 34 34" enable-background="new 0 0 34 34" xml:space="preserve">
+<rect x="0" display="none" fill="#CABADA" width="34" height="34"/>
+<polygon display="none" fill="#1A2A7C" points="7,16 21.6,16 16,10 20,10 26.9,17.5 20,25 16,25 21.5,19 7,19 "/>
+<g>
+	<path fill="#FFFFFF" d="M17,1c8.8,0,16,7.2,16,16s-7.2,16-16,16S1,25.8,1,17S8.1,1,17,1 M17,0C7.6,0,0,7.6,0,17s7.6,17,17,17
+		s17-7.6,17-17S26.3,0,17,0L17,0z"/>
+</g>
+<polygon fill="#FFFFFF" points="13.9,9.6 19.2,9.6 14.9,14.8 27.6,14.8 27.6,20.1 14.8,20.1 19.1,25.4 13.9,25.4 6.4,17.5 "/>
+</svg>

=== modified file 'shutdown/StandaloneSession.cpp'
--- shutdown/StandaloneSession.cpp	2014-05-16 04:24:05 +0000
+++ shutdown/StandaloneSession.cpp	2016-01-15 01:41:44 +0000
@@ -39,6 +39,7 @@
   std::string RealName() const { return "Marco Trevisan"; }
   std::string UserName() const { return "marco"; }
   std::string HostName() const { return "tricky"; }
+  void UserIconFile(std::function<void(std::string const&)> const&) const { std::cout << "UserIconFile" << std::endl; }
 
   void ScreenSaverActivate() { std::cout << "ScreenSaverActivate" << std::endl; }
   void ScreenSaverDeactivate() { std::cout << "ScreenSaverDeactivate" << std::endl; }
@@ -49,6 +50,7 @@
   void Shutdown() { std::cout << "Shutdown" << std::endl; }
   void Suspend() { std::cout << "Suspend" << std::endl; }
   void Hibernate() { std::cout << "Hibernate" << std::endl; }
+  void SwitchToGreeter() { std::cout << "SwitchToGreeter" << std::endl; }
 
   void CancelAction() { std::cout << "CancelAction" << std::endl; }
 

=== modified file 'tests/test_gnome_session_manager.cpp'
--- tests/test_gnome_session_manager.cpp	2015-09-30 21:02:08 +0000
+++ tests/test_gnome_session_manager.cpp	2016-01-15 01:41:44 +0000
@@ -42,6 +42,7 @@
 const std::string CONSOLE_KIT_PATH = "/org/freedesktop/ConsoleKit/Manager";
 const std::string SESSION_MANAGER_PATH = "/org/gnome/SessionManager";
 const std::string SESSION_MANAGER_PRESENCE_PATH = "/org/gnome/SessionManager/Presence";
+const std::string DISPLAY_MANAGER_SEAT_PATH = "/org/freedesktop/DisplayManager/Seat0";
 
 const std::string SESSION_OPTIONS = "com.canonical.indicator.session";
 const std::string SUPPRESS_DIALOGS_KEY = "suppress-logout-restart-shutdown";
@@ -137,6 +138,13 @@
 </node>
 )";
 
+const std::string DISPLAY_MANAGER_SEAT =
+R"(<node>
+  <interface name="org.freedesktop.DisplayManager.Seat">
+    <method name="SwitchToGreeter"/>
+  </interface>
+</node>
+)";
 }
 
 struct MockGnomeSessionManager : session::GnomeManager {
@@ -208,6 +216,9 @@
       return nullptr;
     });
 
+    display_manager_seat_ = std::make_shared<DBusServer>();
+    display_manager_seat_->AddObjects(introspection::DISPLAY_MANAGER_SEAT, DISPLAY_MANAGER_SEAT_PATH);
+
     manager = std::make_shared<MockGnomeSessionManager>();
     shell_proxy_ = std::make_shared<DBusProxy>(TEST_SERVER_NAME, SHELL_OBJECT_PATH, SHELL_INTERFACE);
 
@@ -228,6 +239,7 @@
     Utils::WaitUntilMSec([] { return logind_->IsConnected(); });
     Utils::WaitUntilMSec([] { return console_kit_->IsConnected(); });
     Utils::WaitUntilMSec([] { return session_manager_->IsConnected(); });
+    Utils::WaitUntilMSec([] { return display_manager_seat_->IsConnected(); });
     Utils::WaitUntilMSec([] { return shell_proxy_->IsConnected();});
     ASSERT_TRUE(shell_proxy_->IsConnected());
     EnableInteractiveShutdown(true);
@@ -277,6 +289,7 @@
     logind_.reset();
     console_kit_.reset();
     session_manager_.reset();
+    display_manager_seat_.reset();
   }
 
   bool SettingsAvailable()
@@ -342,6 +355,7 @@
   static DBusServer::Ptr console_kit_;
   static DBusServer::Ptr logind_;
   static DBusServer::Ptr session_manager_;
+  static DBusServer::Ptr display_manager_seat_;
   static DBusProxy::Ptr shell_proxy_;
 };
 
@@ -350,6 +364,7 @@
 DBusServer::Ptr TestGnomeSessionManager::console_kit_;
 DBusServer::Ptr TestGnomeSessionManager::logind_;
 DBusServer::Ptr TestGnomeSessionManager::session_manager_;
+DBusServer::Ptr TestGnomeSessionManager::display_manager_seat_;
 DBusProxy::Ptr TestGnomeSessionManager::shell_proxy_;
 bool TestGnomeSessionManager::can_shutdown_;
 bool TestGnomeSessionManager::can_suspend_;
@@ -390,6 +405,23 @@
   EXPECT_EQ(manager->HostName(), g_get_host_name());
 }
 
+TEST_F(TestGnomeSessionManager, SwitchToGreeter)
+{
+  bool switch_called = false;
+
+  display_manager_seat_->GetObjects().front()->SetMethodsCallsHandler([&] (std::string const& method, GVariant*) {
+    if (method == "SwitchToGreeter")
+      switch_called = true;
+
+    return static_cast<GVariant*>(nullptr);
+  });
+
+  manager->SwitchToGreeter();
+
+  Utils::WaitUntilMSec(switch_called);
+  EXPECT_TRUE(switch_called);
+}
+
 TEST_F(TestGnomeSessionManager, ScreenSaverActivate)
 {
   bool signal_emitted = false;

=== modified file 'tests/test_lockscreen_controller.cpp'
--- tests/test_lockscreen_controller.cpp	2014-09-19 18:02:37 +0000
+++ tests/test_lockscreen_controller.cpp	2016-01-15 01:41:44 +0000
@@ -20,7 +20,7 @@
 #include <gmock/gmock.h>
 using namespace testing;
 
-#include "lockscreen/UserPromptView.h"
+#include "lockscreen/LockScreenAbstractPromptView.h"
 #include "lockscreen/LockScreenController.h"
 
 #include <Nux/NuxTimerTickSource.h>
@@ -51,26 +51,27 @@
 }
 
 
-struct MockShield : AbstractShield
+struct MockShield : BaseShield
 {
   MockShield()
-    : AbstractShield(nullptr, nullptr, nullptr, nux::ObjectPtr<UserPromptView>(), 0, false)
+    : BaseShield(nullptr, nullptr, nullptr, nux::ObjectPtr<AbstractUserPromptView>(), 0, false)
   {}
 
   MOCK_CONST_METHOD0(IsIndicatorOpen, bool());
   MOCK_METHOD0(ActivatePanel, void());
   MOCK_CONST_METHOD0(HasGrab, bool());
+  MOCK_METHOD0(ShowPrimaryView, void());
 };
 
 struct ShieldFactoryMock : ShieldFactoryInterface
 {
-  nux::ObjectPtr<AbstractShield> CreateShield(session::Manager::Ptr const&,
-                                              indicator::Indicators::Ptr const&,
-                                              Accelerators::Ptr const&,
-                                              nux::ObjectPtr<UserPromptView> const&,
-                                              int, bool) override
+  nux::ObjectPtr<BaseShield> CreateShield(session::Manager::Ptr const&,
+                                          indicator::Indicators::Ptr const&,
+                                          Accelerators::Ptr const&,
+                                          nux::ObjectPtr<AbstractUserPromptView> const&,
+                                          int, bool) override
   {
-    return nux::ObjectPtr<AbstractShield>(new MockShield());
+    return nux::ObjectPtr<BaseShield>(new MockShield());
   }
 };
 

=== modified file 'tests/test_mock_session_manager.h'
--- tests/test_mock_session_manager.h	2014-05-16 04:24:05 +0000
+++ tests/test_mock_session_manager.h	2016-01-15 01:41:44 +0000
@@ -28,10 +28,12 @@
 struct MockManager : Manager
 {
   typedef std::shared_ptr<MockManager> Ptr;
+  typedef std::function<void(std::string const&)> ReplyCallback;
 
   MOCK_CONST_METHOD0(RealName, std::string());
   MOCK_CONST_METHOD0(UserName, std::string());
   MOCK_CONST_METHOD0(HostName, std::string());
+  MOCK_CONST_METHOD1(UserIconFile, void(ReplyCallback const&));
 
   MOCK_METHOD0(ScreenSaverActivate, void());
   MOCK_METHOD0(ScreenSaverDeactivate, void());
@@ -43,6 +45,7 @@
   MOCK_METHOD0(Suspend, void());
   MOCK_METHOD0(Hibernate, void());
   MOCK_METHOD0(CancelAction, void());
+  MOCK_METHOD0(SwitchToGreeter, void());
 
   MOCK_CONST_METHOD0(CanLock, bool());
   MOCK_CONST_METHOD0(CanShutdown, bool());

=== modified file 'tests/test_unity_settings.cpp'
--- tests/test_unity_settings.cpp	2014-03-21 19:45:29 +0000
+++ tests/test_unity_settings.cpp	2016-01-15 01:41:44 +0000
@@ -53,12 +53,14 @@
    , sig_receiver(unity_settings)
   {
     g_settings_set_enum(gsettings, "form-factor", static_cast<int>(unity::FormFactor::DESKTOP));
+    g_settings_set_enum(gsettings, "desktop-type", static_cast<int>(unity::DesktopType::UBUNTU));
   }
 
   ~TestUnitySettings()
   {
     sig_receiver.notify_callbacks();
     g_settings_reset(gsettings, "form-factor");
+    g_settings_reset(gsettings, "desktop-type");
   }
 };
 
@@ -78,6 +80,14 @@
   EXPECT_EQ(unity_settings->form_factor(), unity::FormFactor::NETBOOK);
 }
 
+TEST_F(TestUnitySettings, GetDesktopType)
+{
+  ASSERT_NE(unity_settings->desktop_type(), unity::DesktopType::UBUNTUKYLIN);
+
+  g_settings_set_enum(gsettings, "desktop-type", static_cast<int>(unity::DesktopType::UBUNTUKYLIN));
+  EXPECT_EQ(unity_settings->desktop_type(), unity::DesktopType::UBUNTUKYLIN);
+}
+
 TEST_F(TestUnitySettings, FormFactorChangedSignal_Extern)
 {
   EXPECT_CALL(sig_receiver, FormFactorChanged(unity::FormFactor::NETBOOK));

=== modified file 'unity-shared/TextInput.cpp'
--- unity-shared/TextInput.cpp	2015-12-16 09:03:56 +0000
+++ unity-shared/TextInput.cpp	2016-01-15 01:41:44 +0000
@@ -54,6 +54,7 @@
 const RawPixel TOOLTIP_OFFSET    = 10_em;
 const RawPixel DEFAULT_ICON_SIZE = 22_em;
 
+std::string ACTIVATOR_ICON  = "arrow_right.png";
 std::string WARNING_ICON    = "dialog-warning-symbolic";
 // Fonts
 const std::string HINT_LABEL_DEFAULT_FONT_NAME = "Ubuntu";
@@ -88,9 +89,15 @@
 
 TextInput::TextInput(NUX_FILE_LINE_DECL)
   : View(NUX_FILE_LINE_PARAM)
+  , activator_icon(ACTIVATOR_ICON)
+  , activator_icon_size(DEFAULT_ICON_SIZE)
+  , background_color(nux::Color(0.0f, 0.0f, 0.0f, 0.35f))
+  , border_color(nux::Color(1.0f, 1.0f, 1.0f, 0.7f))
+  , border_radius(BORDER_RADIUS)
   , input_hint("")
   , hint_font_name(HINT_LABEL_DEFAULT_FONT_NAME)
   , hint_font_size(HINT_LABEL_FONT_SIZE)
+  , hint_color(nux::Color(1.0f, 1.0f, 1.0f, 0.5f))
   , show_activator(false)
   , show_lock_warnings(false)
   , scale(1.0)
@@ -109,7 +116,9 @@
   hint_layout_->SetLeftAndRightPadding(HINT_PADDING.CP(scale), HINT_PADDING.CP(scale));
 
   hint_ = new StaticCairoText("");
-  hint_->SetTextColor(nux::Color(1.0f, 1.0f, 1.0f, 0.5f));
+  hint_->SetTextColor(hint_color);
+  hint_color.changed.connect(sigc::hide(sigc::mem_fun(this, &TextInput::UpdateHintColor)));
+
   hint_->SetScale(scale);
   hint_layout_->AddView(hint_, 0, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FULL);
   hint_font_name.changed.connect(sigc::hide(sigc::mem_fun(this, &TextInput::UpdateHintFont)));
@@ -146,10 +155,18 @@
   Settings::Instance().font_scaling.changed.connect(sigc::hide(sigc::mem_fun(this, &TextInput::UpdateSize)));
 
   // Activator
-  activator_ = new IconTexture(LoadActivatorIcon(DEFAULT_ICON_SIZE.CP(scale)));
+  activator_ = new IconTexture(LoadActivatorIcon(activator_icon(), activator_icon_size().CP(scale)));
   activator_->SetVisible(show_activator());
   layout_->AddView(activator_, 0, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FULL);
 
+  activator_icon.changed.connect([this] (std::string icon) {
+    activator_->SetTexture(LoadActivatorIcon(icon, activator_icon_size().CP(scale)));
+  });
+
+  activator_icon_size.changed.connect([this] (RawPixel icon_size) {
+    activator_->SetTexture(LoadActivatorIcon(activator_icon(), icon_size.CP(scale)));
+  });
+
   show_activator.changed.connect([this] (bool value) {
     activator_->SetVisible(value);
   });
@@ -185,6 +202,11 @@
   warning_->mouse_leave.connect([this] (int x, int y, int button, int key_flags) {
     tooltip_timeout_ ? tooltip_timeout_.reset() : QueueDraw();
   });
+
+  //background
+  background_color.changed.connect([this] (nux::Color color) { UpdateBackground(true); });
+  border_color.changed.connect([this] (nux::Color color) { UpdateBackground(true); });
+  border_radius.changed.connect([this] (int radius) { UpdateBackground(true); });
 }
 
 void TextInput::UpdateSize()
@@ -208,7 +230,7 @@
   hint_->SetMaximumHeight(pango_entry_->GetMinimumHeight());
 
   spinner_->scale = scale;
-  activator_->SetTexture(LoadActivatorIcon(DEFAULT_ICON_SIZE.CP(scale)));
+  activator_->SetTexture(LoadActivatorIcon(activator_icon(), activator_icon_size().CP(scale)));
   warning_->SetTexture(LoadWarningIcon(DEFAULT_ICON_SIZE.CP(scale)));
   warning_tooltip_.Release();
 
@@ -254,10 +276,15 @@
   hint_->SetFont((hint_font_name() + " " + std::to_string(hint_font_size())).c_str());
 }
 
-nux::ObjectPtr<nux::BaseTexture> TextInput::LoadActivatorIcon(int icon_size)
+void TextInput::UpdateHintColor()
+{
+  hint_->SetTextColor(hint_color);
+}
+
+nux::ObjectPtr<nux::BaseTexture> TextInput::LoadActivatorIcon(std::string const& icon_file, int icon_size)
 {
   TextureCache& cache = TextureCache::GetDefault();
-  return cache.FindTexture("arrow_right.png", icon_size, icon_size);
+  return cache.FindTexture(icon_file, icon_size, icon_size);
 }
 
 nux::ObjectPtr<nux::BaseTexture> TextInput::LoadWarningIcon(int icon_size)
@@ -459,15 +486,15 @@
   cairo_graphics.DrawRoundedRectangle(cr,
                                       1.0f,
                                       0.5, 0.5,
-                                      BORDER_RADIUS,
+                                      border_radius(),
                                       (last_width_/scale) - 1, (last_height_/scale) - 1,
                                       false);
 
   cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
-  cairo_set_source_rgba(cr, 0.0f, 0.0f, 0.0f, 0.35f);
+  cairo_set_source_rgba(cr, background_color().red, background_color().green, background_color().blue, background_color().alpha);
   cairo_fill_preserve(cr);
   cairo_set_line_width(cr, 1);
-  cairo_set_source_rgba(cr, 1.0f, 1.0f, 1.0f, 0.7f);
+  cairo_set_source_rgba(cr, border_color().red, border_color().green, border_color().blue, border_color().alpha);
   cairo_stroke(cr);
 
   auto texture2D = texture_ptr_from_cairo_graphics(cairo_graphics);

=== modified file 'unity-shared/TextInput.h'
--- unity-shared/TextInput.h	2015-11-06 11:40:31 +0000
+++ unity-shared/TextInput.h	2016-01-15 01:41:44 +0000
@@ -26,6 +26,7 @@
 
 #include "Introspectable.h"
 #include "IMTextEntry.h"
+#include "RawPixel.h"
 #include "SearchBarSpinner.h"
 
 namespace nux
@@ -57,10 +58,16 @@
 
   IMTextEntry* text_entry() const;
 
+  nux::Property<std::string> activator_icon;
+  nux::Property<RawPixel> activator_icon_size;
+  nux::Property<nux::Color> background_color;
+  nux::Property<nux::Color> border_color;
+  nux::Property<int> border_radius;
   nux::RWProperty<std::string> input_string;
   nux::Property<std::string> input_hint;
   nux::Property<std::string> hint_font_name;
   nux::Property<int> hint_font_size;
+  nux::Property<nux::Color> hint_color;
   nux::ROProperty<bool> im_active;
   nux::ROProperty<bool> im_preedit;
   nux::Property<bool> show_activator;
@@ -70,6 +77,7 @@
 private:
   void OnFontChanged();
   void UpdateHintFont();
+  void UpdateHintColor();
   void Draw(nux::GraphicsEngine& GfxContext, bool force_draw);
   void DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw);
   void UpdateBackground(bool force);
@@ -84,7 +92,7 @@
   void CheckLocks();
   void OnLockStateChanged(bool);
 
-  nux::ObjectPtr<nux::BaseTexture> LoadActivatorIcon(int icon_size);
+  nux::ObjectPtr<nux::BaseTexture> LoadActivatorIcon(std::string const& icon_file, int icon_size);
   nux::ObjectPtr<nux::BaseTexture> LoadWarningIcon(int icon_size);
   void LoadWarningTooltip();
 

=== modified file 'unity-shared/UnitySettings.cpp'
--- unity-shared/UnitySettings.cpp	2015-05-22 13:20:22 +0000
+++ unity-shared/UnitySettings.cpp	2016-01-15 01:41:44 +0000
@@ -38,6 +38,7 @@
 const std::string SETTINGS_NAME = "com.canonical.Unity";
 const std::string FORM_FACTOR = "form-factor";
 const std::string DOUBLE_CLICK_ACTIVATE = "double-click-activate";
+const std::string DESKTOP_TYPE = "desktop-type";
 
 const std::string LIM_SETTINGS = "com.canonical.Unity.IntegratedMenus";
 const std::string CLICK_MOVEMENT_THRESHOLD = "click-movement-threshold";
@@ -94,6 +95,7 @@
     parent_->form_factor.SetSetterFunction(sigc::mem_fun(this, &Impl::SetFormFactor));
     parent_->double_click_activate.SetGetterFunction(sigc::mem_fun(this, &Impl::GetDoubleClickActivate));
     parent_->remote_content.SetGetterFunction(sigc::mem_fun(this, &Impl::GetRemoteContentEnabled));
+    parent_->desktop_type.SetGetterFunction(sigc::mem_fun(this, &Impl::GetDesktopType));
 
     for (unsigned i = 0; i < monitors::MAX; ++i)
       em_converters_.emplace_back(std::make_shared<EMConverter>());
@@ -218,6 +220,11 @@
     return cached_double_click_activate_;
   }
 
+  DesktopType GetDesktopType() const
+  {
+    return static_cast<DesktopType>(g_settings_get_enum(usettings_, DESKTOP_TYPE.c_str()));
+  }
+
   int GetFontSize() const
   {
     gint font_size;

=== modified file 'unity-shared/UnitySettings.h'
--- unity-shared/UnitySettings.h	2015-05-22 13:20:22 +0000
+++ unity-shared/UnitySettings.h	2016-01-15 01:41:44 +0000
@@ -35,6 +35,12 @@
   TV
 };
 
+enum class DesktopType
+{
+    UBUNTU,
+    UBUNTUKYLIN
+};
+
 class Settings
 {
 public:
@@ -51,6 +57,7 @@
 
   nux::RWProperty<FormFactor> form_factor;
   nux::Property<bool> is_standalone;
+  nux::ROProperty<DesktopType> desktop_type;
   nux::ROProperty<bool> double_click_activate;
   nux::Property<unsigned> lim_movement_thresold;
   nux::Property<unsigned> lim_double_click_wait;