Implements a couple of NOTIMPLEMENTEDs in window_gtk and comments on...

views/window/window_gtk.cc

 // Copyright (c) 2009 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/window_gtk.h"
 
 #include "app/gfx/path.h"
 #include "app/l10n_util.h"
 #include "base/gfx/rect.h"
 #include "views/screen.h"
@@ skipping 86 matching lines @@
   }
 }
 
 gfx::Rect WindowGtk::GetBounds() const {
   gfx::Rect bounds;
   WidgetGtk::GetBounds(&bounds, true);
   return bounds;
 }
 
 gfx::Rect WindowGtk::GetNormalBounds() const {
-  NOTIMPLEMENTED();
+  // We currently don't support tiling, so this doesn't matter.
   return GetBounds();
 }
 
 void WindowGtk::SetBounds(const gfx::Rect& bounds,
                           gfx::NativeWindow other_window) {
   // TODO: need to deal with other_window.
   WidgetGtk::SetBounds(bounds);
 }
 
 void WindowGtk::Show() {
   gtk_widget_show_all(GetNativeView());
 }
 
 void WindowGtk::HideWindow() {
   Hide();
 }
 
-void WindowGtk::PushForceHidden() {
-  NOTIMPLEMENTED();
-}
-
-void WindowGtk::PopForceHidden() {
-  NOTIMPLEMENTED();
-}
-
 void WindowGtk::Activate() {
-  NOTIMPLEMENTED();
+  gtk_window_present(GTK_WINDOW(GetNativeView()));
 }
 
 void WindowGtk::Close() {
   if (window_closed_) {
     // Don't do anything if we've already been closed.
     return;
   }
 
   if (non_client_view_->CanClose()) {
     WidgetGtk::Close();
     window_closed_ = true;
   }
 }
 
 void WindowGtk::Maximize() {
   gtk_window_maximize(GetNativeWindow());
 }
 
 void WindowGtk::Minimize() {
   gtk_window_iconify(GetNativeWindow());
 }
 
 void WindowGtk::Restore() {
-  NOTIMPLEMENTED();
+  if (IsMaximized())
+    gtk_window_unmaximize(GetNativeWindow());
+  else if (IsMinimized())
+    gtk_window_deiconify(GetNativeWindow());
+  else if (IsFullscreen())
+    SetFullscreen(false);
 }
 
 bool WindowGtk::IsActive() const {
   return gtk_window_is_active(GetNativeWindow());
 }
 
 bool WindowGtk::IsVisible() const {
   return GTK_WIDGET_VISIBLE(GetNativeView());
 }
 
@@ skipping 33 matching lines @@
   // the native frame is being used, since this also updates the taskbar, etc.
   std::wstring window_title = window_delegate_->GetWindowTitle();
   std::wstring localized_text;
   if (l10n_util::AdjustStringForLocaleDirection(window_title, &localized_text))
     window_title.assign(localized_text);
 
   gtk_window_set_title(GetNativeWindow(), WideToUTF8(window_title).c_str());
 }
 
 void WindowGtk::UpdateWindowIcon() {
-  NOTIMPLEMENTED();
+  // Doesn't matter for chrome os.
 }
 
 void WindowGtk::SetIsAlwaysOnTop(bool always_on_top) {
   gtk_window_set_keep_above(GetNativeWindow(), always_on_top);
 }
 
 NonClientFrameView* WindowGtk::CreateFrameViewForWindow() {
   // TODO(erg): Always use a custom frame view? Are there cases where we let
   // the window manager deal with the X11 equivalent of the "non-client" area?
   return new CustomFrameView(this);
 }
 
 void WindowGtk::UpdateFrameAfterFrameChange() {
+  // We currently don't support different frame types on Gtk, so we don't
+  // need to implement this.
   NOTIMPLEMENTED();
 }
 
 WindowDelegate* WindowGtk::GetDelegate() const {
   return window_delegate_;
 }
 
 NonClientView* WindowGtk::GetNonClientView() const {
   return non_client_view_;
 }
 
 ClientView* WindowGtk::GetClientView() const {
   return non_client_view_->client_view();
 }
 
 gfx::NativeWindow WindowGtk::GetNativeWindow() const {
   return GTK_WINDOW(GetNativeView());
 }
 
 bool WindowGtk::ShouldUseNativeFrame() const {
   return false;
 }
 
 void WindowGtk::FrameTypeChanged() {
+  // We currently don't support different frame types on Gtk, so we don't
+  // need to implement this.
   NOTIMPLEMENTED();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowGtk, WidgetGtk overrides:
 
 gboolean WindowGtk::OnButtonPress(GtkWidget* widget, GdkEventButton* event) {
   int hittest_code =
       non_client_view_->NonClientHitTest(gfx::Point(event->x, event->y));
   switch (hittest_code) {
@@ skipping 137 matching lines @@
                                          WindowGtk* window_gtk) {
   return window_gtk->OnWindowStateEvent(widget, event);
 }
 
 void WindowGtk::SaveWindowPosition() {
   // The delegate may have gone away on us.
   if (!window_delegate_)
     return;
 
   bool maximized = window_state_ & GDK_WINDOW_STATE_MAXIMIZED;
-  gfx::Rect bounds;
-  WidgetGtk::GetBounds(&bounds, true);
-  window_delegate_->SaveWindowPlacement(bounds, maximized);
+  window_delegate_->SaveWindowPlacement(GetBounds(), maximized);
 }
 
 void WindowGtk::SetInitialBounds(GtkWindow* parent,
                                  const gfx::Rect& create_bounds) {
   gfx::Rect saved_bounds(create_bounds.ToGdkRectangle());
   if (window_delegate_->GetSavedWindowBounds(&saved_bounds)) {
     WidgetGtk::SetBounds(saved_bounds);
   } else {
     if (create_bounds.IsEmpty()) {
       SizeWindowToDefault(parent);
@@ skipping 20 matching lines @@
     center_rect = Screen::GetMonitorWorkAreaNearestWindow(GetNativeWindow());
   }
   gfx::Size size = non_client_view_->GetPreferredSize();
   gfx::Rect bounds(center_rect.x() + (center_rect.width() - size.width()) / 2,
                    center_rect.y() + (center_rect.height() - size.height()) / 2,
                    size.width(), size.height());
   SetBounds(bounds, NULL);
 }
 
 }  // namespace views