New AppListView Scroll Behavior.

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/command_line.h"
@@ skipping 380 matching lines @@
 
 void Textfield::UseDefaultTextColor() {
   use_default_text_color_ = true;
   SetColor(GetTextColor());
 }
 
 SkColor Textfield::GetBackgroundColor() const {
   if (!use_default_background_color_)
     return background_color_;
 
-  return GetNativeTheme()->GetSystemColor(read_only() || !enabled() ?
-      ui::NativeTheme::kColorId_TextfieldReadOnlyBackground :
-      ui::NativeTheme::kColorId_TextfieldDefaultBackground);
+  return GetNativeTheme()->GetSystemColor(
+      read_only() || !enabled()
+          ? ui::NativeTheme::kColorId_TextfieldReadOnlyBackground
+          : ui::NativeTheme::kColorId_TextfieldDefaultBackground);
 }
 
 void Textfield::SetBackgroundColor(SkColor color) {
   background_color_ = color;
   use_default_background_color_ = false;
   UpdateBackgroundColor();
 }
 
 void Textfield::UseDefaultBackgroundColor() {
   use_default_background_color_ = true;
   UpdateBackgroundColor();
 }
 
 SkColor Textfield::GetSelectionTextColor() const {
-  return use_default_selection_text_color_ ?
-      GetNativeTheme()->GetSystemColor(
-          ui::NativeTheme::kColorId_TextfieldSelectionColor) :
-      selection_text_color_;
+  return use_default_selection_text_color_
+             ? GetNativeTheme()->GetSystemColor(
+                   ui::NativeTheme::kColorId_TextfieldSelectionColor)
+             : selection_text_color_;
 }
 
 void Textfield::SetSelectionTextColor(SkColor color) {
   selection_text_color_ = color;
   use_default_selection_text_color_ = false;
   GetRenderText()->set_selection_color(GetSelectionTextColor());
   SchedulePaint();
 }
 
 void Textfield::UseDefaultSelectionTextColor() {
   use_default_selection_text_color_ = true;
   GetRenderText()->set_selection_color(GetSelectionTextColor());
   SchedulePaint();
 }
 
 SkColor Textfield::GetSelectionBackgroundColor() const {
-  return use_default_selection_background_color_ ?
-      GetNativeTheme()->GetSystemColor(
-          ui::NativeTheme::kColorId_TextfieldSelectionBackgroundFocused) :
-      selection_background_color_;
+  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(
       GetSelectionBackgroundColor());
   SchedulePaint();
 }
 
@@ skipping 123 matching lines @@
   return insets;
 }
 
 int Textfield::GetBaseline() const {
   return GetInsets().top() + GetRenderText()->GetBaseline();
 }
 
 gfx::Size Textfield::CalculatePreferredSize() const {
   const gfx::Insets& insets = GetInsets();
   return gfx::Size(GetFontList().GetExpectedTextWidth(default_width_in_chars_) +
-                   insets.width(), GetFontList().GetHeight() + insets.height());
+                       insets.width(),
+                   GetFontList().GetHeight() + insets.height());
 }
 
 const char* Textfield::GetClassName() const {
   return kViewClassName;
 }
 
 void Textfield::SetBorder(std::unique_ptr<Border> b) {
   if (use_focus_ring_ && HasFocus())
     FocusRing::Uninstall(this);
   use_focus_ring_ = false;
@@ skipping 16 matching lines @@
       RequestFocus();
     ShowImeIfNeeded();
   }
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   if (!handled && !had_focus && event.IsOnlyMiddleMouseButton())
     RequestFocus();
 #endif
 
   return selection_controller_.OnMousePressed(
-      event, handled, had_focus ? SelectionController::FOCUSED
-                                : SelectionController::UNFOCUSED);
+      event, handled,
+      had_focus ? SelectionController::FOCUSED
+                : SelectionController::UNFOCUSED);
 }
 
 bool Textfield::OnMouseDragged(const ui::MouseEvent& event) {
   return selection_controller_.OnMouseDragged(event);
 }
 
 void Textfield::OnMouseReleased(const ui::MouseEvent& event) {
   selection_controller_.OnMouseReleased(event);
 }
 
 void Textfield::OnMouseCaptureLost() {
   selection_controller_.OnMouseCaptureLost();
 }
 
