content/browser/web_contents/aura/window

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
OnImplicitAnimationsCompleted
complete_threshold_
ChangeOwner
IsSlideInProgress
SetupSliderLayer
UpdateForScroll
CompleteOrResetSlide
CompleteActiveAnimations
ResetSlide
SlideAnimationCompleted
ResetSlideAnimationCompleted
OnKeyEvent
OnMouseEvent
OnScrollEvent
OnGestureEvent
OnWindowRemovingFromRootWindow
// Copyright (c) 2013 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 "content/browser/web_contents/aura/window_slider.h"

#include <algorithm>

#include "base/bind.h"
#include "base/callback.h"
#include "content/browser/web_contents/aura/shadow_layer_delegate.h"
#include "content/public/browser/overscroll_configuration.h"
#include "ui/aura/window.h"
#include "ui/compositor/layer_animation_observer.h"
#include "ui/compositor/scoped_layer_animation_settings.h"
#include "ui/events/event.h"

namespace content {

namespace {

// An animation observer that runs a callback at the end of the animation, and
// destroys itself.
class CallbackAnimationObserver : public ui::ImplicitAnimationObserver {
 public:
  CallbackAnimationObserver(const base::Closure& closure)
      : closure_(closure) {
  }

  virtual ~CallbackAnimationObserver() {}

 private:
  // Overridden from ui::ImplicitAnimationObserver:
  virtual void OnImplicitAnimationsCompleted() OVERRIDE {
    if (!closure_.is_null())
      closure_.Run();
    base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
  }

  const base::Closure closure_;

