Move more from Window onto Widget.

views/widget/widget.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_WIDGET_WIDGET_H_
 #define VIEWS_WIDGET_WIDGET_H_
 #pragma once
 
 #include <vector>
 
@@ skipping 202 matching lines @@
   // fit the entire size of the RootView. The RootView takes ownership of this
   // View, unless it is set as not being parent-owned.
   void SetContentsView(View* view);
 
   // Returns the bounds of the Widget in screen coordinates.
   gfx::Rect GetWindowScreenBounds() const;
 
   // Returns the bounds of the Widget's client area in screen coordinates.
   gfx::Rect GetClientAreaScreenBounds() const;
 
+  // Retrieves the restored bounds for the window.
+  gfx::Rect GetRestoredBounds() const;
+
   // Sizes and/or places the widget to the specified bounds, size or position.
   void SetBounds(const gfx::Rect& bounds);
   void SetSize(const gfx::Size& size);
 
   // Like SetBounds(), but ensures the Widget is fully visible within the bounds
   // of its parent. If the Widget has no parent, it is centered within the
   // bounds of its screen if it is visible, or |other_widget|'s screen if it is
   // not.
   void SetBoundsConstrained(const gfx::Rect& bounds,
                             Widget* other_widget);
 
   // Places the widget in front of the specified widget in z-order.
   void MoveAboveWidget(Widget* widget);
   void MoveAbove(gfx::NativeView native_view);
 
   // Sets a shape on the widget. This takes ownership of shape.
   void SetShape(gfx::NativeRegion shape);
 
   // Hides the widget then closes it after a return to the message loop.
   virtual void Close();
 
   // TODO(beng): Move off public API.
   // Closes the widget immediately. Compare to |Close|. This will destroy the
   // window handle associated with this Widget, so should not be called from
   // any code that expects it to be valid beyond this call.
   void CloseNow();
 
+  // Toggles the enable state for the Close button (and the Close menu item in
+  // the system menu).
+  void EnableClose(bool enable);
+
   // Shows or hides the widget, without changing activation state.
   virtual void Show();
   void Hide();
 
+  // Like Show(), but does not activate the window.
+  void ShowInactive();
+
   // Activates the widget, assuming it already exists and is visible.
   void Activate();
 
   // Deactivates the widget, making the next window in the Z order the active
   // window.
   void Deactivate();
 
   // Returns whether the Widget is the currently active window.
   virtual bool IsActive() const;
 
+  // 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();
+
   // Sets the widget to be on top of all other widgets in the windowing system.
   void SetAlwaysOnTop(bool on_top);
 
   // Maximizes/minimizes/restores the window.
   void Maximize();
   void Minimize();
   void Restore();
 
   // Whether or not the window is maximized or minimized.
   virtual bool IsMaximized() const;
@@ skipping 68 matching lines @@
   // Sets the currently visible cursor. If |cursor| is NULL, the cursor used
   // before the current is restored.
   void SetCursor(gfx::NativeCursor cursor);
 
   // Resets the last move flag so that we can go around the optimization
   // that disregards duplicate mouse moves when ending animation requires
   // a new hit-test to do some highlighting as in TabStrip::RemoveTabAnimation
   // to cause the close button to highlight.
   void ResetLastMouseMoveFlag();
 
+  // Tell the window to update its title from the delegate.
+  void UpdateWindowTitle();
+
+  // Tell the window to update its icon from the delegate.
+  void UpdateWindowIcon();
+
   // Retrieves the focus traversable for this widget.
   FocusTraversable* GetFocusTraversable();
 
   // Notifies the view hierarchy contained in this widget that theme resources
   // changed.
   void ThemeChanged();
 
   // Notifies the view hierarchy contained in this widget that locale resources
   // changed.
   void LocaleChanged();
@@ skipping 49 matching lines @@
   // native accessibility event and the duplicate event would cause
   // problems.
   void NotifyAccessibilityEvent(
       View* view,
       ui::AccessibilityTypes::Event event_type,
       bool send_native_event);
 
   const NativeWidget* native_widget() const { return native_widget_; }
   NativeWidget* native_widget() { return native_widget_; }
 
