Rework tree APIs to reflect Google style and more const-correctness....

views/view.h

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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.
 
 #ifndef VIEWS_VIEW_H_
 #define VIEWS_VIEW_H_
 #pragma once
 
 #include "build/build_config.h"
 
 #include <algorithm>
@@ skipping 172 matching lines @@
   // be deleted by its parent.
   void set_parent_owned(bool is_parent_owned) {
     is_parent_owned_ = is_parent_owned;
   }
 
   // Return whether a view is owned by its parent.
   bool IsParentOwned() const { return is_parent_owned_; }
 
   // Tree operations -----------------------------------------------------------
 
-  // Add a child View.
-  void AddChildView(View* v);
+  // Get the Widget that hosts this View, if any.
+  virtual const Widget* GetWidget() const;
+  virtual Widget* GetWidget();
 
-  // Adds a child View at the specified position.
-  void AddChildView(int index, View* v);
+  // Add a child View, optionally at |index|.
+  void AddChildView(View* view);
+  void AddChildViewAt(View* view, size_t index);
 
-  // Get the child View at the specified index.
-  View* GetChildViewAt(int index) const;
-
-  // Remove a child view from this view. v's parent will change to NULL
-  void RemoveChildView(View *v);
+  // Remove a child view from this view. The view's parent will change to NULL.
+  void RemoveChildView(View* views);
 
   // Remove all child view from this view.  If |delete_views| is true, the views
   // are deleted, unless marked as not parent owned.
   void RemoveAllChildViews(bool delete_views);
 
+  // Returns the View at the specified |index|.
+  const View* GetChildViewAt(size_t index) const;
+  View* GetChildViewAt(size_t index);
+
   // Get the number of child Views.
-  int GetChildViewCount() const;
+  size_t child_count() const { return children_.size(); }
+  bool has_children() const { return !children_.empty(); }
 
-  // Tests if this view has a given view as direct child.
-  bool HasChildView(View* a_view);
+  // Get the parent View
+  const View* parent() const { return parent_; }
+  View* parent() { return parent_; }
 
-  // Get the Widget that hosts this View, if any.
-  virtual Widget* GetWidget() const;
+  // Returns true if |child| is contained within this View's hierarchy, even as
+  // an indirect descendant. Will return true if child is also this View.
+  bool Contains(const View* view) const;
 
+  // Returns the index of the specified |view| in this view's children, or -1
+  // if the specified view is not a child of this view.
+  size_t GetIndexOf(const View* view) const;

[sky, 2011/02/08 19:11:54]

This can never return -1 now. I'm inclined to think this should take the size_t
and return a bool. The other option is something like std::wstring::npos, which
is all to easy to forget to compare against.

PS I don't like size_t.

+
+  // TODO(beng): REMOVE (Views need not know about Window).
   // Gets the Widget that most closely contains this View, if any.
   // NOTE: almost all views displayed on screen have a Widget, but not
   // necessarily a Window. This is due to widgets being able to create top
   // level windows (as is done for popups, bubbles and menus).
-  virtual Window* GetWindow() const;
+  virtual const Window* GetWindow() const;
+  virtual Window* GetWindow();
 
+  // TODO(beng): REMOVE (TBD)
   // Returns true if the native view |native_view| is contained in the view
   // hierarchy beneath this view.
   virtual bool ContainsNativeView(gfx::NativeView native_view) const;
 
+  // TODO(beng): REMOVE (RootView->internal API)
   // Get the containing RootView
   virtual RootView* GetRootView();
 
