Moves windowsresizers to ash/wm/common

ash/wm/common/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 "ash/wm/common/panels/panel_layout_manager.h"
 
 #include <algorithm>
 #include <map>
 #include <utility>
 
-#include "ash/shell.h"
 #include "ash/wm/common/shelf/wm_shelf.h"
 #include "ash/wm/common/shelf/wm_shelf_util.h"
 #include "ash/wm/common/window_animation_types.h"
 #include "ash/wm/common/window_parenting_utils.h"
 #include "ash/wm/common/window_state.h"
 #include "ash/wm/common/wm_globals.h"
 #include "ash/wm/common/wm_root_window_controller.h"
 #include "ash/wm/common/wm_shell_window_ids.h"
 #include "ash/wm/common/wm_window.h"
 #include "ash/wm/common/wm_window_property.h"
@@ skipping 90 matching lines @@
 
 bool CompareWindowMajor(const VisiblePanelPositionInfo& win1,
                         const VisiblePanelPositionInfo& win2) {
   return win1.major_pos < win2.major_pos;
 }
 
 void FanOutPanels(std::vector<VisiblePanelPositionInfo>::iterator first,
                   std::vector<VisiblePanelPositionInfo>::iterator last) {
   int num_panels = last - first;
   if (num_panels == 1) {
-    (*first).major_pos = std::max((*first).min_major, std::min(
-        (*first).max_major, (*first).major_pos));
+    (*first).major_pos = std::max(
+        (*first).min_major, std::min((*first).max_major, (*first).major_pos));
   }
   if (num_panels <= 1)
     return;
 
   if (num_panels == 2) {
     // If there are two adjacent overlapping windows, separate them by the
     // minimum major_length necessary.
     std::vector<VisiblePanelPositionInfo>::iterator second = first + 1;
     int separation = (*first).major_length / 2 + (*second).major_length / 2 +
                      kPanelIdealSpacing;
     int overlap = (*first).major_pos + separation - (*second).major_pos;
-    (*first).major_pos = std::max((*first).min_major,
-                                  (*first).major_pos - overlap / 2);
-    (*second).major_pos = std::min((*second).max_major,
-                                   (*first).major_pos + separation);
+    (*first).major_pos =
+        std::max((*first).min_major, (*first).major_pos - overlap / 2);
+    (*second).major_pos =
+        std::min((*second).max_major, (*first).major_pos + separation);
     // Recalculate the first panel position in case the second one was
     // constrained on the right.
-    (*first).major_pos = std::max((*first).min_major,
-                                  (*second).major_pos - separation);
+    (*first).major_pos =
+        std::max((*first).min_major, (*second).major_pos - separation);
     return;
   }
 
   // If there are more than two overlapping windows, fan them out from minimum
   // position to maximum position equally spaced.
   int delta = ((*(last - 1)).max_major - (*first).min_major) / (num_panels - 1);
   int major_pos = (*first).min_major;
   for (std::vector<VisiblePanelPositionInfo>::iterator iter = first;
-      iter != last; ++iter) {
-    (*iter).major_pos = std::max((*iter).min_major,
-                                 std::min((*iter).max_major, major_pos));
+       iter != last; ++iter) {
+    (*iter).major_pos =
+        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();
+  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 offset;
   if (alignment == wm::SHELF_ALIGNMENT_LEFT)
     offset.set_x(-kPanelSlideInOffset);
   else if (alignment == wm::SHELF_ALIGNMENT_RIGHT)
     offset.set_x(kPanelSlideInOffset);
   else
     offset.set_y(kPanelSlideInOffset);
@@ skipping 229 matching lines @@
   const int max_width = max_bounds.width() * kMaxWidthFactor;
   const int max_height = max_bounds.height() * kMaxHeightFactor;
   if (bounds.width() > max_width)
     bounds.set_width(max_width);
   if (bounds.height() > max_height)
     bounds.set_height(max_height);
 
   // Reposition dragged panel in the panel order.
   if (dragged_panel_ == child) {
     PanelList::iterator dragged_panel_iter =
-      std::find(panel_windows_.begin(), panel_windows_.end(), dragged_panel_);
+        std::find(panel_windows_.begin(), panel_windows_.end(), dragged_panel_);
     DCHECK(dragged_panel_iter != panel_windows_.end());
     PanelList::iterator new_position;
     for (new_position = panel_windows_.begin();
-         new_position != panel_windows_.end();
-         ++new_position) {
+         new_position != panel_windows_.end(); ++new_position) {
       const gfx::Rect& bounds = (*new_position).window->GetBounds();
       if (bounds.x() + bounds.width() / 2 <= requested_bounds.x())
         break;
     }
     if (new_position != dragged_panel_iter) {
       PanelInfo dragged_panel_info = *dragged_panel_iter;
       panel_windows_.erase(dragged_panel_iter);
       panel_windows_.insert(new_position, dragged_panel_info);
     }
   }
   // Respect the minimum size of the window.
   if (child->HasNonClientArea()) {
     const gfx::Size min_size = child->GetMinimumSize();
     bounds.set_width(std::max(min_size.width(), bounds.width()));
     bounds.set_height(std::max(min_size.height(), bounds.height()));
   }
 
   child->SetBoundsDirect(bounds);
   Relayout();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// PanelLayoutManager, ash::ShellObserver implementation:
+// PanelLayoutManager, wm::WmShellObserver implementation:
 
 void PanelLayoutManager::OnOverviewModeEnded() {
   Relayout();
 }
 
 void PanelLayoutManager::OnShelfAlignmentChanged() {
   Relayout();
 }
 
 /////////////////////////////////////////////////////////////////////////////
@@ skipping 186 matching lines @@
 
     if (panel->IsFocused() ||
         panel->Contains(panel->GetGlobals()->GetFocusedWindow())) {
       DCHECK(!active_panel);
       active_panel = panel;
     }
     icon_bounds = panel_container_->ConvertRectFromScreen(icon_bounds);
     gfx::Point icon_origin = icon_bounds.origin();
     VisiblePanelPositionInfo position_info;
     int icon_start = horizontal ? icon_origin.x() : icon_origin.y();
-    int icon_end = icon_start + (horizontal ? icon_bounds.width() :
-                                 icon_bounds.height());
+    int icon_end =
+        icon_start + (horizontal ? icon_bounds.width() : icon_bounds.height());
     position_info.major_length =
         horizontal ? panel->GetBounds().width() : panel->GetBounds().height();
-    position_info.min_major = std::max(
-        panel_start_bounds + position_info.major_length / 2,
-        icon_end - position_info.major_length / 2);
-    position_info.max_major = std::min(
-        icon_start + position_info.major_length / 2,
-        panel_end_bounds - position_info.major_length / 2);
+    position_info.min_major =
+        std::max(panel_start_bounds + position_info.major_length / 2,
+                 icon_end - position_info.major_length / 2);
+    position_info.max_major =
+        std::min(icon_start + position_info.major_length / 2,
+                 panel_end_bounds - position_info.major_length / 2);
     position_info.major_pos = (icon_start + icon_end) / 2;
     position_info.window = panel;
     position_info.slide_in = iter->slide_in;
     iter->slide_in = false;
     visible_panels.push_back(position_info);
   }
 
   // Sort panels by their X positions and fan out groups of overlapping panels.
   // The fan out method may result in new overlapping panels however given that
   // the panels start at least a full panel width apart this overlap will
   // never completely obscure a panel.
   // TODO(flackr): Rearrange panels if new overlaps are introduced.
   std::sort(visible_panels.begin(), visible_panels.end(), CompareWindowMajor);
   size_t first_overlapping_panel = 0;
   for (size_t i = 1; i < visible_panels.size(); ++i) {
     if (visible_panels[i - 1].major_pos +
-        visible_panels[i - 1].major_length / 2 < visible_panels[i].major_pos -
-        visible_panels[i].major_length / 2) {
+            visible_panels[i - 1].major_length / 2 <
+        visible_panels[i].major_pos - visible_panels[i].major_length / 2) {
       FanOutPanels(visible_panels.begin() + first_overlapping_panel,
                    visible_panels.begin() + i);
       first_overlapping_panel = i;
     }
   }
   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_)
