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

panels/panel_bar.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_bar.h"
 
 #include <algorithm>
 
 #include <gflags/gflags.h>
 
@@ skipping 174 matching lines @@
   panel->StackAtTopOfLayer(source == PANEL_SOURCE_DRAGGED ?
                            StackingManager::LAYER_DRAGGED_PANEL :
                            StackingManager::LAYER_PACKED_PANEL_IN_BAR);
 
   const int final_y = ComputePanelY(*panel);
 
   // Now move the panel to its final position.
   switch (source) {
     case PANEL_SOURCE_NEW:
       // Make newly-created panels slide in from the bottom of the screen.
-      panel->Move(info->desired_right, wm()->height(), 0);
+      panel->Move(Point(info->desired_right, wm()->height()), 0);
       panel->MoveY(final_y, kPanelStateAnimMs);
       break;
     case PANEL_SOURCE_DRAGGED:
       panel->MoveY(final_y, 0);
       break;
     case PANEL_SOURCE_DROPPED:
-      panel->Move(info->desired_right, final_y, kDroppedPanelAnimMs);
+      panel->Move(Point(info->desired_right, final_y), kDroppedPanelAnimMs);
       break;
     default:
       NOTREACHED() << "Unknown panel source " << source;
   }
 
   ArrangePanels(true, NULL);
   panel->SetResizable(panel->is_expanded());
 
   // If this is a new panel and it requested the focus, or it was already
   // focused (e.g. it was focused when it got detached, and now it's being
