Move more from Window onto Widget.

views/widget/native_widget_gtk.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/native_widget_gtk.h"
 
 #include <gdk/gdk.h>
 #include <gdk/gdkx.h>
 #include <X11/extensions/shape.h>
 #include <X11/Xatom.h>
@@ skipping 428 matching lines @@
 
   drag_data_ = NULL;
 
   if (drag_icon_widget) {
     gtk_widget_destroy(drag_icon_widget);
     g_object_unref(provider.drag_image());
   }
 }
 
 void NativeWidgetGtk::IsActiveChanged() {
-  GetWidget()->widget_delegate()->OnWidgetActivated(IsActive());
+  delegate_->OnNativeWidgetActivationChanged(IsActive());
 }
 
 void NativeWidgetGtk::SetInitialFocus() {
   if (!focus_on_creation_)
     return;
 
   View* v = GetWidget()->widget_delegate()->GetInitiallyFocusedView();
   if (v)
     v->RequestFocus();
 }
@@ skipping 453 matching lines @@
     // enough for our uses.
     gtk_window_get_size(GTK_WINDOW(widget_), &w, &h);
   } else {
     GetWidgetPositionOnScreen(widget_, &x, &y);
     w = widget_->allocation.width;
     h = widget_->allocation.height;
   }
   return gfx::Rect(x, y, w, h);
 }
 
+gfx::Rect NativeWidgetGtk::GetRestoredBounds() const {
+  // We currently don't support tiling, so this doesn't matter.
+  return GetWindowScreenBounds();
+}
+
 void NativeWidgetGtk::SetBounds(const gfx::Rect& bounds) {
   if (child_) {
     GtkWidget* parent = gtk_widget_get_parent(widget_);
     if (GTK_IS_VIEWS_FIXED(parent)) {
       NativeWidgetGtk* parent_widget = static_cast<NativeWidgetGtk*>(
           NativeWidget::GetNativeWidgetForNativeView(parent));
       parent_widget->PositionChild(widget_, bounds.x(), bounds.y(),
                                    bounds.width(), bounds.height());
     } else {
       DCHECK(GTK_IS_FIXED(parent))
@@ skipping 73 matching lines @@
   }
 }
 
 void NativeWidgetGtk::CloseNow() {
   if (widget_) {
     input_method_.reset();
     gtk_widget_destroy(widget_);  // Triggers OnDestroy().
   }
 }
 
+void NativeWidgetGtk::EnableClose(bool enable) {
+  gtk_window_set_deletable(GetNativeWindow(), enable);
+}
+
 void NativeWidgetGtk::Show() {
   if (widget_) {
     gtk_widget_show(widget_);
     if (widget_->window)
       gdk_window_raise(widget_->window);
   }
 }
 
 void NativeWidgetGtk::Hide() {
   if (widget_) {
     gtk_widget_hide(widget_);
     if (widget_->window)
       gdk_window_lower(widget_->window);
   }
 }
 
+void NativeWidgetGtk::ShowNativeWidget(ShowState state) {
+  // No concept of maximization (yet) on ChromeOS.
+  if (state == NativeWidget::SHOW_INACTIVE)
+    gtk_window_set_focus_on_map(GetNativeWindow(), false);
+  gtk_widget_show(GetNativeView());
+}
+
 bool NativeWidgetGtk::IsVisible() const {
   return GTK_WIDGET_VISIBLE(GetNativeView());
 }
 
 void NativeWidgetGtk::Activate() {
   gtk_window_present(GetNativeWindow());
 }
 
 void NativeWidgetGtk::Deactivate() {
   gdk_window_lower(GTK_WIDGET(GetNativeView())->window);
@@ skipping 21 matching lines @@
 
 bool NativeWidgetGtk::IsMaximized() const {
   return window_state_ & GDK_WINDOW_STATE_MAXIMIZED;
 }
 
 bool NativeWidgetGtk::IsMinimized() const {
   return window_state_ & GDK_WINDOW_STATE_ICONIFIED;
 }
 
 void NativeWidgetGtk::Restore() {
-  if (IsMaximized())
-    gtk_window_unmaximize(GetNativeWindow());
-  else if (IsMinimized())
-    gtk_window_deiconify(GetNativeWindow());
+  if (IsFullscreen()) {
+    SetFullscreen(false);
+  } else {
+    if (IsMaximized())
+      gtk_window_unmaximize(GetNativeWindow());
+    else if (IsMinimized())
+      gtk_window_deiconify(GetNativeWindow());
+  }
 }
 
 void NativeWidgetGtk::SetFullscreen(bool fullscreen) {
   if (fullscreen)
     gtk_window_fullscreen(GetNativeWindow());
   else
     gtk_window_unfullscreen(GetNativeWindow());
 }
 
 bool NativeWidgetGtk::IsFullscreen() const {
@@ skipping 73 matching lines @@
 void NativeWidgetGtk::OnSizeAllocate(GtkWidget* widget,
                                      GtkAllocation* allocation) {
   // See comment next to size_ as to why we do this. Also note, it's tempting
   // to put this in the static method so subclasses don't need to worry about
   // it, but if a subclasses needs to set a shape then they need to always
   // reset the shape in this method regardless of whether the size changed.
   gfx::Size new_size(allocation->width, allocation->height);
   if (new_size == size_)
     return;
   size_ = new_size;
-  delegate_->OnSizeChanged(size_);
+  delegate_->OnNativeWidgetSizeChanged(size_);
 }
 
 gboolean NativeWidgetGtk::OnPaint(GtkWidget* widget, GdkEventExpose* event) {
   if (transparent_ && child_) {
     // Clear the background before drawing any view and native components.
     DrawTransparentBackground(widget, event);
     if (!CompositePainter::IsComposited(widget_) &&
         gdk_screen_is_composited(gdk_screen_get_default())) {
       // Let the parent draw the content only after something is drawn on
       // the widget.
@@ skipping 259 matching lines @@
 }
 
 void NativeWidgetGtk::OnGrabNotify(GtkWidget* widget, gboolean was_grabbed) {
   if (!window_contents_)
     return;  // Grab broke after window destroyed, don't try processing it.
   gtk_grab_remove(window_contents_);
   HandleGtkGrabBroke();
 }
 
 void NativeWidgetGtk::OnDestroy(GtkWidget* object) {
+  delegate_->OnNativeWidgetDestroying();
   if (!child_)
     ActiveWindowWatcherX::RemoveObserver(this);
   // Note that this handler is hooked to GtkObject::destroy.
   // NULL out pointers here since we might still be in an observer list
   // until deletion happens.
   widget_ = window_contents_ = NULL;
 }
 
 void NativeWidgetGtk::OnDestroyed(GObject *where_the_object_was) {
   delegate_->OnNativeWidgetDestroyed();
@@ skipping 471 matching lines @@
 
   // And now, notify them that they have a brand new parent.
   for (NativeWidgets::iterator it = widgets.begin();
        it != widgets.end(); ++it) {
     (*it)->GetWidget()->NotifyNativeViewHierarchyChanged(true,
                                                          new_parent);
   }
 }
 
 }  // namespace views