Merge lp:~3v1n0/unity/scale-layout-windows into lp:unity

[Marco Trevisan (Treviño)]

UnityScreen: use switcher's LayoutSystem to compute the scaled windows geometries

Thanks to this, both the Alt+Tab and Spread will use the same codepath to define the positioning of the scaled windows.

JohnLea approved it.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3704
http://jenkins.qa.ubuntu.com/job/unity-ci/779/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-amd64-ci/315
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-armhf-ci/311
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-i386-ci/313

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

review: Approve (continuous-integration)

[Christopher Townsend (townsend)]

Looks good

review: Approve

=== modified file 'decorations/DecoratedWindow.cpp'
--- decorations/DecoratedWindow.cpp	2014-02-27 05:30:25 +0000
+++ decorations/DecoratedWindow.cpp	2014-03-12 23:00:55 +0000
@@ -129,7 +129,7 @@
   if (win_->hasUnmapReference())
     return;
 
-  CompWindowExtents empty(0, 0, 0, 0);
+  CompWindowExtents empty;
 
   if (win_->border() != empty || win_->input() != empty)
     win_->setWindowFrameExtents(&empty, &empty);
 
=== modified file 'panel/PanelMenuView.cpp'
--- panel/PanelMenuView.cpp	2014-03-06 09:26:03 +0000
+++ panel/PanelMenuView.cpp	2014-03-12 23:00:55 +0000
@@ -693,22 +693,30 @@
   if (BAMF_IS_WINDOW(window))
   {
     BamfView *view = reinterpret_cast<BamfView*>(window);
-    std::vector<Window> const& our_xids = nux::XInputWindow::NativeHandleList();
     Window window_xid = bamf_window_get_xid(window);
 
-    if (std::find(our_xids.begin(), our_xids.end(), window_xid) != our_xids.end())
+    if (bamf_window_get_window_type(window) == BAMF_WINDOW_DOCK)
     {
-      /* If the active window is an unity window, we need to fallback to the
-       * top one, anyway we should always avoid to focus unity internal windows */
-      BamfWindow* top_win = GetBamfWindowForXid(GetTopWindow());
-
-      if (top_win && top_win != window)
-      {
-        window = top_win;
-      }
-      else
-      {
-        return "";
+      auto panel = const_cast<PanelMenuView*>(this)->GetTopLevelViewWindow();
+      if (static_cast<nux::BaseWindow*>(panel)->GetInputWindowId() == window_xid)
+        return desktop_name_;
+
+      std::vector<Window> const& our_xids = nux::XInputWindow::NativeHandleList();
+
+      if (std::find(our_xids.begin(), our_xids.end(), window_xid) != our_xids.end())
+      {
+        /* If the active window is an unity window, we need to fallback to the
+         * top one, anyway we should always avoid to focus unity internal windows */
+        BamfWindow* top_win = GetBamfWindowForXid(GetTopWindow());
+
+        if (top_win && top_win != window)
+        {
+          window = top_win;
+        }
+        else
+        {
+          return "";
+        }
       }
     }
 
@@ -718,7 +726,7 @@
     }
     else if (!IsValidWindow(window_xid))
     {
-       return "";
+      return "";
     }
 
     if (WindowManager::Default().IsWindowMaximized(window_xid) && !use_appname)
 
=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2014-03-07 19:18:30 +0000
+++ plugins/unityshell/src/unityshell.cpp	2014-03-12 23:00:55 +0000
@@ -52,6 +52,7 @@
 #include "launcher/XdndStartStopNotifierImp.h"
 #include "CompizShortcutModeller.h"
 #include "GnomeKeyGrabber.h"
+#include "RawPixel.h"
 
 #include "decorations/DecorationsDataPool.h"
 #include "decorations/DecorationsManager.h"
@@ -137,7 +138,10 @@
 const unsigned int SCROLL_UP_BUTTON = 7;
 const int MAX_BUFFER_AGE = 11;
 const int FRAMES_TO_REDRAW_ON_RESUME = 10;
+const RawPixel SCALE_PADDING = 40_em;
+const RawPixel SCALE_SPACING = 20_em;
 const std::string RELAYOUT_TIMEOUT = "relayout-timeout";
+const std::string FIRST_RUN_STAMP = "first_run.stamp";
 } // namespace local
 } // anon namespace
 
