NOT FOR SUBMIT - Windows Views HiDPI

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>
 
 #include "base/bind.h"
 #include "base/string_util.h"
 #include "base/win/scoped_gdi_object.h"
 #include "base/win/win_util.h"
 #include "base/win/windows_version.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/dragdrop/drag_source_win.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/dragdrop/os_exchange_data_provider_win.h"
 #include "ui/base/events/event.h"
 #include "ui/base/keycodes/keyboard_code_conversion_win.h"
 #include "ui/base/l10n/l10n_util_win.h"
 #include "ui/base/theme_provider.h"
 #include "ui/base/view_prop.h"
+#include "ui/base/win/dpi.h"
 #include "ui/base/win/hwnd_util.h"
 #include "ui/base/win/mouse_wheel_util.h"
 #include "ui/base/win/shell.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/canvas_paint.h"
 #include "ui/gfx/canvas_skia_paint.h"
 #include "ui/gfx/path.h"
+#include "ui/gfx/point_conversions.h"
 #include "ui/gfx/screen.h"
+#include "ui/gfx/size_conversions.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/controls/native_control_win.h"
 #include "ui/views/controls/textfield/textfield.h"
 #include "ui/views/drag_utils.h"
 #include "ui/views/focus/accelerator_handler.h"
 #include "ui/views/focus/view_storage.h"
 #include "ui/views/focus/widget_focus_manager.h"
 #include "ui/views/ime/input_method_win.h"
 #include "ui/views/widget/aero_tooltip_manager.h"
 #include "ui/views/widget/drop_target_win.h"
