chromecast/graphics/accessibility/fullscreen_magnification_controller.h

// Copyright (c) 2018 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.

#ifndef CHROMECAST_GRAPHICS_ACCESSIBILITY_FULLSCREEN_MAGNIFICATION_CONTROLLER_H_
#define CHROMECAST_GRAPHICS_ACCESSIBILITY_FULLSCREEN_MAGNIFICATION_CONTROLLER_H_

#include "chromecast/graphics/accessibility/magnification_controller.h"
#include "ui/compositor/layer_delegate.h"
#include "ui/events/event_handler.h"
#include "ui/events/event_rewriter.h"
#include "ui/events/gestures/gesture_provider_aura.h"
#include "ui/events/gestures/gesture_types.h"
#include "ui/gfx/geometry/point.h"
#include "ui/gfx/transform.h"

namespace aura {
class Window;
}  // namespace aura

namespace ui {
class GestureProviderAura;
class Layer;
}  // namespace ui

namespace chromecast {

class CastGestureHandler;

class FullscreenMagnificationController : public MagnificationController,
                                          public ui::EventRewriter,
                                          public ui::GestureConsumer,
                                          public ui::LayerDelegate {
 public:
  explicit FullscreenMagnificationController(
      aura::Window* root_window,
      CastGestureHandler* cast_gesture_handler);
  ~FullscreenMagnificationController() override;

  void SetEnabled(bool enabled) override;
  bool IsEnabled() const override;
  void SetMagnificationScale(float magnification_scale) override;

 private:
  class GestureProviderClient;
  enum LockedGestureType { NO_GESTURE, ZOOM, SCROLL };

  // The current transform to apply to the root window to perform magnification.
  gfx::Transform GetMagnifierTransform() const;

  // Process pending gestures in |gesture_provider_|. This method returns true
  // if the controller needs to cancel existing touches.
  bool ProcessGestures();

  // Redraws the magnification window with the given origin position in dip and
  // the given scale. Returns true if the window is changed; otherwise, false.
  bool RedrawDIP(const gfx::PointF& position_in_dip, float scale);

  // Overridden from ui::EventRewriter
  ui::EventRewriteStatus RewriteEvent(
      const ui::Event& event,
      std::unique_ptr<ui::Event>* rewritten_event) override;
  ui::EventRewriteStatus NextDispatchEvent(
      const ui::Event& last_event,
      std::unique_ptr<ui::Event>* new_event) override;

  // Adds the layer for the highlight-ring which provides a visual indicator
  // that magnification is enabled.
  void UpdateHighlightLayerTransform(const gfx::Transform& magnifier_transform);
  void AddHighlightLayer();

  // ui::LayerDelegate overrides:
  void OnPaintLayer(const ui::PaintContext& context) override;
  void OnDeviceScaleFactorChanged(float old_device_scale_factor,
                                  float new_device_scale_factor) override;

  aura::Window* root_window_;

  bool is_enabled_ = false;
  gfx::Transform original_transform_;

  // Stores the last touched location. This value is used on zooming to keep
  // this location visible.
  gfx::Point point_of_interest_in_root_;

  // Current scale, origin (left-top) position of the magnification window.
  float magnification_scale_;
  gfx::PointF magnification_origin_;

  float original_magnification_scale_;
  gfx::PointF original_magnification_origin_;

  // We own our own GestureProvider to detect gestures with screen coordinates
  // of touch events. As MagnificationController changes zoom level and moves
  // viewport, logical coordinates of touches cannot be used for gesture
  // detection as they are changed if the controller reacts to gestures.
  std::unique_ptr<ui::GestureProviderAura> gesture_provider_;
  std::unique_ptr<GestureProviderClient> gesture_provider_client_;

  // We lock the gesture once user performs either scroll or pinch gesture above
  // those thresholds.
  LockedGestureType locked_gesture_ = NO_GESTURE;

  // If true, consumes all touch events.
  bool consume_touch_event_ = false;

  // Number of touch points on the screen.
  int32_t touch_points_ = 0;

  // Map for holding ET_TOUCH_PRESS events. Those events are used to dispatch
  // ET_TOUCH_CANCELLED events. Events will be removed from this map when press
  // events are cancelled, i.e. size of this map can be different from number of
  // touches on the screen. Key is pointer id.
  std::map<int32_t, std::unique_ptr<ui::TouchEvent>> press_event_map_;

  CastGestureHandler* cast_gesture_handler_;

  std::unique_ptr<ui::Layer> highlight_ring_layer_;
};

}  // namespace chromecast

#endif  // CHROMECAST_GRAPHICS_ACCESSIBILITY_FULLSCREEN_MAGNIFICATION_CONTROLLER_H_