Merge lp:~thumper/unity/launcher-messing-around into lp:unity

[Tim Penhey]

Unmerged revisions

2886. By Tim Penhey on 2012-11-11

Drag positions now correct.

2885. By Tim Penhey on 2012-11-11

Logging adjustments.

2884. By Tim Penhey on 2012-11-11

Positional expansion on mouse entry now working properly.

2883. By Tim Penhey on 2012-11-11

Fix the launcher drag values.

2882. By Tim Penhey on 2012-11-09

Sort of working...

2881. By Tim Penhey on 2012-11-08

Working but bouncing top folding.

2880. By Tim Penhey on 2012-11-08

Mostly working, has some jumping around though.

=== modified file 'launcher/Launcher.cpp'
--- launcher/Launcher.cpp	2012-11-08 09:12:24 +0000
+++ launcher/Launcher.cpp	2012-11-12 02:05:28 +0000
@@ -123,6 +123,7 @@
   , _initial_drag_animation(false)
   , _dash_is_open(false)
   , _hud_is_open(false)
+  , _draw_inverted(false)
   , _folded_angle(1.0f)
   , _neg_folded_angle(-1.0f)
   , _folded_z_distance(10.0f)
@@ -524,16 +525,27 @@
   if (anchor)
   {
     float position = y;
+    LOG_DEBUG(logger) << "y: " << y << ", entry_y: " << _enter_y
+          << ", geo.height: " << geo.height;
     for (AbstractLauncherIcon::Ptr const& model_icon : *_model)
     {
       if (model_icon == anchor)
       {
         position += _icon_size / 2;
-        _launcher_drag_delta = _enter_y - position;
+        LOG_DEBUG(logger) << "anchor: " << anchor->tooltip_text()
+          << ", position: " << position;
+        // TODO: log out the details here to figure out what is going on.
+        if (_draw_inverted)
+          _launcher_drag_delta = geo.height - _enter_y - position;
+        else
+          _launcher_drag_delta = _enter_y - position;
+        LOG_DEBUG(logger) << "ldd: " << _launcher_drag_delta;
 
         if (position + _icon_size / 2 + _launcher_drag_delta > geo.height)
+        {
           _launcher_drag_delta -= (position + _icon_size / 2 + _launcher_drag_delta) - geo.height;
-
+          LOG_DEBUG(logger) << "  adjusted ldd: " << _launcher_drag_delta;
+        }
         break;
       }
       position += (_icon_size + _space_between_icons) * IconVisibleProgress(model_icon, current);
@@ -866,14 +878,13 @@
 {
   SetupRenderArg(icon, current, arg);
 
-  // reset z
-  center.z = 0;
+  nux::Point3 local_center(center);
 
   float size_modifier = IconVisibleProgress(icon, current);
   if (size_modifier < 1.0f)
   {
     arg.alpha *= size_modifier;
-    center.z = 300.0f * (1.0f - size_modifier);
+    local_center.z = 300.0f * (1.0f - size_modifier);
   }
 
   float drop_dim_value = 0.2f + 0.8f * IconDropDimValue(icon, current);
@@ -907,46 +918,75 @@
     arg.skip = true;
 
   // goes for 0.0f when fully unfolded, to 1.0f folded
-  float folding_progress = CLAMP((center.y + _icon_size - folding_threshold) / (float) _icon_size, 0.0f, 1.0f);
+  float icon_size = _icon_size; // we want a float value for calculations.
+  // If the initial folding progress is negative, then there is no folding, if
+  // the value is between zero and icon size, then there is partial folding, and
+  // if the value is greater than icon_size, then the icon is considered fully
+  // folded.
+  float folding_progress = center.y + icon_size - folding_threshold;
+  folding_progress = CLAMP(folding_progress / icon_size, 0.0f, 1.0f);
   float present_progress = IconPresentProgress(icon, current);
 
   folding_progress *= 1.0f - present_progress;
 
-  float half_size = (folded_size / 2.0f) + (_icon_size / 2.0f - folded_size / 2.0f) * (1.0f - folding_progress);
+  // Now recalculate the icon_size based on the folding progress.
+  // This will give us a size between the folded_size and the icon_size
+  // based on the folding_progress value.
+  icon_size = folded_size + (icon_size - folded_size) * (1 - folding_progress);
+  // Update icon_size based on the size_modifier (appearing or disappearing)
+  icon_size *= size_modifier;
+  float half_size = icon_size / 2;
   float icon_hide_offset = autohide_offset;
 
   icon_hide_offset *= 1.0f - (present_progress * icon->PresentUrgency());
 
   // icon is crossing threshold, start folding
-  center.z += folded_z_distance * folding_progress;
+  local_center.z += folded_z_distance * folding_progress;
   arg.x_rotation = animation_neg_rads * folding_progress;
 
-  float spacing_overlap = CLAMP((float)(center.y + (2.0f * half_size * size_modifier) + (_space_between_icons * size_modifier) - folding_threshold) / (float) _icon_size, 0.0f, 1.0f);
+  float spacing_overlap = CLAMP((float)(center.y + icon_size + (_space_between_icons * size_modifier) - folding_threshold) / (float) _icon_size, 0.0f, 1.0f);
   float spacing = (_space_between_icons * (1.0f - spacing_overlap) + folded_spacing * spacing_overlap) * size_modifier;
 
   nux::Point3 centerOffset;
   float center_transit_progress = IconCenterTransitionProgress(icon, current);
+
+  local_center.y += half_size;   // move to center
+
+  if (_draw_inverted)
+  {
+    local_center.y = -local_center.y + parent_abs_geo.height;
+  }
+
   if (center_transit_progress <= 1.0f)
   {
     int saved_center = icon->GetSavedCenter(monitor).y - parent_abs_geo.y;
-    centerOffset.y = (saved_center - (center.y + (half_size * size_modifier))) * (1.0f - center_transit_progress);
+    centerOffset.y = (saved_center - local_center.y) * (1.0f - center_transit_progress);
   }
 
-  center.y += half_size * size_modifier;   // move to center
-
-  arg.render_center = nux::Point3(roundf(center.x + icon_hide_offset), roundf(center.y + centerOffset.y), roundf(center.z));
-  arg.logical_center = nux::Point3(roundf(center.x + icon_hide_offset), roundf(center.y), roundf(center.z));
-
-  icon->SetCenter(nux::Point3(roundf(center.x), roundf(center.y), roundf(center.z)), monitor, parent_abs_geo);
-
-  // FIXME: this is a hack, to avoid that we set the target to the end of the icon
-  if (!_initial_drag_animation && icon == _drag_icon && _drag_window && _drag_window->Animating())
+  arg.render_center = nux::Point3(roundf(local_center.x + icon_hide_offset),
+                                  roundf(local_center.y + centerOffset.y),
+                                  roundf(local_center.z));
+  arg.logical_center = nux::Point3(roundf(local_center.x + icon_hide_offset),
+                                   roundf(local_center.y),
+                                   roundf(local_center.z));
+
+  icon->SetCenter(nux::Point3(roundf(local_center.x),
+                              roundf(local_center.y),
+                              roundf(local_center.z)),
+                  monitor, parent_abs_geo);
+
+  // FIXME: this is a hack, to avoid that we set the target to the end of the
+  // icon
+  if (!_initial_drag_animation &&
+      icon == _drag_icon &&
+      _drag_window &&
+      _drag_window->Animating())
   {
     auto const& icon_center = _drag_icon->GetCenter(monitor);
     _drag_window->SetAnimationTarget(icon_center.x, icon_center.y);
   }
 
-  center.y += (half_size * size_modifier) + spacing;   // move to end
+  center.y += icon_size + spacing;   // move to end
 }
 
 float Launcher::DragLimiter(float x)
@@ -969,11 +1009,15 @@
 }
 
 void Launcher::RenderArgs(std::list<RenderArg> &launcher_args,
-                          nux::Geometry& box_geo, float* launcher_alpha, nux::Geometry const& parent_abs_geo)
+                          nux::Geometry& box_geo,
+                          float* launcher_alpha,
+                          nux::Geometry const& parent_abs_geo)
 {
+  LOG_TRACE_BLOCK(logger);
   nux::Geometry const& geo = GetGeometry();
+  LOG_TRACE(logger) << "Launcher geometry: Location(" << geo.x << ", " << geo.y
+      << "), Size(" << geo.width << ", " << geo.height << ")";
   LauncherModel::iterator it;
-  nux::Point3 center;
   struct timespec current;
   clock_gettime(CLOCK_MONOTONIC, &current);
 
@@ -989,9 +1033,18 @@
   float folded_size = _icon_size * folding_not_constant;
   float folded_spacing = _space_between_icons * folding_not_constant;
 
-  center.x = geo.width / 2;
-  center.y = _space_between_icons;
-  center.z = 0;
+  LOG_TRACE(logger) << "Render args:\n\thover_progress: " << hover_progress
+    << "\n\tfolded_z_distance: " << folded_z_distance
+    << "\n\tanimation_neg_rads: " << animation_neg_rads
+    << "\n\tfolding_constant: " << folding_constant
+    << "\n\tfolding_not_constant: " << folding_not_constant
+    << "\n\tfolded_size: " << folded_size
+    << "\n\tfolded_spacing: " << folded_spacing;
+
+
+  nux::Point3 center(geo.width / 2,
+                     _space_between_icons,
+                     0);
 
   int launcher_height = geo.height;
 
@@ -1000,14 +1053,26 @@
   float folding_threshold = launcher_height - _icon_size / 2.5f;
   for (it = _model->begin(); it != _model->end(); ++it)
   {
-    float height = (_icon_size + _space_between_icons) * IconVisibleProgress(*it, current);
+    float height = (_icon_size + _space_between_icons) * 
+                   IconVisibleProgress(*it, current);
     sum += height;
 
-    // magic constant must some day be explained, for now suffice to say this constant prevents the bottom from "marching";
+    // magic constant must some day be explained, for now suffice to say this
+    // constant prevents the bottom from "marching";
     float magic_constant = 1.3f;
 
     float present_progress = IconPresentProgress(*it, current);
-    folding_threshold -= CLAMP(sum - launcher_height, 0.0f, height * magic_constant) * (folding_constant + (1.0f - folding_constant) * present_progress);
+    folding_threshold -= CLAMP(sum - launcher_height,
+                               0.0f,
+                               height * magic_constant) *
+                         (folding_constant + 
+                           (1.0f - folding_constant) * present_progress);
+
+    LOG_TRACE(logger) << "iter through icons:" 
+      << "\n\ticon: " << (*it)->tooltip_text()
+      << "\n\tsum: " << sum 
+      << "\n\tpresent_progress: " << present_progress
+      << "\n\tfolding_threshold: " << folding_threshold;
   }
 
   if (sum - _space_between_icons <= launcher_height)
@@ -1015,7 +1080,8 @@
 
   float autohide_offset = 0.0f;
   *launcher_alpha = 1.0f;
-  if (options()->hide_mode != LAUNCHER_HIDE_NEVER || _hide_machine.GetQuirk(LauncherHideMachine::LOCK_HIDE))
+  if (options()->hide_mode != LAUNCHER_HIDE_NEVER ||
+      _hide_machine.GetQuirk(LauncherHideMachine::LOCK_HIDE))
   {
 
     float autohide_progress = AutohideProgress(current) * (1.0f - DragOutProgress(current));
@@ -1057,15 +1123,30 @@
    */
   static nux::Geometry last_geo = box_geo;
 
-  // this happens on hover, basically its a flag and a value in one, we translate this into a dnd offset
-  if (_enter_y != 0 && _enter_y + _icon_size / 2 > folding_threshold)
-    SetDndDelta(last_geo.x + last_geo.width / 2, center.y, geo, current);
-
+  // This happens on hover, basically its a flag and a value in one, we
+  // translate this into a dnd offset.  The idea here is that if the mouse
+  // entered in the folding area, then expand that area.
+  // NOTE: _entry_y is being used as both a flag and a value.  This means that
+  // if the launcher is being drawn inverted, and the mouse enters from the top
+  // the dnd delta is not set.
+  if (_enter_y != 0)
+  {
+    // If we are folding at the top, we do this by reversing the positions of
+    // everything when determining rendering position. This means that in order
+    // to determine if we are entering a folded area, we need to fake the entry
+    // position.
+    auto entry_position = _enter_y + _icon_size / 2;
+    if (_draw_inverted)
+    {
+      entry_position = geo.height - entry_position + _icon_size;
+    }
+    if (entry_position > folding_threshold)
+      SetDndDelta(last_geo.x + last_geo.width / 2, center.y, geo, current);
+  }
   // Update the last_geo value.
   last_geo = box_geo;
   _enter_y = 0;
 
-  
   // logically dnd exit only restores to the clamped ranges
   // hover_progress restores to 0
   _launcher_drag_delta_max = 0.0f;
@@ -1102,18 +1183,28 @@
     _launcher_drag_delta = 0;
   }
 
-  // The functional position we wish to represent for these icons is not smooth. Rather than introducing
-  // special casing to represent this, we use MIN/MAX functions. This helps ensure that even though our
-  // function is not smooth it is continuous, which is more important for our visual representation (icons
-  // wont start jumping around).  As a general rule ANY if () statements that modify center.y should be seen
-  // as bugs.
+  // The functional position we wish to represent for these icons is not smooth.
+  // Rather than introducing special casing to represent this, we use MIN/MAX
+  // functions. This helps ensure that even though our function is not smooth it
+  // is continuous, which is more important for our visual representation (icons
+  // wont start jumping around).  As a general rule ANY if () statements that
+  // modify center.y should be seen as bugs.
   int index = 1;
   for (it = _model->main_begin(); it != _model->main_end(); ++it)
   {
     RenderArg arg;
     AbstractLauncherIcon::Ptr const& icon = *it;
-    FillRenderArg(icon, arg, center, parent_abs_geo, folding_threshold, folded_size, folded_spacing,
-                  autohide_offset, folded_z_distance, animation_neg_rads, current);
+    FillRenderArg(icon,
+                  arg,
+                  center, 
+                  parent_abs_geo, 
+                  folding_threshold, 
+                  folded_size, 
+                  folded_spacing,
+                  autohide_offset, 
+                  folded_z_distance, 
+                  animation_neg_rads, 
+                  current);
     arg.colorify = colorify;
     launcher_args.push_back(arg);
     index++;
@@ -1125,13 +1216,23 @@
   {
     float height = (_icon_size + _space_between_icons) * IconVisibleProgress(*it, current);
     shelf_sum += height;
+
+//    LOG_TRACE(logger) << "iter through shelf icons:" 
+//      << "\n\ticon: " << (*it)->tooltip_text()
+//      << "\n\tshelf_sum: " << shelf_sum;
   }
 
   // add bottom padding
   if (shelf_sum > 0.0f)
     shelf_sum += _space_between_icons;
 
+  // The whole point of the shelf_delta is to push the shelf down to the
+  // bottom of the launcher, so the trash (in almost all cases) is rendered
+  // at the bottom of the screen.
   float shelf_delta = MAX(((launcher_height - shelf_sum) + _space_between_icons) - center.y, 0.0f);
+  //LOG_DEBUG(logger) << "lh: " << launcher_height << ", ss: " << shelf_sum
+  //                  << ", c.y: " << center.y
+  //                 << ", shelf_delta: " << shelf_delta;
   folding_threshold += shelf_delta;
   center.y += shelf_delta;
 
@@ -1433,11 +1534,22 @@
   UpdateOptions(options());
 }
 
+void Launcher::SetDrawInverted(bool inverted)
+{
+  if (inverted == _draw_inverted)
+    return;
+
+  _draw_inverted = inverted;
+  _folded_angle *= -1;
+  _neg_folded_angle *= -1;
+}
+
 void Launcher::UpdateOptions(Options::Ptr options)
 {
+  LOG_DEBUG_BLOCK(logger);
   SetIconSize(options->tile_size, options->icon_size);
   SetHideMode(options->hide_mode);
-
+  SetDrawInverted(options->fold_behaviour != FOLD_AT_BOTTOM);
   ConfigureBarrier();
   EnsureAnimation();
 }
@@ -1555,7 +1667,7 @@
 bool Launcher::OnScrollTimeout()
 {
   bool continue_animation = true;
-
+  int drag_delta = 0;
   if (IsInKeyNavMode() || !_hovered ||
       GetActionState() == ACTION_DRAG_LAUNCHER)
   {
@@ -1563,27 +1675,31 @@
   }
   else if (MouseOverTopScrollArea())
   {
-    if (_launcher_drag_delta >= _launcher_drag_delta_max)
+    if ((!_draw_inverted && _launcher_drag_delta >= _launcher_drag_delta_max) ||
+        (_draw_inverted && _launcher_drag_delta <= _launcher_drag_delta_min))
       continue_animation = false;
     else if (MouseOverTopScrollExtrema())
-      _launcher_drag_delta += 6;
+      drag_delta = 6;
     else
-      _launcher_drag_delta += 3;
+      drag_delta = 3;
   }
   else if (MouseOverBottomScrollArea())
   {
-    if (_launcher_drag_delta <= _launcher_drag_delta_min)
+    if ((!_draw_inverted && _launcher_drag_delta <= _launcher_drag_delta_min) ||
+        (_draw_inverted && _launcher_drag_delta >= _launcher_drag_delta_max))
       continue_animation = false;
     else if (MouseOverBottomScrollExtrema())
-      _launcher_drag_delta -= 6;
+      drag_delta = -6;
     else
-      _launcher_drag_delta -= 3;
+      drag_delta = -3;
   }
   else
   {
     continue_animation = false;
   }
-
+  if (_draw_inverted)
+    drag_delta *= -1;
+  _launcher_drag_delta += drag_delta;
   if (continue_animation)
   {
     EnsureAnimation();
@@ -1639,6 +1755,16 @@
   ConfigureBarrier();
 }
 
+void Launcher::SetHeight(int height)
+{
+  int width = _icon_size + ICON_PADDING*2 + RIGHT_LINE_WIDTH - 2;
+  nux::Geometry new_geometry(0, 0, width, height);
+  SetMaximumHeight(new_geometry.height);
+  _parent->SetGeometry(new_geometry);
+  SetGeometry(new_geometry);
+}
+
+
 void Launcher::OnIconAdded(AbstractLauncherIcon::Ptr const& icon)
 {
   EnsureAnimation();
@@ -1731,6 +1857,24 @@
 
 }
 
+void Launcher::DrawFromRenderArg(RenderArg const& arg,
+                                 nux::GraphicsEngine& GfxContext,
+                                 nux::Geometry const& base,
+                                 nux::Geometry const& bkg_box)
+{
+  if (arg.stick_thingy)
+    gPainter.Paint2DQuadColor(GfxContext,
+                              nux::Geometry(bkg_box.x,
+                                            arg.render_center.y - 3,
+                                            bkg_box.width,
+                                            2),
+                              nux::Color(0xAAAAAAAA));
+  if (arg.skip)
+    return;
+
+  icon_renderer->RenderIcon(GfxContext, arg, bkg_box, base);
+}
+
 void Launcher::DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw)
 {
   icon_renderer->monitor = monitor();
@@ -1816,49 +1960,49 @@
 
       if (BackgroundEffectHelper::blur_type != unity::BLUR_NONE && (bkg_box.x + bkg_box.width > 0))
       {
-	blur_texture = bg_effect_helper_.GetBlurRegion(blur_geo);
+        blur_texture = bg_effect_helper_.GetBlurRegion(blur_geo);
       }
       else
       {
-	blur_texture = bg_effect_helper_.GetRegion(blur_geo);
+        blur_texture = bg_effect_helper_.GetRegion(blur_geo);
       }
 
       if (blur_texture.IsValid())
       {
-	nux::TexCoordXForm texxform_blur_bg;
-	texxform_blur_bg.flip_v_coord = true;
-	texxform_blur_bg.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
-	texxform_blur_bg.uoffset = ((float) base.x) / geo_absolute.width;
-	texxform_blur_bg.voffset = ((float) base.y) / geo_absolute.height;
+        nux::TexCoordXForm texxform_blur_bg;
+        texxform_blur_bg.flip_v_coord = true;
+        texxform_blur_bg.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
+        texxform_blur_bg.uoffset = ((float) base.x) / geo_absolute.width;
+        texxform_blur_bg.voffset = ((float) base.y) / geo_absolute.height;
 
-	GfxContext.PushClippingRectangle(bkg_box);
+        GfxContext.PushClippingRectangle(bkg_box);
 
 #ifndef NUX_OPENGLES_20
-	if (GfxContext.UsingGLSLCodePath())
-	  gPainter.PushDrawCompositionLayer(GfxContext, base,
-					    blur_texture,
-					    texxform_blur_bg,
-					    nux::color::White,
-					    _background_color, nux::LAYER_BLEND_MODE_OVERLAY,
-					    true, ROP);
-	else
-	  gPainter.PushDrawTextureLayer(GfxContext, base,
-					blur_texture,
-					texxform_blur_bg,
-					nux::color::White,
-					true,
-					ROP);
+        if (GfxContext.UsingGLSLCodePath())
+          gPainter.PushDrawCompositionLayer(GfxContext, base,
+                                            blur_texture,
+                                            texxform_blur_bg,
+                                            nux::color::White,
+                                            _background_color, nux::LAYER_BLEND_MODE_OVERLAY,
+                                            true, ROP);
+        else
+          gPainter.PushDrawTextureLayer(GfxContext, base,
+                                        blur_texture,
+                                        texxform_blur_bg,
+                                        nux::color::White,
+                                        true,
+                                        ROP);
 #else
-	  gPainter.PushDrawCompositionLayer(GfxContext, base,
-					    blur_texture,
-					    texxform_blur_bg,
-					    nux::color::White,
-					    _background_color, nux::LAYER_BLEND_MODE_OVERLAY,
-					    true, ROP);
+        gPainter.PushDrawCompositionLayer(GfxContext, base,
+                                          blur_texture,
+                                          texxform_blur_bg,
+                                          nux::color::White,
+                                          _background_color, nux::LAYER_BLEND_MODE_OVERLAY,
+                                          true, ROP);
 #endif
-	GfxContext.PopClippingRectangle();
+        GfxContext.PopClippingRectangle();
 
-	push_count++;
+        push_count++;
       }
 
       unsigned int alpha = 0, src = 0, dest = 0;
@@ -1872,7 +2016,7 @@
       // apply the bg colour
 #ifndef NUX_OPENGLES_20
       if (GfxContext.UsingGLSLCodePath() == false)
-	gPainter.Paint2DQuadColor(GfxContext, bkg_box, _background_color);
+        gPainter.Paint2DQuadColor(GfxContext, bkg_box, _background_color);
 #endif
 
       // apply the shine
@@ -1883,9 +2027,9 @@
       texxform.uoffset = (1.0f / launcher_sheen_->GetWidth()); // TODO (gord) don't use absolute values here
       texxform.voffset = (1.0f / launcher_sheen_->GetHeight()) * panel::Style::Instance().panel_height;
       GfxContext.QRP_1Tex(base.x, base.y, base.width, base.height,
-			  launcher_sheen_->GetDeviceTexture(),
-			  texxform,
-			  nux::color::White);
+                          launcher_sheen_->GetDeviceTexture(),
+                          texxform,
+                          nux::color::White);
 
       //reset the blend state
       GfxContext.GetRenderStates().SetBlend (alpha, src, dest);
@@ -1903,19 +2047,16 @@
   icon_renderer->PreprocessIcons(args, base);
   EventLogic();
 
-  /* draw launcher */
-  for (rev_it = args.rbegin(); rev_it != args.rend(); ++rev_it)
-  {
-    if ((*rev_it).stick_thingy)
-      gPainter.Paint2DQuadColor(GfxContext,
-                                nux::Geometry(bkg_box.x, (*rev_it).render_center.y - 3, bkg_box.width, 2),
-                                nux::Color(0xAAAAAAAA));
-
-    if ((*rev_it).skip)
-      continue;
-
-    icon_renderer->RenderIcon(GfxContext, *rev_it, bkg_box, base);
-  }
+  // Draw the launcher from the bottom up if folding at the bottom,
+  // and from the top down if folding at the top.
+  //if (options()->fold_behaviour == FOLD_AT_BOTTOM)
+    for (rev_it = args.rbegin(); rev_it != args.rend(); ++rev_it)
+    {
+      DrawFromRenderArg(*rev_it, GfxContext, base, bkg_box);
+    }
+  //else
+    //for (auto& arg : args)
+      //DrawFromRenderArg(arg, GfxContext, base, bkg_box);
 
   if (!IsOverlayOpen())
   {
@@ -2130,9 +2271,11 @@
   struct timespec current;
   clock_gettime(CLOCK_MONOTONIC, &current);
   float progress = DragThresholdProgress(current);
-
+  LOG_DEBUG(logger) << "Update drag (" << x << ", " << y
+    << "), progress: " << progress;
   if (hovered_icon && _drag_icon != hovered_icon)
   {
+    LOG_DEBUG(logger) << "  hovered_icon: " << hovered_icon->tooltip_text();
     if (progress >= 1.0f)
     {
       _model->ReorderSmart(_drag_icon, hovered_icon, true);
@@ -2154,6 +2297,7 @@
 
       if (y >= icon->GetCenter(monitor).y)
       {
+        LOG_DEBUG(logger) << "  icon: " << icon->tooltip_text();
         _model->ReorderAfter(_drag_icon, icon);
         break;
       }
@@ -2210,6 +2354,9 @@
   _dnd_delta_y += dy;
   _dnd_delta_x += dx;
 
+  //LOG_DEBUG(logger) << "Drag: dy: " << dy << ", _dnd_delta_y:" << _dnd_delta_y
+  //  << ", ldd: " << _launcher_drag_delta;
+
   if (nux::Abs(_dnd_delta_y) < MOUSE_DEADZONE &&
       nux::Abs(_dnd_delta_x) < MOUSE_DEADZONE &&
       GetActionState() == ACTION_NONE)
@@ -2226,7 +2373,10 @@
 #ifdef UNITY_HAS_X_ORG_SUPPORT
     if (nux::Abs(_dnd_delta_y) >= nux::Abs(_dnd_delta_x))
     {
-      _launcher_drag_delta += _dnd_delta_y;
+      if (_draw_inverted)
+        _launcher_drag_delta -= _dnd_delta_y;
+      else
+        _launcher_drag_delta += _dnd_delta_y;
       SetActionState(ACTION_DRAG_LAUNCHER);
       _hide_machine.SetQuirk(LauncherHideMachine::VERTICAL_SLIDE_ACTIVE, true);
     }
@@ -2240,7 +2390,10 @@
   }
   else if (GetActionState() == ACTION_DRAG_LAUNCHER)
   {
-    _launcher_drag_delta += dy;
+    if (_draw_inverted)
+      _launcher_drag_delta -= dy;
+    else
+      _launcher_drag_delta += dy;
     ubus_.SendMessage(UBUS_LAUNCHER_END_DND);
   }
   else if (GetActionState() == ACTION_DRAG_ICON)
@@ -2283,18 +2436,20 @@
 {
   if (!_hovered)
     return;
-
+  int value = 0;
   if (wheel_delta < 0)
   {
     // scroll up
-    _launcher_drag_delta -= 25;
+    value = -25;
   }
   else
   {
     // scroll down
-    _launcher_drag_delta += 25;
+     value = 25;
   }
-
+  if (_draw_inverted)
+    value *= -1;
+  _launcher_drag_delta += value;
   EnsureAnimation();
 }
 
@@ -2472,25 +2627,31 @@
 
   for (it = _model->begin(); it != _model->end(); ++it)
   {
-    if (!(*it)->IsVisible() || !(*it)->IsVisibleOnMonitor(monitor))
+    AbstractLauncherIcon::Ptr const& icon = *it;
+    if (!icon->IsVisible() || !icon->IsVisibleOnMonitor(monitor))
       continue;
 
     nux::Point2 screen_coord [4];
+    auto hit_transform = icon->GetTransform(AbstractLauncherIcon::TRANSFORM_HIT_AREA, monitor);
     for (int i = 0; i < 4; ++i)
     {
-      auto hit_transform = (*it)->GetTransform(AbstractLauncherIcon::TRANSFORM_HIT_AREA, monitor);
       screen_coord [i].x = hit_transform [i].x;
       screen_coord [i].y = hit_transform [i].y;
     }
     inside = PointInside2DPolygon(screen_coord, 4, mouse_position, 1);
     if (inside)
-      return (*it);
+    {
+      LOG_TRACE(logger) << "Hit " << icon->tooltip_text();
+      return icon;
+    }
   }
 
   return AbstractLauncherIcon::Ptr();
 }
 
-void Launcher::RenderIconToTexture(nux::GraphicsEngine& GfxContext, AbstractLauncherIcon::Ptr const& icon, nux::ObjectPtr<nux::IOpenGLBaseTexture> texture)
+void Launcher::RenderIconToTexture(nux::GraphicsEngine& GfxContext,
+                                   AbstractLauncherIcon::Ptr const& icon,
+                                   nux::ObjectPtr<nux::IOpenGLBaseTexture> texture)
 {
   RenderArg arg;
   struct timespec current;

=== modified file 'launcher/Launcher.h'
--- launcher/Launcher.h	2012-11-06 18:19:09 +0000
+++ launcher/Launcher.h	2012-11-12 02:05:28 +0000
@@ -123,6 +123,7 @@
   int GetMouseY() const;
 
   void Resize();
+  void SetHeight(int height);
 
   int GetDragDelta() const;
   void SetHover(bool hovered);
@@ -257,6 +258,7 @@
   float IconVisibleProgress(AbstractLauncherIcon::Ptr const& icon, struct timespec const& current) const;
 
   void SetHidden(bool hidden);
+  void SetDrawInverted(bool inverted);
 
   void UpdateChangeInMousePosition(int delta_x, int delta_y);
 
@@ -279,6 +281,11 @@
   void RenderArgs(std::list<ui::RenderArg> &launcher_args,
                   nux::Geometry& box_geo, float* launcher_alpha, nux::Geometry const& parent_abs_geo);
 
+  void DrawFromRenderArg(ui::RenderArg const& arg,
+                         nux::GraphicsEngine& GfxContext,
+                         nux::Geometry const& base,
+                         nux::Geometry const& bkg_box);
+
   void OnIconAdded(AbstractLauncherIcon::Ptr const& icon);
   void OnIconRemoved(AbstractLauncherIcon::Ptr const& icon);
   void OnOrderChanged();
@@ -348,6 +355,7 @@
   bool _initial_drag_animation;
   bool _dash_is_open;
   bool _hud_is_open;
+  bool _draw_inverted;
 
   float _folded_angle;
   float _neg_folded_angle;

=== modified file 'launcher/LauncherHoverMachine.h'
--- launcher/LauncherHoverMachine.h	2012-10-10 22:33:14 +0000
+++ launcher/LauncherHoverMachine.h	2012-11-12 02:05:28 +0000
@@ -29,7 +29,7 @@
 {
 public:
 
-  typedef enum
+  enum HoverQuirk
   {
     DEFAULT                = 0,
     LAUNCHER_HIDDEN        = 1 << 0,
@@ -39,7 +39,7 @@
     KEY_NAV_ACTIVE         = 1 << 4,
     LAUNCHER_IN_ACTION     = 1 << 5,
     PLACES_VISIBLE         = 1 << 6,
-  } HoverQuirk;
+  };
 
   LauncherHoverMachine();
 

=== modified file 'launcher/LauncherModel.cpp'
--- launcher/LauncherModel.cpp	2012-10-11 01:44:15 +0000
+++ launcher/LauncherModel.cpp	2012-11-12 02:05:28 +0000
@@ -19,6 +19,8 @@
  */
 
 #include "LauncherModel.h"
+
+#include <NuxCore/Logger.h>
 #include "AbstractLauncherIcon.h"
 
 #include <UnityCore/GLibWrapper.h>
@@ -28,6 +30,7 @@
 {
 namespace launcher
 {
+DECLARE_LOGGER(logger, "unity.launcher.model");
 
 LauncherModel::LauncherModel()
   : selection_(0)

=== modified file 'launcher/LauncherOptions.cpp'
--- launcher/LauncherOptions.cpp	2012-08-30 18:14:19 +0000
+++ launcher/LauncherOptions.cpp	2012-11-12 02:05:28 +0000
@@ -33,6 +33,7 @@
   , auto_hide_animation(FADE_AND_SLIDE)
   , backlight_mode(BACKLIGHT_NORMAL)
   , reveal_trigger(RevealTrigger::EDGE)
+  , fold_behaviour(FOLD_AT_BOTTOM)
   , icon_size(48)
   , tile_size(54)
   , background_alpha(0.6667)
@@ -54,6 +55,7 @@
   edge_reveal_pressure.changed.connect   ([this] (int value)               { option_changed.emit(); });
   edge_stop_velocity.changed.connect     ([this] (int value)               { option_changed.emit(); });
   edge_passed_disabled_ms.changed.connect([this] (unsigned value)          { option_changed.emit(); });
+  fold_behaviour.changed.connect         ([this] (FoldBehaviour value)     { option_changed.emit(); });
   hide_mode.changed.connect              ([this] (LauncherHideMode value)  { option_changed.emit(); });
   icon_size.changed.connect              ([this] (int value)               { option_changed.emit(); });
   launch_animation.changed.connect       ([this] (LaunchAnimation value)   { option_changed.emit(); });

=== modified file 'launcher/LauncherOptions.h'
--- launcher/LauncherOptions.h	2012-08-07 10:53:16 +0000
+++ launcher/LauncherOptions.h	2012-11-12 02:05:28 +0000
@@ -76,6 +76,12 @@
   CORNER,
 };
 
+enum FoldBehaviour
+{
+  FOLD_AT_BOTTOM,
+  FOLD_AT_TOP,
+};
+
 class Options : public sigc::trackable
 {
 public:
@@ -89,6 +95,7 @@
   nux::Property<AutoHideAnimation> auto_hide_animation;
   nux::Property<BacklightMode> backlight_mode;
   nux::Property<RevealTrigger> reveal_trigger;
+  nux::Property<FoldBehaviour> fold_behaviour;
   nux::Property<int> icon_size;
   nux::Property<int> tile_size;
   nux::Property<float> background_alpha;

=== modified file 'launcher/StandaloneLauncher.cpp'
--- launcher/StandaloneLauncher.cpp	2012-10-17 22:16:48 +0000
+++ launcher/StandaloneLauncher.cpp	2012-11-12 02:05:28 +0000
@@ -18,7 +18,9 @@
  *
  */
 
-#include "Nux/Nux.h"
+#include <memory>
+#include <Nux/Nux.h>
+#include <NuxCore/Logger.h>
 #include <gtk/gtk.h>
 
 #include "unity-shared/BackgroundEffectHelper.h"
@@ -31,32 +33,65 @@
 
 using namespace unity;
 
-static launcher::Controller::Ptr controller;
-
-void ThreadWidgetInit(nux::NThread* thread, void* InitData)
+class StandaloneLauncher
 {
-//  launcherWindow->SetGeometry (nux::Geometry(0, 0, 300, 800));
-  controller.reset(new launcher::Controller());
-}
+public:
+  StandaloneLauncher(std::string const& param)
+  : top_fold(param == "top")
+  {
+  }
+
+  void OnWindowGeometryChanged(int, int, int, int height)
+  {
+    controller->launcher().SetHeight(height);
+  }
+
+  static void ThreadInit(nux::NThread* , void* data)
+  {
+    StandaloneLauncher* self = static_cast<StandaloneLauncher*>(data);
+    self->controller.reset(new launcher::Controller());
+    auto& launcher = self->controller->launcher();
+    launcher.SetHeight(800);
+    if (self->top_fold)
+      launcher.options()->fold_behaviour = launcher::FOLD_AT_TOP;
+  }
+
+private:
+  bool top_fold;
+  launcher::Controller::Ptr controller;
+};
+
 
 int main(int argc, char** argv)
 {
   g_type_init();
   gtk_init(&argc, &argv);
   nux::NuxInitialize(0);
+  nux::logging::configure_logging(::getenv("UNITY_LOG_SEVERITY"));
 
   unity::Settings settings;
   panel::Style panel_style;
   internal::FavoriteStoreGSettings favorite_store;
 
   BackgroundEffectHelper::blur_type = BLUR_NONE;
-  nux::WindowThread* wt = nux::CreateGUIThread(TEXT("Unity Switcher"), 300, 800, 0, &ThreadWidgetInit, 0);
-
-  wt->Run(NULL);
+  std::unique_ptr<nux::WindowThread> wt;
+  {
+    std::string arg;
+    if (argc > 1)
+      arg = argv[1];
+    StandaloneLauncher standalone_launcher(arg);
+    wt.reset(
+      nux::CreateGUIThread("Unity Launcher",
+                         300, 800, 0,
+                         &StandaloneLauncher::ThreadInit,
+                         &standalone_launcher));
+    wt->window_configuration.connect(
+      sigc::mem_fun(&standalone_launcher,
+                    &StandaloneLauncher::OnWindowGeometryChanged));
+    wt->Run(NULL);
+  }
   // Make sure the controller is destroyed before the window thread.
-  controller.reset();
   ::unity::ui::IconRenderer::DestroyTextures();
 
-  delete wt;
   return 0;
 }