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

panels/panel_manager.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_manager.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "cros/chromeos_wm_ipc_enums.h"
@@ skipping 224 matching lines @@
   }
   for (vector<XWindow>::const_iterator it = orphaned_transient_xids.begin();
        it != orphaned_transient_xids.end(); ++it) {
     CHECK(transient_xids_to_owners_.erase(*it) == 1);
   }
 
   CHECK(panels_by_titlebar_xid_.erase(panel->titlebar_xid()) == 1);
   CHECK(panels_.erase(panel->content_xid()) == 1);
 }
 
-void PanelManager::HandleWindowConfigureRequest(
-    Window* win, int req_x, int req_y, int req_width, int req_height) {
+void PanelManager::HandleWindowConfigureRequest(Window* win,
+                                                const Rect& requested_bounds) {
   if (Panel* owner_panel = GetPanelOwningTransientWindow(*win)) {
-    owner_panel->HandleTransientWindowConfigureRequest(
-        win, req_x, req_y, req_width, req_height);
+    owner_panel->HandleTransientWindowConfigureRequest(win, requested_bounds);
     return;
   }
 
   Panel* panel = GetPanelByWindow(*win);
   if (!panel)
     return;
 
   if (win != panel->content_win()) {
     LOG(WARNING) << "Ignoring request to configure non-content window "
                  << win->xid_str() << " for panel " << panel->xid_str();
     return;
   }
   PanelContainer* container = GetContainerForPanel(*panel);
   if (!container) {
     LOG(WARNING) << "Ignoring request to configure panel " << panel->xid_str()
                  << " while it's not in a container";
     return;
   }
   if (panel->is_being_resized_by_user()) {
     LOG(WARNING) << "Ignoring request to configure panel " << panel->xid_str()
                  << " while it's being manually resized";
     win->SendSyntheticConfigureNotify();
     return;
   }
 
-  if (req_width != panel->content_width() ||
-      req_height != panel->content_height()) {
-    container->HandlePanelResizeRequest(panel, req_width, req_height);
-  } else {
+  if (requested_bounds.size() != panel->content_size())
+    container->HandlePanelResizeRequest(panel, requested_bounds.size());
+  else
     win->SendSyntheticConfigureNotify();
-  }
 }
 
 void PanelManager::HandleButtonPress(XWindow xid,
-                                     int x, int y,
-                                     int x_root, int y_root,
+                                     const Point& relative_pos,
+                                     const Point& absolute_pos,
                                      int button,
                                      XTime timestamp) {
   // If this is a container's input window, notify the container.
   PanelContainer* container = GetContainerOwningInputWindow(xid);
   if (container) {
     container->HandleInputWindowButtonPress(
-        xid, x, y, x_root, y_root, button, timestamp);
+        xid, relative_pos, absolute_pos, button, timestamp);
     return;
   }
 
   // If this is a panel's input window, notify the panel.
   Panel* panel = GetPanelOwningInputWindow(xid);
   if (panel) {
-    panel->HandleInputWindowButtonPress(xid, x, y, button, timestamp);
+    panel->HandleInputWindowButtonPress(xid, relative_pos, button, timestamp);
     return;
   }
 
   Window* win = wm_->GetWindow(xid);
   if (!win)
     return;
 
   // If it's a panel's content window, notify the panel's container.
   panel = GetPanelByWindow(*win);
   if (panel) {
     container = GetContainerForPanel(*panel);
     if (container)
       container->HandlePanelButtonPress(panel, button, timestamp);
     return;
   }
 
   panel = GetPanelOwningTransientWindow(*win);
   if (panel) {
     panel->HandleTransientWindowButtonPress(win, button, timestamp);
     return;
   }
 }
 
 void PanelManager::HandleButtonRelease(XWindow xid,
-                                       int x, int y,
-                                       int x_root, int y_root,
+                                       const Point& relative_pos,
+                                       const Point& absolute_pos,
                                        int button,
                                        XTime timestamp) {
   // We only care if button releases happened in container or panel input
   // windows -- there's no current need to notify containers about button
   // releases in their panels.
   PanelContainer* container = GetContainerOwningInputWindow(xid);
   if (container) {
     container->HandleInputWindowButtonRelease(
-        xid, x, y, x_root, y_root, button, timestamp);
+        xid, relative_pos, absolute_pos, button, timestamp);
     return;
   }
 
   Panel* panel = GetPanelOwningInputWindow(xid);
   if (panel) {
-    panel->HandleInputWindowButtonRelease(xid, x, y, button, timestamp);
+    panel->HandleInputWindowButtonRelease(xid, relative_pos, button, timestamp);
     return;
   }
 }
 
 void PanelManager::HandlePointerEnter(XWindow xid,
-                                      int x, int y,
-                                      int x_root, int y_root,
+                                      const Point& relative_pos,
+                                      const Point& absolute_pos,
                                       XTime timestamp) {
   PanelContainer* container = GetContainerOwningInputWindow(xid);
   if (container) {
     container->HandleInputWindowPointerEnter(
-        xid, x, y, x_root, y_root, timestamp);
+        xid, relative_pos, absolute_pos, timestamp);
     return;
   }
 
   // If it's a panel's titlebar window, notify the panel's container.
   Window* win = wm_->GetWindow(xid);
   if (win) {
     Panel* panel = GetPanelByWindow(*win);
     if (panel) {
       container = GetContainerForPanel(*panel);
       if (container && xid == panel->titlebar_xid())
         container->HandlePanelTitlebarPointerEnter(panel, timestamp);
       return;
     }
   }
 }
 
 void PanelManager::HandlePointerLeave(XWindow xid,
-                                      int x, int y,
-                                      int x_root, int y_root,
+                                      const Point& relative_pos,
+                                      const Point& absolute_pos,
                                       XTime timestamp) {
   PanelContainer* container = GetContainerOwningInputWindow(xid);
   if (container)
     container->HandleInputWindowPointerLeave(
-        xid, x, y, x_root, y_root, timestamp);
+        xid, relative_pos, absolute_pos, timestamp);
 }
 
 void PanelManager::HandlePointerMotion(XWindow xid,
-                                       int x, int y,
-                                       int x_root, int y_root,
+                                       const Point& relative_pos,
+                                       const Point& absolute_pos,
                                        XTime timestamp) {
   Panel* panel = GetPanelOwningInputWindow(xid);
   if (panel)
-    panel->HandleInputWindowPointerMotion(xid, x, y);
+    panel->HandleInputWindowPointerMotion(xid, relative_pos);
 }
 
 void PanelManager::HandleChromeMessage(const WmIpc::Message& msg) {
   switch (msg.type()) {
     case chromeos::WM_IPC_MESSAGE_WM_SET_PANEL_STATE: {
       XWindow xid = msg.param(0);
       Panel* panel = GetPanelByXid(xid);
       if (!panel) {
         LOG(WARNING) << "Ignoring WM_SET_PANEL_STATE message for non-panel "
                      << "window " << XidStr(xid);
@@ skipping 15 matching lines @@
       if (dragged_panel_ && panel != dragged_panel_)
         HandlePanelDragComplete(dragged_panel_, false);  // removed=false
       if (panel != dragged_panel_) {
         dragged_panel_ = panel;
         panel->HandleDragStart();
       }
       if (!dragged_panel_event_coalescer_->IsRunning())
         dragged_panel_event_coalescer_->Start();
       // We want the right edge of the panel, but pre-IPC-version-1 Chrome
       // sends us the left edge of the titlebar instead.
-      int drag_x = (wm()->wm_ipc_version() >= 1) ?
-                   msg.param(1) : msg.param(1) + panel->titlebar_width();
-      int drag_y = msg.param(2);
-      dragged_panel_event_coalescer_->StorePosition(drag_x, drag_y);
+      Point drag_pos(
+          (wm()->wm_ipc_version() >= 1) ?
+            msg.param(1) : msg.param(1) + panel->titlebar_width(),
+          msg.param(2));
+      dragged_panel_event_coalescer_->StorePosition(drag_pos);
       break;
     }
     case chromeos::WM_IPC_MESSAGE_WM_NOTIFY_PANEL_DRAG_COMPLETE: {
       XWindow xid = msg.param(0);
       Panel* panel = GetPanelByXid(xid);
       if (!panel) {
         LOG(WARNING) << "Ignoring WM_NOTIFY_PANEL_DRAG_COMPLETE message for "
                      << "non-panel window " << XidStr(xid);
         return;
       }
@@ skipping 165 matching lines @@
 
 void PanelManager::DoInitialSetupForWindow(Window* win) {
   win->SetVisibility(Window::VISIBILITY_HIDDEN);
 }
 
 void PanelManager::HandlePeriodicPanelDragMotion() {
   DCHECK(dragged_panel_);
   if (!dragged_panel_)
     return;
 
-  const int x = dragged_panel_event_coalescer_->x();
-  const int y = dragged_panel_event_coalescer_->y();
+  const Point pos = dragged_panel_event_coalescer_->position();
 
   bool container_handled_drag = false;
   bool panel_was_detached = false;
   PanelContainer* container = GetContainerForPanel(*dragged_panel_);
   if (container) {
-    if (container->HandleNotifyPanelDraggedMessage(dragged_panel_, x, y)) {
+    if (container->HandleNotifyPanelDraggedMessage(dragged_panel_, pos)) {
       container_handled_drag = true;
     } else {
       DLOG(INFO) << "Container " << container << " told us to detach panel "
-                 << dragged_panel_->xid_str()
-                 << " at (" << x << ", " << y << ")";
+                 << dragged_panel_->xid_str() << " at " << pos;
       RemovePanelFromContainer(dragged_panel_, container);
       panel_was_detached = true;
     }
   }
 
   if (!container_handled_drag) {
     if (panel_was_detached) {
       dragged_panel_->SetTitlebarWidth(dragged_panel_->content_width());
       dragged_panel_->StackAtTopOfLayer(StackingManager::LAYER_DRAGGED_PANEL);
     }
 
     // Offer the panel to all of the containers.  If we find one that wants
     // it, attach it; otherwise we just move the panel to the dragged location.
     bool panel_was_reattached = false;
     for (vector<PanelContainer*>::iterator it = containers_.begin();
          it != containers_.end(); ++it) {
-      if ((*it)->ShouldAddDraggedPanel(dragged_panel_, x, y)) {
+      if ((*it)->ShouldAddDraggedPanel(dragged_panel_, pos)) {
         DLOG(INFO) << "Container " << *it << " told us to attach panel "
-                   << dragged_panel_->xid_str()
-                   << " at (" << x << ", " << y << ")";
+                   << dragged_panel_->xid_str() << " at " << pos;
         AddPanelToContainer(dragged_panel_,
                             *it,
                             PanelContainer::PANEL_SOURCE_DRAGGED);
-        CHECK((*it)->HandleNotifyPanelDraggedMessage(dragged_panel_, x, y));
+        CHECK((*it)->HandleNotifyPanelDraggedMessage(dragged_panel_, pos));
         panel_was_reattached = true;
         break;
       }
     }
     if (!panel_was_reattached) {
-      dragged_panel_->Move(
-          x, y, panel_was_detached ? kDetachPanelAnimMs : 0);
+      dragged_panel_->Move(pos, panel_was_detached ? kDetachPanelAnimMs : 0);
     }
   }
 }
 
 void PanelManager::HandlePanelDragComplete(Panel* panel, bool removed) {
   DCHECK(panel);
   DCHECK(dragged_panel_ == panel);
   if (dragged_panel_ != panel)
     return;
 
@@ skipping 59 matching lines @@
                  << panel->xid_str();
     return;
   }
 
   panel->SetFullscreenState(false);
   if (fullscreen_panel_ == panel)
     fullscreen_panel_ = NULL;
 }
 
 }  // namespace window_manager