chrome/browser/ui/autofill/popup_controller_common.cc

   1 // Copyright 2014 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 "chrome/browser/ui/autofill/popup_controller_common.h"
   6
   7 #include <algorithm>
   8 #include <utility>
   9
  10 #include "content/public/browser/render_view_host.h"
  11 #include "content/public/browser/web_contents.h"
  12 #include "ui/gfx/display.h"
  13 #include "ui/gfx/rect_conversions.h"
  14 #include "ui/gfx/screen.h"
  15 #include "ui/gfx/vector2d.h"
  16
  17 namespace autofill {
  18
  19 PopupControllerCommon::PopupControllerCommon(
  20     const gfx::RectF& element_bounds,
  21     const gfx::NativeView container_view,
  22     content::WebContents* web_contents)
  23     : element_bounds_(element_bounds),
  24       container_view_(container_view),
  25       web_contents_(web_contents),
  26       key_press_event_target_(NULL) {}
  27 PopupControllerCommon::~PopupControllerCommon() {}
  28
  29 void PopupControllerCommon::SetKeyPressCallback(
  30     content::RenderWidgetHost::KeyPressEventCallback callback) {
  31   DCHECK(key_press_event_callback_.is_null());
  32   key_press_event_callback_ = callback;
  33 }
  34
  35 void PopupControllerCommon::RegisterKeyPressCallback() {
  36   if (web_contents_ && !key_press_event_target_) {
  37     key_press_event_target_ = web_contents_->GetRenderViewHost();
  38     key_press_event_target_->AddKeyPressEventCallback(
  39         key_press_event_callback_);
  40   }
  41 }
  42
  43 void PopupControllerCommon::RemoveKeyPressCallback() {
  44   if (web_contents_ && (!web_contents_->IsBeingDestroyed()) &&
  45       key_press_event_target_ == web_contents_->GetRenderViewHost()) {
  46     web_contents_->GetRenderViewHost()->RemoveKeyPressEventCallback(
  47         key_press_event_callback_);
  48   }
  49   key_press_event_target_ = NULL;
  50 }
  51
  52 gfx::Display PopupControllerCommon::GetDisplayNearestPoint(
  53     const gfx::Point& point) const {
  54   return gfx::Screen::GetScreenFor(container_view_)->GetDisplayNearestPoint(
  55       point);
  56 }
  57
  58 const gfx::Rect PopupControllerCommon::RoundedElementBounds() const {
  59   return gfx::ToEnclosingRect(element_bounds_);
  60 }
  61
  62 std::pair<int, int> PopupControllerCommon::CalculatePopupXAndWidth(
  63     const gfx::Display& left_display,
  64     const gfx::Display& right_display,
  65     int popup_required_width) const {
  66   int leftmost_display_x = left_display.bounds().x();
  67   int rightmost_display_x =
  68       right_display.GetSizeInPixel().width() + right_display.bounds().x();
  69
  70   // Calculate the start coordinates for the popup if it is growing right or
  71   // the end position if it is growing to the left, capped to screen space.
  72   int right_growth_start = std::max(leftmost_display_x,
  73                                     std::min(rightmost_display_x,
  74                                              RoundedElementBounds().x()));
  75   int left_growth_end = std::max(leftmost_display_x,
  76                                  std::min(rightmost_display_x,
  77                                           RoundedElementBounds().right()));
  78
  79   int right_available = rightmost_display_x - right_growth_start;
  80   int left_available = left_growth_end - leftmost_display_x;
  81
  82   int popup_width = std::min(popup_required_width,
  83                              std::max(right_available, left_available));
  84
  85   // If there is enough space for the popup on the right, show it there,
  86   // otherwise choose the larger size.
  87   if (right_available >= popup_width || right_available >= left_available)
  88     return std::make_pair(right_growth_start, popup_width);
  89   else
  90     return std::make_pair(left_growth_end - popup_width, popup_width);
  91 }
  92
  93 std::pair<int,int> PopupControllerCommon::CalculatePopupYAndHeight(
  94     const gfx::Display& top_display,
  95     const gfx::Display& bottom_display,
  96     int popup_required_height) const {
  97   int topmost_display_y = top_display.bounds().y();
  98   int bottommost_display_y =
  99       bottom_display.GetSizeInPixel().height() + bottom_display.bounds().y();
 100
 101   // Calculate the start coordinates for the popup if it is growing down or
 102   // the end position if it is growing up, capped to screen space.
 103   int top_growth_end = std::max(topmost_display_y,
 104                                 std::min(bottommost_display_y,
 105                                          RoundedElementBounds().y()));
 106   int bottom_growth_start = std::max(topmost_display_y,
 107                                      std::min(bottommost_display_y,
 108                                               RoundedElementBounds().bottom()));
 109
 110   int top_available = bottom_growth_start - topmost_display_y;
 111   int bottom_available = bottommost_display_y - top_growth_end;
 112
 113   // TODO(csharp): Restrict the popup height to what is available.
 114   if (bottom_available >= popup_required_height ||
 115       bottom_available >= top_available) {
 116     // The popup can appear below the field.
 117     return std::make_pair(bottom_growth_start, popup_required_height);
 118   } else {
 119     // The popup must appear above the field.
 120     return std::make_pair(top_growth_end - popup_required_height,
 121                           popup_required_height);
 122   }
 123 }
 124
 125 gfx::Rect PopupControllerCommon::GetPopupBounds(int desired_width,
 126                                                 int desired_height) const {
 127   // This is the top left point of the popup if the popup is above the element
 128   // and grows to the left (since that is the highest and furthest left the
 129   // popup go could).
 130   gfx::Point top_left_corner_of_popup = RoundedElementBounds().origin() +
 131       gfx::Vector2d(RoundedElementBounds().width() - desired_width,
 132                     -desired_height);
 133
 134   // This is the bottom right point of the popup if the popup is below the
 135   // element and grows to the right (since the is the lowest and furthest right
 136   // the popup could go).
 137   gfx::Point bottom_right_corner_of_popup = RoundedElementBounds().origin() +
 138       gfx::Vector2d(desired_width,
 139                     RoundedElementBounds().height() + desired_height);
 140
 141   gfx::Display top_left_display = GetDisplayNearestPoint(
 142       top_left_corner_of_popup);
 143   gfx::Display bottom_right_display = GetDisplayNearestPoint(
 144       bottom_right_corner_of_popup);
 145
 146   std::pair<int, int> popup_x_and_width =
 147       CalculatePopupXAndWidth(top_left_display,
 148                               bottom_right_display,
 149                               desired_width);
 150   std::pair<int, int> popup_y_and_height =
 151       CalculatePopupYAndHeight(top_left_display,
 152                                bottom_right_display,
 153                                desired_height);
 154
 155   return gfx::Rect(popup_x_and_width.first,
 156                    popup_y_and_height.first,
 157                    popup_x_and_width.second,
 158                    popup_y_and_height.second);
 159 }
 160
 161 }  // namespace autofill