ui/v2/src/view.cc

   1 // Copyright (c) 2013 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.
   4
   5 #include "ui/v2/public/view.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/bind.h"
  10 #include "ui/compositor/layer_owner.h"
  11 #include "ui/v2/public/view_observer.h"
  12 #include "ui/v2/src/view_private.h"
  13
  14 namespace v2 {
  15
  16 enum StackDirection {
  17   STACK_ABOVE,
  18   STACK_BELOW
  19 };
  20
  21 void StackChildRelativeTo(View* parent,
  22                           std::vector<View*>* children,
  23                           View* child,
  24                           View* other,
  25                           StackDirection direction) {
  26   DCHECK_NE(child, other);
  27   DCHECK(child);
  28   DCHECK(other);
  29   DCHECK_EQ(parent, child->parent());
  30   DCHECK_EQ(parent, other->parent());
  31
  32   // TODO(beng): Notify stacking changing.
  33   // TODO(beng): consult layout manager
  34   const size_t child_i =
  35       std::find(children->begin(), children->end(), child) - children->begin();
  36   const size_t other_i =
  37       std::find(children->begin(), children->end(), other) - children->begin();
  38   const size_t destination_i =
  39       direction == STACK_ABOVE ?
  40       (child_i < other_i ? other_i : other_i + 1) :
  41       (child_i < other_i ? other_i - 1 : other_i);
  42   children->erase(children->begin() + child_i);
  43   children->insert(children->begin() + destination_i, child);
  44
  45   // TODO(beng): update layer.
  46   // TODO(beng): Notify stacking changed.
  47 }
  48
  49 void NotifyViewTreeChangeAtReceiver(
  50     View* receiver,
  51     const ViewObserver::TreeChangeParams& params) {
  52   ViewObserver::TreeChangeParams local_params = params;
  53   local_params.receiver = receiver;
  54   FOR_EACH_OBSERVER(ViewObserver,
  55                     *ViewPrivate(receiver).observers(),
  56                     OnViewTreeChange(local_params));
  57 }
  58
  59 void NotifyViewTreeChangeUp(View* start_at,
  60                             const ViewObserver::TreeChangeParams& params) {
  61   for (View* current = start_at; current; current = current->parent())
  62     NotifyViewTreeChangeAtReceiver(current, params);
  63 }
  64
  65 void NotifyViewTreeChangeDown(View* start_at,
  66                               const ViewObserver::TreeChangeParams& params) {
  67   NotifyViewTreeChangeAtReceiver(start_at, params);
  68   View::Children::const_iterator it = start_at->children().begin();
  69   for (; it != start_at->children().end(); ++it)
  70     NotifyViewTreeChangeDown(*it, params);
  71 }
  72
  73 void NotifyViewTreeChange(const ViewObserver::TreeChangeParams& params) {
  74   NotifyViewTreeChangeDown(params.target, params);
  75   switch (params.phase) {
  76   case ViewObserver::DISPOSITION_CHANGING:
  77     if (params.old_parent)
  78       NotifyViewTreeChangeUp(params.old_parent, params);
  79     break;
  80   case ViewObserver::DISPOSITION_CHANGED:
  81     if (params.new_parent)
  82       NotifyViewTreeChangeUp(params.new_parent, params);
  83     break;
  84   default:
  85     NOTREACHED();
  86     break;
  87   }
  88 }
  89
  90 class ScopedTreeNotifier {
  91  public:
  92   ScopedTreeNotifier(View* target, View* old_parent, View* new_parent) {
  93     params_.target = target;
  94     params_.old_parent = old_parent;
  95     params_.new_parent = new_parent;
  96     NotifyViewTreeChange(params_);
  97   }
  98   ~ScopedTreeNotifier() {
  99     params_.phase = ViewObserver::DISPOSITION_CHANGED;
 100     NotifyViewTreeChange(params_);
 101   }
 102
 103  private:
 104   ViewObserver::TreeChangeParams params_;
 105
 106   DISALLOW_COPY_AND_ASSIGN(ScopedTreeNotifier);
 107 };
 108
 109 void RemoveChildImpl(View* child, View::Children* children) {
 110   std::vector<View*>::iterator it =
 111       std::find(children->begin(), children->end(), child);
 112   if (it != children->end()) {
 113     children->erase(it);
 114     ViewPrivate(child).ClearParent();
 115   }
 116 }
 117
 118 class ViewLayerOwner : public ui::LayerOwner,
 119                        public ui::LayerDelegate {
 120  public:
 121   explicit ViewLayerOwner(ui::Layer* layer) {
 122     layer_ = layer;
 123   }
 124   ~ViewLayerOwner() {}
 125
 126  private:
 127   // Overridden from ui::LayerDelegate:
 128   virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {
 129     // TODO(beng): paint processor.
 130   }
 131   virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {
 132     // TODO(beng): ???
 133   }
 134   virtual base::Closure PrepareForLayerBoundsChange() OVERRIDE {
 135     return base::Bind(&ViewLayerOwner::OnLayerBoundsChanged,
 136                       base::Unretained(this));
 137   }
 138
 139   void OnLayerBoundsChanged() {
 140     // TODO(beng): ???
 141   }
 142
 143   DISALLOW_COPY_AND_ASSIGN(ViewLayerOwner);
 144 };
 145
 146 ////////////////////////////////////////////////////////////////////////////////
 147 // View, public:
 148
 149 // Creation, configuration -----------------------------------------------------
 150
 151 View::View() : visible_(true), owned_by_parent_(true), parent_(NULL) {
 152 }
 153
 154 View::~View() {
 155   FOR_EACH_OBSERVER(ViewObserver, observers_,
 156                     OnViewDestroy(this, ViewObserver::DISPOSITION_CHANGING));
 157
 158   while (!children_.empty()) {
 159     View* child = children_.front();
 160     if (child->owned_by_parent_) {
 161       delete child;
 162       // Deleting the child also removes it from our child list.
 163       DCHECK(std::find(children_.begin(), children_.end(), child) ==
 164              children_.end());
 165     } else {
 166       RemoveChild(child);
 167     }
 168   }
 169
 170   if (parent_)
 171     parent_->RemoveChild(this);
 172
 173   FOR_EACH_OBSERVER(ViewObserver, observers_,
 174                     OnViewDestroy(this, ViewObserver::DISPOSITION_CHANGED));
 175 }
 176
 177 void View::AddObserver(ViewObserver* observer) {
 178   observers_.AddObserver(observer);
 179 }
 180
 181 void View::RemoveObserver(ViewObserver* observer) {
 182   observers_.RemoveObserver(observer);
 183 }
 184
 185 void View::SetPainter(Painter* painter) {
 186   painter_.reset(painter);
 187 }
 188
 189 void View::SetLayout(Layout* layout) {
 190   layout_.reset(layout);
 191 }
 192
 193 // Disposition -----------------------------------------------------------------
 194
 195 void View::SetBounds(const gfx::Rect& bounds) {
 196   gfx::Rect old_bounds = bounds_;
 197   // TODO(beng): consult layout manager
 198   bounds_ = bounds;
 199   // TODO(beng): update layer
 200
 201   // TODO(beng): write tests for this where layoutmanager prevents a change
 202   //             and no changed notification is sent.
 203   if (bounds_ != old_bounds) {
 204     FOR_EACH_OBSERVER(ViewObserver, observers_, OnViewBoundsChanged(this,
 205         old_bounds, bounds_));
 206   }
 207 }
 208
 209 void View::SetVisible(bool visible) {
 210   FOR_EACH_OBSERVER(ViewObserver, observers_, OnViewVisibilityChange(this,
 211       ViewObserver::DISPOSITION_CHANGING));
 212
 213   bool old_visible = visible_;
 214   // TODO(beng): consult layout manager
 215   visible_ = visible;
 216   // TODO(beng): update layer
 217
 218   // TODO(beng): write tests for this where layoutmanager prevents a change
 219   //             and no changed notification is sent.
 220   if (old_visible != visible_) {
 221     FOR_EACH_OBSERVER(ViewObserver, observers_, OnViewVisibilityChange(this,
 222         ViewObserver::DISPOSITION_CHANGED));
 223   }
 224 }
 225
 226 // Tree ------------------------------------------------------------------------
 227
 228 void View::AddChild(View* child) {
 229   ScopedTreeNotifier notifier(child, child->parent(), this);
 230   if (child->parent())
 231     RemoveChildImpl(child, &child->parent_->children_);
 232   children_.push_back(child);
 233   child->parent_ = this;
 234 }
 235
 236 void View::RemoveChild(View* child) {
 237   DCHECK_EQ(this, child->parent());
 238   ScopedTreeNotifier(child, this, NULL);
 239   RemoveChildImpl(child, &children_);
 240 }
 241
 242 bool View::Contains(View* child) const {
 243   for (View* p = child->parent(); p; p = p->parent()) {
 244     if (p == this)
 245       return true;
 246   }
 247   return false;
 248 }
 249
 250 void View::StackChildAtTop(View* child) {
 251   if (children_.size() <= 1 || child == children_.back())
 252     return;  // On top already.
 253   StackChildAbove(child, children_.back());
 254 }
 255
 256 void View::StackChildAtBottom(View* child) {
 257   if (children_.size() <= 1 || child == children_.front())
 258     return;  // On bottom already.
 259   StackChildBelow(child, children_.front());
 260 }
 261
 262 void View::StackChildAbove(View* child, View* other) {
 263   StackChildRelativeTo(this, &children_, child, other, STACK_ABOVE);
 264 }
 265
 266 void View::StackChildBelow(View* child, View* other) {
 267   StackChildRelativeTo(this, &children_, child, other, STACK_BELOW);
 268 }
 269
 270 // Layer -----------------------------------------------------------------------
 271
 272 const ui::Layer* View::layer() const {
 273   return layer_owner_.get() ? layer_owner_->layer() : NULL;
 274 }
 275
 276 ui::Layer* View::layer() {
 277   return const_cast<ui::Layer*>(const_cast<const View*>(this)->layer());
 278 }
 279
 280 bool View::HasLayer() const {
 281   return !!layer();
 282 }
 283
 284 void View::CreateLayer(ui::LayerType layer_type) {
 285   layer_owner_.reset(new ViewLayerOwner(new ui::Layer(layer_type)));
 286   layer()->SetVisible(visible_);
 287   layer()->set_delegate(layer_owner_.get());
 288   // TODO(beng): layer name?
 289   // TODO(beng): SetFillsBoundsOpaquely?
 290 }
 291
 292 void View::DestroyLayer() {
 293   DCHECK(layer_owner_.get());
 294   layer_owner_.reset();
 295 }
 296
 297 ui::Layer* View::AcquireLayer() {
 298   DCHECK(layer_owner_.get());
 299   return layer_owner_->AcquireLayer();
 300 }
 301
 302 }  // namespace v2