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

layout/layout_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/layout/layout_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <cstdio>
 #include <tr1/memory>
@@ skipping 112 matching lines @@
       overview_drag_last_x_(-1),
       saw_map_request_(false),
       first_toplevel_chrome_window_mapped_(false),
       event_consumer_registrar_(new EventConsumerRegistrar(wm, this)),
       key_bindings_actions_(new KeyBindingsActionRegistrar(wm->key_bindings())),
       active_mode_key_bindings_group_(new KeyBindingsGroup(wm->key_bindings())),
       overview_mode_key_bindings_group_(
           new KeyBindingsGroup(wm->key_bindings())),
       post_toplevel_key_bindings_group_(
           new KeyBindingsGroup(wm->key_bindings())),
-      background_xid_(wm_->CreateInputWindow(wm_->bounds(), 0)),
+      background_xid_(wm_->CreateInputWindow(wm_->root_bounds(), 0)),
       should_layout_windows_after_initial_pixmap_(false),
       should_animate_after_initial_pixmap_(false) {
   wm_->focus_manager()->RegisterFocusChangeListener(this);
   panel_manager_->RegisterAreaChangeListener(this);
   panel_manager_->GetArea(&panel_manager_left_width_,
                           &panel_manager_right_width_);
 
   // Disable the overview key bindings, since we start in active mode.
   overview_mode_key_bindings_group_->Disable();
   post_toplevel_key_bindings_group_->Disable();
@@ skipping 191 matching lines @@
 }
 
 bool LayoutManager::IsInputWindow(XWindow xid) {
   return (GetSnapshotWindowByInputXid(xid) != NULL);
 }
 
 void LayoutManager::HandleScreenResize() {
   MoveAndResizeForAvailableArea();
   ConfigureBackground(wm_->width(), wm_->height());
   if (background_xid_)
-    wm_->xconn()->ResizeWindow(background_xid_,
-                               Size(wm_->width(), wm_->height()));
+    wm_->xconn()->ResizeWindow(background_xid_, wm_->root_size());
 }
 
 bool LayoutManager::HandleWindowMapRequest(Window* win) {
   DCHECK(win);
   saw_map_request_ = true;
 
   if (!IsHandledWindowType(win->type()))
     return false;
 
   if (win->type() == chromeos::WM_IPC_WINDOW_CHROME_TAB_FAV_ICON ||
       win->type() == chromeos::WM_IPC_WINDOW_CHROME_TAB_SNAPSHOT ||
       win->type() == chromeos::WM_IPC_WINDOW_CHROME_TAB_TITLE) {
     wm_->stacking_manager()->StackWindowAtTopOfLayer(
         win,
         StackingManager::LAYER_SNAPSHOT_WINDOW,
         StackingManager::SHADOW_AT_BOTTOM_OF_LAYER);
   } else {
     wm_->stacking_manager()->StackWindowAtTopOfLayer(
         win,
         StackingManager::LAYER_TOPLEVEL_WINDOW,
         StackingManager::SHADOW_AT_BOTTOM_OF_LAYER);
 
     // Resize windows to their final size before mapping them to give them
     // more time to draw their contents.
     if ((win->type() == chromeos::WM_IPC_WINDOW_CHROME_TOPLEVEL ||
          win->type() == chromeos::WM_IPC_WINDOW_UNKNOWN) &&
         !win->transient_for_xid()) {
-      win->ResizeClient(width_, height_, GRAVITY_NORTHWEST);
+      win->Resize(Size(width_, height_), GRAVITY_NORTHWEST);
     }
   }
   return true;
 }
 
 void LayoutManager::HandleWindowMap(Window* win) {
   DCHECK(win);
   if (win->override_redirect() || !IsHandledWindowType(win->type()))
     return;
 
@@ skipping 207 matching lines @@
   DCHECK(win);
 
   if (should_layout_windows_after_initial_pixmap_ &&
       current_toplevel_ && current_toplevel_->win() == win) {
     should_layout_windows_after_initial_pixmap_ = false;
     LayoutWindows(should_animate_after_initial_pixmap_);
   }
 }
 
 void LayoutManager::HandleWindowConfigureRequest(
-    Window* win, int req_x, int req_y, int req_width, int req_height) {
+    Window* win, const Rect& requested_bounds) {
   if (win->type() == chromeos::WM_IPC_WINDOW_CHROME_TAB_SNAPSHOT) {
     SnapshotWindow* snapshot = GetSnapshotWindowByWindow(*win);
     if (snapshot) {
-      if (req_width != win->client_width() ||
-          req_height != win->client_height()) {
-        win->ResizeClient(req_width, req_height, GRAVITY_NORTHWEST);
+      if (requested_bounds.size() != win->client_size()) {
+        win->Resize(requested_bounds.size(), GRAVITY_NORTHWEST);
         LayoutWindows(false);
       } else {
         win->SendSyntheticConfigureNotify();
       }
     }
     return;
   }
 
   ToplevelWindow* toplevel_owner = GetToplevelWindowOwningTransientWindow(*win);
   if (toplevel_owner) {
     toplevel_owner->HandleTransientWindowConfigureRequest(
-        win, req_x, req_y, req_width, req_height);
+        win, requested_bounds);
     return;
   }
 
   // Ignore requests to resize toplevel windows, but send them fake
   // ConfigureNotify events to let them know that we saw the requests.
   ToplevelWindow* toplevel = GetToplevelWindowByWindow(*win);
   if (toplevel) {
     win->SendSyntheticConfigureNotify();
     return;
   }
 }
 
 void LayoutManager::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 (xid == background_xid_ && button == 1) {
-    overview_drag_last_x_ = x;
+    overview_drag_last_x_ = relative_pos.x;
     overview_background_event_coalescer_->Start();
     return;
   }
 
   Window* win = wm_->GetWindow(xid);
   if (!win)
     return;
 
   // Otherwise, it probably means that the user previously focused a panel
   // and then clicked back on a toplevel or transient window.
   ToplevelWindow* toplevel = GetToplevelWindowOwningTransientWindow(*win);
   if (!toplevel)
     toplevel = GetToplevelWindowByWindow(*win);
   if (toplevel)
     toplevel->HandleButtonPress(win, timestamp);
 }
 
 void LayoutManager::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) {
   SnapshotWindow* snapshot = GetSnapshotWindowByInputXid(xid);
   if (snapshot) {
     if (button == 1) {  // Ignore buttons other than 1.
       LOG_IF(WARNING, mode_ != MODE_OVERVIEW)
           << "Got a click in input window " << XidStr(xid)
           << " for snapshot window " << snapshot->win()->xid_str()
           << " while not in overview mode";
-      snapshot->HandleButtonRelease(timestamp, x_root - x_, y_root - y_);
+      snapshot->HandleButtonRelease(
+          timestamp, absolute_pos.x - x_, absolute_pos.y - y_);
     }
     return;
   }
 
   if (xid != background_xid_ || button != 1)
     return;
 
   // The X server automatically removes our asynchronous pointer grab when
   // the mouse buttons are released.
   overview_background_event_coalescer_->Stop();
 
   // We need to do one last configure to update the input windows'
   // positions, which we didn't bother doing while panning.
   LayoutWindows(true);
 
   return;
 }
 
 void LayoutManager::HandlePointerMotion(XWindow xid,
-                                        int x, int y,
-                                        int x_root, int y_root,
+                                        const Point& relative_pos,
+                                        const Point& absolute_pos,
                                         XTime timestamp) {
   if (xid == background_xid_)
-    overview_background_event_coalescer_->StorePosition(x, y);
+    overview_background_event_coalescer_->StorePosition(relative_pos);
 }
 
 void LayoutManager::HandleChromeMessage(const WmIpc::Message& message) {
   if (message.type() == chromeos::WM_IPC_MESSAGE_WM_CYCLE_WINDOWS)
     CycleCurrentToplevelWindow(message.param(0) != 0);
 }
 
 void LayoutManager::HandleClientMessage(XWindow xid,
                                         XAtom message_type,
                                         const long data[5]) {
@@ skipping 446 matching lines @@
   // between the new and old right edge, then we keep the right sides of the
   // windows fixed while resizing.
   Gravity resize_gravity =
       abs(x_ - old_x) > abs(x_ + width_ - (old_x + old_width)) ?
       GRAVITY_NORTHEAST :
       GRAVITY_NORTHWEST;
 
   for (ToplevelWindows::iterator it = toplevels_.begin();
        it != toplevels_.end(); ++it) {
     if (it->get() == fullscreen_toplevel_) {
-      (*it)->win()->ResizeClient(wm_->width(), wm_->height(),
-                                 GRAVITY_NORTHWEST);
+      (*it)->win()->Resize(wm_->root_size(), GRAVITY_NORTHWEST);
     } else {
-      (*it)->win()->ResizeClient(width_, height_, resize_gravity);
+      (*it)->win()->Resize(Size(width_, height_), resize_gravity);
     }
   }
 
   LayoutWindows(true);
 }
 
 void LayoutManager::SetCurrentToplevel(ToplevelWindow* toplevel) {
   CHECK(toplevel);
 
   // If we're not in active mode, nothing changes in the layout.
@@ skipping 774 matching lines @@
     }
   }
 
   if (previously_had_modal_transients && modal_transients_.empty())
     EnableKeyBindingsForMode(mode_);
   else if (!previously_had_modal_transients && !modal_transients_.empty())
     DisableKeyBindingsForMode(mode_);
 }
 
 }  // namespace window_manager