All views::Window objects must have a NonClientView, regardless of whether or...

chrome/views/window.h

 // Copyright (c) 2006-2008 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 CHROME_VIEWS_WINDOW_H__
 #define CHROME_VIEWS_WINDOW_H__
 
 #include "chrome/common/notification_registrar.h"
+#include "chrome/views/client_view.h"
+#include "chrome/views/non_client_view.h"
 #include "chrome/views/widget_win.h"
 
 namespace gfx {
 class Point;
 class Size;
 };
 
 namespace views {
 
-class ClientView;
 class Client;
 class NonClientView;
 class WindowDelegate;
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 // Window
 //
 //  A Window is a WidgetWIn that has a caption and a border. The frame is
 //  rendered by the operating system.
@@ skipping 55 matching lines @@
 
   // Prevents the window from being rendered as deactivated when |disable| is
   // true, until called with |disable| false. Used when a sub-window is to be
   // shown that shouldn't visually de-activate the window.
   // Subclasses can override this to perform additional actions when this value
   // changes.
   virtual void DisableInactiveRendering(bool disable);
 
   WindowDelegate* window_delegate() const { return window_delegate_; }
 
-  // Returns the ClientView object used by this Window.
-  ClientView* client_view() const { return client_view_; }
-
   void set_focus_on_creation(bool focus_on_creation) {
     focus_on_creation_ = focus_on_creation;
   }
 
   // Tell the window to update its title from the delegate.
   virtual void UpdateWindowTitle();
 
   // Tell the window to update its icon from the delegate.
   virtual void UpdateWindowIcon();
 
   // Executes the specified SC_command.
   void ExecuteSystemMenuCommand(int command);
 
   // The parent of this window.
   HWND owning_window() const { return owning_hwnd_; }
 
+  // Shortcut to access the ClientView associated with this window.
+  ClientView* client_view() const { return non_client_view_->client_view(); }
+
   // Returns the preferred size of the contents view of this window based on
   // its localized size data. The width in cols is held in a localized string
   // resource identified by |col_resource_id|, the height in the same fashion.
   // TODO(beng): This should eventually live somewhere else, probably closer to
   //             ClientView.
   static int GetLocalizedContentsWidth(int col_resource_id);
   static int GetLocalizedContentsHeight(int row_resource_id);
   static gfx::Size GetLocalizedContentsSize(int col_resource_id,
                                             int row_resource_id);
 
   // NotificationObserver overrides:
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  protected:
   // Constructs the Window. |window_delegate| cannot be NULL.
   explicit Window(WindowDelegate* window_delegate);
 
   // Create the Window.
   // If parent is NULL, this Window is top level on the desktop.
   // If |bounds| is empty, the view is queried for its preferred size and
   // centered on screen.
   virtual void Init(HWND parent, const gfx::Rect& bounds);
 
-  // Sets the specified view as the ClientView of this Window. The ClientView
-  // is responsible for laying out the Window's contents view, as well as
-  // performing basic hit-testing, and perhaps other responsibilities depending
-  // on the implementation. The Window's view hierarchy takes ownership of the
-  // ClientView unless the ClientView specifies otherwise. This must be called
-  // only once, and after the native window has been created.
-  // This is called by Init. |client_view| cannot be NULL.
-  virtual void SetClientView(ClientView* client_view);
-
   // Sizes the window to the default size specified by its ClientView.
   virtual void SizeWindowToDefault();
 
   // Returns true if the Window is considered to be an "app window" - i.e. any
   // window which when it is the last of its type closed causes the application
   // to exit.
   virtual bool IsAppWindow() const { return false; }
 
-  void set_client_view(ClientView* client_view) { client_view_ = client_view; }
-
   // Shows the system menu at the specified screen point.
   void RunSystemMenu(const gfx::Point& point);
 
   // Overridden from WidgetWin:
   virtual void OnActivate(UINT action, BOOL minimized, HWND window);
   virtual LRESULT OnAppCommand(HWND window, short app_command, WORD device,
                                int keystate);
   virtual void OnCommand(UINT notification_code, int command_id, HWND window);
   virtual void OnDestroy();
   virtual LRESULT OnNCActivate(BOOL active);
   virtual LRESULT OnNCHitTest(const CPoint& point);
   virtual void OnNCLButtonDown(UINT ht_component, const CPoint& point);
   virtual void OnNCRButtonDown(UINT ht_component, const CPoint& point);
   virtual LRESULT OnSetCursor(HWND window, UINT hittest_code, UINT message);
   virtual void OnSize(UINT size_param, const CSize& new_size);
   virtual void OnSysCommand(UINT notification_code, CPoint click);
 
   // The View that provides the non-client area of the window (title bar,
   // window controls, sizing borders etc). To use an implementation other than
   // the default, this class must be subclassed and this value set to the
   // desired implementation before calling |Init|.
   NonClientView* non_client_view_;
 
   // Accessor for disable_inactive_rendering_.
   bool disable_inactive_rendering() const {
     return disable_inactive_rendering_;
   }
 
  private:
+  // Sets the specified view as the ClientView of this Window. The ClientView
+  // is responsible for laying out the Window's contents view, as well as
+  // performing basic hit-testing, and perhaps other responsibilities depending
+  // on the implementation. The Window's view hierarchy takes ownership of the
+  // ClientView unless the ClientView specifies otherwise. This must be called
+  // only once, and after the native window has been created.
+  // This is called by Init. |client_view| cannot be NULL.
+  void SetClientView(ClientView* client_view);
+
   // Set the window as modal (by disabling all the other windows).
   void BecomeModal();
 
   // Sets-up the focus manager with the view that should have focus when the
   // window is shown the first time.  If NULL is returned, the focus goes to the
   // button if there is one, otherwise the to the Cancel button.
   void SetInitialFocus();
 
   // Place and size the window when it is created. |create_bounds| are the
   // bounds used when the window was created.
@@ skipping 16 matching lines @@
   DWORD CalculateWindowStyle();
   DWORD CalculateWindowExStyle();
 
   // Asks the delegate if any to save the window's location and size.
   void SaveWindowPosition();
 
   // Static resource initialization.
   static void InitClass();
   static HCURSOR nwse_cursor_;
 
-  // A ClientView object or subclass, responsible for sizing the contents view
-  // of the window, hit testing and perhaps other tasks depending on the
-  // implementation.
-  ClientView* client_view_;
-
   // Our window delegate (see Init method for documentation).
   WindowDelegate* window_delegate_;
 
   // Whether we should SetFocus() on a newly created window after
   // Init(). Defaults to true.
   bool focus_on_creation_;
 
   // We need to save the parent window that spawned us, since GetParent()
   // returns NULL for dialogs.
   HWND owning_hwnd_;
@@ skipping 29 matching lines @@
 
   // Hold onto notifications.
   NotificationRegistrar notification_registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(Window);
 };
 
 }  // namespace views
 
 #endif  // CHROME_VIEWS_WINDOW_H__