Convert GetPreferredSize from:...

chrome/views/chrome_menu.cc

 // Copyright (c) 2006-2008 The Chromium 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 "chrome/views/chrome_menu.h"
 
 #include <windows.h>
 #include <uxtheme.h>
 #include <Vssym32.h>
 
 #include "base/base_drag_source.h"
 #include "base/gfx/native_theme.h"
 #include "base/gfx/skia_utils.h"
 #include "base/message_loop.h"
 #include "base/task.h"
 #include "base/timer.h"
 #include "base/win_util.h"
 #include "chrome/browser/drag_utils.h"
 #include "chrome/common/gfx/chrome_canvas.h"
 #include "chrome/common/gfx/color_utils.h"
 #include "chrome/common/l10n_util.h"
 #include "chrome/common/os_exchange_data.h"
 #include "chrome/views/border.h"
 #include "chrome/views/hwnd_view_container.h"
 #include "chrome/views/root_view.h"
 #include "generated_resources.h"
 
+#undef min
+#undef max
+
 // Margins between the top of the item and the label.
 static const int kItemTopMargin = 3;
 
 // Margins between the bottom of the item and the label.
 static const int kItemBottomMargin = 4;
 
 // Margins between the left of the item and the icon.
 static const int kItemLeftMargin = 4;
 
 // Padding between the label and submenu arrow.
@@ skipping 50 matching lines @@
 
 // Color of the drop indicator.
 static const SkColor kDropIndicatorColor = SK_ColorBLACK;
 
 // Whether or not the gutter should be rendered. The gutter is specific to
 // Vista.
 static bool render_gutter = false;
 
 // Max width of a menu. There does not appear to be an OS value for this, yet
 // both IE and FF restrict the max width of a menu.
-static const LONG kMaxMenuWidth = 400;
+static const int kMaxMenuWidth = 400;
 
 // Period of the scroll timer (in milliseconds).
 static const int kScrollTimerMS = 30;
 
 // Preferred height of menu items. Reset every time a menu is run.
 static int pref_menu_height;
 
 // Are mnemonics shown? This is updated before the menus are shown.
 static bool show_mnemonics;
 
@@ skipping 51 matching lines @@
   }
 
   item_right_margin = kLabelToArrowPadding + arrow_width + kArrowToEdgePadding;
 
   label_start = kItemLeftMargin + check_width + kIconToLabelPadding;
   if (render_gutter)
     label_start += gutter_width + kGutterToLabel;
 
   ReleaseDC(NULL, dc);
 
-  CSize pref;
   MenuItemView menu_item(NULL);
   menu_item.SetTitle(L"blah");  // Text doesn't matter here.
