Variety of tweaks to View API.

views/view.h

 // 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"
 
@@ skipping 166 matching lines @@
   // TODO(beng): Figure out what these methods are for and delete them.
 
   // TODO(beng): this one isn't even google3-style. wth.
   virtual Widget* child_widget();
 
   // Creation and lifetime -----------------------------------------------------
 
   View();
   virtual ~View();
 
-  // Set whether this view is owned by its parent. A view that is owned by its
-  // parent is automatically deleted when the parent is deleted. The default is
-  // true. Set to false if the view is owned by another object and should not
-  // 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_; }
+  // By default a View is owned by its parent unless specified otherwise here.
+  bool parent_owned() const { return parent_owned_; }
+  void set_parent_owned(bool parent_owned) { parent_owned_ = parent_owned; }
 
   // Tree operations -----------------------------------------------------------
 
   // Get the Widget that hosts this View, if any.
   virtual const Widget* GetWidget() const;
   virtual Widget* GetWidget();
 
+  // Returns the containing Window. Although Window is a Widget subclass, this
+  // function may not return the same value as GetWidget() above since this View
+  // may be a child of a Widget nested within a Window. This function will
+  // return the nearest containing Window in the Widget hierarchy. The View may
+  // not be contained in a Window Widget, in which case this function will
+  // return NULL.
+  virtual const Window* GetWindow() const;
+  virtual Window* GetWindow();
+
   // Add a child View, optionally at |index|.
   void AddChildView(View* view);
   void AddChildViewAt(View* view, int index);
 
   // 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);
@@ skipping 11 matching lines @@
   View* parent() { return parent_; }
 
   // 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.
   int GetIndexOf(const View* view) const;
 
-  // 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 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;
 
   // 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.
@@ skipping 37 matching lines @@
   // therefore it will return the mirrored version of the visible bounds if
   // need be.
   // TODO(beng): const.
   gfx::Rect GetVisibleBounds();
 
   // Return the bounds of the View in screen coordinate system.
   gfx::Rect GetScreenBounds() const;
 
   // Returns the baseline of this view, or -1 if this view has no baseline. The
   // return value is relative to the preferred height.
+  // TODO(beng): const
   virtual int GetBaseline();
 
   // Get the size the View would like to be, if enough space were available.
   virtual gfx::Size GetPreferredSize();
 
   // Convenience method that sizes this view to its preferred size.
   void SizeToPreferredSize();
 
   // Gets the minimum size of the view. View's implementation invokes
   // GetPreferredSize.
   virtual gfx::Size GetMinimumSize();
 
   // Return the height necessary to display this view with the provided width.
   // View's implementation returns the value from getPreferredSize.cy.
   // Override if your View's preferred height depends upon the width (such
   // as with Labels).
   virtual int GetHeightForWidth(int w);
 
-  // Set whether the receiving view is visible. Painting is scheduled as needed
-  virtual void SetVisible(bool flag);
-
-  // Return whether a view is visible
-  virtual bool IsVisible() const;
-
-  // Return whether a view and its ancestors are visible. Returns true if the
-  // path from this view to the root view is visible.
-  virtual bool IsVisibleInRootView() const;
-
-  // Set whether this view is enabled. A disabled view does not receive keyboard
-  // or mouse inputs. If flag differs from the current value, SchedulePaint is
-  // invoked.
-  virtual void SetEnabled(bool flag);
-
-  // Returns whether the view is enabled.
-  virtual bool IsEnabled() const;
-
   // Transformations -----------------------------------------------------------
 
   // Methods for setting transformations for a view (e.g. rotation, scaling).
 
   const ui::Transform& GetTransform() const;
 
   // Clipping parameters. Clipping happens from the right and/or bottom. The
   // clipping amount is in parent's coordinate system, as in, if the view is
   // rotated, then the clipping will be applied after the rotation (and other
   // transformations, if any).
@@ skipping 64 matching lines @@
 
   // Gets/Sets the Layout Manager used by this view to size and place its
   // children.
   // The LayoutManager is owned by the View and is deleted when the view is
   // deleted, or when a new LayoutManager is installed.
   LayoutManager* GetLayoutManager() const;
   void SetLayoutManager(LayoutManager* layout);
 
   // Attributes ----------------------------------------------------------------
 
+  // If a View is not visible, it will not be painted, focusable, etc.
+  bool visible() const { return visible_; }
+  // TODO(beng): Should not be virtual. ExtensionView, AccessiblePaneView.
+  virtual void SetVisible(bool flag);
+
+  // Return whether a view and its ancestors are visible. Returns true if the
+  // path from this view to the root view is visible.
+  // TODO(beng): Consider replacing visible() with this, since it is a more
+  //             reliable test of View visibility.
+  virtual bool IsVisibleInRootView() const;
+
+  // Disabled Views will not receive mouse press or release events, and will not
+  // be focused.
+  // TODO(beng): This method should not be virtual and instead be a simple
+  //             accessor.
+  virtual bool IsEnabled() const;
+  // TODO(beng): This method should not be virtual. Those methods overriding
+  //             this should receive a state notification change instead.
+  virtual void SetEnabled(bool enabled);
+
   // The view class name.
   static char kViewClassName[];
 
   // Return the receiving view's class name. A view class is a string which
   // uniquely identifies the view class. It is intended to be used as a way to
   // find out during run time if a view can be safely casted to a specific view
   // 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 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;
