Variety of tweaks to View API.

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 "views/view.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 81 matching lines @@
 }
 
 // Creation and lifetime -------------------------------------------------------
 
 View::View()
     : enabled_(true),
       id_(0),
       group_(-1),
       focusable_(false),
       accessibility_focusable_(false),
-      is_parent_owned_(true),
+      parent_owned_(true),
       parent_(NULL),
-      is_visible_(true),
+      visible_(true),
       registered_for_visible_bounds_notification_(false),
       clip_x_(0.0),
       clip_y_(0.0),
       needs_layout_(true),
       flip_canvas_on_paint_for_rtl_ui_(false),
 #if !defined(COMPOSITOR_2)
       texture_id_(0),  // TODO(sadrul): 0 can be a valid texture id.
 #endif
       texture_needs_updating_(true),
       accelerator_registration_delayed_(false),
       accelerator_focus_manager_(NULL),
       registered_accelerator_count_(0),
       next_focusable_view_(NULL),
       previous_focusable_view_(NULL),
       context_menu_controller_(NULL),
       drag_controller_(NULL) {
 }
 
 View::~View() {
   if (parent_)
     parent_->RemoveChildView(this);
 
   int c = static_cast<int>(children_.size());
   while (--c >= 0) {
-    children_[c]->SetParent(NULL);
-    if (children_[c]->IsParentOwned())
+    children_[c]->parent_ = NULL;
+    if (children_[c]->parent_owned())
       delete children_[c];
   }
 
 #if defined(OS_WIN)
   if (native_view_accessibility_win_.get())
     native_view_accessibility_win_->set_view(NULL);
 #endif
 }
 
 // Tree operations -------------------------------------------------------------
 
 const Widget* View::GetWidget() const {
   // The root view holds a reference to this view hierarchy's Widget.
   return parent_ ? parent_->GetWidget() : NULL;
 }
 
 Widget* View::GetWidget() {
   return const_cast<Widget*>(const_cast<const View*>(this)->GetWidget());
 }
 
+const Window* View::GetWindow() const {
+  const Widget* widget = GetWidget();
+  return widget ? widget->GetContainingWindow() : NULL;
+}
+
+Window* View::GetWindow() {
+  return const_cast<Window*>(const_cast<const View*>(this)->GetWindow());
+}
+
 void View::AddChildView(View* view) {
   AddChildViewAt(view, child_count());
 }
 
 void View::AddChildViewAt(View* view, int index) {
   CHECK(view != this) << "You cannot add a view as its own child";
 
   // Remove the view from its current parent if any.
   if (view->parent())
     view->parent()->RemoveChildView(view);
 
   // Sets the prev/next focus views.
   InitFocusSiblings(view, index);
 
   // Let's insert the view.
   children_.insert(children_.begin() + index, view);
-  view->SetParent(this);
+  view->parent_ = this;
 
   for (View* p = this; p; p = p->parent())
     p->ViewHierarchyChangedImpl(false, true, this, view);
 
   view->PropagateAddNotifications(this, view);
   UpdateTooltip();
   if (GetWidget())
     RegisterChildrenForVisibleBoundsNotification(view);
 
   if (layout_manager_.get())
@@ skipping 28 matching lines @@
   return false;
 }
 
 int View::GetIndexOf(const View* view) const {
   ViewVector::const_iterator it = std::find(children_.begin(), children_.end(),
                                             view);
   return it != children_.end() ? it - children_.begin() : -1;
 }
 
 // TODO(beng): remove
-const Window* View::GetWindow() const {
-  const Widget* widget = GetWidget();
-  return widget ? widget->GetContainingWindow() : NULL;
-}
-
-// TODO(beng): remove
-Window* View::GetWindow() {
-  return const_cast<Window*>(const_cast<const View*>(this)->GetWindow());
-}
-
-// TODO(beng): remove
 bool View::ContainsNativeView(gfx::NativeView native_view) const {
   for (int i = 0, count = child_count(); i < count; ++i) {
     if (GetChildViewAt(i)->ContainsNativeView(native_view))
       return true;
   }
   return false;
 }
 
 // Size and disposition --------------------------------------------------------
 
