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

views/window/window.h

 // 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.
 
 #ifndef VIEWS_WINDOW_WINDOW_H_
 #define VIEWS_WINDOW_WINDOW_H_
 #pragma once
 
 #include "ui/gfx/native_widget_types.h"
 #include "views/widget/widget.h"
@@ skipping 12 matching lines @@
 class NativeWindow;
 class NonClientFrameView;
 class Widget;
 class WindowDelegate;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Window class
 //
 // Encapsulates window-like behavior. See WindowDelegate.
 //
+//  TODO(beng): Subclass Widget as part of V2.
+//
+//  TODO(beng): Note that this class being non-abstract means that we have a
+//              violation of Google style in that we are using multiple
+//              inheritance. The intention is to split this into a separate
+//              object associated with but not equal to a NativeWidget
+//              implementation. Multiple inheritance is required for this
+//              transitional step.
+//
 class Window : public Widget,
                public internal::NativeWindowDelegate {
  public:
   struct InitParams {
     // |window_delegate| cannot be NULL.
     explicit InitParams(WindowDelegate* window_delegate);
 
     WindowDelegate* window_delegate;
     gfx::NativeWindow parent_window;
     NativeWindow* native_window;
@@ skipping 35 matching lines @@
 
   // Retrieves the restored bounds for the window.
   gfx::Rect GetNormalBounds() const;
 
   // Sets the Window's bounds. The window is inserted after |other_window| in
   // the window Z-order. If this window is not yet visible, other_window's
   // monitor is used as the constraining rectangle, rather than this window's
   // monitor.
   void SetWindowBounds(const gfx::Rect& bounds, gfx::NativeWindow other_window);
 
+  // Makes the window visible.
+  void Show();
+
   // Like Show(), but does not activate the window.
   void ShowInactive();
 
+  // Hides the window. This does not delete the window, it just hides it. This
+  // always hides the window, it is separate from the stack maintained by
+  // Push/PopForceHidden.
+  virtual void HideWindow();
+
   // Prevents the window from being rendered as deactivated the next time it is.
   // This state is reset automatically as soon as the window becomes activated
   // again. There is no ability to control the state through this API as this
   // leads to sync problems.
   void DisableInactiveRendering();
 
+  // Activates the window, assuming it already exists and is visible.
+  void Activate();
+
+  // Deactivates the window, making the next window in the Z order the active
+  // window.
+  void Deactivate();
+
+  // Closes the window, ultimately destroying it. The window hides immediately,
+  // and is destroyed after a return to the message loop. Close() can be called
+  // multiple times.
+  virtual void Close() OVERRIDE;
+
+  // Maximizes/minimizes/restores the window.
+  void Maximize();
+  void Minimize();
+  void Restore();
+
+  // Whether or not the window is currently active.
+  bool IsActive() const;
+
+  // Whether or not the window is currently visible.
+  bool IsVisible() const;
+
+  // Whether or not the window is maximized or minimized.
+  virtual bool IsMaximized() const;
+  bool IsMinimized() const;
+
   // Accessors for fullscreen state.
   void SetFullscreen(bool fullscreen);
   bool IsFullscreen() const;
 
   // Sets whether or not the window should show its frame as a "transient drag
   // frame" - slightly transparent and without the standard window controls.
   void SetUseDragFrame(bool use_drag_frame);
 
   // Toggles the enable state for the Close button (and the Close menu item in
   // the system menu).
   void EnableClose(bool enable);
 
   // Tell the window to update its title from the delegate.
   void UpdateWindowTitle();
 
   // Tell the window to update its icon from the delegate.
   void UpdateWindowIcon();
 
+  // Sets whether or not the window is always-on-top.
+  void SetIsAlwaysOnTop(bool always_on_top);
+
   // Creates an appropriate NonClientFrameView for this window.
   virtual NonClientFrameView* CreateFrameViewForWindow();
 
   // Updates the frame after an event caused it to be changed.
   virtual void UpdateFrameAfterFrameChange();
 
+  // Retrieves the Window's native window handle.
+  gfx::NativeWindow GetNativeWindow() const;
+
   void set_frame_type(FrameType frame_type) { frame_type_ = frame_type; }
   FrameType frame_type() const { return frame_type_; }
 
   // Whether we should be using a native frame.
   bool ShouldUseNativeFrame() const;
 
   // Forces the frame into the alternate frame type (custom or native) depending
   // on its current state.
   void DebugToggleFrameType();
 
   // Tell the window that something caused the frame type to change.
   void FrameTypeChanged();
 
-  // Overridden from Widget:
-  virtual void Show() OVERRIDE;
-  virtual void Close() OVERRIDE;
-
   WindowDelegate* window_delegate() {
     return const_cast<WindowDelegate*>(
         const_cast<const Window*>(this)->window_delegate());
   }
   const WindowDelegate* window_delegate() const {
     return window_delegate_;
   }
 
   NonClientView* non_client_view() {
     return const_cast<NonClientView*>(
@@ skipping 69 matching lines @@
   // The current frame type in use by this window. Defaults to
   // FRAME_TYPE_DEFAULT.
   FrameType frame_type_;
 
   DISALLOW_COPY_AND_ASSIGN(Window);
 };
 
 }  // namespace views
 
 #endif  // #ifndef VIEWS_WINDOW_WINDOW_H_