Custom frame UI for platform apps on Windows.

ui/views/widget/native_widget_win.cc

 // Copyright (c) 2012 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 "ui/views/widget/native_widget_win.h"
 
 #include <dwmapi.h>
 #include <shellapi.h>
 
 #include <algorithm>
@@ skipping 796 matching lines @@
   gfx::Rect bounds;
   GetWindowPlacement(&bounds, NULL);
   return bounds;
 }
 
 void NativeWidgetWin::SetBounds(const gfx::Rect& bounds) {
   LONG style = GetWindowLong(GWL_STYLE);
   if (style & WS_MAXIMIZE)
     SetWindowLong(GWL_STYLE, style & ~WS_MAXIMIZE);
   SetWindowPos(NULL, bounds.x(), bounds.y(), bounds.width(), bounds.height(),
-               SWP_NOACTIVATE | SWP_NOZORDER);
+               SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED);

[jeremya, 2012/02/06 00:58:32]

I added this to make the call to SetInitialBounds() in Widget::Init() cause
Windows to send a WM_NCCALCSIZE message. We probably don't want to use
SWP_FRAMECHANGED in every SetBounds call -- it's only needed during the
SetInitialBounds() call -- but I'm not sure what the best way to gate it is. (An
extra argument? A second function? A flag?)

 }
 
 void NativeWidgetWin::SetSize(const gfx::Size& size) {
   SetWindowPos(NULL, 0, 0, size.width(), size.height(),
                SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE);
 }
 
 void NativeWidgetWin::StackAbove(gfx::NativeView native_view) {
   SetWindowPos(native_view, 0, 0, 0, 0,
                SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
@@ skipping 806 matching lines @@
     return TRUE;
   }
 
   return DefWindowProcWithRedrawLock(WM_NCACTIVATE,
                                      inactive_rendering_disabled || active, 0);
 }
 
 LRESULT NativeWidgetWin::OnNCCalcSize(BOOL mode, LPARAM l_param) {
   // We only override the default handling if we need to specify a custom
   // non-client edge width. Note that in most cases "no insets" means no
-  // custom width, but in fullscreen mode we want a custom width of 0.
+  // custom width, but in fullscreen mode or when the NonClientFrameView
+  // requests it, we want a custom width of 0.
   gfx::Insets insets = GetClientAreaInsets();
-  if (insets.empty() && !IsFullscreen()) {
+  if (insets.empty() && !IsFullscreen() &&
+      !(mode && ShouldRemoveStandardFrame())) {
     SetMsgHandled(FALSE);
     return 0;
   }
 
   RECT* client_rect = mode ?
       &(reinterpret_cast<NCCALCSIZE_PARAMS*>(l_param)->rgrc[0]) :
       reinterpret_cast<RECT*>(l_param);
   client_rect->left += insets.left();
   client_rect->top += insets.top();
   client_rect->bottom -= insets.bottom();
@@ skipping 64 matching lines @@
 }
 
 LRESULT NativeWidgetWin::OnNCHitTest(const CPoint& point) {
   if (!GetWidget()->non_client_view()) {
     SetMsgHandled(FALSE);
     return 0;
   }
 
   // If the DWM is rendering the window controls, we need to give the DWM's
   // default window procedure first chance to handle hit testing.
-  if (GetWidget()->ShouldUseNativeFrame()) {
+  if (!ShouldRemoveStandardFrame() && GetWidget()->ShouldUseNativeFrame()) {
     LRESULT result;
     if (DwmDefWindowProc(GetNativeView(), WM_NCHITTEST, 0,
                          MAKELPARAM(point.x, point.y), &result)) {
       return result;
     }
   }
 
   // First, give the NonClientView a chance to test the point to see if it
   // provides any of the non-client area.
   POINT temp = point;
@@ skipping 612 matching lines @@
     SetWindowLong(GWL_STYLE, GetWindowLong(GWL_STYLE) | WS_VISIBLE);
     lock_updates_count_ = 0;
   }
 }
 
 bool NativeWidgetWin::WidgetSizeIsClientSize() const {
   const Widget* widget = GetWidget()->GetTopLevelWidget();
   return IsZoomed() || (widget && widget->ShouldUseNativeFrame());
 }
 
+bool NativeWidgetWin::ShouldRemoveStandardFrame() const {
+  NonClientFrameView* frame_view = GetWidget()->non_client_view()->frame_view();

[jeremya, 2012/02/06 00:58:32]

I've hit some problems (hopefully none of which remain) with this function being
called before the non_client_view gets initialized. It might be better/easier to
define this 'ShouldRemoveStandardFrame' thing in the init params, since we don't
support it changing after the window is created.

+  gfx::Rect client_area = frame_view->GetBoundsForClientView();
+  gfx::Rect window_area =
+      frame_view->GetWindowBoundsForClientBounds(client_area);
+  return client_area == window_area;
+}
+
 void NativeWidgetWin::ClientAreaSizeChanged() {
   RECT r;
   if (WidgetSizeIsClientSize())
     GetClientRect(&r);
   else
     GetWindowRect(&r);
   gfx::Size s(std::max(0, static_cast<int>(r.right - r.left)),
               std::max(0, static_cast<int>(r.bottom - r.top)));
   if (compositor_.get())
     compositor_->WidgetSizeChanged(s);
   delegate_->OnNativeWidgetSizeChanged(s);
   if (use_layered_buffer_)
     layered_window_contents_.reset(new gfx::CanvasSkia(s, false));
+
+  if (ShouldRemoveStandardFrame()) {
+    MARGINS m = {10, 10, 10, 10};
+    DwmExtendFrameIntoClientArea(GetNativeView(), &m);

[jeremya, 2012/02/06 00:58:32]

This is appropriate for the specific case of the ShellWindow, but conceivably
other clients might want different behaviour. I think it makes sense to
hard-code it until there's a need for generalization.

+  }
 }
 
 void NativeWidgetWin::ResetWindowRegion(bool force) {
   // A native frame uses the native window region, and we don't want to mess
   // with it.
   if (GetWidget()->ShouldUseNativeFrame() || !GetWidget()->non_client_view()) {
     if (force)
       SetWindowRgn(NULL, TRUE);
     return;
   }
@@ skipping 221 matching lines @@
   return (GetKeyState(VK_LBUTTON) & 0x80) ||
     (GetKeyState(VK_RBUTTON) & 0x80) ||
     (GetKeyState(VK_MBUTTON) & 0x80) ||
     (GetKeyState(VK_XBUTTON1) & 0x80) ||
     (GetKeyState(VK_XBUTTON2) & 0x80);
 }
 
 }  // namespace internal
 
 }  // namespace views