Upstream version 11.40.277.0
[platform/framework/web/crosswalk.git] / src / ui / views / controls / tree / tree_view.cc
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