@@ skipping 60 matching lines @@
 }
 
 void NativeWidgetWin::Show(int show_state) {
   message_handler_->Show(show_state);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetWin, NativeWidget implementation:
 
 void NativeWidgetWin::InitNativeWidget(const Widget::InitParams& params) {
-  SetInitParams(params);
-  message_handler_->Init(params.parent, params.bounds);
+  gfx::Rect pixel_bounds = ui::win::DIPToScreenRect(params.bounds);
+  Widget::InitParams params_in_pixel(params);
+  params_in_pixel.bounds = pixel_bounds;
+  SetInitParams(params_in_pixel);
+  message_handler_->Init(params.parent, pixel_bounds);
 }
 
 NonClientFrameView* NativeWidgetWin::CreateNonClientFrameView() {
   return GetWidget()->ShouldUseNativeFrame() ?
       new NativeFrameView(GetWidget()) : NULL;
 }
 
 bool NativeWidgetWin::ShouldUseNativeFrame() const {
   return ui::win::IsAeroGlassEnabled();
 }
@@ skipping 75 matching lines @@
 
 InputMethod* NativeWidgetWin::CreateInputMethod() {
   return new InputMethodWin(GetMessageHandler(), GetNativeWindow(), NULL);
 }
 
 internal::InputMethodDelegate* NativeWidgetWin::GetInputMethodDelegate() {
   return message_handler_.get();
 }
 
 void NativeWidgetWin::CenterWindow(const gfx::Size& size) {
-  message_handler_->CenterWindow(size);
+  gfx::Size size_in_pixels = ui::win::DIPToScreenSize(size);
+  message_handler_->CenterWindow(size_in_pixels);
 }
 
 void NativeWidgetWin::GetWindowPlacement(
     gfx::Rect* bounds,
     ui::WindowShowState* show_state) const {
   message_handler_->GetWindowPlacement(bounds, show_state);
+  *bounds = ui::win::ScreenToDIPRect(*bounds);
 }
 
 void NativeWidgetWin::SetWindowTitle(const string16& title) {
   message_handler_->SetTitle(title);
 }
 
 void NativeWidgetWin::SetWindowIcons(const gfx::ImageSkia& window_icon,
                                      const gfx::ImageSkia& app_icon) {
   message_handler_->SetWindowIcons(window_icon, app_icon);
 }
 
 void NativeWidgetWin::InitModalType(ui::ModalType modal_type) {
   message_handler_->InitModalType(modal_type);
 }
 
 gfx::Rect NativeWidgetWin::GetWindowBoundsInScreen() const {
-  return message_handler_->GetWindowBoundsInScreen();
+  gfx::Rect bounds_in_pixels = message_handler_->GetWindowBoundsInScreen();
+  return ui::win::ScreenToDIPRect(bounds_in_pixels);
 }
 
 gfx::Rect NativeWidgetWin::GetClientAreaBoundsInScreen() const {
-  return message_handler_->GetClientAreaBoundsInScreen();
+  gfx::Rect bounds_in_pixels = message_handler_->GetClientAreaBoundsInScreen();
+  return ui::win::ScreenToDIPRect(bounds_in_pixels);
 }
 
 gfx::Rect NativeWidgetWin::GetRestoredBounds() const {
-  return message_handler_->GetRestoredBounds();
+  gfx::Rect bounds_in_pixels = message_handler_->GetRestoredBounds();
+  return ui::win::ScreenToDIPRect(bounds_in_pixels);
 }
 
 void NativeWidgetWin::SetBounds(const gfx::Rect& bounds) {
-  message_handler_->SetBounds(bounds);
+  float scale = ui::win::GetDeviceScaleFactor();
+  gfx::Rect bounds_in_pixels(
+      gfx::ToCeiledPoint(gfx::ScalePoint(bounds.origin(), scale)),
+      gfx::ToFlooredSize(gfx::ScaleSize(bounds.size(), scale)));
+  message_handler_->SetBounds(bounds_in_pixels);
 }
 
 void NativeWidgetWin::SetSize(const gfx::Size& size) {
   message_handler_->SetSize(size);
 }
 
 void NativeWidgetWin::StackAbove(gfx::NativeView native_view) {
   message_handler_->StackAbove(native_view);
 }
 
@@ skipping 20 matching lines @@
 void NativeWidgetWin::Show() {
   message_handler_->Show();
 }
 
 void NativeWidgetWin::Hide() {
   message_handler_->Hide();
 }
 
 void NativeWidgetWin::ShowMaximizedWithBounds(
     const gfx::Rect& restored_bounds) {
-  message_handler_->ShowMaximizedWithBounds(restored_bounds);
+  gfx::Rect pixel_bounds = ui::win::DIPToScreenRect(restored_bounds);
+  message_handler_->ShowMaximizedWithBounds(pixel_bounds);
 }
 
 void NativeWidgetWin::ShowWithWindowState(ui::WindowShowState show_state) {
   message_handler_->ShowWindowWithState(show_state);
 }
 
 bool NativeWidgetWin::IsVisible() const {
   return message_handler_->IsVisible();
 }
 
@@ skipping 85 matching lines @@
 
 void NativeWidgetWin::RunShellDrag(View* view,
                                    const ui::OSExchangeData& data,
                                    const gfx::Point& location,
                                    int operation,
                                    ui::DragDropTypes::DragEventSource source) {
   views::RunShellDrag(NULL, data, location, operation, source);
 }
 
 void NativeWidgetWin::SchedulePaintInRect(const gfx::Rect& rect) {
-  message_handler_->SchedulePaintInRect(rect);
+  gfx::Rect pixel_rect = ui::win::DIPToScreenRect(rect);
+  message_handler_->SchedulePaintInRect(pixel_rect);
 }
 
 void NativeWidgetWin::SetCursor(gfx::NativeCursor cursor) {
   message_handler_->SetCursor(cursor);
 }
 
 void NativeWidgetWin::ClearNativeFocus() {
   message_handler_->ClearNativeFocus();
 }
 
 gfx::Rect NativeWidgetWin::GetWorkAreaBoundsInScreen() const {
-  return gfx::Screen::GetNativeScreen()->GetDisplayNearestWindow(
-      GetNativeView()).work_area();
+  return ui::win::ScreenToDIPRect(
+      gfx::Screen::GetNativeScreen()->GetDisplayNearestWindow(
+      GetNativeView()).work_area());
 }
 
 void NativeWidgetWin::SetInactiveRenderingDisabled(bool value) {
 }
 
 Widget::MoveLoopResult NativeWidgetWin::RunMoveLoop(
     const gfx::Vector2d& drag_offset,
     Widget::MoveLoopSource source) {
   return message_handler_->RunMoveLoop(drag_offset) ?
       Widget::MOVE_LOOP_SUCCESSFUL : Widget::MOVE_LOOP_CANCELED;
@@ skipping 106 matching lines @@
 
 int NativeWidgetWin::GetInitialShowState() const {
   return SW_SHOWNORMAL;
 }
 
 bool NativeWidgetWin::WillProcessWorkAreaChange() const {
   return GetWidget()->widget_delegate()->WillProcessWorkAreaChange();
 }
 
 int NativeWidgetWin::GetNonClientComponent(const gfx::Point& point) const {
-  return delegate_->GetNonClientComponent(point);
+  gfx::Point point_in_dip = ui::win::ScreenToDIPPoint(point);
+  return delegate_->GetNonClientComponent(point_in_dip);
 }
 
 void NativeWidgetWin::GetWindowMask(const gfx::Size& size, gfx::Path* path) {
   if (GetWidget()->non_client_view())
     GetWidget()->non_client_view()->GetWindowMask(size, path);
 }
 
 bool NativeWidgetWin::GetClientAreaInsets(gfx::Insets* insets) const {
   return false;
 }
 
 void NativeWidgetWin::GetMinMaxSize(gfx::Size* min_size,
                                     gfx::Size* max_size) const {
-  *min_size = delegate_->GetMinimumSize();
-  *max_size = delegate_->GetMaximumSize();
+  *min_size = ui::win::ScreenToDIPSize(delegate_->GetMinimumSize());
+  *max_size = ui::win::ScreenToDIPSize(delegate_->GetMaximumSize());
 }
 
 gfx::Size NativeWidgetWin::GetRootViewSize() const {
-  return GetWidget()->GetRootView()->size();
+  gfx::Size pixel_size = GetWidget()->GetRootView()->size();
+  return ui::win::ScreenToDIPSize(pixel_size);
 }
 
 void NativeWidgetWin::ResetWindowControls() {
   GetWidget()->non_client_view()->ResetWindowControls();
 }
 
 void NativeWidgetWin::PaintLayeredWindow(gfx::Canvas* canvas) {
   GetWidget()->GetRootView()->Paint(canvas);
 }
 
@@ skipping 114 matching lines @@
 
 void NativeWidgetWin::HandleWorkAreaChanged() {
   GetWidget()->widget_delegate()->OnWorkAreaChanged();
 }
 
 void NativeWidgetWin::HandleVisibilityChanged(bool visible) {
   delegate_->OnNativeWidgetVisibilityChanged(visible);
 }
 
 void NativeWidgetWin::HandleClientSizeChanged(const gfx::Size& new_size) {
-  delegate_->OnNativeWidgetSizeChanged(new_size);
+  gfx::Size size_in_dip = ui::win::ScreenToDIPSize(new_size);
+  delegate_->OnNativeWidgetSizeChanged(size_in_dip);
 }
 
 void NativeWidgetWin::HandleFrameChanged() {
   // Replace the frame and layout the contents.
   GetWidget()->non_client_view()->UpdateFrame(true);
 }
 
 void NativeWidgetWin::HandleNativeFocus(HWND last_focused_window) {
   delegate_->OnNativeFocus(last_focused_window);
   InputMethod* input_method = GetInputMethod();
   if (input_method)
     input_method->OnFocus();
 }
 
 void NativeWidgetWin::HandleNativeBlur(HWND focused_window) {
   delegate_->OnNativeBlur(focused_window);
   InputMethod* input_method = GetInputMethod();
   if (input_method)
     input_method->OnBlur();
 }
 
 bool NativeWidgetWin::HandleMouseEvent(const ui::MouseEvent& event) {
-  delegate_->OnMouseEvent(const_cast<ui::MouseEvent*>(&event));
-  return event.handled();
+  ui::MouseEvent dpi_event(event);
+  dpi_event.set_location(ui::win::ScreenToDIPPoint(event.location()));
+  dpi_event.set_root_location(ui::win::ScreenToDIPPoint(event.location()));
+  delegate_->OnMouseEvent(&dpi_event);
+  return dpi_event.handled();
 }
 
 bool NativeWidgetWin::HandleKeyEvent(const ui::KeyEvent& event) {
   delegate_->OnKeyEvent(const_cast<ui::KeyEvent*>(&event));
   return event.handled();
 }
 
 bool NativeWidgetWin::HandleUntranslatedKeyEvent(const ui::KeyEvent& event) {
   InputMethod* input_method = GetInputMethod();
   if (input_method)
@@ skipping 25 matching lines @@
 void NativeWidgetWin::HandleInputLanguageChange(DWORD character_set,
                                                 HKL input_language_id) {
   InputMethod* input_method = GetInputMethod();
   if (input_method && !input_method->IsMock()) {
     static_cast<InputMethodWin*>(input_method)->OnInputLangChange(
         character_set, input_language_id);
   }
 }
 
 bool NativeWidgetWin::HandlePaintAccelerated(const gfx::Rect& invalid_rect) {
-  return delegate_->OnNativeWidgetPaintAccelerated(gfx::Rect(invalid_rect));
+  gfx::Rect dpi_rect = ui::win::ScreenToDIPRect(invalid_rect);
+  return delegate_->OnNativeWidgetPaintAccelerated(dpi_rect);
 }
 
 void NativeWidgetWin::HandlePaint(gfx::Canvas* canvas) {
   delegate_->OnNativeWidgetPaint(canvas);
 }
 
 bool NativeWidgetWin::HandleTooltipNotify(int w_param,
                                           NMHDR* l_param,
                                           LRESULT* l_result) {
   // We can be sent this message before the tooltip manager is created, if a
@@ skipping 68 matching lines @@
                          gfx::Rect* rect) {
   DCHECK(source);
   DCHECK(target);
   DCHECK(rect);
 
   HWND source_hwnd = source->GetNativeView();
   HWND target_hwnd = target->GetNativeView();
   if (source_hwnd == target_hwnd)
     return true;
 
-  RECT win_rect = rect->ToRECT();
+  RECT win_rect = ui::win::DIPToScreenRect(*rect).ToRECT();
   if (::MapWindowPoints(source_hwnd, target_hwnd,
                         reinterpret_cast<LPPOINT>(&win_rect),
                         sizeof(RECT)/sizeof(POINT))) {
-    *rect = gfx::Rect(win_rect);
+    *rect = ui::win::ScreenToDIPRect(gfx::Rect(win_rect));
     return true;
   }
   return false;
 }
 
 namespace internal {
 
 ////////////////////////////////////////////////////////////////////////////////
 // internal::NativeWidgetPrivate, public:
 
@@ skipping 111 matching lines @@
 // static
 bool NativeWidgetPrivate::IsTouchDown() {
   // This currently isn't necessary because we're not generating touch events on
   // windows.  When we do, this will need to be updated.
   return false;
 }
 
 }  // namespace internal
 
 }  // namespace views