Remove last dependencies on ui/base from ui/gfx

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"
 #include "ui/gfx/point3_f.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/transform_util.h"
 #include "ui/gfx/vector3d_f.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
 // times 0 and 1, with a scale from 1 to 0.3 between times 0 and 0.25 and a
 // scale from 0.3 to 1 from between times 0.75 and 1.
 //
 ///////////////////////////////////////////////////////////////////////////////
-class UI_EXPORT InterpolatedTransform {
+class GFX_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.
   gfx::Transform Interpolate(float t) const;
@@ skipping 38 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(InterpolatedTransform);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // class InterpolatedRotation
 //
 // Represents an animated rotation.
 //
 ///////////////////////////////////////////////////////////////////////////////
-class UI_EXPORT InterpolatedRotation : public InterpolatedTransform {
+class GFX_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 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 {
+class GFX_EXPORT InterpolatedAxisAngleRotation : public InterpolatedTransform {
  public:
   InterpolatedAxisAngleRotation(const gfx::Vector3dF& axis,
                                 float start_degrees,
                                 float end_degrees);
   InterpolatedAxisAngleRotation(const gfx::Vector3dF& axis,
                                 float start_degrees,
                                 float end_degrees,
                                 float start_time,
                                 float end_time);
   virtual ~InterpolatedAxisAngleRotation();
 
  protected:
   virtual gfx::Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
 
  private:
   gfx::Vector3dF 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 {
+class GFX_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 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 {
+class GFX_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 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 {
+class GFX_EXPORT InterpolatedConstantTransform : public InterpolatedTransform {
  public:
   explicit InterpolatedConstantTransform(const gfx::Transform& transform);
   virtual ~InterpolatedConstantTransform();
 
  protected:
   virtual gfx::Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
 
  private:
   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 {
+class GFX_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 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 InterpolatedMatrixTransform : public InterpolatedTransform {
+class GFX_EXPORT InterpolatedMatrixTransform : public InterpolatedTransform {
  public:
   InterpolatedMatrixTransform(const gfx::Transform& start_transform,
                               const gfx::Transform& end_transform);
 
   InterpolatedMatrixTransform(const gfx::Transform& start_transform,
                               const gfx::Transform& end_transform,
                               float start_time,
                               float end_time);
 
   virtual ~InterpolatedMatrixTransform();
 
  protected:
   virtual gfx::Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
 
  private:
   void Init(const gfx::Transform& start_transform,
             const gfx::Transform& end_transform);
 
   gfx::DecomposedTransform start_decomp_;
   gfx::DecomposedTransform end_decomp_;
 };
 
 } // namespace ui
 
 #endif  // UI_GFX_INTERPOLATED_TRANSFORM_H_