Merge lp:~gordallott/unity/more-dash-speedups into lp:unity

[Gord Allott]

two speedups, first the dash only draws the results that are physically on the screen, anything not expanded or scrolled off will not get drawn

secondly we only pre-load the majority of results when the result view is expanded.

I tried to make it work so that we only pre-loaded a few screens worth even then, but nux doesn't give you a nice way of knowing if you have been scrolled, so it just lead to lots of waiting around for icons to load, not fun

all in all we should be much nicer on your memory with this branch

[Mirco Müller (macslow)]

Very nice! Approved!

review: Approve

=== modified file 'plugins/unityshell/src/ResultRendererTile.cpp'
--- plugins/unityshell/src/ResultRendererTile.cpp	2011-09-05 00:46:13 +0000
+++ plugins/unityshell/src/ResultRendererTile.cpp	2011-09-08 09:40:25 +0000
@@ -75,6 +75,10 @@
                                 nux::Geometry& geometry,
                                 int x_offset, int y_offset)
 {
+  TextureContainer* container = row.renderer<TextureContainer*>();
+  if (container == nullptr)
+    return;
+
   std::string row_text = row.name;
   std::string row_iconhint = row.icon_hint;
   PlacesStyle* style = PlacesStyle::GetDefault();
@@ -99,8 +103,6 @@
                        geometry.height,
                        col);
 