@@ -267,6 +271,7 @@
      ScreenInterface::setHandler(screen);
      CompositeScreenInterface::setHandler(cScreen);
      GLScreenInterface::setHandler(gScreen);
+     ScaleScreenInterface::setHandler(sScreen);
 
      PluginAdapter::Initialize(screen);
      AddChild(&WindowManager::Default());
@@ -878,9 +883,8 @@
       if (CompWindow* window = screen->findWindow(target->xid))
       {
         UnityWindow *unity_window = UnityWindow::get(window);
-        double scale = target->result.width / static_cast<double>(target->geo.width);
         double parent_alpha = switcher_controller_->Opacity();
-        unity_window->paintThumbnail(target->result, target->alpha, parent_alpha, scale,
+        unity_window->paintThumbnail(target->result, target->alpha, parent_alpha, target->scale,
                                      target->decoration_height, target->selected);
       }
     }
@@ -3603,7 +3607,77 @@
   ScheduleRelayout(500);
 }
 
-void UnityScreen::OnDashRealized ()
+bool UnityScreen::layoutSlotsAndAssignWindows()
+{
+  auto const& scaled_windows = sScreen->getWindows();
+
+  for (auto const& output : screen->outputDevs())
+  {
+    ui::LayoutWindow::Vector layout_windows;
+    int monitor = UScreen::GetDefault()->GetMonitorAtPosition(output.centerX(), output.centerY());
+    double monitor_scale = unity_settings_.em(monitor)->DPIScale();
+
+    for (ScaleWindow *sw : scaled_windows)
+    {
+      if (sw->window->outputDevice() == static_cast<int>(output.id()))
+      {
+        UnityWindow::get(sw->window)->deco_win_->scaled = true;
+        layout_windows.emplace_back(std::make_shared<LayoutWindow>(sw->window->id()));
+      }
+    }
+
+    auto max_bounds = NuxGeometryFromCompRect(output.workArea());
+
+    if (launcher_controller_->options()->hide_mode != LAUNCHER_HIDE_NEVER)
+    {
+      int monitor_width = unity_settings_.LauncherWidth(monitor);
+      max_bounds.x += monitor_width;
+      max_bounds.width -= monitor_width;
+    }
+
+    nux::Geometry final_bounds;
+    ui::LayoutSystem layout;
+    layout.max_row_height = max_bounds.height;
+    layout.spacing = local::SCALE_SPACING.CP(monitor_scale);
+    int padding = local::SCALE_PADDING.CP(monitor_scale);
+    max_bounds.Expand(-padding, -padding);
+    layout.LayoutWindows(layout_windows, max_bounds, final_bounds);
+
+    auto lw_it = layout_windows.begin();
+    for (auto const& sw : scaled_windows)
+    {
+      if (lw_it == layout_windows.end())
+        break;
+
+      LayoutWindow::Ptr const& lw = *lw_it;
+
+      if (sw->window->id() != lw->xid)
+        continue;
+
+      ScaleSlot slot(CompRectFromNuxGeo(lw->result));
+      slot.scale = lw->scale;
+
+      float sx = lw->geo.width * slot.scale;
+      float sy = lw->geo.height * slot.scale;
+      float cx = (slot.x1() + slot.x2()) / 2;
+      float cy = (slot.y1() + slot.y2()) / 2;
+
+      CompWindow *w = sw->window;
+      cx += w->input().left * slot.scale;
+      cy += w->input().top * slot.scale;
+
+      slot.setGeometry(cx - sx / 2, cy - sy / 2, sx, sy);
+      slot.filled = true;
+
+      sw->setSlot(slot);
+      ++lw_it;
+    }
+  }
+
+  return true;
+}
+
+void UnityScreen::OnDashRealized()
 {
   /* stack any windows named "onboard" above us */
   for (CompWindow *w : screen->windows ())
@@ -3663,6 +3737,7 @@
   auto shortcuts_modeller = std::make_shared<shortcut::CompizModeller>();
   shortcut_controller_ = std::make_shared<shortcut::Controller>(base_window_raiser, shortcuts_modeller);
   AddChild(shortcut_controller_.get());
+  ShowFirstRunHints();
 
   // Setup Session Controller
   auto manager = std::make_shared<session::GnomeManager>();
@@ -3742,6 +3817,41 @@
   return menus_->KeyGrabber()->GetActions();
 }
 
