Adds ability for tree model to reorder its children. I'm going to use...

chrome/views/tree_view.cc

 // Copyright (c) 2006-2008 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 "chrome/views/tree_view.h"
 
 #include <shellapi.h>
 
 #include "base/win_util.h"
 #include "chrome/common/gfx/chrome_canvas.h"
@@ skipping 221 matching lines @@
                    model_->GetChild(parent, i + start));
     }
   }
 }
 
 void TreeView::TreeNodesRemoved(TreeModel* model,
                                 TreeModelNode* parent,
                                 int start,
                                 int count) {
   DCHECK(parent && start >= 0 && count > 0);
-  if (node_to_details_map_.find(parent) == node_to_details_map_.end()) {
-    // User hasn't navigated to this entry yet. Ignore the change.
+  HTREEITEM parent_tree_item = GetTreeItemForNodeDuringMutation(parent);
+  if (!parent_tree_item)
     return;
-  }
-  HTREEITEM parent_tree_item = NULL;
-  if (!root_shown_ || parent != model_->GetRoot()) {
-    const NodeDetails* details = GetNodeDetails(parent);
-    if (!details->loaded_children) {
-      // Ignore the change, we haven't actually created entries in the tree
-      // for the children.
-      return;
-    }
-    parent_tree_item = details->tree_item;
-  } else {
-    parent_tree_item = TreeView_GetRoot(tree_view_);
-  }
+
   // Find the last item. Windows doesn't offer a convenient way to get the
   // TREEITEM at a particular index, so we iterate.
   HTREEITEM tree_item = TreeView_GetChild(tree_view_, parent_tree_item);
   for (int i = 0; i < (start + count - 1); ++i) {
     tree_item = TreeView_GetNextSibling(tree_view_, tree_item);
   }
   // NOTE: the direction doesn't matter here. I've made it backwards to
   // reinforce we're deleting from the end forward.
   for (int i = count - 1; i >= 0; --i) {
     HTREEITEM previous = (start + i) > 0 ?
         TreeView_GetPrevSibling(tree_view_, tree_item) : NULL;
     RecursivelyDelete(GetNodeDetailsByTreeItem(tree_item));
     tree_item = previous;
   }
 }
 
+namespace {
+
+// Callback function used to compare two items. The first two args are the
+// LPARAMs of the HTREEITEMs being compared. The last arg maps from LPARAM
+// to order. This is invoked from TreeNodeChildrenReordered.
+int CALLBACK CompareTreeItems(LPARAM item1_lparam,
+                              LPARAM item2_lparam,
+                              LPARAM map_as_lparam) {
+  std::map<int, int>& mapping =
+      *reinterpret_cast<std::map<int, int>*>(map_as_lparam);
+  return mapping[static_cast<int>(item1_lparam)] -
+         mapping[static_cast<int>(item2_lparam)];
+}
+
+}  // namespace
+
+void TreeView::TreeNodeChildrenReordered(TreeModel* model,
+                                         TreeModelNode* parent) {
+  DCHECK(parent);
+  if (model_->GetChildCount(parent) <= 1)
+    return;
+
+  TVSORTCB sort_details;
+  sort_details.hParent = GetTreeItemForNodeDuringMutation(parent);
+  if (!sort_details.hParent)
+    return;
+
+  std::map<int, int> lparam_to_order_map;
+  for (int i = 0; i < model_->GetChildCount(parent); ++i) {
+    TreeModelNode* node = model_->GetChild(parent, i);
+    lparam_to_order_map[GetNodeDetails(node)->id] = i;
+  }
+
+  sort_details.lpfnCompare = &CompareTreeItems;
+  sort_details.lParam = reinterpret_cast<LPARAM>(&lparam_to_order_map);
+  TreeView_SortChildrenCB(tree_view_, &sort_details, 0);
+}
+
 void TreeView::TreeNodeChanged(TreeModel* model, TreeModelNode* node) {
   if (node_to_details_map_.find(node) == node_to_details_map_.end()) {
     // User hasn't navigated to this entry yet. Ignore the change.
     return;
   }
   const NodeDetails* details = GetNodeDetails(node);
   TV_ITEM tv_item = {0};
   tv_item.mask = TVIF_TEXT;
   tv_item.hItem = details->tree_item;
   tv_item.pszText = LPSTR_TEXTCALLBACK;
@@ skipping 331 matching lines @@
     DestroyIcon(h_opened_icon);
     for (size_t i = 0; i < model_images.size(); ++i) {
       HICON model_icon = IconUtil::CreateHICONFromSkBitmap(model_images[i]);
       ImageList_AddIcon(image_list, model_icon);
       DestroyIcon(model_icon);
     }
   }
   return image_list;
 }
 
+HTREEITEM TreeView::GetTreeItemForNodeDuringMutation(TreeModelNode* node) {
+  if (node_to_details_map_.find(node) == node_to_details_map_.end()) {
+    // User hasn't navigated to this entry yet. Ignore the change.
+    return NULL;
+  }
+  if (!root_shown_ || node != model_->GetRoot()) {
+    const NodeDetails* details = GetNodeDetails(node);
+    if (!details->loaded_children)
+      return NULL;
+    return details->tree_item;
+  }
+  return TreeView_GetRoot(tree_view_);
+}
+
 LRESULT CALLBACK TreeView::TreeWndProc(HWND window,
                                        UINT message,
                                        WPARAM w_param,
                                        LPARAM l_param) {
   TreeViewWrapper* wrapper = reinterpret_cast<TreeViewWrapper*>(
       GetWindowLongPtr(window, GWLP_USERDATA));
   DCHECK(wrapper);
   TreeView* tree = wrapper->tree_view;
 
   // We handle the messages WM_ERASEBKGND and WM_PAINT such that we paint into
@@ skipping 59 matching lines @@
       }
       // Fall through and let the default handler process as well.
       break;
   }
   WNDPROC handler = tree->original_handler_;
   DCHECK(handler);
   return CallWindowProc(handler, window, message, w_param, l_param);
 }
 
 }  // namespace views