1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
  100
  101
  102
  103
  104
  105
  106
  107
  108
  109
  110
  111
  112
  113
  114
  115
  116
  117


ash / keyboard / ui / container_floating_behavior.h [blame]

// Copyright 2017 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef ASH_KEYBOARD_UI_CONTAINER_FLOATING_BEHAVIOR_H_
#define ASH_KEYBOARD_UI_CONTAINER_FLOATING_BEHAVIOR_H_

#include <memory>
#include <optional>

#include "ash/keyboard/ui/container_behavior.h"
#include "ash/keyboard/ui/drag_descriptor.h"
#include "ash/keyboard/ui/keyboard_export.h"
#include "ui/gfx/geometry/point.h"
#include "ui/gfx/geometry/rect.h"

namespace keyboard {

// Margins from the bottom right corner of the screen for the default location
// of the keyboard.
constexpr int kDefaultDistanceFromScreenBottom = 20;
constexpr int kDefaultDistanceFromScreenRight = 20;

class KEYBOARD_EXPORT ContainerFloatingBehavior : public ContainerBehavior {
 public:
  explicit ContainerFloatingBehavior(Delegate* delegate);
  ~ContainerFloatingBehavior() override;

  // ContainerBehavior overrides
  void DoHidingAnimation(
      aura::Window* container,
      ::wm::ScopedHidingAnimationSettings* animation_settings) override;
  void DoShowingAnimation(
      aura::Window* container,
      ui::ScopedLayerAnimationSettings* animation_settings) override;
  void InitializeShowAnimationStartingState(aura::Window* container) override;
  gfx::Rect AdjustSetBoundsRequest(
      const gfx::Rect& display_bounds,
      const gfx::Rect& requested_bounds_in_screen_coords) override;
  bool IsOverscrollAllowed() const override;
  void SavePosition(const gfx::Rect& keyboard_bounds_in_screen,
                    const gfx::Size& screen_size) override;
  bool HandlePointerEvent(const ui::LocatedEvent& event,
                          const display::Display& current_display) override;
  bool HandleGestureEvent(const ui::GestureEvent& event,
                          const gfx::Rect& bounds_in_screen) override;

  void SetCanonicalBounds(aura::Window* container,
                          const gfx::Rect& display_bounds) override;
  ContainerType GetType() const override;
  bool TextBlurHidesKeyboard() const override;
  gfx::Rect GetOccludedBounds(
      const gfx::Rect& visual_bounds_in_screen) const override;
  bool OccludedBoundsAffectWorkspaceLayout() const override;
  void SetDraggableArea(const gfx::Rect& rect) override;
  void SetAreaToRemainOnScreen(const gfx::Rect& bounds) override;

  // Calculate the position of the keyboard for when it is being shown.
  gfx::Point GetPositionForShowingKeyboard(
      const gfx::Size& keyboard_size,
      const gfx::Rect& display_bounds) const;

 private:
  struct KeyboardPosition {
    double left_padding_allotment_ratio;
    double top_padding_allotment_ratio;
  };

  // This returns a new bounds that is guaranteed to be contained within the
  // bounds of the user's display. If the given bounds is contained within
  // the display's bounds then they remain unchanged. If the given bounds are
  // overlapping an edge of the display, or are completely off the display,
  // then the closest valid bounds within the display will be returned.
  gfx::Rect GetBoundsWithinDisplay(const gfx::Rect& bounds,
                                   const gfx::Rect& display_bounds) const;

  // Convert bounds that are relative to the origin of the keyboard window, to
  // bounds that are relative to the origin of the display.
  gfx::Rect ConvertAreaInKeyboardToScreenBounds(
      const gfx::Rect& area_in_keyboard_window,
      const gfx::Rect& keyboard_window_bounds_in_display) const;

  // This returns a new bounds for the keyboard window that is guaranteed to
  // keep the keyboard window on the display. The area of the keyboard window
  // that is guaranteed to remain on the display is either;
  //
  //  1) the area defined by area_in_window_to_remain_on_screen_, or
  //  2) the entire keyboard window bounds.
  //
  // If area_in_window_to_remain_on_screen_ is not defined, then the entire
  // keyboard window bounds are kept on the display. Otherwise the area
  // defined by area_in_window_to_remain_on_screen_ is kept on the display.
  gfx::Rect ContainKeyboardToDisplayBounds(
      const gfx::Rect& keyboard_window_bounds_in_screen,
      const gfx::Rect& display_bounds) const;

  // Saves the current keyboard location for use the next time it is displayed.
  void UpdateLastPoint(const gfx::Point& position);

  // TODO(blakeo): cache the default_position_ on a per-display basis.
  std::unique_ptr<KeyboardPosition> default_position_in_screen_;

  // Current state of a cursor drag to move the keyboard, if one exists.
  // Otherwise nullptr.
  std::unique_ptr<const DragDescriptor> drag_descriptor_;

  gfx::Rect draggable_area_ = gfx::Rect();

  // The area within the keyboard window that must remain on screen during a
  // drag operation. Note that this is relative to the current keyboard window
  // not the screen.
  std::optional<gfx::Rect> area_in_window_to_remain_on_screen_;
};

}  // namespace keyboard

#endif  // ASH_KEYBOARD_UI_CONTAINER_FLOATING_BEHAVIOR_H_