+void UnityScreen::ShowFirstRunHints()
+{
+  sources_.AddTimeoutSeconds(1, [this] {
+    auto const& cache_dir = glib::gchar_to_string(g_get_user_cache_dir())+"/unity/";
+    if (!g_file_test((cache_dir+local::FIRST_RUN_STAMP).c_str(), G_FILE_TEST_EXISTS))
+    {
+      // We focus the panel, so the shortcut hint will be hidden at first user input
+      auto const& panels = panel_controller_->panels();
+      if (!panels.empty())
+      {
+        auto panel_win = static_cast<nux::BaseWindow*>(panels.front()->GetTopLevelViewWindow());
+        SaveInputThenFocus(panel_win->GetInputWindowId());
+      }
+      shortcut_controller_->first_run = true;
+      shortcut_controller_->Show();
+
+      if (g_mkdir_with_parents(cache_dir.c_str(), 0700) >= 0)
+      {
+        glib::Error error;
+        g_file_set_contents((cache_dir+local::FIRST_RUN_STAMP).c_str(), "", 0, &error);
+
+        if (error)
+        {
+          LOG_ERROR(logger) << "Impossible to save the unity stamp file: " << error;
+        }
+      }
+      else
+      {
+        LOG_ERROR(logger) << "Impossible to create unity cache folder!";
+      }
+    }
+    return false;
+  });
+}
+
 /* Window init */
 
 namespace
 
=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2014-03-07 03:37:43 +0000
+++ plugins/unityshell/src/unityshell.h	2014-03-12 23:00:55 +0000
@@ -109,6 +109,7 @@
   public ScreenInterface,
   public CompositeScreenInterface,
   public GLScreenInterface,
+  public ScaleScreenInterface,
   public BaseSwitchScreen,
   public PluginClassHandler <UnityScreen, CompScreen>,
   public CompAction::Container,
@@ -172,6 +173,9 @@
   void enterShowDesktopMode ();
   void leaveShowDesktopMode (CompWindow *w);
 
+   /* window scaling */
+  bool layoutSlotsAndAssignWindows();
+
   bool showMenuBarInitiate(CompAction* action, CompAction::State state, CompOption::Vector& options);
   bool showMenuBarTerminate(CompAction* action, CompAction::State state, CompOption::Vector& options);
   bool showLauncherKeyInitiate(CompAction* action, CompAction::State state, CompOption::Vector& options);
@@ -306,6 +310,8 @@
 
   void DamageBlurUpdateRegion(nux::Geometry const&);
 
+  void ShowFirstRunHints();
+
   std::unique_ptr<na::TickSource> tick_source_;
   std::unique_ptr<na::AnimationController> animation_controller_;
 
 
=== modified file 'shortcuts/ShortcutController.cpp'
--- shortcuts/ShortcutController.cpp	2013-11-20 21:39:40 +0000
+++ shortcuts/ShortcutController.cpp	2014-03-12 23:00:55 +0000
@@ -37,7 +37,8 @@
 
 Controller::Controller(BaseWindowRaiser::Ptr const& base_window_raiser,
                        AbstractModeller::Ptr const& modeller)
-  : modeller_(modeller)
+  : first_run(false)
+  , modeller_(modeller)
   , base_window_raiser_(base_window_raiser)
   , visible_(false)
   , enabled_(true)
@@ -155,6 +156,7 @@
   AddChild(view_.GetPointer());
   view_->SetModel(modeller_->GetCurrentModel());
   view_->background_color = WindowManager::Default().average_color();
+  view_->closable = first_run();
 
   if (!view_window_)
   {
@@ -197,6 +199,8 @@
   if (view_window_ && view_window_->GetOpacity() > 0.0f)
   {
     view_->live_background = false;
+    view_->closable = false;
+    first_run = false;
     animation::StartOrReverse(fade_animator_, animation::Direction::BACKWARD);
   }
 }
 
