Views: Draw Textfield selected text in gray when top-level Widget loses focus.

ui/views/controls/textfield/textfield.cc

 // Copyright (c) 2012 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 "ui/views/controls/textfield/textfield.h"
 
 #include <string>
 #include <utility>
 
 #include "base/trace_event/trace_event.h"
@@ skipping 233 matching lines @@
       read_only_(false),
       default_width_in_chars_(0),
       use_default_text_color_(true),
       use_default_background_color_(true),
       use_default_selection_text_color_(true),
       use_default_selection_background_color_(true),
       text_color_(SK_ColorBLACK),
       background_color_(SK_ColorWHITE),
       selection_text_color_(SK_ColorWHITE),
       selection_background_color_(SK_ColorBLUE),
+      change_selection_background_color_on_next_blur_(false),
       placeholder_text_color_(kDefaultPlaceholderTextColor),
       text_input_type_(ui::TEXT_INPUT_TYPE_TEXT),
       text_input_flags_(0),
       performing_user_action_(false),
       skip_input_method_cancel_composition_(false),
       drop_cursor_visible_(false),
       initiating_drag_(false),
       aggregated_clicks_(0),
       drag_start_display_offset_(0),
       touch_handles_hidden_due_to_scroll_(false),
       use_focus_ring_(ui::MaterialDesignController::IsSecondaryUiMaterial()),
       weak_ptr_factory_(this) {
   set_context_menu_controller(this);
   set_drag_controller(this);
   GetRenderText()->SetFontList(GetDefaultFontList());
   View::SetBorder(std::unique_ptr<Border>(new FocusableBorder()));
   SetFocusBehavior(FocusBehavior::ALWAYS);
 
   // These allow BrowserView to pass edit commands from the Chrome menu to us
   // when we're focused by simply asking the FocusManager to
   // ProcessAccelerator() with the relevant accelerators.
   AddAccelerator(ui::Accelerator(ui::VKEY_X, ui::EF_CONTROL_DOWN));
   AddAccelerator(ui::Accelerator(ui::VKEY_C, ui::EF_CONTROL_DOWN));
   AddAccelerator(ui::Accelerator(ui::VKEY_V, ui::EF_CONTROL_DOWN));
 }
 
 Textfield::~Textfield() {
+  FocusManager* focus_manager = GetFocusManager();

[tapted, 2016/10/13 06:21:35]

comment why this might be null?

[Patti Lor, 2016/10/24 02:43:17]

Done.

+  if (focus_manager)
+    focus_manager->RemoveFocusChangeListener(this);
+
   if (GetInputMethod()) {
     // The textfield should have been blurred before destroy.
     DCHECK(this != GetInputMethod()->GetTextInputClient());
   }
 }
 
 void Textfield::SetReadOnly(bool read_only) {
   // Update read-only without changing the focusable state (or active, etc.).
   read_only_ = read_only;
   if (GetInputMethod())
@@ skipping 130 matching lines @@
 SkColor Textfield::GetSelectionBackgroundColor() const {
   return use_default_selection_background_color_ ?
       GetNativeTheme()->GetSystemColor(
           ui::NativeTheme::kColorId_TextfieldSelectionBackgroundFocused) :
       selection_background_color_;
 }
 
 void Textfield::SetSelectionBackgroundColor(SkColor color) {
   selection_background_color_ = color;
   use_default_selection_background_color_ = false;
-  GetRenderText()->set_selection_background_focused_color(
+  GetRenderText()->set_selection_background_color(
       GetSelectionBackgroundColor());
   SchedulePaint();
 }
 
 void Textfield::UseDefaultSelectionBackgroundColor() {
   use_default_selection_background_color_ = true;
-  GetRenderText()->set_selection_background_focused_color(
+  GetRenderText()->set_selection_background_color(
       GetSelectionBackgroundColor());
   SchedulePaint();
 }
 
+SkColor Textfield::GetUnfocusedSelectionBackgroundColor() const {
+  return GetNativeTheme()->GetSystemColor(
+      ui::NativeTheme::kColorId_TextfieldSelectionBackgroundUnfocused);
+}
+
 bool Textfield::GetCursorEnabled() const {
   return GetRenderText()->cursor_enabled();
 }
 
 void Textfield::SetCursorEnabled(bool enabled) {
   GetRenderText()->SetCursorEnabled(enabled);
 }
 
 const gfx::FontList& Textfield::GetFontList() const {
   return GetRenderText()->font_list();
@@ skipping 76 matching lines @@
 
 void Textfield::SetAccessibleName(const base::string16& name) {
   accessible_name_ = name;
 }
 
 bool Textfield::HasTextBeingDragged() {
   return initiating_drag_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// Textfield, View overrides:
+// Textfield, View:
 
 gfx::Insets Textfield::GetInsets() const {
   gfx::Insets insets = View::GetInsets();
   insets += gfx::Insets(kTextPadding, kTextPadding, kTextPadding, kTextPadding);
   return insets;
 }
 
 int Textfield::GetBaseline() const {
   return GetInsets().top() + GetRenderText()->GetBaseline();
 }
@@ skipping 29 matching lines @@
     if (event.IsOnlyLeftMouseButton() || event.IsOnlyRightMouseButton()) {
       RequestFocus();
       ShowImeIfNeeded();
     }
 
     if (event.IsOnlyLeftMouseButton()) {
       OnBeforeUserAction();
       initiating_drag_ = false;
       switch (aggregated_clicks_) {
         case 0:
-          if (GetRenderText()->IsPointInSelection(event.location()))
+          if (GetRenderText()->IsPointInSelection(event.location())) {
             initiating_drag_ = true;
-          else
+            // If this isn't actually a mouse drag (determined later in
+            // OnMouseReleased()), the selection should be cleared before being
+            // drawn. But if it does turn out to be a mouse drag (determined
+            // later in OnMouseDragged()), the selection needs to be kept for
+            // dragging. Don't draw the text selection til it's known for sure.
+            if (!GetSelectedRange().is_empty())
+              GetRenderText()->set_draw_text_selection(false);
+          } else {
             MoveCursorTo(event.location(), event.IsShiftDown());
+          }
           break;
         case 1:
           SelectWordAt(event.location());
           double_click_word_ = GetRenderText()->selection();
           break;
         case 2:
           SelectAll(false);
           break;
         default:
           NOTREACHED();
@@ skipping 14 matching lines @@
       }
     }
 #endif
   }
 
   return true;
 }
 
 bool Textfield::OnMouseDragged(const ui::MouseEvent& event) {
   last_drag_location_ = event.location();
+  // Follow up from setting this to false in OnMousePressed() - it's safe to
+  // draw the selection now that it's determined this is a drag.
+  GetRenderText()->set_draw_text_selection(true);
 
   // Don't adjust the cursor on a potential drag and drop.
   if (initiating_drag_ || !event.IsOnlyLeftMouseButton())
     return true;
 
   // A timer is used to continuously scroll while selecting beyond side edges.
   const int x = event.location().x();
   if ((x >= 0 && x <= width()) || GetDragSelectionDelay() == 0) {
     drag_selection_timer_.Stop();
     SelectThroughLastDragLocation();
   } else if (!drag_selection_timer_.IsRunning()) {
     // Select through the edge of the visible text, then start the scroll timer.
     last_drag_location_.set_x(std::min(std::max(0, x), width()));
     SelectThroughLastDragLocation();
     drag_selection_timer_.Start(
         FROM_HERE, base::TimeDelta::FromMilliseconds(GetDragSelectionDelay()),
         this, &Textfield::SelectThroughLastDragLocation);
   }
 
   return true;
 }
 
 void Textfield::OnMouseReleased(const ui::MouseEvent& event) {
   OnBeforeUserAction();
   drag_selection_timer_.Stop();
   // Cancel suspected drag initiations, the user was clicking in the selection.
-  if (initiating_drag_)
+  if (initiating_drag_) {
     MoveCursorTo(event.location(), false);
+    // Follow up from setting this to false in OnMousePressed() - it's safe to
+    // draw the selection now that it's determined this is just a click.
+    GetRenderText()->set_draw_text_selection(true);
+  }
   initiating_drag_ = false;
   UpdateSelectionClipboard();
   OnAfterUserAction();
 }
 
 WordLookupClient* Textfield::GetWordLookupClient() {
   return this;
 }
 
 bool Textfield::OnKeyPressed(const ui::KeyEvent& event) {
@@ skipping 309 matching lines @@
     touch_selection_controller_->SelectionChanged();
 }
 
 void Textfield::OnEnabledChanged() {
   View::OnEnabledChanged();
   if (GetInputMethod())
     GetInputMethod()->OnTextInputTypeChanged(this);
   SchedulePaint();
 }
 
+void Textfield::ViewHierarchyChanged(
+    const ViewHierarchyChangedDetails& details) {
+  FocusManager* focus_manager = GetFocusManager();
+  if (details.parent->Contains(this) && details.move_view == nullptr &&
+      focus_manager) {
+    if (details.is_add)
+      focus_manager->AddFocusChangeListener(this);
+    else
+      focus_manager->RemoveFocusChangeListener(this);
+  }
+}
+
 void Textfield::OnPaint(gfx::Canvas* canvas) {
   OnPaintBackground(canvas);
   PaintTextAndCursor(canvas);
   OnPaintBorder(canvas);
 }
 
 void Textfield::OnFocus() {
   GetRenderText()->set_focused(true);
+  GetRenderText()->set_selection_background_color(
+      GetSelectionBackgroundColor());
   if (ShouldShowCursor())
     GetRenderText()->set_cursor_visible(true);
   if (GetInputMethod())
     GetInputMethod()->SetFocusedTextInputClient(this);
   OnCaretBoundsChanged();
   if (ShouldBlinkCursor())
     StartBlinkingCursor();
   if (use_focus_ring_)
     FocusRing::Install(this);
   SchedulePaint();
   View::OnFocus();
 }
 
 void Textfield::OnBlur() {
   gfx::RenderText* render_text = GetRenderText();
   render_text->set_focused(false);
   if (GetInputMethod())
     GetInputMethod()->DetachTextInputClient(this);
   StopBlinkingCursor();
   if (render_text->cursor_visible()) {
     render_text->set_cursor_visible(false);
     RepaintCursor();
   }
 
+  if (change_selection_background_color_on_next_blur_) {
+    // This being set means the entire Widget has now lost focus. Check that.
+    DCHECK(GetFocusManager()->GetFocusedView() == nullptr);
+    change_selection_background_color_on_next_blur_ = false;
+    GetRenderText()->set_selection_background_color(
+        GetUnfocusedSelectionBackgroundColor());
+    GetRenderText()->set_draw_text_selection(true);
+  }
+
   DestroyTouchSelection();
 
   if (use_focus_ring_)
     FocusRing::Uninstall(this);
   SchedulePaint();
   View::OnBlur();
 }
 
 gfx::Point Textfield::GetKeyboardContextMenuLocation() {
   return GetCaretBounds().bottom_right();
 }
 
 void Textfield::OnNativeThemeChanged(const ui::NativeTheme* theme) {
   gfx::RenderText* render_text = GetRenderText();
   render_text->SetColor(GetTextColor());
   UpdateBackgroundColor();
   render_text->set_cursor_color(GetTextColor());
   render_text->set_selection_color(GetSelectionTextColor());
-  render_text->set_selection_background_focused_color(
-      GetSelectionBackgroundColor());
+  if (HasFocus())
+    render_text->set_selection_background_color(GetSelectionBackgroundColor());
+  else

[tapted, 2016/10/13 06:21:35]

needs curlies (both parts)

[Patti Lor, 2016/10/24 02:43:17]

Done.

+    render_text->set_selection_background_color(
+        GetUnfocusedSelectionBackgroundColor());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// Textfield, TextfieldModel::Delegate overrides:
+// Textfield, TextfieldModel::Delegate:
 
 void Textfield::OnCompositionTextConfirmedOrCleared() {
   if (!skip_input_method_cancel_composition_)
     GetInputMethod()->CancelComposition(this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// Textfield, ContextMenuController overrides:
+// Textfield, ContextMenuController:
 
 void Textfield::ShowContextMenuForView(View* source,
                                        const gfx::Point& point,
                                        ui::MenuSourceType source_type) {
   UpdateContextMenu();
   ignore_result(context_menu_runner_->RunMenuAt(GetWidget(),
                                                 NULL,
                                                 gfx::Rect(point, gfx::Size()),
                                                 MENU_ANCHOR_TOPLEFT,
                                                 source_type));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// Textfield, DragController overrides:
+// Textfield, DragController:
 
 void Textfield::WriteDragDataForView(View* sender,
                                      const gfx::Point& press_pt,
                                      OSExchangeData* data) {
   const base::string16& selected_text(GetSelectedText());
   data->SetString(selected_text);
   Label label(selected_text, GetFontList());
   label.SetBackgroundColor(GetBackgroundColor());
   label.SetSubpixelRenderingEnabled(false);
   gfx::Size size(label.GetPreferredSize());
@@ skipping 30 matching lines @@
   return drag_operations;
 }
 
 bool Textfield::CanStartDragForView(View* sender,
                                     const gfx::Point& press_pt,
                                     const gfx::Point& p) {
   return initiating_drag_ && GetRenderText()->IsPointInSelection(press_pt);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// Textfield, FocusChangeListener:
+
+void Textfield::OnWillChangeFocus(View* focus_before, View* focus_after) {
+  // If this was the last focused View before switching Widgets, draw the text
+  // selection grayed out.
+  if (focus_before == this && focus_after == nullptr)
+    change_selection_background_color_on_next_blur_ = true;

[tapted, 2016/10/13 06:21:35]

what happens if we try to gray it out immediately? (comment?)

[Patti Lor, 2016/10/24 02:43:17]

Ah, I think that variable was there from your suggestion to avoid changing
anything in the RenderText class, but I mentioned in my reply comment that I
didn't think that was avoidable, so there isn't any need for it any more. Have
deleted it.

+  // If another View in the same widget is focused, don't draw the selection.
+  else if (focus_before == this && focus_after != nullptr)

[tapted, 2016/10/13 06:21:35]

needs curlies due to comments

[Patti Lor, 2016/10/24 02:43:17]

Done.

+    GetRenderText()->set_draw_text_selection(false);
+  // This is focused now, draw the text selection.
+  else if (focus_after == this)
+    GetRenderText()->set_draw_text_selection(true);
+}
+
+void Textfield::OnDidChangeFocus(View* focused_before, View* focused_now) {}
+
+////////////////////////////////////////////////////////////////////////////////
 // Textfield, WordLookupClient overrides:
 
 bool Textfield::GetDecoratedWordAtPoint(const gfx::Point& point,
                                         gfx::DecoratedText* decorated_word,
                                         gfx::Point* baseline_point) {
   return GetRenderText()->GetDecoratedWordAtPoint(point, decorated_word,
                                                   baseline_point);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// Textfield, ui::TouchEditable overrides:
+// Textfield, ui::TouchEditable:
 
 void Textfield::SelectRect(const gfx::Point& start, const gfx::Point& end) {
   if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE)
     return;
 
   gfx::SelectionModel start_caret = GetRenderText()->FindCursorPosition(start);
   gfx::SelectionModel end_caret = GetRenderText()->FindCursorPosition(end);
   gfx::SelectionModel selection(
       gfx::Range(start_caret.caret_pos(), end_caret.caret_pos()),
       end_caret.caret_affinity());
@@ skipping 62 matching lines @@
 void Textfield::OpenContextMenu(const gfx::Point& anchor) {
   DestroyTouchSelection();
   ShowContextMenu(anchor, ui::MENU_SOURCE_TOUCH_EDIT_MENU);
 }
 
 void Textfield::DestroyTouchSelection() {
   touch_selection_controller_.reset();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// Textfield, ui::SimpleMenuModel::Delegate overrides:
+// Textfield, ui::SimpleMenuModel::Delegate:
 
 bool Textfield::IsCommandIdChecked(int command_id) const {
   return true;
 }
 
 bool Textfield::IsCommandIdEnabled(int command_id) const {
   return Textfield::IsTextEditCommandEnabled(
       GetTextEditCommandFromMenuCommand(command_id, HasSelection()));
 }
 
@@ skipping 24 matching lines @@
       return false;
   }
 }
 
 void Textfield::ExecuteCommand(int command_id, int event_flags) {
   Textfield::ExecuteTextEditCommand(
       GetTextEditCommandFromMenuCommand(command_id, HasSelection()));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// Textfield, ui::TextInputClient overrides:
+// Textfield, ui::TextInputClient:
 
 void Textfield::SetCompositionText(const ui::CompositionText& composition) {
   if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE)
     return;
 
   OnBeforeUserAction();
   skip_input_method_cancel_composition_ = true;
   model_->SetCompositionText(composition);
   skip_input_method_cancel_composition_ = false;
   UpdateAfterChange(true, true);
@@ skipping 820 matching lines @@
 }
 
 void Textfield::OnCursorBlinkTimerFired() {
   DCHECK(ShouldBlinkCursor());
   gfx::RenderText* render_text = GetRenderText();
   render_text->set_cursor_visible(!render_text->cursor_visible());
   RepaintCursor();
 }
 
 }  // namespace views