+  // TODO(beng): remove once Window is folded in.
+  virtual Window* AsWindow();
+  virtual const Window* AsWindow() const;
+
   // Overridden from NativeWidgetDelegate:
+  virtual bool CanActivate() const OVERRIDE;
+  virtual bool IsInactiveRenderingDisabled() const OVERRIDE;
+  virtual void EnableInactiveRendering() OVERRIDE;
+  virtual void OnNativeWidgetActivationChanged(bool active) OVERRIDE;
   virtual void OnNativeFocus(gfx::NativeView focused_view) OVERRIDE;
   virtual void OnNativeBlur(gfx::NativeView focused_view) OVERRIDE;
   virtual void OnNativeWidgetCreated() OVERRIDE;
+  virtual void OnNativeWidgetDestroying() OVERRIDE;
   virtual void OnNativeWidgetDestroyed() OVERRIDE;
-  virtual void OnSizeChanged(const gfx::Size& new_size) OVERRIDE;
+  virtual gfx::Size GetMinimumSize() OVERRIDE;
+  virtual void OnNativeWidgetSizeChanged(const gfx::Size& new_size) OVERRIDE;
+  virtual void OnNativeWidgetBeginUserBoundsChange() OVERRIDE;
+  virtual void OnNativeWidgetEndUserBoundsChange() OVERRIDE;
   virtual bool HasFocusManager() const OVERRIDE;
   virtual bool OnNativeWidgetPaintAccelerated(
       const gfx::Rect& dirty_region) OVERRIDE;
   virtual void OnNativeWidgetPaint(gfx::Canvas* canvas) OVERRIDE;
+  virtual int GetNonClientComponent(const gfx::Point& point) OVERRIDE;
   virtual bool OnKeyEvent(const KeyEvent& event) OVERRIDE;
   virtual bool OnMouseEvent(const MouseEvent& event) OVERRIDE;
   virtual void OnMouseCaptureLost() OVERRIDE;
+  virtual bool ExecuteCommand(int command_id) OVERRIDE;
   virtual Widget* AsWidget() OVERRIDE;
   virtual const Widget* AsWidget() const OVERRIDE;
 
   // Overridden from FocusTraversable:
   virtual FocusSearch* GetFocusSearch() OVERRIDE;
   virtual FocusTraversable* GetFocusTraversableParent() OVERRIDE;
   virtual View* GetFocusTraversableParentView() OVERRIDE;
 
  protected:
   // TODO(beng): Remove NativeWidgetGtk's dependence on the mouse state flags.
@@ skipping 25 matching lines @@
   bool last_mouse_event_was_move_;
   gfx::Point last_mouse_event_position_;
 
  private:
   // Try to create a compositor if one hasn't been created yet.
   void EnsureCompositor();
 
   // Returns whether capture should be released on mouse release.
   virtual bool ShouldReleaseCaptureOnMouseReleased() const;
 
+  // Persists the window's restored position and maximized state using the
+  // window delegate.
+  void SaveWindowPosition();
+
   NativeWidget* native_widget_;
 
-  InitParams::Type type_;
-
   // Non-owned pointer to the Widget's delegate.  May be NULL if no delegate is
   // being used.
   WidgetDelegate* widget_delegate_;
 
   // The root of the View hierarchy attached to this window.
   // WARNING: see warning in tooltip_manager_ for ordering dependencies with
   // this and tooltip_manager_.
   scoped_ptr<internal::RootView> root_view_;
 
   // The View that provides the non-client area of the window (title bar,
@@ skipping 21 matching lines @@
   // See class documentation for Widget above for a note about ownership.
   InitParams::Ownership ownership_;
 
   // See set_is_secondary_widget().
   bool is_secondary_widget_;
 
   // The current frame type in use by this window. Defaults to
   // FRAME_TYPE_DEFAULT.
   FrameType frame_type_;
 
+  // True when the window should be rendered as active, regardless of whether
+  // or not it actually is.
+  bool disable_inactive_rendering_;
+
+  // Set to true if the widget is in the process of closing.
+  bool widget_closed_;
+
   DISALLOW_COPY_AND_ASSIGN(Widget);
 };
 
 }  // namespace views
 
 #endif // VIEWS_WIDGET_WIDGET_H_