-  menu_item.GetPreferredSize(&pref);
-  pref_menu_height = pref.cy;
+  pref_menu_height = menu_item.GetPreferredSize().height();
 }
 
 namespace {
 
 // Convenience for scrolling the view such that the origin is visible.
 static void ScrollToVisible(View* view) {
   view->ScrollRectToVisible(0, 0, view->width(), view->height());
 }
 
 // MenuScrollTask --------------------------------------------------------------
@@ skipping 87 matching lines @@
 
 class MenuScrollButton : public View {
  public:
   explicit MenuScrollButton(SubmenuView* host, bool is_up)
       : host_(host),
         is_up_(is_up),
         // Make our height the same as that of other MenuItemViews.
         pref_height_(pref_menu_height) {
   }
 
-  virtual void GetPreferredSize(CSize* out) {
-    out->cx = kScrollArrowHeight * 2 - 1;
-    out->cy = pref_height_;
+  virtual gfx::Size GetPreferredSize() {
+    return gfx::Size(kScrollArrowHeight * 2 - 1, pref_height_);
   }
 
   virtual bool CanDrop(const OSExchangeData& data) {
     DCHECK(host_->GetMenuItem()->GetMenuController());
     return true;  // Always return true so that drop events are targeted to us.
   }
 
   virtual void OnDragEntered(const DropTargetEvent& event) {
     DCHECK(host_->GetMenuItem()->GetMenuController());
     host_->GetMenuItem()->GetMenuController()->OnDragEnteredScrollButton(
@@ skipping 65 matching lines @@
   explicit MenuScrollView(View* child) {
     AddChildView(child);
   }
 
   virtual void ScrollRectToVisible(int x, int y, int width, int height) {
     // NOTE: this assumes we only want to scroll in the y direction.
 
     View* child = GetContents();
     // Convert y to view's coordinates.
     y -= child->y();
-    CSize pref;
-    child->GetPreferredSize(&pref);
+    gfx::Size pref = child->GetPreferredSize();
     // Constrain y to make sure we don't show past the bottom of the view.
-    y = std::max(0, std::min(static_cast<int>(pref.cy) - this->height(), y));
+    y = std::max(0, std::min(pref.height() - this->height(), y));
     child->SetY(-y);
   }
 
   // Returns the contents, which is the SubmenuView.
   View* GetContents() {
     return GetChildViewAt(0);
   }
 
  private:
   DISALLOW_EVIL_CONSTRUCTORS(MenuScrollView);
@@ skipping 37 matching lines @@
     int x = insets.left();
     int y = insets.top();
     int width = View::width() - insets.width();
     int content_height = height() - insets.height();
     if (!scroll_up_button_->IsVisible()) {
       scroll_view_->SetBounds(x, y, width, content_height);
       scroll_view_->Layout();
       return;
     }
 
-    CSize pref;
-    scroll_up_button_->GetPreferredSize(&pref);
-    scroll_up_button_->SetBounds(x, y, width, pref.cy);
-    content_height -= pref.cy;
+    gfx::Size pref = scroll_up_button_->GetPreferredSize();
+    scroll_up_button_->SetBounds(x, y, width, pref.height());
+    content_height -= pref.height();
 
-    const int scroll_view_y = y + pref.cy;
+    const int scroll_view_y = y + pref.height();
 
-    scroll_down_button_->GetPreferredSize(&pref);
-    scroll_down_button_->SetBounds(x, height() - pref.cy - insets.top(),
-                                   width, pref.cy);
-    content_height -= pref.cy;
+    pref = scroll_down_button_->GetPreferredSize();
+    scroll_down_button_->SetBounds(x, height() - pref.height() - insets.top(),
+                                   width, pref.height());
+    content_height -= pref.height();
 
     scroll_view_->SetBounds(x, scroll_view_y, width, content_height);
     scroll_view_->Layout();
   }
 
   virtual void DidChangeBounds(const CRect& previous, const CRect& current) {
-    CSize content_pref;
-    scroll_view_->GetContents()->GetPreferredSize(&content_pref);
-    scroll_up_button_->SetVisible(content_pref.cy > height());
-    scroll_down_button_->SetVisible(content_pref.cy > height());
+    gfx::Size content_pref = scroll_view_->GetContents()->GetPreferredSize();
+    scroll_up_button_->SetVisible(content_pref.height() > height());
+    scroll_down_button_->SetVisible(content_pref.height() > height());
   }
 
-  virtual void GetPreferredSize(CSize* out) {
-    scroll_view_->GetContents()->GetPreferredSize(out);
+  virtual gfx::Size GetPreferredSize() {
+    gfx::Size prefsize = scroll_view_->GetContents()->GetPreferredSize();
     gfx::Insets insets = GetInsets();
-    out->cx += insets.width();
-    out->cy += insets.height();
+    prefsize.Enlarge(insets.width(), insets.height());
+    return prefsize;
   }
 
  private:
   // The scroll buttons.
   View* scroll_up_button_;
   View* scroll_down_button_;
 
   // The scroll view.
   MenuScrollView* scroll_view_;
 
@@ skipping 24 matching lines @@
                                                &gutter_bounds);
       start_x = gutter_bounds.left + gutter_width;
       start_y = 0;
     }
     RECT separator_bounds = { start_x, start_y, width(), height() };
     NativeTheme::instance()->PaintMenuSeparator(dc, MENU_POPUPSEPARATOR,
                                                 MPI_NORMAL, &separator_bounds);
     canvas->endPlatformPaint();
   }
 
-  void GetPreferredSize(CSize* out) {
-    out->cx = 10; // Just in case we're the only item in a menu.
-    out->cy = separator_height;
+  gfx::Size GetPreferredSize() {
+    return gfx::Size(10, // Just in case we're the only item in a menu.
+                     separator_height);
   }
 
  private:
   DISALLOW_EVIL_CONSTRUCTORS(MenuSeparator);
 };
 
 // MenuHostRootView ----------------------------------------------------------
 
 // MenuHostRootView is the RootView of the window showing the menu.
 // SubmenuView's scroll view is added as a child of MenuHostRootView.
@@ skipping 279 matching lines @@
   }
   NOTREACHED();
   return NULL;
 }
 
 void SubmenuView::Layout() {
   // We're in a ScrollView, and need to set our width/height ourselves.
   View* parent = GetParent();
   if (!parent)
     return;
-  CSize pref;
-  GetPreferredSize(&pref);
-  SetBounds(x(), y(), parent->width(), pref.cy);
+  SetBounds(x(), y(), parent->width(), GetPreferredSize().height());
 
   gfx::Insets insets = GetInsets();
   int x = insets.left();
   int y = insets.top();
   int menu_item_width = width() - insets.width();
   for (int i = 0; i < GetChildViewCount(); ++i) {
     View* child = GetChildViewAt(i);
-    CSize child_pref_size;
-    child->GetPreferredSize(&child_pref_size);
-    child->SetBounds(x, y, menu_item_width, child_pref_size.cy);
-    y += child_pref_size.cy;
+    gfx::Size child_pref_size = child->GetPreferredSize();
+    child->SetBounds(x, y, menu_item_width, child_pref_size.height());
+    y += child_pref_size.height();
   }
 }
 
