Makes sure widget is created at right size before showing

views/widget/widget.cc

 // Copyright (c) 2011 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 "views/widget/widget.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "ui/base/l10n/l10n_font_util.h"
@@ skipping 78 matching lines @@
       delegate(NULL),
       child(false),
       transient(false),
       transparent(false),
       accept_events(true),
       can_activate(true),
       keep_on_top(false),
       ownership(NATIVE_WIDGET_OWNS_WIDGET),
       mirror_origin_in_rtl(false),
       has_dropshadow(false),
+      maximize(false),
       double_buffer(false),
       parent(NULL),
       parent_widget(NULL),
       native_widget(NULL) {
 }
 
 Widget::InitParams::InitParams(Type type)
     : type(type),
       delegate(NULL),
       child(type == TYPE_CONTROL),
       transient(type == TYPE_POPUP || type == TYPE_MENU),
       transparent(false),
       accept_events(true),
       can_activate(type != TYPE_POPUP && type != TYPE_MENU),
       keep_on_top(type == TYPE_MENU),
       ownership(NATIVE_WIDGET_OWNS_WIDGET),
       mirror_origin_in_rtl(false),
       has_dropshadow(false),
+      maximize(false),
       double_buffer(false),
       parent(NULL),
       parent_widget(NULL),
       native_widget(NULL) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Widget, public:
 
 // static
@@ skipping 291 matching lines @@
 }
 
 void Widget::EnableClose(bool enable) {
   if (non_client_view_)
     non_client_view_->EnableClose(enable);
   native_widget_->EnableClose(enable);
 }
 
 void Widget::Show() {
   if (non_client_view_) {
-    native_widget_->ShowNativeWidget(
-        saved_maximized_state_ ? internal::NativeWidgetPrivate::SHOW_MAXIMIZED
-                               : internal::NativeWidgetPrivate::SHOW_RESTORED);
+    if (saved_maximized_state_ && !initial_restored_bounds_.IsEmpty()) {
+      native_widget_->ShowMaximizedWithBounds(initial_restored_bounds_);
+    } else {
+      native_widget_->ShowWithState(saved_maximized_state_ ?
+          internal::NativeWidgetPrivate::SHOW_MAXIMIZED :
+          internal::NativeWidgetPrivate::SHOW_RESTORED);
+    }
     // |saved_maximized_state_| only applies the first time the window is shown.
     // If we don't reset the value the window will be shown maximized every time
     // it is subsequently shown after being hidden.
     saved_maximized_state_ = false;
   } else {
     native_widget_->Show();
   }
 }
 
 void Widget::Hide() {
   native_widget_->Hide();
 }
 
 void Widget::ShowInactive() {
-  native_widget_->ShowNativeWidget(
-      internal::NativeWidgetPrivate::SHOW_INACTIVE);
+  native_widget_->ShowWithState(internal::NativeWidgetPrivate::SHOW_INACTIVE);
 }
 
 void Widget::Activate() {
   native_widget_->Activate();
 }
 
 void Widget::Deactivate() {
   native_widget_->Deactivate();
 }
 
@@ skipping 535 matching lines @@
   bool maximized;
   gfx::Rect bounds;
   native_widget_->GetWindowBoundsAndMaximizedState(&bounds, &maximized);
   widget_delegate_->SaveWindowPlacement(bounds, maximized);
 }
 
 void Widget::SetInitialBounds(const gfx::Rect& bounds) {
   if (!non_client_view_)
     return;
 
-  // First we obtain the window's saved show-style and store it. We need to do
-  // this here, rather than in Show() because by the time Show() is called,
-  // the window's size will have been reset (below) and the saved maximized
-  // state will have been lost. Sadly there's no way to tell on Windows when
-  // a window is restored from maximized state, so we can't more accurately
-  // track maximized state independently of sizing information.
-  widget_delegate_->GetSavedMaximizedState(&saved_maximized_state_);
-
-  // Restore the window's placement from the controller.
-  gfx::Rect saved_bounds = bounds;
-  if (widget_delegate_->GetSavedWindowBounds(&saved_bounds)) {
-    if (!widget_delegate_->ShouldRestoreWindowSize()) {
-      saved_bounds.set_size(non_client_view_->GetPreferredSize());
+  gfx::Rect saved_bounds;
+  if (GetSavedBounds(&saved_bounds, &saved_maximized_state_)) {
+    if (saved_maximized_state_) {
+      // If we're going to maximize, wait until Show is invoked to set the
+      // bounds. That way we avoid a noticable resize.
+      initial_restored_bounds_ = saved_bounds;
     } else {
-      // Make sure the bounds are at least the minimum size.
-      if (saved_bounds.width() < minimum_size_.width()) {
-        saved_bounds.SetRect(saved_bounds.x(), saved_bounds.y(),
-                             saved_bounds.right() + minimum_size_.width() -
-                                 saved_bounds.width(),
-                             saved_bounds.bottom());
-      }
-
-      if (saved_bounds.height() < minimum_size_.height()) {
-        saved_bounds.SetRect(saved_bounds.x(), saved_bounds.y(),
-                             saved_bounds.right(),
-                             saved_bounds.bottom() + minimum_size_.height() -
-                                 saved_bounds.height());
-      }
+      SetBounds(saved_bounds);
     }
-
-    // Widget's SetBounds method does not further modify the bounds that are
-    // passed to it.
-    SetBounds(saved_bounds);
   } else {
     if (bounds.IsEmpty()) {
       // No initial bounds supplied, so size the window to its content and
       // center over its parent.
       native_widget_->CenterWindow(non_client_view_->GetPreferredSize());
     } else {
       // Use the supplied initial bounds.
       SetBoundsConstrained(bounds, NULL);
     }
   }
 }
 
+bool Widget::GetSavedBounds(gfx::Rect* bounds, bool* maximize) {
+  // First we obtain the window's saved show-style and store it. We need to do
+  // this here, rather than in Show() because by the time Show() is called,
+  // the window's size will have been reset (below) and the saved maximized
+  // state will have been lost. Sadly there's no way to tell on Windows when
+  // a window is restored from maximized state, so we can't more accurately
+  // track maximized state independently of sizing information.
+  widget_delegate_->GetSavedMaximizedState(maximize);

[oshima, 2011/07/19 16:23:44]

no need to change in this CL, but looks like all three parameters (maximized
state, bounds and hould_restore_window_size) can be in one struct like
SavedWindowState?

+
+  // Restore the window's placement from the controller.
+  if (widget_delegate_->GetSavedWindowBounds(bounds)) {
+    if (!widget_delegate_->ShouldRestoreWindowSize()) {
+      bounds->set_size(non_client_view_->GetPreferredSize());
+    } else {
+      // Make sure the bounds are at least the minimum size.
+      if (bounds->width() < minimum_size_.width())
+        bounds->set_width(minimum_size_.width());
+
+      if (bounds->height() < minimum_size_.height())
+        bounds->set_height(minimum_size_.height());
+    }
+    return true;
+  }
+  return false;
+}
+
 namespace internal {
 
 ////////////////////////////////////////////////////////////////////////////////
 // internal::NativeWidgetPrivate, NativeWidget implementation:
 
 internal::NativeWidgetPrivate* NativeWidgetPrivate::AsNativeWidgetPrivate() {
   return this;
 }
 
 }  // namespace internal
 }  // namespace views