mole expand/collapse API

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 135 matching lines @@
   void DetachFromShelf(bool browser);
   void AttachToShelf(bool browser);
 
   // Show / Hide the shelf handle.
   void ShowShelfHandle();
   void DoShowShelfHandle();
   void HideShelfHandle(int delay_ms);
   void DoHideShelfHandle();
   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);
 
  private:
   // The actual renderer that this toolstrip contains.
   ExtensionHost* host_;
 
   // Manifest definition of this toolstrip.
   Extension::ToolstripInfo info_;
@@ skipping 81 matching lines @@
 
   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 sz = title_->GetPreferredSize();
   sz.set_width(std::max(view()->width(), sz.width()));
-  if (!expanded_) {
+  if (!expanded_)
     sz.Enlarge(2 + kHandlePadding * 2, kHandlePadding * 2);
-  }
   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 56 matching lines @@
     // Drop the toolstrip roughly where it is now.
     views::View::OnMouseReleased(event, canceled);
     dragging_ = false;
     // |this| and |shelf_| are in different view hierarchies, so we need to
     // convert to screen coordinates and back again to map locations.
     gfx::Point loc = event.location();
     View::ConvertPointToScreen(this, &loc);
     View::ConvertPointToView(NULL, shelf_, &loc);
     shelf_->DropExtension(this, loc, canceled);
     AttachToShelf(true);
-  } else if (!canceled &&
-             info_.mole.is_valid() && info_.toolstrip.is_valid()) {
+  } else if (!canceled) {
     // Toggle mole to either expanded or collapsed.
-    expanded_ = !expanded_;
-    view()->set_is_toolstrip(!expanded_);
+    // TODO(erikkay) If there's no valid URL in the manifest, should we
+    // post an event to the toolstrip in this case?
     if (expanded_) {
-      host_->NavigateToURL(info_.mole);
-      StopHandleTimer();
-      DetachFromShelf(false);
-
-      gfx::Size extension_size = view()->GetPreferredSize();
-      extension_size.set_height(info_.mole_height);
-      view()->SetPreferredSize(extension_size);
-      LayoutHandle();
+      if (info_.toolstrip.is_valid())
+        shelf_->CollapseToolstrip(host_, info_.toolstrip);
     } else {
-      gfx::Size extension_size = view()->GetPreferredSize();
-      extension_size.set_height(kToolstripHeight);
-      view()->SetPreferredSize(extension_size);
-
-      host_->NavigateToURL(info_.toolstrip);
-      AttachToShelf(false);
+     if (info_.mole.is_valid())
+       shelf_->ExpandToolstrip(host_, info_.mole, info_.mole_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.
-    view()->SetVisible(false);
   }
 }
 
 BrowserBubble* ExtensionShelf::Toolstrip::GetHandle() {
   if (!handle_.get()) {
     handle_.reset(new BrowserBubble(this, shelf_->GetWidget(),
                                     gfx::Point(0, 0)));
     handle_->set_delegate(this);
     LayoutHandle();
   }
@@ skipping 34 matching lines @@
     BrowserBubble* bubble) {
   HideShelfHandle(0);
 }
 
 void ExtensionShelf::Toolstrip::BubbleBrowserWindowClosing(
     BrowserBubble* bubble) {
   DoHideShelfHandle();
 }
 
 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_);
 
   AddChildView(view());
   SizeToPreferredSize();
   handle_->ResizeToView();
   Layout();
 }
 
 void ExtensionShelf::Toolstrip::AttachToShelf(bool browserAttach) {
+  DCHECK(handle_.get());
+  DCHECK(placeholder_view_);
   if (browserAttach && !handle_->attached())
     handle_->AttachToBrowser();
 
   // Move the view back into the shelf and remove the old placeholder.
   shelf_->AddChildView(view());
 
   // The size of the view may have changed, so just set the position.
   view()->SetX(placeholder_view_->x());
   view()->SetY(placeholder_view_->y());
 
@@ skipping 23 matching lines @@
     handle_->DetachFromBrowser();
   handle_.reset(NULL);
   shelf_->Layout();
 }
 
 void ExtensionShelf::Toolstrip::StopHandleTimer() {
   if (!timer_factory_.empty())
     timer_factory_.RevokeAll();
 }
 