-void SubmenuView::GetPreferredSize(CSize* out) {
-  if (GetChildViewCount() == 0) {
-    out->SetSize(0, 0);
-    return;
-  }
+gfx::Size SubmenuView::GetPreferredSize() {
+  if (GetChildViewCount() == 0)
+    return gfx::Size();
 
   int max_width = 0;
   int height = 0;
   for (int i = 0; i < GetChildViewCount(); ++i) {
     View* child = GetChildViewAt(i);
-    CSize child_pref_size;
-    child->GetPreferredSize(&child_pref_size);
-    max_width = std::max(max_width, static_cast<int>(child_pref_size.cx));
-    height += child_pref_size.cy;
+    gfx::Size child_pref_size = child->GetPreferredSize();
+    max_width = std::max(max_width, child_pref_size.width());
+    height += child_pref_size.height();
   }
   gfx::Insets insets = GetInsets();
-  out->SetSize(max_width + insets.width(), height + insets.height());
+  return gfx::Size(max_width + insets.width(), height + insets.height());
 }
 
 void SubmenuView::DidChangeBounds(const CRect& previous, const CRect& current) {
   SchedulePaint();
 }
 
 void SubmenuView::PaintChildren(ChromeCanvas* canvas) {
   View::PaintChildren(canvas);
 
   if (drop_item_ && drop_position_ != MenuDelegate::DROP_ON)
@@ skipping 309 matching lines @@
 
 void MenuItemView::SetIcon(const SkBitmap& icon) {
   icon_ = icon;
   SchedulePaint();
 }
 
 void MenuItemView::Paint(ChromeCanvas* canvas) {
   Paint(canvas, false);
 }
 
-void MenuItemView::GetPreferredSize(CSize* out) {
-  out->cx = font_.GetStringWidth(title_) + label_start + item_right_margin;
-  out->cy = font_.height() + kItemBottomMargin + kItemTopMargin;
+gfx::Size MenuItemView::GetPreferredSize() {
+  return gfx::Size(
+      font_.GetStringWidth(title_) + label_start + item_right_margin,
+      font_.height() + kItemBottomMargin + kItemTopMargin);
 }
 
 MenuController* MenuItemView::GetMenuController() {
   return GetRootMenuItem()->controller_;
 }
 
 MenuDelegate* MenuItemView::GetDelegate() {
   return GetRootMenuItem()->delegate_;
 }
 
@@ skipping 1227 matching lines @@
 }
 
 gfx::Rect MenuController::CalculateMenuBounds(MenuItemView* item,
                                               bool prefer_leading,
                                               bool* is_leading) {
   DCHECK(item);
 
   SubmenuView* submenu = item->GetSubmenu();
   DCHECK(submenu);
 
-  CSize pref;
-  submenu->GetScrollViewContainer()->GetPreferredSize(&pref);
+  gfx::Size pref = submenu->GetScrollViewContainer()->GetPreferredSize();
 
   // Don't let the menu go to wide. This is some where between what IE and FF
   // do.
-  pref.cx = std::min(pref.cx, kMaxMenuWidth);
+  pref.set_width(std::min(pref.width(), kMaxMenuWidth));
   if (!state_.monitor_bounds.IsEmpty())
-    pref.cx = std::min(pref.cx,
-                       static_cast<LONG>(state_.monitor_bounds.width()));
+    pref.set_width(std::min(pref.width(), state_.monitor_bounds.width()));
 
   // Assume we can honor prefer_leading.
   *is_leading = prefer_leading;
 
   int x, y;
 
   if (!item->GetParentMenuItem()) {
     // First item, position relative to initial location.
     x = state_.initial_bounds.x();
     y = state_.initial_bounds.bottom();
     if (state_.anchor == MenuItemView::TOPRIGHT)
-      x = x + state_.initial_bounds.width() - pref.cx;
+      x = x + state_.initial_bounds.width() - pref.width();
     if (!state_.monitor_bounds.IsEmpty() &&
-        y + pref.cy > state_.monitor_bounds.bottom()) {
+        y + pref.height() > state_.monitor_bounds.bottom()) {
       // The menu doesn't fit on screen. If the first location is above the
       // half way point, show from the mouse location to bottom of screen.
       // Otherwise show from the top of the screen to the location of the mouse.
       // While odd, this behavior matches IE.
       if (y < (state_.monitor_bounds.y() +
                state_.monitor_bounds.height() / 2)) {
-        pref.cy = std::min(pref.cy,
-            static_cast<LONG>(state_.monitor_bounds.bottom() - y));
+        pref.set_height(std::min(pref.height(),
+                                 state_.monitor_bounds.bottom() - y));
       } else {
-        pref.cy = std::min(pref.cy, static_cast<LONG>(
+        pref.set_height(std::min(pref.height(),
             state_.initial_bounds.y() - state_.monitor_bounds.y()));
-        y = state_.initial_bounds.y() - pref.cy;
+        y = state_.initial_bounds.y() - pref.height();
       }
     }
   } else {
     // Not the first menu; position it relative to the bounds of the menu
     // item.
     gfx::Point item_loc;
     View::ConvertPointToScreen(item, &item_loc);
 
     // We must make sure we take into account the UI layout. If the layout is
     // RTL, then a 'leading' menu is positioned to the left of the parent menu
     // item and not to the right.
     bool layout_is_rtl = item->UILayoutIsRightToLeft();
     bool create_on_the_right = (prefer_leading && !layout_is_rtl) ||
                                (!prefer_leading && layout_is_rtl);
 
     if (create_on_the_right) {
       x = item_loc.x() + item->width() - kSubmenuHorizontalInset;
       if (state_.monitor_bounds.width() != 0 &&
-          x + pref.cx > state_.monitor_bounds.right()) {
+          x + pref.width() > state_.monitor_bounds.right()) {
         if (layout_is_rtl)
           *is_leading = true;
         else
           *is_leading = false;
-        x = item_loc.x() - pref.cx + kSubmenuHorizontalInset;
+        x = item_loc.x() - pref.width() + kSubmenuHorizontalInset;
       }
     } else {
-      x = item_loc.x() - pref.cx + kSubmenuHorizontalInset;
+      x = item_loc.x() - pref.width() + kSubmenuHorizontalInset;
       if (state_.monitor_bounds.width() != 0 && x < state_.monitor_bounds.x()) {
         if (layout_is_rtl)
           *is_leading = false;
         else
           *is_leading = true;
         x = item_loc.x() + item->width() - kSubmenuHorizontalInset;
       }
     }
     y = item_loc.y() - kSubmenuBorderSize;
     if (state_.monitor_bounds.width() != 0) {
-      pref.cy = std::min(pref.cy,
-                         static_cast<LONG>(state_.monitor_bounds.height()));
-      if (y + pref.cy > state_.monitor_bounds.bottom())
-        y = state_.monitor_bounds.bottom() - pref.cy;
+      pref.set_height(std::min(pref.height(), state_.monitor_bounds.height()));
+      if (y + pref.height() > state_.monitor_bounds.bottom())
+        y = state_.monitor_bounds.bottom() - pref.height();
       if (y < state_.monitor_bounds.y())
         y = state_.monitor_bounds.y();
     }
   }
 
   if (state_.monitor_bounds.width() != 0) {
-    if (x + pref.cx > state_.monitor_bounds.right())
-      x = state_.monitor_bounds.right() - pref.cx;
+    if (x + pref.width() > state_.monitor_bounds.right())
+      x = state_.monitor_bounds.right() - pref.width();
     if (x < state_.monitor_bounds.x())
       x = state_.monitor_bounds.x();
   }
-  return gfx::Rect(x, y, pref.cx, pref.cy);
+  return gfx::Rect(x, y, pref.width(), pref.height());
 }
 
 // static
 int MenuController::MenuDepth(MenuItemView* item) {
   if (!item)
     return 0;
   return MenuDepth(item->GetParentMenuItem()) + 1;
 }
 
 void MenuController::IncrementSelection(int delta) {
@@ skipping 207 matching lines @@
     scroll_task_.reset(new MenuScrollTask());
   scroll_task_->Update(part);
 }
 
 void MenuController::StopScrolling() {
   scroll_task_.reset(NULL);
 }
 
 }  // namespace ChromeViews