@@ skipping 64 matching lines @@
   //
   // 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, wm::WmWindow*> window_ordering;
   const bool horizontal = wm::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));
+    window_ordering.insert(
+        std::make_pair(horizontal ? bounds.x() + bounds.width() / 2
+                                  : bounds.y() + bounds.height() / 2,
+                       it->window));
   }
 
   wm::WmWindow* previous_panel = nullptr;
   for (std::map<int, wm::WmWindow*>::const_iterator it =
            window_ordering.begin();
        it != window_ordering.end() && it->second != active_panel; ++it) {
     if (previous_panel)
       panel_container_->StackChildAbove(it->second, previous_panel);
     previous_panel = it->second;
   }
@@ skipping 30 matching lines @@
       callout_widget->Hide();
       callout_widget_window->GetLayer()->SetOpacity(0);
       continue;
     }
 
     gfx::Rect callout_bounds = callout_widget->GetWindowBoundsInScreen();
     gfx::Vector2d slide_vector = bounds.origin() - current_bounds.origin();
     int slide_distance = horizontal ? slide_vector.x() : slide_vector.y();
     int distance_until_over_panel = 0;
     if (horizontal) {
-      callout_bounds.set_x(
-          icon_bounds.x() + (icon_bounds.width() - callout_bounds.width()) / 2);
-      distance_until_over_panel = std::max(
-          current_bounds.x() - callout_bounds.x(),
-          callout_bounds.right() - current_bounds.right());
+      callout_bounds.set_x(icon_bounds.x() +
+                           (icon_bounds.width() - callout_bounds.width()) / 2);
+      distance_until_over_panel =
+          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());
+      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)
       callout_bounds.set_x(bounds.x() - callout_bounds.width());
     else if (shelf_->GetAlignment() == wm::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();
     // If the panel is not over the callout position or has just become visible
     // then fade in the callout.
     if ((distance_until_over_panel > 0 || layer->GetTargetOpacity() < 1)) {
       if (distance_until_over_panel > 0 &&
           slide_distance >= distance_until_over_panel) {
         // If the panel is not yet over the callout, then delay fading in
         // the callout until after the panel should be over it.
         int delay = kPanelSlideDurationMilliseconds *
-            distance_until_over_panel / slide_distance;
+                    distance_until_over_panel / slide_distance;
         layer->SetOpacity(0);
         layer->GetAnimator()->StopAnimating();
         layer->GetAnimator()->SchedulePauseForProperties(
             base::TimeDelta::FromMilliseconds(delay),
             ui::LayerAnimationElement::OPACITY);
       }
       ui::ScopedLayerAnimationSettings callout_settings(layer->GetAnimator());
       callout_settings.SetPreemptionStrategy(
           ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
       callout_settings.SetTransitionDuration(
-          base::TimeDelta::FromMilliseconds(
-              kCalloutFadeDurationMilliseconds));
+          base::TimeDelta::FromMilliseconds(kCalloutFadeDurationMilliseconds));
       layer->SetOpacity(1);
     }
 
     // Show after changing the opacity animation. This way we don't have a
     // state where the widget is visible but the opacity is 0.
     callout_widget->Show();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // keyboard::KeyboardControllerObserver implementation:
 
 void PanelLayoutManager::OnKeyboardBoundsChanging(
     const gfx::Rect& keyboard_bounds) {
   gfx::Rect parent_bounds = panel_container_->GetBounds();
   int available_space = parent_bounds.height() - keyboard_bounds.height();
   for (PanelList::iterator iter = panel_windows_.begin();
-       iter != panel_windows_.end();
-       ++iter) {
+       iter != panel_windows_.end(); ++iter) {
     wm::WmWindow* panel = iter->window;
     wm::WindowState* panel_state = panel->GetWindowState();
     if (keyboard_bounds.height() > 0) {
       // Save existing bounds, so that we can restore them when the keyboard
       // hides.
       panel_state->SaveCurrentBoundsForRestore();
 
       gfx::Rect panel_bounds =
           panel->GetParent()->ConvertRectToScreen(panel->GetTargetBounds());
       int delta = panel_bounds.height() - available_space;
       // Ensure panels are not pushed above the parent boundaries, shrink any
       // panels that violate this constraint.
       if (delta > 0) {
         panel->SetBoundsDirect(
             gfx::Rect(panel_bounds.x(), panel_bounds.y() + delta,
                       panel_bounds.width(), panel_bounds.height() - delta));
       }
     } else if (panel_state->HasRestoreBounds()) {
       // 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