GTK Themes: Set the text color of bookmark buttons to theme color.

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 <vector>
 
 #include "app/gfx/text_elider.h"
 #include "app/l10n_util.h"
@@ skipping 28 matching lines @@
 
 // The height of the bar.
 const int kBookmarkBarHeight = 29;
 
 // Left-padding for the instructional text.
 const int kInstructionsPadding = 6;
 
 // Color of the instructional text.
 const GdkColor kInstructionsColor = GDK_COLOR_RGB(128, 128, 142);
 
-void SetUseSystemThemeGraphicsOnToolbarItems(GtkToolItem* item, bool use_gtk) {
-  GtkWidget* child = gtk_bin_get_child(GTK_BIN(item));
-  if (GTK_IS_CHROME_BUTTON(child)) {
-    gtk_chrome_button_set_use_gtk_rendering(GTK_CHROME_BUTTON(child), use_gtk);
-  }
-}
-
 }  // namespace
 
 BookmarkBarGtk::BookmarkBarGtk(Profile* profile, Browser* browser,
                                BrowserWindowGtk* window)
     : profile_(NULL),
       page_navigator_(NULL),
       browser_(browser),
       window_(window),
       model_(NULL),
       instructions_(NULL),
@@ skipping 40 matching lines @@
 }
 
 void BookmarkBarGtk::SetPageNavigator(PageNavigator* navigator) {
   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);
+  GtkThemeProperties properties(profile);
 
   bookmark_hbox_.Own(gtk_hbox_new(FALSE, 0));
 
   instructions_ = gtk_alignment_new(0.0, 0.0, 1.0, 1.0);
   gtk_alignment_set_padding(GTK_ALIGNMENT(instructions_), 0, 0,
                             kInstructionsPadding, 0);
   g_signal_connect(instructions_, "destroy", G_CALLBACK(gtk_widget_destroyed),
                    &instructions_);
   GtkWidget* instructions_label = gtk_label_new(
       l10n_util::GetStringUTF8(IDS_BOOKMARKS_NO_ITEMS).c_str());
@@ skipping 31 matching lines @@
 
   gtk_box_pack_start(GTK_BOX(bookmark_hbox_.get()), gtk_vseparator_new(),
                      FALSE, FALSE, 0);
 
   // We pack the button manually (rather than using gtk_button_set_*) so that
   // we can have finer control over its label.
   other_bookmarks_button_ = gtk_chrome_button_new();
   ConnectFolderButtonEvents(other_bookmarks_button_);
 
   GtkWidget* image = gtk_image_new_from_pixbuf(folder_icon);
-  GtkWidget* label = gtk_label_new(
+  other_bookmarks_label_ = gtk_label_new(
       l10n_util::GetStringUTF8(IDS_BOOMARK_BAR_OTHER_BOOKMARKED).c_str());
-  bookmark_utils::SetButtonTextColors(label);
+  bookmark_utils::SetButtonTextColors(other_bookmarks_label_, &properties);
 
   GtkWidget* box = gtk_hbox_new(FALSE, bookmark_utils::kBarButtonPadding);
   gtk_box_pack_start(GTK_BOX(box), image, FALSE, FALSE, 0);
-  gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 0);
+  gtk_box_pack_start(GTK_BOX(box), other_bookmarks_label_, FALSE, FALSE, 0);
   gtk_container_add(GTK_CONTAINER(other_bookmarks_button_), box);
 
   gtk_box_pack_start(GTK_BOX(bookmark_hbox_.get()), other_bookmarks_button_,
                      FALSE, FALSE, 0);
 
   // Set the current theme state for all the buttons.
