Animated Rotation

ui/gfx/interpolated_transform.h

 // 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.
 
 #ifndef UI_GFX_INTERPOLATED_TRANSFORM_H_
 #define UI_GFX_INTERPOLATED_TRANSFORM_H_
 #pragma once
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/gfx/point.h"
+#include "ui/gfx/point3.h"
 #include "ui/gfx/transform.h"
 
 namespace ui {
 
 ///////////////////////////////////////////////////////////////////////////////
 // class InterpolatedTransform
 //
 // Abstract base class for transforms that animate over time. These
 // interpolated transforms can be combined to allow for more sophisticated
 // animations. For example, you might combine a rotation of 90 degrees between
@@ skipping 12 matching lines @@
 
   // Returns the interpolated transform at time t. Note: not virtual.
   ui::Transform Interpolate(float t) const;
 
   // The Intepolate ultimately returns the product of our transform at time t
   // and our child's transform at time t (if we have one).
   //
   // This function takes ownership of the passed InterpolatedTransform.
   void SetChild(InterpolatedTransform* child);
 
+  static bool FactorTRS(const ui::Transform& transform,
+                        gfx::Point* translation,
+                        float* rotation,
+                        gfx::Point3f* scale);
+
  protected:
   // Calculates the interpolated transform without considering our child.
   virtual ui::Transform InterpolateButDoNotCompose(float t) const = 0;
 
   // If time in (start_time_, end_time_], this function linearly interpolates
   // between start_value and end_value.  More precisely it returns
   // (1 - t) * start_value + t * end_value where
   // t = (start_time_ - time) / (end_time_ - start_time_).
   // If time < start_time_ it returns start_value, and if time >= end_time_
   // it returns end_value.
   float ValueBetween(float time, float start_value, float end_value) const;
 
+  float start_time() const { return start_time_; }
+  float end_time() const { return end_time_; }
+
  private:
   const float start_time_;
   const float end_time_;
 
   // The child transform. If you consider an interpolated transform as a
   // function of t. If, without a child, we are f(t), and our child is
   // g(t), then with a child we become f'(t) = f(t) * g(t). Using a child
   // transform, we can chain collections of transforms together.
   scoped_ptr<InterpolatedTransform> child_;
 
@@ skipping 27 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // class InterpolatedScale
 //
 // Represents an animated scale.
 //
 ///////////////////////////////////////////////////////////////////////////////
 class UI_EXPORT InterpolatedScale : public InterpolatedTransform {
  public:
   InterpolatedScale(float start_scale, float end_scale);
-  InterpolatedScale(float start_scale,
-                    float end_scale,
+  InterpolatedScale(float start_scale, float end_scale,
+                    float start_time, float end_time);
+  InterpolatedScale(const gfx::Point3f& start_scale,
+                    const gfx::Point3f& end_scale);
+  InterpolatedScale(const gfx::Point3f& start_scale,
+                    const gfx::Point3f& end_scale,
                     float start_time,
                     float end_time);
   virtual ~InterpolatedScale();
 
  protected:
   virtual ui::Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
 
  private:
-  const float start_scale_;
-  const float end_scale_;
+  const gfx::Point3f start_scale_;
+  const gfx::Point3f end_scale_;
 
   DISALLOW_COPY_AND_ASSIGN(InterpolatedScale);
 };
 
 class UI_EXPORT InterpolatedTranslation : public InterpolatedTransform {
  public:
   InterpolatedTranslation(const gfx::Point& start_pos,
                           const gfx::Point& end_pos);
   InterpolatedTranslation(const gfx::Point& start_pos,
                           const gfx::Point& end_pos,
@@ skipping 49 matching lines @@
                                   InterpolatedTransform* transform);
 
   // Takes ownership of the passed transform.
   InterpolatedTransformAboutPivot(const gfx::Point& pivot,
                                   InterpolatedTransform* transform,
                                   float start_time,
                                   float end_time);
   virtual ~InterpolatedTransformAboutPivot();
 
  protected:
-  virtual ui::Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
+  virtual Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
 
  private:
   void Init(const gfx::Point& pivot, InterpolatedTransform* transform);
 
   scoped_ptr<InterpolatedTransform> transform_;
 
   DISALLOW_COPY_AND_ASSIGN(InterpolatedTransformAboutPivot);
 };
 
+class UI_EXPORT InterpolatedTRSTransform : public InterpolatedTransform {
+ public:
+  InterpolatedTRSTransform(const Transform& start_transform,
+                           const Transform& end_transform);
+
+  InterpolatedTRSTransform(const Transform& start_transform,
+                           const Transform& end_transform,
+                           float start_time,
+                           float end_time);
+
+  virtual ~InterpolatedTRSTransform();
+
+ protected:
+  virtual Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
+
+ private:
+  void Init(const ui::Transform& start_transform,
+            const ui::Transform& end_transform);
+
+  scoped_ptr<InterpolatedTransform> transform_;
+};
+
 } // namespace ui
 
 #endif // UI_GFX_INTERPOLATED_TRANSFORM_H_