linux: Bookmark bar slide animation.

chrome/browser/gtk/bookmark_bar_gtk.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/gtk/bookmark_bar_gtk.h"
 
 #include "app/gfx/gtk_util.h"
 #include "app/gfx/text_elider.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
@@ skipping 12 matching lines @@
 #include "chrome/browser/profile.h"
 #include "chrome/common/gtk_util.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "grit/app_resources.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 
 namespace {
 
+// The height of the bar.
+const int kBookmarkBarHeight = 33;
+
 // Maximum number of characters on a bookmark button.
 const size_t kMaxCharsOnAButton = 15;
 
 // Used in gtk_selection_data_set(). (I assume from this parameter that gtk has
 // to some really exotic hardware...)
 const int kBitsInAByte = 8;
 
 // Dictionary key used to store a BookmarkNode* on a GtkWidget.
 const char kBookmarkNode[] = "bookmark-node";
 
 // Mime types for DnD. Used to synchronize across applications.
 const char kInternalURIType[] = "application/x-chrome-bookmark-item";
 
+// Left-padding for the instructional text.
+const int kInstructionsPadding = 6;
+
+// Color of the instructional text.
+const GdkColor kInstructionsColor = GDK_COLOR_RGB(128, 128, 142);
+
 // Table of the mime types that we accept with their options.
 const GtkTargetEntry kTargetTable[] = {
   { const_cast<char*>(kInternalURIType), GTK_TARGET_SAME_APP,
     dnd::X_CHROME_BOOKMARK_ITEM }
   // TODO(erg): Add "text/uri-list" support.
 };
 
 const int kTargetTableSize = G_N_ELEMENTS(kTargetTable);
 
 }  // namespace
@@ skipping 47 matching lines @@
   page_navigator_ = navigator;
 }
 
 void BookmarkBarGtk::Init(Profile* profile) {
   // Load the default images from the resource bundle.
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   static GdkPixbuf* folder_icon = rb.GetPixbufNamed(IDR_BOOKMARK_BAR_FOLDER);
 
   bookmark_hbox_.Own(gtk_hbox_new(FALSE, 0));
 
-  instructions_ = gtk_label_new(
+  instructions_ = gtk_alignment_new(0.0, 0.0, 1.0, 1.0);
+  gtk_alignment_set_padding(GTK_ALIGNMENT(instructions_), 0, 0,
+                            kInstructionsPadding, 0);
+  GtkWidget* instructions_label = gtk_label_new(
       l10n_util::GetStringUTF8(IDS_BOOKMARKS_NO_ITEMS).c_str());
+  gtk_widget_modify_fg(instructions_label, GTK_STATE_NORMAL,
+                       &kInstructionsColor);
+  gtk_container_add(GTK_CONTAINER(instructions_), instructions_label);
   gtk_box_pack_start(GTK_BOX(bookmark_hbox_.get()), instructions_,
                      FALSE, FALSE, 0);
+
   gtk_widget_set_app_paintable(bookmark_hbox_.get(), TRUE);
   g_signal_connect(G_OBJECT(bookmark_hbox_.get()), "expose-event",
                    G_CALLBACK(&OnHBoxExpose), this);
 
   bookmark_toolbar_.Own(gtk_toolbar_new());
   gtk_widget_set_app_paintable(bookmark_toolbar_.get(), TRUE);
   g_signal_connect(G_OBJECT(bookmark_toolbar_.get()), "expose-event",
                    G_CALLBACK(&OnToolbarExpose), this);
   gtk_box_pack_start(GTK_BOX(bookmark_hbox_.get()), bookmark_toolbar_.get(),
                      TRUE, TRUE, 0);
@@ skipping 18 matching lines @@
   other_bookmarks_button_ = gtk_chrome_button_new();
   ConnectFolderButtonEvents(other_bookmarks_button_);
   gtk_button_set_label(
       GTK_BUTTON(other_bookmarks_button_),
       l10n_util::GetStringUTF8(IDS_BOOMARK_BAR_OTHER_BOOKMARKED).c_str());
   gtk_button_set_image(GTK_BUTTON(other_bookmarks_button_),
                        gtk_image_new_from_pixbuf(folder_icon));
 
   gtk_box_pack_start(GTK_BOX(bookmark_hbox_.get()), other_bookmarks_button_,
                      FALSE, FALSE, 0);
+  gtk_widget_set_size_request(bookmark_hbox_.get(), -1, 0);
+
+  slide_animation_.reset(new SlideAnimation(this));
 }
 
 void BookmarkBarGtk::AddBookmarkbarToBox(GtkWidget* box) {
   gtk_box_pack_start(GTK_BOX(box), bookmark_hbox_.get(), FALSE, FALSE, 0);
 }
 
 void BookmarkBarGtk::Show() {
   gtk_widget_show_all(bookmark_hbox_.get());
+  slide_animation_->Show();
 
   // Maybe show the instructions
   if (show_instructions_) {
     gtk_widget_show(instructions_);
   } else {
     gtk_widget_hide(instructions_);
   }
 }
 
 void BookmarkBarGtk::Hide() {
-  gtk_widget_hide_all(bookmark_hbox_.get());
+  // Sometimes we get called without a matching call to open. If that happens
+  // then force hide.
+  if (slide_animation_->IsShowing())
+    slide_animation_->Hide();
+  else
+    gtk_widget_hide(bookmark_hbox_.get());
 }
 
 bool BookmarkBarGtk::OnNewTabPage() {
   return (browser_ && browser_->GetSelectedTabContents() &&
           browser_->GetSelectedTabContents()->IsBookmarkBarAlwaysVisible());
 }
 
 void BookmarkBarGtk::Loaded(BookmarkModel* model) {
   RemoveAllBookmarkButtons();
 
@@ skipping 92 matching lines @@
     GtkToolItem* item = CreateBookmarkToolItem(node->GetChild(i));
     gtk_toolbar_insert(GTK_TOOLBAR(bookmark_toolbar_.get()), item, -1);
   }
 
   SetInstructionState(node);
 }
 
 void BookmarkBarGtk::SetInstructionState(BookmarkNode* boomarks_bar_node) {
   show_instructions_ = (boomarks_bar_node->GetChildCount() == 0);
   if (show_instructions_) {
-    gtk_widget_show(instructions_);
+    gtk_widget_show_all(instructions_);
   } else {
     gtk_widget_hide(instructions_);
   }
 }
 
 void BookmarkBarGtk::RemoveAllBookmarkButtons() {
   gtk_util::RemoveAllChildren(bookmark_toolbar_.get());
 }
 
 int BookmarkBarGtk::GetBookmarkButtonCount() {
   GList* children = gtk_container_get_children(
       GTK_CONTAINER(bookmark_toolbar_.get()));
   int count = g_list_length(children);
   g_list_free(children);
   return count;
 }
 
 bool BookmarkBarGtk::IsAlwaysShown() {
   return profile_->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar);
 }
 
