Revise the shelf alignment locking mechanism.

ash/wm/panels/panel_layout_manager.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ash/wm/panels/panel_layout_manager.h"
 
 #include <algorithm>
 #include <map>
 #include <utility>
 
@@ skipping 52 matching lines @@
 
 class CalloutWidgetBackground : public views::Background {
  public:
   CalloutWidgetBackground() : alignment_(SHELF_ALIGNMENT_BOTTOM) {
   }
 
   void Paint(gfx::Canvas* canvas, views::View* view) const override {
     SkPath path;
     switch (alignment_) {
       case SHELF_ALIGNMENT_BOTTOM:
+      case SHELF_ALIGNMENT_BOTTOM_LOCKED:
         path.moveTo(SkIntToScalar(0), SkIntToScalar(0));
         path.lineTo(SkIntToScalar(kArrowWidth / 2),
                     SkIntToScalar(kArrowHeight));
         path.lineTo(SkIntToScalar(kArrowWidth), SkIntToScalar(0));
         break;
       case SHELF_ALIGNMENT_LEFT:
         path.moveTo(SkIntToScalar(kArrowHeight), SkIntToScalar(kArrowWidth));
         path.lineTo(SkIntToScalar(0), SkIntToScalar(kArrowWidth / 2));
         path.lineTo(SkIntToScalar(kArrowHeight), SkIntToScalar(0));
         break;
       case SHELF_ALIGNMENT_RIGHT:
         path.moveTo(SkIntToScalar(0), SkIntToScalar(0));
         path.lineTo(SkIntToScalar(kArrowHeight),
                     SkIntToScalar(kArrowWidth / 2));
         path.lineTo(SkIntToScalar(0), SkIntToScalar(kArrowWidth));
         break;
     }
     // Hard code the arrow color for now.
     SkPaint paint;
     paint.setStyle(SkPaint::kFill_Style);
     paint.setColor(SkColorSetARGB(0xff, 0xe5, 0xe5, 0xe5));
     canvas->DrawPath(path, paint);
   }
 
-  ShelfAlignment alignment() {
-    return alignment_;
-  }
+  ShelfAlignment alignment() { return alignment_; }
 
-  void set_alignment(ShelfAlignment alignment) {
-    alignment_ = alignment;
-  }
+  void set_alignment(ShelfAlignment alignment) { alignment_ = alignment; }
 
  private:
   ShelfAlignment alignment_;
 
   DISALLOW_COPY_AND_ASSIGN(CalloutWidgetBackground);
 };
 
 struct VisiblePanelPositionInfo {
   VisiblePanelPositionInfo()
       : min_major(0),
@@ skipping 58 matching lines @@
 
 bool BoundsAdjacent(const gfx::Rect& bounds1, const gfx::Rect& bounds2) {
   return bounds1.x() == bounds2.right() ||
          bounds1.y() == bounds2.bottom() ||
          bounds1.right() == bounds2.x() ||
          bounds1.bottom() == bounds2.y();
 }
 
 gfx::Vector2d GetSlideInAnimationOffset(ShelfAlignment alignment) {
   gfx::Vector2d offset;
-  switch (alignment) {
-    case SHELF_ALIGNMENT_BOTTOM:
-      offset.set_y(kPanelSlideInOffset);
-      break;
-    case SHELF_ALIGNMENT_LEFT:
-      offset.set_x(-kPanelSlideInOffset);
-      break;
-    case SHELF_ALIGNMENT_RIGHT:
-      offset.set_x(kPanelSlideInOffset);
-      break;
-  }
+  if (alignment == SHELF_ALIGNMENT_LEFT)
+    offset.set_x(-kPanelSlideInOffset);
+  else if (alignment == SHELF_ALIGNMENT_RIGHT)
+    offset.set_x(kPanelSlideInOffset);
+  else
+    offset.set_y(kPanelSlideInOffset);
   return offset;
 }
 
 }  // namespace
 
 class PanelCalloutWidget : public views::Widget {
  public:
   explicit PanelCalloutWidget(aura::Window* container)
       : background_(NULL) {
     InitWidget(container);
   }
 
   void SetAlignment(ShelfAlignment alignment) {
     gfx::Rect callout_bounds = GetWindowBoundsInScreen();
-    if (alignment == SHELF_ALIGNMENT_BOTTOM) {
+    if (IsHorizontalAlignment(alignment)) {
       callout_bounds.set_width(kArrowWidth);
       callout_bounds.set_height(kArrowHeight);
     } else {
       callout_bounds.set_width(kArrowHeight);
       callout_bounds.set_height(kArrowWidth);
     }
     GetNativeWindow()->SetBounds(callout_bounds);
     if (background_->alignment() != alignment) {
       background_->set_alignment(alignment);
       SchedulePaintInRect(gfx::Rect(gfx::Point(), callout_bounds.size()));
@@ skipping 479 matching lines @@
     }
   }
   FanOutPanels(visible_panels.begin() + first_overlapping_panel,
                visible_panels.end());
 
   for (size_t i = 0; i < visible_panels.size(); ++i) {
     if (visible_panels[i].window == dragged_panel_)
       continue;
     bool slide_in = visible_panels[i].slide_in;
     gfx::Rect bounds = visible_panels[i].window->GetTargetBounds();
-    switch (alignment) {
-      case SHELF_ALIGNMENT_BOTTOM:
-        bounds.set_y(shelf_bounds.y() - bounds.height());
-        break;
-      case SHELF_ALIGNMENT_LEFT:
-        bounds.set_x(shelf_bounds.right());
-        break;
-      case SHELF_ALIGNMENT_RIGHT:
-        bounds.set_x(shelf_bounds.x() - bounds.width());
-        break;
-    }
+    if (alignment == SHELF_ALIGNMENT_LEFT)
+      bounds.set_x(shelf_bounds.right());
+    else if (alignment == SHELF_ALIGNMENT_RIGHT)
+      bounds.set_x(shelf_bounds.x() - bounds.width());
+    else
+      bounds.set_y(shelf_bounds.y() - bounds.height());
     bool on_shelf = visible_panels[i].window->GetTargetBounds() == bounds;
 
     if (horizontal) {
       bounds.set_x(visible_panels[i].major_pos -
                    visible_panels[i].major_length / 2);
     } else {
       bounds.set_y(visible_panels[i].major_pos -
                    visible_panels[i].major_length / 2);
     }
 
@@ skipping 112 matching lines @@
           current_bounds.x() - callout_bounds.x(),
           callout_bounds.right() - current_bounds.right());
     } else {
       callout_bounds.set_y(
           icon_bounds.y() + (icon_bounds.height() -
                              callout_bounds.height()) / 2);
       distance_until_over_panel = std::max(
           current_bounds.y() - callout_bounds.y(),
           callout_bounds.bottom() - current_bounds.bottom());
     }
-    switch (shelf_->alignment()) {
-      case SHELF_ALIGNMENT_BOTTOM:
-        callout_bounds.set_y(bounds.bottom());
-        break;
-      case SHELF_ALIGNMENT_LEFT:
-        callout_bounds.set_x(bounds.x() - callout_bounds.width());
-        break;
-      case SHELF_ALIGNMENT_RIGHT:
-        callout_bounds.set_x(bounds.right());
-        break;
-    }
+    if (shelf_->alignment() == SHELF_ALIGNMENT_LEFT)
+      callout_bounds.set_x(bounds.x() - callout_bounds.width());
+    else if (shelf_->alignment() == SHELF_ALIGNMENT_RIGHT)
+      callout_bounds.set_x(bounds.right());
+    else
+      callout_bounds.set_y(bounds.bottom());
     callout_bounds = ScreenUtil::ConvertRectFromScreen(
         callout_widget->GetNativeWindow()->parent(),
         callout_bounds);
 
     SetChildBoundsDirect(callout_widget->GetNativeWindow(), callout_bounds);
     panel_container_->StackChildAbove(callout_widget->GetNativeWindow(),
                                       panel);
 
     ui::Layer* layer = callout_widget->GetNativeWindow()->layer();
     // If the panel is not over the callout position or has just become visible
@@ skipping 59 matching lines @@
       // Keyboard hidden, restore original bounds if they exist.
       SetChildBounds(panel, panel_state->GetRestoreBoundsInScreen());
     }
   }
   // This bounds change will have caused a change to the Shelf which does not
   // propogate automatically to this class, so manually recalculate bounds.
   OnWindowResized();
 }
 
 }  // namespace ash