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

panels/panel.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/panels/panel.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <string>
@@ skipping 81 matching lines @@
       top_left_input_xid_(wm()->CreateInputWindow(Rect(-1, -1, 1, 1), 0)),
       top_right_input_xid_(wm()->CreateInputWindow(Rect(-1, -1, 1, 1), 0)),
       left_input_xid_(wm()->CreateInputWindow(Rect(-1, -1, 1, 1), 0)),
       right_input_xid_(wm()->CreateInputWindow(Rect(-1, -1, 1, 1), 0)),
       resizable_(false),
       horizontal_resize_allowed_(true),
       vertical_resize_allowed_(true),
       composited_windows_set_up_(false),
       being_dragged_to_new_position_(false),
       resize_drag_xid_(0),
-      resize_drag_start_x_(0),
-      resize_drag_start_y_(0),
-      resize_drag_orig_width_(1),
-      resize_drag_orig_height_(1),
-      resize_drag_last_width_(1),
-      resize_drag_last_height_(1),
       event_consumer_registrar_(
           new EventConsumerRegistrar(wm(), panel_manager)),
       transients_(
           new TransientWindowCollection(
               content_win_, titlebar_win_, true, panel_manager)),
       separator_shadow_(
           Shadow::Create(wm()->compositor(), Shadow::TYPE_PANEL_SEPARATOR)) {
   CHECK(content_win_);
   CHECK(titlebar_win_);
 
@@ skipping 33 matching lines @@
   wm()->xconn()->AddButtonGrabOnWindow(right_input_xid_, 1, event_mask, false);
 
   content_win_->SetVisibility(Window::VISIBILITY_HIDDEN);
   titlebar_win_->SetVisibility(Window::VISIBILITY_HIDDEN);
 
   content_win_->SetShadowType(Shadow::TYPE_PANEL_CONTENT);
   titlebar_win_->SetShadowType(Shadow::TYPE_PANEL_TITLEBAR);
 
   // Make sure that the content window's size is within the allowable range.
   UpdateContentWindowSizeLimits();
-  const int capped_width =
+  const Size capped_size(
       min(max(content_win_->client_width(), min_content_width_),
-          max_content_width_);
-  const int capped_height =
+          max_content_width_),
       min(max(content_win_->client_height(), min_content_height_),
-          max_content_height_);
-  if (capped_width != content_win_->client_width() ||
-      capped_height != content_win_->client_height()) {
-    content_win_->ResizeClient(capped_width, capped_height, GRAVITY_NORTHWEST);
-  }
+          max_content_height_));
+  if (capped_size != content_win_->client_size())
+    content_win_->Resize(capped_size, GRAVITY_NORTHWEST);
 
   content_win_->CopyClientBoundsToRect(&content_bounds_);
   titlebar_win_->CopyClientBoundsToRect(&titlebar_bounds_);
 
   if (!kTopCursor)
     InitCursors(wm()->xconn());
   wm()->xconn()->SetWindowCursor(top_input_xid_, kTopCursor);
   wm()->xconn()->SetWindowCursor(top_left_input_xid_, kTopLeftCursor);
   wm()->xconn()->SetWindowCursor(top_right_input_xid_, kTopRightCursor);
   wm()->xconn()->SetWindowCursor(left_input_xid_, kLeftCursor);
