MacViews: support backgrounds for selected rows

ui/views/controls/tree/tree_view.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/tree/tree_view.h"
 
 #include <algorithm>
 
 #include "base/i18n/rtl.h"
 #include "base/message_loop/message_loop.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/resources/grit/ui_resources.h"
 #include "ui/views/controls/prefix_selector.h"
 #include "ui/views/controls/scroll_view.h"
 #include "ui/views/controls/textfield/textfield.h"
 #include "ui/views/controls/tree/tree_view_controller.h"
 #include "ui/views/resources/grit/views_resources.h"
+#include "ui/views/style/platform_style.h"
 
 using ui::TreeModel;
 using ui::TreeModelNode;
 
 namespace views {
 
 // Insets around the view.
 static const int kHorizontalInset = 2;
 static const int kVerticalInset = 2;
 // Padding before/after the image.
@@ skipping 23 matching lines @@
 // and |is_selected| is true if the item is selected.
 ui::NativeTheme::ColorId text_color_id(bool has_focus, bool is_selected) {
   if (is_selected) {
     if (has_focus)
       return ui::NativeTheme::kColorId_TreeSelectedText;
     return ui::NativeTheme::kColorId_TreeSelectedTextUnfocused;
   }
   return ui::NativeTheme::kColorId_TreeText;
 }
 
+bool EventIsDoubleTapOrClick(const ui::LocatedEvent& event) {
+  if (event.type() == ui::ET_GESTURE_TAP)
+    return event.AsGestureEvent()->details().tap_count() == 2;
+  return !!(event.flags() & ui::EF_IS_DOUBLE_CLICK);
+}
+
 }  // namespace
 
 TreeView::TreeView()
     : model_(NULL),
       selected_node_(NULL),
       editing_(false),
       editor_(NULL),
       focus_manager_(NULL),
       auto_expand_children_(false),
       editable_(true),
@@ skipping 155 matching lines @@
     SchedulePaintForNode(selected_node_);
     selected_node_ = node;
     if (selected_node_ == &root_ && !root_shown_)
       selected_node_ = NULL;
     if (selected_node_ && selected_node_ != &root_)
       Expand(model_->GetParent(selected_node_->model_node()));
     SchedulePaintForNode(selected_node_);
   }
 
   if (selected_node_)
-    ScrollRectToVisible(GetBoundsForNode(selected_node_));
+    ScrollRectToVisible(GetForegroundBoundsForNode(selected_node_));
 
   // Notify controller if the old selection was empty to handle the case of
   // remove explicitly resetting selected_node_ before invoking this.
   if (controller_ && (changed || was_empty_selection))
     controller_->OnTreeViewSelectionChanged(this);
 
   if (changed) {
     NotifyAccessibilityEvent(ui::AX_EVENT_TEXT_CHANGED, true);
     NotifyAccessibilityEvent(ui::AX_EVENT_SELECTION, true);
   }