+void BookmarkBarGtk::AnimationProgressed(const Animation* animation) {
+  DCHECK_EQ(animation, slide_animation_.get());
+
+  gtk_widget_set_size_request(bookmark_hbox_.get(), -1,
+                              animation->GetCurrentValue() *
+                              kBookmarkBarHeight);
+}
+
+void BookmarkBarGtk::AnimationEnded(const Animation* animation) {
+  DCHECK_EQ(animation, slide_animation_.get());
+
+  if (!slide_animation_->IsShowing())
+    gtk_widget_hide(bookmark_hbox_.get());
+}
+
 void BookmarkBarGtk::ConfigureButtonForNode(BookmarkNode* node,
                                             GtkWidget* button) {
   std::string tooltip = BuildTooltip(node);
   if (!tooltip.empty())
     gtk_widget_set_tooltip_text(button, tooltip.c_str());
 
   // TODO(erg): Consider a soft maximum instead of this hard 15.
   std::wstring title = node->GetTitle();
   title = title.substr(0, std::min(title.size(), kMaxCharsOnAButton));
   gtk_button_set_label(GTK_BUTTON(button), WideToUTF8(title).c_str());
@@ skipping 48 matching lines @@
     // button.
     g_signal_connect(G_OBJECT(button), "button-press-event",
                      G_CALLBACK(OnButtonPressed), this);
     g_signal_connect(G_OBJECT(button), "button-release-event",
                      G_CALLBACK(OnButtonReleased), this);
   } else {
     // TODO(erg): This button can also be a drop target.
     ConnectFolderButtonEvents(button);
   }
 
-  GTK_WIDGET_UNSET_FLAGS(button, GTK_CAN_FOCUS);
-
   return button;
 }
 
 GtkToolItem* BookmarkBarGtk::CreateBookmarkToolItem(BookmarkNode* node) {
   GtkWidget* button = CreateBookmarkButton(node);
   g_object_set_data(G_OBJECT(button), "left-align-popup",
                     reinterpret_cast<void*>(true));
 
   GtkToolItem* item = gtk_tool_item_new();
   gtk_container_add(GTK_CONTAINER(item), button);
@@ skipping 366 matching lines @@
   cairo_rectangle(cr, event->area.x, event->area.y,
                   event->area.width, event->area.height);
   cairo_clip(cr);
   bar->InitBackground();
   bar->background_ninebox_->RenderTopCenterStrip(cr, event->area.x,
                                                  0, event->area.width);
   cairo_destroy(cr);
 
   return FALSE;  // Propagate expose to children.
 }