Migrate ui::Transform to gfx::Transform

ui/gfx/interpolated_transform.h

 // Copyright (c) 2012 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_
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/gfx/point.h"
@@ skipping 15 matching lines @@
 class UI_EXPORT InterpolatedTransform {
  public:
   InterpolatedTransform();
   // The interpolated transform varies only when t in (start_time, end_time).
   // If t <= start_time, Interpolate(t) will return the initial transform, and
   // if t >= end_time, Interpolate(t) will return the final transform.
   InterpolatedTransform(float start_time, float end_time);
   virtual ~InterpolatedTransform();
 
   // Returns the interpolated transform at time t. Note: not virtual.
-  ui::Transform Interpolate(float t) const;
+  gfx::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);
 
   // If the interpolated transform is reversed, Interpolate(t) will return
   // Interpolate(1 - t)
   void SetReversed(bool reversed) { reversed_ = reversed; }
   bool Reversed() const { return reversed_; }
 
-  static bool FactorTRS(const ui::Transform& transform,
+  static bool FactorTRS(const gfx::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;
+  virtual gfx::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_; }
@@ skipping 23 matching lines @@
 class UI_EXPORT InterpolatedRotation : public InterpolatedTransform {
  public:
   InterpolatedRotation(float start_degrees, float end_degrees);
   InterpolatedRotation(float start_degrees,
                        float end_degrees,
                        float start_time,
                        float end_time);
   virtual ~InterpolatedRotation();
 
  protected:
-  virtual ui::Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
+  virtual gfx::Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
 
  private:
   const float start_degrees_;
   const float end_degrees_;
 
   DISALLOW_COPY_AND_ASSIGN(InterpolatedRotation);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // class InterpolatedAxisAngleRotation
 //
 // Represents an animated rotation.
 //
 ///////////////////////////////////////////////////////////////////////////////
 class UI_EXPORT InterpolatedAxisAngleRotation : public InterpolatedTransform {
  public:
   InterpolatedAxisAngleRotation(gfx::Point3f axis,
                                 float start_degrees,
                                 float end_degrees);
   InterpolatedAxisAngleRotation(gfx::Point3f axis,
                                 float start_degrees,
                                 float end_degrees,
                                 float start_time,
                                 float end_time);
   virtual ~InterpolatedAxisAngleRotation();
 
  protected:
-  virtual ui::Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
+  virtual gfx::Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
 
  private:
   gfx::Point3f axis_;
   const float start_degrees_;
   const float end_degrees_;
 
   DISALLOW_COPY_AND_ASSIGN(InterpolatedAxisAngleRotation);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // 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,
                     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;
+  virtual gfx::Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
 
  private:
   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,
                           float start_time,
                           float end_time);
   virtual ~InterpolatedTranslation();
 
  protected:
-  virtual ui::Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
+  virtual gfx::Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
 
  private:
   const gfx::Point start_pos_;
   const gfx::Point end_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(InterpolatedTranslation);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // class InterpolatedConstantTransform
 //
 // Represents a transform that is constant over time. This is only useful when
 // composed with other interpolated transforms.
 //
 // See InterpolatedTransformAboutPivot for an example of its usage.
 //
 ///////////////////////////////////////////////////////////////////////////////
 class UI_EXPORT InterpolatedConstantTransform : public InterpolatedTransform {
  public:
-  InterpolatedConstantTransform(const ui::Transform& transform);
+  InterpolatedConstantTransform(const gfx::Transform& transform);
   virtual ~InterpolatedConstantTransform();
 
  protected:
-  virtual ui::Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
+  virtual gfx::Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
 
  private:
-  const ui::Transform transform_;
+  const gfx::Transform transform_;
 
   DISALLOW_COPY_AND_ASSIGN(InterpolatedConstantTransform);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // class InterpolatedTransformAboutPivot
 //
 // Represents an animated transform with a transformed origin. Essentially,
 // at each time, t, the interpolated transform is created by composing
 // P * T * P^-1 where P is a constant transform to the new origin.
 //
 ///////////////////////////////////////////////////////////////////////////////
 class UI_EXPORT InterpolatedTransformAboutPivot : public InterpolatedTransform {
  public:
   // Takes ownership of the passed transform.
   InterpolatedTransformAboutPivot(const gfx::Point& pivot,
                                   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 Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
+  virtual gfx::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 gfx::Transform& start_transform,
+                           const gfx::Transform& end_transform);
 
-  InterpolatedTRSTransform(const Transform& start_transform,
-                           const Transform& end_transform,
+  InterpolatedTRSTransform(const gfx::Transform& start_transform,
+                           const gfx::Transform& end_transform,
                            float start_time,
                            float end_time);
 
   virtual ~InterpolatedTRSTransform();
 
  protected:
-  virtual Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
+  virtual gfx::Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
 
  private:
-  void Init(const ui::Transform& start_transform,
-            const ui::Transform& end_transform);
+  void Init(const gfx::Transform& start_transform,
+            const gfx::Transform& end_transform);
 
   scoped_ptr<InterpolatedTransform> transform_;
 };
 
 } // namespace ui
 
 #endif // UI_GFX_INTERPOLATED_TRANSFORM_H_