views::TreeView allow the selection to fill the row

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"
@@ skipping 26 matching lines @@
 // Padding before/after the image.
 static const int kImagePadding = 4;
 // Size of the arrow region.
 static const int kArrowRegionSize = 12;
 // Padding around the text (on each side).
 static const int kTextVerticalPadding = 3;
 static const int kTextHorizontalPadding = 2;
 // How much children are indented from their parent.
 static const int kIndent = 20;
 
+#if defined(OS_MACOSX)
+static const bool kSelectionFillsRow = true;
+#else
+static const bool kSelectionFillsRow = false;
+#endif
+
 // static
 const char TreeView::kViewClassName[] = "TreeView";
 
 namespace {
 
-// Returns the color id for the background of selected text. |has_focus|
-// indicates if the tree has focus.
-ui::NativeTheme::ColorId text_background_color_id(bool has_focus) {
+// Returns the color id for a row. |has_focus| indicates if the tree has focus.
+ui::NativeTheme::ColorId text_background_color_id(bool is_selected_row,
+                                                  bool has_focus) {
+  if (!is_selected_row)
+    return ui::NativeTheme::kColorId_TreeBackground;
   return has_focus ?
       ui::NativeTheme::kColorId_TreeSelectionBackgroundFocused :
       ui::NativeTheme::kColorId_TreeSelectionBackgroundUnfocused;
 }
 
 // Returns the color id for text. |has_focus| indicates if the tree has focus
 // 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)
@@ skipping 698 matching lines @@
   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));
 
+  const SkColor bg_color = GetNativeTheme()->GetSystemColor(
+      text_background_color_id(node == selected_node_, HasFocus()));
+  if (kSelectionFillsRow) {
+    canvas->FillRect(bounds, bg_color);
+    bounds.set_x(depth * kIndent + kHorizontalInset);
+  }
+
   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()));
+    if (!kSelectionFillsRow && node == selected_node_) {
       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,
@@ skipping 54 matching lines @@
 
 gfx::Rect TreeView::GetBoundsForNode(InternalNode* node) {
   int row, depth;
   row = GetRowForInternalNode(node, &depth);
   return GetBoundsForNodeImpl(node, row, depth);
 }
 
 gfx::Rect TreeView::GetBoundsForNodeImpl(InternalNode* node,
                                          int row,
                                          int depth) {
-  gfx::Rect rect(depth * kIndent + kHorizontalInset,
-                 row * row_height_ + kVerticalInset,
-                 text_offset_ + node->text_width() +
-                 kTextHorizontalPadding * 2,
+  int row_x = kSelectionFillsRow ? 0 : depth * kIndent + kHorizontalInset;
+  int row_width = kSelectionFillsRow ? width() : text_offset_ +
+                                                     node->text_width() +
+                                                     kTextHorizontalPadding * 2;
+  gfx::Rect rect(row_x, row * row_height_ + kVerticalInset, row_width,
                  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;
@@ skipping 153 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