+bool Textfield::OnMouseWheel(const ui::MouseWheelEvent& event) {
+  return controller_ && controller_->HandleMouseEvent(this, event);
+}
+
 WordLookupClient* Textfield::GetWordLookupClient() {
   return this;
 }
 
 bool Textfield::OnKeyPressed(const ui::KeyEvent& event) {
   ui::TextEditCommand edit_command = scheduled_text_edit_command_;
   scheduled_text_edit_command_ = ui::TextEditCommand::INVALID_COMMAND;
 
   // Since HandleKeyEvent() might destroy |this|, get a weak pointer and verify
   // it isn't null before proceeding.
@@ skipping 105 matching lines @@
     case ui::ET_GESTURE_SCROLL_BEGIN:
       touch_handles_hidden_due_to_scroll_ = touch_selection_controller_ != NULL;
       DestroyTouchSelection();
       drag_start_location_ = event->location();
       drag_start_display_offset_ =
           GetRenderText()->GetUpdatedDisplayOffset().x();
       event->SetHandled();
       break;
     case ui::ET_GESTURE_SCROLL_UPDATE: {
       int new_offset = drag_start_display_offset_ + event->location().x() -
-          drag_start_location_.x();
+                       drag_start_location_.x();
       GetRenderText()->SetDisplayOffset(new_offset);
       SchedulePaint();
       event->SetHandled();
       break;
     }
     case ui::ET_GESTURE_SCROLL_END:
     case ui::ET_SCROLL_FLING_START:
       if (touch_handles_hidden_due_to_scroll_) {
         CreateTouchSelectionControllerAndNotifyIt();
         touch_handles_hidden_due_to_scroll_ = false;
@@ skipping 60 matching lines @@
   std::set<ui::Clipboard::FormatType> format_types;
   GetDropFormats(&formats, &format_types);
   return enabled() && !read_only() && data.HasAnyFormat(formats, format_types);
 }
 
 int Textfield::OnDragUpdated(const ui::DropTargetEvent& event) {
   DCHECK(CanDrop(event.data()));
   gfx::RenderText* render_text = GetRenderText();
   const gfx::Range& selection = render_text->selection();
   drop_cursor_position_ = render_text->FindCursorPosition(event.location());
-  bool in_selection = !selection.is_empty() &&
+  bool in_selection =
+      !selection.is_empty() &&
       selection.Contains(gfx::Range(drop_cursor_position_.caret_pos()));
   drop_cursor_visible_ = !in_selection;
   // TODO(msw): Pan over text when the user drags to the visible text edge.
   OnCaretBoundsChanged();
   SchedulePaint();
 
   StopBlinkingCursor();
 
   if (initiating_drag_) {
     if (in_selection)
       return ui::DragDropTypes::DRAG_NONE;
-    return event.IsControlDown() ? ui::DragDropTypes::DRAG_COPY :
-                                   ui::DragDropTypes::DRAG_MOVE;
+    return event.IsControlDown() ? ui::DragDropTypes::DRAG_COPY
+                                 : ui::DragDropTypes::DRAG_MOVE;
   }
   return ui::DragDropTypes::DRAG_COPY | ui::DragDropTypes::DRAG_MOVE;
 }
 
 void Textfield::OnDragExited() {
   drop_cursor_visible_ = false;
   if (ShouldBlinkCursor())
     StartBlinkingCursor();
   SchedulePaint();
 }
@@ skipping 523 matching lines @@
     return false;
   gfx::Range composition_range;
   model_->GetCompositionTextRange(&composition_range);
   DCHECK(!composition_range.is_empty());
 
   size_t text_index = composition_range.start() + index;
   if (composition_range.end() <= text_index)
     return false;
   gfx::RenderText* render_text = GetRenderText();
   if (!render_text->IsValidCursorIndex(text_index)) {
-    text_index = render_text->IndexOfAdjacentGrapheme(
-        text_index, gfx::CURSOR_BACKWARD);
+    text_index =
+        render_text->IndexOfAdjacentGrapheme(text_index, gfx::CURSOR_BACKWARD);
   }
   if (text_index < composition_range.start())
     return false;
   const gfx::SelectionModel caret(text_index, gfx::CURSOR_BACKWARD);
   *rect = render_text->GetCursorBounds(caret, false);
   ConvertRectToScreen(this, rect);
   return true;
 }
 
 bool Textfield::HasCompositionText() const {
@@ skipping 59 matching lines @@
   return true;
 }
 
 void Textfield::OnInputMethodChanged() {}
 
 bool Textfield::ChangeTextDirectionAndLayoutAlignment(
     base::i18n::TextDirection direction) {
   // Restore text directionality mode when the indicated direction matches the
   // current forced mode; otherwise, force the mode indicated. This helps users
   // manage BiDi text layout without getting stuck in forced LTR or RTL modes.
-  const gfx::DirectionalityMode mode = direction == base::i18n::RIGHT_TO_LEFT ?
-      gfx::DIRECTIONALITY_FORCE_RTL : gfx::DIRECTIONALITY_FORCE_LTR;
+  const gfx::DirectionalityMode mode = direction == base::i18n::RIGHT_TO_LEFT
+                                           ? gfx::DIRECTIONALITY_FORCE_RTL
+                                           : gfx::DIRECTIONALITY_FORCE_LTR;
   if (mode == GetRenderText()->directionality_mode())
     GetRenderText()->SetDirectionalityMode(gfx::DIRECTIONALITY_FROM_TEXT);
   else
     GetRenderText()->SetDirectionalityMode(mode);
   SchedulePaint();
   return true;
 }
 
 void Textfield::ExtendSelectionAndDelete(size_t before, size_t after) {
   gfx::Range range = GetRenderText()->selection();
@@ skipping 125 matching lines @@
 gfx::RenderText* Textfield::GetRenderText() const {
   return model_->render_text();
 }
 
 gfx::Point Textfield::GetLastClickLocation() const {
   return selection_controller_.last_click_location();
 }
 
 base::string16 Textfield::GetSelectionClipboardText() const {
   base::string16 selection_clipboard_text;
-  ui::Clipboard::GetForCurrentThread()->ReadText(
-      ui::CLIPBOARD_TYPE_SELECTION, &selection_clipboard_text);
+  ui::Clipboard::GetForCurrentThread()->ReadText(ui::CLIPBOARD_TYPE_SELECTION,
+                                                 &selection_clipboard_text);
   return selection_clipboard_text;
 }
 
 void Textfield::ExecuteTextEditCommand(ui::TextEditCommand command) {
   DestroyTouchSelection();
 
   bool add_to_kill_buffer = false;
 
   // Some codepaths may bypass GetCommandForKeyEvent, so any selection-dependent
   // modifications of the command should happen here.
@@ skipping 272 matching lines @@
   if (ui::MaterialDesignController::IsSecondaryUiMaterial()) {
     SetBackground(
         CreateBackgroundFromPainter(Painter::CreateSolidRoundRectPainter(
             color, FocusableBorder::kCornerRadiusDp)));
   } else {
     SetBackground(CreateSolidBackground(color));
   }
   // Disable subpixel rendering when the background color is transparent
   // because it draws incorrect colors around the glyphs in that case.
   // See crbug.com/115198
-  GetRenderText()->set_subpixel_rendering_suppressed(
-      SkColorGetA(color) != SK_AlphaOPAQUE);
+  GetRenderText()->set_subpixel_rendering_suppressed(SkColorGetA(color) !=
+                                                     SK_AlphaOPAQUE);
   SchedulePaint();
 }
 
 void Textfield::UpdateBorder() {
   auto border = base::MakeUnique<views::FocusableBorder>();
   if (invalid_)
     border->SetColorId(ui::NativeTheme::kColorId_AlertSeverityHigh);
   View::SetBorder(std::move(border));
 }
 
@@ skipping 135 matching lines @@
   // Disallow input method editing of password fields.
   ui::TextInputType t = GetTextInputType();
   return (t != ui::TEXT_INPUT_TYPE_NONE && t != ui::TEXT_INPUT_TYPE_PASSWORD);
 }
 
 void Textfield::RevealPasswordChar(int index) {
   GetRenderText()->SetObscuredRevealIndex(index);
   SchedulePaint();
 
   if (index != -1) {
-    password_reveal_timer_.Start(FROM_HERE, GetPasswordRevealDuration(),
+    password_reveal_timer_.Start(
+        FROM_HERE, GetPasswordRevealDuration(),
         base::Bind(&Textfield::RevealPasswordChar,
                    weak_ptr_factory_.GetWeakPtr(), -1));
   }
 }
 
 void Textfield::CreateTouchSelectionControllerAndNotifyIt() {
   if (!HasFocus())
     return;
 
   if (!touch_selection_controller_) {
@@ skipping 12 matching lines @@
   return HasFocus() && !HasSelection() && enabled() && !read_only() &&
          !drop_cursor_visible_ && GetRenderText()->cursor_enabled();
 }
 
 bool Textfield::ShouldBlinkCursor() const {
   return ShouldShowCursor() && Textfield::GetCaretBlinkMs() != 0;
 }
 
 void Textfield::StartBlinkingCursor() {
   DCHECK(ShouldBlinkCursor());
-  cursor_blink_timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(
-                                           Textfield::GetCaretBlinkMs()),
-                            this, &Textfield::OnCursorBlinkTimerFired);
+  cursor_blink_timer_.Start(
+      FROM_HERE,
+      base::TimeDelta::FromMilliseconds(Textfield::GetCaretBlinkMs()), this,
+      &Textfield::OnCursorBlinkTimerFired);
 }
 
 void Textfield::StopBlinkingCursor() {
   cursor_blink_timer_.Stop();
 }
 
 void Textfield::OnCursorBlinkTimerFired() {
   DCHECK(ShouldBlinkCursor());
   UpdateCursorViewPosition();
   cursor_view_.SetVisible(!cursor_view_.visible());
 }
 
 }  // namespace views