ui/views/focus/focus_search.cc

   1 // Copyright (c) 2011 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 "base/logging.h"
   6 #include "ui/views/focus/focus_manager.h"
   7 #include "ui/views/focus/focus_search.h"
   8 #include "ui/views/view.h"
   9
  10 namespace views {
  11
  12 FocusSearch::FocusSearch(View* root, bool cycle, bool accessibility_mode)
  13     : root_(root),
  14       cycle_(cycle),
  15       accessibility_mode_(accessibility_mode) {
  16 }
  17
  18 View* FocusSearch::FindNextFocusableView(View* starting_view,
  19                                          bool reverse,
  20                                          Direction direction,
  21                                          bool check_starting_view,
  22                                          FocusTraversable** focus_traversable,
  23                                          View** focus_traversable_view) {
  24   *focus_traversable = NULL;
  25   *focus_traversable_view = NULL;
  26
  27   if (!root_->has_children()) {
  28     NOTREACHED();
  29     // Nothing to focus on here.
  30     return NULL;
  31   }
  32
  33   View* initial_starting_view = starting_view;
  34   int starting_view_group = -1;
  35   if (starting_view)
  36     starting_view_group = starting_view->GetGroup();
  37
  38   if (!starting_view) {
  39     // Default to the first/last child
  40     starting_view = reverse ? root_->child_at(root_->child_count() - 1) :
  41         root_->child_at(0);
  42     // If there was no starting view, then the one we select is a potential
  43     // focus candidate.
  44     check_starting_view = true;
  45   } else {
  46     // The starting view should be a direct or indirect child of the root.
  47     DCHECK(Contains(root_, starting_view));
  48   }
  49
  50   View* v = NULL;
  51   if (!reverse) {
  52     v = FindNextFocusableViewImpl(starting_view, check_starting_view,
  53                                   true,
  54                                   (direction == DOWN),
  55                                   starting_view_group,
  56                                   focus_traversable,
  57                                   focus_traversable_view);
  58   } else {
  59     // If the starting view is focusable, we don't want to go down, as we are
  60     // traversing the view hierarchy tree bottom-up.
  61     bool can_go_down = (direction == DOWN) && !IsFocusable(starting_view);
  62     v = FindPreviousFocusableViewImpl(starting_view, check_starting_view,
  63                                       true,
  64                                       can_go_down,
  65                                       starting_view_group,
  66                                       focus_traversable,
  67                                       focus_traversable_view);
  68   }
  69
  70   // Don't set the focus to something outside of this view hierarchy.
  71   if (v && v != root_ && !Contains(root_, v))
  72     v = NULL;
  73
  74   // If |cycle_| is true, prefer to keep cycling rather than returning NULL.
  75   if (cycle_ && !v && initial_starting_view) {
  76     v = FindNextFocusableView(NULL, reverse, direction, check_starting_view,
  77                               focus_traversable, focus_traversable_view);
  78     DCHECK(IsFocusable(v));
  79     return v;
  80   }
  81
  82   // Doing some sanity checks.
  83   if (v) {
  84     DCHECK(IsFocusable(v));
  85     return v;
  86   }
  87   if (*focus_traversable) {
  88     DCHECK(*focus_traversable_view);
  89     return NULL;
  90   }
  91   // Nothing found.
  92   return NULL;
  93 }
  94
  95 bool FocusSearch::IsViewFocusableCandidate(View* v, int skip_group_id) {
  96   return IsFocusable(v) &&
  97       (v->IsGroupFocusTraversable() || skip_group_id == -1 ||
  98        v->GetGroup() != skip_group_id);
  99 }
 100
 101 bool FocusSearch::IsFocusable(View* v) {
 102   if (accessibility_mode_)
 103     return v && v->IsAccessibilityFocusable();
 104   return v && v->IsFocusable();
 105 }
 106
 107 View* FocusSearch::FindSelectedViewForGroup(View* view) {
 108   if (view->IsGroupFocusTraversable() ||
 109       view->GetGroup() == -1)  // No group for that view.
 110     return view;
 111
 112   View* selected_view = view->GetSelectedViewForGroup(view->GetGroup());
 113   if (selected_view)
 114     return selected_view;
 115
 116   // No view selected for that group, default to the specified view.
 117   return view;
 118 }
 119
 120 View* FocusSearch::GetParent(View* v) {
 121   return Contains(root_, v) ? v->parent() : NULL;
 122 }
 123
 124 bool FocusSearch::Contains(View* root, const View* v) {
 125   return root->Contains(v);
 126 }
 127
 128 // Strategy for finding the next focusable view:
 129 // - keep going down the first child, stop when you find a focusable view or
 130 //   a focus traversable view (in that case return it) or when you reach a view
 131 //   with no children.
 132 // - go to the right sibling and start the search from there (by invoking
 133 //   FindNextFocusableViewImpl on that view).
 134 // - if the view has no right sibling, go up the parents until you find a parent
 135 //   with a right sibling and start the search from there.
 136 View* FocusSearch::FindNextFocusableViewImpl(
 137     View* starting_view,
 138     bool check_starting_view,
 139     bool can_go_up,
 140     bool can_go_down,
 141     int skip_group_id,
 142     FocusTraversable** focus_traversable,
 143     View** focus_traversable_view) {
 144   if (check_starting_view) {
 145     if (IsViewFocusableCandidate(starting_view, skip_group_id)) {
 146       View* v = FindSelectedViewForGroup(starting_view);
 147       // The selected view might not be focusable (if it is disabled for
 148       // example).
 149       if (IsFocusable(v))
 150         return v;
 151     }
 152
 153     *focus_traversable = starting_view->GetFocusTraversable();
 154     if (*focus_traversable) {
 155       *focus_traversable_view = starting_view;
 156       return NULL;
 157     }
 158   }
 159
 160   // First let's try the left child.
 161   if (can_go_down) {
 162     if (starting_view->has_children()) {
 163       View* v = FindNextFocusableViewImpl(starting_view->child_at(0),
 164                                           true, false, true, skip_group_id,
 165                                           focus_traversable,
 166                                           focus_traversable_view);
 167       if (v || *focus_traversable)
 168         return v;
 169     }
 170   }
 171
 172   // Then try the right sibling.
 173   View* sibling = starting_view->GetNextFocusableView();
 174   if (sibling) {
 175     View* v = FindNextFocusableViewImpl(sibling,
 176                                         true, false, true, skip_group_id,
 177                                         focus_traversable,
 178                                         focus_traversable_view);
 179     if (v || *focus_traversable)
 180       return v;
 181   }
 182
 183   // Then go up to the parent sibling.
 184   if (can_go_up) {
 185     View* parent = GetParent(starting_view);
 186     while (parent && parent != root_) {
 187       sibling = parent->GetNextFocusableView();
 188       if (sibling) {
 189         return FindNextFocusableViewImpl(sibling,
 190                                          true, true, true,
 191                                          skip_group_id,
 192                                          focus_traversable,
 193                                          focus_traversable_view);
 194       }
 195       parent = GetParent(parent);
 196     }
 197   }
 198
 199   // We found nothing.
 200   return NULL;
 201 }
 202
 203 // Strategy for finding the previous focusable view:
 204 // - keep going down on the right until you reach a view with no children, if it
 205 //   it is a good candidate return it.
 206 // - start the search on the left sibling.
 207 // - if there are no left sibling, start the search on the parent (without going
 208 //   down).
 209 View* FocusSearch::FindPreviousFocusableViewImpl(
 210     View* starting_view,
 211     bool check_starting_view,
 212     bool can_go_up,
 213     bool can_go_down,
 214     int skip_group_id,
 215     FocusTraversable** focus_traversable,
 216     View** focus_traversable_view) {
 217   // Let's go down and right as much as we can.
 218   if (can_go_down) {
 219     // Before we go into the direct children, we have to check if this view has
 220     // a FocusTraversable.
 221     *focus_traversable = starting_view->GetFocusTraversable();
 222     if (*focus_traversable) {
 223       *focus_traversable_view = starting_view;
 224       return NULL;
 225     }
 226
 227     if (starting_view->has_children()) {
 228       View* view =
 229           starting_view->child_at(starting_view->child_count() - 1);
 230       View* v = FindPreviousFocusableViewImpl(view, true, false, true,
 231                                               skip_group_id,
 232                                               focus_traversable,
 233                                               focus_traversable_view);
 234       if (v || *focus_traversable)
 235         return v;
 236     }
 237   }
 238
 239   // Then look at this view. Here, we do not need to see if the view has
 240   // a FocusTraversable, since we do not want to go down any more.
 241   if (check_starting_view &&
 242       IsViewFocusableCandidate(starting_view, skip_group_id)) {
 243     View* v = FindSelectedViewForGroup(starting_view);
 244     // The selected view might not be focusable (if it is disabled for
 245     // example).
 246     if (IsFocusable(v))
 247       return v;
 248   }
 249
 250   // Then try the left sibling.
 251   View* sibling = starting_view->GetPreviousFocusableView();
 252   if (sibling) {
 253     return FindPreviousFocusableViewImpl(sibling,
 254                                          true, can_go_up, true,
 255                                          skip_group_id,
 256                                          focus_traversable,
 257                                          focus_traversable_view);
 258   }
 259
 260   // Then go up the parent.
 261   if (can_go_up) {
 262     View* parent = GetParent(starting_view);
 263     if (parent)
 264       return FindPreviousFocusableViewImpl(parent,
 265                                            true, true, false,
 266                                            skip_group_id,
 267                                            focus_traversable,
 268                                            focus_traversable_view);
 269   }
 270
 271   // We found nothing.
 272   return NULL;
 273 }
 274
 275 }  // namespace views