ui/base/animation -> ui/gfx/animation

chrome/browser/ui/gtk/tabs/tab_strip_gtk.cc

 // 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.
 
 #include "chrome/browser/ui/gtk/tabs/tab_strip_gtk.h"
 
 #include <gtk/gtk.h>
 
 #include <algorithm>
 #include <string>
@@ skipping 21 matching lines @@
 #include "chrome/browser/ui/gtk/tabs/dragged_tab_controller_gtk.h"
 #include "chrome/browser/ui/gtk/tabs/tab_strip_menu_controller.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/tabs/tab_strip_model_delegate.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/ui_resources.h"
-#include "ui/base/animation/animation_delegate.h"
-#include "ui/base/animation/slide_animation.h"
 #include "ui/base/dragdrop/gtk_dnd_util.h"
 #include "ui/base/gtk/gtk_screen_util.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "ui/gfx/animation/animation_delegate.h"
+#include "ui/gfx/animation/slide_animation.h"
 #include "ui/gfx/gtk_compat.h"
 #include "ui/gfx/gtk_util.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/point.h"
 
 using content::UserMetricsAction;
 using content::WebContents;
 
 namespace {
 
@@ skipping 66 matching lines @@
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // TabAnimation
 //
 //  A base class for all TabStrip animations.
 //
-class TabStripGtk::TabAnimation : public ui::AnimationDelegate {
+class TabStripGtk::TabAnimation : public gfx::AnimationDelegate {
  public:
   friend class TabStripGtk;
 
   // Possible types of animation.
   enum Type {
     INSERT,
     REMOVE,
     MOVE,
     RESIZE,
     MINI,
     MINI_MOVE
   };
 
   TabAnimation(TabStripGtk* tabstrip, Type type)
       : tabstrip_(tabstrip),
         animation_(this),
         start_selected_width_(0),
         start_unselected_width_(0),
         end_selected_width_(0),
         end_unselected_width_(0),
         layout_on_completion_(false),
         type_(type) {
   }
   virtual ~TabAnimation() {}
 
   Type type() const { return type_; }
 
   void Start() {
     animation_.SetSlideDuration(GetDuration());
-    animation_.SetTweenType(ui::Tween::EASE_OUT);
+    animation_.SetTweenType(gfx::Tween::EASE_OUT);
     if (!animation_.IsShowing()) {
       animation_.Reset();
       animation_.Show();
     }
   }
 
   void Stop() {
     animation_.Stop();
   }
 
@@ skipping 18 matching lines @@
 
     if (animation) {
       double specified_tab_width = animation->GetWidthForTab(index);
       if (specified_tab_width != -1)
         tab_width = specified_tab_width;
     }
 
     return tab_width;
   }
 
-  // Overridden from ui::AnimationDelegate:
-  virtual void AnimationProgressed(const ui::Animation* animation) OVERRIDE {
+  // Overridden from gfx::AnimationDelegate:
+  virtual void AnimationProgressed(const gfx::Animation* animation) OVERRIDE {
     tabstrip_->AnimationLayout(end_unselected_width_);
   }
 
-  virtual void AnimationEnded(const ui::Animation* animation) OVERRIDE {
+  virtual void AnimationEnded(const gfx::Animation* animation) OVERRIDE {
     tabstrip_->FinishAnimation(this, layout_on_completion_);
     // This object is destroyed now, so we can't do anything else after this.
   }
 
-  virtual void AnimationCanceled(const ui::Animation* animation) OVERRIDE {
+  virtual void AnimationCanceled(const gfx::Animation* animation) OVERRIDE {
     AnimationEnded(animation);
   }
 
   // Returns the gap before the tab at the specified index. Subclass if during
   // an animation you need to insert a gap before a tab.
   virtual double GetGapWidth(int index) {
     return 0;
   }
 
  protected:
@@ skipping 27 matching lines @@
       start_unselected_width_ -= minimum_tab_width / start_tab_count;
     }
 
     tabstrip_->GenerateIdealBounds();
     tabstrip_->GetDesiredTabWidths(end_tab_count, end_mini_count,
                                    &end_unselected_width_,
                                    &end_selected_width_);
   }
 
   TabStripGtk* tabstrip_;
-  ui::SlideAnimation animation_;
+  gfx::SlideAnimation animation_;
 
   double start_selected_width_;
   double start_unselected_width_;
   double end_selected_width_;
   double end_unselected_width_;
 
  private:
   // True if a complete re-layout is required upon completion of the animation.
   // Subclasses set this if they don't perform a complete layout
   // themselves and canceling the animation may leave the strip in an
@@ skipping 133 matching lines @@
     // the start of the animation.
     if (tab->IsActive()) {
       double delta = end_selected_width_ - start_selected_width_;
       return start_selected_width_ + (delta * animation_.GetCurrentValue());
     }
 
     double delta = end_unselected_width_ - start_unselected_width_;
     return start_unselected_width_ + (delta * animation_.GetCurrentValue());
   }
 
-  virtual void AnimationEnded(const ui::Animation* animation) OVERRIDE {
+  virtual void AnimationEnded(const gfx::Animation* animation) OVERRIDE {
     tabstrip_->RemoveTabAt(index_);
     TabStripGtk::TabAnimation::AnimationEnded(animation);
   }
 
  private:
   int index_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoveTabAnimation);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // Handles the movement of a Tab from one position to another.
 class MoveTabAnimation : public TabStripGtk::TabAnimation {
  public:
   MoveTabAnimation(TabStripGtk* tabstrip, int tab_a_index, int tab_b_index)
       : TabAnimation(tabstrip, MOVE),
         start_tab_a_bounds_(tabstrip_->GetIdealBounds(tab_b_index)),
         start_tab_b_bounds_(tabstrip_->GetIdealBounds(tab_a_index)) {
     tab_a_ = tabstrip_->GetTabAt(tab_a_index);
     tab_b_ = tabstrip_->GetTabAt(tab_b_index);
 
     // Since we don't do a full TabStrip re-layout, we need to force a full
     // layout upon completion since we're not guaranteed to be in a good state
     // if for example the animation is canceled.
     set_layout_on_completion(true);
   }
   virtual ~MoveTabAnimation() {}
 
-  // Overridden from ui::AnimationDelegate:
-  virtual void AnimationProgressed(const ui::Animation* animation) OVERRIDE {
+  // Overridden from gfx::AnimationDelegate:
+  virtual void AnimationProgressed(const gfx::Animation* animation) OVERRIDE {
     // Position Tab A
     double distance = start_tab_b_bounds_.x() - start_tab_a_bounds_.x();
     double delta = distance * animation_.GetCurrentValue();
     double new_x = start_tab_a_bounds_.x() + delta;
     gfx::Rect bounds(Round(new_x), start_tab_a_bounds_.y(), tab_a_->width(),
         tab_a_->height());
     tabstrip_->SetTabBounds(tab_a_, bounds);
 
     // Position Tab B
     distance = start_tab_a_bounds_.x() - start_tab_b_bounds_.x();
@@ skipping 31 matching lines @@
   explicit ResizeLayoutAnimation(TabStripGtk* tabstrip)
       : TabAnimation(tabstrip, RESIZE) {
     int tab_count = tabstrip->GetTabCount();
     int mini_tab_count = tabstrip->GetMiniTabCount();
     GenerateStartAndEndWidths(tab_count, tab_count, mini_tab_count,
                               mini_tab_count);
     InitStartState();
   }
   virtual ~ResizeLayoutAnimation() {}
 
-  // Overridden from ui::AnimationDelegate:
-  virtual void AnimationEnded(const ui::Animation* animation) OVERRIDE {
+  // Overridden from gfx::AnimationDelegate:
+  virtual void AnimationEnded(const gfx::Animation* animation) OVERRIDE {
     tabstrip_->needs_resize_layout_ = false;
     TabStripGtk::TabAnimation::AnimationEnded(animation);
   }
 
  protected:
   // Overridden from TabStripGtk::TabAnimation:
   virtual int GetDuration() const OVERRIDE {
     return kResizeLayoutAnimationDurationMs;
   }
 
@@ skipping 112 matching lines @@
     if (tabstrip->GetTabAt(to_index)->mini())
       start_mini_count--;
     else
       start_mini_count++;
     GenerateStartAndEndWidths(tab_count, tab_count, start_mini_count,
                               end_mini_count);
     target_bounds_ = tabstrip->GetIdealBounds(to_index);
     tab_->set_animating_mini_change(true);
   }
 
-  // Overridden from ui::AnimationDelegate:
-  virtual void AnimationProgressed(const ui::Animation* animation) OVERRIDE {
+  // Overridden from gfx::AnimationDelegate:
+  virtual void AnimationProgressed(const gfx::Animation* animation) OVERRIDE {
     // Do the normal layout.
     TabAnimation::AnimationProgressed(animation);
 
     // Then special case the position of the tab being moved.
     int x = animation_.CurrentValueBetween(start_bounds_.x(),
                                            target_bounds_.x());
     int width = animation_.CurrentValueBetween(start_bounds_.width(),
                                                target_bounds_.width());
     gfx::Rect tab_bounds(x, start_bounds_.y(), width,
                          start_bounds_.height());
     tabstrip_->SetTabBounds(tab_, tab_bounds);
   }
 
-  virtual void AnimationEnded(const ui::Animation* animation) OVERRIDE {
+  virtual void AnimationEnded(const gfx::Animation* animation) OVERRIDE {
     tabstrip_->needs_resize_layout_ = false;
     TabStripGtk::TabAnimation::AnimationEnded(animation);
   }
 
   virtual double GetGapWidth(int index) OVERRIDE {
     if (to_index_ < from_index_) {
       // The tab was made mini.
       if (index == to_index_) {
         double current_size =
             animation_.CurrentValueBetween(0, target_bounds_.width());
@@ skipping 1610 matching lines @@
 
 void TabStripGtk::SetNewTabButtonBackground() {
   SkColor color = theme_service_->GetColor(
       ThemeProperties::COLOR_BUTTON_BACKGROUND);
   SkBitmap background = theme_service_->GetImageNamed(
       IDR_THEME_WINDOW_CONTROL_BACKGROUND).AsBitmap();
   SkBitmap mask = theme_service_->GetImageNamed(
       IDR_NEWTAB_BUTTON_MASK).AsBitmap();
   newtab_button_->SetBackground(color, background, mask);
 }