@@ skipping 108 matching lines @@
 gfx::Size View::GetMinimumSize() {
   return GetPreferredSize();
 }
 
 int View::GetHeightForWidth(int w) {
   if (layout_manager_.get())
     return layout_manager_->GetPreferredHeightForWidth(this, w);
   return GetPreferredSize().height();
 }
 
-void View::SetVisible(bool flag) {
-  if (flag != is_visible_) {
-    // If the tab is currently visible, schedule paint to
-    // refresh parent
-    if (IsVisible())
-      SchedulePaint();
-    else
-      ResetTexture();
-
-    is_visible_ = flag;
-
-    // This notifies all sub-views recursively.
-    PropagateVisibilityNotifications(this, flag);
-
-    // If we are newly visible, schedule paint.
-    if (IsVisible())
-      SchedulePaint();
-  }
-}
-
-bool View::IsVisible() const {
-  return is_visible_;
-}
-
-bool View::IsVisibleInRootView() const {
-  return IsVisible() && parent() ? parent()->IsVisibleInRootView() : false;
-}
-
-void View::SetEnabled(bool state) {
-  if (enabled_ != state) {
-    enabled_ = state;
-    SchedulePaint();
-  }
-}
-
-bool View::IsEnabled() const {
-  return enabled_;
-}
-
 // Transformations -------------------------------------------------------------
 
 const ui::Transform& View::GetTransform() const {
   static const ui::Transform* no_op = new ui::Transform;
   if (transform_.get())
     return *transform_.get();
   return *no_op;
 }
 
 void View::SetTransform(const ui::Transform& transform) {
@@ skipping 83 matching lines @@
   if (layout_manager_.get())
     layout_manager_->Uninstalled(this);
 
   layout_manager_.reset(layout_manager);
   if (layout_manager_.get())
     layout_manager_->Installed(this);
 }
 
 // Attributes ------------------------------------------------------------------
 
+void View::SetVisible(bool flag) {
+  if (flag != visible_) {
+    // If the tab is currently visible, schedule paint to
+    // refresh parent
+    if (visible())
+      SchedulePaint();
+    else
+      ResetTexture();
+
+    visible_ = flag;
+
+    // This notifies all sub-views recursively.
+    PropagateVisibilityNotifications(this, flag);
+
+    // If we are newly visible, schedule paint.
+    if (visible())
+      SchedulePaint();
+  }
+}
+
+bool View::IsVisibleInRootView() const {
+  return visible() && parent() ? parent()->IsVisibleInRootView() : false;
+}
+
+bool View::IsEnabled() const {
+  return enabled_;
+}
+
+void View::SetEnabled(bool enabled) {
+  if (enabled_ != enabled) {
+    enabled_ = enabled;
+    SchedulePaint();
+  }
+}
+
 std::string View::GetClassName() const {
   return kViewClassName;
 }
 
 View* View::GetAncestorWithClassName(const std::string& name) {
   for (View* view = this; view; view = view->parent()) {
     if (view->GetClassName() == name)
       return view;
   }
   return NULL;
 }
 
 const View* View::GetViewByID(int id) const {
   if (id == id_)
     return const_cast<View*>(this);
 
   for (int i = 0, count = child_count(); i < count; ++i) {
     const View* view = GetChildViewAt(i)->GetViewByID(id);
     if (view)
       return view;
   }
   return NULL;
 }
 
 View* View::GetViewByID(int id) {
   return const_cast<View*>(const_cast<const View*>(this)->GetViewByID(id));
 }
 
