wm: Update a lot of code to use structs from geometry.h.

panels/panel_dock.cc

 // Copyright (c) 2010 The Chromium OS 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 "window_manager/panels/panel_dock.h"
 
 #include <algorithm>
 #include <utility>
 
 #include <gflags/gflags.h>
@@ skipping 106 matching lines @@
     bg_shadow_->MoveX(x_, kBackgroundAnimMs);
     bg_shadow_->SetOpacity(1, kBackgroundAnimMs);
     panel_manager_->HandleDockVisibilityChange(this);
   }
 
   panel->StackAtTopOfLayer(
       source == PANEL_SOURCE_DRAGGED ?
         StackingManager::LAYER_DRAGGED_PANEL :
         StackingManager::LAYER_PACKED_PANEL_IN_DOCK);
 
+  int panel_x = (type_ == DOCK_TYPE_RIGHT) ? x_ + width_ : x_ + panel->width();
   // Try to make the panel fit vertically within our dimensions.
   int panel_y = panel->titlebar_y();
   if (panel_y + panel->total_height() > y_ + height_)
     panel_y = y_ + height_ - panel->total_height();
   if (panel_y < y_)
     panel_y = y_;
-  panel->Move(type_ == DOCK_TYPE_RIGHT ? x_ + width_ : x_ + panel->width(),
-              panel_y,
-              0);
+  panel->Move(Point(panel_x, panel_y), 0);
   // TODO: Ideally, we would resize the panel here to match our width, but
   // that messes up the subsequent notification messages about the panel
   // being dragged -- some of them will be with regard to the panel's old
   // dimensions and others will be with regard to the new dimensions.
   // Instead, we defer resizing the panel until the drag is complete.
 }
 
 void PanelDock::RemovePanel(Panel* panel) {
   if (dragged_panel_ == panel)
     dragged_panel_ = NULL;
 
   vector<Panel*>::iterator it = find(panels_.begin(), panels_.end(), panel);
   DCHECK(it != panels_.end());
   panels_.erase(it);
   CHECK(static_cast<int>(panel_infos_.erase(panel)) == 1);
 
   if (panels_.empty()) {
     const int bg_x = type_ == DOCK_TYPE_LEFT ? x_ - width_ : x_ + width_;
     wm()->xconn()->ConfigureWindowOffscreen(bg_input_xid_);
     bg_actor_->MoveX(bg_x, kBackgroundAnimMs);
     bg_shadow_->MoveX(bg_x, kBackgroundAnimMs);
     bg_shadow_->SetOpacity(0, kBackgroundAnimMs);
     panel_manager_->HandleDockVisibilityChange(this);
   } else {
     PackPanels(dragged_panel_);
   }
 }
 
 bool PanelDock::ShouldAddDraggedPanel(const Panel* panel,
-                                      int drag_x,
-                                      int drag_y) {
+                                      const Point& drag_pos) {
   return (type_ == DOCK_TYPE_RIGHT) ?
-         drag_x >= x_ + width_ - kAttachThresholdPixels :
-         drag_x - panel->content_width() <= x_ + kAttachThresholdPixels;
+         drag_pos.x >= x_ + width_ - kAttachThresholdPixels :
+         drag_pos.x - panel->content_width() <= x_ + kAttachThresholdPixels;
 }
 
 void PanelDock::HandlePanelButtonPress(Panel* panel,
                                        int button,
                                        XTime timestamp) {
   FocusPanel(panel, timestamp);
 }
 
 void PanelDock::HandleSetPanelStateMessage(Panel* panel, bool expand) {
   LOG(WARNING) << "Ignoring request to " << (expand ? "expand" : "collapse")
                << " docked panel " << panel->xid_str();
 }
 
 bool PanelDock::HandleNotifyPanelDraggedMessage(Panel* panel,
-                                                int drag_x,
-                                                int drag_y) {
+                                                const Point& drag_pos) {
   if (type_ == DOCK_TYPE_RIGHT) {
-    if (drag_x <= x_ + width_ - kDetachThresholdPixels)
+    if (drag_pos.x <= x_ + width_ - kDetachThresholdPixels)
       return false;
   } else {
-    if (drag_x - panel->content_width() >= x_ + kDetachThresholdPixels)
+    if (drag_pos.x - panel->content_width() >= x_ + kDetachThresholdPixels)
       return false;
   }
 
   if (dragged_panel_ != panel) {
     dragged_panel_ = panel;
     panel->StackAtTopOfLayer(StackingManager::LAYER_DRAGGED_PANEL);
     panel->SetShadowOpacity(1, kPanelShadowAnimMs);
   }
 
   // Cap the drag position within the Y bounds of the dock.
-  if (drag_y + panel->total_height() > y_ + height_)
-    drag_y = y_ + height_ - panel->total_height();
-  if (drag_y < y_)
-    drag_y = y_;
+  Point capped_pos = drag_pos;
+  if (capped_pos.y + panel->total_height() > y_ + height_)
+    capped_pos.y = y_ + height_ - panel->total_height();
+  if (capped_pos.y < y_)
+    capped_pos.y = y_;
 
-  panel->MoveY(drag_y, 0);
+  panel->MoveY(capped_pos.y, 0);
   ReorderPanel(panel);
   return true;
 }
 
 void PanelDock::HandleNotifyPanelDragCompleteMessage(Panel* panel) {
   if (dragged_panel_ != panel)
     return;
   // Move client windows.
-  panel->Move(panel->right(), panel->titlebar_y(), 0);
+  panel->Move(Point(panel->right(), panel->titlebar_y()), 0);
   if (panel->width() != width_) {
     panel->ResizeContent(
-        width_, panel->content_height(),
+        Size(width_, panel->content_height()),
         type_ == DOCK_TYPE_RIGHT ?  GRAVITY_NORTHEAST : GRAVITY_NORTHWEST,
         true);
   }
   panel->SetShadowOpacity(0, kPanelShadowAnimMs);
   panel->StackAtTopOfLayer(StackingManager::LAYER_PACKED_PANEL_IN_DOCK);
   dragged_panel_ = NULL;
   PackPanels(NULL);
 }
 
 void PanelDock::HandleFocusPanelMessage(Panel* panel, XTime timestamp) {
   DCHECK(panel);
   FocusPanel(panel, timestamp);
 }
 
 void PanelDock::HandlePanelResizeRequest(Panel* panel,
-                                         int req_width, int req_height) {
+                                         const Size& requested_size) {
 
   DCHECK(panel);
 
+  Size adjusted_size = requested_size;
+
   // We ignore requests to change the panel's width.
-  if (req_width != panel->content_width()) {
+  if (requested_size.width != panel->content_width()) {
     LOG(WARNING) << "Ignoring width resize request for docked panel "
-                 << panel->xid_str() << " (orig was " << panel->content_width()
-                 << "x" << panel->content_height() << "), new is " << req_width
-                 << "x" << req_height << ")";
-    req_width = panel->content_width();
+                 << panel->xid_str() << " (orig was " << panel->content_size()
+                 << ", new is " << requested_size << ")";
+    adjusted_size.width = panel->content_width();
   }
-  panel->ResizeContent(req_width, req_height, GRAVITY_NORTHWEST, true);
+  panel->ResizeContent(adjusted_size, GRAVITY_NORTHWEST, true);
   PackPanels(dragged_panel_);
 }
 
 void PanelDock::HandleScreenResize() {
   height_ = wm()->height();
   if (type_ == DOCK_TYPE_RIGHT)
     x_ = wm()->width() - width_;
 
   bool hidden = panels_.empty();
 
@@ skipping 98 matching lines @@
 void PanelDock::ResizeBackgroundActor(int width, int height) {
   DCHECK(bg_actor_.get());
   DCHECK_GT(width, 0);
   DCHECK_GT(height, 0);
   bg_actor_->Scale(static_cast<float>(width_) / bg_actor_->GetWidth(),
                    static_cast<float>(height_) / bg_actor_->GetHeight(),
                    0);  // anim_ms
 }
 
 };  // namespace window_manager