@@ skipping 82 matching lines @@
   windows_out->clear();
   windows_out->reserve(5);
   windows_out->push_back(top_input_xid_);
   windows_out->push_back(top_left_input_xid_);
   windows_out->push_back(top_right_input_xid_);
   windows_out->push_back(left_input_xid_);
   windows_out->push_back(right_input_xid_);
 }
 
 void Panel::HandleInputWindowButtonPress(
-    XWindow xid, int x, int y, int button, XTime timestamp) {
+    XWindow xid, const Point& relative_pos, int button, XTime timestamp) {
   if (wm()->IsModalWindowFocused())
     return;
   if (button != 1)
     return;
   DCHECK(resize_drag_xid_ == 0)
       << "Panel " << xid_str() << " got button press in " << XidStr(xid)
       << " but already has resize drag XID " << XidStr(resize_drag_xid_);
 
   resize_drag_xid_ = xid;
-  resize_drag_start_x_ = x;
-  resize_drag_start_y_ = y;
-  resize_drag_orig_width_ = resize_drag_last_width_ = content_width();
-  resize_drag_orig_height_ = resize_drag_last_height_ = content_height();
+  resize_drag_start_pos_ = relative_pos;
+  resize_drag_orig_size_ = content_size();
+  resize_drag_last_size_ = content_size();
   resize_event_coalescer_.Start();
 
   if (!FLAGS_panel_opaque_resize) {
     DCHECK(!resize_box_.get());
     resize_box_.reset(new ResizeBox(wm()->compositor()));
     resize_box_->SetBounds(
         Rect(titlebar_x(), titlebar_y(), content_width(), total_height()), 0);
     wm()->stage()->AddActor(resize_box_->actor());
     resize_box_->actor()->SetOpacity(kResizeBoxOpacity, 0);
     wm()->stacking_manager()->StackActorAtTopOfLayer(
         resize_box_->actor(), StackingManager::LAYER_DRAGGED_PANEL);
     resize_box_->actor()->Show();
   }
 }
 
 void Panel::HandleInputWindowButtonRelease(
-    XWindow xid, int x, int y, int button, XTime timestamp) {
+    XWindow xid, const Point& relative_pos, int button, XTime timestamp) {
   if (button != 1)
     return;
   if (xid != resize_drag_xid_) {
     LOG(WARNING) << "Ignoring button release for unexpected input window "
                  << XidStr(xid) << " (currently in resize drag initiated by "
                  << XidStr(resize_drag_xid_) << ")";
     return;
   }
   // GrabButton-initiated asynchronous pointer grabs are automatically removed
   // by the X server when *all* buttons are released, but we specifically
   // want the grab to end when the first button is released, to prevent the
   // user from essentially transferring the grab from one button to
   // another: see http://crosbug.com/4267.
   wm()->xconn()->UngrabPointer(false, timestamp);
-  resize_event_coalescer_.StorePosition(x, y);
+  resize_event_coalescer_.StorePosition(relative_pos);
   resize_event_coalescer_.Stop();
   resize_drag_xid_ = 0;
 
   if (FLAGS_panel_opaque_resize) {
     ConfigureInputWindows();
   } else {
     DCHECK(resize_box_.get());
     resize_box_.reset(NULL);
-    ResizeContent(resize_drag_last_width_, resize_drag_last_height_,
-                  resize_drag_gravity_, true);
+    ResizeContent(resize_drag_last_size_, resize_drag_gravity_, true);
   }
 
   // Let the container know about the resize.
   panel_manager_->HandlePanelResizeByUser(this);
 }
 
