ui/views/view.h - Issue 6541030: View API/implementation cleanup:...

Unified Diff: ui/views/view.h

Issue 6541030: View API/implementation cleanup:... (Closed) Base URL: svn://chrome-svn/chrome/trunk/src/

Patch Set: Created 9 years, 10 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: ui/views/view.h

===================================================================

--- ui/views/view.h (revision 75141)

+++ ui/views/view.h (working copy)

@@ -39,7 +39,7 @@

class Widget;

////////////////////////////////////////////////////////////////////////////////

-// View class

+// View

// View encapsulates rendering, layout and event handling for rectangles within

// a view hierarchy.

@@ -54,9 +54,10 @@

// TODO(beng): consider the visibility of many of these methods.

// consider making RootView a friend and making many private or

// protected.

class View {

public:

- typedef std::vector<View*> ViewVector;

+ typedef std::vector<View*> Views;

// Creation and lifetime -----------------------------------------------------

View();

@@ -72,25 +73,28 @@

// Size and disposition ------------------------------------------------------

- 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);

gfx::Rect bounds() const { return bounds_; }

+ // TODO(pkasting): How is this different than bounds()?

Ben Goodger (Google) 2011/02/18 19:02:28 This returns the visible bounds of the view in the

Peter Kasting 2011/02/18 19:09:43 I updated the comment to try and capture that.

gfx::Rect GetVisibleBounds() const;

- int x() const { return bounds_.x(); }

- int y() const { return bounds_.y(); }

- int width() const { return bounds_.width(); }

- int height() const { return bounds_.height(); }

+ // Returns the bounds of the content area of the view, i.e. the rectangle

+ // enclosed by the view's border.

+ gfx::Rect GetContentsBounds() const;

+ void SetBounds(const gfx::Rect& bounds);

+ gfx::Point origin() const { return bounds().origin(); }

+ int x() const { return bounds().x(); }

+ int y() const { return bounds().y(); }

+ void SetOrigin(const gfx::Point& origin);

+ gfx::Size size() const { return bounds().size(); }

+ int width() const { return bounds().width(); }

+ int height() const { return bounds().height(); }

+ void SetSize(const gfx::Size& size);

// Owned by the view.

+ Border* border() { return border_.get(); }

void SetBorder(Border* border);

- Border* border() { return border_.get(); }

- // Returns the bounds of the content area of the view, i.e. the rectangle

- // enclosed by the view's border.

- gfx::Rect GetContentsBounds() const;

// Override to be notified when the bounds of a view have changed.

virtual void OnBoundsChanged();

@@ -118,11 +122,11 @@

// Returns the View within this View's hierarchy whose id matches that

// specified.

- View* GetViewById(int id) const;

+ View* GetViewByID(int id);

- // Populates a ViewVector with the Views within this View's hierarchy that

- // match the specified group id.

- void GetViewsWithGroup(int group, ViewVector* vec) const;

+ // Populates |vec| with the Views within this View's hierarchy that match the

+ // specified group id.

+ void GetViewsInGroup(int group, Views* vec);

// TODO(beng): implementme

virtual View* GetSelectedViewForGroup(int group_id);

@@ -130,46 +134,58 @@

// Coordinate conversion -----------------------------------------------------

// Converts a point from the coordinate system of |source| to |target|.

- static void ConvertPointToView(View* source, View* target, gfx::Point* point);

+ static void ConvertPointToView(const View& source,

+ const View& target,

+ gfx::Point* point);

// Converts a point from the coordinate system of |source| to the screen.

// If |source| is not attached to a Widget that is in screen space, |point| is

// not modified.

- static void ConvertPointToScreen(View* source, gfx::Point* point);

+ static void ConvertPointToScreen(const View& source, gfx::Point* point);

// Converts a point from the coordinate system of |source| to the Widget that

// most closely contains it.

- static void ConvertPointToWidget(View* source, gfx::Point* point);

+ static void ConvertPointToWidget(const View& source, gfx::Point* point);

// Tree operations -----------------------------------------------------------

// Returns the Widget that contains this View, or NULL if it is not contained

// within a Widget.

- virtual Widget* GetWidget() const;

+ Widget* GetWidget() {

+ return const_cast<Widget*>(static_cast<const View*>(this)->GetWidget());

+ }

+ virtual const Widget* GetWidget() const;

// Adds a View as a child of this one, optionally at |index|.

void AddChildView(View* view);

void AddChildViewAt(View* view, size_t index);

- // Removes a View as a child of this View. Does not delete the child.

- View* RemoveChildView(View* view);

+ // If |view| is a child of this View, removes it and optionally deletes it.

+ void RemoveChildView(View* view, bool delete_child);

// Removes all View children of this View. Deletes the children if

// |delete_children| is true.

void RemoveAllChildViews(bool delete_children);

- // Returns the View at the specified |index|.

- View* GetChildViewAt(size_t index);

+ // STL-style accessors.

+ Views::const_iterator children_begin() { return children_.begin(); }

+ Views::const_iterator children_end() { return children_.end(); }

+ Views::const_reverse_iterator children_rbegin() { return children_.rbegin(); }

+ Views::const_reverse_iterator children_rend() { return children_.rend(); }

+ size_t children_size() const { return children_.size(); }

+ bool children_empty() const { return children_.empty(); }

+ View* child_at(size_t index) {

+ DCHECK_LT(index, children_size());

+ return children_[index];

+ }

