layer_animation_element.cc revision 5821806d5e7f356e8fa4b058a389a808ea183019 
1// Copyright (c) 2012 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/compositor/layer_animation_element.h"
6
7#include "base/compiler_specific.h"
8#include "ui/base/animation/tween.h"
9#include "ui/compositor/layer_animation_delegate.h"
10#include "ui/compositor/layer_animator.h"
11#include "ui/gfx/interpolated_transform.h"
12
13namespace ui {
14
15namespace {
16
17// Pause -----------------------------------------------------------------------
18class Pause : public LayerAnimationElement {
19 public:
20  Pause(const AnimatableProperties& properties, base::TimeDelta duration)
21      : LayerAnimationElement(properties, duration) {
22  }
23  virtual ~Pause() {}
24
25 private:
26  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {}
27  virtual bool OnProgress(double t,
28                          LayerAnimationDelegate* delegate) OVERRIDE {
29    return false;
30  }
31  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {}
32  virtual void OnAbort() OVERRIDE {}
33
34  DISALLOW_COPY_AND_ASSIGN(Pause);
35};
36
37// TransformTransition ---------------------------------------------------------
38
39class TransformTransition : public LayerAnimationElement {
40 public:
41    TransformTransition(const gfx::Transform& target, base::TimeDelta duration)
42      : LayerAnimationElement(GetProperties(), duration),
43        target_(target) {
44  }
45  virtual ~TransformTransition() {}
46
47 protected:
48  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
49    start_ = delegate->GetTransformForAnimation();
50  }
51
52  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
53    delegate->SetTransformFromAnimation(
54        Tween::ValueBetween(t, start_, target_));
55    return true;
56  }
57
58  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
59    target->transform = target_;
60  }
61
62  virtual void OnAbort() OVERRIDE {}
63
64 private:
65  static AnimatableProperties GetProperties() {
66    AnimatableProperties properties;
67    properties.insert(LayerAnimationElement::TRANSFORM);
68    return properties;
69  }
70
71  gfx::Transform start_;
72  const gfx::Transform target_;
73
74  DISALLOW_COPY_AND_ASSIGN(TransformTransition);
75};
76
77// InterpolatedTransformTransition ---------------------------------------------
78
79class InterpolatedTransformTransition : public LayerAnimationElement {
80 public:
81  InterpolatedTransformTransition(InterpolatedTransform* interpolated_transform,
82                                  base::TimeDelta duration)
83      : LayerAnimationElement(GetProperties(), duration),
84        interpolated_transform_(interpolated_transform) {
85  }
86  virtual ~InterpolatedTransformTransition() {}
87
88 protected:
89  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
90  }
91
92  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
93    delegate->SetTransformFromAnimation(
94        interpolated_transform_->Interpolate(static_cast<float>(t)));
95    return true;
96  }
97
98  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
99    target->transform = interpolated_transform_->Interpolate(1.0f);
100  }
101
102  virtual void OnAbort() OVERRIDE {}
103
104 private:
105  static AnimatableProperties GetProperties() {
106    AnimatableProperties properties;
107    properties.insert(LayerAnimationElement::TRANSFORM);
108    return properties;
109  }
110
111  scoped_ptr<InterpolatedTransform> interpolated_transform_;
112
113  DISALLOW_COPY_AND_ASSIGN(InterpolatedTransformTransition);
114};
115
116// BoundsTransition ------------------------------------------------------------
117
118class BoundsTransition : public LayerAnimationElement {
119 public:
120  BoundsTransition(const gfx::Rect& target, base::TimeDelta duration)
121      : LayerAnimationElement(GetProperties(), duration),
122        target_(target) {
123  }
124  virtual ~BoundsTransition() {}
125
126 protected:
127  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
128    start_ = delegate->GetBoundsForAnimation();
129  }
130
131  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
132    delegate->SetBoundsFromAnimation(Tween::ValueBetween(t, start_, target_));
133    return true;
134  }
135
136  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
137    target->bounds = target_;
138  }
139
140  virtual void OnAbort() OVERRIDE {}
141
142 private:
143  static AnimatableProperties GetProperties() {
144    AnimatableProperties properties;
145    properties.insert(LayerAnimationElement::BOUNDS);
146    return properties;
147  }
148
149  gfx::Rect start_;
150  const gfx::Rect target_;
151
152  DISALLOW_COPY_AND_ASSIGN(BoundsTransition);
153};
154
155// OpacityTransition -----------------------------------------------------------
156
157class OpacityTransition : public LayerAnimationElement {
158 public:
159  OpacityTransition(float target, base::TimeDelta duration)
160      : LayerAnimationElement(GetProperties(), duration),
161        start_(0.0f),
162        target_(target) {
163  }
164  virtual ~OpacityTransition() {}
165
166 protected:
167  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
168    start_ = delegate->GetOpacityForAnimation();
169  }
170
171  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
172    delegate->SetOpacityFromAnimation(Tween::ValueBetween(t, start_, target_));
173    return true;
174  }
175
176  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
177    target->opacity = target_;
178  }
179
180  virtual void OnAbort() OVERRIDE {}
181
182 private:
183  static AnimatableProperties GetProperties() {
184    AnimatableProperties properties;
185    properties.insert(LayerAnimationElement::OPACITY);
186    return properties;
187  }
188
189  float start_;
190  const float target_;
191
192  DISALLOW_COPY_AND_ASSIGN(OpacityTransition);
193};
194
195// VisibilityTransition --------------------------------------------------------
196
197class VisibilityTransition : public LayerAnimationElement {
198 public:
199  VisibilityTransition(bool target, base::TimeDelta duration)
200      : LayerAnimationElement(GetProperties(), duration),
201        start_(false),
202        target_(target) {
203  }
204  virtual ~VisibilityTransition() {}
205
206 protected:
207  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
208    start_ = delegate->GetVisibilityForAnimation();
209  }
210
211  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
212    delegate->SetVisibilityFromAnimation(t == 1.0 ? target_ : start_);
213    return t == 1.0;
214  }
215
216  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
217    target->visibility = target_;
218  }
219
220  virtual void OnAbort() OVERRIDE {}
221
222 private:
223  static AnimatableProperties GetProperties() {
224    AnimatableProperties properties;
225    properties.insert(LayerAnimationElement::VISIBILITY);
226    return properties;
227  }
228
229  bool start_;
230  const bool target_;
231
232  DISALLOW_COPY_AND_ASSIGN(VisibilityTransition);
233};
234
235// BrightnessTransition --------------------------------------------------------
236
237class BrightnessTransition : public LayerAnimationElement {
238 public:
239  BrightnessTransition(float target, base::TimeDelta duration)
240      : LayerAnimationElement(GetProperties(), duration),
241        start_(0.0f),
242        target_(target) {
243  }
244  virtual ~BrightnessTransition() {}
245
246 protected:
247  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
248    start_ = delegate->GetBrightnessForAnimation();
249  }
250
251  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
252    delegate->SetBrightnessFromAnimation(
253        Tween::ValueBetween(t, start_, target_));
254    return true;
255  }
256
257  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
258    target->brightness = target_;
259  }
260
261  virtual void OnAbort() OVERRIDE {}
262
263 private:
264  static AnimatableProperties GetProperties() {
265    AnimatableProperties properties;
266    properties.insert(LayerAnimationElement::BRIGHTNESS);
267    return properties;
268  }
269
270  float start_;
271  const float target_;
272
273  DISALLOW_COPY_AND_ASSIGN(BrightnessTransition);
274};
275
276// GrayscaleTransition ---------------------------------------------------------
277
278class GrayscaleTransition : public LayerAnimationElement {
279 public:
280  GrayscaleTransition(float target, base::TimeDelta duration)
281      : LayerAnimationElement(GetProperties(), duration),
282        start_(0.0f),
283        target_(target) {
284  }
285  virtual ~GrayscaleTransition() {}
286
287 protected:
288  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
289    start_ = delegate->GetGrayscaleForAnimation();
290  }
291
292  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
293    delegate->SetGrayscaleFromAnimation(
294        Tween::ValueBetween(t, start_, target_));
295    return true;
296  }
297
298  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
299    target->grayscale = target_;
300  }
301
302  virtual void OnAbort() OVERRIDE {}
303
304 private:
305  static AnimatableProperties GetProperties() {
306    AnimatableProperties properties;
307    properties.insert(LayerAnimationElement::GRAYSCALE);
308    return properties;
309  }
310
311  float start_;
312  const float target_;
313
314  DISALLOW_COPY_AND_ASSIGN(GrayscaleTransition);
315};
316
317// ColorTransition -------------------------------------------------------------
318
319class ColorTransition : public LayerAnimationElement {
320 public:
321  ColorTransition(SkColor target, base::TimeDelta duration)
322      : LayerAnimationElement(GetProperties(), duration),
323        start_(SK_ColorBLACK),
324        target_(target) {
325  }
326  virtual ~ColorTransition() {}
327
328 protected:
329  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
330    start_ = delegate->GetColorForAnimation();
331  }
332
333  virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
334    delegate->SetColorFromAnimation(
335        SkColorSetARGB(
336            Tween::ValueBetween(t,
337                                static_cast<int>(SkColorGetA(start_)),
338                                static_cast<int>(SkColorGetA(target_))),
339            Tween::ValueBetween(t,
340                                static_cast<int>(SkColorGetR(start_)),
341                                static_cast<int>(SkColorGetR(target_))),
342            Tween::ValueBetween(t,
343                                static_cast<int>(SkColorGetG(start_)),
344                                static_cast<int>(SkColorGetG(target_))),
345            Tween::ValueBetween(t,
346                                static_cast<int>(SkColorGetB(start_)),
347                                static_cast<int>(SkColorGetB(target_)))));
348    return true;
349  }
350
351  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
352    target->color = target_;
353  }
354
355  virtual void OnAbort() OVERRIDE {}
356
357 private:
358  static AnimatableProperties GetProperties() {
359    AnimatableProperties properties;
360    properties.insert(LayerAnimationElement::COLOR);
361    return properties;
362  }
363
364  SkColor start_;
365  const SkColor target_;
366
367  DISALLOW_COPY_AND_ASSIGN(ColorTransition);
368};
369
370}  // namespace
371
372// LayerAnimationElement::TargetValue ------------------------------------------
373
374LayerAnimationElement::TargetValue::TargetValue()
375    : opacity(0.0f),
376      visibility(false),
377      brightness(0.0f),
378      grayscale(0.0f),
379      color(SK_ColorBLACK) {
380}
381
382LayerAnimationElement::TargetValue::TargetValue(
383    const LayerAnimationDelegate* delegate)
384    : bounds(delegate ? delegate->GetBoundsForAnimation() : gfx::Rect()),
385      transform(delegate ?
386                delegate->GetTransformForAnimation() : gfx::Transform()),
387      opacity(delegate ? delegate->GetOpacityForAnimation() : 0.0f),
388      visibility(delegate ? delegate->GetVisibilityForAnimation() : false),
389      brightness(delegate ? delegate->GetBrightnessForAnimation() : 0.0f),
390      grayscale(delegate ? delegate->GetGrayscaleForAnimation() : 0.0f),
391      color(delegate ? delegate->GetColorForAnimation() : 0.0f) {
392}
393
394// LayerAnimationElement -------------------------------------------------------
395
396LayerAnimationElement::LayerAnimationElement(
397    const AnimatableProperties& properties,
398    base::TimeDelta duration)
399    : first_frame_(true),
400      properties_(properties),
401      duration_(GetEffectiveDuration(duration)),
402      tween_type_(Tween::LINEAR) {
403}
404
405LayerAnimationElement::~LayerAnimationElement() {
406}
407
408bool LayerAnimationElement::Progress(double t,
409                                     LayerAnimationDelegate* delegate) {
410  if (first_frame_)
411    OnStart(delegate);
412  bool need_draw = OnProgress(Tween::CalculateValue(tween_type_, t), delegate);
413  first_frame_ = t == 1.0;
414  return need_draw;
415}
416
417void LayerAnimationElement::GetTargetValue(TargetValue* target) const {
418  OnGetTarget(target);
419}
420
421void LayerAnimationElement::Abort() {
422  first_frame_ = true;
423  OnAbort();
424}
425
426// static
427base::TimeDelta LayerAnimationElement::GetEffectiveDuration(
428    const base::TimeDelta& duration) {
429  if (LayerAnimator::disable_animations_for_test())
430    return base::TimeDelta();
431
432  if (LayerAnimator::slow_animation_mode())
433    return duration * LayerAnimator::slow_animation_scale_factor();
434
435  return duration;
436}
437
438// static
439LayerAnimationElement* LayerAnimationElement::CreateTransformElement(
440    const gfx::Transform& transform,
441    base::TimeDelta duration) {
442  return new TransformTransition(transform, duration);
443}
444
445// static
446LayerAnimationElement*
447LayerAnimationElement::CreateInterpolatedTransformElement(
448    InterpolatedTransform* interpolated_transform,
449    base::TimeDelta duration) {
450  return new InterpolatedTransformTransition(interpolated_transform, duration);
451}
452
453// static
454LayerAnimationElement* LayerAnimationElement::CreateBoundsElement(
455    const gfx::Rect& bounds,
456    base::TimeDelta duration) {
457  return new BoundsTransition(bounds, duration);
458}
459
460// static
461LayerAnimationElement* LayerAnimationElement::CreateOpacityElement(
462    float opacity,
463    base::TimeDelta duration) {
464  return new OpacityTransition(opacity, duration);
465}
466
467// static
468LayerAnimationElement* LayerAnimationElement::CreateVisibilityElement(
469    bool visibility,
470    base::TimeDelta duration) {
471  return new VisibilityTransition(visibility, duration);
472}
473
474// static
475LayerAnimationElement* LayerAnimationElement::CreateBrightnessElement(
476    float brightness,
477    base::TimeDelta duration) {
478  return new BrightnessTransition(brightness, duration);
479}
480
481// static
482LayerAnimationElement* LayerAnimationElement::CreateGrayscaleElement(
483    float grayscale,
484    base::TimeDelta duration) {
485  return new GrayscaleTransition(grayscale, duration);
486}
487
488// static
489LayerAnimationElement* LayerAnimationElement::CreatePauseElement(
490    const AnimatableProperties& properties,
491    base::TimeDelta duration) {
492  return new Pause(properties, duration);
493}
494
495// static
496LayerAnimationElement* LayerAnimationElement::CreateColorElement(
497    SkColor color,
498    base::TimeDelta duration) {
499  return new ColorTransition(color, duration);
500}
501
502}  // namespace ui
503