=== modified file 'shortcuts/ShortcutController.h'
--- shortcuts/ShortcutController.h	2013-11-14 00:17:19 +0000
+++ shortcuts/ShortcutController.h	2014-03-12 23:00:55 +0000
@@ -47,6 +47,8 @@
   Controller(BaseWindowRaiser::Ptr const& raiser, AbstractModeller::Ptr const& modeller);
   virtual ~Controller();
 
+  nux::Property<bool> first_run;
+
   bool Show();
   void Hide();
 
 
=== modified file 'tests/test_layout_system.cpp'
--- tests/test_layout_system.cpp	2013-10-14 17:36:51 +0000
+++ tests/test_layout_system.cpp	2014-03-12 23:00:55 +0000
@@ -57,6 +57,7 @@
   EXPECT_EQ(lwin.geo, fake_window->geo);
   EXPECT_EQ(lwin.decoration_height, 0);
   EXPECT_EQ(lwin.selected, false);
+  EXPECT_FLOAT_EQ(lwin.scale, 1.0f);
   EXPECT_EQ(lwin.aspect_ratio, fake_window->geo().width / static_cast<float>(fake_window->geo().height));
 }
 
 
=== modified file 'tests/test_shortcut_controller.cpp'
--- tests/test_shortcut_controller.cpp	2013-09-25 00:48:03 +0000
+++ tests/test_shortcut_controller.cpp	2014-03-12 23:00:55 +0000
@@ -68,6 +68,7 @@
     MOCK_METHOD1(SetOpacity, void(double));
     using Controller::GetOffsetPerMonitor;
     using Controller::ConstructView;
+    using Controller::OnShowTimer;
     using Controller::view_;
 
     void RealSetOpacity(double value)
@@ -188,5 +189,37 @@
   color_property.changed.emit(nux::color::RandomColor());
 }
 
+TEST_F(TestShortcutController, FirstRunFalse)
+{
+  ASSERT_FALSE(controller_.first_run());
+
+  controller_.ConstructView();
+  EXPECT_FALSE(controller_.view_->closable());
+}
+
+TEST_F(TestShortcutController, FirstRunTrue)
+{
+  ASSERT_FALSE(controller_.first_run());
+
+  controller_.first_run = true;
+  controller_.ConstructView();
+  EXPECT_TRUE(controller_.view_->closable());
+}
+
+TEST_F(TestShortcutController, UnsetFirstRunOnHide)
+{
+  controller_.first_run = true;
+  controller_.ConstructView();
+
+  ASSERT_TRUE(controller_.view_->closable());
+  controller_.Show();
+  controller_.OnShowTimer();
+  tick_source_.tick(100 * 1000);
+  controller_.Hide();
+
+  EXPECT_FALSE(controller_.first_run());
+  EXPECT_FALSE(controller_.view_->closable());
+}
+
 }
 }
 
=== modified file 'unity-shared/LayoutSystem.cpp'
--- unity-shared/LayoutSystem.cpp	2013-09-19 16:44:03 +0000
+++ unity-shared/LayoutSystem.cpp	2014-03-12 23:00:55 +0000
@@ -125,12 +125,12 @@
   for (LayoutWindow::Ptr const& window : row)
   {
     // we dont allow scaling up
-    float final_scalar = std::min(1.0f, (unpadded_bounds.height / (float)window->geo.height) * global_scalar);
+    window->scale = std::min(1.0f, (unpadded_bounds.height / (float)window->geo.height) * global_scalar);
 
     window->result.x = x;
     window->result.y = y;
-    window->result.width = window->geo.width * final_scalar;
-    window->result.height = window->geo.height * final_scalar;
+    window->result.width = window->geo.width * window->scale;
+    window->result.height = window->geo.height * window->scale;
 
     x += window->result.width;
   }
@@ -275,6 +275,7 @@
  , decoration_height(0)
  , selected(false)
  , aspect_ratio(geo.width / static_cast<float>(geo.height))
+ , scale(1.0f)
  , alpha(0.0f)
 {
   auto& wm = WindowManager::Default();
 
=== modified file 'unity-shared/LayoutSystem.h'
--- unity-shared/LayoutSystem.h	2013-09-19 16:44:03 +0000
+++ unity-shared/LayoutSystem.h	2014-03-12 23:00:55 +0000
@@ -46,6 +46,7 @@
 
   bool selected;
   float aspect_ratio;
+  float scale;
   float alpha;
 
 protected: