1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #ifndef UI_VIEWS_VIEW_H_
6 #define UI_VIEWS_VIEW_H_
14 #include "base/compiler_specific.h"
15 #include "base/i18n/rtl.h"
16 #include "base/logging.h"
17 #include "base/memory/scoped_ptr.h"
18 #include "build/build_config.h"
19 #include "ui/base/accelerators/accelerator.h"
20 #include "ui/base/accessibility/accessibility_types.h"
21 #include "ui/base/dragdrop/drag_drop_types.h"
22 #include "ui/base/dragdrop/drop_target_event.h"
23 #include "ui/base/dragdrop/os_exchange_data.h"
24 #include "ui/base/ui_base_types.h"
25 #include "ui/compositor/layer_delegate.h"
26 #include "ui/compositor/layer_owner.h"
27 #include "ui/events/event.h"
28 #include "ui/events/event_target.h"
29 #include "ui/gfx/insets.h"
30 #include "ui/gfx/native_widget_types.h"
31 #include "ui/gfx/rect.h"
32 #include "ui/gfx/vector2d.h"
33 #include "ui/views/views_export.h"
36 #include "base/win/scoped_comptr.h"
39 using ui::OSExchangeData;
49 struct AccessibleViewState;
53 class TextInputClient;
62 class ContextMenuController;
65 class FocusTraversable;
68 class NativeViewAccessibility;
73 class PostEventDispatchHandler;
77 /////////////////////////////////////////////////////////////////////////////
81 // A View is a rectangle within the views View hierarchy. It is the base
82 // class for all Views.
84 // A View is a container of other Views (there is no such thing as a Leaf
85 // View - makes code simpler, reduces type conversion headaches, design
88 // The View contains basic properties for sizing (bounds), layout (flex,
89 // orientation, etc), painting of children and event dispatch.
91 // The View also uses a simple Box Layout Manager similar to XUL's
92 // SprocketLayout system. Alternative Layout Managers implementing the
93 // LayoutManager interface can be used to lay out children if required.
95 // It is up to the subclass to implement Painting and storage of subclass -
96 // specific properties and functionality.
98 // Unless otherwise documented, views is not thread safe and should only be
99 // accessed from the main thread.
101 /////////////////////////////////////////////////////////////////////////////
102 class VIEWS_EXPORT View : public ui::LayerDelegate,
103 public ui::LayerOwner,
104 public ui::AcceleratorTarget,
105 public ui::EventTarget {
107 typedef std::vector<View*> Views;
109 // TODO(tdanderson,sadrul): Becomes obsolete with the refactoring of the
110 // event targeting logic for views and windows.
111 // Specifies the source of the region used in a hit test.
112 // HIT_TEST_SOURCE_MOUSE indicates the hit test is being performed with a
113 // single point and HIT_TEST_SOURCE_TOUCH indicates the hit test is being
114 // performed with a rect larger than a single point. This value can be used,
115 // for example, to add extra padding or change the shape of the hit test mask.
117 HIT_TEST_SOURCE_MOUSE,
118 HIT_TEST_SOURCE_TOUCH
121 struct ViewHierarchyChangedDetails {
122 ViewHierarchyChangedDetails()
128 ViewHierarchyChangedDetails(bool is_add,
135 move_view(move_view) {}
138 // New parent if |is_add| is true, old parent if |is_add| is false.
140 // The view being added or removed.
142 // If this is a move (reparent), meaning AddChildViewAt() is invoked with an
143 // existing parent, then a notification for the remove is sent first,
144 // followed by one for the add. This case can be distinguished by a
145 // non-NULL |move_view|.
146 // For the remove part of move, |move_view| is the new parent of the View
148 // For the add part of move, |move_view| is the old parent of the View being
153 // Creation and lifetime -----------------------------------------------------
158 // By default a View is owned by its parent unless specified otherwise here.
159 void set_owned_by_client() { owned_by_client_ = true; }
161 // Tree operations -----------------------------------------------------------
163 // Get the Widget that hosts this View, if any.
164 virtual const Widget* GetWidget() const;
165 virtual Widget* GetWidget();
167 // Adds |view| as a child of this view, optionally at |index|.
168 void AddChildView(View* view);
169 void AddChildViewAt(View* view, int index);
171 // Moves |view| to the specified |index|. A negative value for |index| moves
172 // the view at the end.
173 void ReorderChildView(View* view, int index);
175 // Removes |view| from this view. The view's parent will change to NULL.
176 void RemoveChildView(View* view);
178 // Removes all the children from this view. If |delete_children| is true,
179 // the views are deleted, unless marked as not parent owned.
180 void RemoveAllChildViews(bool delete_children);
182 int child_count() const { return static_cast<int>(children_.size()); }
183 bool has_children() const { return !children_.empty(); }
185 // Returns the child view at |index|.
186 const View* child_at(int index) const {
188 DCHECK_LT(index, child_count());
189 return children_[index];
191 View* child_at(int index) {
192 return const_cast<View*>(const_cast<const View*>(this)->child_at(index));
195 // Returns the parent view.
196 const View* parent() const { return parent_; }
197 View* parent() { return parent_; }
199 // Returns true if |view| is contained within this View's hierarchy, even as
200 // an indirect descendant. Will return true if child is also this view.
201 bool Contains(const View* view) const;
203 // Returns the index of |view|, or -1 if |view| is not a child of this view.
204 int GetIndexOf(const View* view) const;
206 // Size and disposition ------------------------------------------------------
207 // Methods for obtaining and modifying the position and size of the view.
208 // Position is in the coordinate system of the view's parent.
209 // Position is NOT flipped for RTL. See "RTL positioning" for RTL-sensitive
210 // position accessors.
211 // Transformations are not applied on the size/position. For example, if
212 // bounds is (0, 0, 100, 100) and it is scaled by 0.5 along the X axis, the
213 // width will still be 100 (although when painted, it will be 50x50, painted
214 // at location (0, 0)).
216 void SetBounds(int x, int y, int width, int height);
217 void SetBoundsRect(const gfx::Rect& bounds);
218 void SetSize(const gfx::Size& size);
219 void SetPosition(const gfx::Point& position);
223 // No transformation is applied on the size or the locations.
224 const gfx::Rect& bounds() const { return bounds_; }
225 int x() const { return bounds_.x(); }
226 int y() const { return bounds_.y(); }
227 int width() const { return bounds_.width(); }
228 int height() const { return bounds_.height(); }
229 const gfx::Size& size() const { return bounds_.size(); }
231 // Returns the bounds of the content area of the view, i.e. the rectangle
232 // enclosed by the view's border.
233 gfx::Rect GetContentsBounds() const;
235 // Returns the bounds of the view in its own coordinates (i.e. position is
237 gfx::Rect GetLocalBounds() const;
239 // Returns the bounds of the layer in its own pixel coordinates.
240 gfx::Rect GetLayerBoundsInPixel() const;
242 // Returns the insets of the current border. If there is no border an empty
243 // insets is returned.
244 virtual gfx::Insets GetInsets() const;
246 // Returns the visible bounds of the receiver in the receivers coordinate
249 // When traversing the View hierarchy in order to compute the bounds, the
250 // function takes into account the mirroring setting and transformation for
251 // each View and therefore it will return the mirrored and transformed version
252 // of the visible bounds if need be.
253 gfx::Rect GetVisibleBounds() const;
255 // Return the bounds of the View in screen coordinate system.
256 gfx::Rect GetBoundsInScreen() const;
258 // Returns the baseline of this view, or -1 if this view has no baseline. The
259 // return value is relative to the preferred height.
260 virtual int GetBaseline() const;
262 // Get the size the View would like to be, if enough space were available.
263 virtual gfx::Size GetPreferredSize();
265 // Convenience method that sizes this view to its preferred size.
266 void SizeToPreferredSize();
268 // Gets the minimum size of the view. View's implementation invokes
270 virtual gfx::Size GetMinimumSize();
272 // Gets the maximum size of the view. Currently only used for sizing shell
274 virtual gfx::Size GetMaximumSize();
276 // Return the height necessary to display this view with the provided width.
277 // View's implementation returns the value from getPreferredSize.cy.
278 // Override if your View's preferred height depends upon the width (such
280 virtual int GetHeightForWidth(int w);
282 // Set whether this view is visible. Painting is scheduled as needed.
283 virtual void SetVisible(bool visible);
285 // Return whether a view is visible
286 bool visible() const { return visible_; }
288 // Returns true if this view is drawn on screen.
289 virtual bool IsDrawn() const;
291 // Set whether this view is enabled. A disabled view does not receive keyboard
292 // or mouse inputs. If |enabled| differs from the current value, SchedulePaint
294 void SetEnabled(bool enabled);
296 // Returns whether the view is enabled.
297 bool enabled() const { return enabled_; }
299 // This indicates that the view completely fills its bounds in an opaque
300 // color. This doesn't affect compositing but is a hint to the compositor to
301 // optimize painting.
302 // Note that this method does not implicitly create a layer if one does not
303 // already exist for the View, but is a no-op in that case.
304 void SetFillsBoundsOpaquely(bool fills_bounds_opaquely);
306 // Transformations -----------------------------------------------------------
308 // Methods for setting transformations for a view (e.g. rotation, scaling).
310 gfx::Transform GetTransform() const;
312 // Clipping parameters. Clipping is done relative to the view bounds.
313 void set_clip_insets(gfx::Insets clip_insets) { clip_insets_ = clip_insets; }
315 // Sets the transform to the supplied transform.
316 void SetTransform(const gfx::Transform& transform);
318 // Sets whether this view paints to a layer. A view paints to a layer if
319 // either of the following are true:
320 // . the view has a non-identity transform.
321 // . SetPaintToLayer(true) has been invoked.
322 // View creates the Layer only when it exists in a Widget with a non-NULL
324 void SetPaintToLayer(bool paint_to_layer);
326 // Recreates a layer for the view and returns the old layer. After this call,
327 // the View no longer has a pointer to the old layer (so it won't be able to
328 // update the old layer or destroy it). The caller must free the returned
330 // Returns NULL and does not recreate layer if view does not own its layer.
331 ui::Layer* RecreateLayer() WARN_UNUSED_RESULT;
333 // RTL positioning -----------------------------------------------------------
335 // Methods for accessing the bounds and position of the view, relative to its
336 // parent. The position returned is mirrored if the parent view is using a RTL
339 // NOTE: in the vast majority of the cases, the mirroring implementation is
340 // transparent to the View subclasses and therefore you should use the
341 // bounds() accessor instead.
342 gfx::Rect GetMirroredBounds() const;
343 gfx::Point GetMirroredPosition() const;
344 int GetMirroredX() const;
346 // Given a rectangle specified in this View's coordinate system, the function
347 // computes the 'left' value for the mirrored rectangle within this View. If
348 // the View's UI layout is not right-to-left, then bounds.x() is returned.
350 // UI mirroring is transparent to most View subclasses and therefore there is
351 // no need to call this routine from anywhere within your subclass
353 int GetMirroredXForRect(const gfx::Rect& rect) const;
355 // Given the X coordinate of a point inside the View, this function returns
356 // the mirrored X coordinate of the point if the View's UI layout is
357 // right-to-left. If the layout is left-to-right, the same X coordinate is
360 // Following are a few examples of the values returned by this function for
361 // a View with the bounds {0, 0, 100, 100} and a right-to-left layout:
363 // GetMirroredXCoordinateInView(0) -> 100
364 // GetMirroredXCoordinateInView(20) -> 80
365 // GetMirroredXCoordinateInView(99) -> 1
366 int GetMirroredXInView(int x) const;
368 // Given a X coordinate and a width inside the View, this function returns
369 // the mirrored X coordinate if the View's UI layout is right-to-left. If the
370 // layout is left-to-right, the same X coordinate is returned.
372 // Following are a few examples of the values returned by this function for
373 // a View with the bounds {0, 0, 100, 100} and a right-to-left layout:
375 // GetMirroredXCoordinateInView(0, 10) -> 90
376 // GetMirroredXCoordinateInView(20, 20) -> 60
377 int GetMirroredXWithWidthInView(int x, int w) const;
379 // Layout --------------------------------------------------------------------
381 // Lay out the child Views (set their bounds based on sizing heuristics
382 // specific to the current Layout Manager)
383 virtual void Layout();
385 // TODO(beng): I think we should remove this.
386 // Mark this view and all parents to require a relayout. This ensures the
387 // next call to Layout() will propagate to this view, even if the bounds of
388 // parent views do not change.
389 void InvalidateLayout();
391 // Gets/Sets the Layout Manager used by this view to size and place its
393 // The LayoutManager is owned by the View and is deleted when the view is
394 // deleted, or when a new LayoutManager is installed.
395 LayoutManager* GetLayoutManager() const;
396 void SetLayoutManager(LayoutManager* layout);
398 // Attributes ----------------------------------------------------------------
400 // The view class name.
401 static const char kViewClassName[];
403 // Return the receiving view's class name. A view class is a string which
404 // uniquely identifies the view class. It is intended to be used as a way to
405 // find out during run time if a view can be safely casted to a specific view
406 // subclass. The default implementation returns kViewClassName.
407 virtual const char* GetClassName() const;
409 // Returns the first ancestor, starting at this, whose class name is |name|.
410 // Returns null if no ancestor has the class name |name|.
411 View* GetAncestorWithClassName(const std::string& name);
413 // Recursively descends the view tree starting at this view, and returns
414 // the first child that it encounters that has the given ID.
415 // Returns NULL if no matching child view is found.
416 virtual const View* GetViewByID(int id) const;
417 virtual View* GetViewByID(int id);
419 // Gets and sets the ID for this view. ID should be unique within the subtree
420 // that you intend to search for it. 0 is the default ID for views.
421 int id() const { return id_; }
422 void set_id(int id) { id_ = id; }
424 // A group id is used to tag views which are part of the same logical group.
425 // Focus can be moved between views with the same group using the arrow keys.
426 // Groups are currently used to implement radio button mutual exclusion.
427 // The group id is immutable once it's set.
428 void SetGroup(int gid);
429 // Returns the group id of the view, or -1 if the id is not set yet.
430 int GetGroup() const;
432 // If this returns true, the views from the same group can each be focused
433 // when moving focus with the Tab/Shift-Tab key. If this returns false,
434 // only the selected view from the group (obtained with
435 // GetSelectedViewForGroup()) is focused.
436 virtual bool IsGroupFocusTraversable() const;
438 // Fills |views| with all the available views which belong to the provided
440 void GetViewsInGroup(int group, Views* views);
442 // Returns the View that is currently selected in |group|.
443 // The default implementation simply returns the first View found for that
445 virtual View* GetSelectedViewForGroup(int group);
447 // Coordinate conversion -----------------------------------------------------
449 // Note that the utility coordinate conversions functions always operate on
450 // the mirrored position of the child Views if the parent View uses a
451 // right-to-left UI layout.
453 // Convert a point from the coordinate system of one View to another.
455 // |source| and |target| must be in the same widget, but doesn't need to be in
456 // the same view hierarchy.
457 // Neither |source| nor |target| can be NULL.
458 static void ConvertPointToTarget(const View* source,
462 // Convert |rect| from the coordinate system of |source| to the coordinate
463 // system of |target|.
465 // |source| and |target| must be in the same widget, but doesn't need to be in
466 // the same view hierarchy.
467 // Neither |source| nor |target| can be NULL.
468 static void ConvertRectToTarget(const View* source,
472 // Convert a point from a View's coordinate system to that of its Widget.
473 static void ConvertPointToWidget(const View* src, gfx::Point* point);
475 // Convert a point from the coordinate system of a View's Widget to that
476 // View's coordinate system.
477 static void ConvertPointFromWidget(const View* dest, gfx::Point* p);
479 // Convert a point from a View's coordinate system to that of the screen.
480 static void ConvertPointToScreen(const View* src, gfx::Point* point);
482 // Convert a point from a View's coordinate system to that of the screen.
483 static void ConvertPointFromScreen(const View* dst, gfx::Point* point);
485 // Applies transformation on the rectangle, which is in the view's coordinate
486 // system, to convert it into the parent's coordinate system.
487 gfx::Rect ConvertRectToParent(const gfx::Rect& rect) const;
489 // Converts a rectangle from this views coordinate system to its widget
490 // coordinate system.
491 gfx::Rect ConvertRectToWidget(const gfx::Rect& rect) const;
493 // Painting ------------------------------------------------------------------
495 // Mark all or part of the View's bounds as dirty (needing repaint).
496 // |r| is in the View's coordinates.
497 // Rectangle |r| should be in the view's coordinate system. The
498 // transformations are applied to it to convert it into the parent coordinate
499 // system before propagating SchedulePaint up the view hierarchy.
500 // TODO(beng): Make protected.
501 virtual void SchedulePaint();
502 virtual void SchedulePaintInRect(const gfx::Rect& r);
504 // Called by the framework to paint a View. Performs translation and clipping
505 // for View coordinates and language direction as required, allows the View
506 // to paint itself via the various OnPaint*() event handlers and then paints
507 // the hierarchy beneath it.
508 virtual void Paint(gfx::Canvas* canvas);
510 // The background object is owned by this object and may be NULL.
511 void set_background(Background* b);
512 const Background* background() const { return background_.get(); }
513 Background* background() { return background_.get(); }
515 // The border object is owned by this object and may be NULL.
516 void SetBorder(scoped_ptr<Border> b);
517 const Border* border() const { return border_.get(); }
518 Border* border() { return border_.get(); }
520 // Get the theme provider from the parent widget.
521 virtual ui::ThemeProvider* GetThemeProvider() const;
523 // Returns the NativeTheme to use for this View. This calls through to
524 // GetNativeTheme() on the Widget this View is in. If this View is not in a
525 // Widget this returns ui::NativeTheme::instance().
526 ui::NativeTheme* GetNativeTheme() {
527 return const_cast<ui::NativeTheme*>(
528 const_cast<const View*>(this)->GetNativeTheme());
530 const ui::NativeTheme* GetNativeTheme() const;
532 // RTL painting --------------------------------------------------------------
534 // This method determines whether the gfx::Canvas object passed to
535 // View::Paint() needs to be transformed such that anything drawn on the
536 // canvas object during View::Paint() is flipped horizontally.
538 // By default, this function returns false (which is the initial value of
539 // |flip_canvas_on_paint_for_rtl_ui_|). View subclasses that need to paint on
540 // a flipped gfx::Canvas when the UI layout is right-to-left need to call
541 // EnableCanvasFlippingForRTLUI().
542 bool FlipCanvasOnPaintForRTLUI() const {
543 return flip_canvas_on_paint_for_rtl_ui_ ? base::i18n::IsRTL() : false;
546 // Enables or disables flipping of the gfx::Canvas during View::Paint().
547 // Note that if canvas flipping is enabled, the canvas will be flipped only
548 // if the UI layout is right-to-left; that is, the canvas will be flipped
549 // only if base::i18n::IsRTL() returns true.
551 // Enabling canvas flipping is useful for leaf views that draw an image that
552 // needs to be flipped horizontally when the UI layout is right-to-left
553 // (views::Button, for example). This method is helpful for such classes
554 // because their drawing logic stays the same and they can become agnostic to
555 // the UI directionality.
556 void EnableCanvasFlippingForRTLUI(bool enable) {
557 flip_canvas_on_paint_for_rtl_ui_ = enable;
560 // Accelerated painting ------------------------------------------------------
562 // Enable/Disable accelerated compositing.
563 static void set_use_acceleration_when_possible(bool use);
564 static bool get_use_acceleration_when_possible();
566 // Input ---------------------------------------------------------------------
567 // The points, rects, mouse locations, and touch locations in the following
568 // functions are in the view's coordinates, except for a RootView.
570 // Convenience functions which calls into GetEventHandler() with
571 // a 1x1 rect centered at |point|.
572 View* GetEventHandlerForPoint(const gfx::Point& point);
574 // If point-based targeting should be used, return the deepest visible
575 // descendant that contains the center point of |rect|.
576 // If rect-based targeting (i.e., fuzzing) should be used, return the
577 // closest visible descendant having at least kRectTargetOverlap of
578 // its area covered by |rect|. If no such descendant exists, return the
579 // deepest visible descendant that contains the center point of |rect|.
580 // See http://goo.gl/3Jp2BD for more information about rect-based targeting.
581 virtual View* GetEventHandlerForRect(const gfx::Rect& rect);
583 // Returns the deepest visible descendant that contains the specified point
584 // and supports tooltips. If the view does not contain the point, returns
586 virtual View* GetTooltipHandlerForPoint(const gfx::Point& point);
588 // Return the cursor that should be used for this view or the default cursor.
589 // The event location is in the receiver's coordinate system. The caller is
590 // responsible for managing the lifetime of the returned object, though that
591 // lifetime may vary from platform to platform. On Windows and Aura,
592 // the cursor is a shared resource.
593 virtual gfx::NativeCursor GetCursor(const ui::MouseEvent& event);
595 // A convenience function which calls HitTestRect() with a rect of size
596 // 1x1 and an origin of |point|.
597 bool HitTestPoint(const gfx::Point& point) const;
599 // Tests whether |rect| intersects this view's bounds.
600 virtual bool HitTestRect(const gfx::Rect& rect) const;
602 // Returns true if the mouse cursor is over |view| and mouse events are
604 bool IsMouseHovered();
606 // This method is invoked when the user clicks on this view.
607 // The provided event is in the receiver's coordinate system.
609 // Return true if you processed the event and want to receive subsequent
610 // MouseDraggged and MouseReleased events. This also stops the event from
611 // bubbling. If you return false, the event will bubble through parent
614 // If you remove yourself from the tree while processing this, event bubbling
615 // stops as if you returned true, but you will not receive future events.
616 // The return value is ignored in this case.
618 // Default implementation returns true if a ContextMenuController has been
619 // set, false otherwise. Override as needed.
621 virtual bool OnMousePressed(const ui::MouseEvent& event);
623 // This method is invoked when the user clicked on this control.
624 // and is still moving the mouse with a button pressed.
625 // The provided event is in the receiver's coordinate system.
627 // Return true if you processed the event and want to receive
628 // subsequent MouseDragged and MouseReleased events.
630 // Default implementation returns true if a ContextMenuController has been
631 // set, false otherwise. Override as needed.
633 virtual bool OnMouseDragged(const ui::MouseEvent& event);
635 // This method is invoked when the user releases the mouse
636 // button. The event is in the receiver's coordinate system.
638 // Default implementation notifies the ContextMenuController is appropriate.
639 // Subclasses that wish to honor the ContextMenuController should invoke
641 virtual void OnMouseReleased(const ui::MouseEvent& event);
643 // This method is invoked when the mouse press/drag was canceled by a
644 // system/user gesture.
645 virtual void OnMouseCaptureLost();
647 // This method is invoked when the mouse is above this control
648 // The event is in the receiver's coordinate system.
650 // Default implementation does nothing. Override as needed.
651 virtual void OnMouseMoved(const ui::MouseEvent& event);
653 // This method is invoked when the mouse enters this control.
655 // Default implementation does nothing. Override as needed.
656 virtual void OnMouseEntered(const ui::MouseEvent& event);
658 // This method is invoked when the mouse exits this control
659 // The provided event location is always (0, 0)
660 // Default implementation does nothing. Override as needed.
661 virtual void OnMouseExited(const ui::MouseEvent& event);
663 // Set the MouseHandler for a drag session.
665 // A drag session is a stream of mouse events starting
666 // with a MousePressed event, followed by several MouseDragged
667 // events and finishing with a MouseReleased event.
669 // This method should be only invoked while processing a
670 // MouseDragged or MousePressed event.
672 // All further mouse dragged and mouse up events will be sent
673 // the MouseHandler, even if it is reparented to another window.
675 // The MouseHandler is automatically cleared when the control
676 // comes back from processing the MouseReleased event.
678 // Note: if the mouse handler is no longer connected to a
679 // view hierarchy, events won't be sent.
681 // TODO(sky): rename this.
682 virtual void SetMouseHandler(View* new_mouse_handler);
684 // Invoked when a key is pressed or released.
685 // Subclasser should return true if the event has been processed and false
686 // otherwise. If the event has not been processed, the parent will be given a
688 virtual bool OnKeyPressed(const ui::KeyEvent& event);
689 virtual bool OnKeyReleased(const ui::KeyEvent& event);
691 // Invoked when the user uses the mousewheel. Implementors should return true
692 // if the event has been processed and false otherwise. This message is sent
693 // if the view is focused. If the event has not been processed, the parent
694 // will be given a chance.
695 virtual bool OnMouseWheel(const ui::MouseWheelEvent& event);
698 // See field for description.
699 void set_notify_enter_exit_on_child(bool notify) {
700 notify_enter_exit_on_child_ = notify;
702 bool notify_enter_exit_on_child() const {
703 return notify_enter_exit_on_child_;
706 // Returns the View's TextInputClient instance or NULL if the View doesn't
707 // support text input.
708 virtual ui::TextInputClient* GetTextInputClient();
710 // Convenience method to retrieve the InputMethod associated with the
711 // Widget that contains this view. Returns NULL if this view is not part of a
712 // view hierarchy with a Widget.
713 virtual InputMethod* GetInputMethod();
714 virtual const InputMethod* GetInputMethod() const;
716 // Overridden from ui::EventTarget:
717 virtual bool CanAcceptEvent(const ui::Event& event) OVERRIDE;
718 virtual ui::EventTarget* GetParentTarget() OVERRIDE;
719 virtual scoped_ptr<ui::EventTargetIterator> GetChildIterator() const OVERRIDE;
720 virtual ui::EventTargeter* GetEventTargeter() OVERRIDE;
722 // Overridden from ui::EventHandler:
723 virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
724 virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
725 virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
726 virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
727 virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
729 // Accelerators --------------------------------------------------------------
731 // Sets a keyboard accelerator for that view. When the user presses the
732 // accelerator key combination, the AcceleratorPressed method is invoked.
733 // Note that you can set multiple accelerators for a view by invoking this
734 // method several times. Note also that AcceleratorPressed is invoked only
735 // when CanHandleAccelerators() is true.
736 virtual void AddAccelerator(const ui::Accelerator& accelerator);
738 // Removes the specified accelerator for this view.
739 virtual void RemoveAccelerator(const ui::Accelerator& accelerator);
741 // Removes all the keyboard accelerators for this view.
742 virtual void ResetAccelerators();
744 // Overridden from AcceleratorTarget:
745 virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) OVERRIDE;
747 // Returns whether accelerators are enabled for this view. Accelerators are
748 // enabled if the containing widget is visible and the view is enabled() and
750 virtual bool CanHandleAccelerators() const OVERRIDE;
752 // Focus ---------------------------------------------------------------------
754 // Returns whether this view currently has the focus.
755 virtual bool HasFocus() const;
757 // Returns the view that should be selected next when pressing Tab.
758 View* GetNextFocusableView();
759 const View* GetNextFocusableView() const;
761 // Returns the view that should be selected next when pressing Shift-Tab.
762 View* GetPreviousFocusableView();
764 // Sets the component that should be selected next when pressing Tab, and
765 // makes the current view the precedent view of the specified one.
766 // Note that by default views are linked in the order they have been added to
767 // their container. Use this method if you want to modify the order.
768 // IMPORTANT NOTE: loops in the focus hierarchy are not supported.
769 void SetNextFocusableView(View* view);
771 // Sets whether this view is capable of taking focus.
772 // Note that this is false by default so that a view used as a container does
773 // not get the focus.
774 void SetFocusable(bool focusable);
776 // Returns true if this view is |focusable_|, |enabled_| and drawn.
777 virtual bool IsFocusable() const;
779 // Return whether this view is focusable when the user requires full keyboard
780 // access, even though it may not be normally focusable.
781 bool IsAccessibilityFocusable() const;
783 // Set whether this view can be made focusable if the user requires
784 // full keyboard access, even though it's not normally focusable.
785 // Note that this is false by default.
786 void SetAccessibilityFocusable(bool accessibility_focusable);
788 // Convenience method to retrieve the FocusManager associated with the
789 // Widget that contains this view. This can return NULL if this view is not
790 // part of a view hierarchy with a Widget.
791 virtual FocusManager* GetFocusManager();
792 virtual const FocusManager* GetFocusManager() const;
794 // Request keyboard focus. The receiving view will become the focused view.
795 virtual void RequestFocus();
797 // Invoked when a view is about to be requested for focus due to the focus
798 // traversal. Reverse is this request was generated going backward
800 virtual void AboutToRequestFocusFromTabTraversal(bool reverse) {}
802 // Invoked when a key is pressed before the key event is processed (and
803 // potentially eaten) by the focus manager for tab traversal, accelerators and
804 // other focus related actions.
805 // The default implementation returns false, ensuring that tab traversal and
806 // accelerators processing is performed.
807 // Subclasses should return true if they want to process the key event and not
808 // have it processed as an accelerator (if any) or as a tab traversal (if the
809 // key event is for the TAB key). In that case, OnKeyPressed will
810 // subsequently be invoked for that event.
811 virtual bool SkipDefaultKeyEventProcessing(const ui::KeyEvent& event);
813 // Subclasses that contain traversable children that are not directly
814 // accessible through the children hierarchy should return the associated
815 // FocusTraversable for the focus traversal to work properly.
816 virtual FocusTraversable* GetFocusTraversable();
818 // Subclasses that can act as a "pane" must implement their own
819 // FocusTraversable to keep the focus trapped within the pane.
820 // If this method returns an object, any view that's a direct or
821 // indirect child of this view will always use this FocusTraversable
822 // rather than the one from the widget.
823 virtual FocusTraversable* GetPaneFocusTraversable();
825 // Tooltips ------------------------------------------------------------------
827 // Gets the tooltip for this View. If the View does not have a tooltip,
828 // return false. If the View does have a tooltip, copy the tooltip into
829 // the supplied string and return true.
830 // Any time the tooltip text that a View is displaying changes, it must
831 // invoke TooltipTextChanged.
832 // |p| provides the coordinates of the mouse (relative to this view).
833 virtual bool GetTooltipText(const gfx::Point& p,
834 base::string16* tooltip) const;
836 // Returns the location (relative to this View) for the text on the tooltip
837 // to display. If false is returned (the default), the tooltip is placed at
838 // a default position.
839 virtual bool GetTooltipTextOrigin(const gfx::Point& p, gfx::Point* loc) const;
841 // Context menus -------------------------------------------------------------
843 // Sets the ContextMenuController. Setting this to non-null makes the View
844 // process mouse events.
845 ContextMenuController* context_menu_controller() {
846 return context_menu_controller_;
848 void set_context_menu_controller(ContextMenuController* menu_controller) {
849 context_menu_controller_ = menu_controller;
852 // Provides default implementation for context menu handling. The default
853 // implementation calls the ShowContextMenu of the current
854 // ContextMenuController (if it is not NULL). Overridden in subclassed views
855 // to provide right-click menu display triggerd by the keyboard (i.e. for the
856 // Chrome toolbar Back and Forward buttons). No source needs to be specified,
857 // as it is always equal to the current View.
858 virtual void ShowContextMenu(const gfx::Point& p,
859 ui::MenuSourceType source_type);
861 // On some platforms, we show context menu on mouse press instead of release.
862 // This method returns true for those platforms.
863 static bool ShouldShowContextMenuOnMousePress();
865 // Drag and drop -------------------------------------------------------------
867 DragController* drag_controller() { return drag_controller_; }
868 void set_drag_controller(DragController* drag_controller) {
869 drag_controller_ = drag_controller;
872 // During a drag and drop session when the mouse moves the view under the
873 // mouse is queried for the drop types it supports by way of the
874 // GetDropFormats methods. If the view returns true and the drag site can
875 // provide data in one of the formats, the view is asked if the drop data
876 // is required before any other drop events are sent. Once the
877 // data is available the view is asked if it supports the drop (by way of
878 // the CanDrop method). If a view returns true from CanDrop,
879 // OnDragEntered is sent to the view when the mouse first enters the view,
880 // as the mouse moves around within the view OnDragUpdated is invoked.
881 // If the user releases the mouse over the view and OnDragUpdated returns a
882 // valid drop, then OnPerformDrop is invoked. If the mouse moves outside the
883 // view or over another view that wants the drag, OnDragExited is invoked.
885 // Similar to mouse events, the deepest view under the mouse is first checked
886 // if it supports the drop (Drop). If the deepest view under
887 // the mouse does not support the drop, the ancestors are walked until one
888 // is found that supports the drop.
890 // Override and return the set of formats that can be dropped on this view.
891 // |formats| is a bitmask of the formats defined bye OSExchangeData::Format.
892 // The default implementation returns false, which means the view doesn't
894 virtual bool GetDropFormats(
896 std::set<OSExchangeData::CustomFormat>* custom_formats);
898 // Override and return true if the data must be available before any drop
899 // methods should be invoked. The default is false.
900 virtual bool AreDropTypesRequired();
902 // A view that supports drag and drop must override this and return true if
903 // data contains a type that may be dropped on this view.
904 virtual bool CanDrop(const OSExchangeData& data);
906 // OnDragEntered is invoked when the mouse enters this view during a drag and
907 // drop session and CanDrop returns true. This is immediately
908 // followed by an invocation of OnDragUpdated, and eventually one of
909 // OnDragExited or OnPerformDrop.
910 virtual void OnDragEntered(const ui::DropTargetEvent& event);
912 // Invoked during a drag and drop session while the mouse is over the view.
913 // This should return a bitmask of the DragDropTypes::DragOperation supported
914 // based on the location of the event. Return 0 to indicate the drop should
916 virtual int OnDragUpdated(const ui::DropTargetEvent& event);
918 // Invoked during a drag and drop session when the mouse exits the views, or
919 // when the drag session was canceled and the mouse was over the view.
920 virtual void OnDragExited();
922 // Invoked during a drag and drop session when OnDragUpdated returns a valid
923 // operation and the user release the mouse.
924 virtual int OnPerformDrop(const ui::DropTargetEvent& event);
926 // Invoked from DoDrag after the drag completes. This implementation does
927 // nothing, and is intended for subclasses to do cleanup.
928 virtual void OnDragDone();
930 // Returns true if the mouse was dragged enough to start a drag operation.
931 // delta_x and y are the distance the mouse was dragged.
932 static bool ExceededDragThreshold(const gfx::Vector2d& delta);
934 // Accessibility -------------------------------------------------------------
936 // Modifies |state| to reflect the current accessible state of this view.
937 virtual void GetAccessibleState(ui::AccessibleViewState* state) { }
939 // Returns an instance of the native accessibility interface for this view.
940 virtual gfx::NativeViewAccessible GetNativeViewAccessible();
942 // Notifies assistive technology that an accessibility event has
943 // occurred on this view, such as when the view is focused or when its
944 // value changes. Pass true for |send_native_event| except for rare
945 // cases where the view is a native control that's already sending a
946 // native accessibility event and the duplicate event would cause
948 void NotifyAccessibilityEvent(ui::AccessibilityTypes::Event event_type,
949 bool send_native_event);
951 // Scrolling -----------------------------------------------------------------
952 // TODO(beng): Figure out if this can live somewhere other than View, i.e.
953 // closer to ScrollView.
955 // Scrolls the specified region, in this View's coordinate system, to be
956 // visible. View's implementation passes the call onto the parent View (after
957 // adjusting the coordinates). It is up to views that only show a portion of
958 // the child view, such as Viewport, to override appropriately.
959 virtual void ScrollRectToVisible(const gfx::Rect& rect);
961 // The following methods are used by ScrollView to determine the amount
962 // to scroll relative to the visible bounds of the view. For example, a
963 // return value of 10 indicates the scrollview should scroll 10 pixels in
964 // the appropriate direction.
966 // Each method takes the following parameters:
968 // is_horizontal: if true, scrolling is along the horizontal axis, otherwise
969 // the vertical axis.
970 // is_positive: if true, scrolling is by a positive amount. Along the
971 // vertical axis scrolling by a positive amount equates to
974 // The return value should always be positive and gives the number of pixels
975 // to scroll. ScrollView interprets a return value of 0 (or negative)
976 // to scroll by a default amount.
978 // See VariableRowHeightScrollHelper and FixedRowHeightScrollHelper for
979 // implementations of common cases.
980 virtual int GetPageScrollIncrement(ScrollView* scroll_view,
981 bool is_horizontal, bool is_positive);
982 virtual int GetLineScrollIncrement(ScrollView* scroll_view,
983 bool is_horizontal, bool is_positive);
986 // Used to track a drag. RootView passes this into
987 // ProcessMousePressed/Dragged.
989 // Sets possible_drag to false and start_x/y to 0. This is invoked by
990 // RootView prior to invoke ProcessMousePressed.
993 // Sets possible_drag to true and start_pt to the specified point.
994 // This is invoked by the target view if it detects the press may generate
996 void PossibleDrag(const gfx::Point& p);
998 // Whether the press may generate a drag.
1001 // Coordinates of the mouse press.
1002 gfx::Point start_pt;
1005 // Size and disposition ------------------------------------------------------
1007 // Override to be notified when the bounds of the view have changed.
1008 virtual void OnBoundsChanged(const gfx::Rect& previous_bounds);
1010 // Called when the preferred size of a child view changed. This gives the
1011 // parent an opportunity to do a fresh layout if that makes sense.
1012 virtual void ChildPreferredSizeChanged(View* child) {}
1014 // Called when the visibility of a child view changed. This gives the parent
1015 // an opportunity to do a fresh layout if that makes sense.
1016 virtual void ChildVisibilityChanged(View* child) {}
1018 // Invalidates the layout and calls ChildPreferredSizeChanged on the parent
1019 // if there is one. Be sure to call View::PreferredSizeChanged when
1020 // overriding such that the layout is properly invalidated.
1021 virtual void PreferredSizeChanged();
1023 // Override returning true when the view needs to be notified when its visible
1024 // bounds relative to the root view may have changed. Only used by
1026 virtual bool NeedsNotificationWhenVisibleBoundsChange() const;
1028 // Notification that this View's visible bounds relative to the root view may
1029 // have changed. The visible bounds are the region of the View not clipped by
1030 // its ancestors. This is used for clipping NativeViewHost.
1031 virtual void OnVisibleBoundsChanged();
1033 // Override to be notified when the enabled state of this View has
1034 // changed. The default implementation calls SchedulePaint() on this View.
1035 virtual void OnEnabledChanged();
1037 // Tree operations -----------------------------------------------------------
1039 // This method is invoked when the tree changes.
1041 // When a view is removed, it is invoked for all children and grand
1042 // children. For each of these views, a notification is sent to the
1043 // view and all parents.
1045 // When a view is added, a notification is sent to the view, all its
1046 // parents, and all its children (and grand children)
1048 // Default implementation does nothing. Override to perform operations
1049 // required when a view is added or removed from a view hierarchy
1051 // Refer to comments in struct |ViewHierarchyChangedDetails| for |details|.
1052 virtual void ViewHierarchyChanged(const ViewHierarchyChangedDetails& details);
1054 // When SetVisible() changes the visibility of a view, this method is
1055 // invoked for that view as well as all the children recursively.
1056 virtual void VisibilityChanged(View* starting_from, bool is_visible);
1058 // This method is invoked when the parent NativeView of the widget that the
1059 // view is attached to has changed and the view hierarchy has not changed.
1060 // ViewHierarchyChanged() is called when the parent NativeView of the widget
1061 // that the view is attached to is changed as a result of changing the view
1062 // hierarchy. Overriding this method is useful for tracking which
1063 // FocusManager manages this view.
1064 virtual void NativeViewHierarchyChanged();
1066 // Painting ------------------------------------------------------------------
1068 // Responsible for calling Paint() on child Views. Override to control the
1069 // order child Views are painted.
1070 virtual void PaintChildren(gfx::Canvas* canvas);
1072 // Override to provide rendering in any part of the View's bounds. Typically
1073 // this is the "contents" of the view. If you override this method you will
1074 // have to call the subsequent OnPaint*() methods manually.
1075 virtual void OnPaint(gfx::Canvas* canvas);
1077 // Override to paint a background before any content is drawn. Typically this
1078 // is done if you are satisfied with a default OnPaint handler but wish to
1079 // supply a different background.
1080 virtual void OnPaintBackground(gfx::Canvas* canvas);
1082 // Override to paint a border not specified by SetBorder().
1083 virtual void OnPaintBorder(gfx::Canvas* canvas);
1085 // Accelerated painting ------------------------------------------------------
1087 // Returns the offset from this view to the nearest ancestor with a layer. If
1088 // |layer_parent| is non-NULL it is set to the nearest ancestor with a layer.
1089 virtual gfx::Vector2d CalculateOffsetToAncestorWithLayer(
1090 ui::Layer** layer_parent);
1092 // Updates the view's layer's parent. Called when a view is added to a view
1093 // hierarchy, responsible for parenting the view's layer to the enclosing
1094 // layer in the hierarchy.
1095 virtual void UpdateParentLayer();
1097 // If this view has a layer, the layer is reparented to |parent_layer| and its
1098 // bounds is set based on |point|. If this view does not have a layer, then
1099 // recurses through all children. This is used when adding a layer to an
1100 // existing view to make sure all descendants that have layers are parented to
1102 void MoveLayerToParent(ui::Layer* parent_layer, const gfx::Point& point);
1104 // Called to update the bounds of any child layers within this View's
1105 // hierarchy when something happens to the hierarchy.
1106 void UpdateChildLayerBounds(const gfx::Vector2d& offset);
1108 // Overridden from ui::LayerDelegate:
1109 virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE;
1110 virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE;
1111 virtual base::Closure PrepareForLayerBoundsChange() OVERRIDE;
1113 // Finds the layer that this view paints to (it may belong to an ancestor
1114 // view), then reorders the immediate children of that layer to match the
1115 // order of the view tree.
1116 virtual void ReorderLayers();
1118 // This reorders the immediate children of |*parent_layer| to match the
1119 // order of the view tree. Child layers which are owned by a view are
1120 // reordered so that they are below any child layers not owned by a view.
1121 // Widget::ReorderNativeViews() should be called to reorder any child layers
1122 // with an associated view. Widget::ReorderNativeViews() may reorder layers
1123 // below layers owned by a view.
1124 virtual void ReorderChildLayers(ui::Layer* parent_layer);
1126 // Input ---------------------------------------------------------------------
1128 // Called by HitTestRect() to see if this View has a custom hit test mask. If
1129 // the return value is true, GetHitTestMask() will be called to obtain the
1130 // mask. Default value is false, in which case the View will hit-test against
1132 virtual bool HasHitTestMask() const;
1134 // Called by HitTestRect() to retrieve a mask for hit-testing against.
1135 // Subclasses override to provide custom shaped hit test regions.
1136 virtual void GetHitTestMask(HitTestSource source, gfx::Path* mask) const;
1138 virtual DragInfo* GetDragInfo();
1140 // Focus ---------------------------------------------------------------------
1142 // Returns last value passed to SetFocusable(). Use IsFocusable() to determine
1143 // if a view can take focus right now.
1144 bool focusable() const { return focusable_; }
1146 // Override to be notified when focus has changed either to or from this View.
1147 virtual void OnFocus();
1148 virtual void OnBlur();
1150 // Handle view focus/blur events for this view.
1154 // System events -------------------------------------------------------------
1156 // Called when the UI theme (not the NativeTheme) has changed, overriding
1157 // allows individual Views to do special cleanup and processing (such as
1158 // dropping resource caches). To dispatch a theme changed notification, call
1159 // Widget::ThemeChanged().
1160 virtual void OnThemeChanged() {}
1162 // Called when the locale has changed, overriding allows individual Views to
1163 // update locale-dependent strings.
1164 // To dispatch a locale changed notification, call Widget::LocaleChanged().
1165 virtual void OnLocaleChanged() {}
1167 // Tooltips ------------------------------------------------------------------
1169 // Views must invoke this when the tooltip text they are to display changes.
1170 void TooltipTextChanged();
1172 // Context menus -------------------------------------------------------------
1174 // Returns the location, in screen coordinates, to show the context menu at
1175 // when the context menu is shown from the keyboard. This implementation
1176 // returns the middle of the visible region of this view.
1178 // This method is invoked when the context menu is shown by way of the
1180 virtual gfx::Point GetKeyboardContextMenuLocation();
1182 // Drag and drop -------------------------------------------------------------
1184 // These are cover methods that invoke the method of the same name on
1185 // the DragController. Subclasses may wish to override rather than install
1186 // a DragController.
1187 // See DragController for a description of these methods.
1188 virtual int GetDragOperations(const gfx::Point& press_pt);
1189 virtual void WriteDragData(const gfx::Point& press_pt, OSExchangeData* data);
1191 // Returns whether we're in the middle of a drag session that was initiated
1195 // Returns how much the mouse needs to move in one direction to start a
1196 // drag. These methods cache in a platform-appropriate way. These values are
1197 // used by the public static method ExceededDragThreshold().
1198 static int GetHorizontalDragThreshold();
1199 static int GetVerticalDragThreshold();
1201 // NativeTheme ---------------------------------------------------------------
1203 // Invoked when the NativeTheme associated with this View changes.
1204 virtual void OnNativeThemeChanged(const ui::NativeTheme* theme) {}
1206 // Debugging -----------------------------------------------------------------
1208 #if !defined(NDEBUG)
1209 // Returns string containing a graph of the views hierarchy in graphViz DOT
1210 // language (http://graphviz.org/). Can be called within debugger and save
1211 // to a file to compile/view.
1212 // Note: Assumes initial call made with first = true.
1213 virtual std::string PrintViewGraph(bool first);
1215 // Some classes may own an object which contains the children to displayed in
1216 // the views hierarchy. The above function gives the class the flexibility to
1217 // decide which object should be used to obtain the children, but this
1218 // function makes the decision explicit.
1219 std::string DoPrintViewGraph(bool first, View* view_with_children);
1223 friend class internal::PostEventDispatchHandler;
1224 friend class internal::RootView;
1225 friend class FocusManager;
1226 friend class Widget;
1228 // Painting -----------------------------------------------------------------
1230 enum SchedulePaintType {
1231 // Indicates the size is the same (only the origin changed).
1232 SCHEDULE_PAINT_SIZE_SAME,
1234 // Indicates the size changed (and possibly the origin).
1235 SCHEDULE_PAINT_SIZE_CHANGED
1238 // Invoked before and after the bounds change to schedule painting the old and
1240 void SchedulePaintBoundsChanged(SchedulePaintType type);
1242 // Common Paint() code shared by accelerated and non-accelerated code paths to
1243 // invoke OnPaint() on the View.
1244 void PaintCommon(gfx::Canvas* canvas);
1246 // Tree operations -----------------------------------------------------------
1248 // Removes |view| from the hierarchy tree. If |update_focus_cycle| is true,
1249 // the next and previous focusable views of views pointing to this view are
1250 // updated. If |update_tool_tip| is true, the tooltip is updated. If
1251 // |delete_removed_view| is true, the view is also deleted (if it is parent
1252 // owned). If |new_parent| is not NULL, the remove is the result of
1253 // AddChildView() to a new parent. For this case, |new_parent| is the View
1254 // that |view| is going to be added to after the remove completes.
1255 void DoRemoveChildView(View* view,
1256 bool update_focus_cycle,
1257 bool update_tool_tip,
1258 bool delete_removed_view,
1261 // Call ViewHierarchyChanged() for all child views and all parents.
1262 // |old_parent| is the original parent of the View that was removed.
1263 // If |new_parent| is not NULL, the View that was removed will be reparented
1264 // to |new_parent| after the remove operation.
1265 void PropagateRemoveNotifications(View* old_parent, View* new_parent);
1267 // Call ViewHierarchyChanged() for all children.
1268 void PropagateAddNotifications(const ViewHierarchyChangedDetails& details);
1270 // Propagates NativeViewHierarchyChanged() notification through all the
1272 void PropagateNativeViewHierarchyChanged();
1274 // Takes care of registering/unregistering accelerators if
1275 // |register_accelerators| true and calls ViewHierarchyChanged().
1276 void ViewHierarchyChangedImpl(bool register_accelerators,
1277 const ViewHierarchyChangedDetails& details);
1279 // Invokes OnNativeThemeChanged() on this and all descendants.
1280 void PropagateNativeThemeChanged(const ui::NativeTheme* theme);
1282 // Size and disposition ------------------------------------------------------
1284 // Call VisibilityChanged() recursively for all children.
1285 void PropagateVisibilityNotifications(View* from, bool is_visible);
1287 // Registers/unregisters accelerators as necessary and calls
1288 // VisibilityChanged().
1289 void VisibilityChangedImpl(View* starting_from, bool is_visible);
1291 // Responsible for propagating bounds change notifications to relevant
1293 void BoundsChanged(const gfx::Rect& previous_bounds);
1295 // Visible bounds notification registration.
1296 // When a view is added to a hierarchy, it and all its children are asked if
1297 // they need to be registered for "visible bounds within root" notifications
1298 // (see comment on OnVisibleBoundsChanged()). If they do, they are registered
1299 // with every ancestor between them and the root of the hierarchy.
1300 static void RegisterChildrenForVisibleBoundsNotification(View* view);
1301 static void UnregisterChildrenForVisibleBoundsNotification(View* view);
1302 void RegisterForVisibleBoundsNotification();
1303 void UnregisterForVisibleBoundsNotification();
1305 // Adds/removes view to the list of descendants that are notified any time
1306 // this views location and possibly size are changed.
1307 void AddDescendantToNotify(View* view);
1308 void RemoveDescendantToNotify(View* view);
1310 // Sets the layer's bounds given in DIP coordinates.
1311 void SetLayerBounds(const gfx::Rect& bounds_in_dip);
1313 // Transformations -----------------------------------------------------------
1315 // Returns in |transform| the transform to get from coordinates of |ancestor|
1316 // to this. Returns true if |ancestor| is found. If |ancestor| is not found,
1317 // or NULL, |transform| is set to convert from root view coordinates to this.
1318 bool GetTransformRelativeTo(const View* ancestor,
1319 gfx::Transform* transform) const;
1321 // Coordinate conversion -----------------------------------------------------
1323 // Convert a point in the view's coordinate to an ancestor view's coordinate
1324 // system using necessary transformations. Returns whether the point was
1325 // successfully converted to the ancestor's coordinate system.
1326 bool ConvertPointForAncestor(const View* ancestor, gfx::Point* point) const;
1328 // Convert a point in the ancestor's coordinate system to the view's
1329 // coordinate system using necessary transformations. Returns whether the
1330 // point was successfully converted from the ancestor's coordinate system
1331 // to the view's coordinate system.
1332 bool ConvertPointFromAncestor(const View* ancestor, gfx::Point* point) const;
1334 // Convert a rect in the view's coordinate to an ancestor view's coordinate
1335 // system using necessary transformations. Returns whether the rect was
1336 // successfully converted to the ancestor's coordinate system.
1337 bool ConvertRectForAncestor(const View* ancestor, gfx::RectF* rect) const;
1339 // Convert a rect in the ancestor's coordinate system to the view's
1340 // coordinate system using necessary transformations. Returns whether the
1341 // rect was successfully converted from the ancestor's coordinate system
1342 // to the view's coordinate system.
1343 bool ConvertRectFromAncestor(const View* ancestor, gfx::RectF* rect) const;
1345 // Accelerated painting ------------------------------------------------------
1347 // Creates the layer and related fields for this view.
1350 // Parents all un-parented layers within this view's hierarchy to this view's
1352 void UpdateParentLayers();
1354 // Parents this view's layer to |parent_layer|, and sets its bounds and other
1355 // properties in accordance to |offset|, the view's offset from the
1357 void ReparentLayer(const gfx::Vector2d& offset, ui::Layer* parent_layer);
1359 // Called to update the layer visibility. The layer will be visible if the
1360 // View itself, and all its parent Views are visible. This also updates
1361 // visibility of the child layers.
1362 void UpdateLayerVisibility();
1363 void UpdateChildLayerVisibility(bool visible);
1365 // Orphans the layers in this subtree that are parented to layers outside of
1367 void OrphanLayers();
1369 // Destroys the layer associated with this view, and reparents any descendants
1370 // to the destroyed layer's parent.
1371 void DestroyLayer();
1373 // Input ---------------------------------------------------------------------
1375 bool ProcessMousePressed(const ui::MouseEvent& event);
1376 bool ProcessMouseDragged(const ui::MouseEvent& event);
1377 void ProcessMouseReleased(const ui::MouseEvent& event);
1379 // Accelerators --------------------------------------------------------------
1381 // Registers this view's keyboard accelerators that are not registered to
1382 // FocusManager yet, if possible.
1383 void RegisterPendingAccelerators();
1385 // Unregisters all the keyboard accelerators associated with this view.
1386 // |leave_data_intact| if true does not remove data from accelerators_ array,
1387 // so it could be re-registered with other focus manager
1388 void UnregisterAccelerators(bool leave_data_intact);
1390 // Focus ---------------------------------------------------------------------
1392 // Initialize the previous/next focusable views of the specified view relative
1393 // to the view at the specified index.
1394 void InitFocusSiblings(View* view, int index);
1396 // System events -------------------------------------------------------------
1398 // Used to propagate theme changed notifications from the root view to all
1399 // views in the hierarchy.
1400 virtual void PropagateThemeChanged();
1402 // Used to propagate locale changed notifications from the root view to all
1403 // views in the hierarchy.
1404 virtual void PropagateLocaleChanged();
1406 // Tooltips ------------------------------------------------------------------
1408 // Propagates UpdateTooltip() to the TooltipManager for the Widget.
1409 // This must be invoked any time the View hierarchy changes in such a way
1410 // the view under the mouse differs. For example, if the bounds of a View is
1411 // changed, this is invoked. Similarly, as Views are added/removed, this
1413 void UpdateTooltip();
1415 // Drag and drop -------------------------------------------------------------
1417 // Starts a drag and drop operation originating from this view. This invokes
1418 // WriteDragData to write the data and GetDragOperations to determine the
1419 // supported drag operations. When done, OnDragDone is invoked. |press_pt| is
1420 // in the view's coordinate system.
1421 // Returns true if a drag was started.
1422 bool DoDrag(const ui::LocatedEvent& event,
1423 const gfx::Point& press_pt,
1424 ui::DragDropTypes::DragEventSource source);
1426 //////////////////////////////////////////////////////////////////////////////
1428 // Creation and lifetime -----------------------------------------------------
1430 // False if this View is owned by its parent - i.e. it will be deleted by its
1431 // parent during its parents destruction. False is the default.
1432 bool owned_by_client_;
1434 // Attributes ----------------------------------------------------------------
1436 // The id of this View. Used to find this View.
1439 // The group of this view. Some view subclasses use this id to find other
1440 // views of the same group. For example radio button uses this information
1441 // to find other radio buttons.
1444 // Tree operations -----------------------------------------------------------
1446 // This view's parent.
1449 // This view's children.
1452 // Size and disposition ------------------------------------------------------
1454 // This View's bounds in the parent coordinate system.
1457 // Whether this view is visible.
1460 // Whether this view is enabled.
1463 // When this flag is on, a View receives a mouse-enter and mouse-leave event
1464 // even if a descendant View is the event-recipient for the real mouse
1465 // events. When this flag is turned on, and mouse moves from outside of the
1466 // view into a child view, both the child view and this view receives
1467 // mouse-enter event. Similarly, if the mouse moves from inside a child view
1468 // and out of this view, then both views receive a mouse-leave event.
1469 // When this flag is turned off, if the mouse moves from inside this view into
1470 // a child view, then this view receives a mouse-leave event. When this flag
1471 // is turned on, it does not receive the mouse-leave event in this case.
1472 // When the mouse moves from inside the child view out of the child view but
1473 // still into this view, this view receives a mouse-enter event if this flag
1474 // is turned off, but doesn't if this flag is turned on.
1475 // This flag is initialized to false.
1476 bool notify_enter_exit_on_child_;
1478 // Whether or not RegisterViewForVisibleBoundsNotification on the RootView
1479 // has been invoked.
1480 bool registered_for_visible_bounds_notification_;
1482 // List of descendants wanting notification when their visible bounds change.
1483 scoped_ptr<Views> descendants_to_notify_;
1485 // Transformations -----------------------------------------------------------
1487 // Clipping parameters. skia transformation matrix does not give us clipping.
1488 // So we do it ourselves.
1489 gfx::Insets clip_insets_;
1491 // Layout --------------------------------------------------------------------
1493 // Whether the view needs to be laid out.
1496 // The View's LayoutManager defines the sizing heuristics applied to child
1497 // Views. The default is absolute positioning according to bounds_.
1498 scoped_ptr<LayoutManager> layout_manager_;
1500 // Painting ------------------------------------------------------------------
1503 scoped_ptr<Background> background_;
1506 scoped_ptr<Border> border_;
1508 // RTL painting --------------------------------------------------------------
1510 // Indicates whether or not the gfx::Canvas object passed to View::Paint()
1511 // is going to be flipped horizontally (using the appropriate transform) on
1512 // right-to-left locales for this View.
1513 bool flip_canvas_on_paint_for_rtl_ui_;
1515 // Accelerated painting ------------------------------------------------------
1517 bool paint_to_layer_;
1519 // Accelerators --------------------------------------------------------------
1521 // Focus manager accelerators registered on.
1522 FocusManager* accelerator_focus_manager_;
1524 // The list of accelerators. List elements in the range
1525 // [0, registered_accelerator_count_) are already registered to FocusManager,
1526 // and the rest are not yet.
1527 scoped_ptr<std::vector<ui::Accelerator> > accelerators_;
1528 size_t registered_accelerator_count_;
1530 // Focus ---------------------------------------------------------------------
1532 // Next view to be focused when the Tab key is pressed.
1533 View* next_focusable_view_;
1535 // Next view to be focused when the Shift-Tab key combination is pressed.
1536 View* previous_focusable_view_;
1538 // Whether this view can be focused.
1541 // Whether this view is focusable if the user requires full keyboard access,
1542 // even though it may not be normally focusable.
1543 bool accessibility_focusable_;
1545 // Context menus -------------------------------------------------------------
1547 // The menu controller.
1548 ContextMenuController* context_menu_controller_;
1550 // Drag and drop -------------------------------------------------------------
1552 DragController* drag_controller_;
1554 // Input --------------------------------------------------------------------
1556 scoped_ptr<internal::PostEventDispatchHandler> post_dispatch_handler_;
1558 // Accessibility -------------------------------------------------------------
1560 // Belongs to this view, but it's reference-counted on some platforms
1561 // so we can't use a scoped_ptr. It's dereferenced in the destructor.
1562 NativeViewAccessibility* native_view_accessibility_;
1564 DISALLOW_COPY_AND_ASSIGN(View);
1567 } // namespace views
1569 #endif // UI_VIEWS_VIEW_H_