V2

ui/views/view.cc

+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/views/view.h"
+
+#include <algorithm>
+#include <functional>
+
+#include "gfx/canvas.h"
+#include "gfx/point.h"
+#include "gfx/size.h"
+#include "ui/base/dragdrop/drag_drop_types.h"
+#include "ui/views/events/context_menu_controller.h"
+#include "ui/views/events/drag_controller.h"
+#include "ui/views/layout/layout_manager.h"
+#include "ui/views/rendering/border.h"
+#include "ui/views/widget/widget.h"
+
+namespace ui {
+
+namespace {
+
+// Saves gfx::Canvas state upon construction and automatically restores it when
+// it goes out of scope.
+class ScopedCanvasState {
+ public:
+  explicit ScopedCanvasState(gfx::Canvas* canvas) : canvas_(canvas) {
+    canvas_->Save();
+  }
+  ~ScopedCanvasState() {
+    canvas_->Restore();
+  }
+
+ private:
+  gfx::Canvas* canvas_;
+  DISALLOW_COPY_AND_ASSIGN(ScopedCanvasState);
+};
+
+bool ExceededDragThreshold(const gfx::Point& press_point,
+                           const gfx::Point& event_point) {
+  // TODO(beng): implement
+  return true;
+}
+
+}  // namespace
+
+////////////////////////////////////////////////////////////////////////////////
+// View, public:
+
+View::View()
+    : parent_(NULL),
+      parent_owned_(true),
+      visible_(true),
+      enabled_(true),
+      id_(-1),
+      group_(-1),
+      focusable_(false),
+      context_menu_controller_(NULL),
+      drag_controller_(NULL) {
+}
+
+View::~View() {
+  if (parent_)
+    parent_->RemoveChildView(this);
+
+  ViewVector::const_iterator it = children_.begin();
+  for (; it != children_.end(); ++it) {
+    (*it)->parent_ = NULL;
+    if ((*it)->parent_owned())
+      delete *it;
+  }
+}
+
+// Size and disposition --------------------------------------------------------
+
+void View::SetBounds(int x, int y, int width, int height) {
+  SetBoundsRect(gfx::Rect(x, y, std::max(0, width), std::max(0, height)));
+}
+
+void View::SetBoundsRect(const gfx::Rect& bounds) {
+  gfx::Rect old_bounds = bounds_;
+  bounds_ = bounds;
+  // TODO(beng): investigate usage of needs_layout_ in old View code.
+  if (old_bounds != bounds_) {
+    OnBoundsChanged();
+    Layout();
+  }
+}
+
+gfx::Rect View::GetVisibleBounds() const {
+  // TODO(beng):
+  return bounds();
+}
+
+void View::SetSize(const gfx::Size& size) {
+  SetBounds(x(), y(), size.width(), size.height());
+}
+
+void View::SetPosition(const gfx::Point& position) {
+  SetBounds(position.x(), position.y(), width(), height());
+}
+
+void View::SetBorder(Border* border) {
+  border_.reset(border);
+}
+
+gfx::Rect View::GetContentsBounds() const {
+  if (border_.get()) {
+    return gfx::Rect(
+        border_->insets().left(), border_->insets().top(),
+        width() - border_->insets().right() - border_->insets().left(),
+        height() - border_->insets().bottom() - border_->insets().top());
+  }
+  return gfx::Rect(0, 0, width(), height());
+}
+
+void View::OnBoundsChanged() {
+}
+
+gfx::Size View::GetPreferredSize() const {
+  return gfx::Size();
+}
+
+gfx::Size View::GetMinimumSize() const {
+  return GetPreferredSize();
+}
+
+void View::SetLayoutManager(LayoutManager* layout_manager) {
+  layout_manager_.reset(layout_manager);
+}
+
+void View::Layout() {
+  if (layout_manager_.get()) {
+    // Layout Manager handles laying out children.
+    layout_manager_->Layout(this);
+  } else {
+    // We handle laying out our own children.
+    ViewVector::iterator it = children_.begin();
+    for (; it != children_.end(); ++it)
+      (*it)->Layout();
+  }
+  // TODO(beng): needs_layout_? SchedulePaint()?
+}
+
+void View::SetVisible(bool visible) {
+  if (visible != visible_) {
+    visible_ = visible;
+
+    // InvaldateRect() checks for view visibility before proceeding, so we need
+    // to ask the parent to invalidate our bounds.
+    if (parent_)
+      parent_->InvalidateRect(bounds_);
+  }
+}
+
+void View::SetEnabled(bool enabled) {
+  if (enabled != enabled_) {
+    enabled_ = enabled;
+    Invalidate();
+  }
+}
+
+// Coordinate conversion -------------------------------------------------------
+
+// static
+void View::ConvertPointToView(View* source, View* target, gfx::Point* point) {
+  View* inner = NULL;
+  View* outer = NULL;
+  if (source->Contains(target)) {
+    inner = target;
+    outer = source;
+  } else if (target->Contains(source)) {
+    inner = source;
+    outer = target;
+  } // Note that we cannot do a plain "else" here since |source| and |target|
+    // may be in different hierarchies with no relation.
+
+  if (inner && outer) {
+    gfx::Point offset;
+    View* temp = inner;
+    while (temp != outer) {
+      offset.Offset(temp->x(), temp->y());
+      temp = temp->parent();
+    }
+    // When target is contained by source, we need to subtract the offset.
+    // When source is contained by target, we need to add the fofset.
+    int multiplier = inner == target ? -1 : 1;
+    point->Offset(multiplier * offset.x(), multiplier * offset.y());
+  }
+}
+
+// static
+void View::ConvertPointToScreen(View* source, gfx::Point* point) {
+  Widget* widget = source->GetWidget();
+  if (widget) {
+    ConvertPointToWidget(source, point);
+    gfx::Rect r = widget->GetClientAreaScreenBounds();
+    point->Offset(r.x(), r.y());
+  }
+}
+
+// static
+void View::ConvertPointToWidget(View* source, gfx::Point* point) {
+  for (View* v = source; v; v = v->parent())
+    point->Offset(v->x(), v->y());
+}
+
+// Tree operations -------------------------------------------------------------
+
+Widget* View::GetWidget() const {
+  return parent_ ? parent_->GetWidget() : NULL;
+}
+
+void View::AddChildView(View* view) {
+  AddChildViewAt(view, children_.size());
+}
+
+void View::AddChildViewAt(View* view, size_t index) {
+  CHECK(view != this) << "A view cannot be its own child.";
+
+  // Remove the child from its current parent if any.
+  if (view->parent())
+    view->parent()->RemoveChildView(view);
+
+  children_.insert(children_.begin() + index, view);
+  view->parent_ = this;
+
+  // Notify the hierarchy.
+  NotifyHierarchyChanged(this, view, true);
+
+  // TODO(beng): Notify other objects like tooltip, layout manager, etc.
+  //             Figure out RegisterChildrenForVisibleBoundsNotification.
+}
+
+View* View::RemoveChildView(View* view) {
+  ViewVector::iterator it = find(children_.begin(), children_.end(), view);
+  if (it != children_.end()) {
+    View* old_parent = view->parent_;
+    view->parent_ = NULL;
+    children_.erase(it);
+    NotifyHierarchyChanged(old_parent, view, false);
+  }
+
+  // TODO(beng): Notify other objects like tooltip, layout manager, etc.
+  return view;
+}
+
+void View::RemoveAllChildViews(bool delete_children) {
+  // TODO(beng): use for_each.
+  ViewVector::iterator it = children_.begin();
+  while (it != children_.end()) {
+    View* v = RemoveChildView(*it);
+    if (delete_children)
+      delete v;
+    // TODO(beng): view deletion is actually more complicated in the old view.cc
+    //             figure out why. (it uses a ScopedVector to accumulate a list
+    //             of views to delete).
+  }
+}
+
+View* View::GetChildViewAt(size_t index) {
+  CHECK(index < child_count());
+  return children_[index];
+}
+
+bool View::Contains(View* child) {
+  while (child) {
+    if (child == this)
+      return true;
+    child = child->parent();
+  }
+  return false;
+}
+
+View* View::GetViewForPoint(const gfx::Point& point) const {
+  ViewVector::const_reverse_iterator it = children_.rbegin();
+  for (; it != children_.rend(); ++it) {
+    View* child = *it;
+    if (!child->visible())
+      continue;
+
+    gfx::Point point_in_child_coords(point);
+    View::ConvertPointToView(const_cast<View*>(this), child,
+                             &point_in_child_coords);
+    if (child->HitTest(point_in_child_coords))
+      return child->GetViewForPoint(point_in_child_coords);
+  }
+  return const_cast<View*>(this);
+}
+
+bool View::HitTest(const gfx::Point& point) const {
+  // TODO(beng): Hit test mask support.
+  return gfx::Rect(0, 0, width(), height()).Contains(point);
+}
+
+View* View::GetViewById(int id) const {
+  if (id_ == id)
+    return const_cast<View*>(this);
+  ViewVector::const_iterator it = children_.begin();
+  for (; it != children_.end(); ++it) {
+    View* view = (*it)->GetViewById(id);
+    if (view)
+      return view;
+  }
+  return NULL;
+}
+
+void View::GetViewsWithGroup(int group, ViewVector* vec) const {
+  if (group_ == group)
+    vec->push_back(const_cast<View*>(this));
+  ViewVector::const_iterator it = children_.begin();
+  for (; it != children_.end(); ++it)
+    (*it)->GetViewsWithGroup(group, vec);
+}
+
+void View::OnViewAdded(View* parent, View* child) {
+}
+
+void View::OnViewRemoved(View* parent, View* child) {
+}
+
+void View::OnViewAddedToWidget() {
+}
+
+void View::OnViewRemovedFromWidget() {
+}
+
+// Accelerators ----------------------------------------------------------------
+
+void View::AddAccelerator(const Accelerator& accelerator) {
+}
+
+void View::RemoveAccelerator(const Accelerator& accelerator) {
+}
+
+void View::RemoveAllAccelerators() {
+}
+
+bool View::OnAcceleratorPressed(const Accelerator& accelerator) {
+  return false;
+}
+
+// Focus -----------------------------------------------------------------------
+
+FocusManager* View::GetFocusManager() const {
+  return NULL;
+}
+
+FocusTraversable* View::GetFocusTraversable() const {
+  return NULL;
+}
+
+View* View::GetNextFocusableView() const {
+  return NULL;
+}
+
+View* View::GetPreviousFocusableView() const {
+  return NULL;
+}
+
+bool View::SkipDefaultKeyEventProcessing(const KeyEvent& event) const {
+  return false;
+}
+
+bool View::IsFocusable() const {
+  return false;
+}
+
+bool View::HasFocus() const {
+  return false;
+}
+
+void View::RequestFocus() {
+}
+
+void View::OnFocus(/* const FocusEvent& event */) {
+}
+
+void View::OnBlur() {
+}
+
+// Input -----------------------------------------------------------------------
+
+bool View::OnKeyPressed(const KeyEvent& event) {
+  return true;
+}
+
+bool View::OnKeyReleased(const KeyEvent& event) {
+  return true;
+}
+
+bool View::OnMouseWheel(const MouseWheelEvent& event) {
+  return true;
+}
+
+bool View::OnMousePressed(const MouseEvent& event) {
+  return true;
+}
+
+bool View::OnMouseDragged(const MouseEvent& event) {
+  return true;
+}
+
+void View::OnMouseReleased(const MouseEvent& event) {
+
+}
+
+void View::OnMouseCaptureLost() {
+
+}
+
+void View::OnMouseMoved(const MouseEvent& event) {
+
+}
+
+void View::OnMouseEntered(const MouseEvent& event) {
+
+}
+
+void View::OnMouseExited(const MouseEvent& event) {
+
+}
+
+gfx::NativeCursor View::GetCursorForPoint(const gfx::Point& point) {
+  return NULL;
+}
+
+// Painting --------------------------------------------------------------------
+
+void View::Invalidate() {
+  InvalidateRect(gfx::Rect(0, 0, width(), height()));
+}
+
+void View::InvalidateRect(const gfx::Rect& invalid_rect) {
+  if (!visible_)
+    return;
+
+  if (parent_) {
+    gfx::Rect r = invalid_rect;
+    r.Offset(bounds_.origin());
+    parent_->InvalidateRect(r);
+  }
+}
+
+void View::Paint(gfx::Canvas* canvas) {
+  // Invisible views are not painted.
+  if (!visible_)
+    return;
+
+  ScopedCanvasState canvas_state(canvas);
+  if (canvas->ClipRectInt(x(), y(), width(), height())) {
+    canvas->TranslateInt(x(), y());
+    // TODO(beng): RTL
+    ScopedCanvasState canvas_state(canvas);
+    OnPaint(canvas);
+    PaintChildren(canvas);
+  }
+}
+
+void View::PaintChildren(gfx::Canvas* canvas) {
+  // TODO(beng): use for_each.
+  // std::for_each(children_.begin(), children_.end(),
+  //              std::bind2nd(std::mem_fun_ref(&View::Paint), canvas));
+  ViewVector::iterator it = children_.begin();
+  for (; it != children_.end(); ++it)
+    (*it)->Paint(canvas);
+}
+
+void View::OnPaint(gfx::Canvas* canvas) {
+  // TODO(beng): investigate moving these function calls to Paint().
+  OnPaintBackground(canvas);
+  OnPaintFocusBorder(canvas);
+  OnPaintBorder(canvas);
+}
+
+void View::OnPaintBackground(gfx::Canvas* canvas) {
+}
+
+void View::OnPaintBorder(gfx::Canvas* canvas) {
+  if (border_.get())
+    border_->Paint(const_cast<const View*>(this), canvas);
+}
+
+void View::OnPaintFocusBorder(gfx::Canvas* canvas) {
+}
+
+// Resources -------------------------------------------------------------------
+
+ThemeProvider* View::GetThemeProvider() const {
+  Widget* widget = GetWidget();
+  return widget ? widget->GetThemeProvider() : NULL;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// View, private:
+
+void View::DragInfo::Reset() {
+  possible_drag = false;
+  press_point = gfx::Point();
+}
+
+void View::DragInfo::PossibleDrag(const gfx::Point& point) {
+  possible_drag = true;
+  press_point = point;
+}
+
+// Drag & Drop -----------------------------------------------------------------
+
+int View::GetDragOperations(const gfx::Point& point) {
+  return drag_controller_ ?
+      drag_controller_->GetDragOperations(const_cast<View*>(this), point) :
+      DragDropTypes::DRAG_NONE;
+}
+
+void View::WriteDragData(const gfx::Point& point, OSExchangeData* data) {
+  drag_controller_->WriteDragData(this, point, data);
+}
+
+void View::StartShellDrag(const MouseEvent& event,
+                          const gfx::Point& press_point) {
+  // TODO(beng): system stuff.
+}
+
+// RootView API ----------------------------------------------------------------
+
+bool View::MousePressed(const MouseEvent& event, DragInfo* drag_info) {
+  bool handled = OnMousePressed(event);
+  // TODO(beng): deal with view deletion, see ProcessMousePressed() in old code.
+  if (!enabled_)
+    return handled;
+
+  int drag_operations =
+      enabled_ && event.IsOnlyLeftMouseButton() && HitTest(event.location()) ?
+      GetDragOperations(event.location()) : DragDropTypes::DRAG_NONE;
+  if (drag_operations != DragDropTypes::DRAG_NONE) {
+    drag_info->PossibleDrag(event.location());
+    return true;
+  }
+  bool has_context_menu = event.IsRightMouseButton() ?
+      !!context_menu_controller_ : NULL;
+  return has_context_menu || handled;
+}
+
+bool View::MouseDragged(const MouseEvent& event, DragInfo* drag_info) {
+  if (drag_info->possible_drag &&
+      ExceededDragThreshold(drag_info->press_point, event.location())) {
+    if (!drag_controller_ ||
+        drag_controller_->CanStartDrag(this, drag_info->press_point,
+                                       event.location())) {
+      StartShellDrag(event, drag_info->press_point);
+    }
+  } else {
+    if (OnMouseDragged(event))
+      return true;
+  }
+  // TODO(beng): Handle view deletion from OnMouseDragged().
+  return !!context_menu_controller_ || drag_info->possible_drag;
+}
+
+void View::MouseReleased(const MouseEvent& event) {
+  OnMouseReleased(event);
+  // TODO(beng): Handle view deletion from OnMouseReleased().
+  if (context_menu_controller_ && event.IsOnlyRightMouseButton()) {
+    gfx::Point location(event.location());
+    if (HitTest(location)) {
+      ConvertPointToScreen(this, &location);
+      context_menu_controller_->ShowContextMenu(this, location, true);
+    }
+  }
+}
+
+// Tree operations -------------------------------------------------------------
+
+void View::NotifyHierarchyChanged(View* parent, View* child, bool is_add) {
+  // Notify the child. Note that we call GetWidget() on the parent, not the
+  // child, since this method is called after the child is already removed from
+  // the hierarchy when |is_add| is false and so child->GetWidget() will always
+  // return NULL.
+  bool has_widget = parent->GetWidget() != NULL;
+  CallViewNotification(child, parent, child, is_add, has_widget);
+
+  // Notify the hierarchy up.
+  NotifyHierarchyChangedUp(parent, child, is_add);
+
+  // Notify the hierarchy down.
+  if (!is_add) {
+    // Because |child| has already been removed from |parent|'s child list, we
+    // need to notify its hierarchy manually.
+    child->NotifyHierarchyChangedDown(parent, child, is_add, has_widget);
+  }
+  NotifyHierarchyChangedDown(parent, child, is_add, has_widget);
+}
+
+void View::NotifyHierarchyChangedUp(View* parent, View* child, bool is_add) {
+  for (View* v = parent; v; v = v->parent()) {
+    if (is_add)
+      v->OnViewAdded(parent, child);
+    else
+      v->OnViewRemoved(parent, child);
+  }
+}
+
+void View::NotifyHierarchyChangedDown(View* parent, View* child, bool is_add,
+                                       bool has_widget) {
+  ViewVector::iterator it = children_.begin();
+  for (; it != children_.end(); ++it) {
+    CallViewNotification(*it, parent, child, is_add, has_widget);
+    (*it)->NotifyHierarchyChangedDown(parent, child, is_add, has_widget);
+  }
+}
+
+void View::CallViewNotification(View* target,
+                                View* parent,
+                                View* child,
+                                bool is_add,
+                                bool has_widget) {
+  if (is_add) {
+    target->OnViewAdded(parent, child);
+    if (has_widget)
+      target->OnViewAddedToWidget();
+  } else {
+    target->OnViewRemoved(parent, child);
+    if (has_widget)
+      target->OnViewRemovedFromWidget();
+  }
+}
+
+}  // namespace ui