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

chrome/views/window.cc

 // 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.
 
 #include "chrome/views/window.h"
 
 #include "base/win_util.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/common/gfx/chrome_font.h"
 #include "chrome/common/gfx/icon_util.h"
@@ skipping 112 matching lines @@
 
 void Window::Close() {
   if (window_closed_) {
     // It appears we can hit this code path if you close a modal dialog then
     // close the last browser before the destructor is hit, which triggers
     // invoking Close again. I'm short circuiting this code path to avoid
     // calling into the delegate twice, which is problematic.
     return;
   }
 
-  if (client_view_->CanClose()) {
+  if (non_client_view_->CanClose()) {
     SaveWindowPosition();
     RestoreEnabledIfNecessary();
     WidgetWin::Close();
     // If the user activates another app after opening us, then comes back and
     // closes us, we want our owner to gain activation.  But only if the owner
     // is visible. If we don't manually force that here, the other app will
     // regain activation instead.
     if (owning_hwnd_ && GetHWND() == GetForegroundWindow() &&
         IsWindowVisible(owning_hwnd_)) {
       SetForegroundWindow(owning_hwnd_);
@@ skipping 100 matching lines @@
   Close();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Window, protected:
 
 Window::Window(WindowDelegate* window_delegate)
     : WidgetWin(),
       focus_on_creation_(true),
       window_delegate_(window_delegate),
-      non_client_view_(NULL),
-      client_view_(NULL),
+      non_client_view_(new NonClientView),
       owning_hwnd_(NULL),
       minimum_size_(100, 100),
       is_modal_(false),
       restored_enabled_(false),
       is_always_on_top_(false),
       window_closed_(false),
       disable_inactive_rendering_(false),
       saved_maximized_state_(0) {
   InitClass();
   DCHECK(window_delegate_);
@@ skipping 34 matching lines @@
   InitAlwaysOnTopState();
 
   if (!IsAppWindow()) {
     notification_registrar_.Add(
         this,
         NotificationType::ALL_APPWINDOWS_CLOSED,
         NotificationService::AllSources());
   }
 }
 
-void Window::SetClientView(ClientView* client_view) {
-  DCHECK(client_view && !client_view_ && GetHWND());
-  client_view_ = client_view;
-  if (non_client_view_) {
-    // This will trigger the ClientView to be added by the non-client view.
-    WidgetWin::SetContentsView(non_client_view_);
-  } else {
-    WidgetWin::SetContentsView(client_view_);
-  }
-}
-
 void Window::SizeWindowToDefault() {
-  gfx::Size pref;
-  if (non_client_view_) {
-    pref = non_client_view_->GetPreferredSize();
-  } else {
-    pref = client_view_->GetPreferredSize();
-  }
+  gfx::Size pref = non_client_view_->GetPreferredSize();
   DCHECK(pref.width() > 0 && pref.height() > 0);
   // CenterAndSizeWindow adjusts the window size to accommodate the non-client
   // area.
   win_util::CenterAndSizeWindow(owning_window(), GetHWND(), pref.ToSIZE(),
                                 true);
 }
 
 void Window::RunSystemMenu(const gfx::Point& point) {
   // We need to reset and clean up any currently created system menu objects.
   // We need to call this otherwise there's a small chance that we aren't going
@@ skipping 29 matching lines @@
   // messages even after the window is destroyed.
   // If the notification code is > 1 it means it is control specific and we
   // should ignore it.
   if (notification_code > 1 || !window_delegate_ ||
       window_delegate_->ExecuteWindowsCommand(command_id)) {
     WidgetWin::OnCommand(notification_code, command_id, window);
   }
 }
 
 void Window::OnDestroy() {
-  if (client_view_) {
-    client_view_->WindowClosing();
-    window_delegate_ = NULL;
-  }
+  non_client_view_->WindowClosing();
+  window_delegate_ = NULL;
   RestoreEnabledIfNecessary();
   WidgetWin::OnDestroy();
 }
 
 LRESULT Window::OnNCActivate(BOOL active) {
   if (disable_inactive_rendering_) {
     disable_inactive_rendering_ = false;
     return DefWindowProc(GetHWND(), WM_NCACTIVATE, TRUE, 0);
   }
   // Otherwise just do the default thing.
   return WidgetWin::OnNCActivate(active);
 }
 
 LRESULT Window::OnNCHitTest(const CPoint& point) {
   // First, give the ClientView a chance to test the point to see if it is part
   // of the non-client area.
   CPoint temp = point;
   MapWindowPoints(HWND_DESKTOP, GetHWND(), &temp, 1);
-  int component = HTNOWHERE;
-  if (non_client_view_) {
-    component = non_client_view_->NonClientHitTest(gfx::Point(temp));
-  } else {
-    component = client_view_->NonClientHitTest(gfx::Point(temp));
-  }
+  int component = non_client_view_->NonClientHitTest(gfx::Point(temp));
   if (component != HTNOWHERE)
     return component;
 
   // Otherwise, we let Windows do all the native frame non-client handling for
   // us.
   SetMsgHandled(FALSE);
   return 0;
 }
 
 void Window::OnNCLButtonDown(UINT ht_component, const CPoint& point) {
-  if (ht_component == HTSYSMENU) {
-    gfx::Point system_menu_point;
-    if (non_client_view_) {
-      system_menu_point = non_client_view_->GetSystemMenuPoint();
-    } else {
-      CPoint temp(0, -NonClientView::kFrameShadowThickness);
-      MapWindowPoints(GetHWND(), HWND_DESKTOP, &temp, 1);
-      system_menu_point = gfx::Point(temp);
-    }
-    RunSystemMenu(system_menu_point);
-  } else {
+  if (ht_component == HTSYSMENU)
+    RunSystemMenu(non_client_view_->GetSystemMenuPoint());
+  else
     WidgetWin::OnNCLButtonDown(ht_component, point);
-  }
 }
 
 void Window::OnNCRButtonDown(UINT ht_component, const CPoint& point) {
   if (ht_component == HTCAPTION || ht_component == HTSYSMENU)
     RunSystemMenu(gfx::Point(point));
   else
     WidgetWin::OnNCRButtonDown(ht_component, point);
 }
 
 
@@ skipping 34 matching lines @@
     BOOL r = ::GetMenuItemInfo(system_menu, IDC_ALWAYS_ON_TOP,
                                FALSE, &menu_info);
     DCHECK(r);
     menu_info.fMask = MIIM_STATE;
     if (is_always_on_top_)
       menu_info.fState = MFS_CHECKED;
     r = ::SetMenuItemInfo(system_menu, IDC_ALWAYS_ON_TOP, FALSE, &menu_info);
 
     // Now change the actual window's behavior.
     AlwaysOnTopChanged();
-  } else if ((notification_code == SC_KEYMENU) && (click.x == VK_SPACE) &&
-             non_client_view_) {
+  } else if ((notification_code == SC_KEYMENU) && (click.x == VK_SPACE)) {
     // Run the system menu at the NonClientView's desired location.
     RunSystemMenu(non_client_view_->GetSystemMenuPoint());
   } else {
     // Use the default implementation for any other command.
     DefWindowProc(GetHWND(), WM_SYSCOMMAND, notification_code,
                   MAKELPARAM(click.y, click.x));
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Window, private:
 
+void Window::SetClientView(ClientView* client_view) {
+  DCHECK(client_view && GetHWND());
+  non_client_view_->set_client_view(client_view);
+  // This will trigger the ClientView to be added by the non-client view.
+  WidgetWin::SetContentsView(non_client_view_);
+}
+
 void Window::BecomeModal() {
   // We implement modality by crawling up the hierarchy of windows starting
   // at the owner, disabling all of them so that they don't receive input
   // messages.
   DCHECK(owning_hwnd_) << "Can't create a modal dialog without an owner";
   HWND start = owning_hwnd_;
   while (start != NULL) {
     ::EnableWindow(start, FALSE);
     start = ::GetParent(start);
   }
@@ skipping 172 matching lines @@
 void Window::InitClass() {
   static bool initialized = false;
   if (!initialized) {
     nwse_cursor_ = LoadCursor(NULL, IDC_SIZENWSE);
     initialized = true;
   }
 }
 
 }  // namespace views