Adds arrow icon and updates exit label color for touch calibration

chrome/browser/chromeos/display/touch_calibrator/touch_calibrator_view.cc

 // Copyright 2016 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 "chrome/browser/chromeos/display/touch_calibrator/touch_calibrator_view.h"
 
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/resources/vector_icons/vector_icons.h"
 #include "ash/shell.h"
 #include "ui/aura/window.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/animation/linear_animation.h"
 #include "ui/gfx/animation/throb_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/paint_vector_icon.h"
 #include "ui/strings/grit/ui_strings.h"
 #include "ui/views/background.h"
+#include "ui/views/bubble/bubble_border.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/widget/widget.h"
 
 namespace chromeos {
 
 namespace {
 
 constexpr char kWidgetName[] = "TouchCalibratorOverlay";
 
 constexpr int kAnimationFrameRate = 100;
 constexpr int kFadeDurationInMs = 150;
 constexpr int kPointMoveDurationInMs = 400;
 constexpr int kPointMoveDurationLongInMs = 500;
 
-const SkColor kExitLabelColor = SkColorSetARGBInline(255, 96, 96, 96);
+const SkColor kExitLabelColor = SkColorSetARGBInline(255, 138, 138, 138);
 constexpr int kExitLabelWidth = 300;
 constexpr int kExitLabelHeight = 20;
 
 const SkColor kTapHereLabelColor = SK_ColorWHITE;
 
 constexpr int kHintBoxWidth = 298;
 constexpr int kHintBoxHeight = 180;
 constexpr int kHintBoxLabelTextSize = 5;
 constexpr int kHintBoxSublabelTextSize = 3;
 
@@ skipping 18 matching lines @@
 
 constexpr int kCircleAnimationDurationMs = 900;
 
 constexpr int kHintRectBorderRadius = 4;
 
 constexpr float kBackgroundFinalOpacity = 0.75f;
 
 constexpr int kTouchTargetWidth = 64;
 constexpr int kTouchTargetHeight = kTouchTargetWidth + kTouchTargetWidth / 2;
 
-constexpr float kTouchTargetVerticalOffsetFactor = 5.f / 12.f;
+constexpr float kTouchTargetVerticalOffsetFactor = 11.f / 24.f;
 
 const SkColor kTouchTargetInnerCircleColor =
     SkColorSetARGBInline(255, 66, 133, 244);
 const SkColor kTouchTargetOuterCircleColor =
     SkColorSetA(kTouchTargetInnerCircleColor, 255 * 0.2);
 const SkColor kHandIconColor = SkColorSetARGBInline(255, 201, 201, 201);
 constexpr float kHandIconHorizontalOffsetFactor = 7.f / 32.f;
 
 // Returns the initialization params for the widget that contains the touch
 // calibrator view.
@@ skipping 187 matching lines @@
   HintBox(const gfx::Rect& bounds, int border_radius);
   ~HintBox() override;
 
   // views::View overrides:
   void OnPaint(gfx::Canvas* canvas) override;
 
   void SetLabel(const base::string16& text, const SkColor& color);
   void SetSubLabel(const base::string16& text, const SkColor& color);
 
  private:
+  void UpdateWidth(int updated_width);
+
   base::string16 label_text_;
   base::string16 sublabel_text_;
 
   SkColor label_color_;
   SkColor sublabel_color_;
 
   const int border_radius_;
 
+  int base_border_;
+
+  int arrow_width_;
+
   int horizontal_offset_;
 
+  gfx::Rect rounded_rect_bounds_;
+
   gfx::FontList label_font_list_;
   gfx::FontList sublabel_font_list_;
 
   gfx::Rect label_text_bounds_;
   gfx::Rect sublabel_text_bounds_;
 
   SkPaint paint_;
 
   DISALLOW_COPY_AND_ASSIGN(HintBox);
 };
 
 HintBox::HintBox(const gfx::Rect& bounds, int border_radius)
     : border_radius_(border_radius) {
-  SetBoundsRect(bounds);
+  SetBorder(base::MakeUnique<views::BubbleBorder>(
+      base::i18n::IsRTL() ? views::BubbleBorder::RIGHT_CENTER
+                          : views::BubbleBorder::LEFT_CENTER,
+      views::BubbleBorder::NO_SHADOW_OPAQUE_BORDER, SK_ColorWHITE));
+
+  arrow_width_ = (GetInsets().right() - GetInsets().left()) *
+                 (base::i18n::IsRTL() ? 1 : -1);
+
+  // Border on all sides are the same except on the side of the arrow, in which
+  // case the width of the arrow is additional.
+  base_border_ = base::i18n::IsRTL() ? GetInsets().left() : GetInsets().right();
+
+  SetBounds(bounds.x(), bounds.y() - base_border_,
+            bounds.width() + 2 * base_border_ + arrow_width_,
+            bounds.height() + 2 * base_border_);
+
+  rounded_rect_bounds_ = GetLocalBounds();
+  rounded_rect_bounds_.Inset(GetInsets());
 
   paint_.setColor(SK_ColorWHITE);
   paint_.setStyle(SkPaint::kFill_Style);
   paint_.setFlags(SkPaint::kAntiAlias_Flag);
 
-  horizontal_offset_ = width() * 0.08f;
+  horizontal_offset_ =
+      arrow_width_ + base_border_ + rounded_rect_bounds_.width() * 0.08f;
   int top_offset = horizontal_offset_;
-  int line_gap = height() * 0.018f;
-  int label_height = height() * 0.11f;
+  int line_gap = rounded_rect_bounds_.height() * 0.018f;
+  int label_height = rounded_rect_bounds_.height() * 0.11f;
 
   label_text_bounds_.SetRect(horizontal_offset_, top_offset, 0, label_height);
 
   top_offset += label_text_bounds_.height() + line_gap;
 
   sublabel_text_bounds_.SetRect(horizontal_offset_, top_offset, 0,
                                 label_height);
 }
 
 HintBox::~HintBox() {}
 
+void HintBox::UpdateWidth(int updated_width) {
+  SetSize(gfx::Size(updated_width + 2 * base_border_ + arrow_width_, height()));
+  rounded_rect_bounds_ = GetLocalBounds();
+  rounded_rect_bounds_.Inset(GetInsets());
+}
+
 void HintBox::SetLabel(const base::string16& text, const SkColor& color) {
   label_text_ = text;
   label_color_ = color;
 
   label_font_list_ =
       ui::ResourceBundle::GetSharedInstance().GetFontListWithDelta(
           kHintBoxLabelTextSize, gfx::Font::FontStyle::NORMAL,
           gfx::Font::Weight::NORMAL);
 
   // Adjust size of label bounds based on text and font.
   gfx::Size size = GetSizeForString(label_text_, label_font_list_);
   label_text_bounds_.set_size(
       gfx::Size(size.width(), label_text_bounds_.height()));
 
   // Check if the width of hint box needs to be updated.
-  int minimum_expected_width = size.width() + 2 * horizontal_offset_;
-  if (minimum_expected_width > width())
-    SetSize(gfx::Size(minimum_expected_width, height()));
+  int minimum_expected_width =
+      size.width() + 2 * horizontal_offset_ - arrow_width_;
+  if (minimum_expected_width > rounded_rect_bounds_.width())
+    UpdateWidth(minimum_expected_width);
 }
 
 void HintBox::SetSubLabel(const base::string16& text, const SkColor& color) {
   sublabel_text_ = text;
   sublabel_color_ = color;
 
   sublabel_font_list_ =
       ui::ResourceBundle::GetSharedInstance().GetFontListWithDelta(
           kHintBoxSublabelTextSize, gfx::Font::FontStyle::NORMAL,
           gfx::Font::Weight::NORMAL);
 
   // Adjust size of sublabel label bounds based on text and font.
   gfx::Size size = GetSizeForString(sublabel_text_, sublabel_font_list_);
   sublabel_text_bounds_.set_size(
       gfx::Size(size.width(), sublabel_text_bounds_.height()));
 
   // Check if the width of hint box needs to be updated.
-  int minimum_expected_width = size.width() + 2 * horizontal_offset_;
-  if (minimum_expected_width > width())
-    SetSize(gfx::Size(minimum_expected_width, height()));
+  int minimum_expected_width =
+      size.width() + 2 * horizontal_offset_ - arrow_width_;
+  if (minimum_expected_width > rounded_rect_bounds_.width())
+    UpdateWidth(minimum_expected_width);
 }
 
 void HintBox::OnPaint(gfx::Canvas* canvas) {
-  canvas->DrawRoundRect(GetLocalBounds(), border_radius_, paint_);
+  views::View::OnPaint(canvas);
+  canvas->DrawRoundRect(rounded_rect_bounds_, border_radius_, paint_);
   canvas->DrawStringRectWithFlags(label_text_, label_font_list_, label_color_,
                                   label_text_bounds_, gfx::Canvas::NO_ELLIPSIS);
   canvas->DrawStringRectWithFlags(sublabel_text_, sublabel_font_list_,
                                   sublabel_color_, sublabel_text_bounds_,
                                   gfx::Canvas::NO_ELLIPSIS);
 }
 
 class CompletionMessageView : public views::View {
  public:
   CompletionMessageView(const gfx::Rect& bounds, const base::string16& message);
@@ skipping 152 matching lines @@
   // Initialize the Hint Box view.
   base::string16 hint_label_text =
       rb.GetLocalizedString(IDS_DISPLAY_TOUCH_CALIBRATION_HINT_LABEL_TEXT);
   base::string16 hint_sublabel_text =
       rb.GetLocalizedString(IDS_DISPLAY_TOUCH_CALIBRATION_HINT_SUBLABEL_TEXT);
 
   int tpv_width = touch_point_view_->width();
 
   gfx::Size size(kHintBoxWidth, kHintBoxHeight);
 
-  gfx::Point position(
-      touch_point_view_->x() + tpv_width * 1.2f,
-      touch_point_view_->y() + (tpv_width / 2.f) - (size.height() / 2.f));
+  gfx::Point position(touch_point_view_->x() + tpv_width * 1.2f,
+                      touch_point_view_->y() +
+                          (kThrobberCircleViewWidth / 2.f) -
+                          (size.height() / 2.f));
 
   HintBox* hint_box =
       new HintBox(gfx::Rect(position, size), kHintRectBorderRadius);
   hint_box->SetVisible(false);
   hint_box->SetLabel(hint_label_text, kHintLabelTextColor);
   hint_box->SetSubLabel(hint_sublabel_text, kHintSublabelTextColor);
   hint_box_view_ = hint_box;
 
   AddChildView(hint_box_view_);
 
   // Initialize the animated hint box throbber view.
   TouchTargetThrobberView* target_view = new TouchTargetThrobberView(
-      gfx::Rect((size.width() - kTouchTargetWidth) / 2,
-                size.height() * kTouchTargetVerticalOffsetFactor,
+      gfx::Rect((hint_box->width() - kTouchTargetWidth) / 2,
+                hint_box->height() * kTouchTargetVerticalOffsetFactor,
                 kTouchTargetWidth, kTouchTargetHeight),
       kTouchTargetInnerCircleColor, kTouchTargetOuterCircleColor,
       kHandIconColor, kCircleAnimationDurationMs);
   target_view->SetVisible(true);
 
   hint_box_view_->AddChildView(target_view);
 
   // Initialize the view that contains the calibration complete message which
   // will be displayed at the end.
   base::string16 finish_msg_text =
@@ skipping 221 matching lines @@
 void TouchCalibratorView::SkipCurrentAnimation() {
   if (animator_->is_animating())
     animator_->End();
   if (touch_point_view_ &&
       touch_point_view_->layer()->GetAnimator()->is_animating()) {
     touch_point_view_->layer()->GetAnimator()->StopAnimating();
   }
 }
 
 }  // namespace chromeos