@@ skipping 55 matching lines @@
   if (dragged_panel_ && !(GetPanelInfoOrDie(dragged_panel_)->is_floating))
     if (ReorderPanelInVector(dragged_panel_, &packed_panels_))
       ArrangePanels(false, NULL);
 
   // If this was the last collapsed panel, move the input window offscreen.
   if (was_collapsed && GetNumCollapsedPanels() == 0)
     ConfigureShowCollapsedPanelsInputWindow(false);
 }
 
 bool PanelBar::ShouldAddDraggedPanel(const Panel* panel,
-                                     int drag_x,
-                                     int drag_y) {
-  return drag_y + panel->total_height() >
+                                     const Point& drag_pos) {
+  return drag_pos.y + panel->total_height() >
          wm()->height() - kPanelAttachThresholdPixels;
 }
 
 void PanelBar::HandleInputWindowButtonPress(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 (wm()->IsModalWindowFocused())
     return;
 
   CHECK(xid == anchor_input_xid_);
   if (button != 1)
     return;
 
   // Destroy the anchor and collapse the corresponding panel.
   DLOG(INFO) << "Got button press in anchor window";
   Panel* panel = anchor_panel_;
   DestroyAnchor();
   if (panel)
     CollapsePanel(panel, kPanelStateAnimMs);
   else
     LOG(WARNING) << "Anchor panel no longer exists";
 }
 
 void PanelBar::HandleInputWindowPointerEnter(XWindow xid,
-                                             int x, int y,
-                                             int x_root, int y_root,
+                                             const Point& relative_pos,
+                                             const Point& absolute_pos,
                                              XTime timestamp) {
   if (xid == show_collapsed_panels_input_xid_) {
     DLOG(INFO) << "Got mouse enter in show-collapsed-panels window";
-    if (x_root >= wm()->width() - packed_panel_width_) {
+    if (absolute_pos.x >= wm()->width() - packed_panel_width_) {
       // If the user moves the pointer down quickly to the bottom of the
       // screen, it's possible that it could end up below a collapsed panel
       // without us having received an enter event in the panel's titlebar.
       // Show the panels immediately in this case.
       ShowCollapsedPanels();
     } else {
       // Otherwise, set up a timeout to show the panels if we're not already
       // doing so.
       if (collapsed_panel_state_ != COLLAPSED_PANEL_STATE_SHOWN &&
           collapsed_panel_state_ != COLLAPSED_PANEL_STATE_WAITING_TO_SHOW) {
         collapsed_panel_state_ = COLLAPSED_PANEL_STATE_WAITING_TO_SHOW;
         DCHECK_EQ(show_collapsed_panels_timeout_id_, -1);
         show_collapsed_panels_timeout_id_ =
             wm()->event_loop()->AddTimeout(
                 NewPermanentCallback(
                     this, &PanelBar::HandleShowCollapsedPanelsTimeout),
                 kShowCollapsedPanelsDelayMs, 0);
       }
     }
   }
 }
 
 void PanelBar::HandleInputWindowPointerLeave(XWindow xid,
-                                             int x, int y,
-                                             int x_root, int y_root,
+                                             const Point& relative_pos,
+                                             const Point& absolute_pos,
                                              XTime timestamp) {
   if (xid == show_collapsed_panels_input_xid_) {
     DLOG(INFO) << "Got mouse leave in show-collapsed-panels window";
     if (collapsed_panel_state_ == COLLAPSED_PANEL_STATE_WAITING_TO_SHOW) {
       collapsed_panel_state_ = COLLAPSED_PANEL_STATE_HIDDEN;
       DisableShowCollapsedPanelsTimeout();
     }
   }
 }
 
-void PanelBar::HandlePanelButtonPress(
-    Panel* panel, int button, XTime timestamp) {
+void PanelBar::HandlePanelButtonPress(Panel* panel,
+                                      int button,
+                                      XTime timestamp) {
   if (wm()->IsModalWindowFocused())
     return;
   DCHECK(panel);
   DLOG(INFO) << "Got button press in panel " << panel->xid_str()
              << "; giving it the focus";
   // Get rid of the passive button grab, and then ungrab the pointer
   // and replay events so the panel will get a copy of the click.
   FocusPanel(panel, timestamp);
 }
 
 void PanelBar::HandlePanelTitlebarPointerEnter(Panel* panel, XTime timestamp) {
   DCHECK(panel);
   DLOG(INFO) << "Got pointer enter in panel " << panel->xid_str()
              << "'s titlebar";
   if (collapsed_panel_state_ != COLLAPSED_PANEL_STATE_SHOWN &&
       !panel->is_expanded()) {
     ShowCollapsedPanels();
   }
 }
 
 void PanelBar::HandleSetPanelStateMessage(Panel* panel, bool expand) {
   DCHECK(panel);
   if (expand)
     ExpandPanel(panel, true, kPanelStateAnimMs);
   else
     CollapsePanel(panel, kPanelStateAnimMs);
 }
 
 bool PanelBar::HandleNotifyPanelDraggedMessage(Panel* panel,
-                                               int drag_x,
-                                               int drag_y) {
+                                               const Point& drag_pos) {
   DCHECK(panel);
   DLOG(INFO) << "Notified about drag of panel " << panel->xid_str()
-             << " to (" << drag_x << ", " << drag_y << ")";
+             << " to " << drag_pos;
 
   if (FLAGS_allow_panels_to_be_detached) {
     const int y_threshold =
         wm()->height() - panel->total_height() - kPanelDetachThresholdPixels;
-    if (drag_y <= y_threshold)
+    if (drag_pos.y <= y_threshold)
       return false;
   }
 
   if (dragged_panel_ != panel) {
     if (dragged_panel_) {
       LOG(WARNING) << "Abandoning dragged panel " << dragged_panel_->xid_str()
                    << " in favor of " << panel->xid_str();
       HandlePanelDragComplete(dragged_panel_);
     }
 
     DLOG(INFO) << "Starting drag of panel " << panel->xid_str();
     dragged_panel_ = panel;
     dragging_panel_horizontally_ =
-        (abs(drag_x - panel->right()) > abs(drag_y - panel->titlebar_y()));
+        (abs(drag_pos.x - panel->right()) >
+         abs(drag_pos.y - panel->titlebar_y()));
     panel->StackAtTopOfLayer(StackingManager::LAYER_DRAGGED_PANEL);
   }
 
   if (dragging_panel_horizontally_) {
-    panel->MoveX(drag_x, 0);
+    panel->MoveX(drag_pos.x, 0);
     PanelInfo* info = GetPanelInfoOrDie(panel);
 
     // Make sure that the panel is in the correct vector (floating vs.
     // packed) for its current position.
 
     // We want to find the total width of all packed panels (except the
     // dragged panel, if it's packed), plus the padding that would go to
     // the right of the dragged panel (which differs depending on whether
     // there are other packed panels or not).
     int packed_width_with_padding = packed_panel_width_;
     if (!info->is_floating) {
       packed_width_with_padding -= panel->width();
     } else {
       packed_width_with_padding +=
           packed_panels_.empty() ? kRightPaddingPixels : kPixelsBetweenPanels;
     }
 
     const int floating_threshold =
         wm()->width() - packed_width_with_padding -
         kFloatingPanelThresholdPixels;
 
     bool moved_to_other_vector = false;
-    if (drag_x < floating_threshold) {
+    if (drag_pos.x < floating_threshold) {
       moved_to_other_vector = MovePanelToFloatingVector(panel, info);
-      info->desired_right = drag_x;
+      info->desired_right = drag_pos.x;
       ArrangePanels(false, NULL);
     } else {
       moved_to_other_vector = MovePanelToPackedVector(panel, info);
       ArrangePanels(false, NULL);
     }
 
     if (!moved_to_other_vector) {
       // If we didn't move the panel to the other vector, then just make
       // sure that it's in the correct position within its current vector.
       PanelVector* panel_vector =
           info->is_floating ? &floating_panels_ : &packed_panels_;
       if (ReorderPanelInVector(panel, panel_vector) && !info->is_floating)
         ArrangePanels(false, NULL);
     }
 
   } else {
     // If we're dragging vertically, cap the Y value between the lowest and
     // highest positions that the panel can take while in the bar.
     const int capped_y =
-        max(min(drag_y, wm()->height() - panel->titlebar_height()),
+        max(min(drag_pos.y, wm()->height() - panel->titlebar_height()),
             wm()->height() - panel->total_height());
     panel->MoveY(capped_y, 0);
   }
   return true;
 }
 
 void PanelBar::HandleNotifyPanelDragCompleteMessage(Panel* panel) {
   DCHECK(panel);
   HandlePanelDragComplete(panel);
 }
 
 void PanelBar::HandleFocusPanelMessage(Panel* panel, XTime timestamp) {
   DCHECK(panel);
   if (!panel->is_expanded())
     ExpandPanel(panel, false, kPanelStateAnimMs);
   FocusPanel(panel, timestamp);
 }
 
 void PanelBar::HandlePanelResizeRequest(Panel* panel,
-                                        int req_width, int req_height) {
+                                        const Size& requested_size) {
   DCHECK(panel);
-  panel->ResizeContent(req_width, req_height, GRAVITY_SOUTHEAST, true);
+  panel->ResizeContent(requested_size, GRAVITY_SOUTHEAST, true);
   ArrangePanels(true, NULL);
 }
 
 void PanelBar::HandlePanelResizeByUser(Panel* panel) {
   DCHECK(panel);
   Panel* fixed_floating_panel = NULL;
   PanelInfo* info = GetPanelInfoOrDie(panel);
   if (info->is_floating) {
     info->desired_right = panel->right();
     fixed_floating_panel = panel;
@@ skipping 391 matching lines @@
     if (info->desired_right - panel->width() < left_edge)
       info->desired_right = left_edge + panel->width();
     left_edge = info->desired_right + kPixelsBetweenPanels;
   }
 }
 
 void PanelBar::CreateAnchor(Panel* panel) {
   Point pointer_pos;
   wm()->xconn()->QueryPointerPosition(&pointer_pos);
 
-  const int width = anchor_actor_->GetWidth();
-  const int height = anchor_actor_->GetHeight();
-  const int x = min(max(static_cast<int>(pointer_pos.x - 0.5 * width), 0),
-                    wm()->width() - width);
-  const int y = wm()->height() - height;
-
-  wm()->ConfigureInputWindow(anchor_input_xid_, Rect(x, y, width, height));
+  const Rect anchor_bounds(
+      min(max(static_cast<int>(pointer_pos.x - 0.5 * anchor_actor_->GetWidth()),
+              0),
+          wm()->width() - anchor_actor_->GetWidth()),
+      wm()->height() - anchor_actor_->GetHeight(),
+      anchor_actor_->GetWidth(),
+      anchor_actor_->GetHeight());
+  wm()->ConfigureInputWindow(anchor_input_xid_, anchor_bounds);
   anchor_panel_ = panel;
-  anchor_actor_->Move(x, y, 0);
+  anchor_actor_->Move(anchor_bounds.x, anchor_bounds.y, 0);
   anchor_actor_->SetOpacity(1, kAnchorFadeAnimMs);
 
   // We might not get a LeaveNotify event*, so we also poll the pointer
   // position.
 
   // * If the mouse cursor has already been moved away before the anchor
   // input window gets created, the anchor never gets a mouse leave event.
   // Additionally, Chrome appears to be stacking its status bubble window
   // above all other windows, so we sometimes get a leave event as soon as
   // we slide a panel up.
   anchor_pointer_watcher_.reset(
       new PointerPositionWatcher(
           wm()->event_loop(),
           wm()->xconn(),
           NewPermanentCallback(this, &PanelBar::DestroyAnchor),
           false,  // watch_for_entering_target=false
-          x, y, width, height));
+          anchor_bounds));
 }
 
 void PanelBar::DestroyAnchor() {
   wm()->xconn()->ConfigureWindowOffscreen(anchor_input_xid_);
   anchor_actor_->SetOpacity(0, kAnchorFadeAnimMs);
   anchor_panel_ = NULL;
   anchor_pointer_watcher_.reset();
 }
 
 Panel* PanelBar::GetNearestExpandedPanel(Panel* panel) {
@@ skipping 37 matching lines @@
   }
 }
 
 void PanelBar::StartHideCollapsedPanelsWatcher() {
   hide_collapsed_panels_pointer_watcher_.reset(
       new PointerPositionWatcher(
           wm()->event_loop(),
           wm()->xconn(),
           NewPermanentCallback(this, &PanelBar::HideCollapsedPanels),
           false,  // watch_for_entering_target=false
-          0, wm()->height() - kHideCollapsedPanelsDistancePixels,
-          wm()->width(), kHideCollapsedPanelsDistancePixels));
+          Rect(0, wm()->height() - kHideCollapsedPanelsDistancePixels,
+               wm()->width(), kHideCollapsedPanelsDistancePixels)));
 }
 
 void PanelBar::ShowCollapsedPanels() {
   DLOG(INFO) << "Showing collapsed panels";
   DisableShowCollapsedPanelsTimeout();
   collapsed_panel_state_ = COLLAPSED_PANEL_STATE_SHOWN;
 
   for (PanelSet::iterator it = all_panels_.begin();
        it != all_panels_.end(); ++it) {
     Panel* panel = *it;
@@ skipping 44 matching lines @@
   }
 }
 
 void PanelBar::HandleShowCollapsedPanelsTimeout() {
   DCHECK(collapsed_panel_state_ == COLLAPSED_PANEL_STATE_WAITING_TO_SHOW);
   DisableShowCollapsedPanelsTimeout();
   ShowCollapsedPanels();
 }
 
 }  // namespace window_manager