Support DWM switching....

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"
 #include "chrome/common/gfx/path.h"
 #include "chrome/common/l10n_util.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/common/resource_bundle.h"
 #include "chrome/common/win_util.h"
 #include "chrome/views/client_view.h"
-#include "chrome/views/custom_frame_window.h"
-#include "chrome/views/default_non_client_view.h"
+#include "chrome/views/custom_frame_view.h"
+#include "chrome/views/native_frame_view.h"
 #include "chrome/views/non_client_view.h"
 #include "chrome/views/root_view.h"
 #include "chrome/views/window_delegate.h"
 #include "grit/generated_resources.h"
 
 namespace views {
 
 // A scoping class that prevents a window from being able to redraw in response
 // to invalidations that may occur within it for the lifetime of the object.
 //
@@ skipping 44 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // Window, public:
 
 Window::~Window() {
 }
 
 // static
 Window* Window::CreateChromeWindow(HWND parent,
                                    const gfx::Rect& bounds,
                                    WindowDelegate* window_delegate) {
-  Window* window = NULL;
-  if (win_util::ShouldUseVistaFrame()) {
-    window = new Window(window_delegate);
-  } else {
-    window = new CustomFrameWindow(window_delegate);
-  }
+  Window* window = new Window(window_delegate);
+  window->non_client_view_->SetFrameView(window->CreateFrameViewForWindow());
   window->Init(parent, bounds);
   return window;
 }
 
 gfx::Size Window::CalculateMaximumSize() const {
   // If this is a top level window, the maximum size is the size of the working
   // rect of the display the window is on, less padding. If this is a child
   // (constrained) window, the maximum size of this Window are the bounds of the
   // parent window, less padding.
   DCHECK(GetHWND()) << "Cannot calculate maximum size before Init() is called";
@@ skipping 97 matching lines @@
   EnableMenuItem(GetSystemMenu(GetHWND(), false),
                  SC_CLOSE, enable ? MF_ENABLED : MF_GRAYED);
 
   // Let the window know the frame changed.
   SetWindowPos(NULL, 0, 0, 0, 0,
                SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOCOPYBITS |
                    SWP_NOMOVE | SWP_NOOWNERZORDER | SWP_NOREPOSITION |
                    SWP_NOSENDCHANGING | SWP_NOSIZE | SWP_NOZORDER);
 }
 
-void Window::DisableInactiveRendering(bool disable) {
-  disable_inactive_rendering_ = disable;
-  if (!disable_inactive_rendering_)
-    DefWindowProc(GetHWND(), WM_NCACTIVATE, FALSE, 0);
-  
-  if (!non_client_view_->UseNativeFrame()) {
-    // If the non-client view is rendering its own frame, we need to forcibly
-    // schedule a paint so it updates when we unset this mode.
-    non_client_view_->set_paint_as_active(disable);
-    if (!disable)
-      non_client_view_->SchedulePaint();
-  }
+void Window::DisableInactiveRendering() {
+  disable_inactive_rendering_ = true;
+  non_client_view_->DisableInactiveRendering(disable_inactive_rendering_);
 }
 
 void Window::UpdateWindowTitle() {
   // If the non-client view is rendering its own title, it'll need to relayout
   // now.
   non_client_view_->Layout();
 
   // Update the native frame's text. We do this regardless of whether or not
   // the native frame is being used, since this also updates the taskbar, etc.
   std::wstring window_title = window_delegate_->GetWindowTitle();
@@ skipping 25 matching lines @@
     if (old_icon)
       DestroyIcon(old_icon);
   }
 }
 
 void Window::ExecuteSystemMenuCommand(int command) {
   if (command)
     SendMessage(GetHWND(), WM_SYSCOMMAND, command, 0);
 }
 
+gfx::Rect Window::GetWindowBoundsForClientBounds(
+    const gfx::Rect& client_bounds) {
+  return non_client_view_->GetWindowBoundsForClientBounds(client_bounds);
+}
+
 // static
 int Window::GetLocalizedContentsWidth(int col_resource_id) {
   double chars = _wtof(l10n_util::GetString(col_resource_id).c_str());
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   ChromeFont font = rb.GetFont(ResourceBundle::BaseFont);
   int width = font.GetExpectedTextWidth(static_cast<int>(chars));
   DCHECK(width > 0);
   return width;
 }
 
@@ skipping 27 matching lines @@
   Close();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Window, protected:
 
 Window::Window(WindowDelegate* window_delegate)
     : WidgetWin(),
       focus_on_creation_(true),
       window_delegate_(window_delegate),
-      non_client_view_(new NonClientView),
+      non_client_view_(new NonClientView(this)),
       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),
       is_active_(false),
       lock_updates_(false),
       saved_window_style_(0),
@@ skipping 19 matching lines @@
   is_always_on_top_ = window_delegate_->IsAlwaysOnTop();
 
   if (window_style() == 0)
     set_window_style(CalculateWindowStyle());
   if (window_ex_style() == 0)
     set_window_ex_style(CalculateWindowExStyle());
 
   WidgetWin::Init(parent, bounds, true);
   win_util::SetWindowUserData(GetHWND(), this);
   
-  std::wstring window_title = window_delegate_->GetWindowTitle();
-  std::wstring localized_text;
-  if (l10n_util::AdjustStringForLocaleDirection(window_title, &localized_text))
-    window_title.assign(localized_text);
-  SetWindowText(GetHWND(), window_title.c_str());
+  // Create the ClientView, add it to the NonClientView and add the
+  // NonClientView to the RootView. This will cause everything to be parented.
+  non_client_view_->set_client_view(window_delegate_->CreateClientView(this));
+  WidgetWin::SetContentsView(non_client_view_);
 
-  SetClientView(window_delegate_->CreateClientView(this));
+  UpdateWindowTitle();
+
   SetInitialBounds(bounds);
   InitAlwaysOnTopState();
 
   if (!IsAppWindow()) {
     notification_registrar_.Add(
         this,
         NotificationType::ALL_APPWINDOWS_CLOSED,
         NotificationService::AllSources());
   }
 
-  ResetWindowRegion();
+  ResetWindowRegion(false);
+}
+
+NonClientFrameView* Window::CreateFrameViewForWindow() {
+  if (non_client_view_->UseNativeFrame())
+    return new NativeFrameView(this);
+  return new CustomFrameView(this);
+}
+
+void Window::UpdateFrameAfterFrameChange() {
+  // We've either gained or lost a custom window region, so reset it now.
+  ResetWindowRegion(true);
 }
 
 void Window::SizeWindowToDefault() {
   // CenterAndSizeWindow adjusts the window size to accommodate the non-client
   // area if we're using a native frame.
   win_util::CenterAndSizeWindow(owning_window(), GetHWND(),
                                 non_client_view_->GetPreferredSize().ToSIZE(),
                                 non_client_view_->UseNativeFrame());
 }
 
@@ skipping 11 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Window, WidgetWin overrides:
 
 void Window::OnActivate(UINT action, BOOL minimized, HWND window) {
   if (action == WA_INACTIVE)
     SaveWindowPosition();
 }
 
+void Window::OnActivateApp(BOOL active, DWORD thread_id) {
+  if (!active && thread_id != GetCurrentThreadId()) {
+    // Another application was activated, we should reset any state that
+    // disables inactive rendering now.
+    disable_inactive_rendering_ = false;
+    non_client_view_->DisableInactiveRendering(false);
+  }
+}
+
 LRESULT Window::OnAppCommand(HWND window, short app_command, WORD device,
                              int keystate) {
   // We treat APPCOMMAND ids as an extension of our command namespace, and just
   // let the delegate figure out what to do...
   if (!window_delegate_->ExecuteWindowsCommand(app_command))
     return WidgetWin::OnAppCommand(window, app_command, device, keystate);
   return 0;
 }
 
 void Window::OnCommand(UINT notification_code, int command_id, HWND window) {
   // We NULL check |window_delegate_| here because we can be sent WM_COMMAND
   // 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() {
   non_client_view_->WindowClosing();
   window_delegate_ = NULL;
   RestoreEnabledIfNecessary();
   WidgetWin::OnDestroy();
 }
 
 namespace {
+static BOOL CALLBACK SendDwmCompositionChanged(HWND window, LPARAM param) {
+  SendMessage(window, WM_DWMCOMPOSITIONCHANGED, 0, 0);
+  return TRUE;
+}
+}  // namespace
+
+LRESULT Window::OnDwmCompositionChanged(UINT msg, WPARAM w_param,
+                                        LPARAM l_param) {
+  // We respond to this in response to WM_DWMCOMPOSITIONCHANGED since that is
+  // the only thing we care about - we don't actually respond to WM_THEMECHANGED
+  // messages.
+  non_client_view_->SystemThemeChanged();
+
+  // WM_DWMCOMPOSITIONCHANGED is only sent to top level windows, however we want
+  // to notify our children too, since we can have MDI child windows who need to
+  // update their appearance.
+  EnumChildWindows(GetHWND(), &SendDwmCompositionChanged, NULL);
+  return 0;
+}
+
+namespace {
 static void EnableMenuItem(HMENU menu, UINT command, bool enabled) {
   UINT flags = MF_BYCOMMAND | (enabled ? MF_ENABLED : MF_DISABLED | MF_GRAYED);
   EnableMenuItem(menu, command, flags);
 }
 }  // namespace
 
 void Window::OnInitMenu(HMENU menu) {
   // We only need to manually enable the system menu if we're not using a native
   // frame.
-  if (non_client_view_->UseNativeFrame()) {
-    SetMsgHandled(FALSE);
-    return;
-  }
+  if (non_client_view_->UseNativeFrame())
+    WidgetWin::OnInitMenu(menu);
 
   bool is_minimized = IsMinimized();
   bool is_maximized = IsMaximized();
   bool is_restored = !is_minimized && !is_maximized;
 
   ScopedRedrawLock lock(this);
   EnableMenuItem(menu, SC_RESTORE, !is_restored);
   EnableMenuItem(menu, SC_MOVE, is_restored);
   EnableMenuItem(menu, SC_SIZE, window_delegate()->CanResize() && is_restored);
   EnableMenuItem(menu, SC_MAXIMIZE,
@@ skipping 23 matching lines @@
       // mouse really will have left the bounds of the RootView.
       process_mouse_exited = false;
     }
   }
 
   if (process_mouse_exited)
     ProcessMouseExited();
 }
 
 LRESULT Window::OnNCActivate(BOOL active) {
+  is_active_ = !!active;
+
   // If we're not using the native frame, we need to force a synchronous repaint
   // otherwise we'll be left in the wrong activation state until something else
   // causes a repaint later.
   if (!non_client_view_->UseNativeFrame()) {
-    is_active_ = !!active;
-
     // We can get WM_NCACTIVATE before we're actually visible. If we're not
     // visible, no need to paint.
     if (IsWindowVisible(GetHWND())) {
       non_client_view_->SchedulePaint();
       // We need to force a paint now, as a user dragging a window will block
       // painting operations while the move is in progress.
       PaintNow(root_view_->GetScheduledPaintRect());
     }
   }
 
+  // If we're active again, we should be allowed to render as inactive, so
+  // tell the non-client view. This must be done independently of the check for
+  // disable_inactive_rendering_ since that check is valid even if the frame
+  // is not active, but this can only be done if we've become active.
+  if (is_active_)
+    non_client_view_->DisableInactiveRendering(false);
+
+  // Reset the disable inactive rendering state since activation has changed.
   if (disable_inactive_rendering_) {
     disable_inactive_rendering_ = false;
-    return DefWindowProc(GetHWND(), WM_NCACTIVATE, TRUE, 0);
+    return CallDefaultNCActivateHandler(TRUE);
   }
-  // Otherwise just do the default thing.
-  return WidgetWin::OnNCActivate(active);
+  return CallDefaultNCActivateHandler(active);
 }
 
 LRESULT Window::OnNCCalcSize(BOOL mode, LPARAM l_param) {
   // We only need to adjust the client size/paint handling when we're not using
   // the native frame.
-  if (non_client_view_->UseNativeFrame()) {
-    SetMsgHandled(FALSE);
-    return 0;
-  }
+  if (non_client_view_->UseNativeFrame())
+    return WidgetWin::OnNCCalcSize(mode, l_param);
 
   // We need to repaint all when the window bounds change.
   return WVR_REDRAW;
 }
 
 LRESULT Window::OnNCHitTest(const CPoint& point) {
   // First, give the NonClientView a chance to test the point to see if it
   // provides any of the non-client area.
   CPoint temp = point;
   MapWindowPoints(HWND_DESKTOP, GetHWND(), &temp, 1);
   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;
+  return WidgetWin::OnNCHitTest(point);
 }
 
 namespace {
 struct ClipState {
   // The window being painted.
   HWND parent;
 
   // DC painting to.
   HDC dc;
 
@@ skipping 13 matching lines @@
                     bounds.top - clip_state->y,
                     bounds.right - clip_state->x,
                     bounds.bottom - clip_state->y);
   }
   return TRUE;
 }
 }  // namespace
 
 void Window::OnNCPaint(HRGN rgn) {
   // We only do non-client painting if we're not using the native frame.
-  if (non_client_view_->UseNativeFrame()) {
-    SetMsgHandled(FALSE);
-    return;
-  }
+  if (non_client_view_->UseNativeFrame())
+    return WidgetWin::OnNCPaint(rgn);
 
   // We have an NC region and need to paint it. We expand the NC region to
   // include the dirty region of the root view. This is done to minimize
   // paints.
   CRect window_rect;
   GetWindowRect(&window_rect);
 
   if (window_rect.Width() != root_view_->width() ||
       window_rect.Height() != root_view_->height()) {
     // If the size of the window differs from the size of the root view it
@@ skipping 177 matching lines @@
 void Window::OnSize(UINT size_param, const CSize& new_size) {
   // Don't no-op if the new_size matches current size. If our normal bounds
   // and maximized bounds are the same, then we need to layout (because we
   // layout differently when maximized).
   SaveWindowPosition();
   ChangeSize(size_param, new_size);
   RedrawWindow(GetHWND(), NULL, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN);
 
   // ResetWindowRegion is going to trigger WM_NCPAINT. By doing it after we've
   // invoked OnSize we ensure the RootView has been laid out.
-  ResetWindowRegion();
+  ResetWindowRegion(false);
 }
 
 void Window::OnSysCommand(UINT notification_code, CPoint click) {
   if (!non_client_view_->UseNativeFrame()) {
     // Windows uses the 4 lower order bits of |notification_code| for type-
     // specific information so we must exclude this when comparing.
     static const int sc_mask = 0xFFF0;
     if ((notification_code & sc_mask) == SC_MINIMIZE ||
         (notification_code & sc_mask) == SC_MAXIMIZE ||
         (notification_code & sc_mask) == SC_RESTORE) {
@@ skipping 10 matching lines @@
   }
 
   // First see if the delegate can handle it.
   if (window_delegate_->ExecuteWindowsCommand(notification_code))
     return;
 
   if (notification_code == IDC_ALWAYS_ON_TOP) {
     is_always_on_top_ = !is_always_on_top_;
 
     // Change the menu check state.
-    HMENU system_menu = ::GetSystemMenu(GetHWND(), FALSE);
+    HMENU system_menu = GetSystemMenu(GetHWND(), FALSE);
     MENUITEMINFO menu_info;
     memset(&menu_info, 0, sizeof(MENUITEMINFO));
     menu_info.cbSize = sizeof(MENUITEMINFO);
-    BOOL r = ::GetMenuItemInfo(system_menu, IDC_ALWAYS_ON_TOP,
-                               FALSE, &menu_info);
+    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);
+    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)) {
     // 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 173 matching lines @@
   lock_updates_ = true;
   saved_window_style_ = GetWindowLong(GetHWND(), GWL_STYLE);
   SetWindowLong(GetHWND(), GWL_STYLE, saved_window_style_ & ~WS_VISIBLE);
 }
 
 void Window::UnlockUpdates() {
   SetWindowLong(GetHWND(), GWL_STYLE, saved_window_style_);
   lock_updates_ = false;
 }
 
-void Window::ResetWindowRegion() {
+void Window::ResetWindowRegion(bool force) {
   // A native frame uses the native window region, and we don't want to mess
   // with it.
-  if (non_client_view_->UseNativeFrame())
+  if (non_client_view_->UseNativeFrame()) {
+    if (force)
+      SetWindowRgn(NULL, TRUE);
     return;
+  }
 
   // Changing the window region is going to force a paint. Only change the
   // window region if the region really differs.
   HRGN current_rgn = CreateRectRgn(0, 0, 0, 0);
   int current_rgn_result = GetWindowRgn(GetHWND(), current_rgn);
 
   CRect window_rect;
   GetWindowRect(&window_rect);
   HRGN new_region;
   if (IsMaximized()) {
@@ skipping 27 matching lines @@
   MapWindowPoints(HWND_DESKTOP, GetHWND(), &temp, 1);
   UINT message_flags = 0;
   if ((GetKeyState(VK_CONTROL) & 0x80) == 0x80)
     message_flags |= MK_CONTROL;
   if ((GetKeyState(VK_SHIFT) & 0x80) == 0x80)
     message_flags |= MK_SHIFT;
   message_flags |= flags;
   ProcessMousePressed(temp, message_flags, false, false);
 }
 
+LRESULT Window::CallDefaultNCActivateHandler(BOOL active) {
+  // The DefWindowProc handling for WM_NCACTIVATE renders the classic-look
+  // window title bar directly, so we need to use a redraw lock here to prevent
+  // it from doing so.
+  ScopedRedrawLock lock(this);
+  return DefWindowProc(GetHWND(), WM_NCACTIVATE, active, 0);
+}
+
 void Window::InitClass() {
   static bool initialized = false;
   if (!initialized) {
     resize_cursors_[RC_NORMAL] = LoadCursor(NULL, IDC_ARROW);
     resize_cursors_[RC_VERTICAL] = LoadCursor(NULL, IDC_SIZENS);
     resize_cursors_[RC_HORIZONTAL] = LoadCursor(NULL, IDC_SIZEWE);
     resize_cursors_[RC_NESW] = LoadCursor(NULL, IDC_SIZENESW);
     resize_cursors_[RC_NWSE] = LoadCursor(NULL, IDC_SIZENWSE);
     initialized = true;
   }
 }
 
 }  // namespace views