components/native_viewport/platform_viewport_win.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/native_viewport/platform_viewport.h"
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "mojo/converters/geometry/geometry_type_converters.h"
   9 #include "mojo/converters/input_events/input_events_type_converters.h"
  10 #include "ui/events/event.h"
  11 #include "ui/gfx/geometry/rect.h"
  12 #include "ui/platform_window/platform_window_delegate.h"
  13 #include "ui/platform_window/win/win_window.h"
  14
  15 namespace native_viewport {
  16 namespace {
  17 float ConvertUIWheelValueToMojoValue(int offset) {
  18   // Mojo's event type takes a value between -1 and 1. Normalize by allowing
  19   // up to 20 of ui's offset. This is a bit arbitrary.
  20   return std::max(
  21       -1.0f, std::min(1.0f, static_cast<float>(offset) /
  22                                 (20 * static_cast<float>(
  23                                           ui::MouseWheelEvent::kWheelDelta))));
  24 }
  25 }  // namespace
  26
  27 class PlatformViewportWin : public PlatformViewport,
  28                             public ui::PlatformWindowDelegate {
  29  public:
  30   explicit PlatformViewportWin(Delegate* delegate)
  31       : delegate_(delegate) {
  32   }
  33
  34   ~PlatformViewportWin() {
  35     // Destroy the platform-window while |this| is still alive.
  36     platform_window_.reset();
  37   }
  38
  39  private:
  40   // Overridden from PlatformViewport:
  41   void Init(const gfx::Rect& bounds) override {
  42     metrics_ = mojo::ViewportMetrics::New();
  43     // TODO(sky): make density real.
  44     metrics_->device_pixel_ratio = 1.f;
  45     metrics_->size = mojo::Size::From(bounds.size());
  46     platform_window_.reset(new ui::WinWindow(this, bounds));
  47   }
  48
  49   void Show() override {
  50     platform_window_->Show();
  51   }
  52
  53   void Hide() override {
  54     platform_window_->Hide();
  55   }
  56
  57   void Close() override {
  58     platform_window_->Close();
  59   }
  60
  61   gfx::Size GetSize() override { return metrics_->size.To<gfx::Size>(); }
  62
  63   void SetBounds(const gfx::Rect& bounds) override {
  64     platform_window_->SetBounds(bounds);
  65   }
  66
  67   // ui::PlatformWindowDelegate:
  68   void OnBoundsChanged(const gfx::Rect& new_bounds) override {
  69     metrics_->size = mojo::Size::From(new_bounds.size());
  70     delegate_->OnMetricsChanged(metrics_.Clone());
  71   }
  72
  73   void OnDamageRect(const gfx::Rect& damaged_region) override {
  74   }
  75
  76   void DispatchEvent(ui::Event* event) override {
  77     // TODO(jam): this code is copied from the X11 version.
  78     mojo::EventPtr mojo_event(mojo::Event::From(*event));
  79     if (event->IsMouseWheelEvent()) {
  80       // Mojo's event type has a different meaning for wheel events. Convert
  81       // between the two.
  82       ui::MouseWheelEvent* wheel_event =
  83           static_cast<ui::MouseWheelEvent*>(event);
  84       DCHECK(mojo_event->pointer_data);
  85       mojo_event->pointer_data->horizontal_wheel =
  86           ConvertUIWheelValueToMojoValue(wheel_event->x_offset());
  87       mojo_event->pointer_data->horizontal_wheel =
  88           ConvertUIWheelValueToMojoValue(wheel_event->y_offset());
  89     }
  90     delegate_->OnEvent(mojo_event.Pass());
  91
  92     switch (event->type()) {
  93       case ui::ET_MOUSE_PRESSED:
  94       case ui::ET_TOUCH_PRESSED:
  95         platform_window_->SetCapture();
  96         break;
  97       case ui::ET_MOUSE_RELEASED:
  98       case ui::ET_TOUCH_RELEASED:
  99         platform_window_->ReleaseCapture();
 100         break;
 101       default:
 102         break;
 103     }
 104   }
 105
 106   void OnCloseRequest() override {
 107     platform_window_->Close();
 108   }
 109
 110   void OnClosed() override {
 111     delegate_->OnDestroyed();
 112   }
 113
 114   void OnWindowStateChanged(ui::PlatformWindowState state) override {
 115   }
 116
 117   void OnLostCapture() override {
 118   }
 119
 120   void OnAcceleratedWidgetAvailable(
 121       gfx::AcceleratedWidget widget) override {
 122     delegate_->OnAcceleratedWidgetAvailable(widget,
 123                                             metrics_->device_pixel_ratio);
 124   }
 125
 126   void OnActivationChanged(bool active) override {}
 127
 128   scoped_ptr<ui::PlatformWindow> platform_window_;
 129   Delegate* delegate_;
 130   mojo::ViewportMetricsPtr metrics_;
 131
 132   DISALLOW_COPY_AND_ASSIGN(PlatformViewportWin);
 133 };
 134
 135 // static
 136 scoped_ptr<PlatformViewport> PlatformViewport::Create(Delegate* delegate) {
 137   return scoped_ptr<PlatformViewport>(new PlatformViewportWin(delegate)).Pass();
 138 }
 139
 140 }  // namespace native_viewport