- // Returns the number of child views.

- size_t child_count() const { return children_.size(); }

// Returns the parent View, or NULL if this View has no parent.

- View* parent() const { return parent_; }

+ View* parent() { return parent_; }

+ const View* parent() const { 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(View* child);

+ bool Contains(const View& child) const;

// Painting ------------------------------------------------------------------

@@ -195,16 +211,17 @@

// Focus ---------------------------------------------------------------------

// Manager.

- FocusManager* GetFocusManager() const;

+ FocusManager* GetFocusManager();

+ const FocusManager* GetFocusManager() const;

// Traversal.

- virtual FocusTraversable* GetFocusTraversable() const;

- View* GetNextFocusableView() const;

- View* GetPreviousFocusableView() const;

+ virtual FocusTraversable* GetFocusTraversable();

+ View* GetNextFocusableView();

+ View* GetPreviousFocusableView();

// Attributes.

+ bool is_focusable() const { return focusable_ && enabled_ && visible_; }

Ben Goodger (Google) 2011/02/18 19:02:28 This actually needs to be more complex in reality.

Peter Kasting 2011/02/18 19:09:43 Changed back to a non-inline function.

void set_focusable(bool focusable) { focusable_ = focusable; }

- bool IsFocusable() const;

bool HasFocus() const;

void RequestFocus();

@@ -218,16 +235,18 @@

// Resources -----------------------------------------------------------------

- ThemeProvider* GetThemeProvider() const;

+ ThemeProvider* GetThemeProvider();

protected:

// Tree operations -----------------------------------------------------------

- // Called on every view in the hierarchy when a view is added or removed.

- virtual void OnViewAdded(View* parent, View* child);

- virtual void OnViewRemoved(View* parent, View* child);

+ // Called on every view in |parent|'s and |child|'s hierarchies, as well as

+ // ancestors, when |child| is added to or removed from |parent|.

+ virtual void OnViewAdded(const View& parent, const View& child);

+ virtual void OnViewRemoved(const View& parent, const View& child);

- // Called on a View when it is added or removed from a Widget.

+ // Called on a View when it is part of a hierarchy that has been added to or

+ // removed from a Widget.

virtual void OnViewAddedToWidget();

virtual void OnViewRemovedFromWidget();

@@ -262,9 +281,9 @@

// locate views for event targeting. Override this function if you wish to

// specify a view other than the one most closely enclosing |point| to receive

// notifications for events within it.

- virtual View* GetEventHandlerForPoint(const gfx::Point& point) const;

+ virtual View* GetEventHandlerForPoint(const gfx::Point& point);

- virtual gfx::NativeCursor GetCursorForPoint(const gfx::Point& point);

+ virtual gfx::NativeCursor GetCursorForPoint(const gfx::Point& point) const;

virtual bool OnKeyPressed(const KeyEvent& event);

virtual bool OnKeyReleased(const KeyEvent& event);

@@ -290,7 +309,7 @@

// TODO(beng): kill these, move to focus manager.

virtual bool IsFocusableInRootView() const;

virtual bool IsAccessibilityFocusableInRootView() const;

- virtual FocusTraversable* GetPaneFocusTraversable() const;

+ virtual FocusTraversable* GetPaneFocusTraversable();

virtual void OnFocus(const FocusEvent& event);

virtual void OnBlur(const FocusEvent& event);

@@ -320,13 +339,21 @@

};

// Tree operations -----------------------------------------------------------

- void NotifyHierarchyChanged(View* parent, View* child, bool is_add);

- void NotifyHierarchyChangedUp(View* parent, View* child, bool is_add);

- void NotifyHierarchyChangedDown(View* parent, View* child, bool is_add,

+ // Notifies all views in our and |child|'s hierarchies, as well as ancestors,

+ // that |child| was added to or removed from |this|.

+ void NotifyHierarchyChanged(View* child, bool is_add);

+ // Notifies all views in our hierarchy that |child| was added to or removed

Ben Goodger (Google) 2011/02/18 19:02:28 if

Peter Kasting 2011/02/18 19:09:43 No, I really meant iff ("if and only if").

+ void NotifyHierarchyChangedDown(const View& child,

+ bool is_add,

bool has_widget);

+ // |has_widget| is true iff |this| is in a widget.

void CallViewNotification(View* target,

- View* parent,

- View* child,

+ const View& child,

bool is_add,

bool has_widget);

@@ -338,7 +365,8 @@

// the hierarchy beneath it.

void Paint(gfx::Canvas* canvas);

- // Input --------------------------------------------------------------

+ // Input ---------------------------------------------------------------------

// These methods are designed to be called by the RootView. The RootView

// should limit its interaction with the View to these methods and the public

// API.

@@ -354,6 +382,7 @@

void InitFocusSiblings(View* child, size_t index);

// Drag & Drop ---------------------------------------------------------------

int GetDragOperations(const gfx::Point& point);

void WriteDragData(const gfx::Point& point, OSExchangeData* data);

void StartShellDrag(const MouseEvent& event, const gfx::Point& press_point);

@@ -399,7 +428,7 @@

View* parent_;

// The View's children.

- ViewVector children_;

+ Views children_;

// Focus ---------------------------------------------------------------------

« no previous file with comments | « no previous file | ui/views/view.cc » ('j') | ui/views/view.cc » ('J')