-  TextureContainer* container = row.renderer<TextureContainer*>();
-
   if (container->blurred_icon)
   {
     GfxContext.QRP_1Tex(geometry.x + ((geometry.width - 58) / 2) - x_offset,
@@ -221,9 +223,12 @@
 
 void ResultRendererTile::Preload(Result& row)
 {
-  row.set_renderer(new TextureContainer());
-  LoadIcon(row);
-  LoadText(row);
+  if (row.renderer<TextureContainer*>() == nullptr)
+  {
+    row.set_renderer(new TextureContainer());
+    LoadIcon(row);
+    LoadText(row);
+  }
 }
 
 void ResultRendererTile::Unload(Result& row)

=== modified file 'plugins/unityshell/src/ResultViewGrid.cpp'
--- plugins/unityshell/src/ResultViewGrid.cpp	2011-09-08 03:04:04 +0000
+++ plugins/unityshell/src/ResultViewGrid.cpp	2011-09-08 09:40:25 +0000
@@ -52,6 +52,7 @@
   , active_index_(-1)
   , selected_index_(-1)
   , preview_row_(0)
+  , lazy_load_queued_(false)
   , last_mouse_down_x_(-1)
   , last_mouse_down_y_(-1)
 {
@@ -89,6 +90,66 @@
 {
 }
 
+gboolean ResultViewGrid::OnLazyLoad (gpointer data)
+{
+  ResultViewGrid *self = (ResultViewGrid*)data;
+  self->DoLazyLoad();
+  return FALSE;
+}
+
+void ResultViewGrid::QueueLazyLoad()
+{
+  if (lazy_load_queued_ == false)
+  {
+    g_timeout_add(0, (GSourceFunc)(&ResultViewGrid::OnLazyLoad), this);
+    lazy_load_queued_ = true;
+  }
+}
+
+void ResultViewGrid::DoLazyLoad()
+{
+  lazy_load_queued_ = false;
+  // FIXME - so this code was nice, it would only load the visible entries on the screen
+  // however nux does not give us a good enough indicator right now that we are scrolling,
+  // thus if you scroll more than a screen in one frame, you will end up with at least one frame where
+  // no icons are displayed (they have not been preloaded yet) - it sucked. we should fix this next cycle when we can break api
+  //~ int index = 0;
+//~
+  //~ ResultListBounds visible_bounds = GetVisableResults();
+  //~ int lower_bound = std::get<0>(visible_bounds);
+  //~ int upper_bound = std::get<1>(visible_bounds);
+//~
+  //~ ResultList::iterator it;
+  //~ for (it = results_.begin(); it != results_.end(); it++)
+  //~ {
+    //~ if (index >= lower_bound && index <= upper_bound)
+    //~ {
+      //~ renderer_->Preload((*it));
+    //~ }
+    //~ index++;
+  //~ }
+
+  // instead we will just pre-load all the items if expanded or just one row if not
+  int index = 0;
+  int items_per_row = GetItemsPerRow();
+  ResultList::iterator it;
+  for (it = results_.begin(); it != results_.end(); it++)
+  {
+    if ((!expanded && index < items_per_row) || expanded)
+    {
+      renderer_->Preload((*it));
+    }
+
+    if (!expanded && index >= items_per_row)
+      break; //early exit
+
+    index++;
+  }
+
+  QueueDraw();
+}
+
+
 int ResultViewGrid::GetItemsPerRow()
 {
   int items_per_row = (GetGeometry().width - (padding * 2)) / (renderer_->width + horizontal_spacing);
@@ -135,14 +196,18 @@
 
 void ResultViewGrid::AddResult(Result& result)
 {
-  ResultView::AddResult(result);
+  results_.push_back(result);
+
   SizeReallocate();
+  QueueLazyLoad();
+  NeedRedraw();
 }
 
 void ResultViewGrid::RemoveResult(Result& result)
 {
   ResultView::RemoveResult(result);
   SizeReallocate();
+  QueueLazyLoad();
 }
 
 void ResultViewGrid::SizeReallocate()
@@ -150,7 +215,7 @@
   //FIXME - needs to use the geometry assigned to it, but only after a layout
   int items_per_row = GetItemsPerRow();
 
-  int total_rows = (results_.size() / items_per_row);
+  int total_rows = (results_.size() / items_per_row) + 1;
   int total_height = 0;
 
   if (expanded)
@@ -401,11 +466,63 @@
 long ResultViewGrid::ComputeLayout2()
 {
   SizeReallocate();
+  QueueLazyLoad();
   long ret = ResultView::ComputeLayout2();
   return ret;
 
 }
 
+
+typedef std::tuple <int, int> ResultListBounds;
+ResultListBounds ResultViewGrid::GetVisableResults()
+{
+  int items_per_row = GetItemsPerRow();
+  int start, end;
+
+  if (!expanded)
+  {
+    // we are not expanded, so the bounds are known
+    start = 0;
+    end = items_per_row - 1;
+  }
+  else
+  {
+    //find the row we start at
+    int absolute_y = GetAbsoluteY();
+    uint row_size = renderer_->height + vertical_spacing;
+
+    if (absolute_y < 0)
+    {
+      // we are scrolled up a little,
+      int row_index = abs(absolute_y) / row_size;
+      start = row_index * items_per_row;
+    }
+    else
+    {
+      start = 0;
+    }
+
+    if (absolute_y + GetAbsoluteHeight() > GetToplevel()->GetAbsoluteHeight())
+    {
+      // our elements overflow the visable viewport
+      int visible_height = (GetToplevel()->GetAbsoluteHeight() - std::max(absolute_y, 0));
+      visible_height = std::min(visible_height, absolute_y + GetAbsoluteHeight());
+
+      int visible_rows = std::ceil(visible_height / static_cast<float>(row_size));
+      end = start + (visible_rows * items_per_row) + items_per_row;
+    }
+    else
+    {
+      end = results_.size() - 1;
+    }
+  }
+
+  start = std::max(start, 0);
+  end = std::min(end, static_cast<int>(results_.size()) - 1);
+
+  return ResultListBounds(start, end);
+}
+
 void ResultViewGrid::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
 {
   GfxContext.PushClippingRectangle(GetGeometry());
@@ -425,14 +542,13 @@
   int y_position = padding + GetGeometry().y;
   nux::Area* top_level_parent = GetToplevel();
 
+  ResultListBounds visible_bounds = GetVisableResults();
+
   for (uint row_index = 0; row_index <= total_rows; row_index++)
   {
-    // check if the row is displayed on the screen,
-    // FIXME - optimisation - replace 2048 with the height of the displayed viewport
-    // or at the very least, with the largest monitor resolution
-    //~ if ((y_position + renderer_->height) + absolute_y >= 0
-    //~ && (y_position - renderer_->height) + absolute_y <= top_level_parent->GetGeometry().height)
-    if (1)
+    int row_lower_bound = row_index * items_per_row;
+    if (row_lower_bound >= std::get<0>(visible_bounds) &&
+        row_lower_bound <= std::get<1>(visible_bounds))
     {
       int x_position = padding + GetGeometry().x;
       for (int column_index = 0; column_index < items_per_row; column_index++)

=== modified file 'plugins/unityshell/src/ResultViewGrid.h'
--- plugins/unityshell/src/ResultViewGrid.h	2011-08-31 23:28:44 +0000
+++ plugins/unityshell/src/ResultViewGrid.h	2011-09-08 09:40:25 +0000
@@ -53,7 +53,6 @@
   nux::Property<int> padding;
 
 
-
 protected:
   void MouseMove(int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags);
   void MouseClick(int x, int y, unsigned long button_flags, unsigned long key_flags);
@@ -76,6 +75,13 @@
   virtual long ComputeLayout2();
 
 private:
+  typedef std::tuple <int, int> ResultListBounds;
+  ResultListBounds GetVisableResults();
+
+  static gboolean OnLazyLoad (gpointer data);
+  void QueueLazyLoad();
+  void DoLazyLoad();
+
   int GetItemsPerRow();
   void SizeReallocate();
   void PositionPreview();
@@ -87,6 +93,7 @@
   uint preview_row_;
   std::string focused_uri_;
 
+  bool lazy_load_queued_;
   int last_mouse_down_x_;
   int last_mouse_down_y_;
   std::string current_drag_uri_;

=== modified file 'tests/TestResultView.cpp'
--- tests/TestResultView.cpp	2011-08-31 14:14:18 +0000
+++ tests/TestResultView.cpp	2011-09-08 09:40:25 +0000
@@ -88,6 +88,8 @@
     iters_.push_back(iter);
   }
 
+  DeeModelTag* tag = dee_model_register_tag(model_, NULL);
+
   LOG_DEBUG(logger) << "took " << (g_get_monotonic_time () - time_start) / 1000000.0f << " seconds to init dee";
   time_start = g_get_monotonic_time();
 
@@ -103,7 +105,7 @@
   std::vector<DeeModelIter*>::iterator it;
   for (it = iters_.begin(); it != iters_.end(); it++)
   {
-    unity::dash::Result* result = new unity::dash::Result(model_, (*it), NULL);
+    unity::dash::Result* result = new unity::dash::Result(model_, (*it), tag);
     result_view->AddResult (*result);
   }