-void View::SetID(int id) {
-  id_ = id;
-}
-
-int View::GetID() const {
-  return id_;
-}
-
-void View::SetGroup(int gid) {
-  // Don't change the group id once it's set.
-  DCHECK(group_ == -1 || group_ == gid);
-  group_ = gid;
-}
-
-int View::GetGroup() const {
-  return group_;
+void View::set_group(int group) {
+  DCHECK(group_ == -1 || group_ == group);
+  group_ = group;
 }
 
 bool View::IsGroupFocusTraversable() const {
   return true;
 }
 
-void View::GetViewsWithGroup(int group_id, std::vector<View*>* out) {
-  if (group_ == group_id)
+void View::GetViewsInGroup(int group, std::vector<View*>* out) {
+  if (group_ == group)
     out->push_back(this);
 
   for (int i = 0, count = child_count(); i < count; ++i)
-    GetChildViewAt(i)->GetViewsWithGroup(group_id, out);
+    GetChildViewAt(i)->GetViewsInGroup(group, out);
 }
 
-View* View::GetSelectedViewForGroup(int group_id) {
+View* View::GetSelectedViewForGroup(int group) {
   std::vector<View*> views;
-  GetWidget()->GetRootView()->GetViewsWithGroup(group_id, &views);
+  GetWidget()->GetRootView()->GetViewsInGroup(group, &views);
   return views.empty() ? NULL : views[0];
 }
 
 // Coordinate conversion -------------------------------------------------------
 
 // static
 void View::ConvertPointToView(const View* src,
                               const View* dst,
                               gfx::Point* point) {
   ConvertPointToView(src, dst, point, true);
@@ skipping 37 matching lines @@
   return x_rect;
 }
 
 // Painting --------------------------------------------------------------------
 
 void View::SchedulePaint() {
   SchedulePaintInRect(GetLocalBounds());
 }
 
 void View::SchedulePaintInRect(const gfx::Rect& rect) {
-  if (!IsVisible())
+  if (!visible())
     return;
 
   if (parent_) {
     // Translate the requested paint rect to the parent's coordinate system
     // then pass this notification up to the parent.
     gfx::Rect paint_rect = ConvertRectToParent(rect);
     paint_rect.Offset(GetMirroredPosition());
     parent_->SchedulePaintInRect(paint_rect);
   }
 }
 
 void View::Paint(gfx::Canvas* canvas) {
-  if (!IsVisible())
+  if (!visible())
     return;
 
   ScopedCanvas scoped_canvas(NULL);
   scoped_ptr<gfx::Canvas> texture_canvas;
   gfx::Rect texture_rect;
 
 #if !defined(COMPOSITOR_2)
   if (use_acceleration_when_possible &&
       transform_.get() && transform_->HasChange()) {
     // This view has a transformation. So this maintains its own canvas.
@@ skipping 100 matching lines @@
   use_acceleration_when_possible = use;
 }
 
 // Input -----------------------------------------------------------------------
 
 View* View::GetEventHandlerForPoint(const gfx::Point& point) {
   // Walk the child Views recursively looking for the View that most
   // tightly encloses the specified point.
   for (int i = child_count() - 1; i >= 0; --i) {
     View* child = GetChildViewAt(i);
-    if (!child->IsVisible())
+    if (!child->visible())
       continue;
 
     gfx::Point point_in_child_coords(point);
     View::ConvertPointToView(this, child, &point_in_child_coords);
     if (child->HitTest(point_in_child_coords))
       return child->GetEventHandlerForPoint(point_in_child_coords);
   }
   return this;
 }
 
@@ skipping 150 matching lines @@
 
 View* View::GetPreviousFocusableView() {
   return previous_focusable_view_;
 }
 
 void View::SetNextFocusableView(View* view) {
   view->previous_focusable_view_ = this;
   next_focusable_view_ = view;
 }
 
-void View::SetFocusable(bool focusable) {
-  focusable_ = focusable;
-}
-
 bool View::IsFocusableInRootView() const {
   return IsFocusable() && IsVisibleInRootView();
 }
 
 bool View::IsAccessibilityFocusableInRootView() const {
   return (focusable_ || accessibility_focusable_) && IsEnabled() &&
     IsVisibleInRootView();
 }
 
 void View::set_accessibility_focusable(bool accessibility_focusable) {
@@ skipping 209 matching lines @@
 
   for (int i = 0, count = child_count(); i < count; ++i) {
     View* child = GetChildViewAt(i);
     child->PaintComposite(compositor);
   }
 
   compositor->RestoreTransform();
 }
 #else
 void View::PaintComposite() {
-  if (!IsVisible())
+  if (!visible())
     return;
 
   if (texture_.get()) {
     // TODO: if dirty_region doesn't itersect bounds, return.
     ui::Transform transform;
     GetTransformRelativeTo(NULL, &transform);
     texture_->Draw(transform);
   }
 
   for (int i = 0, count = child_count(); i < count; ++i)
     GetChildViewAt(i)->PaintComposite();
 }
 
 void View::PaintToTexture(const gfx::Rect& dirty_region) {
-  if (!IsVisible())
+  if (!visible())
     return;
 
   if (ShouldPaintToTexture() && texture_needs_updating_) {
     texture_clip_rect_ = dirty_region;
     Paint(NULL);
     texture_clip_rect_.SetRect(0, 0, 0, 0);
   } else {
     // Forward to all children as a descendant may be dirty and have a texture.
     for (int i = child_count() - 1; i >= 0; --i) {
       View* child_view = GetChildViewAt(i);
@@ skipping 26 matching lines @@
   return false;
 }
 
 void View::GetHitTestMask(gfx::Path* mask) const {
   DCHECK(mask);
 }
 
 // Focus -----------------------------------------------------------------------
 
 bool View::IsFocusable() const {
-  return focusable_ && IsEnabled() && IsVisible();
+  return focusable_ && IsEnabled() && visible();
 }
 
 void View::OnFocus() {
   // TODO(beng): Investigate whether it's possible for us to move this to
   //             Focus().
   // By default, we clear the native focus. This ensures that no visible native
   // view as the focus and that we still receive keyboard inputs.
   FocusManager* focus_manager = GetFocusManager();
   if (focus_manager)
     focus_manager->ClearNativeFocus();
@@ skipping 86 matching lines @@
       if (prev_focusable)
         prev_focusable->next_focusable_view_ = next_focusable;
       if (next_focusable)
         next_focusable->previous_focusable_view_ = prev_focusable;
     }
 
     if (GetWidget())
       UnregisterChildrenForVisibleBoundsNotification(view);
     view->ResetTexture();
     view->PropagateRemoveNotifications(this);
-    view->SetParent(NULL);
+    view->parent_ = NULL;
 
-    if (delete_removed_view && view->IsParentOwned())
+    if (delete_removed_view && view->parent_owned())
       view_to_be_deleted.reset(view);
 
     children_.erase(i);
   }
 
   if (update_tool_tip)
     UpdateTooltip();
 
   if (layout_manager_.get())
     layout_manager_->ViewRemoved(this, view);
 }
 
-void View::SetParent(View* parent) {
-  if (parent != parent_)
-    parent_ = parent;
-}
-
 void View::PropagateRemoveNotifications(View* parent) {
   for (int i = 0, count = child_count(); i < count; ++i)
     GetChildViewAt(i)->PropagateRemoveNotifications(parent);
 
   for (View* v = this; v; v = v->parent())
     v->ViewHierarchyChangedImpl(true, false, parent, this);
 }
 
 void View::PropagateAddNotifications(View* parent, View* child) {
   for (int i = 0, count = child_count(); i < count; ++i)
@@ skipping 51 matching lines @@
     UnregisterAccelerators(true);
   VisibilityChanged(starting_from, is_visible);
 }
 
 void View::BoundsChanged(const gfx::Rect& previous_bounds) {
 #if !defined(COMPOSITOR_2)
   if (canvas_.get())
     canvas_.reset(gfx::Canvas::CreateCanvas(width(), height(), false));
 #endif
 
-  if (IsVisible()) {
+  if (visible()) {
     if (parent_) {
       // Paint the old bounds.
       if (base::i18n::IsRTL()) {
         gfx::Rect paint_rect = previous_bounds;
         paint_rect.set_x(parent()->GetMirroredXForRect(paint_rect));
         parent_->SchedulePaintInRect(paint_rect);
       } else {
         parent_->SchedulePaintInRect(previous_bounds);
       }
 
@@ skipping 427 matching lines @@
     result.append(GetChildViewAt(i)->PrintViewGraph(false));
 
   if (first)
     result.append("}\n");
 
   return result;
 }
 #endif
 
 }  // namespace views