Home | History | Annotate | Download | only in tree 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "ui/views/controls/tree/tree_view.h"
      6 
      7 #include <algorithm>
      8 
      9 #include "base/i18n/rtl.h"
     10 #include "base/message_loop/message_loop.h"
     11 #include "ui/accessibility/ax_view_state.h"
     12 #include "ui/base/resource/resource_bundle.h"
     13 #include "ui/events/event.h"
     14 #include "ui/events/keycodes/keyboard_codes.h"
     15 #include "ui/gfx/canvas.h"
     16 #include "ui/gfx/geometry/rect.h"
     17 #include "ui/gfx/image/image.h"
     18 #include "ui/gfx/rect_conversions.h"
     19 #include "ui/gfx/skia_util.h"
     20 #include "ui/native_theme/native_theme.h"
     21 #include "ui/resources/grit/ui_resources.h"
     22 #include "ui/views/controls/prefix_selector.h"
     23 #include "ui/views/controls/scroll_view.h"
     24 #include "ui/views/controls/textfield/textfield.h"
     25 #include "ui/views/controls/tree/tree_view_controller.h"
     26 #include "ui/views/ime/input_method.h"
     27 
     28 using ui::TreeModel;
     29 using ui::TreeModelNode;
     30 
     31 namespace views {
     32 
     33 // Insets around the view.
     34 static const int kHorizontalInset = 2;
     35 static const int kVerticalInset = 2;
     36 // Padding before/after the image.
     37 static const int kImagePadding = 4;
     38 // Size of the arrow region.
     39 static const int kArrowRegionSize = 12;
     40 // Padding around the text (on each side).
     41 static const int kTextVerticalPadding = 3;
     42 static const int kTextHorizontalPadding = 2;
     43 // How much children are indented from their parent.
     44 static const int kIndent = 20;
     45 
     46 // static
     47 const char TreeView::kViewClassName[] = "TreeView";
     48 
     49 namespace {
     50 
     51 // Returns the color id for the background of selected text. |has_focus|
     52 // indicates if the tree has focus.
     53 ui::NativeTheme::ColorId text_background_color_id(bool has_focus) {
     54   return has_focus ?
     55       ui::NativeTheme::kColorId_TreeSelectionBackgroundFocused :
     56       ui::NativeTheme::kColorId_TreeSelectionBackgroundUnfocused;
     57 }
     58 
     59 // Returns the color id for text. |has_focus| indicates if the tree has focus
     60 // and |is_selected| is true if the item is selected.
     61 ui::NativeTheme::ColorId text_color_id(bool has_focus, bool is_selected) {
     62   if (is_selected) {
     63     if (has_focus)
     64       return ui::NativeTheme::kColorId_TreeSelectedText;
     65     return ui::NativeTheme::kColorId_TreeSelectedTextUnfocused;
     66   }
     67   return ui::NativeTheme::kColorId_TreeText;
     68 }
     69 
     70 }  // namespace
     71 
     72 TreeView::TreeView()
     73     : model_(NULL),
     74       selected_node_(NULL),
     75       editing_(false),
     76       editor_(NULL),
     77       focus_manager_(NULL),
     78       auto_expand_children_(false),
     79       editable_(true),
     80       controller_(NULL),
     81       root_shown_(true),
     82       row_height_(font_list_.GetHeight() + kTextVerticalPadding * 2) {
     83   SetFocusable(true);
     84   closed_icon_ = *ui::ResourceBundle::GetSharedInstance().GetImageNamed(
     85       (base::i18n::IsRTL() ? IDR_FOLDER_CLOSED_RTL
     86                            : IDR_FOLDER_CLOSED)).ToImageSkia();
     87   open_icon_ = *ui::ResourceBundle::GetSharedInstance().GetImageNamed(
     88       (base::i18n::IsRTL() ? IDR_FOLDER_OPEN_RTL
     89                            : IDR_FOLDER_OPEN)).ToImageSkia();
     90   text_offset_ = closed_icon_.width() + kImagePadding + kImagePadding +
     91       kArrowRegionSize;
     92 }
     93 
     94 TreeView::~TreeView() {
     95   if (model_)
     96     model_->RemoveObserver(this);
     97   if (focus_manager_) {
     98     focus_manager_->RemoveFocusChangeListener(this);
     99     focus_manager_ = NULL;
    100   }
    101 }
    102 
    103 View* TreeView::CreateParentIfNecessary() {
    104   ScrollView* scroll_view = ScrollView::CreateScrollViewWithBorder();
    105   scroll_view->SetContents(this);
    106   return scroll_view;
    107 }
    108 
    109 void TreeView::SetModel(TreeModel* model) {
    110   if (model == model_)
    111     return;
    112   if (model_)
    113     model_->RemoveObserver(this);
    114 
    115   CancelEdit();
    116 
    117   model_ = model;
    118   selected_node_ = NULL;
    119   icons_.clear();
    120   if (model_) {
    121     model_->AddObserver(this);
    122     model_->GetIcons(&icons_);
    123 
    124     root_.RemoveAll();
    125     ConfigureInternalNode(model_->GetRoot(), &root_);
    126     LoadChildren(&root_);
    127     root_.set_is_expanded(true);
    128     if (root_shown_)
    129       selected_node_ = &root_;
    130     else if (root_.child_count())
    131       selected_node_ = root_.GetChild(0);
    132   }
    133   DrawnNodesChanged();
    134 }
    135 
    136 void TreeView::SetEditable(bool editable) {
    137   if (editable == editable_)
    138     return;
    139   editable_ = editable;
    140   CancelEdit();
    141 }
    142 
    143 void TreeView::StartEditing(TreeModelNode* node) {
    144   DCHECK(node);
    145   // Cancel the current edit.
    146   CancelEdit();
    147   // Make sure all ancestors are expanded.
    148   if (model_->GetParent(node))
    149     Expand(model_->GetParent(node));
    150   // Select the node, else if the user commits the edit the selection reverts.
    151   SetSelectedNode(node);
    152   if (GetSelectedNode() != node)
    153     return;  // Selection failed for some reason, don't start editing.
    154   DCHECK(!editing_);
    155   editing_ = true;
    156   if (!editor_) {
    157     editor_ = new Textfield;
    158     // Add the editor immediately as GetPreferredSize returns the wrong thing if
    159     // not parented.
    160     AddChildView(editor_);
    161     editor_->SetFontList(font_list_);
    162     empty_editor_size_ = editor_->GetPreferredSize();
    163     editor_->set_controller(this);
    164   }
    165   editor_->SetText(selected_node_->model_node()->GetTitle());
    166   LayoutEditor();
    167   editor_->SetVisible(true);
    168   SchedulePaintForNode(selected_node_);
    169   editor_->RequestFocus();
    170   editor_->SelectAll(false);
    171 
    172   // Listen for focus changes so that we can cancel editing.
    173   focus_manager_ = GetFocusManager();
    174   if (focus_manager_)
    175     focus_manager_->AddFocusChangeListener(this);
    176 
    177   // Accelerators to commit/cancel edit.
    178   AddAccelerator(ui::Accelerator(ui::VKEY_RETURN, ui::EF_NONE));
    179   AddAccelerator(ui::Accelerator(ui::VKEY_ESCAPE, ui::EF_NONE));
    180 }
    181 
    182 void TreeView::CancelEdit() {
    183   if (!editing_)
    184     return;
    185 
    186   // WARNING: don't touch |selected_node_|, it may be bogus.
    187 
    188   editing_ = false;
    189   if (focus_manager_) {
    190     focus_manager_->RemoveFocusChangeListener(this);
    191     focus_manager_ = NULL;
    192   }
    193   editor_->SetVisible(false);
    194   SchedulePaint();
    195 
    196   RemoveAccelerator(ui::Accelerator(ui::VKEY_RETURN, ui::EF_NONE));
    197   RemoveAccelerator(ui::Accelerator(ui::VKEY_ESCAPE, ui::EF_NONE));
    198 }
    199 
    200 void TreeView::CommitEdit() {
    201   if (!editing_)
    202     return;
    203 
    204   DCHECK(selected_node_);
    205   const bool editor_has_focus = editor_->HasFocus();
    206   model_->SetTitle(GetSelectedNode(), editor_->text());
    207   CancelEdit();
    208   if (editor_has_focus)
    209     RequestFocus();
    210 }
    211 
    212 TreeModelNode* TreeView::GetEditingNode() {
    213   return editing_ ? selected_node_->model_node() : NULL;
    214 }
    215 
    216 void TreeView::SetSelectedNode(TreeModelNode* model_node) {
    217   if (editing_ || model_node != selected_node_)
    218     CancelEdit();
    219   if (model_node && model_->GetParent(model_node))
    220     Expand(model_->GetParent(model_node));
    221   if (model_node && model_node == root_.model_node() && !root_shown_)
    222     return;  // Ignore requests to select the root when not shown.
    223   InternalNode* node = model_node ? GetInternalNodeForModelNode(
    224       model_node, CREATE_IF_NOT_LOADED) : NULL;
    225   bool was_empty_selection = (selected_node_ == NULL);
    226   bool changed = (selected_node_ != node);
    227   if (changed) {
    228     SchedulePaintForNode(selected_node_);
    229     selected_node_ = node;
    230     if (selected_node_ == &root_ && !root_shown_)
    231       selected_node_ = NULL;
    232     if (selected_node_ && selected_node_ != &root_)
    233       Expand(model_->GetParent(selected_node_->model_node()));
    234     SchedulePaintForNode(selected_node_);
    235   }
    236 
    237   if (selected_node_)
    238     ScrollRectToVisible(GetBoundsForNode(selected_node_));
    239 
    240   // Notify controller if the old selection was empty to handle the case of
    241   // remove explicitly resetting selected_node_ before invoking this.
    242   if (controller_ && (changed || was_empty_selection))
    243     controller_->OnTreeViewSelectionChanged(this);
    244 
    245   if (changed) {
    246     // TODO(dmazzoni): Decide if EVENT_SELECTION_CHANGED is a better choice for
    247     // sub-item selection event.
    248     NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, true);
    249   }
    250 }
    251 
    252 TreeModelNode* TreeView::GetSelectedNode() {
    253   return selected_node_ ? selected_node_->model_node() : NULL;
    254 }
    255 
    256 void TreeView::Collapse(ui::TreeModelNode* model_node) {
    257   // Don't collapse the root if the root isn't shown, otherwise nothing is
    258   // displayed.
    259   if (model_node == root_.model_node() && !root_shown_)
    260     return;
    261   InternalNode* node =
    262       GetInternalNodeForModelNode(model_node, DONT_CREATE_IF_NOT_LOADED);
    263   if (!node)
    264     return;
    265   bool was_expanded = IsExpanded(model_node);
    266   if (node->is_expanded()) {
    267     if (selected_node_ && selected_node_->HasAncestor(node))
    268       SetSelectedNode(model_node);
    269     node->set_is_expanded(false);
    270   }
    271   if (was_expanded)
    272     DrawnNodesChanged();
    273 }
    274 
    275 void TreeView::Expand(TreeModelNode* node) {
    276   if (ExpandImpl(node))
    277     DrawnNodesChanged();
    278   // TODO: need to support auto_expand_children_.
    279 }
    280 
    281 void TreeView::ExpandAll(TreeModelNode* node) {
    282   DCHECK(node);
    283   // Expand the node.
    284   bool expanded_at_least_one = ExpandImpl(node);
    285   // And recursively expand all the children.
    286   for (int i = model_->GetChildCount(node) - 1; i >= 0; --i) {
    287     TreeModelNode* child = model_->GetChild(node, i);
    288     if (ExpandImpl(child))
    289       expanded_at_least_one = true;
    290   }
    291   if (expanded_at_least_one)
    292     DrawnNodesChanged();
    293 }
    294 
    295 bool TreeView::IsExpanded(TreeModelNode* model_node) {
    296   if (!model_node) {
    297     // NULL check primarily for convenience for uses in this class so don't have
    298     // to add NULL checks every where we look up the parent.
    299     return true;
    300   }
    301   InternalNode* node = GetInternalNodeForModelNode(
    302       model_node, DONT_CREATE_IF_NOT_LOADED);
    303   if (!node)
    304     return false;
    305 
    306   while (node) {
    307     if (!node->is_expanded())
    308       return false;
    309     node = node->parent();
    310   }
    311   return true;
    312 }
    313 
    314 void TreeView::SetRootShown(bool root_shown) {
    315   if (root_shown_ == root_shown)
    316     return;
    317   root_shown_ = root_shown;
    318   if (!root_shown_ && selected_node_ == &root_) {
    319     if (model_->GetChildCount(root_.model_node()))
    320       SetSelectedNode(model_->GetChild(root_.model_node(), 0));
    321     else
    322       SetSelectedNode(NULL);
    323   }
    324   DrawnNodesChanged();
    325 }
    326 
    327 ui::TreeModelNode* TreeView::GetNodeForRow(int row) {
    328   int depth = 0;
    329   InternalNode* node = GetNodeByRow(row, &depth);
    330   return node ? node->model_node() : NULL;
    331 }
    332 
    333 int TreeView::GetRowForNode(ui::TreeModelNode* node) {
    334   InternalNode* internal_node =
    335       GetInternalNodeForModelNode(node, DONT_CREATE_IF_NOT_LOADED);
    336   if (!internal_node)
    337     return -1;
    338   int depth = 0;
    339   return GetRowForInternalNode(internal_node, &depth);
    340 }
    341 
    342 void TreeView::Layout() {
    343   int width = preferred_size_.width();
    344   int height = preferred_size_.height();
    345   if (parent()) {
    346     width = std::max(parent()->width(), width);
    347     height = std::max(parent()->height(), height);
    348   }
    349   SetBounds(x(), y(), width, height);
    350   LayoutEditor();
    351 }
    352 
    353 gfx::Size TreeView::GetPreferredSize() const {
    354   return preferred_size_;
    355 }
    356 
    357 bool TreeView::AcceleratorPressed(const ui::Accelerator& accelerator) {
    358   if (accelerator.key_code() == ui::VKEY_RETURN) {
    359     CommitEdit();
    360   } else {
    361     DCHECK_EQ(ui::VKEY_ESCAPE, accelerator.key_code());
    362     CancelEdit();
    363     RequestFocus();
    364   }
    365   return true;
    366 }
    367 
    368 bool TreeView::OnMousePressed(const ui::MouseEvent& event) {
    369   return OnClickOrTap(event);
    370 }
    371 
    372 ui::TextInputClient* TreeView::GetTextInputClient() {
    373   if (!selector_)
    374     selector_.reset(new PrefixSelector(this));
    375   return selector_.get();
    376 }
    377 
    378 void TreeView::OnGestureEvent(ui::GestureEvent* event) {
    379   if (event->type() == ui::ET_GESTURE_TAP) {
    380     if (OnClickOrTap(*event))
    381       event->SetHandled();
    382   }
    383 }
    384 
    385 void TreeView::ShowContextMenu(const gfx::Point& p,
    386                                ui::MenuSourceType source_type) {
    387   if (!model_)
    388     return;
    389   if (source_type == ui::MENU_SOURCE_MOUSE) {
    390     // Only invoke View's implementation (which notifies the
    391     // ContextMenuController) if over a node.
    392     gfx::Point local_point(p);
    393     ConvertPointFromScreen(this, &local_point);
    394     int row = (local_point.y() - kVerticalInset) / row_height_;
    395     int depth = 0;
    396     InternalNode* node = GetNodeByRow(row, &depth);
    397     if (!node)
    398       return;
    399     gfx::Rect bounds(GetBoundsForNodeImpl(node, row, depth));
    400     if (!bounds.Contains(local_point))
    401       return;
    402   }
    403   View::ShowContextMenu(p, source_type);
    404 }
    405 
    406 void TreeView::GetAccessibleState(ui::AXViewState* state) {
    407   state->role = ui::AX_ROLE_TREE;
    408   state->AddStateFlag(ui::AX_STATE_READ_ONLY);
    409   if (!selected_node_)
    410     return;
    411 
    412   // Get selected item info.
    413   state->role = ui::AX_ROLE_TREE_ITEM;
    414   state->name = selected_node_->model_node()->GetTitle();
    415 }
    416 
    417 const char* TreeView::GetClassName() const {
    418   return kViewClassName;
    419 }
    420 
    421 void TreeView::TreeNodesAdded(TreeModel* model,
    422                               TreeModelNode* parent,
    423                               int start,
    424                               int count) {
    425   InternalNode* parent_node =
    426       GetInternalNodeForModelNode(parent, DONT_CREATE_IF_NOT_LOADED);
    427   if (!parent_node || !parent_node->loaded_children())
    428     return;
    429   for (int i = 0; i < count; ++i) {
    430     InternalNode* child = new InternalNode;
    431     ConfigureInternalNode(model_->GetChild(parent, start + i), child);
    432     parent_node->Add(child, start + i);
    433   }
    434   if (IsExpanded(parent))
    435     DrawnNodesChanged();
    436 }
    437 
    438 void TreeView::TreeNodesRemoved(TreeModel* model,
    439                                 TreeModelNode* parent,
    440                                 int start,
    441                                 int count) {
    442   InternalNode* parent_node =
    443       GetInternalNodeForModelNode(parent, DONT_CREATE_IF_NOT_LOADED);
    444   if (!parent_node || !parent_node->loaded_children())
    445     return;
    446   bool reset_selection = false;
    447   for (int i = 0; i < count; ++i) {
    448     InternalNode* child_removing = parent_node->GetChild(start);
    449     if (selected_node_ && selected_node_->HasAncestor(child_removing))
    450       reset_selection = true;
    451     delete parent_node->Remove(child_removing);
    452   }
    453   if (reset_selection) {
    454     // selected_node_ is no longer valid (at the time we enter this function
    455     // its model_node() is likely deleted). Explicitly NULL out the field
    456     // rather than invoking SetSelectedNode() otherwise, we'll try and use a
    457     // deleted value.
    458     selected_node_ = NULL;
    459     TreeModelNode* to_select = parent;
    460     if (parent == root_.model_node() && !root_shown_) {
    461       to_select = model_->GetChildCount(parent) > 0 ?
    462           model_->GetChild(parent, 0) : NULL;
    463     }
    464     SetSelectedNode(to_select);
    465   }
    466   if (IsExpanded(parent))
    467     DrawnNodesChanged();
    468 }
    469 
    470 void TreeView::TreeNodeChanged(TreeModel* model, TreeModelNode* model_node) {
    471   InternalNode* node =
    472       GetInternalNodeForModelNode(model_node, DONT_CREATE_IF_NOT_LOADED);
    473   if (!node)
    474     return;
    475   int old_width = node->text_width();
    476   UpdateNodeTextWidth(node);
    477   if (old_width != node->text_width() &&
    478       ((node == &root_ && root_shown_) ||
    479        (node != &root_ && IsExpanded(node->parent()->model_node())))) {
    480     DrawnNodesChanged();
    481   }
    482 }
    483 
    484 void TreeView::ContentsChanged(Textfield* sender,
    485                                const base::string16& new_contents) {
    486 }
    487 
    488 bool TreeView::HandleKeyEvent(Textfield* sender,
    489                               const ui::KeyEvent& key_event) {
    490   switch (key_event.key_code()) {
    491     case ui::VKEY_RETURN:
    492       CommitEdit();
    493       return true;
    494 
    495     case ui::VKEY_ESCAPE:
    496       CancelEdit();
    497       RequestFocus();
    498       return true;
    499 
    500     default:
    501       return false;
    502   }
    503 }
    504 
    505 void TreeView::OnWillChangeFocus(View* focused_before, View* focused_now) {
    506 }
    507 
    508 void TreeView::OnDidChangeFocus(View* focused_before, View* focused_now) {
    509   CommitEdit();
    510 }
    511 
    512 int TreeView::GetRowCount() {
    513   int row_count = root_.NumExpandedNodes();
    514   if (!root_shown_)
    515     row_count--;
    516   return row_count;
    517 }
    518 
    519 int TreeView::GetSelectedRow() {
    520   ui::TreeModelNode* model_node = GetSelectedNode();
    521   return model_node ? GetRowForNode(model_node) : -1;
    522 }
    523 
    524 void TreeView::SetSelectedRow(int row) {
    525   SetSelectedNode(GetNodeForRow(row));
    526 }
    527 
    528 base::string16 TreeView::GetTextForRow(int row) {
    529   return GetNodeForRow(row)->GetTitle();
    530 }
    531 
    532 gfx::Point TreeView::GetKeyboardContextMenuLocation() {
    533   int y = height() / 2;
    534   if (selected_node_) {
    535     gfx::Rect node_bounds(GetBoundsForNode(selected_node_));
    536     gfx::Rect vis_bounds(GetVisibleBounds());
    537     if (node_bounds.y() >= vis_bounds.y() &&
    538         node_bounds.y() < vis_bounds.bottom()) {
    539       y = node_bounds.y();
    540     }
    541   }
    542   gfx::Point screen_loc(0, y);
    543   if (base::i18n::IsRTL())
    544     screen_loc.set_x(width());
    545   ConvertPointToScreen(this, &screen_loc);
    546   return screen_loc;
    547 }
    548 
    549 bool TreeView::OnKeyPressed(const ui::KeyEvent& event) {
    550   if (!HasFocus())
    551     return false;
    552 
    553   switch (event.key_code()) {
    554     case ui::VKEY_F2:
    555       if (!editing_) {
    556         TreeModelNode* selected_node = GetSelectedNode();
    557         if (selected_node && (!controller_ ||
    558                               controller_->CanEdit(this, selected_node))) {
    559           StartEditing(selected_node);
    560         }
    561       }
    562       return true;
    563 
    564     case ui::VKEY_UP:
    565     case ui::VKEY_DOWN:
    566       IncrementSelection(event.key_code() == ui::VKEY_UP ?
    567                          INCREMENT_PREVIOUS : INCREMENT_NEXT);
    568       return true;
    569 
    570     case ui::VKEY_LEFT:
    571       if (base::i18n::IsRTL())
    572         ExpandOrSelectChild();
    573       else
    574         CollapseOrSelectParent();
    575       return true;
    576 
    577     case ui::VKEY_RIGHT:
    578       if (base::i18n::IsRTL())
    579         CollapseOrSelectParent();
    580       else
    581         ExpandOrSelectChild();
    582       return true;
    583 
    584     default:
    585       break;
    586   }
    587   return false;
    588 }
    589 
    590 void TreeView::OnPaint(gfx::Canvas* canvas) {
    591   // Don't invoke View::OnPaint so that we can render our own focus border.
    592   canvas->DrawColor(GetNativeTheme()->GetSystemColor(
    593                         ui::NativeTheme::kColorId_TreeBackground));
    594 
    595   int min_y, max_y;
    596   {
    597     SkRect sk_clip_rect;
    598     if (canvas->sk_canvas()->getClipBounds(&sk_clip_rect)) {
    599       // Pixels partially inside the clip rect should be included.
    600       gfx::Rect clip_rect = gfx::ToEnclosingRect(
    601           gfx::SkRectToRectF(sk_clip_rect));
    602       min_y = clip_rect.y();
    603       max_y = clip_rect.bottom();
    604     } else {
    605       gfx::Rect vis_bounds = GetVisibleBounds();
    606       min_y = vis_bounds.y();
    607       max_y = vis_bounds.bottom();
    608     }
    609   }
    610 
    611   int min_row = std::max(0, (min_y - kVerticalInset) / row_height_);
    612   int max_row = (max_y - kVerticalInset) / row_height_;
    613   if ((max_y - kVerticalInset) % row_height_ != 0)
    614     max_row++;
    615   int current_row = root_row();
    616   PaintRows(canvas, min_row, max_row, &root_, root_depth(), &current_row);
    617 }
    618 
    619 void TreeView::OnFocus() {
    620   GetInputMethod()->OnFocus();
    621   View::OnFocus();
    622   SchedulePaintForNode(selected_node_);
    623 
    624   // Notify the InputMethod so that it knows to query the TextInputClient.
    625   if (GetInputMethod())
    626     GetInputMethod()->OnCaretBoundsChanged(this);
    627 }
    628 
    629 void TreeView::OnBlur() {
    630   GetInputMethod()->OnBlur();
    631   SchedulePaintForNode(selected_node_);
    632   if (selector_)
    633     selector_->OnViewBlur();
    634 }
    635 
    636 bool TreeView::OnClickOrTap(const ui::LocatedEvent& event) {
    637   CommitEdit();
    638   RequestFocus();
    639 
    640   int row = (event.y() - kVerticalInset) / row_height_;
    641   int depth = 0;
    642   InternalNode* node = GetNodeByRow(row, &depth);
    643   if (node) {
    644     gfx::Rect bounds(GetBoundsForNodeImpl(node, row, depth));
    645     if (bounds.Contains(event.location())) {
    646       int relative_x = event.x() - bounds.x();
    647       if (base::i18n::IsRTL())
    648         relative_x = bounds.width() - relative_x;
    649       if (relative_x < kArrowRegionSize &&
    650           model_->GetChildCount(node->model_node())) {
    651         if (node->is_expanded())
    652           Collapse(node->model_node());
    653         else
    654           Expand(node->model_node());
    655       } else if (relative_x > kArrowRegionSize) {
    656         SetSelectedNode(node->model_node());
    657         bool should_toggle = false;
    658         if (event.type() == ui::ET_GESTURE_TAP) {
    659           const ui::GestureEvent& gesture =
    660               static_cast<const ui::GestureEvent&>(event);
    661           should_toggle = gesture.details().tap_count() == 2;
    662         } else {
    663           should_toggle = (event.flags() & ui::EF_IS_DOUBLE_CLICK) != 0;
    664         }
    665         if (should_toggle) {
    666           if (node->is_expanded())
    667             Collapse(node->model_node());
    668           else
    669             Expand(node->model_node());
    670         }
    671       }
    672     }
    673   }
    674   return true;
    675 }
    676 
    677 void TreeView::LoadChildren(InternalNode* node) {
    678   DCHECK_EQ(0, node->child_count());
    679   DCHECK(!node->loaded_children());
    680   node->set_loaded_children(true);
    681   for (int i = 0, child_count = model_->GetChildCount(node->model_node());
    682        i < child_count; ++i) {
    683     InternalNode* child = new InternalNode;
    684     ConfigureInternalNode(model_->GetChild(node->model_node(), i), child);
    685     node->Add(child, node->child_count());
    686   }
    687 }
    688 
    689 void TreeView::ConfigureInternalNode(TreeModelNode* model_node,
    690                                      InternalNode* node) {
    691   node->Reset(model_node);
    692   UpdateNodeTextWidth(node);
    693 }
    694 
    695 void TreeView::UpdateNodeTextWidth(InternalNode* node) {
    696   int width = 0, height = 0;
    697   gfx::Canvas::SizeStringInt(node->model_node()->GetTitle(), font_list_,
    698                              &width, &height, 0, gfx::Canvas::NO_ELLIPSIS);
    699   node->set_text_width(width);
    700 }
    701 
    702 void TreeView::DrawnNodesChanged() {
    703   UpdatePreferredSize();
    704   PreferredSizeChanged();
    705   SchedulePaint();
    706 }
    707 
    708 void TreeView::UpdatePreferredSize() {
    709   preferred_size_ = gfx::Size();
    710   if (!model_)
    711     return;
    712 
    713   preferred_size_.SetSize(
    714       root_.GetMaxWidth(text_offset_, root_shown_ ? 1 : 0) +
    715       kTextHorizontalPadding * 2,
    716       row_height_ * GetRowCount() + kVerticalInset * 2);
    717 }
    718 
    719 void TreeView::LayoutEditor() {
    720   if (!editing_)
    721     return;
    722 
    723   DCHECK(selected_node_);
    724   // Position the editor so that its text aligns with the text we drew.
    725   gfx::Rect row_bounds = GetBoundsForNode(selected_node_);
    726   row_bounds.set_x(
    727       GetMirroredXWithWidthInView(row_bounds.x(), row_bounds.width()));
    728   row_bounds.set_x(row_bounds.x() + text_offset_);
    729   row_bounds.set_width(row_bounds.width() - text_offset_);
    730   row_bounds.Inset(kTextHorizontalPadding, kTextVerticalPadding);
    731   row_bounds.Inset(-empty_editor_size_.width() / 2,
    732                    -(empty_editor_size_.height() - font_list_.GetHeight()) / 2);
    733   // Give a little extra space for editing.
    734   row_bounds.set_width(row_bounds.width() + 50);
    735   editor_->SetBoundsRect(row_bounds);
    736   editor_->Layout();
    737 }
    738 
    739 void TreeView::SchedulePaintForNode(InternalNode* node) {
    740   if (!node)
    741     return;  // Explicitly allow NULL to be passed in.
    742   SchedulePaintInRect(GetBoundsForNode(node));
    743 }
    744 
    745 void TreeView::PaintRows(gfx::Canvas* canvas,
    746                          int min_row,
    747                          int max_row,
    748                          InternalNode* node,
    749                          int depth,
    750                          int* row) {
    751   if (*row >= max_row)
    752     return;
    753 
    754   if (*row >= min_row && *row < max_row)
    755     PaintRow(canvas, node, *row, depth);
    756   (*row)++;
    757   if (!node->is_expanded())
    758     return;
    759   depth++;
    760   for (int i = 0; i < node->child_count() && *row < max_row; ++i)
    761     PaintRows(canvas, min_row, max_row, node->GetChild(i), depth, row);
    762 }
    763 
    764 void TreeView::PaintRow(gfx::Canvas* canvas,
    765                         InternalNode* node,
    766                         int row,
    767                         int depth) {
    768   gfx::Rect bounds(GetBoundsForNodeImpl(node, row, depth));
    769 
    770   if (model_->GetChildCount(node->model_node()))
    771     PaintExpandControl(canvas, bounds, node->is_expanded());
    772 
    773   // Paint the icon.
    774   gfx::ImageSkia icon;
    775   int icon_index = model_->GetIconIndex(node->model_node());
    776   if (icon_index != -1)
    777     icon = icons_[icon_index];
    778   else if (node == selected_node_)
    779     icon = open_icon_;
    780   else
    781     icon = closed_icon_;
    782   int icon_x = kArrowRegionSize + kImagePadding +
    783                (open_icon_.width() - icon.width()) / 2;
    784   if (base::i18n::IsRTL())
    785     icon_x = bounds.right() - icon_x - open_icon_.width();
    786   else
    787     icon_x += bounds.x();
    788   canvas->DrawImageInt(
    789       icon, icon_x,
    790       bounds.y() + (bounds.height() - icon.height()) / 2);
    791 
    792   if (!editing_ || node != selected_node_) {
    793     gfx::Rect text_bounds(bounds.x() + text_offset_, bounds.y(),
    794                           bounds.width() - text_offset_, bounds.height());
    795     if (base::i18n::IsRTL())
    796       text_bounds.set_x(bounds.x());
    797     if (node == selected_node_) {
    798       const SkColor bg_color = GetNativeTheme()->GetSystemColor(
    799           text_background_color_id(HasFocus()));
    800       canvas->FillRect(text_bounds, bg_color);
    801       if (HasFocus())
    802         canvas->DrawFocusRect(text_bounds);
    803     }
    804     const ui::NativeTheme::ColorId color_id =
    805         text_color_id(HasFocus(), node == selected_node_);
    806     const gfx::Rect internal_bounds(
    807         text_bounds.x() + kTextHorizontalPadding,
    808         text_bounds.y() + kTextVerticalPadding,
    809         text_bounds.width() - kTextHorizontalPadding * 2,
    810         text_bounds.height() - kTextVerticalPadding * 2);
    811     canvas->DrawStringRect(node->model_node()->GetTitle(), font_list_,
    812                            GetNativeTheme()->GetSystemColor(color_id),
    813                            internal_bounds);
    814   }
    815 }
    816 
    817 void TreeView::PaintExpandControl(gfx::Canvas* canvas,
    818                                   const gfx::Rect& node_bounds,
    819                                   bool expanded) {
    820   int center_x;
    821   if (base::i18n::IsRTL()) {
    822     center_x = node_bounds.right() - kArrowRegionSize +
    823                (kArrowRegionSize - 4) / 2;
    824   } else {
    825     center_x = node_bounds.x() + (kArrowRegionSize - 4) / 2;
    826   }
    827   int center_y = node_bounds.y() + node_bounds.height() / 2;
    828   const SkColor arrow_color = GetNativeTheme()->GetSystemColor(
    829       ui::NativeTheme::kColorId_TreeArrow);
    830   // TODO: this should come from an image.
    831   if (!expanded) {
    832     int delta = base::i18n::IsRTL() ? 1 : -1;
    833     for (int i = 0; i < 4; ++i) {
    834       canvas->FillRect(gfx::Rect(center_x + delta * (2 - i),
    835                                  center_y - (3 - i), 1, (3 - i) * 2 + 1),
    836                        arrow_color);
    837     }
    838   } else {
    839     center_y -= 2;
    840     for (int i = 0; i < 4; ++i) {
    841       canvas->FillRect(gfx::Rect(center_x - (3 - i), center_y + i,
    842                                  (3 - i) * 2 + 1, 1), arrow_color);
    843     }
    844   }
    845 }
    846 
    847 TreeView::InternalNode* TreeView::GetInternalNodeForModelNode(
    848     ui::TreeModelNode* model_node,
    849     GetInternalNodeCreateType create_type) {
    850   if (model_node == root_.model_node())
    851     return &root_;
    852   InternalNode* parent_internal_node =
    853       GetInternalNodeForModelNode(model_->GetParent(model_node), create_type);
    854   if (!parent_internal_node)
    855     return NULL;
    856   if (!parent_internal_node->loaded_children()) {
    857     if (create_type == DONT_CREATE_IF_NOT_LOADED)
    858       return NULL;
    859     LoadChildren(parent_internal_node);
    860   }
    861   return parent_internal_node->GetChild(
    862       model_->GetIndexOf(parent_internal_node->model_node(), model_node));
    863 }
    864 
    865 gfx::Rect TreeView::GetBoundsForNode(InternalNode* node) {
    866   int row, depth;
    867   row = GetRowForInternalNode(node, &depth);
    868   return GetBoundsForNodeImpl(node, row, depth);
    869 }
    870 
    871 gfx::Rect TreeView::GetBoundsForNodeImpl(InternalNode* node,
    872                                          int row,
    873                                          int depth) {
    874   gfx::Rect rect(depth * kIndent + kHorizontalInset,
    875                  row * row_height_ + kVerticalInset,
    876                  text_offset_ + node->text_width() +
    877                  kTextHorizontalPadding * 2,
    878                  row_height_);
    879   rect.set_x(GetMirroredXWithWidthInView(rect.x(), rect.width()));
    880   return rect;
    881 }
    882 
    883 int TreeView::GetRowForInternalNode(InternalNode* node, int* depth) {
    884   DCHECK(!node->parent() || IsExpanded(node->parent()->model_node()));
    885   *depth = -1;
    886   int row = -1;
    887   InternalNode* tmp_node = node;
    888   while (tmp_node->parent()) {
    889     int index_in_parent = tmp_node->parent()->GetIndexOf(tmp_node);
    890     (*depth)++;
    891     row++;  // For node.
    892     for (int i = 0; i < index_in_parent; ++i)
    893       row += tmp_node->parent()->GetChild(i)->NumExpandedNodes();
    894     tmp_node = tmp_node->parent();
    895   }
    896   if (root_shown_) {
    897     (*depth)++;
    898     row++;
    899   }
    900   return row;
    901 }
    902 
    903 TreeView::InternalNode* TreeView::GetNodeByRow(int row, int* depth) {
    904   int current_row = root_row();
    905   *depth = 0;
    906   return GetNodeByRowImpl(&root_, row, root_depth(), &current_row, depth);
    907 }
    908 
    909 TreeView::InternalNode* TreeView::GetNodeByRowImpl(InternalNode* node,
    910                                                    int target_row,
    911                                                    int current_depth,
    912                                                    int* current_row,
    913                                                    int* node_depth) {
    914   if (*current_row == target_row) {
    915     *node_depth = current_depth;
    916     return node;
    917   }
    918   (*current_row)++;
    919   if (node->is_expanded()) {
    920     current_depth++;
    921     for (int i = 0; i < node->child_count(); ++i) {
    922       InternalNode* result = GetNodeByRowImpl(
    923           node->GetChild(i), target_row, current_depth, current_row,
    924           node_depth);
    925       if (result)
    926         return result;
    927     }
    928   }
    929   return NULL;
    930 }
    931 
    932 void TreeView::IncrementSelection(IncrementType type) {
    933   if (!model_)
    934     return;
    935 
    936   if (!GetSelectedNode()) {
    937     // If nothing is selected select the first or last node.
    938     if (!root_.child_count())
    939       return;
    940     if (type == INCREMENT_PREVIOUS) {
    941       int row_count = GetRowCount();
    942       int depth = 0;
    943       DCHECK(row_count);
    944       InternalNode* node = GetNodeByRow(row_count - 1, &depth);
    945       SetSelectedNode(node->model_node());
    946     } else if (root_shown_) {
    947       SetSelectedNode(root_.model_node());
    948     } else {
    949       SetSelectedNode(root_.GetChild(0)->model_node());
    950     }
    951     return;
    952   }
    953 
    954   int depth = 0;
    955   int delta = type == INCREMENT_PREVIOUS ? -1 : 1;
    956   int row = GetRowForInternalNode(selected_node_, &depth);
    957   int new_row = std::min(GetRowCount() - 1, std::max(0, row + delta));
    958   if (new_row == row)
    959     return;  // At the end/beginning.
    960   SetSelectedNode(GetNodeByRow(new_row, &depth)->model_node());
    961 }
    962 
    963 void TreeView::CollapseOrSelectParent() {
    964   if (selected_node_) {
    965     if (selected_node_->is_expanded())
    966       Collapse(selected_node_->model_node());
    967     else if (selected_node_->parent())
    968       SetSelectedNode(selected_node_->parent()->model_node());
    969   }
    970 }
    971 
    972 void TreeView::ExpandOrSelectChild() {
    973   if (selected_node_) {
    974     if (!selected_node_->is_expanded())
    975       Expand(selected_node_->model_node());
    976     else if (selected_node_->child_count())
    977       SetSelectedNode(selected_node_->GetChild(0)->model_node());
    978   }
    979 }
    980 
    981 bool TreeView::ExpandImpl(TreeModelNode* model_node) {
    982   TreeModelNode* parent = model_->GetParent(model_node);
    983   if (!parent) {
    984     // Node should be the root.
    985     DCHECK_EQ(root_.model_node(), model_node);
    986     bool was_expanded = root_.is_expanded();
    987     root_.set_is_expanded(true);
    988     return !was_expanded;
    989   }
    990 
    991   // Expand all the parents.
    992   bool return_value = ExpandImpl(parent);
    993   InternalNode* internal_node =
    994       GetInternalNodeForModelNode(model_node, CREATE_IF_NOT_LOADED);
    995   DCHECK(internal_node);
    996   if (!internal_node->is_expanded()) {
    997     if (!internal_node->loaded_children())
    998       LoadChildren(internal_node);
    999     internal_node->set_is_expanded(true);
   1000     return_value = true;
   1001   }
   1002   return return_value;
   1003 }
   1004 
   1005 // InternalNode ----------------------------------------------------------------
   1006 
   1007 TreeView::InternalNode::InternalNode()
   1008     : model_node_(NULL),
   1009       loaded_children_(false),
   1010       is_expanded_(false),
   1011       text_width_(0) {
   1012 }
   1013 
   1014 TreeView::InternalNode::~InternalNode() {
   1015 }
   1016 
   1017 void TreeView::InternalNode::Reset(ui::TreeModelNode* node) {
   1018   model_node_ = node;
   1019   loaded_children_ = false;
   1020   is_expanded_ = false;
   1021   text_width_ = 0;
   1022 }
   1023 
   1024 int TreeView::InternalNode::NumExpandedNodes() const {
   1025   int result = 1;  // For this.
   1026   if (!is_expanded_)
   1027     return result;
   1028   for (int i = 0; i < child_count(); ++i)
   1029     result += GetChild(i)->NumExpandedNodes();
   1030   return result;
   1031 }
   1032 
   1033 int TreeView::InternalNode::GetMaxWidth(int indent, int depth) {
   1034   int max_width = text_width_ + indent * depth;
   1035   if (!is_expanded_)
   1036     return max_width;
   1037   for (int i = 0; i < child_count(); ++i) {
   1038     max_width = std::max(max_width,
   1039                          GetChild(i)->GetMaxWidth(indent, depth + 1));
   1040   }
   1041   return max_width;
   1042 }
   1043 
   1044 }  // namespace views
   1045