+  int id() const { return id_; }
+  void set_id(int id) { id_ = id; }
 
-  // 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.
-  void SetGroup(int gid);
-  // Returns the group id of the view, or -1 if the id is not set yet.
-  int GetGroup() const;
+  // A group id is used to tag views which are part of the same logical control
+  // 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 defaults to -1 for all Views and is immutable once set.
+  int group() const { return group_; }
+  void set_group(int group);
 
   // If this returns true, the views from the same group can each be focused
   // when moving focus with the Tab/Shift-Tab key.  If this returns false,
   // only the selected view from the group (obtained with
   // GetSelectedViewForGroup()) is focused.
   virtual bool IsGroupFocusTraversable() const;
 
   // Fills the provided vector with all the available views which belong to the
   // provided group.
-  void GetViewsWithGroup(int group_id, std::vector<View*>* out);
+  void GetViewsInGroup(int group, std::vector<View*>* out);
 
   // Return the View that is currently selected in the specified group.
   // The default implementation simply returns the first View found for that
   // group.
-  virtual View* GetSelectedViewForGroup(int group_id);
+  virtual View* GetSelectedViewForGroup(int group);
 
   // Coordinate conversion -----------------------------------------------------
 
   // Note that the utility coordinate conversions functions always operate on
   // the mirrored position of the child Views if the parent View uses a
   // right-to-left UI layout.
 
   // Convert a point from source coordinate system to dst coordinate system.
   //
   // |src| and |dst| needs to be in the same widget, but doesn't need to be in
@@ skipping 240 matching lines @@
   // 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);
 
   // Sets whether this view can accept the focus.
   // Note that this is false by default so that a view used as a container does
   // not get the focus.
-  virtual void SetFocusable(bool focusable);
+  void set_focusable(bool focusable) { focusable_ = focusable; }
 
   // Returns true if the view is focusable (IsFocusable) and visible in the root
   // view. See also IsFocusable.
   bool IsFocusableInRootView() const;
 
   // Return whether this view is focusable when the user requires full keyboard
   // access, even though it may not be normally focusable.
   bool IsAccessibilityFocusableInRootView() const;
 
   // Set whether this view can be made focusable if the user requires
@@ skipping 421 matching lines @@
   // Removes |view| from the hierarchy tree.  If |update_focus_cycle| is true,
   // the next and previous focusable views of views pointing to this view are
   // updated.  If |update_tool_tip| is true, the tooltip is updated.  If
   // |delete_removed_view| is true, the view is also deleted (if it is parent
   // owned).
   void DoRemoveChildView(View* view,
                          bool update_focus_cycle,
                          bool update_tool_tip,
                          bool delete_removed_view);
 
-  // Sets the parent View. This is called automatically by AddChild and is
-  // thus private.
-  void SetParent(View* parent);
-
   // Call ViewHierarchyChanged for all child views on all parents
   void PropagateRemoveNotifications(View* parent);
 
   // Call ViewHierarchyChanged for all children
   void PropagateAddNotifications(View* parent, View* child);
 
   // Propagates NativeViewHierarchyChanged() notification through all the
   // children.
   void PropagateNativeViewHierarchyChanged(bool attached,
                                            gfx::NativeView native_view,
@@ skipping 134 matching lines @@
   // to a file to compile/view.
   // Note: Assumes initial call made with first = true.
   std::string PrintViewGraph(bool first);
 #endif
 
   //////////////////////////////////////////////////////////////////////////////
 
   // Creation and lifetime -----------------------------------------------------
 
   // Whether this view is owned by its parent.
-  bool is_parent_owned_;
+  bool parent_owned_;
 
   // Tree operations -----------------------------------------------------------
 
   // This view's parent
   View* parent_;
 
   // This view's children.
   typedef std::vector<View*> ViewVector;
   ViewVector children_;
 
   // Size and disposition ------------------------------------------------------
 
   // This View's bounds in the parent coordinate system.
   gfx::Rect bounds_;
 
   // Visible state
-  bool is_visible_;
+  bool visible_;
 
   // 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<ViewVector> descendants_to_notify_;
 
   // Transformations -----------------------------------------------------------
 
@@ skipping 89 matching lines @@
   // The Windows-specific accessibility implementation for this View.
   scoped_refptr<NativeViewAccessibilityWin> native_view_accessibility_win_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(View);
 };
 
 }  // namespace views
 
 #endif  // VIEWS_VIEW_H_