Reorder

mojo/services/public/cpp/view_manager/lib/view_tree_node.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "mojo/services/public/cpp/view_manager/view_tree_node.h"
 
 #include "mojo/services/public/cpp/view_manager/lib/view_manager_synchronizer.h"
 #include "mojo/services/public/cpp/view_manager/lib/view_private.h"
 #include "mojo/services/public/cpp/view_manager/lib/view_tree_node_private.h"
 #include "mojo/services/public/cpp/view_manager/view.h"
@@ skipping 62 matching lines @@
 
 void RemoveChildImpl(ViewTreeNode* child, ViewTreeNode::Children* children) {
   ViewTreeNode::Children::iterator it =
       std::find(children->begin(), children->end(), child);
   if (it != children->end()) {
     children->erase(it);
     ViewTreeNodePrivate(child).ClearParent();
   }
 }
 
+class ScopedOrderChangedNotifier {
+ public:
+  ScopedOrderChangedNotifier(ViewTreeNode* node,
+                             ViewTreeNode* relative_node,
+                             OrderDirection direction)
+      : node_(node),
+        relative_node_(relative_node),
+        direction_(direction) {
+    FOR_EACH_OBSERVER(
+        ViewTreeNodeObserver,
+        *ViewTreeNodePrivate(node_).observers(),
+        OnNodeReordered(node_,
+                        relative_node_,
+                        direction_,
+                        ViewTreeNodeObserver::DISPOSITION_CHANGING));
+
+  }
+  ~ScopedOrderChangedNotifier() {
+    FOR_EACH_OBSERVER(
+        ViewTreeNodeObserver,
+        *ViewTreeNodePrivate(node_).observers(),
+        OnNodeReordered(node_,
+                        relative_node_,
+                        direction_,
+                        ViewTreeNodeObserver::DISPOSITION_CHANGED));
+  }
+
+ private:
+  ViewTreeNode* node_;
+  ViewTreeNode* relative_node_;
+  OrderDirection direction_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedOrderChangedNotifier);
+};
+
+// Returns true if the order actually changed.
+bool ReorderImpl(ViewTreeNode::Children* children,
+                 ViewTreeNode* node,
+                 ViewTreeNode* relative,
+                 OrderDirection direction) {
+  DCHECK(relative);
+  DCHECK_NE(node, relative);
+  DCHECK_EQ(node->parent(), relative->parent());
+
+  const size_t child_i =
+      std::find(children->begin(), children->end(), node) - children->begin();
+  const size_t target_i =
+      std::find(children->begin(), children->end(), relative) -
+      children->begin();
+  if ((direction == ORDER_ABOVE && child_i == target_i + 1) ||
+      (direction == ORDER_BELOW && child_i + 1 == target_i)) {
+    return false;
+  }
+
+  ScopedOrderChangedNotifier notifier(node, relative, direction);
+
+  const size_t dest_i =
+      direction == ORDER_ABOVE ?
+      (child_i < target_i ? target_i : target_i + 1) :
+      (child_i < target_i ? target_i - 1 : target_i);
+  children->erase(children->begin() + child_i);
+  children->insert(children->begin() + dest_i, node);
+
+  return true;
+}
+
 class ScopedSetActiveViewNotifier {
  public:
   ScopedSetActiveViewNotifier(ViewTreeNode* node,
                               View* old_view,
                               View* new_view)
       : node_(node),
         old_view_(old_view),
         new_view_(new_view) {
     FOR_EACH_OBSERVER(
         ViewTreeNodeObserver,
@@ skipping 138 matching lines @@
   //             embeddee in an embedder-embeddee relationship.
   if (manager_)
     CHECK_EQ(ViewTreeNodePrivate(child).view_manager(), manager_);
   LocalRemoveChild(child);
   if (manager_) {
     static_cast<ViewManagerSynchronizer*>(manager_)->RemoveChild(child->id(),
                                                                  id_);
   }
 }
 
+void ViewTreeNode::MoveToFront() {
+  Reorder(parent_->children_.back(), ORDER_ABOVE);
+}
+
+void ViewTreeNode::MoveToBack() {
+  Reorder(parent_->children_.front(), ORDER_BELOW);
+}
+
+void ViewTreeNode::Reorder(ViewTreeNode* relative, OrderDirection direction) {
+  if (!LocalReorder(relative, direction))
+    return;
+  if (manager_) {
+    static_cast<ViewManagerSynchronizer*>(manager_)->Reorder(id_,
+                                                             relative->id(),
+                                                             direction);
+  }
+}
+
 bool ViewTreeNode::Contains(ViewTreeNode* child) const {
   if (manager_)
     CHECK_EQ(ViewTreeNodePrivate(child).view_manager(), manager_);
   for (ViewTreeNode* p = child->parent(); p; p = p->parent()) {
     if (p == this)
       return true;
   }
   return false;
 }
 
@@ skipping 66 matching lines @@
   children_.push_back(child);
   child->parent_ = this;
 }
 
 void ViewTreeNode::LocalRemoveChild(ViewTreeNode* child) {
   DCHECK_EQ(this, child->parent());
   ScopedTreeNotifier notifier(child, this, NULL);
   RemoveChildImpl(child, &children_);
 }
 
+bool ViewTreeNode::LocalReorder(ViewTreeNode* relative,
+                                OrderDirection direction) {
+  return ReorderImpl(&parent_->children_, this, relative, direction);
+}
+
 void ViewTreeNode::LocalSetActiveView(View* view) {
   ScopedSetActiveViewNotifier notifier(this, active_view_, view);
   if (active_view_)
     ViewPrivate(active_view_).set_node(NULL);
   active_view_ = view;
   if (active_view_)
     ViewPrivate(active_view_).set_node(this);
 }
 
 void ViewTreeNode::LocalSetBounds(const gfx::Rect& old_bounds,
                                   const gfx::Rect& new_bounds) {
   DCHECK(old_bounds == bounds_);
   ScopedSetBoundsNotifier notifier(this, old_bounds, new_bounds);
   bounds_ = new_bounds;
 }
 
 }  // namespace view_manager
 }  // namespace mojo