+void ExtensionShelf::Toolstrip::Expand(int height, const GURL& url) {
+  DCHECK(!expanded_);
+
+  DoShowShelfHandle();
+
+  expanded_ = true;
+  view()->set_is_toolstrip(!expanded_);
+
+  bool navigate = (!url.is_empty() && url != host_->GetURL());
+  if (navigate)
+    host_->NavigateToURL(url);
+
+  StopHandleTimer();
+  DetachFromShelf(false);
+
+  gfx::Size extension_size = view()->GetPreferredSize();
+  extension_size.set_height(height);
+  view()->SetPreferredSize(extension_size);
+  LayoutHandle();
+
+  // 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_);
+
+  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_)
     return;
   if (delay_ms) {
     MessageLoop::current()->PostDelayedTask(FROM_HERE,
         timer_factory_.NewRunnableMethod(
             &ExtensionShelf::Toolstrip::DoHideShelfHandle),
         delay_ms);
   } else {
     DoHideShelfHandle();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 ExtensionShelf::ExtensionShelf(Browser* browser)
-    : model_(new ExtensionShelfModel(browser)) {
+    : model_(browser->extension_shelf_model()) {
   model_->AddObserver(this);
   LoadFromModel();
   EnableCanvasFlippingForRTLUI(true);
 }
 
 ExtensionShelf::~ExtensionShelf() {
-  int count = model_->count();
-  for (int i = 0; i < count; ++i) {
-    delete ToolstripAtIndex(i);
-    model_->SetToolstripDataAt(i, NULL);
+  if (model_) {
+    int count = model_->count();
+    for (int i = 0; i < count; ++i) {
+      delete ToolstripAtIndex(i);
+      model_->SetToolstripDataAt(i, NULL);
+    }
+    model_->RemoveObserver(this);
   }
-  model_->RemoveObserver(this);
 }
 
 void ExtensionShelf::Paint(gfx::Canvas* canvas) {
 #if 0
   // TODO(erikkay) re-enable this when Glen has the gradient values worked out.
   SkPaint paint;
   paint.setShader(skia::CreateGradientShader(0,
                                              height(),
                                              kTopGradientColor,
                                              kBackgroundColor))->safeUnref();
@@ skipping 30 matching lines @@
 void ExtensionShelf::ChildPreferredSizeChanged(View* child) {
   Toolstrip *toolstrip = ToolstripForView(static_cast<ExtensionView*>(child));
   if (!toolstrip)
     return;
   Layout();
 }
 
 void ExtensionShelf::Layout() {
   if (!GetParent())
     return;
+  if (!model_)
+    return;
 
   int x = kLeftMargin;
   int y = kTopMargin;
   int content_height = height() - kTopMargin - kBottomMargin;
   int max_x = width() - kRightMargin;
 
   int count = model_->count();
   for (int i = 0; i < count; ++i) {
     x += kToolstripPadding;  // left padding
     Toolstrip* toolstrip = ToolstripAtIndex(i);
@@ skipping 36 matching lines @@
   return false;
 }
 
 void ExtensionShelf::SetAccessibleName(const std::wstring& name) {
   accessible_name_.assign(name);
 }
 
 void ExtensionShelf::ToolstripInsertedAt(ExtensionHost* host,
                                          int index) {
   model_->SetToolstripDataAt(index,
-      new Toolstrip(this, host, model_->ToolstripInfoAt(index)));
+      new Toolstrip(this, host, model_->ToolstripAt(index).info));
 
   bool had_views = GetChildViewCount() > 0;
   ExtensionView* view = host->view();
   if (!background_.empty())
     view->SetBackground(background_);
   AddChildView(view);
   view->SetContainer(this);
   if (!had_views)
     PreferredSizeChanged();
   Layout();
@@ skipping 13 matching lines @@
 }
 
 void ExtensionShelf::ToolstripDraggingFrom(ExtensionHost* host, int index) {
 }
 
 void ExtensionShelf::ToolstripMoved(ExtensionHost* host, int from_index,
                                     int to_index) {
   Layout();
 }
 
-void ExtensionShelf::ToolstripChangedAt(ExtensionHost* toolstrip, int index) {
+void ExtensionShelf::ToolstripChanged(ExtensionShelfModel::iterator toolstrip) {
+  Toolstrip* t = static_cast<Toolstrip*>(toolstrip->data);
+  if (toolstrip->height > 0) {
+    if (!t->expanded()) {
+      t->Expand(toolstrip->height, toolstrip->url);
+    }
+  } else if (t->expanded()) {
+    t->Collapse(toolstrip->url);
+  }
 }
 
 void ExtensionShelf::ExtensionShelfEmpty() {
   PreferredSizeChanged();
 }
 
 void ExtensionShelf::ShelfModelReloaded() {
   // None of the child views are parent owned, so nothing is being leaked here.
   RemoveAllChildViews(false);
   LoadFromModel();
 }
 
+void ExtensionShelf::ShelfModelDeleting() {
+  int count = model_->count();
+  for (int i = 0; i < count; ++i) {
+    delete ToolstripAtIndex(i);
+    model_->SetToolstripDataAt(i, NULL);
+  }
+  model_->RemoveObserver(this);
+  model_ = NULL;
+}
+
 void ExtensionShelf::OnExtensionMouseEvent(ExtensionView* view) {
   Toolstrip *toolstrip = ToolstripForView(view);
   if (toolstrip)
     toolstrip->ShowShelfHandle();
 }
 
 void ExtensionShelf::OnExtensionMouseLeave(ExtensionView* view) {
   Toolstrip *toolstrip = ToolstripForView(view);
   if (toolstrip)
     toolstrip->HideShelfHandle(kHideDelayMs);
 }
 
 void ExtensionShelf::DropExtension(Toolstrip* toolstrip, const gfx::Point& pt,
                                    bool cancel) {
   Toolstrip* dest_toolstrip = ToolstripAtX(pt.x());
   if (!dest_toolstrip) {
     if (pt.x() > 0)
       dest_toolstrip = ToolstripAtIndex(model_->count() - 1);
     else
       dest_toolstrip = ToolstripAtIndex(0);
   }
   if (toolstrip == dest_toolstrip)
     return;
-  int from = model_->IndexOfToolstrip(toolstrip->host());
-  int to = model_->IndexOfToolstrip(dest_toolstrip->host());
+  int from = model_->IndexOfHost(toolstrip->host());
+  int to = model_->IndexOfHost(dest_toolstrip->host());
   DCHECK(from != to);
   model_->MoveToolstripAt(from, to);
 }
 
+void ExtensionShelf::ExpandToolstrip(ExtensionHost* host, const GURL& url,
+                                     int height) {
+  ExtensionShelfModel::iterator toolstrip = model_->ToolstripForHost(host);
+  model_->ExpandToolstrip(toolstrip, url, height);
+}
+
+void ExtensionShelf::CollapseToolstrip(ExtensionHost* host, const GURL& url) {
+  ExtensionShelfModel::iterator toolstrip = model_->ToolstripForHost(host);
+  model_->CollapseToolstrip(toolstrip, url);
+}
+
 void ExtensionShelf::InitBackground(gfx::Canvas* canvas, const SkRect& subset) {
   if (!background_.empty())
     return;
 
   const SkBitmap& background = canvas->getDevice()->accessBitmap(false);
 
   // Extract the correct subset of the toolstrip background into a bitmap. We
   // must use a temporary here because extractSubset() returns a bitmap that
   // references pixels in the original one and we want to actually make a copy
   // that will have a long lifetime.
@@ skipping 34 matching lines @@
     View* view = toolstrip->GetShelfView();
     if (x > (view->x() + view->width() + kToolstripPadding))
       continue;
     return toolstrip;
   }
 
   return NULL;
 }
 
 ExtensionShelf::Toolstrip* ExtensionShelf::ToolstripAtIndex(int index) {
-  return static_cast<Toolstrip*>(model_->ToolstripDataAt(index));
+  return static_cast<Toolstrip*>(model_->ToolstripAt(index).data);
 }
 
 ExtensionShelf::Toolstrip* ExtensionShelf::ToolstripForView(
     ExtensionView* view) {
   int count = model_->count();
   for (int i = 0; i < count; ++i) {
     Toolstrip* toolstrip = ToolstripAtIndex(i);
     if (view == toolstrip->view())
       return toolstrip;
   }
-  NOTREACHED();
   return NULL;
 }
 
 void ExtensionShelf::LoadFromModel() {
   int count = model_->count();
   for (int i = 0; i < count; ++i)
-    ToolstripInsertedAt(model_->ToolstripAt(i), i);
+    ToolstripInsertedAt(model_->ToolstripAt(i).host, i);
 }