mash: Move ash/common/wm/shelf to ash/common/shelf

ash/common/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/common/wm/panels/panel_layout_manager.h"
 
 #include <algorithm>
 #include <map>
 #include <utility>
 
+#include "ash/common/shelf/wm_shelf.h"
+#include "ash/common/shelf/wm_shelf_util.h"
 #include "ash/common/shell_window_ids.h"
-#include "ash/common/wm/shelf/wm_shelf.h"
-#include "ash/common/wm/shelf/wm_shelf_util.h"
 #include "ash/common/wm/window_animation_types.h"
 #include "ash/common/wm/window_parenting_utils.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm_lookup.h"
 #include "ash/common/wm_root_window_controller.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "ash/common/wm_window_property.h"
 #include "base/auto_reset.h"
 #include "third_party/skia/include/core/SkColor.h"
@@ skipping 21 matching lines @@
 // Offset used when sliding panel in/out of the shelf. Used for minimizing,
 // restoring and the initial showing of a panel.
 const int kPanelSlideInOffset = 20;
 
 // Callout arrow dimensions.
 const int kArrowWidth = 18;
 const int kArrowHeight = 9;
 
 class CalloutWidgetBackground : public views::Background {
  public:
-  CalloutWidgetBackground() : alignment_(wm::SHELF_ALIGNMENT_BOTTOM) {}
+  CalloutWidgetBackground() : alignment_(SHELF_ALIGNMENT_BOTTOM) {}
 
   void Paint(gfx::Canvas* canvas, views::View* view) const override {
     SkPath path;
     switch (alignment_) {
-      case wm::SHELF_ALIGNMENT_BOTTOM:
-      case wm::SHELF_ALIGNMENT_BOTTOM_LOCKED:
+      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 wm::SHELF_ALIGNMENT_LEFT:
+      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 wm::SHELF_ALIGNMENT_RIGHT:
+      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);
   }
 
-  wm::ShelfAlignment alignment() { return alignment_; }
+  ShelfAlignment alignment() { return alignment_; }
 
-  void set_alignment(wm::ShelfAlignment alignment) { alignment_ = alignment; }
+  void set_alignment(ShelfAlignment alignment) { alignment_ = alignment; }
 
  private:
-  wm::ShelfAlignment alignment_;
+  ShelfAlignment alignment_;
 
   DISALLOW_COPY_AND_ASSIGN(CalloutWidgetBackground);
 };
 
 struct VisiblePanelPositionInfo {
   VisiblePanelPositionInfo()
       : min_major(0),
         max_major(0),
         major_pos(0),
         major_length(0),
@@ skipping 51 matching lines @@
         std::max((*iter).min_major, std::min((*iter).max_major, major_pos));
     major_pos += delta;
   }
 }
 
 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(wm::ShelfAlignment alignment) {
+gfx::Vector2d GetSlideInAnimationOffset(ShelfAlignment alignment) {
   gfx::Vector2d offset;
-  if (alignment == wm::SHELF_ALIGNMENT_LEFT)
+  if (alignment == SHELF_ALIGNMENT_LEFT)
     offset.set_x(-kPanelSlideInOffset);
-  else if (alignment == wm::SHELF_ALIGNMENT_RIGHT)
+  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(WmWindow* container) : background_(nullptr) {
     InitWidget(container);
   }
 
-  void SetAlignment(wm::ShelfAlignment alignment) {
+  void SetAlignment(ShelfAlignment alignment) {
     gfx::Rect callout_bounds = GetWindowBoundsInScreen();
-    if (wm::IsHorizontalAlignment(alignment)) {
+    if (IsHorizontalAlignment(alignment)) {
       callout_bounds.set_width(kArrowWidth);
       callout_bounds.set_height(kArrowHeight);
     } else {
       callout_bounds.set_width(kArrowHeight);
       callout_bounds.set_height(kArrowWidth);
     }
     SetBounds(callout_bounds);
     if (background_->alignment() != alignment) {
       background_->set_alignment(alignment);
       SchedulePaintInRect(gfx::Rect(callout_bounds.size()));
@@ skipping 90 matching lines @@
   DCHECK(!dragged_panel_);
   dragged_panel_ = panel;
   Relayout();
 }
 
 void PanelLayoutManager::FinishDragging() {
   dragged_panel_ = NULL;
   Relayout();
 }
 
-void PanelLayoutManager::SetShelf(wm::WmShelf* shelf) {
+void PanelLayoutManager::SetShelf(WmShelf* shelf) {
   DCHECK(!shelf_);
   shelf_ = shelf;
   shelf_->AddObserver(this);
   WillChangeVisibilityState(shelf_->GetVisibilityState());
 }
 
 void PanelLayoutManager::ToggleMinimize(WmWindow* panel) {
   DCHECK(panel->GetParent() == panel_container_);
   wm::WindowState* window_state = panel->GetWindowState();
   if (window_state->IsMinimized())
@@ skipping 274 matching lines @@
   // when the WindowSelectorController is restoring minimized windows so that
   // they actually become visible.
   WmShell* shell = panel_container_->GetShell();
   if (in_layout_ || (shell->IsOverviewModeSelecting() &&
                      !shell->IsOverviewModeRestoringMinimizedWindows())) {
     return;
   }
 
   base::AutoReset<bool> auto_reset_in_layout(&in_layout_, true);
 
-  const wm::ShelfAlignment alignment = shelf_->GetAlignment();
-  const bool horizontal = wm::IsHorizontalAlignment(shelf_->GetAlignment());
+  const ShelfAlignment alignment = shelf_->GetAlignment();
+  const bool horizontal = IsHorizontalAlignment(shelf_->GetAlignment());
   gfx::Rect shelf_bounds = panel_container_->ConvertRectFromScreen(
       shelf_->GetWindow()->GetBoundsInScreen());
   int panel_start_bounds = kPanelIdealSpacing;
   int panel_end_bounds =
       horizontal ? panel_container_->GetBounds().width() - kPanelIdealSpacing
                  : panel_container_->GetBounds().height() - kPanelIdealSpacing;
   WmWindow* active_panel = nullptr;
   std::vector<VisiblePanelPositionInfo> visible_panels;
   for (PanelList::iterator iter = panel_windows_.begin();
        iter != panel_windows_.end(); ++iter) {
@@ skipping 70 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();
-    if (alignment == wm::SHELF_ALIGNMENT_LEFT)
+    if (alignment == SHELF_ALIGNMENT_LEFT)
       bounds.set_x(shelf_bounds.right());
-    else if (alignment == wm::SHELF_ALIGNMENT_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 -
@@ skipping 44 matching lines @@
   // We want to to stack the panels like a deck of cards:
   // ,--,--,--,-------.--.--.
   // |  |  |  |       |  |  |
   // |  |  |  |       |  |  |
   //
   // We use the middle of each panel to figure out how to stack the panels. This
   // allows us to update the stacking when a panel is being dragged around by
   // the titlebar--even though it doesn't update the shelf icon positions, we
   // still want the visual effect.
   std::map<int, WmWindow*> window_ordering;
-  const bool horizontal = wm::IsHorizontalAlignment(shelf_->GetAlignment());
+  const bool horizontal = IsHorizontalAlignment(shelf_->GetAlignment());
   for (PanelList::const_iterator it = panel_windows_.begin();
        it != panel_windows_.end(); ++it) {
     gfx::Rect bounds = it->window->GetBounds();
     window_ordering.insert(
         std::make_pair(horizontal ? bounds.x() + bounds.width() / 2
                                   : bounds.y() + bounds.height() / 2,
                        it->window));
   }
 
   WmWindow* previous_panel = nullptr;
@@ skipping 13 matching lines @@
     previous_panel = it->second;
   }
 
   panel_container_->StackChildAtTop(active_panel);
   if (dragged_panel_ && dragged_panel_->GetParent() == panel_container_)
     panel_container_->StackChildAtTop(dragged_panel_);
   last_active_panel_ = active_panel;
 }
 
 void PanelLayoutManager::UpdateCallouts() {
-  const bool horizontal = wm::IsHorizontalAlignment(shelf_->GetAlignment());
+  const bool horizontal = IsHorizontalAlignment(shelf_->GetAlignment());
   for (PanelList::iterator iter = panel_windows_.begin();
        iter != panel_windows_.end(); ++iter) {
     WmWindow* panel = iter->window;
     views::Widget* callout_widget = iter->callout_widget;
     WmWindow* callout_widget_window =
         WmLookup::Get()->GetWindowForWidget(callout_widget);
 
     gfx::Rect current_bounds = panel->GetBoundsInScreen();
     gfx::Rect bounds =
         panel->GetParent()->ConvertRectToScreen(panel->GetTargetBounds());
@@ skipping 16 matching lines @@
           std::max(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());
     }
-    if (shelf_->GetAlignment() == wm::SHELF_ALIGNMENT_LEFT)
+    if (shelf_->GetAlignment() == SHELF_ALIGNMENT_LEFT)
       callout_bounds.set_x(bounds.x() - callout_bounds.width());
-    else if (shelf_->GetAlignment() == wm::SHELF_ALIGNMENT_RIGHT)
+    else if (shelf_->GetAlignment() == SHELF_ALIGNMENT_RIGHT)
       callout_bounds.set_x(bounds.right());
     else
       callout_bounds.set_y(bounds.bottom());
     callout_bounds = callout_widget_window->GetParent()->ConvertRectFromScreen(
         callout_bounds);
 
     callout_widget_window->SetBoundsDirect(callout_bounds);
     panel_container_->StackChildAbove(callout_widget_window, panel);
 
     ui::Layer* layer = callout_widget_window->GetLayer();
@@ skipping 56 matching lines @@
       // Keyboard hidden, restore original bounds if they exist.
       panel->SetBoundsDirect(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