  DISALLOW_COPY_AND_ASSIGN(CallbackAnimationObserver);
};

}  // namespace

WindowSlider::WindowSlider(Delegate* delegate,
                           aura::Window* event_window,
                           aura::Window* owner)
    : delegate_(delegate),
      event_window_(event_window),
      owner_(owner),
      active_animator_(NULL),
      delta_x_(0.f),
      weak_factory_(this),
      active_start_threshold_(0.f),
      start_threshold_touchscreen_(content::GetOverscrollConfig(
          content::OVERSCROLL_CONFIG_HORIZ_THRESHOLD_START_TOUCHSCREEN)),
      start_threshold_touchpad_(content::GetOverscrollConfig(
          content::OVERSCROLL_CONFIG_HORIZ_THRESHOLD_START_TOUCHPAD)),
      complete_threshold_(content::GetOverscrollConfig(
          content::OVERSCROLL_CONFIG_HORIZ_THRESHOLD_COMPLETE)) {
  event_window_->AddPreTargetHandler(this);

  event_window_->AddObserver(this);
  owner_->AddObserver(this);
}

WindowSlider::~WindowSlider() {
  if (event_window_) {
    event_window_->RemovePreTargetHandler(this);
    event_window_->RemoveObserver(this);
  }
  if (owner_)
    owner_->RemoveObserver(this);
  delegate_->OnWindowSliderDestroyed();
}

void WindowSlider::ChangeOwner(aura::Window* new_owner) {
  if (owner_)
    owner_->RemoveObserver(this);
  owner_ = new_owner;
  if (owner_) {
    owner_->AddObserver(this);
    UpdateForScroll(0.f, 0.f);
  }
}

bool WindowSlider::IsSlideInProgress() const {
  // if active_start_threshold_ is 0, it means that sliding hasn't been started
  return active_start_threshold_ != 0 && (slider_.get() || active_animator_);
}

void WindowSlider::SetupSliderLayer() {
  ui::Layer* parent = owner_->layer()->parent();
  parent->Add(slider_.get());
  if (delta_x_ < 0)
    parent->StackAbove(slider_.get(), owner_->layer());
  else
    parent->StackBelow(slider_.get(), owner_->layer());
  slider_->SetBounds(owner_->layer()->bounds());
  slider_->SetVisible(true);
}

void WindowSlider::UpdateForScroll(float x_offset, float y_offset) {
  if (active_animator_) {
    // If there is an active animation, complete it before processing the scroll
    // so that the callbacks that are invoked on the Delegate are consistent.
    // Completing the animation may destroy WindowSlider through the animation
    // callback, so we can't continue processing the scroll event here.
    delta_x_ += x_offset;
    CompleteActiveAnimations();
    return;
  }

  float old_delta = delta_x_;
  delta_x_ += x_offset;
  if (fabs(delta_x_) < active_start_threshold_ && !slider_.get())
    return;

  if ((old_delta < 0 && delta_x_ > 0) ||
      (old_delta > 0 && delta_x_ < 0)) {
    slider_.reset();
    shadow_.reset();
  }

  float translate = 0.f;
  ui::Layer* translate_layer = NULL;

  if (!slider_.get()) {
    slider_.reset(delta_x_ < 0 ? delegate_->CreateFrontLayer() :
                                 delegate_->CreateBackLayer());
    if (!slider_.get())
      return;
    SetupSliderLayer();
  }

  if (delta_x_ <= -active_start_threshold_) {
    translate = owner_->bounds().width() +
        std::max(delta_x_ + active_start_threshold_,
                 static_cast<float>(-owner_->bounds().width()));
    translate_layer = slider_.get();
  } else if (delta_x_ >= active_start_threshold_) {
    translate = std::min(delta_x_ - active_start_threshold_,
                         static_cast<float>(owner_->bounds().width()));
    translate_layer = owner_->layer();
  } else {
    return;
  }

  if (!shadow_.get())
    shadow_.reset(new ShadowLayerDelegate(translate_layer));

  gfx::Transform transform;
  transform.Translate(translate, 0);
  translate_layer->SetTransform(transform);
}

void WindowSlider::CompleteOrResetSlide() {
  if (!slider_.get())
    return;

  int width = owner_->bounds().width();
  float ratio = (fabs(delta_x_) - active_start_threshold_) / width;
  if (ratio < complete_threshold_) {
    ResetSlide();
    return;
  }

  ui::Layer* sliding = delta_x_ < 0 ? slider_.get() : owner_->layer();
  active_animator_ = sliding->GetAnimator();

  ui::ScopedLayerAnimationSettings settings(active_animator_);
  settings.SetPreemptionStrategy(
      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
  settings.SetTweenType(gfx::Tween::EASE_OUT);
  settings.AddObserver(new CallbackAnimationObserver(
      base::Bind(&WindowSlider::SlideAnimationCompleted,
                 weak_factory_.GetWeakPtr(),
                 base::Passed(&slider_),
                 base::Passed(&shadow_))));

  gfx::Transform transform;
  transform.Translate(delta_x_ < 0 ? 0 : width, 0);
  delta_x_ = 0;
  delegate_->OnWindowSlideCompleting();
  sliding->SetTransform(transform);
}

void WindowSlider::CompleteActiveAnimations() {
  if (active_animator_)
    active_animator_->StopAnimating();
}

void WindowSlider::ResetSlide() {
  if (!slider_.get())
    return;

  // Reset the state of the sliding layer.
  if (slider_.get()) {
    ui::Layer* translate_layer;
    gfx::Transform transform;
    if (delta_x_ < 0) {
      translate_layer = slider_.get();
      transform.Translate(translate_layer->bounds().width(), 0);
    } else {
      translate_layer = owner_->layer();
    }

    active_animator_ = translate_layer->GetAnimator();
    ui::ScopedLayerAnimationSettings settings(active_animator_);
    settings.SetPreemptionStrategy(
        ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
    settings.SetTweenType(gfx::Tween::EASE_OUT);
    settings.AddObserver(new CallbackAnimationObserver(
        base::Bind(&WindowSlider::ResetSlideAnimationCompleted,
                   weak_factory_.GetWeakPtr(),
                   base::Passed(&slider_),
                   base::Passed(&shadow_))));
    translate_layer->SetTransform(transform);
  }

  delta_x_ = 0.f;
}

void WindowSlider::SlideAnimationCompleted(
    scoped_ptr<ui::Layer> layer, scoped_ptr<ShadowLayerDelegate> shadow) {
  active_animator_ = NULL;
  shadow.reset();
  layer.reset();
  delegate_->OnWindowSlideCompleted();
}

void WindowSlider::ResetSlideAnimationCompleted(
    scoped_ptr<ui::Layer> layer, scoped_ptr<ShadowLayerDelegate> shadow) {
  active_animator_ = NULL;
  shadow.reset();
  layer.reset();
  delegate_->OnWindowSlideAborted();
}

void WindowSlider::OnKeyEvent(ui::KeyEvent* event) {
  ResetSlide();
}

void WindowSlider::OnMouseEvent(ui::MouseEvent* event) {
  if (!(event->flags() & ui::EF_IS_SYNTHESIZED))
    ResetSlide();
}

void WindowSlider::OnScrollEvent(ui::ScrollEvent* event) {
  active_start_threshold_ = start_threshold_touchpad_;
  if (event->type() == ui::ET_SCROLL)
    UpdateForScroll(event->x_offset_ordinal(), event->y_offset_ordinal());
  else if (event->type() == ui::ET_SCROLL_FLING_START)
    CompleteOrResetSlide();
  else
    ResetSlide();
  event->SetHandled();
}

void WindowSlider::OnGestureEvent(ui::GestureEvent* event) {
  active_start_threshold_ = start_threshold_touchscreen_;
  const ui::GestureEventDetails& details = event->details();
  switch (event->type()) {
    case ui::ET_GESTURE_SCROLL_BEGIN:
      CompleteActiveAnimations();
      break;

    case ui::ET_GESTURE_SCROLL_UPDATE:
      UpdateForScroll(details.scroll_x(), details.scroll_y());
      break;

    case ui::ET_GESTURE_SCROLL_END:
      CompleteOrResetSlide();
      break;

    case ui::ET_SCROLL_FLING_START:
      CompleteOrResetSlide();
      break;

    case ui::ET_GESTURE_PINCH_BEGIN:
    case ui::ET_GESTURE_PINCH_UPDATE:
    case ui::ET_GESTURE_PINCH_END:
      ResetSlide();
      break;

    default:
      break;
  }

  event->SetHandled();
}

void WindowSlider::OnWindowRemovingFromRootWindow(aura::Window* window,
                                                  aura::Window* new_root) {
  if (window == event_window_) {
    window->RemoveObserver(this);
    window->RemovePreTargetHandler(this);
    event_window_ = NULL;
  } else if (window == owner_) {
    window->RemoveObserver(this);
    owner_ = NULL;
    delete this;
  } else {
    NOTREACHED();
  }
}

}  // namespace content
/* [<][>][^][v][top][bottom][index][help] */
root/content/browser/web_contents/aura/window_slider.cc

DEFINITIONS