-  // Get the parent View
-  View* GetParent() const { return parent_; }
-
-  // Returns the index of the specified |view| in this view's children, or -1
-  // if the specified view is not a child of this view.
-  int GetChildIndex(const View* v) const;
-
-  // Returns true if the specified view is a direct or indirect child of this
-  // view.
-  bool IsParentOf(View* v) const;
-
-#ifndef NDEBUG
-  // Debug method that logs the view hierarchy to the output.
-  void PrintViewHierarchy();
-
-  // Debug method that logs the focus traversal hierarchy to the output.
-  void PrintFocusHierarchy();
-#endif
-
   // Size and disposition ------------------------------------------------------
   // Methods for obtaining and modifying the position and size of the view.
   // Position is in the coordinate system of the view's parent.
   // Position is NOT flipped for RTL. See "RTL positioning" for RTL-sensitive
   // position accessors.
 
   void SetBounds(int x, int y, int width, int height);
   void SetBoundsRect(const gfx::Rect& bounds);
   void SetSize(const gfx::Size& size);
   void SetPosition(const gfx::Point& position);
@@ skipping 149 matching lines @@
   // subclass. The default implementation returns kViewClassName.
   virtual std::string GetClassName() const;
 
   // Returns the first ancestor, starting at this, whose class name is |name|.
   // Returns null if no ancestor has the class name |name|.
   View* GetAncestorWithClassName(const std::string& name);
 
   // Recursively descends the view tree starting at this view, and returns
   // the first child that it encounters that has the given ID.
   // Returns NULL if no matching child view is found.
-  virtual View* GetViewByID(int id) const;
+  virtual const View* GetViewByID(int id) const;
+  virtual View* GetViewByID(int id);
 
   // Sets and gets the ID for this view.  ID should be unique within the subtree
   // that you intend to search for it.  0 is the default ID for views.
   void SetID(int id);
   int GetID() const;
 
   // A group id is used to tag views which are part of the same logical group.
   // Focus can be moved between views with the same group using the arrow keys.
   // Groups are currently used to implement radio button mutual exclusion.
   // The group id is immutable once it's set.
@@ skipping 266 matching lines @@
     return false;
   }
 
   // Focus ---------------------------------------------------------------------
 
   // Returns whether this view currently has the focus.
   virtual bool HasFocus();
 
   // Returns the view that should be selected next when pressing Tab.
   View* GetNextFocusableView();
+  const View* GetNextFocusableView() const;
 
   // Returns the view that should be selected next when pressing Shift-Tab.
   View* GetPreviousFocusableView();
 
   // Sets the component that should be selected next when pressing Tab, and
   // makes the current view the precedent view of the specified one.
   // Note that by default views are linked in the order they have been added to
   // their container. Use this method if you want to modify the order.
   // IMPORTANT NOTE: loops in the focus hierarchy are not supported.
   void SetNextFocusableView(View* view);
@@ skipping 581 matching lines @@
 
   // Whether this view is owned by its parent.
   bool is_parent_owned_;
 
   // Tree operations -----------------------------------------------------------
 
   // This view's parent
   View* parent_;
 
   // This view's children.
-  typedef std::vector<View*> ViewList;
-  ViewList child_views_;
+  typedef std::vector<View*> ViewVector;

[sky, 2011/02/08 19:11:54]

all typedefs should be grouped together.

+  ViewVector children_;
 
   // Size and disposition ------------------------------------------------------
 
   // This View's bounds in the parent coordinate system.
   gfx::Rect bounds_;
 
   // Visible state
   bool is_visible_;
 
   // See SetNotifyWhenVisibleBoundsInRootChanges.
   bool notify_when_visible_bounds_in_root_changes_;
 
   // Whether or not RegisterViewForVisibleBoundsNotification on the RootView
   // has been invoked.
   bool registered_for_visible_bounds_notification_;
 
   // List of descendants wanting notification when their visible bounds change.
-  scoped_ptr<ViewList> descendants_to_notify_;
+  scoped_ptr<ViewVector> descendants_to_notify_;
 
   // Layout --------------------------------------------------------------------
 
   // Whether the view needs to be laid out.
   bool needs_layout_;
 
   // The View's LayoutManager defines the sizing heuristics applied to child
   // Views. The default is absolute positioning according to bounds_.
   scoped_ptr<LayoutManager> layout_manager_;
 
@@ skipping 53 matching lines @@
   // The accessibility implementation for this View.
   scoped_refptr<ViewAccessibility> view_accessibility_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(View);
 };
 
 }  // namespace views
 
 #endif  // VIEWS_VIEW_H_