sliding animation for moles

chrome/browser/views/extensions/extension_shelf.cc

 // Copyright (c) 2009 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/views/extensions/extension_shelf.h"
 
 #include <algorithm>
 
 #include "app/resource_bundle.h"
 #include "base/logging.h"
@@ skipping 94 matching lines @@
   gfx::Size GetPreferredSize() { return size(); }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PlaceholderView);
 };
 
 // A wrapper class for the ExtensionHost displayed as a toolstrip.
 // The class itself also acts as the View for the handle of the toolstrip
 // it represents.
 class ExtensionShelf::Toolstrip : public views::View,
-                                  public BrowserBubble::Delegate {
+                                  public BrowserBubble::Delegate,
+                                  public AnimationDelegate {
  public:
   Toolstrip(ExtensionShelf* shelf, ExtensionHost* host,
             const Extension::ToolstripInfo& info);
   virtual ~Toolstrip();
 
+  // Convenience to calculate just the size of the handle.
+  gfx::Size GetHandlePreferredSize();
+
   // View
   virtual void Paint(gfx::Canvas* canvas);
   virtual gfx::Size GetPreferredSize();
   virtual void Layout();
   virtual void OnMouseEntered(const views::MouseEvent& event);
   virtual void OnMouseExited(const views::MouseEvent& event);
   virtual bool OnMousePressed(const views::MouseEvent& event);
   virtual bool OnMouseDragged(const views::MouseEvent& event);
   virtual void OnMouseReleased(const views::MouseEvent& event, bool canceled);
   virtual bool IsFocusable() const { return true; }
@@ skipping 43 matching lines @@
   void StopHandleTimer();
 
   // Expand / Collapse
   void Expand(int height, const GURL& url);
   void Collapse(const GURL& url);
 
   // BrowserBubble::Delegate
   virtual void BubbleBrowserWindowMoved(BrowserBubble* bubble);
   virtual void BubbleBrowserWindowClosing(BrowserBubble* bubble);
 
+  // AnimationDelegate
+  virtual void AnimationProgressed(const Animation* animation);
+  virtual void AnimationEnded(const Animation* animation);
+
  private:
   // The actual renderer that this toolstrip contains.
   ExtensionHost* host_;
 
   // Manifest definition of this toolstrip.
   Extension::ToolstripInfo info_;
 
   // The handle is a BrowserBubble so that it can exist as an independent,
   // floating window.  It also acts as the container for the ExtensionView when
   // it's being dragged.
   scoped_ptr<BrowserBubble> handle_;
 
   // Used for drawing the name of the extension in the handle.
   scoped_ptr<views::Label> title_;
 
   // Pointer back to the containing shelf.
   ExtensionShelf* shelf_;
 
   // When dragging, a placeholder view is put into the shelf to hold space
   // for the ExtensionView.  This view is parent owned when it's in the view
   // hierarchy, so there's no ownership issues here.
   PlaceholderView* placeholder_view_;
 
   // Current state of the toolstrip, currently can't both be expanded and
   // dragging.
   // TODO(erikkay) Support dragging while expanded.
   bool dragging_;
   bool expanded_;
 
+  // The target expanded height of the toolstrip (used for animation).
+  int expanded_height_;
+
   // If dragging, where did the drag start from.
   gfx::Point initial_drag_location_;
 
   // Timers for tracking mouse hovering.
   ScopedRunnableMethodFactory<ExtensionShelf::Toolstrip> timer_factory_;
 
+  // Animate opening and closing the mole.
+  scoped_ptr<SlideAnimation> mole_animation_;
+
   DISALLOW_COPY_AND_ASSIGN(Toolstrip);
 };
 
 ExtensionShelf::Toolstrip::Toolstrip(ExtensionShelf* shelf,
                                      ExtensionHost* host,
                                      const Extension::ToolstripInfo& info)
     : host_(host),
       info_(info),
       shelf_(shelf),
       placeholder_view_(NULL),
       dragging_(false),
       expanded_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(timer_factory_(this)) {
   DCHECK(host->view());
   // We're owned by shelf_, not the bubble that we get inserted in and out of.
   SetParentOwned(false);
 
+  mole_animation_.reset(new SlideAnimation(this));
+
   std::wstring name = UTF8ToWide(host_->extension()->name());
   // |title_| isn't actually put in the view hierarchy.  We just use it
   // to draw in place.  The reason for this is so that we can properly handle
   // the various mouse events necessary for hovering and dragging.
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   title_.reset(new views::Label(name, rb.GetFont(ResourceBundle::BaseFont)));
   title_->SetColor(kHandleTextColor);
   title_->SetDrawHighlighted(true);
   title_->SetHighlightColor(kHandleTextHighlightColor);
   title_->SetBounds(kHandlePadding, kHandlePadding, 100, 100);
@@ skipping 22 matching lines @@
   // Draw the title using a Label as a stamp.
   // See constructor for comment about this.
   title_->ProcessPaint(canvas);
 
   if (dragging_) {
     // when we're dragging, draw the bottom border.
     canvas->FillRectInt(kBorderColor, 0, height() - 1, width(), 1);
   }
 }
 
-gfx::Size ExtensionShelf::Toolstrip::GetPreferredSize() {
+gfx::Size ExtensionShelf::Toolstrip::GetHandlePreferredSize() {
   gfx::Size sz = title_->GetPreferredSize();
   sz.set_width(std::max(view()->width(), sz.width()));
   if (!expanded_)
     sz.Enlarge(2 + kHandlePadding * 2, kHandlePadding * 2);
+  return sz;
+}
+
+gfx::Size ExtensionShelf::Toolstrip::GetPreferredSize() {
+  gfx::Size sz = GetHandlePreferredSize();
   if (dragging_ || expanded_) {
     gfx::Size extension_size = view()->GetPreferredSize();
     sz.Enlarge(0, extension_size.height() + 2);
   }
   return sz;
 }
 
 void ExtensionShelf::Toolstrip::Layout() {
   if (dragging_ || expanded_) {
     int y = title_->bounds().bottom() + kHandlePadding + 1;
@@ skipping 84 matching lines @@
     handle_->set_delegate(this);
     LayoutHandle();
   }
   return handle_.get();
 }
 
 void ExtensionShelf::Toolstrip::LayoutHandle() {
   if (!handle_.get())
     return;
 
+  int handle_height;
+  if (mole_animation_->IsAnimating()) {
+    // We only want to animate the body of the mole window.  When we're
+    // expanding, this is everything except for the handle.  When we're
+    // collapsing, this is everything except for the handle and the toolstrip.
+    // We subtract this amount from the target height, figure out the step in
+    // the animation from the rest, and then add it back in.
+    int handle_offset = shelf_->height();
+    if (!mole_animation_->IsShowing())
+      handle_offset += GetPreferredSize().height();
+    else
+      handle_offset += GetHandlePreferredSize().height();
+    int h = expanded_height_ - handle_offset;
+    handle_height = static_cast<int>(h * mole_animation_->GetCurrentValue());
+    handle_height += handle_offset;
+  } else {
+    handle_height = height();
+  }
+
+  // Now figure out where to place the handle on the screen.  Since it's a top-
+  // level widget, we need to do some coordinate conversion to get this right.
   int handle_width = std::max(view()->width(), width());
-  gfx::Point origin(-kToolstripPadding, -(height() + kToolstripPadding - 1));
-  if (expanded_) {
-    origin.set_y(GetShelfView()->height() - height());
+  gfx::Point origin(-kToolstripPadding,
+                    -(handle_height + kToolstripPadding - 1));
+  if (expanded_ || mole_animation_->IsAnimating()) {
+    origin.set_y(GetShelfView()->height() - handle_height);
     views::View::ConvertPointToView(GetShelfView(), shelf_->GetRootView(),
                                     &origin);
   } else {
     views::View::ConvertPointToWidget(view(), &origin);
   }
   SetBounds(0, 0, handle_width, height());
-  handle_->SetBounds(origin.x(), origin.y(), handle_width, height());
-  handle_->ResizeToView();
+  handle_->SetBounds(origin.x(), origin.y(), handle_width, handle_height);
 }
 
 void ExtensionShelf::Toolstrip::ChildPreferredSizeChanged(View* child) {
   if (child == view()) {
     child->SizeToPreferredSize();
     Layout();
+    LayoutHandle();
     if (expanded_) {
-      LayoutHandle();
       placeholder_view_->SetWidth(child->width());
       shelf_->Layout();
     }
   }
 }
 
 void ExtensionShelf::Toolstrip::BubbleBrowserWindowMoved(
     BrowserBubble* bubble) {
   HideShelfHandle(0);
 }
 
 void ExtensionShelf::Toolstrip::BubbleBrowserWindowClosing(
     BrowserBubble* bubble) {
   DoHideShelfHandle();
 }
 
+void ExtensionShelf::Toolstrip::AnimationProgressed(
+    const Animation* animation) {
+  LayoutHandle();
+}
+
+void ExtensionShelf::Toolstrip::AnimationEnded(const Animation* animation) {
+  LayoutHandle();
+  if (!expanded_) {
+    // Must use the delay due to bug 18248.
+    HideShelfHandle(kHideDelayMs * 2);
+    AttachToShelf(false);
+  }
+}
+
 void ExtensionShelf::Toolstrip::DetachFromShelf(bool browserDetach) {
   DCHECK(handle_.get());
   DCHECK(!placeholder_view_);
   if (browserDetach && handle_->attached())
     handle_->DetachFromBrowser();
 
   // Construct a placeholder view to replace the view.
   placeholder_view_ = new PlaceholderView();
   placeholder_view_->SetBounds(view()->bounds());
   shelf_->AddChildView(placeholder_view_);
@@ skipping 58 matching lines @@
   expanded_ = true;
   view()->set_is_toolstrip(!expanded_);
 
   bool navigate = (!url.is_empty() && url != host_->GetURL());
   if (navigate)
     host_->NavigateToURL(url);
 
   StopHandleTimer();
   DetachFromShelf(false);
 
+  mole_animation_->Show();
+
   gfx::Size extension_size = view()->GetPreferredSize();
   extension_size.set_height(height);
   view()->SetPreferredSize(extension_size);
-  LayoutHandle();
+  expanded_height_ = GetPreferredSize().height();
 
   // This is to prevent flickering as the page loads and lays out.
   // Once the navigation is finished, ExtensionView will wind up setting
   // visibility to true.
   if (navigate)
     view()->SetVisible(false);
 }
 
 void ExtensionShelf::Toolstrip::Collapse(const GURL& url) {
   DCHECK(expanded_);
   expanded_ = false;
   view()->set_is_toolstrip(!expanded_);
 
+  mole_animation_->Hide();
+
   gfx::Size extension_size = view()->GetPreferredSize();
   extension_size.set_height(kToolstripHeight);
   view()->SetPreferredSize(extension_size);
-  AttachToShelf(false);
 
   if (!url.is_empty() && url != host_->GetURL()) {
     host_->NavigateToURL(url);
 
     // This is to prevent flickering as the page loads and lays out.
     // Once the navigation is finished, ExtensionView will wind up setting
     // visibility to true.
     view()->SetVisible(false);
   }
-
-  // Must use the delay due to bug 18248.
-  HideShelfHandle(kHideDelayMs);
 }
 
 void ExtensionShelf::Toolstrip::ShowShelfHandle() {
   StopHandleTimer();
   if (handle_visible())
     return;
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
       timer_factory_.NewRunnableMethod(
           &ExtensionShelf::Toolstrip::DoShowShelfHandle),
       1000);
 }
 
 void ExtensionShelf::Toolstrip::HideShelfHandle(int delay_ms) {
   StopHandleTimer();
-  if (!handle_visible() || dragging_ || expanded_)
+  if (!handle_visible() || dragging_ || expanded_ ||
+      mole_animation_->IsAnimating()) {
     return;
+  }
   if (delay_ms) {
     MessageLoop::current()->PostDelayedTask(FROM_HERE,
         timer_factory_.NewRunnableMethod(
             &ExtensionShelf::Toolstrip::DoHideShelfHandle),
         delay_ms);
   } else {
     DoHideShelfHandle();
   }
 }
 
@@ skipping 457 matching lines @@
 
 bool ExtensionShelf::IsAlwaysShown() {
   Profile* profile = browser_->profile();
   return profile->GetPrefs()->GetBoolean(prefs::kShowExtensionShelf);
 }
 
 bool ExtensionShelf::OnNewTabPage() {
   return (browser_ && browser_->GetSelectedTabContents() &&
       browser_->GetSelectedTabContents()->IsExtensionShelfAlwaysVisible());
 }