Revert 86914 - Move a bunch of functions from Window onto Widget.

views/window/native_window_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/window/native_window_gtk.h"
 
 #include "base/i18n/rtl.h"
 #include "base/utf_string_conversions.h"
 #include "ui/gfx/gtk_util.h"
 #include "ui/gfx/path.h"
@@ skipping 62 matching lines @@
   return GDK_LEFT_PTR;
 }
 
 }  // namespace
 
 namespace views {
 
 NativeWindowGtk::NativeWindowGtk(internal::NativeWindowDelegate* delegate)
     : NativeWidgetGtk(delegate->AsNativeWidgetDelegate()),
       delegate_(delegate),
+      window_state_(GDK_WINDOW_STATE_WITHDRAWN),
       window_closed_(false) {
   is_window_ = true;
 }
 
 NativeWindowGtk::~NativeWindowGtk() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWindowGtk, NativeWidgetGtk overrides:
 
@@ skipping 81 matching lines @@
                                                           allocation->height),
                                                 &window_mask);
   GdkRegion* mask_region = window_mask.CreateNativeRegion();
   gdk_window_shape_combine_region(GetNativeView()->window, mask_region, 0, 0);
   if (mask_region)
     gdk_region_destroy(mask_region);
 
   SaveWindowPosition();
 }
 