@@ skipping 128 matching lines @@
 
 void TreeView::ShowContextMenu(const gfx::Point& p,
                                ui::MenuSourceType source_type) {
   if (!model_)
     return;
   if (source_type == ui::MENU_SOURCE_MOUSE) {
     // Only invoke View's implementation (which notifies the
     // ContextMenuController) if over a node.
     gfx::Point local_point(p);
     ConvertPointFromScreen(this, &local_point);
-    int row = (local_point.y() - kVerticalInset) / row_height_;
-    int depth = 0;
-    InternalNode* node = GetNodeByRow(row, &depth);
-    if (!node)
-      return;
-    gfx::Rect bounds(GetBoundsForNodeImpl(node, row, depth));
-    if (!bounds.Contains(local_point))
+    if (!GetNodeAtPoint(local_point))
       return;
   }
   View::ShowContextMenu(p, source_type);
 }
 
 void TreeView::GetAccessibleState(ui::AXViewState* state) {
   state->role = ui::AX_ROLE_TREE;
   state->AddStateFlag(ui::AX_STATE_READ_ONLY);
   if (!selected_node_)
     return;
@@ skipping 117 matching lines @@
   SetSelectedNode(GetNodeForRow(row));
 }
 
 base::string16 TreeView::GetTextForRow(int row) {
   return GetNodeForRow(row)->GetTitle();
 }
 
 gfx::Point TreeView::GetKeyboardContextMenuLocation() {
   int y = height() / 2;
   if (selected_node_) {
-    gfx::Rect node_bounds(GetBoundsForNode(selected_node_));
+    gfx::Rect node_bounds(GetForegroundBoundsForNode(selected_node_));
     gfx::Rect vis_bounds(GetVisibleBounds());
     if (node_bounds.y() >= vis_bounds.y() &&
         node_bounds.y() < vis_bounds.bottom()) {
       y = node_bounds.y();
     }
   }
   gfx::Point screen_loc(0, y);
   if (base::i18n::IsRTL())
     screen_loc.set_x(width());
   ConvertPointToScreen(this, &screen_loc);
@@ skipping 86 matching lines @@
     GetInputMethod()->DetachTextInputClient(GetPrefixSelector());
   SchedulePaintForNode(selected_node_);
   if (selector_)
     selector_->OnViewBlur();
 }
 
 bool TreeView::OnClickOrTap(const ui::LocatedEvent& event) {
   CommitEdit();
   RequestFocus();
 
-  int row = (event.y() - kVerticalInset) / row_height_;
-  int depth = 0;
-  InternalNode* node = GetNodeByRow(row, &depth);
-  if (node) {
-    gfx::Rect bounds(GetBoundsForNodeImpl(node, row, depth));
-    if (bounds.Contains(event.location())) {
-      int relative_x = event.x() - bounds.x();
-      if (base::i18n::IsRTL())
-        relative_x = bounds.width() - relative_x;
-      if (relative_x < kArrowRegionSize &&
-          model_->GetChildCount(node->model_node())) {
-        if (node->is_expanded())
-          Collapse(node->model_node());
-        else
-          Expand(node->model_node());
-      } else if (relative_x > kArrowRegionSize) {
-        SetSelectedNode(node->model_node());
-        bool should_toggle = false;
-        if (event.type() == ui::ET_GESTURE_TAP) {
-          const ui::GestureEvent& gesture =
-              static_cast<const ui::GestureEvent&>(event);
-          should_toggle = gesture.details().tap_count() == 2;
-        } else {
-          should_toggle = (event.flags() & ui::EF_IS_DOUBLE_CLICK) != 0;
-        }
-        if (should_toggle) {
-          if (node->is_expanded())
-            Collapse(node->model_node());
-          else
-            Expand(node->model_node());
-        }
-      }
-    }
+  InternalNode* node = GetNodeAtPoint(event.location());
+  if (!node)
+    return true;
+
+  bool hits_arrow = IsPointInExpandControl(node, event.location());
+  if (!hits_arrow)
+    SetSelectedNode(node->model_node());
+
+  if (hits_arrow || EventIsDoubleTapOrClick(event)) {
+    if (node->is_expanded())
+      Collapse(node->model_node());
+    else
+      Expand(node->model_node());
   }
   return true;
 }
 
 void TreeView::LoadChildren(InternalNode* node) {
   DCHECK_EQ(0, node->child_count());
   DCHECK(!node->loaded_children());
   node->set_loaded_children(true);
   for (int i = 0, child_count = model_->GetChildCount(node->model_node());
        i < child_count; ++i) {
@@ skipping 32 matching lines @@
       kTextHorizontalPadding * 2,
       row_height_ * GetRowCount() + kVerticalInset * 2);
 }
 
 void TreeView::LayoutEditor() {
   if (!editing_)
     return;
 
   DCHECK(selected_node_);
   // Position the editor so that its text aligns with the text we drew.
-  gfx::Rect row_bounds = GetBoundsForNode(selected_node_);
+  gfx::Rect row_bounds = GetForegroundBoundsForNode(selected_node_);
   row_bounds.set_x(
       GetMirroredXWithWidthInView(row_bounds.x(), row_bounds.width()));
   row_bounds.set_x(row_bounds.x() + text_offset_);
   row_bounds.set_width(row_bounds.width() - text_offset_);
   row_bounds.Inset(kTextHorizontalPadding, kTextVerticalPadding);
   row_bounds.Inset(-empty_editor_size_.width() / 2,
                    -(empty_editor_size_.height() - font_list_.GetHeight()) / 2);
   // Give a little extra space for editing.
   row_bounds.set_width(row_bounds.width() + 50);
   editor_->SetBoundsRect(row_bounds);
   editor_->Layout();
 }
 
 void TreeView::SchedulePaintForNode(InternalNode* node) {
   if (!node)
     return;  // Explicitly allow NULL to be passed in.
-  SchedulePaintInRect(GetBoundsForNode(node));
+  SchedulePaintInRect(GetBackgroundBoundsForNode(node));
 }
 
 void TreeView::PaintRows(gfx::Canvas* canvas,
                          int min_row,
                          int max_row,
                          InternalNode* node,
                          int depth,
                          int* row) {
   if (*row >= max_row)
     return;
 
   if (*row >= min_row && *row < max_row)
     PaintRow(canvas, node, *row, depth);
   (*row)++;
   if (!node->is_expanded())
     return;
   depth++;
   for (int i = 0; i < node->child_count() && *row < max_row; ++i)
     PaintRows(canvas, min_row, max_row, node->GetChild(i), depth, row);
 }
 
 void TreeView::PaintRow(gfx::Canvas* canvas,
                         InternalNode* node,
                         int row,
                         int depth) {
-  gfx::Rect bounds(GetBoundsForNodeImpl(node, row, depth));
+  gfx::Rect bounds(GetForegroundBoundsForNodeImpl(node, row, depth));
+  const SkColor selected_row_bg_color = GetNativeTheme()->GetSystemColor(
+      text_background_color_id(HasFocus() || editing_));
+
+  // Paint the row background.
+  if (PlatformStyle::kTreeViewSelectionPaintsEntireRow &&
+      selected_node_ == node) {
+    canvas->FillRect(GetBackgroundBoundsForNode(node), selected_row_bg_color);
+  }
 
   if (model_->GetChildCount(node->model_node()))
     PaintExpandControl(canvas, bounds, node->is_expanded());
 
   // Paint the icon.
   gfx::ImageSkia icon;
   int icon_index = model_->GetIconIndex(node->model_node());
   if (icon_index != -1)
     icon = icons_[icon_index];
   else if (node == selected_node_)
     icon = open_icon_;
   else
     icon = closed_icon_;
   int icon_x = kArrowRegionSize + kImagePadding +
                (open_icon_.width() - icon.width()) / 2;
   if (base::i18n::IsRTL())
     icon_x = bounds.right() - icon_x - open_icon_.width();
   else
     icon_x += bounds.x();
   canvas->DrawImageInt(
       icon, icon_x,
       bounds.y() + (bounds.height() - icon.height()) / 2);
 
-  if (!editing_ || node != selected_node_) {
-    gfx::Rect text_bounds(bounds.x() + text_offset_, bounds.y(),
-                          bounds.width() - text_offset_, bounds.height());
-    if (base::i18n::IsRTL())
-      text_bounds.set_x(bounds.x());
-    if (node == selected_node_) {
-      const SkColor bg_color = GetNativeTheme()->GetSystemColor(
-          text_background_color_id(HasFocus()));
-      canvas->FillRect(text_bounds, bg_color);
-      if (HasFocus())
-        canvas->DrawFocusRect(text_bounds);
-    }
-    const ui::NativeTheme::ColorId color_id =
-        text_color_id(HasFocus(), node == selected_node_);
-    const gfx::Rect internal_bounds(
-        text_bounds.x() + kTextHorizontalPadding,
-        text_bounds.y() + kTextVerticalPadding,
-        text_bounds.width() - kTextHorizontalPadding * 2,
-        text_bounds.height() - kTextVerticalPadding * 2);
-    canvas->DrawStringRect(node->model_node()->GetTitle(), font_list_,
-                           GetNativeTheme()->GetSystemColor(color_id),
-                           internal_bounds);
+  // Paint the text background and text. In edit mode, the selected node is a
+  // separate editing control, so it does not need to be painted here.
+  if (editing_ && selected_node_ == node)
+    return;
+
+  gfx::Rect text_bounds(GetTextBoundsForNode(node));
+  if (base::i18n::IsRTL())
+    text_bounds.set_x(bounds.x());
+
+  // Paint the background on the selected row.
+  if (!PlatformStyle::kTreeViewSelectionPaintsEntireRow &&
+      node == selected_node_) {
+    canvas->FillRect(text_bounds, selected_row_bg_color);
+    if (HasFocus())
+      canvas->DrawFocusRect(text_bounds);
   }
+
+  // Paint the text.
+  const ui::NativeTheme::ColorId color_id =
+      text_color_id(HasFocus(), node == selected_node_);
+  const gfx::Rect internal_bounds(
+      text_bounds.x() + kTextHorizontalPadding,
+      text_bounds.y() + kTextVerticalPadding,
+      text_bounds.width() - kTextHorizontalPadding * 2,
+      text_bounds.height() - kTextVerticalPadding * 2);
+  canvas->DrawStringRect(node->model_node()->GetTitle(), font_list_,
+                         GetNativeTheme()->GetSystemColor(color_id),
+                         internal_bounds);
 }
 
 void TreeView::PaintExpandControl(gfx::Canvas* canvas,
                                   const gfx::Rect& node_bounds,
                                   bool expanded) {
   int center_x;
   if (base::i18n::IsRTL()) {
     center_x = node_bounds.right() - kArrowRegionSize +
                (kArrowRegionSize - 4) / 2;
   } else {
@@ skipping 30 matching lines @@
     return NULL;
   if (!parent_internal_node->loaded_children()) {
     if (create_type == DONT_CREATE_IF_NOT_LOADED)
       return NULL;
     LoadChildren(parent_internal_node);
   }
   return parent_internal_node->GetChild(
       model_->GetIndexOf(parent_internal_node->model_node(), model_node));
 }
 
-gfx::Rect TreeView::GetBoundsForNode(InternalNode* node) {
+gfx::Rect TreeView::GetBackgroundBoundsForNode(InternalNode* node) {
+  if (!PlatformStyle::kTreeViewSelectionPaintsEntireRow)
+    return GetForegroundBoundsForNode(node);
+
+  int row, ignored_depth;
+  row = GetRowForInternalNode(node, &ignored_depth);
+  return gfx::Rect(bounds().x(), row * row_height_ + kVerticalInset,
+                   bounds().width(), row_height_);
+}
+
+gfx::Rect TreeView::GetForegroundBoundsForNode(InternalNode* node) {
   int row, depth;
   row = GetRowForInternalNode(node, &depth);
-  return GetBoundsForNodeImpl(node, row, depth);
+  return GetForegroundBoundsForNodeImpl(node, row, depth);
 }
 
-gfx::Rect TreeView::GetBoundsForNodeImpl(InternalNode* node,
-                                         int row,
-                                         int depth) {
+gfx::Rect TreeView::GetTextBoundsForNode(InternalNode* node) {
+  gfx::Rect bounds(GetForegroundBoundsForNode(node));
+  bounds.Inset(text_offset_, 0, 0, 0);
+  return bounds;
+}
+
+gfx::Rect TreeView::GetForegroundBoundsForNodeImpl(InternalNode* node,
+                                                   int row,
+                                                   int depth) {
   gfx::Rect rect(depth * kIndent + kHorizontalInset,
                  row * row_height_ + kVerticalInset,
                  text_offset_ + node->text_width() +
                  kTextHorizontalPadding * 2,
                  row_height_);
   rect.set_x(GetMirroredXWithWidthInView(rect.x(), rect.width()));
   return rect;
 }
 
 int TreeView::GetRowForInternalNode(InternalNode* node, int* depth) {
   DCHECK(!node->parent() || IsExpanded(node->parent()->model_node()));
   *depth = -1;
   int row = -1;
   InternalNode* tmp_node = node;
   while (tmp_node->parent()) {
     int index_in_parent = tmp_node->parent()->GetIndexOf(tmp_node);
     (*depth)++;
     row++;  // For node.
     for (int i = 0; i < index_in_parent; ++i)
       row += tmp_node->parent()->GetChild(i)->NumExpandedNodes();
     tmp_node = tmp_node->parent();
   }
   if (root_shown_) {
     (*depth)++;
     row++;
   }
   return row;
 }
 
+TreeView::InternalNode* TreeView::GetNodeAtPoint(const gfx::Point& point) {
+  int row = (point.y() - kVerticalInset) / row_height_;
+  int depth = -1;
+  InternalNode* node = GetNodeByRow(row, &depth);
+  if (!node)
+    return nullptr;
+
+  // If the entire row gets a selected background, clicking anywhere in the row
+  // serves to hit this node.
+  if (PlatformStyle::kTreeViewSelectionPaintsEntireRow)
+    return node;
+  gfx::Rect bounds(GetForegroundBoundsForNodeImpl(node, row, depth));
+  return bounds.Contains(point) ? node : nullptr;
+}
+
 TreeView::InternalNode* TreeView::GetNodeByRow(int row, int* depth) {
   int current_row = root_row();
   *depth = 0;
   return GetNodeByRowImpl(&root_, row, root_depth(), &current_row, depth);
 }
 
 TreeView::InternalNode* TreeView::GetNodeByRowImpl(InternalNode* node,
                                                    int target_row,
                                                    int current_depth,
                                                    int* current_row,
@@ skipping 88 matching lines @@
   }
   return return_value;
 }
 
 PrefixSelector* TreeView::GetPrefixSelector() {
   if (!selector_)
     selector_.reset(new PrefixSelector(this));
   return selector_.get();
 }
 
+bool TreeView::IsPointInExpandControl(InternalNode* node,
+                                      const gfx::Point& point) {
+  if (!model_->GetChildCount(node->model_node()))
+    return false;
+
+  int depth = -1;
+  int row = GetRowForInternalNode(node, &depth);
+
+  int arrow_dx = depth * kIndent + kHorizontalInset;
+  gfx::Rect arrow_bounds(bounds().x() + arrow_dx,
+                         row * row_height_ + kVerticalInset, kArrowRegionSize,
+                         row_height_);
+  if (base::i18n::IsRTL())
+    arrow_bounds.set_x(bounds().width() - arrow_dx - kArrowRegionSize);
+  return arrow_bounds.Contains(point);
+}
+
 // InternalNode ----------------------------------------------------------------
 
 TreeView::InternalNode::InternalNode()
     : model_node_(NULL),
       loaded_children_(false),
       is_expanded_(false),
       text_width_(0) {
 }
 
 TreeView::InternalNode::~InternalNode() {
@@ skipping 20 matching lines @@
   if (!is_expanded_)
     return max_width;
   for (int i = 0; i < child_count(); ++i) {
     max_width = std::max(max_width,
                          GetChild(i)->GetMaxWidth(indent, depth + 1));
   }
   return max_width;
 }
 
 }  // namespace views