mojo/services/view_manager/node.cc

// Copyright 2014 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 "mojo/services/view_manager/node.h"

#include "mojo/services/view_manager/node_delegate.h"
#include "mojo/services/view_manager/view.h"
#include "ui/aura/window_property.h"
#include "ui/base/cursor/cursor.h"
#include "ui/base/hit_test.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/image/image_skia.h"
#include "ui/gfx/native_widget_types.h"

DECLARE_WINDOW_PROPERTY_TYPE(mojo::view_manager::service::Node*);

namespace mojo {
namespace view_manager {
namespace service {

DEFINE_WINDOW_PROPERTY_KEY(Node*, kNodeKey, NULL);

Node::Node(NodeDelegate* delegate, const NodeId& id)
    : delegate_(delegate),
      id_(id),
      view_(NULL),
      window_(this) {
  DCHECK(delegate);  // Must provide a delegate.
  window_.set_owned_by_parent(false);
  window_.AddObserver(this);
  window_.SetProperty(kNodeKey, this);
  window_.Init(aura::WINDOW_LAYER_TEXTURED);

  // TODO(sky): this likely needs to be false and add a visibility API.
  window_.Show();
}

Node::~Node() {
  SetView(NULL);
  // This is implicitly done during deletion of the window, but we do it here so
  // that we're in a known state.
  if (window_.parent())
    window_.parent()->RemoveChild(&window_);
}

const Node* Node::GetParent() const {
  if (!window_.parent())
    return NULL;
  return window_.parent()->GetProperty(kNodeKey);
}

void Node::Add(Node* child) {
  window_.AddChild(&child->window_);
}

void Node::Remove(Node* child) {
  window_.RemoveChild(&child->window_);
}

void Node::Reorder(Node* child, Node* relative, OrderDirection direction) {
  if (direction == ORDER_ABOVE)
    window_.StackChildAbove(child->window(), relative->window());
  else if (direction == ORDER_BELOW)
    window_.StackChildBelow(child->window(), relative->window());
}

const Node* Node::GetRoot() const {
  const aura::Window* window = &window_;
  while (window && window->parent())
    window = window->parent();
  return window->GetProperty(kNodeKey);
}

std::vector<const Node*> Node::GetChildren() const {
  std::vector<const Node*> children;
  children.reserve(window_.children().size());
  for (size_t i = 0; i < window_.children().size(); ++i)
    children.push_back(window_.children()[i]->GetProperty(kNodeKey));
  return children;
}

std::vector<Node*> Node::GetChildren() {
  std::vector<Node*> children;
  children.reserve(window_.children().size());
  for (size_t i = 0; i < window_.children().size(); ++i)
    children.push_back(window_.children()[i]->GetProperty(kNodeKey));
  return children;
}

bool Node::Contains(const Node* node) const {
  return node && window_.Contains(&(node->window_));
}

void Node::SetView(View* view) {
  if (view == view_)
    return;

  // Detach view from existing node. This way notifications are sent out.
  if (view && view->node())
    view->node()->SetView(NULL);

  View* old_view = view_;
  if (view_)
    view_->set_node(NULL);
  view_ = view;
  if (view)
    view->set_node(this);
  delegate_->OnNodeViewReplaced(this, view, old_view);
}

void Node::OnWindowHierarchyChanged(
    const aura::WindowObserver::HierarchyChangeParams& params) {
  if (params.target != &window_ || params.receiver != &window_)
    return;
  const Node* new_parent = params.new_parent ?
      params.new_parent->GetProperty(kNodeKey) : NULL;
  const Node* old_parent = params.old_parent ?
      params.old_parent->GetProperty(kNodeKey) : NULL;
  delegate_->OnNodeHierarchyChanged(this, new_parent, old_parent);
}

gfx::Size Node::GetMinimumSize() const {
  return gfx::Size();
}

gfx::Size Node::GetMaximumSize() const {
  return gfx::Size();
}

void Node::OnBoundsChanged(const gfx::Rect& old_bounds,
                           const gfx::Rect& new_bounds) {
}

gfx::NativeCursor Node::GetCursor(const gfx::Point& point) {
  return gfx::kNullCursor;
}

int Node::GetNonClientComponent(const gfx::Point& point) const {
  return HTCAPTION;
}

bool Node::ShouldDescendIntoChildForEventHandling(
    aura::Window* child,
    const gfx::Point& location) {
  return true;
}

bool Node::CanFocus() {
  return true;
}

void Node::OnCaptureLost() {
}

void Node::OnPaint(gfx::Canvas* canvas) {
  if (view_) {
    canvas->DrawImageInt(
        gfx::ImageSkia::CreateFrom1xBitmap(view_->bitmap()), 0, 0);
  }
}

void Node::OnDeviceScaleFactorChanged(float device_scale_factor) {
}

void Node::OnWindowDestroying(aura::Window* window) {
}

void Node::OnWindowDestroyed(aura::Window* window) {
}

void Node::OnWindowTargetVisibilityChanged(bool visible) {
}

bool Node::HasHitTestMask() const {
  return false;
}

void Node::GetHitTestMask(gfx::Path* mask) const {
}

void Node::OnEvent(ui::Event* event) {
  if (view_)
    delegate_->OnViewInputEvent(view_, event);
}

}  // namespace service
}  // namespace view_manager
}  // namespace mojo