Move last of event handlers down to NativeWidgetWin/Gtk.

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"
+#include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/compositor/compositor.h"
 #include "views/focus/view_storage.h"
 #include "views/ime/input_method.h"
 #include "views/views_delegate.h"
 #include "views/widget/default_theme_provider.h"
 #include "views/widget/root_view.h"
 #include "views/widget/native_widget.h"
 #include "views/widget/widget_delegate.h"
 #include "views/window/custom_frame_view.h"
 
@@ skipping 71 matching lines @@
     : is_mouse_button_pressed_(false),
       last_mouse_event_was_move_(false),
       native_widget_(NULL),
       widget_delegate_(NULL),
       non_client_view_(NULL),
       dragged_view_(NULL),
       ownership_(InitParams::NATIVE_WIDGET_OWNS_WIDGET),
       is_secondary_widget_(true),
       frame_type_(FRAME_TYPE_DEFAULT),
       disable_inactive_rendering_(false),
-      widget_closed_(false) {
+      widget_closed_(false),
+      saved_maximized_state_(false),
+      minimum_size_(100, 100) {
 }
 
 Widget::~Widget() {
   DestroyRootView();
 
   if (ownership_ == InitParams::WIDGET_OWNS_NATIVE_WIDGET)
     delete native_widget_;
 }
 
 // static
 void Widget::SetPureViews(bool pure) {
   use_pure_views = pure;
 }
 
 // static
 bool Widget::IsPureViews() {
   return use_pure_views;
 }
 
 // static
 Widget* Widget::GetWidgetForNativeView(gfx::NativeView native_view) {
   NativeWidget* native_widget =
       NativeWidget::GetNativeWidgetForNativeView(native_view);
   return native_widget ? native_widget->GetWidget() : NULL;
 }
 
+// static
+int Widget::GetLocalizedContentsWidth(int col_resource_id) {
+  return ui::GetLocalizedContentsWidthForFont(col_resource_id,
+      ResourceBundle::GetSharedInstance().GetFont(ResourceBundle::BaseFont));
+}
+
+// static
+int Widget::GetLocalizedContentsHeight(int row_resource_id) {
+  return ui::GetLocalizedContentsHeightForFont(row_resource_id,
+      ResourceBundle::GetSharedInstance().GetFont(ResourceBundle::BaseFont));
+}
+
+// static
+gfx::Size Widget::GetLocalizedContentsSize(int col_resource_id,
+                                           int row_resource_id) {
+  return gfx::Size(GetLocalizedContentsWidth(col_resource_id),
+                   GetLocalizedContentsHeight(row_resource_id));
+}
+
 void Widget::Init(const InitParams& params) {
   widget_delegate_ =
       params.delegate ? params.delegate : new DefaultWidgetDelegate;
   ownership_ = params.ownership;
   native_widget_ =
       params.native_widget ? params.native_widget
                            : NativeWidget::CreateNativeWidget(this);
   GetRootView();
   default_theme_provider_.reset(new DefaultThemeProvider);
   if (params.type == InitParams::TYPE_MENU)
     is_mouse_button_pressed_ = native_widget_->IsMouseButtonDown();
   native_widget_->InitNativeWidget(params);
   if (params.type == InitParams::TYPE_WINDOW) {
     non_client_view_ = new NonClientView;
     non_client_view_->SetFrameView(CreateNonClientFrameView());
     // Create the ClientView, add it to the NonClientView and add the
     // NonClientView to the RootView. This will cause everything to be parented.
     non_client_view_->set_client_view(widget_delegate_->CreateClientView(this));
     SetContentsView(non_client_view_);
+    SetInitialBounds(params.bounds);
+    UpdateWindowTitle();
   }
 }
 
 // Unconverted methods (see header) --------------------------------------------
 
 gfx::NativeView Widget::GetNativeView() const {
    return native_widget_->GetNativeView();
 }
 
 gfx::NativeWindow Widget::GetNativeWindow() const {
@@ skipping 120 matching lines @@
 void Widget::CloseNow() {
   native_widget_->CloseNow();
 }
 
 void Widget::EnableClose(bool enable) {
   non_client_view_->EnableClose(enable);
   native_widget_->EnableClose(enable);
 }
 
 void Widget::Show() {
-  native_widget_->Show();
+  if (non_client_view_) {
+    native_widget_->ShowNativeWidget(
+        saved_maximized_state_ ? NativeWidget::SHOW_MAXIMIZED
+                               : NativeWidget::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(NativeWidget::SHOW_INACTIVE);
 }
 
@@ skipping 128 matching lines @@
 
 void Widget::SetCursor(gfx::NativeCursor cursor) {
   native_widget_->SetCursor(cursor);
 }
 
 void Widget::ResetLastMouseMoveFlag() {
   last_mouse_event_was_move_ = false;
 }
 
 void Widget::UpdateWindowTitle() {
-  if (non_client_view_) {
-    // If the non-client view is rendering its own title, it'll need to relayout
-    // now.
-    non_client_view_->Layout();
-  }
+  if (!non_client_view_)
+    return;
+
+  // If the non-client view is rendering its own title, it'll need to relayout
+  // now.
+  non_client_view_->Layout();
 
   // Update the native frame's text. We do this regardless of whether or not
   // the native frame is being used, since this also updates the taskbar, etc.
   string16 window_title;
   if (native_widget_->IsScreenReaderActive()) {
     window_title = WideToUTF16(widget_delegate_->GetAccessibleWindowTitle());
   } else {
     window_title = WideToUTF16(widget_delegate_->GetWindowTitle());
   }
   base::i18n::AdjustStringForLocaleDirection(&window_title);
@@ skipping 66 matching lines @@
   if (ViewsDelegate::views_delegate)
     ViewsDelegate::views_delegate->NotifyAccessibilityEvent(view, event_type);
 
   if (send_native_event)
     native_widget_->SendNativeAccessibilityEvent(view, event_type);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Widget, NativeWidgetDelegate implementation:
 
+bool Widget::IsModal() const {
+  return widget_delegate_->IsModal();
+}
+
+bool Widget::IsDialogBox() const {
+  return !!widget_delegate_->AsDialogDelegate();
+}
+
 bool Widget::CanActivate() const {
   return widget_delegate_->CanActivate();
 }
 
 bool Widget::IsInactiveRenderingDisabled() const {
   return disable_inactive_rendering_;
 }
 
 void Widget::EnableInactiveRendering() {
   disable_inactive_rendering_ = false;
@@ skipping 26 matching lines @@
     // Only the top level Widget in a native widget hierarchy has a focus
     // manager.
     focus_manager_.reset(new FocusManager(this));
   }
   EnsureCompositor();
 
   native_widget_->SetAccessibleRole(
       widget_delegate_->GetAccessibleWindowRole());
   native_widget_->SetAccessibleState(
       widget_delegate_->GetAccessibleWindowState());
+
+  if (widget_delegate_->IsModal())
+    native_widget_->BecomeModal();
 }
 
 void Widget::OnNativeWidgetDestroying() {
   if (non_client_view_)
     non_client_view_->WindowClosing();
   widget_delegate_->WindowClosing();
 }
 
 void Widget::OnNativeWidgetDestroyed() {
   widget_delegate_->DeleteDelegate();
@@ skipping 190 matching lines @@
   // bail.
   if (!widget_delegate_)
     return;
 
   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());
+    } 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());
+      }
+    }
+
+    // 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);
+    }
+  }
+}
 
 
 }  // namespace views