Move src/chrome/views to src/views. RS=darin http://crbug.com/11387
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@15604 0039d316-1c4b-4281-b951-d872f2087c98
diff --git a/views/view.h b/views/view.h
new file mode 100644
index 0000000..d2d8e52
--- /dev/null
+++ b/views/view.h
@@ -0,0 +1,1351 @@
+// 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.
+
+#ifndef VIEWS_VIEW_H_
+#define VIEWS_VIEW_H_
+
+#include "build/build_config.h"
+
+#if defined(OS_WIN)
+#include <atlbase.h>
+#include <atlapp.h>
+#include <atlmisc.h>
+#endif // defined(OS_WIN)
+
+#include <algorithm>
+#include <map>
+#include <string>
+#include <vector>
+
+#include "base/gfx/rect.h"
+#include "base/scoped_ptr.h"
+#include "chrome/common/accessibility_types.h"
+#include "views/accelerator.h"
+#include "views/background.h"
+#include "views/border.h"
+
+namespace gfx {
+class Insets;
+class Path;
+}
+
+class ChromeCanvas;
+class OSExchangeData;
+class ViewAccessibilityWrapper;
+
+namespace views {
+
+class Background;
+class Border;
+class FocusManager;
+class FocusTraversable;
+class LayoutManager;
+class RestoreFocusTask;
+class RootView;
+class ScrollView;
+class Widget;
+class Window;
+
+// ContextMenuController is responsible for showing the context menu for a
+// View. To use a ContextMenuController invoke SetContextMenuController on a
+// View. When the appropriate user gesture occurs ShowContextMenu is invoked
+// on the ContextMenuController.
+//
+// Setting a ContextMenuController on a view makes the view process mouse
+// events.
+//
+// It is up to subclasses that do their own mouse processing to invoke
+// the appropriate ContextMenuController method, typically by invoking super's
+// implementation for mouse processing.
+//
+class ContextMenuController {
+ public:
+ // Invoked to show the context menu for the source view. If is_mouse_gesture
+ // is true, the x/y coordinate are the location of the mouse. If
+ // is_mouse_gesture is false, this method was not invoked by a mouse gesture
+ // and x/y is the recommended location to show the menu at.
+ //
+ // x/y is in screen coordinates.
+ virtual void ShowContextMenu(View* source,
+ int x,
+ int y,
+ bool is_mouse_gesture) = 0;
+};
+
+// DragController is responsible for writing drag data for a view, as well as
+// supplying the supported drag operations. Use DragController if you don't
+// want to subclass.
+
+class DragController {
+ public:
+ // Writes the data for the drag.
+ virtual void WriteDragData(View* sender,
+ int press_x,
+ int press_y,
+ OSExchangeData* data) = 0;
+
+ // Returns the supported drag operations (see DragDropTypes for possible
+ // values). A drag is only started if this returns a non-zero value.
+ virtual int GetDragOperations(View* sender, int x, int y) = 0;
+};
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// View class
+//
+// A View is a rectangle within the views View hierarchy. It is the base
+// class for all Views.
+//
+// A View is a container of other Views (there is no such thing as a Leaf
+// View - makes code simpler, reduces type conversion headaches, design
+// mistakes etc)
+//
+// The View contains basic properties for sizing (bounds), layout (flex,
+// orientation, etc), painting of children and event dispatch.
+//
+// The View also uses a simple Box Layout Manager similar to XUL's
+// SprocketLayout system. Alternative Layout Managers implementing the
+// LayoutManager interface can be used to lay out children if required.
+//
+// It is up to the subclass to implement Painting and storage of subclass -
+// specific properties and functionality.
+//
+/////////////////////////////////////////////////////////////////////////////
+class View : public AcceleratorTarget {
+ public:
+
+ // Used in EnumerateFloatingViews() to specify which floating view to
+ // retrieve.
+ enum FloatingViewPosition {
+ FIRST = 0,
+ NEXT,
+ PREVIOUS,
+ LAST,
+ CURRENT
+ };
+
+ // Used in the versions of GetBounds() and x() that take a transformation
+ // parameter in order to determine whether or not to take into account the
+ // mirroring setting of the View when returning bounds positions.
+ enum PositionMirroringSettings {
+ IGNORE_MIRRORING_TRANSFORMATION = 0,
+ APPLY_MIRRORING_TRANSFORMATION
+ };
+
+ // The view class name.
+ static char kViewClassName[];
+
+ View();
+ virtual ~View();
+
+ // Sizing functions
+
+ // Get the bounds of the View, relative to the parent. Essentially, this
+ // function returns the bounds_ rectangle.
+ //
+ // This is the function subclasses should use whenever they need to obtain
+ // the bounds of one of their child views (for example, when implementing
+ // View::Layout()).
+ // TODO(beng): Convert |bounds_| to a gfx::Rect.
+ gfx::Rect bounds() const { return bounds_; }
+
+ // Get the size of the View.
+ gfx::Size size() const { return bounds_.size(); }
+
+ // Return the bounds of the View, relative to the parent. If
+ // |settings| is IGNORE_MIRRORING_TRANSFORMATION, the function returns the
+ // bounds_ rectangle. If |settings| is APPLY_MIRRORING_SETTINGS AND the
+ // parent View is using a right-to-left UI layout, then the function returns
+ // a shifted version of the bounds_ rectangle that represents the mirrored
+ // View bounds.
+ //
+ // NOTE: in the vast majority of the cases, the mirroring implementation is
+ // transparent to the View subclasses and therefore you should use the
+ // version of GetBounds() which does not take a transformation settings
+ // parameter.
+ gfx::Rect GetBounds(PositionMirroringSettings settings) const;
+
+ // Set the bounds in the parent's coordinate system.
+ void SetBounds(const gfx::Rect& bounds);
+ void SetBounds(int x, int y, int width, int height) {
+ SetBounds(gfx::Rect(x, y, std::max(0, width), std::max(0, height)));
+ }
+ void SetX(int x) { SetBounds(x, y(), width(), height()); }
+ void SetY(int y) { SetBounds(x(), y, width(), height()); }
+
+ // Returns the left coordinate of the View, relative to the parent View,
+ // which is the value of bounds_.x().
+ //
+ // This is the function subclasses should use whenever they need to obtain
+ // the left position of one of their child views (for example, when
+ // implementing View::Layout()).
+ // This is equivalent to GetX(IGNORE_MIRRORING_TRANSFORMATION), but
+ // inlinable.
+ int x() const { return bounds_.x(); }
+ int y() const { return bounds_.y(); }
+ int width() const { return bounds_.width(); }
+ int height() const { return bounds_.height(); }
+
+ // Return the left coordinate of the View, relative to the parent. If
+ // |settings| is IGNORE_MIRRORING_SETTINGS, the function returns the value of
+ // bounds_.x(). If |settings| is APPLY_MIRRORING_SETTINGS AND the parent
+ // View is using a right-to-left UI layout, then the function returns the
+ // mirrored value of bounds_.x().
+ //
+ // NOTE: in the vast majority of the cases, the mirroring implementation is
+ // transparent to the View subclasses and therefore you should use the
+ // paremeterless version of x() when you need to get the X
+ // coordinate of a child View.
+ int GetX(PositionMirroringSettings settings) const;
+
+ // Return this control local bounds. If include_border is true, local bounds
+ // is the rectangle {0, 0, width(), height()}, otherwise, it does not
+ // include the area where the border (if any) is painted.
+ gfx::Rect GetLocalBounds(bool include_border) const;
+
+ // Get the position of the View, relative to the parent.
+ //
+ // Note that if the parent uses right-to-left UI layout, then the mirrored
+ // position of this View is returned. Use x()/y() if you want to ignore
+ // mirroring.
+ gfx::Point GetPosition() const;
+
+ // 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);
+
+ // This method is invoked when this object size or position changes.
+ // The default implementation does nothing.
+ virtual void DidChangeBounds(const gfx::Rect& previous,
+ const gfx::Rect& current);
+
+ // 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 is_visible_; }
+
+ // 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;
+
+ // Set whether this view is hottracked. A disabled view cannot be hottracked.
+ // If flag differs from the current value, SchedulePaint is invoked.
+ virtual void SetHotTracked(bool flag);
+
+ // Returns whether the view is hot-tracked.
+ virtual bool IsHotTracked() const { return false; }
+
+ // Returns whether the view is pushed.
+ virtual bool IsPushed() const { return false; }
+
+ // Scrolls the specified region, in this View's coordinate system, to be
+ // visible. View's implementation passes the call onto the parent View (after
+ // adjusting the coordinates). It is up to views that only show a portion of
+ // the child view, such as Viewport, to override appropriately.
+ virtual void ScrollRectToVisible(int x, int y, int width, int height);
+
+ // Layout functions
+
+ // Lay out the child Views (set their bounds based on sizing heuristics
+ // specific to the current Layout Manager)
+ virtual void Layout();
+
+ // 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);
+
+ // Right-to-left UI layout functions
+
+ // Indicates whether the UI layout for this view is right-to-left. The view
+ // has an RTL UI layout if RTL hasn't been disabled for the view and if the
+ // locale's language is an RTL language.
+ bool UILayoutIsRightToLeft() const;
+
+ // Enables or disables the right-to-left layout for the view. If |enable| is
+ // true, the layout will become right-to-left only if the locale's language
+ // is right-to-left.
+ //
+ // By default, right-to-left UI layout is enabled for the view and therefore
+ // this function must be called (with false as the |enable| parameter) in
+ // order to disable the right-to-left layout property for a specific instance
+ // of the view. Disabling the right-to-left UI layout is necessary in case a
+ // UI element will not appear correctly when mirrored.
+ void EnableUIMirroringForRTLLanguages(bool enable) {
+ ui_mirroring_is_enabled_for_rtl_languages_ = enable;
+ }
+
+ // This method determines whether the ChromeCanvas object passed to
+ // View::Paint() needs to be transformed such that anything drawn on the
+ // canvas object during View::Paint() is flipped horizontally.
+ //
+ // By default, this function returns false (which is the initial value of
+ // |flip_canvas_on_paint_for_rtl_ui_|). View subclasses that need to paint on
+ // a flipped ChromeCanvas when the UI layout is right-to-left need to call
+ // EnableCanvasFlippingForRTLUI().
+ bool FlipCanvasOnPaintForRTLUI() const {
+ return flip_canvas_on_paint_for_rtl_ui_ ? UILayoutIsRightToLeft() : false;
+ }
+
+ // Enables or disables flipping of the ChromeCanvas during View::Paint().
+ // Note that if canvas flipping is enabled, the canvas will be flipped only
+ // if the UI layout is right-to-left; that is, the canvas will be flipped
+ // only if UILayoutIsRightToLeft() returns true.
+ //
+ // Enabling canvas flipping is useful for leaf views that draw a bitmap that
+ // needs to be flipped horizontally when the UI layout is right-to-left
+ // (views::Button, for example). This method is helpful for such classes
+ // because their drawing logic stays the same and they can become agnostic to
+ // the UI directionality.
+ void EnableCanvasFlippingForRTLUI(bool enable) {
+ flip_canvas_on_paint_for_rtl_ui_ = enable;
+ }
+
+ // Returns the mirrored X position for the view, relative to the parent. If
+ // the parent view is not mirrored, this function returns bound_.left.
+ //
+ // UI mirroring is transparent to most View subclasses and therefore there is
+ // no need to call this routine from anywhere within your subclass
+ // implementation.
+ int MirroredX() const;
+
+ // Given a rectangle specified in this View's coordinate system, the function
+ // computes the 'left' value for the mirrored rectangle within this View. If
+ // the View's UI layout is not right-to-left, then bounds.x() is returned.
+ //
+ // UI mirroring is transparent to most View subclasses and therefore there is
+ // no need to call this routine from anywhere within your subclass
+ // implementation.
+ int MirroredLeftPointForRect(const gfx::Rect& rect) const;
+
+ // Given the X coordinate of a point inside the View, this function returns
+ // the mirrored X coordinate of the point if the View's UI layout is
+ // right-to-left. If the layout is left-to-right, the same X coordinate is
+ // returned.
+ //
+ // Following are a few examples of the values returned by this function for
+ // a View with the bounds {0, 0, 100, 100} and a right-to-left layout:
+ //
+ // MirroredXCoordinateInsideView(0) -> 100
+ // MirroredXCoordinateInsideView(20) -> 80
+ // MirroredXCoordinateInsideView(99) -> 1
+ int MirroredXCoordinateInsideView(int x) const {
+ return UILayoutIsRightToLeft() ? width() - x : x;
+ }
+
+ // Painting functions
+
+ // Mark the specified rectangle as dirty (needing repaint). If |urgent| is
+ // true, the view will be repainted when the current event processing is
+ // done. Otherwise, painting will take place as soon as possible.
+ virtual void SchedulePaint(const gfx::Rect& r, bool urgent);
+
+ // Mark the entire View's bounds as dirty. Painting will occur as soon as
+ // possible.
+ virtual void SchedulePaint();
+
+ // Convenience to schedule a paint given some ints. Painting will occur as
+ // soon as possible.
+ virtual void SchedulePaint(int x, int y, int w, int h);
+
+ // Paint the receiving view. g is prepared such as it is in
+ // receiver's coordinate system. g's state is restored after this
+ // call so your implementation can change the graphics configuration
+ //
+ // Default implementation paints the background if it is defined
+ //
+ // Override this method when implementing a new control.
+ virtual void Paint(ChromeCanvas* canvas);
+
+ // Paint the background if any. This method is called by Paint() and
+ // should rarely be invoked directly.
+ virtual void PaintBackground(ChromeCanvas* canvas);
+
+ // Paint the border if any. This method is called by Paint() and
+ // should rarely be invoked directly.
+ virtual void PaintBorder(ChromeCanvas* canvas);
+
+ // Paints the focus border (only if the view has the focus).
+ // This method is called by Paint() and should rarely be invoked directly.
+ // The default implementation paints a gray border around the view. Override
+ // it for custom focus effects.
+ virtual void PaintFocusBorder(ChromeCanvas* canvas);
+
+ // Paint this View immediately.
+ virtual void PaintNow();
+
+ // Paint a view without attaching it to this view hierarchy.
+ // Any view can be painted that way.
+ // This method set bounds, calls layout and handles clipping properly. The
+ // provided view can be attached to a parent. The parent will be saved and
+ // restored. (x, y, width, height) define the floating view bounds
+ void PaintFloatingView(ChromeCanvas* canvas, View* view,
+ int x, int y, int w, int h);
+
+ // Tree functions
+
+ // Add a child View.
+ void AddChildView(View* v);
+
+ // Adds a child View at the specified position.
+ void AddChildView(int index, View* v);
+
+ // 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 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);
+
+ // Get the number of child Views.
+ int GetChildViewCount() const;
+
+ // Get the child View at the specified point.
+ virtual View* GetViewForPoint(const gfx::Point& point);
+
+ // Get the Widget that hosts this View, if any.
+ virtual Widget* GetWidget() const;
+
+ // Gets the Widget that most closely contains this View, if any.
+ virtual Window* GetWindow() const;
+
+ // 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(View* v) const;
+
+ // Returns true if the specified view is a direct or indirect child of this
+ // view.
+ bool IsParentOf(View* v) const;
+
+ // 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;
+
+ // 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.
+ void SetGroup(int gid);
+ int GetGroup() const;
+
+ // 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 { return true; }
+
+ // Fills the provided vector with all the available views which belong to the
+ // provided group.
+ void GetViewsWithGroup(int group_id, 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);
+
+ // Focus support
+ //
+ // Returns the view that should be selected next when pressing Tab.
+ View* GetNextFocusableView();
+
+ // 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);
+
+ // Return whether this view can accept the focus.
+ virtual bool IsFocusable() const;
+
+ // 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);
+
+ // Convenience method to retrieve the FocusManager associated with the
+ // Widget that contains this view. This can return NULL if this view is not
+ // part of a view hierarchy with a Widget.
+ virtual FocusManager* GetFocusManager();
+
+ // Sets a keyboard accelerator for that view. When the user presses the
+ // accelerator key combination, the AcceleratorPressed method is invoked.
+ // Note that you can set multiple accelerators for a view by invoking this
+ // method several times.
+ virtual void AddAccelerator(const Accelerator& accelerator);
+
+ // Removes the specified accelerator for this view.
+ virtual void RemoveAccelerator(const Accelerator& accelerator);
+
+ // Removes all the keyboard accelerators for this view.
+ virtual void ResetAccelerators();
+
+ // Called when a keyboard accelerator is pressed.
+ // Derived classes should implement desired behavior and return true if they
+ // handled the accelerator.
+ virtual bool AcceleratorPressed(const Accelerator& accelerator) {
+ return false;
+ }
+
+ // Called on a view (if it is has focus) before an Accelerator is processed.
+ // Views that want to override an accelerator should override this method to
+ // perform the required action and return true, to indicate that the
+ // accelerator should not be processed any further.
+ virtual bool OverrideAccelerator(const Accelerator& accelerator) {
+ return false;
+ }
+
+ // Returns whether this view currently has the focus.
+ virtual bool HasFocus();
+
+ // Accessibility support
+ // TODO(klink): Move all this out to a AccessibleInfo wrapper class.
+ //
+ // Returns the MSAA default action of the current view. The string returned
+ // describes the default action that will occur when executing
+ // IAccessible::DoDefaultAction. For instance, default action of a button is
+ // 'Press'. Sets the input string appropriately, and returns true if
+ // successful.
+ virtual bool GetAccessibleDefaultAction(std::wstring* action) {
+ return false;
+ }
+
+ // Returns a string containing the mnemonic, or the keyboard shortcut, for a
+ // given control. Sets the input string appropriately, and returns true if
+ // successful.
+ virtual bool GetAccessibleKeyboardShortcut(std::wstring* shortcut) {
+ return false;
+ }
+
+ // Returns a brief, identifying string, containing a unique, readable name of
+ // a given control. Sets the input string appropriately, and returns true if
+ // successful.
+ virtual bool GetAccessibleName(std::wstring* name) { return false; }
+
+ // Returns the accessibility role of the current view. The role is what
+ // assistive technologies (ATs) use to determine what behavior to expect from
+ // a given control. Sets the input Role appropriately, and returns true if
+ // successful.
+ virtual bool GetAccessibleRole(AccessibilityTypes::Role* role) {
+ return false;
+ }
+
+ // Returns the accessibility state of the current view. Sets the input State
+ // appropriately, and returns true if successful.
+ virtual bool GetAccessibleState(AccessibilityTypes::State* state) {
+ return false;
+ }
+
+ // Assigns a keyboard shortcut string description to the given control. Needed
+ // as a View does not know which shortcut will be associated with it until it
+ // is created to be a certain type.
+ virtual void SetAccessibleKeyboardShortcut(const std::wstring& shortcut) {}
+
+ // Assigns a string name to the given control. Needed as a View does not know
+ // which name will be associated with it until it is created to be a
+ // certain type.
+ virtual void SetAccessibleName(const std::wstring& name) {}
+
+ // Returns an instance of a wrapper class implementing the (platform-specific)
+ // accessibility interface for a given View. If one exists, it will be
+ // re-used, otherwise a new instance will be created.
+ ViewAccessibilityWrapper* GetViewAccessibilityWrapper();
+
+ // Accessor used to determine if a child view (leaf) has accessibility focus.
+ // Returns NULL if there are no children, or if none of the children has
+ // accessibility focus.
+ virtual View* GetAccFocusedChildView() { return NULL; }
+
+ // Floating views
+ //
+ // A floating view is a view that is used to paint a cell within a parent view
+ // Floating Views are painted using PaintFloatingView() above.
+ //
+ // Floating views can also be lazily created and attached to the view
+ // hierarchy to process events. To make this possible, each view is given an
+ // opportunity to create and attach a floating view right before an mouse
+ // event is processed.
+
+ // Retrieves the id for the floating view at the specified coordinates if any.
+ // Derived classes that use floating views should implement this method and
+ // return true if a view has been found and its id set in |id|.
+ virtual bool GetFloatingViewIDForPoint(int x, int y, int* id);
+
+ // Retrieves the ID of the floating view at the specified |position| and sets
+ // it in |id|.
+ // For positions NEXT and PREVIOUS, the specified |starting_id| is used as
+ // the origin, it is ignored for FIRST and LAST.
+ // Returns true if an ID was found, false otherwise.
+ // For CURRENT, the |starting_id| should be set in |id| and true returned if
+ // the |starting_id| is a valid floating view id.
+ // Derived classes that use floating views should implement this method and
+ // return a unique ID for each floating view.
+ // The default implementation always returns false.
+ virtual bool EnumerateFloatingViews(FloatingViewPosition position,
+ int starting_id,
+ int* id);
+
+ // Creates and attaches the floating view with the specified |id| to this view
+ // hierarchy and returns it.
+ // Derived classes that use floating views should implement this method.
+ //
+ // NOTE: subclasses implementing this should return NULL if passed an invalid
+ // id. An invalid ID may be passed in by the focus manager when attempting
+ // to restore focus.
+ virtual View* ValidateFloatingViewForID(int id);
+
+ // Whether the focus should automatically be restored to the last focused
+ // view. Default implementation returns true.
+ // Derived classes that want to restore focus themselves should override this
+ // method and return false.
+ virtual bool ShouldRestoreFloatingViewFocus();
+
+ // Attach a floating view to the receiving view. The view is inserted
+ // in the child view list and will behave like a normal view. |id| is the
+ // floating view id for that view.
+ void AttachFloatingView(View* v, int id);
+
+ // Return whether a view already has a floating view which bounds intersects
+ // the provided point.
+ //
+ // If the View uses right-to-left UI layout, then the given point is checked
+ // against the mirrored position of each floating View.
+ bool HasFloatingViewForPoint(int x, int y);
+
+ // Detach and delete all floating views. Call this method when your model
+ // or layout changes.
+ void DetachAllFloatingViews();
+
+ // Returns the view with the specified |id|, by calling
+ // ValidateFloatingViewForID if that view has not yet been attached.
+ virtual View* RetrieveFloatingViewForID(int id);
+
+ // Restores the focus to the previously selected floating view.
+ virtual void RestoreFloatingViewFocus();
+
+ // Goes up the parent hierarchy of this view and returns the first floating
+ // view found. Returns NULL if none were found.
+ View* RetrieveFloatingViewParent();
+
+ // Utility functions
+
+ // 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.
+ //
+ // source is a parent or a child of dst, directly or transitively.
+ // If source and dst are not in the same View hierarchy, the result is
+ // undefined.
+ // Source can be NULL in which case it means the screen coordinate system
+ static void ConvertPointToView(const View* src,
+ const View* dst,
+ gfx::Point* point);
+
+ // Convert a point from the coordinate system of a View to that of the
+ // Widget. This is useful for example when sizing HWND children of the
+ // Widget that don't know about the View hierarchy and need to be placed
+ // relative to the Widget that is their parent.
+ static void ConvertPointToWidget(const View* src, gfx::Point* point);
+
+ // Convert a point from a view Widget to a View dest
+ static void ConvertPointFromWidget(const View* dest, gfx::Point* p);
+
+ // Convert a point from the coordinate system of a View to that of the
+ // screen. This is useful for example when placing popup windows.
+ static void ConvertPointToScreen(const View* src, gfx::Point* point);
+
+ // Event Handlers
+
+ // This method is invoked when the user clicks on this view.
+ // The provided event is in the receiver's coordinate system.
+ //
+ // Return true if you processed the event and want to receive subsequent
+ // MouseDraggged and MouseReleased events. This also stops the event from
+ // bubbling. If you return false, the event will bubble through parent
+ // views.
+ //
+ // If you remove yourself from the tree while processing this, event bubbling
+ // stops as if you returned true, but you will not receive future events.
+ // The return value is ignored in this case.
+ //
+ // Default implementation returns true if a ContextMenuController has been
+ // set, false otherwise. Override as needed.
+ //
+ virtual bool OnMousePressed(const MouseEvent& event);
+
+ // This method is invoked when the user clicked on this control.
+ // and is still moving the mouse with a button pressed.
+ // The provided event is in the receiver's coordinate system.
+ //
+ // Return true if you processed the event and want to receive
+ // subsequent MouseDragged and MouseReleased events.
+ //
+ // Default implementation returns true if a ContextMenuController has been
+ // set, false otherwise. Override as needed.
+ //
+ virtual bool OnMouseDragged(const MouseEvent& event);
+
+ // This method is invoked when the user releases the mouse
+ // button. The event is in the receiver's coordinate system.
+ //
+ // If canceled is true it indicates the mouse press/drag was canceled by a
+ // system/user gesture.
+ //
+ // Default implementation notifies the ContextMenuController is appropriate.
+ // Subclasses that wish to honor the ContextMenuController should invoke
+ // super.
+ virtual void OnMouseReleased(const MouseEvent& event, bool canceled);
+
+ // This method is invoked when the mouse is above this control
+ // The event is in the receiver's coordinate system.
+ //
+ // Default implementation does nothing. Override as needed.
+ virtual void OnMouseMoved(const MouseEvent& e);
+
+ // This method is invoked when the mouse enters this control.
+ //
+ // Default implementation does nothing. Override as needed.
+ virtual void OnMouseEntered(const MouseEvent& event);
+
+ // This method is invoked when the mouse exits this control
+ // The provided event location is always (0, 0)
+ // Default implementation does nothing. Override as needed.
+ virtual void OnMouseExited(const MouseEvent& event);
+
+ // Set the MouseHandler for a drag session.
+ //
+ // A drag session is a stream of mouse events starting
+ // with a MousePressed event, followed by several MouseDragged
+ // events and finishing with a MouseReleased event.
+ //
+ // This method should be only invoked while processing a
+ // MouseDragged or MouseReleased event.
+ //
+ // All further mouse dragged and mouse up events will be sent
+ // the MouseHandler, even if it is reparented to another window.
+ //
+ // The MouseHandler is automatically cleared when the control
+ // comes back from processing the MouseReleased event.
+ //
+ // Note: if the mouse handler is no longer connected to a
+ // view hierarchy, events won't be sent.
+ //
+ virtual void SetMouseHandler(View* new_mouse_handler);
+
+ // Request the keyboard focus. The receiving view will become the
+ // focused view.
+ virtual void RequestFocus();
+
+ // Invoked when a view is about to gain focus
+ virtual void WillGainFocus();
+
+ // Invoked when a view just gained focus.
+ virtual void DidGainFocus();
+
+ // Invoked when a view is about lose focus
+ virtual void WillLoseFocus();
+
+ // Invoked when a view is about to be requested for focus due to the focus
+ // traversal. Reverse is this request was generated going backward
+ // (Shift-Tab).
+ virtual void AboutToRequestFocusFromTabTraversal(bool reverse) { }
+
+ // Invoked when a key is pressed or released.
+ // Subclasser should return true if the event has been processed and false
+ // otherwise. If the event has not been processed, the parent will be given a
+ // chance.
+ virtual bool OnKeyPressed(const KeyEvent& e);
+ virtual bool OnKeyReleased(const KeyEvent& e);
+
+ // Whether the view wants to receive Tab and Shift-Tab key events.
+ // If false, Tab and Shift-Tabs key events are used for focus traversal and
+ // are not sent to the view. If true, the events are sent to the view and not
+ // used for focus traversal.
+ // This implementation returns false (so that by default views handle nicely
+ // the keyboard focus traversal).
+ virtual bool CanProcessTabKeyEvents();
+
+ // Invoked when the user uses the mousewheel. Implementors should return true
+ // if the event has been processed and false otherwise. This message is sent
+ // if the view is focused. If the event has not been processed, the parent
+ // will be given a chance.
+ virtual bool OnMouseWheel(const MouseWheelEvent& e);
+
+ // Drag and drop functions.
+
+ // Set/get the DragController. See description of DragController for more
+ // information.
+ void SetDragController(DragController* drag_controller);
+ DragController* GetDragController();
+
+ // During a drag and drop session when the mouse moves the view under the
+ // mouse is queried to see if it should be a target for the drag and drop
+ // session. A view indicates it is a valid target by returning true from
+ // CanDrop. If a view returns true from CanDrop,
+ // OnDragEntered is sent to the view when the mouse first enters the view,
+ // as the mouse moves around within the view OnDragUpdated is invoked.
+ // If the user releases the mouse over the view and OnDragUpdated returns a
+ // valid drop, then OnPerformDrop is invoked. If the mouse moves outside the
+ // view or over another view that wants the drag, OnDragExited is invoked.
+ //
+ // Similar to mouse events, the deepest view under the mouse is first checked
+ // if it supports the drop (Drop). If the deepest view under
+ // the mouse does not support the drop, the ancestors are walked until one
+ // is found that supports the drop.
+
+ // A view that supports drag and drop must override this and return true if
+ // data contains a type that may be dropped on this view.
+ virtual bool CanDrop(const OSExchangeData& data);
+
+ // OnDragEntered is invoked when the mouse enters this view during a drag and
+ // drop session and CanDrop returns true. This is immediately
+ // followed by an invocation of OnDragUpdated, and eventually one of
+ // OnDragExited or OnPerformDrop.
+ virtual void OnDragEntered(const DropTargetEvent& event);
+
+ // Invoked during a drag and drop session while the mouse is over the view.
+ // This should return a bitmask of the DragDropTypes::DragOperation supported
+ // based on the location of the event. Return 0 to indicate the drop should
+ // not be accepted.
+ virtual int OnDragUpdated(const DropTargetEvent& event);
+
+ // Invoked during a drag and drop session when the mouse exits the views, or
+ // when the drag session was canceled and the mouse was over the view.
+ virtual void OnDragExited();
+
+ // Invoked during a drag and drop session when OnDragUpdated returns a valid
+ // operation and the user release the mouse.
+ virtual int OnPerformDrop(const DropTargetEvent& event);
+
+ // Returns true if the mouse was dragged enough to start a drag operation.
+ // delta_x and y are the distance the mouse was dragged.
+ static bool ExceededDragThreshold(int delta_x, int delta_y);
+
+ // This method is the main entry point to process paint for this
+ // view and its children. This method is called by the painting
+ // system. You should call this only if you want to draw a sub tree
+ // inside a custom graphics.
+ // To customize painting override either the Paint or PaintChildren method,
+ // not this one.
+ virtual void ProcessPaint(ChromeCanvas* canvas);
+
+ // Paint the View's child Views, in reverse order.
+ virtual void PaintChildren(ChromeCanvas* canvas);
+
+ // Sets the ContextMenuController. Setting this to non-null makes the View
+ // process mouse events.
+ void SetContextMenuController(ContextMenuController* menu_controller);
+ ContextMenuController* GetContextMenuController() {
+ return context_menu_controller_;
+ }
+
+ // Provides default implementation for context menu handling. The default
+ // implementation calls the ShowContextMenu of the current
+ // ContextMenuController (if it is not NULL). Overridden in subclassed views
+ // to provide right-click menu display triggerd by the keyboard (i.e. for the
+ // Chrome toolbar Back and Forward buttons). No source needs to be specified,
+ // as it is always equal to the current View.
+ virtual void ShowContextMenu(int x,
+ int y,
+ bool is_mouse_gesture);
+
+ // The background object is owned by this object and may be NULL.
+ void set_background(Background* b) { background_.reset(b); }
+ const Background* background() const { return background_.get(); }
+
+ // The border object is owned by this object and may be NULL.
+ void set_border(Border* b) { border_.reset(b); }
+ const Border* border() const { return border_.get(); }
+
+ // Returns the insets of the current border. If there is no border an empty
+ // insets is returned.
+ virtual gfx::Insets GetInsets() const;
+
+#if defined(OS_WIN)
+ // TODO(port): Make GetCursorForPoint portable.
+
+ // Return the cursor that should be used for this view or NULL if
+ // the default cursor should be used. The provided point is in the
+ // receiver's coordinate system.
+ virtual HCURSOR GetCursorForPoint(Event::EventType event_type, int x, int y);
+#endif // defined(OS_WIN)
+
+ // Convenience to test whether a point is within this view's bounds
+ virtual bool HitTest(const gfx::Point& l) const;
+
+ // Gets the tooltip for this View. If the View does not have a tooltip,
+ // return false. If the View does have a tooltip, copy the tooltip into
+ // the supplied string and return true.
+ // Any time the tooltip text that a View is displaying changes, it must
+ // invoke TooltipTextChanged.
+ // The x/y provide the coordinates of the mouse (relative to this view).
+ virtual bool GetTooltipText(int x, int y, std::wstring* tooltip);
+
+ // Returns the location (relative to this View) for the text on the tooltip
+ // to display. If false is returned (the default), the tooltip is placed at
+ // a default position.
+ virtual bool GetTooltipTextOrigin(int x, int y, gfx::Point* loc);
+
+ // 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 SetParentOwned(bool f);
+
+ // Return whether a view is owned by its parent. See SetParentOwned()
+ bool IsParentOwned() const;
+
+ // 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);
+
+ // Returns the visible bounds of the receiver in the receivers coordinate
+ // system.
+ //
+ // When traversing the View hierarchy in order to compute the bounds, the
+ // function takes into account the mirroring setting for each View and
+ // therefore it will return the mirrored version of the visible bounds if
+ // need be.
+ gfx::Rect GetVisibleBounds();
+
+ // Subclasses that contain traversable children that are not directly
+ // accessible through the children hierarchy should return the associated
+ // FocusTraversable for the focus traversal to work properly.
+ virtual FocusTraversable* GetFocusTraversable() { return NULL; }
+
+#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
+
+ // The following methods are used by ScrollView to determine the amount
+ // to scroll relative to the visible bounds of the view. For example, a
+ // return value of 10 indicates the scrollview should scroll 10 pixels in
+ // the appropriate direction.
+ //
+ // Each method takes the following parameters:
+ //
+ // is_horizontal: if true, scrolling is along the horizontal axis, otherwise
+ // the vertical axis.
+ // is_positive: if true, scrolling is by a positive amount. Along the
+ // vertical axis scrolling by a positive amount equates to
+ // scrolling down.
+ //
+ // The return value should always be positive and gives the number of pixels
+ // to scroll. ScrollView interprets a return value of 0 (or negative)
+ // to scroll by a default amount.
+ //
+ // See VariableRowHeightScrollHelper and FixedRowHeightScrollHelper for
+ // implementations of common cases.
+ virtual int GetPageScrollIncrement(ScrollView* scroll_view,
+ bool is_horizontal, bool is_positive);
+ virtual int GetLineScrollIncrement(ScrollView* scroll_view,
+ bool is_horizontal, bool is_positive);
+
+ protected:
+ // The id of this View. Used to find this View.
+ int id_;
+
+ // The group of this view. Some view subclasses use this id to find other
+ // views of the same group. For example radio button uses this information
+ // to find other radio buttons.
+ int group_;
+
+ // Called when the UI theme has changed, overriding allows individual Views to
+ // do special cleanup and processing (such as dropping resource caches).
+ // Subclasses that override this method must call the base class
+ // implementation to ensure child views are processed.
+ // Can only be called by subclasses. To dispatch a theme changed notification,
+ // call this method on the RootView.
+ virtual void ThemeChanged();
+
+#ifndef NDEBUG
+ // Returns true if the View is currently processing a paint.
+ virtual bool IsProcessingPaint() const;
+#endif
+
+ // Returns the location, in screen coordinates, to show the context menu at
+ // when the context menu is shown from the keyboard. This implementation
+ // returns the middle of the visible region of this view.
+ //
+ // This method is invoked when the context menu is shown by way of the
+ // keyboard.
+ virtual gfx::Point GetKeyboardContextMenuLocation();
+
+ // Called by HitTest to see if this View has a custom hit test mask. If the
+ // return value is true, GetHitTestMask will be called to obtain the mask.
+ // Default value is false, in which case the View will hit-test against its
+ // bounds.
+ virtual bool HasHitTestMask() const;
+
+ // Called by HitTest to retrieve a mask for hit-testing against. Subclasses
+ // override to provide custom shaped hit test regions.
+ virtual void GetHitTestMask(gfx::Path* mask) const;
+
+ // This method is invoked when the tree changes.
+ //
+ // When a view is removed, it is invoked for all children and grand
+ // children. For each of these views, a notification is sent to the
+ // view and all parents.
+ //
+ // When a view is added, a notification is sent to the view, all its
+ // parents, and all its children (and grand children)
+ //
+ // Default implementation does nothing. Override to perform operations
+ // required when a view is added or removed from a view hierarchy
+ //
+ // parent is the new or old parent. Child is the view being added or
+ // removed.
+ //
+ virtual void ViewHierarchyChanged(bool is_add, View* parent, View* child);
+
+ // When SetVisible() changes the visibility of a view, this method is
+ // invoked for that view as well as all the children recursively.
+ virtual void VisibilityChanged(View* starting_from, bool is_visible);
+
+ // Views must invoke this when the tooltip text they are to display changes.
+ void TooltipTextChanged();
+
+ // Actual implementation of GetViewForPoint.
+ virtual View* GetViewForPoint(const gfx::Point& point,
+ bool can_create_floating);
+
+ // Sets whether this view wants notification when its visible bounds relative
+ // to the root view changes. If true, this view is notified any time the
+ // origin of one its ancestors changes, or the portion of the bounds not
+ // obscured by ancestors changes. The default is false.
+ void SetNotifyWhenVisibleBoundsInRootChanges(bool value);
+ bool GetNotifyWhenVisibleBoundsInRootChanges();
+
+ // Notification that this views visible bounds, relative to the RootView
+ // has changed. The visible bounds corresponds to the region of the
+ // view not obscured by other ancestors.
+ virtual void VisibleBoundsInRootChanged() {}
+
+ // Sets the keyboard focus to this View. The correct way to set the focus is
+ // to call RequestFocus() on the view. This method is called when the focus is
+ // set and gives an opportunity to subclasses to perform any extra focus steps
+ // (for example native component set the native focus on their native
+ // component). The default behavior is to set the native focus on the root
+ // Widget, which is what is appropriate for views that have no native window
+ // associated with them (so the root view gets the keyboard messages).
+ virtual void Focus();
+
+ // Invoked when a key is pressed before the key event is processed by the
+ // focus manager for accelerators. This gives a chance to the view to
+ // override an accelerator. Subclasser should return false if they want to
+ // process the key event and not have it translated to an accelerator (if
+ // any). In that case, OnKeyPressed will subsequently be invoked for that
+ // event.
+ virtual bool ShouldLookupAccelerators(const KeyEvent& e) { return true; }
+
+ // A convenience method for derived classes which have floating views with IDs
+ // that are consecutive numbers in an interval [|low_bound|, |high_bound|[.
+ // They can call this method in their EnumerateFloatingViews implementation.
+ // If |ascending_order| is true, the first id is |low_bound|, the next after
+ // id n is n + 1, and so on. If |ascending_order| is false, the order is
+ // reversed, first id is |high_bound|, the next id after id n is n -1...
+ static bool EnumerateFloatingViewsForInterval(int low_bound, int high_bound,
+ bool ascending_order,
+ FloatingViewPosition position,
+ int starting_id,
+ int* id);
+
+ // These are cover methods that invoke the method of the same name on
+ // the DragController. Subclasses may wish to override rather than install
+ // a DragController.
+ // See DragController for a description of these methods.
+ virtual int GetDragOperations(int press_x, int press_y);
+ virtual void WriteDragData(int press_x, int press_y, OSExchangeData* data);
+
+ // Invoked from DoDrag after the drag completes. This implementation does
+ // nothing, and is intended for subclasses to do cleanup.
+ virtual void OnDragDone();
+
+ // Returns whether we're in the middle of a drag session that was initiated
+ // by us.
+ bool InDrag();
+
+ // Whether this view is enabled.
+ bool enabled_;
+
+ // Whether the view can be focused.
+ bool focusable_;
+
+ private:
+ friend class RootView;
+ friend class FocusManager;
+ friend class ViewStorage;
+
+ // Used to track a drag. RootView passes this into
+ // ProcessMousePressed/Dragged.
+ struct DragInfo {
+ // Sets possible_drag to false and start_x/y to 0. This is invoked by
+ // RootView prior to invoke ProcessMousePressed.
+ void Reset();
+
+ // Sets possible_drag to true and start_x/y to the specified coordinates.
+ // This is invoked by the target view if it detects the press may generate
+ // a drag.
+ void PossibleDrag(int x, int y);
+
+ // Whether the press may generate a drag.
+ bool possible_drag;
+
+ // Coordinates of the mouse press.
+ int start_x;
+ int start_y;
+ };
+
+ // Returns how much the mouse needs to move in one direction to start a
+ // drag. These methods cache in a platform-appropriate way. These values are
+ // used by the public static method ExceededDragThreshold().
+ static int GetHorizontalDragThreshold();
+ static int GetVerticalDragThreshold();
+
+ // RootView invokes these. These in turn invoke the appropriate OnMouseXXX
+ // method. If a drag is detected, DoDrag is invoked.
+ bool ProcessMousePressed(const MouseEvent& e, DragInfo* drop_info);
+ bool ProcessMouseDragged(const MouseEvent& e, DragInfo* drop_info);
+ void ProcessMouseReleased(const MouseEvent& e, bool canceled);
+
+ // Starts a drag and drop operation originating from this view. This invokes
+ // WriteDragData to write the data and GetDragOperations to determine the
+ // supported drag operations. When done, OnDragDone is invoked.
+ void DoDrag(const MouseEvent& e, int press_x, int press_y);
+
+ // Adds a child View at the specified position. |floating_view| should be true
+ // if the |v| is a floating view.
+ void AddChildView(int index, View* v, bool floating_view);
+
+ // 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);
+
+ // Call VisibilityChanged() recursively for all children.
+ void PropagateVisibilityNotifications(View* from, bool is_visible);
+
+ // Takes care of registering/unregistering accelerators if
+ // |register_accelerators| true and calls ViewHierarchyChanged().
+ void ViewHierarchyChangedImpl(bool register_accelerators,
+ bool is_add,
+ View* parent,
+ View* child);
+
+ // This is the actual implementation for ConvertPointToView()
+ // Attempts a parent -> child conversion and then a
+ // child -> parent conversion if try_other_direction is true
+ static void ConvertPointToView(const View* src,
+ const View* dst,
+ gfx::Point* point,
+ bool try_other_direction);
+
+ // Propagates UpdateTooltip() to the TooltipManager for the Widget.
+ // This must be invoked any time the View hierarchy changes in such a way
+ // the view under the mouse differs. For example, if the bounds of a View is
+ // changed, this is invoked. Similarly, as Views are added/removed, this
+ // is invoked.
+ void UpdateTooltip();
+
+ // Recursively descends through all descendant views,
+ // registering/unregistering all views that want visible bounds in root
+ // view notification.
+ static void RegisterChildrenForVisibleBoundsNotification(RootView* root,
+ View* view);
+ static void UnregisterChildrenForVisibleBoundsNotification(RootView* root,
+ View* view);
+
+ // Adds/removes view to the list of descendants that are notified any time
+ // this views location and possibly size are changed.
+ void AddDescendantToNotify(View* view);
+ void RemoveDescendantToNotify(View* view);
+
+ // Initialize the previous/next focusable views of the specified view relative
+ // to the view at the specified index.
+ void InitFocusSiblings(View* view, int index);
+
+ // Actual implementation of PrintFocusHierarchy.
+ void PrintViewHierarchyImp(int indent);
+ void PrintFocusHierarchyImp(int indent);
+
+ // Registers/unregister this view's keyboard accelerators with the
+ // FocusManager.
+ void RegisterAccelerators();
+ void UnregisterAccelerators();
+
+ // Returns the number of children that are actually attached floating views.
+ int GetFloatingViewCount() const;
+
+ // Returns the id for this floating view.
+ int GetFloatingViewID();
+
+ // Returns whether this view is a floating view.
+ bool IsFloatingView();
+
+ // Sets in |path| the path in the view hierarchy from |start| to |end| (the
+ // path is the list of indexes in each view's children to get from |start|
+ // to |end|).
+ // Returns true if |start| and |view| are connected and the |path| has been
+ // retrieved succesfully, false otherwise.
+ static bool GetViewPath(View* start, View* end, std::vector<int>* path);
+
+ // Returns the view at the end of the specified |path|, starting at the
+ // |start| view.
+ static View* GetViewForPath(View* start, const std::vector<int>& path);
+
+ // This View's bounds in the parent coordinate system.
+ gfx::Rect bounds_;
+
+ // This view's parent
+ View *parent_;
+
+ // This view's children.
+ typedef std::vector<View*> ViewList;
+ ViewList child_views_;
+
+ // List of floating children. A floating view is always referenced by
+ // child_views_ and will be deleted on destruction just like any other
+ // child view.
+ ViewList floating_views_;
+
+ // Maps a floating view to its floating view id.
+ std::map<View*, int> floating_views_ids_;
+
+ // Whether we want the focus to be restored. This is used to store/restore
+ // focus for floating views.
+ bool should_restore_focus_;
+
+ // 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_;
+
+ // Visible state
+ bool is_visible_;
+
+ // Background
+ scoped_ptr<Background> background_;
+
+ // Border.
+ scoped_ptr<Border> border_;
+
+ // Whether this view is owned by its parent.
+ bool is_parent_owned_;
+
+ // 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_;
+
+ // Next view to be focused when the Tab key is pressed.
+ View* next_focusable_view_;
+
+ // Next view to be focused when the Shift-Tab key combination is pressed.
+ View* previous_focusable_view_;
+
+ // The list of accelerators.
+ scoped_ptr<std::vector<Accelerator> > accelerators_;
+
+ // The task used to restore automatically the focus to the last focused
+ // floating view.
+ RestoreFocusTask* restore_focus_view_task_;
+
+ // The menu controller.
+ ContextMenuController* context_menu_controller_;
+
+#if defined(OS_WIN)
+ // The accessibility implementation for this View.
+ scoped_ptr<ViewAccessibilityWrapper> accessibility_;
+#endif
+
+ DragController* drag_controller_;
+
+ // Indicates whether or not the view is going to be mirrored (that is, use a
+ // right-to-left UI layout) if the locale's language is a right-to-left
+ // language like Arabic or Hebrew.
+ bool ui_mirroring_is_enabled_for_rtl_languages_;
+
+ // Indicates whether or not the ChromeCanvas object passed to View::Paint()
+ // is going to be flipped horizontally (using the appropriate transform) on
+ // right-to-left locales for this View.
+ bool flip_canvas_on_paint_for_rtl_ui_;
+
+ DISALLOW_COPY_AND_ASSIGN(View);
+};
+
+} // namespace views
+
+#endif // VIEWS_VIEW_H_