-void Panel::HandleInputWindowPointerMotion(XWindow xid, int x, int y) {
+void Panel::HandleInputWindowPointerMotion(XWindow xid,
+                                           const Point& relative_pos) {
   if (xid != resize_drag_xid_) {
     LOG(WARNING) << "Ignoring motion event for unexpected input window "
                  << XidStr(xid) << " (currently in resize drag initiated by "
                  << XidStr(resize_drag_xid_) << ")";
     return;
   }
-  resize_event_coalescer_.StorePosition(x, y);
+  resize_event_coalescer_.StorePosition(relative_pos);
 }
 
-void Panel::Move(int right, int y, int anim_ms) {
-  titlebar_bounds_.x = right - titlebar_bounds_.width;
-  titlebar_bounds_.y = y;
-  content_bounds_.x = right - content_bounds_.width;
-  content_bounds_.y = y + titlebar_bounds_.height;
+void Panel::Move(const Point& top_right_origin, int anim_ms) {
+  titlebar_bounds_.x = top_right_origin.x - titlebar_bounds_.width;
+  titlebar_bounds_.y = top_right_origin.y;
+  content_bounds_.x = top_right_origin.x - content_bounds_.width;
+  content_bounds_.y = top_right_origin.y + titlebar_bounds_.height;
 
   transients_->CloseAllWindows();
 
   if (can_configure_windows()) {
     titlebar_win_->Move(titlebar_bounds_.position(), anim_ms);
     content_win_->Move(content_bounds_.position(), anim_ms);
     separator_shadow_->Move(content_bounds_.x, content_bounds_.y, anim_ms);
     if (!composited_windows_set_up_) {
       titlebar_win_->SetVisibility(Window::VISIBILITY_SHOWN);
       content_win_->SetVisibility(Window::VISIBILITY_SHOWN);
@@ skipping 36 matching lines @@
     separator_shadow_->MoveY(content_bounds_.y, anim_ms);
     if (!being_dragged_to_new_position_)
       ConfigureInputWindows();
   }
 }
 
 void Panel::SetTitlebarWidth(int width) {
   CHECK(width > 0);
   titlebar_bounds_.resize(width, titlebar_bounds_.height, GRAVITY_NORTHEAST);
   if (can_configure_windows()) {
-    titlebar_win_->ResizeClient(
-        width, titlebar_win_->client_height(), GRAVITY_NORTHEAST);
+    titlebar_win_->Resize(
+        Size(width, titlebar_win_->client_height()), GRAVITY_NORTHEAST);
   }
 }
 
 void Panel::SetShadowOpacity(double opacity, int anim_ms) {
   titlebar_win_->SetShadowOpacity(opacity, anim_ms);
   content_win_->SetShadowOpacity(opacity, anim_ms);
 }
 
 void Panel::SetResizable(bool resizable) {
   if (resizable != resizable_) {
@@ skipping 36 matching lines @@
 }
 
 WindowManager* Panel::wm() {
   return panel_manager_->wm();
 }
 
 void Panel::TakeFocus(XTime timestamp) {
   wm()->FocusWindow(content_win_, timestamp);
 }
 
-void Panel::ResizeContent(int width, int height,
+void Panel::ResizeContent(const Size& size,
                           Gravity gravity,
                           bool configure_input_windows) {
-  DCHECK_GT(width, 0);
-  DCHECK_GT(height, 0);
+  DCHECK(!size.empty());
 
-  const int capped_width =
-      min(max(width, min_content_width_), max_content_width_);
-  const int capped_height =
-      min(max(height, min_content_height_), max_content_height_);
+  const Size capped_size(
+      min(max(size.width, min_content_width_), max_content_width_),
+      min(max(size.height, min_content_height_), max_content_height_));
 
-  if (capped_width != width || capped_height != height) {
+  if (capped_size != size) {
     LOG(WARNING) << "Capped resize of panel " << xid_str() << " to "
-                 << capped_width << "x" << capped_height
-                 << " (request was for " << width << "x" << height << ")";
-    width = capped_width;
-    height = capped_height;
+                 << capped_size << " (request was for " << size << ")";
   }
 
-  if (width == content_bounds_.width && height == content_bounds_.height)
+  if (capped_size == content_bounds_.size())
     return;
 
-  bool changing_height = (height != content_bounds_.height);
+  bool changing_height = (capped_size.height != content_bounds_.height);
 
-  content_bounds_.resize(width, height, gravity);
-  titlebar_bounds_.resize(width, titlebar_bounds_.height, gravity);
+  content_bounds_.resize(capped_size, gravity);
+  titlebar_bounds_.resize(capped_size.width, titlebar_bounds_.height, gravity);
   if (changing_height)
     titlebar_bounds_.y = content_bounds_.y - titlebar_bounds_.height;
 
   transients_->CloseAllWindows();
 
   if (can_configure_windows()) {
-    content_win_->ResizeClient(width, height, gravity);
-    titlebar_win_->ResizeClient(width, titlebar_bounds_.height, gravity);
+    content_win_->Resize(capped_size, gravity);
+    titlebar_win_->Resize(Size(capped_size.width, titlebar_bounds_.height),
+                          gravity);
     separator_shadow_->Move(content_x(), content_y(), 0);
     separator_shadow_->Resize(content_width(), 0, 0);
 
     // TODO: This is broken if we start resizing scaled windows.
     if (changing_height)
       titlebar_win_->Move(titlebar_bounds_.position(), 0);
   }
 
   if (configure_input_windows)
     ConfigureInputWindows();
@@ skipping 15 matching lines @@
     wm_state[wm()->GetXAtom(ATOM_NET_WM_STATE_FULLSCREEN)] = is_fullscreen_;
     content_win_->ChangeWmState(wm_state);
   }
 
   if (fullscreen) {
     wm()->stacking_manager()->StackWindowAtTopOfLayer(
         content_win_,
         StackingManager::LAYER_FULLSCREEN_WINDOW,
         StackingManager::SHADOW_AT_BOTTOM_OF_LAYER);
     content_win_->Move(Point(0, 0), 0);
-    content_win_->ResizeClient(
-        wm()->width(), wm()->height(), GRAVITY_NORTHWEST);
+    content_win_->Resize(wm()->root_size(), GRAVITY_NORTHWEST);
     if (!content_win_->IsFocused()) {
       LOG(WARNING) << "Fullscreening unfocused panel " << xid_str()
                    << ", so automatically giving it the focus";
       wm()->FocusWindow(content_win_, wm()->GetCurrentTimeFromServer());
     }
   } else {
-    content_win_->ResizeClient(
-        content_bounds_.width, content_bounds_.height, GRAVITY_NORTHWEST);
+    content_win_->Resize(content_bounds_.size(), GRAVITY_NORTHWEST);
     content_win_->Move(content_bounds_.position(), 0);
-    titlebar_win_->ResizeClient(
-        titlebar_bounds_.width, titlebar_bounds_.height, GRAVITY_NORTHWEST);
+    titlebar_win_->Resize(titlebar_bounds_.size(), GRAVITY_NORTHWEST);
     titlebar_win_->Move(titlebar_bounds_.position(), 0);
     separator_shadow_->Move(content_x(), content_y(), 0);
     separator_shadow_->Resize(content_width(), 0, 0);
     StackAtTopOfLayer(stacking_layer_);
   }
 }
 
 void Panel::HandleScreenResize() {
   if (is_fullscreen_) {
-    DLOG(INFO) << "Resizing fullscreen panel to " << wm()->width()
-               << "x" << wm()->height() << " in response to screen resize";
-    content_win_->ResizeClient(
-        wm()->width(), wm()->height(), GRAVITY_NORTHWEST);
+    DLOG(INFO) << "Resizing fullscreen panel to " << wm()->root_size()
+               << " in response to screen resize";
+    content_win_->Resize(wm()->root_size(), GRAVITY_NORTHWEST);
   }
 }
 
 void Panel::HandleContentWindowSizeHintsChange() {
   UpdateContentWindowSizeLimits();
 }
 
 void Panel::HandleDragStart() {
   if (being_dragged_to_new_position_)
     return;
@@ skipping 48 matching lines @@
         states.find(wm()->GetXAtom(ATOM_NET_WM_STATE_MODAL));
     if (it != states.end()) {
       map<XAtom, bool> new_state;
       new_state[it->first] = it->second;
       win->ChangeWmState(new_state);
     }
   }
 }
 
 void Panel::HandleTransientWindowConfigureRequest(
-    Window* win, int req_x, int req_y, int req_width, int req_height) {
+    Window* win, const Rect& requested_bounds) {
   DCHECK(win);
   DCHECK(transients_->ContainsWindow(*win));
-  transients_->HandleConfigureRequest(
-      win, req_x, req_y, req_width, req_height);
+  transients_->HandleConfigureRequest(win, requested_bounds);
 }
 
 void Panel::ConfigureInputWindows() {
   if (!resizable_ ||
       (!horizontal_resize_allowed_ && !vertical_resize_allowed_)) {
     wm()->xconn()->ConfigureWindowOffscreen(top_input_xid_);
     wm()->xconn()->ConfigureWindowOffscreen(top_left_input_xid_);
     wm()->xconn()->ConfigureWindowOffscreen(top_right_input_xid_);
     wm()->xconn()->ConfigureWindowOffscreen(left_input_xid_);
     wm()->xconn()->ConfigureWindowOffscreen(right_input_xid_);
@@ skipping 59 matching lines @@
   // (which is stacked beneath the titlebar) -- we don't want the
   // corner windows to occlude the titlebar.
   wm()->xconn()->StackWindow(top_input_xid_, content_win_->xid(), false);
   wm()->xconn()->StackWindow(top_left_input_xid_, content_win_->xid(), false);
   wm()->xconn()->StackWindow(top_right_input_xid_, content_win_->xid(), false);
   wm()->xconn()->StackWindow(left_input_xid_, content_win_->xid(), false);
   wm()->xconn()->StackWindow(right_input_xid_, content_win_->xid(), false);
 }
 
 void Panel::ApplyResize() {
-  int dx = resize_event_coalescer_.x() - resize_drag_start_x_;
-  int dy = resize_event_coalescer_.y() - resize_drag_start_y_;
+  int dx = resize_event_coalescer_.x() - resize_drag_start_pos_.x;
+  int dy = resize_event_coalescer_.y() - resize_drag_start_pos_.y;
   resize_drag_gravity_ = GRAVITY_NORTHWEST;
 
   if (resize_drag_xid_ == top_input_xid_) {
     resize_drag_gravity_ = GRAVITY_SOUTHWEST;
     dx = 0;
     dy *= -1;
   } else if (resize_drag_xid_ == top_left_input_xid_) {
     resize_drag_gravity_ = GRAVITY_SOUTHEAST;
     dx *= -1;
     dy *= -1;
   } else if (resize_drag_xid_ == top_right_input_xid_) {
     resize_drag_gravity_ = GRAVITY_SOUTHWEST;
     dy *= -1;
   } else if (resize_drag_xid_ == left_input_xid_) {
     resize_drag_gravity_ = GRAVITY_NORTHEAST;
     dx *= -1;
     dy = 0;
   } else if (resize_drag_xid_ == right_input_xid_) {
     resize_drag_gravity_ = GRAVITY_NORTHWEST;
     dy = 0;
   }
 
-  resize_drag_last_width_ =
-      min(max(resize_drag_orig_width_ + dx, min_content_width_),
-          max_content_width_);
-  resize_drag_last_height_ =
-      min(max(resize_drag_orig_height_ + dy, min_content_height_),
-          max_content_height_);
+  resize_drag_last_size_.reset(
+      min(max(resize_drag_orig_size_.width + dx, min_content_width_),
+          max_content_width_),
+      min(max(resize_drag_orig_size_.height + dy, min_content_height_),
+          max_content_height_));
 
   if (FLAGS_panel_opaque_resize) {
     // Avoid reconfiguring the input windows until the end of the resize; moving
     // them now would affect the positions of subsequent motion events from the
     // drag.
-    ResizeContent(resize_drag_last_width_, resize_drag_last_height_,
-                  resize_drag_gravity_, false);
+    ResizeContent(resize_drag_last_size_, resize_drag_gravity_, false);
   } else {
     if (resize_box_.get()) {
       int actor_x = titlebar_x();
       if (resize_drag_gravity_ == GRAVITY_SOUTHEAST ||
           resize_drag_gravity_ == GRAVITY_NORTHEAST) {
-        actor_x -= (resize_drag_last_width_ - resize_drag_orig_width_);
+        actor_x -= (resize_drag_last_size_.width -
+                    resize_drag_orig_size_.width);
       }
       int actor_y = titlebar_y();
       if (resize_drag_gravity_ == GRAVITY_SOUTHWEST ||
           resize_drag_gravity_ == GRAVITY_SOUTHEAST) {
-        actor_y -= (resize_drag_last_height_ - resize_drag_orig_height_);
+        actor_y -= (resize_drag_last_size_.height -
+                    resize_drag_orig_size_.height);
       }
 
-      Rect bounds(actor_x, actor_y, resize_drag_last_width_,
-                  resize_drag_last_height_ + titlebar_height());
+      Rect bounds(actor_x, actor_y,
+                  resize_drag_last_size_.width,
+                  resize_drag_last_size_.height + titlebar_height());
       resize_box_->SetBounds(bounds, 0);
     }
   }
 }
 
 bool Panel::SendStateMessageToChrome() {
   WmIpc::Message msg(chromeos::WM_IPC_MESSAGE_CHROME_NOTIFY_PANEL_STATE);
   msg.set_param(0, is_expanded_);
   return wm()->wm_ipc()->SendMessage(content_win_->xid(), msg);
 }
@@ skipping 14 matching lines @@
 
   max_content_width_ = content_win_->size_hints().max_size.width > 0 ?
                        content_win_->size_hints().max_size.width :
                        numeric_limits<int>::max();
   max_content_height_ = content_win_->size_hints().max_size.height > 0 ?
                         content_win_->size_hints().max_size.height :
                         numeric_limits<int>::max();
 }
 
 }  // namespace window_manager