+gboolean NativeWindowGtk::OnWindowStateEvent(GtkWidget* widget,
+                                             GdkEventWindowState* event) {
+  window_state_ = event->new_window_state;
+  if (!(window_state_ & GDK_WINDOW_STATE_WITHDRAWN))
+    SaveWindowPosition();
+  return FALSE;
+}
+
 gboolean NativeWindowGtk::OnLeaveNotify(GtkWidget* widget,
                                         GdkEventCrossing* event) {
   gdk_window_set_cursor(widget->window, gfx::GetCursor(GDK_LEFT_PTR));
 
   return NativeWidgetGtk::OnLeaveNotify(widget, event);
 }
 
 void NativeWindowGtk::IsActiveChanged() {
   NativeWidgetGtk::IsActiveChanged();
   delegate_->OnNativeWindowActivationChanged(IsActive());
 }
 
 void NativeWindowGtk::InitNativeWidget(const Widget::InitParams& params) {
   NativeWidgetGtk::InitNativeWidget(params);
 
   g_signal_connect(G_OBJECT(GetNativeWindow()), "configure-event",
                    G_CALLBACK(CallConfigureEvent), this);
+  g_signal_connect(G_OBJECT(GetNativeWindow()), "window-state-event",
+                   G_CALLBACK(CallWindowStateEvent), this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWindowGtk, NativeWindow implementation:
 
 NativeWidget* NativeWindowGtk::AsNativeWidget() {
   return this;
 }
 
 const NativeWidget* NativeWindowGtk::AsNativeWidget() const {
@@ skipping 73 matching lines @@
 const Window* NativeWindowGtk::GetWindow() const {
   return delegate_->AsWindow();
 }
 
 void NativeWindowGtk::SetWindowBounds(const gfx::Rect& bounds,
                                 gfx::NativeWindow other_window) {
   // TODO: need to deal with other_window.
   NativeWidgetGtk::SetBounds(bounds);
 }
 
+void NativeWindowGtk::HideWindow() {
+  GetWindow()->Hide();
+}
+
+void NativeWindowGtk::Activate() {
+  gtk_window_present(GTK_WINDOW(GetNativeView()));
+}
+
+void NativeWindowGtk::Deactivate() {
+  gdk_window_lower(GTK_WIDGET(GetNativeView())->window);
+}
+
+void NativeWindowGtk::Maximize() {
+  gtk_window_maximize(GetNativeWindow());
+}
+
+void NativeWindowGtk::Minimize() {
+  gtk_window_iconify(GetNativeWindow());
+}
+
+void NativeWindowGtk::Restore() {
+  if (IsMaximized())
+    gtk_window_unmaximize(GetNativeWindow());
+  else if (IsMinimized())
+    gtk_window_deiconify(GetNativeWindow());
+  else if (IsFullscreen())
+    SetFullscreen(false);
+}
+
+bool NativeWindowGtk::IsActive() const {
+  return NativeWidgetGtk::IsActive();
+}
+
+bool NativeWindowGtk::IsVisible() const {
+  return GTK_WIDGET_VISIBLE(GetNativeView());
+}
+
+bool NativeWindowGtk::IsMaximized() const {
+  return window_state_ & GDK_WINDOW_STATE_MAXIMIZED;
+}
+
+bool NativeWindowGtk::IsMinimized() const {
+  return window_state_ & GDK_WINDOW_STATE_ICONIFIED;
+}
+
 void NativeWindowGtk::SetFullscreen(bool fullscreen) {
   if (fullscreen)
     gtk_window_fullscreen(GetNativeWindow());
   else
     gtk_window_unfullscreen(GetNativeWindow());
 }
 
 bool NativeWindowGtk::IsFullscreen() const {
   return window_state_ & GDK_WINDOW_STATE_FULLSCREEN;
 }
 
 void NativeWindowGtk::SetUseDragFrame(bool use_drag_frame) {
   NOTIMPLEMENTED();
 }
 
 NonClientFrameView* NativeWindowGtk::CreateFrameViewForWindow() {
   return NULL;
 }
 
+void NativeWindowGtk::SetAlwaysOnTop(bool always_on_top) {
+  gtk_window_set_keep_above(GetNativeWindow(), always_on_top);
+}
+
 void NativeWindowGtk::UpdateFrameAfterFrameChange() {
   // We currently don't support different frame types on Gtk, so we don't
   // need to implement this.
   NOTIMPLEMENTED();
 }
 
+gfx::NativeWindow NativeWindowGtk::GetNativeWindow() const {
+  return GTK_WINDOW(GetNativeView());
+}
+
 bool NativeWindowGtk::ShouldUseNativeFrame() const {
   return false;
 }
 
 void NativeWindowGtk::FrameTypeChanged() {
   // This is called when the Theme has changed, so forward the event to the root
   // widget.
   GetWidget()->ThemeChanged();
   GetWidget()->GetRootView()->SchedulePaint();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// NativeWindowGtk, NativeWidgetGtk overrides:
-
-void NativeWindowGtk::Restore() {
-  if (IsFullscreen())
-    SetFullscreen(false);
-  else
-    NativeWidgetGtk::Restore();
-}
-
-gboolean NativeWindowGtk::OnWindowStateEvent(GtkWidget* widget,
-                                             GdkEventWindowState* event) {
-  if (!(event->new_window_state & GDK_WINDOW_STATE_WITHDRAWN))
-    SaveWindowPosition();
-  return NativeWidgetGtk::OnWindowStateEvent(widget, event);
-}
-
-////////////////////////////////////////////////////////////////////////////////
 // NativeWindowGtk, private:
 
 // static
 gboolean NativeWindowGtk::CallConfigureEvent(GtkWidget* widget,
                                              GdkEventConfigure* event,
                                              NativeWindowGtk* window_gtk) {
   return window_gtk->OnConfigureEvent(widget, event);
 }
 
+// static
+gboolean NativeWindowGtk::CallWindowStateEvent(GtkWidget* widget,
+                                               GdkEventWindowState* event,
+                                               NativeWindowGtk* window_gtk) {
+  return window_gtk->OnWindowStateEvent(widget, event);
+}
+
 void NativeWindowGtk::SaveWindowPosition() {
   // The delegate may have gone away on us.
   if (!GetWindow()->window_delegate())
     return;
 
   bool maximized = window_state_ & GDK_WINDOW_STATE_MAXIMIZED;
   GetWindow()->window_delegate()->SaveWindowPlacement(
       GetWidget()->GetWindowScreenBounds(),
       maximized);
 }
 
 void NativeWindowGtk::OnDestroy(GtkWidget* widget) {
   delegate_->OnNativeWindowDestroying();
   NativeWidgetGtk::OnDestroy(widget);
   delegate_->OnNativeWindowDestroyed();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWindow, public:
 
 // static
 NativeWindow* NativeWindow::CreateNativeWindow(
     internal::NativeWindowDelegate* delegate) {
   return new NativeWindowGtk(delegate);
 }
 
 }  // namespace views