ui/wm/core/transient_window_stacking_client.cc

   1 // Copyright (c) 2013 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/wm/core/transient_window_stacking_client.h"
   6
   7 #include <algorithm>
   8
   9 #include "ui/wm/core/transient_window_manager.h"
  10 #include "ui/wm/core/window_util.h"
  11
  12 using aura::Window;
  13
  14 namespace wm {
  15
  16 namespace {
  17
  18 // Populates |ancestors| with all transient ancestors of |window| that are
  19 // siblings of |window|. Returns true if any ancestors were found, false if not.
  20 bool GetAllTransientAncestors(Window* window, Window::Windows* ancestors) {
  21   Window* parent = window->parent();
  22   for (; window; window = GetTransientParent(window)) {
  23     if (window->parent() == parent)
  24       ancestors->push_back(window);
  25   }
  26   return (!ancestors->empty());
  27 }
  28
  29 // Replaces |window1| and |window2| with their possible transient ancestors that
  30 // are still siblings (have a common transient parent).  |window1| and |window2|
  31 // are not modified if such ancestors cannot be found.
  32 void FindCommonTransientAncestor(Window** window1, Window** window2) {
  33   DCHECK(window1);
  34   DCHECK(window2);
  35   DCHECK(*window1);
  36   DCHECK(*window2);
  37   // Assemble chains of ancestors of both windows.
  38   Window::Windows ancestors1;
  39   Window::Windows ancestors2;
  40   if (!GetAllTransientAncestors(*window1, &ancestors1) ||
  41       !GetAllTransientAncestors(*window2, &ancestors2)) {
  42     return;
  43   }
  44   // Walk the two chains backwards and look for the first difference.
  45   Window::Windows::reverse_iterator it1 = ancestors1.rbegin();
  46   Window::Windows::reverse_iterator it2 = ancestors2.rbegin();
  47   for (; it1  != ancestors1.rend() && it2  != ancestors2.rend(); ++it1, ++it2) {
  48     if (*it1 != *it2) {
  49       *window1 = *it1;
  50       *window2 = *it2;
  51       break;
  52     }
  53   }
  54 }
  55
  56 // Adjusts |target| so that we don't attempt to stack on top of a window with a
  57 // NULL delegate.
  58 void SkipNullDelegates(Window::StackDirection direction, Window** target) {
  59   const Window::Windows& children((*target)->parent()->children());
  60   size_t target_i =
  61       std::find(children.begin(), children.end(), *target) -
  62       children.begin();
  63
  64   // By convention we don't stack on top of windows with layers with NULL
  65   // delegates.  Walk backward to find a valid target window.  See tests
  66   // TransientWindowManagerTest.StackingMadrigal and StackOverClosingTransient
  67   // for an explanation of this.
  68   while (target_i > 0) {
  69     const size_t index = direction == Window::STACK_ABOVE ?
  70         target_i : target_i - 1;
  71     if (!children[index]->layer() ||
  72         children[index]->layer()->delegate() != NULL)
  73       break;
  74     --target_i;
  75   }
  76   *target = children[target_i];
  77 }
  78
  79 }  // namespace
  80
  81 // static
  82 TransientWindowStackingClient* TransientWindowStackingClient::instance_ = NULL;
  83
  84 TransientWindowStackingClient::TransientWindowStackingClient() {
  85   instance_ = this;
  86 }
  87
  88 TransientWindowStackingClient::~TransientWindowStackingClient() {
  89   if (instance_ == this)
  90     instance_ = NULL;
  91 }
  92
  93 bool TransientWindowStackingClient::AdjustStacking(
  94     Window** child,
  95     Window** target,
  96     Window::StackDirection* direction) {
  97   const TransientWindowManager* transient_manager =
  98       TransientWindowManager::Get(static_cast<const Window*>(*child));
  99   if (transient_manager && transient_manager->IsStackingTransient(*target))
 100     return true;
 101
 102   // For windows that have transient children stack the transient ancestors that
 103   // are siblings. This prevents one transient group from being inserted in the
 104   // middle of another.
 105   FindCommonTransientAncestor(child, target);
 106
 107   // When stacking above skip to the topmost transient descendant of the target.
 108   if (*direction == Window::STACK_ABOVE &&
 109       !HasTransientAncestor(*child, *target)) {
 110     const Window::Windows& siblings((*child)->parent()->children());
 111     size_t target_i =
 112         std::find(siblings.begin(), siblings.end(), *target) - siblings.begin();
 113     while (target_i + 1 < siblings.size() &&
 114            HasTransientAncestor(siblings[target_i + 1], *target)) {
 115       ++target_i;
 116     }
 117     *target = siblings[target_i];
 118   }
 119
 120   SkipNullDelegates(*direction, target);
 121
 122   // If we couldn't find a valid target position, don't move anything.
 123   if (*direction == Window::STACK_ABOVE &&
 124       ((*target)->layer() && (*target)->layer()->delegate() == NULL)) {
 125     return false;
 126   }
 127
 128   return *child != *target;
 129 }
 130
 131 }  // namespace wm