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

login/login_controller.cc

 // Copyright (c) 2011 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/login/login_controller.h"
 
 #include <map>
 #include <string>
 #include <tr1/memory>
 
@@ skipping 108 matching lines @@
 
 #ifndef TOUCH_UI
   // Hide the mouse cursor until the user moves the pointer.  We map a
   // fullscreen input window so we can tell when they've moved it (at which
   // point we'll destroy the window immediately so other windows can receive
   // input).
   DCHECK(!wm_->logged_in());
   wm_->xconn()->HideCursor();
   hide_mouse_cursor_xid_ =
       wm_->CreateInputWindow(
-          wm_->bounds(), PointerMotionMask | LeaveWindowMask | ButtonPressMask);
+          wm_->root_bounds(),
+          PointerMotionMask | LeaveWindowMask | ButtonPressMask);
   registrar_.RegisterForWindowEvents(hide_mouse_cursor_xid_);
   wm_->xconn()->RaiseWindow(hide_mouse_cursor_xid_);
 #endif
 }
 
 LoginController::~LoginController() {
   if (hide_mouse_cursor_xid_)
     ShowMouseCursor();
 }
 
 bool LoginController::IsInputWindow(XWindow xid) {
   return hide_mouse_cursor_xid_ && xid == hide_mouse_cursor_xid_;
 }
 
 void LoginController::HandleScreenResize() {
   if (requested_destruction_)
     return;
 
   if (background_window_)
-    background_window_->ResizeClient(wm_->width(), wm_->height(),
-                                     GRAVITY_NORTHWEST);
+    background_window_->Resize(wm_->root_size(), GRAVITY_NORTHWEST);
 
   if (all_windows_are_ready_ &&
       is_entry_selection_enabled_ &&
       !waiting_for_browser_window_) {
     vector<Point> origins;
     CalculateIdealOrigins(&origins);
     for (size_t i = 0; i < entries_.size(); ++i) {
       if (!entries_[i]->has_all_windows())
         continue;
       entries_[i]->UpdatePositionAndScale(
@@ skipping 283 matching lines @@
     if (win == background_window_) {
       DoInitialSetupIfWindowsAreReady();
     } else {
       LoginEntry* entry = GetEntryForWindow(win, false);
       if (entry && entry->HasAllPixmaps())
         DoInitialSetupIfWindowsAreReady();
     }
   }
 }
 
-void LoginController::HandleWindowConfigureRequest(Window* win,
-                                                   int req_x,
-                                                   int req_y,
-                                                   int req_width,
-                                                   int req_height) {
+void LoginController::HandleWindowConfigureRequest(
+    Window* win, const Rect& requested_bounds) {
   if (requested_destruction_)
     return;
 
   if (IsLoginWindow(win)) {
     // We manage the x/y, but let Chrome manage the width/height.
-    win->ResizeClient(req_width, req_height, GRAVITY_NORTHWEST);
+    win->Resize(requested_bounds.size(), GRAVITY_NORTHWEST);
   } else if (non_login_xids_.count(win->xid())) {
     // If this is a non-login window that we're managing, just make
     // whatever changes the client asked for.
-    win->MoveClient(req_x, req_y);
+    win->MoveClient(requested_bounds.x, requested_bounds.y);
     win->MoveCompositedToClient();
-    win->ResizeClient(req_width, req_height, GRAVITY_NORTHWEST);
+    win->Resize(requested_bounds.size(), GRAVITY_NORTHWEST);
   }
 }
 
 void LoginController::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 (requested_destruction_)
     return;
 
   if (hide_mouse_cursor_xid_)
     ShowMouseCursor();
 
   // Ignore clicks if a modal window has the focus.
   if (wm_->focus_manager()->focused_win() &&
@@ skipping 15 matching lines @@
   if (login_xids_.count(xid) == 0)
     return;
 
   // Otherwise, this was probably just some window that had a button grab
   // as a result of us calling FocusManager::UseClickToFocusForWindow().
   if (login_window_to_focus_)
     wm_->FocusWindow(login_window_to_focus_, wm_->GetCurrentTimeFromServer());
 }
 
 void LoginController::HandlePointerLeave(XWindow xid,
-                                         int x, int y,
-                                         int x_root, int y_root,
+                                         const Point& relative_pos,
+                                         const Point& absolute_pos,
                                          XTime timestamp) {
   // We'll get a LeaveNotify event when the pointer is grabbed.  We need to show
   // the mouse cursor in response to this since we won't get any MotionNotify
   // events while it's grabbed.  If the user opens a menu with the keyboard
   // (causing a grab) and then tries to move the mouse, we want to make sure
   // that they can see the cursor.
   if (hide_mouse_cursor_xid_)
     ShowMouseCursor();
 }
 
 void LoginController::HandlePointerMotion(XWindow xid,
-                                          int x, int y,
-                                          int x_root, int y_root,
+                                          const Point& relative_pos,
+                                          const Point& absolute_pos,
                                           XTime timestamp) {
   if (hide_mouse_cursor_xid_)
     ShowMouseCursor();
 }
 
 void LoginController::HandleChromeMessage(const WmIpc::Message& msg) {
   if (requested_destruction_)
     return;
 
   switch (msg.type()) {
@@ skipping 430 matching lines @@
 }
 
 void LoginController::NotifySessionManager() {
   wm_->dbus()->CallMethod(login_manager::kSessionManagerServiceName,
                           login_manager::kSessionManagerServicePath,
                           login_manager::kSessionManagerInterface,
                           login_manager::kSessionManagerEmitLoginPromptVisible);
 }
 
 }  // namespace window_manager