-  UserChangedTheme(profile);
   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(bool animate) {
@@ skipping 76 matching lines @@
                                        int index) {
   if (parent != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   DCHECK(index >= 0 && index <= GetBookmarkButtonCount());
 
   GtkToolItem* item = CreateBookmarkToolItem(parent->GetChild(index));
   gtk_toolbar_insert(GTK_TOOLBAR(bookmark_toolbar_.get()),
                      item, index);
-  bool use_gtk = GtkThemeProvider::UseSystemThemeGraphics(profile_);
-  SetUseSystemThemeGraphicsOnToolbarItems(item, use_gtk);
 
   SetInstructionState(parent);
 }
 
 void BookmarkBarGtk::BookmarkNodeRemoved(BookmarkModel* model,
                                          const BookmarkNode* parent,
                                          int index) {
   if (parent != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
     return;
@@ skipping 13 matching lines @@
   if (node->GetParent() != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   int index = model_->GetBookmarkBarNode()->IndexOfChild(node);
   DCHECK(index != -1);
 
   GtkToolItem* item = gtk_toolbar_get_nth_item(
       GTK_TOOLBAR(bookmark_toolbar_.get()), index);
   GtkWidget* button = gtk_bin_get_child(GTK_BIN(item));
-  bookmark_utils::ConfigureButtonForNode(node, model, button);
+  GtkThemeProperties properties(profile_);
+  bookmark_utils::ConfigureButtonForNode(node, model, button, &properties);
 }
 
 void BookmarkBarGtk::BookmarkNodeFavIconLoaded(BookmarkModel* model,
                                                const BookmarkNode* node) {
   BookmarkNodeChanged(model, node);
 }
 
 void BookmarkBarGtk::BookmarkNodeChildrenReordered(BookmarkModel* model,
                                                    const BookmarkNode* node) {
   if (node != model_->GetBookmarkBarNode())
     return;  // We only care about reordering of the bookmark bar node.
 
   // Purge and rebuild the bar.
   RemoveAllBookmarkButtons();
   CreateAllBookmarkButtons(node);
 }
 
 void BookmarkBarGtk::CreateAllBookmarkButtons(const BookmarkNode* node) {
   // Create a button for each of the children on the bookmark bar.
   for (int i = 0; i < node->GetChildCount(); ++i) {
     GtkToolItem* item = CreateBookmarkToolItem(node->GetChild(i));
     gtk_toolbar_insert(GTK_TOOLBAR(bookmark_toolbar_.get()), item, -1);
   }
 
-  // Now that we've made a bunch of toolbar items, we need to make sure they
-  // have the correct theme state.
-  UserChangedTheme(profile_);
-
   SetInstructionState(node);
 }
 
 void BookmarkBarGtk::SetInstructionState(
     const BookmarkNode* boomarks_bar_node) {
   show_instructions_ = (boomarks_bar_node->GetChildCount() == 0);
   if (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::UserChangedTheme(Profile* profile) {
-  bool use_gtk = GtkThemeProvider::UseSystemThemeGraphics(profile);
+void BookmarkBarGtk::UserChangedTheme(GtkThemeProperties* properties) {
+  gtk_chrome_button_set_use_gtk_rendering(
+      GTK_CHROME_BUTTON(other_bookmarks_button_),
+      properties->use_gtk_rendering);
+  bookmark_utils::SetButtonTextColors(other_bookmarks_label_, properties);
 
-  gtk_chrome_button_set_use_gtk_rendering(
-      GTK_CHROME_BUTTON(other_bookmarks_button_), use_gtk);
+  if (model_) {
+    // Regenerate the bookmark bar with all new objects with their theme
+    // properties set correctly for the new theme.
+    RemoveAllBookmarkButtons();
 
-  gtk_container_foreach(
-      GTK_CONTAINER(bookmark_toolbar_.get()),
-      reinterpret_cast<void (*)(GtkWidget*, void*)>(
-          SetUseSystemThemeGraphicsOnToolbarItems),
-      reinterpret_cast<void*>(use_gtk));
+    const BookmarkNode* node = model_->GetBookmarkBarNode();
+    DCHECK(node && model_->other_node());
+    CreateAllBookmarkButtons(node);
+  } else {
+    DLOG(ERROR) << "Received a theme change notification while we don't have a "
+                << "BookmarkModel. Taking no action.";
+  }
 }
 
 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());
 }
 
 GtkWidget* BookmarkBarGtk::CreateBookmarkButton(const BookmarkNode* node) {
   GtkWidget* button = gtk_chrome_button_new();
-  bookmark_utils::ConfigureButtonForNode(node, model_, button);
+  GtkThemeProperties properties(profile_);
+  bookmark_utils::ConfigureButtonForNode(node, model_, button, &properties);
 
   // The tool item is also a source for dragging
   gtk_drag_source_set(button, GDK_BUTTON1_MASK,
                       NULL, 0, GDK_ACTION_MOVE);
   GtkDndUtil::SetSourceTargetListFromCodeMask(
       button, GtkDndUtil::X_CHROME_BOOKMARK_ITEM);
   g_signal_connect(G_OBJECT(button), "drag-begin",
                    G_CALLBACK(&OnButtonDragBegin), this);
   g_signal_connect(G_OBJECT(button), "drag-end",
                    G_CALLBACK(&OnButtonDragEnd), this);
@@ skipping 165 matching lines @@
 
   // Signal to any future OnButtonReleased calls that we're dragging instead of
   // pressing.
   bar->ignore_button_release_ = true;
 
   const BookmarkNode* node = bar->GetNodeForToolButton(button);
   DCHECK(!bar->dragged_node_);
   bar->dragged_node_ = node;
   DCHECK(bar->dragged_node_);
 
-  GtkWidget* window = bookmark_utils::GetDragRepresentation(node, bar->model_);
+  GtkThemeProperties properties(bar->profile_);
+  GtkWidget* window = bookmark_utils::GetDragRepresentation(node, bar->model_,
+                                                            &properties);
   gint x, y;
   gtk_widget_get_pointer(button, &x, &y);
   gtk_drag_set_icon_widget(drag_context, window, x, y);
 
   // Hide our node.
   gtk_widget_hide(button);
 }
 
 // static
 void BookmarkBarGtk::OnButtonDragEnd(GtkWidget* button,
@@ skipping 179 matching lines @@
   bar->InitBackground();
   gfx::Point tabstrip_origin =
       bar->window_->tabstrip()->GetTabStripOriginForWidget(widget);
   bar->background_ninebox_->RenderTopCenterStrip(
       cr, tabstrip_origin.x(), tabstrip_origin.y(),
       event->area.x + event->area.width - tabstrip_origin.x());
   cairo_destroy(cr);
 
   return FALSE;  // Propagate expose to children.
 }