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

chrome/browser/gtk/bookmark_utils_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_utils_gtk.h"
 
 #include "app/resource_bundle.h"
 #include "base/gfx/gtk_util.h"
 #include "base/pickle.h"
 #include "base/string_util.h"
 #include "chrome/browser/bookmarks/bookmark_drag_data.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/gtk/gtk_chrome_button.h"
 #include "chrome/browser/gtk/gtk_dnd_util.h"
+#include "chrome/browser/gtk/gtk_theme_provider.h"
 #include "chrome/browser/profile.h"
 #include "grit/app_resources.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 
 namespace {
 
 // Used in gtk_selection_data_set(). (I assume from this parameter that gtk has
 // to some really exotic hardware...)
 const int kBitsInAByte = 8;
 
 // Maximum number of characters on a bookmark button.
 const size_t kMaxCharsOnAButton = 15;
 
 // Only used for the background of the drag widget.
 const GdkColor kBackgroundColor = GDK_COLOR_RGB(0xe6, 0xed, 0xf4);
 
-// Color of the button text, taken from TextButtonView.
-const GdkColor kEnabledColor = GDK_COLOR_RGB(6, 45, 117);
-const GdkColor kDisabledColor = GDK_COLOR_RGB(161, 161, 146);
-// TextButtonView uses 255, 255, 255 with opacity of 200. We don't support
-// transparent text though, so just use a slightly lighter version of
-// kEnabledColor.
-const GdkColor kHighlightColor = GDK_COLOR_RGB(56, 95, 167);
-
 void* AsVoid(const BookmarkNode* node) {
   return const_cast<BookmarkNode*>(node);
 }
 
 }  // namespace
 
 namespace bookmark_utils {
 
 const char kBookmarkNode[] = "bookmark-node";
 
@@ skipping 25 matching lines @@
     }
   } else {
     pixbuf = GetFolderIcon();
     g_object_ref(pixbuf);
   }
 
   return pixbuf;
 }
 
 GtkWidget* GetDragRepresentation(const BookmarkNode* node,
-                                 BookmarkModel* model) {
+                                 BookmarkModel* model,
+                                 GtkThemeProperties* properties) {
   // Build a windowed representation for our button.
   GtkWidget* window = gtk_window_new(GTK_WINDOW_POPUP);
-  gtk_widget_modify_bg(window, GTK_STATE_NORMAL, &kBackgroundColor);
+  if (!properties->use_gtk_rendering) {
+    // TODO(erg): Theme wise, which color should I be picking here?
+    // COLOR_BUTTON_BACKGROUND doesn't match the default theme!
+    gtk_widget_modify_bg(window, GTK_STATE_NORMAL, &kBackgroundColor);
+  }
   gtk_widget_realize(window);
 
   GtkWidget* frame = gtk_frame_new(NULL);
   gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT);
   gtk_container_add(GTK_CONTAINER(window), frame);
   gtk_widget_show(frame);
 
   GtkWidget* floating_button = gtk_chrome_button_new();
-  bookmark_utils::ConfigureButtonForNode(node, model, floating_button);
+  bookmark_utils::ConfigureButtonForNode(node, model, floating_button,
+                                         properties);
   gtk_container_add(GTK_CONTAINER(frame), floating_button);
   gtk_widget_show(floating_button);
 
   return window;
 }
 
 void ConfigureButtonForNode(const BookmarkNode* node, BookmarkModel* model,
-                            GtkWidget* button) {
+                            GtkWidget* button, GtkThemeProperties* properties) {
   GtkWidget* former_child = gtk_bin_get_child(GTK_BIN(button));
   if (former_child)
     gtk_container_remove(GTK_CONTAINER(button), former_child);
 
   std::string tooltip = BuildTooltipFor(node);
   if (!tooltip.empty())
     gtk_widget_set_tooltip_text(button, tooltip.c_str());
 
   // We pack the button manually (rather than using gtk_button_set_*) so that
   // we can have finer control over its label.
   GdkPixbuf* pixbuf = bookmark_utils::GetPixbufForNode(node, model);
   GtkWidget* image = gtk_image_new_from_pixbuf(pixbuf);
   g_object_unref(pixbuf);
 
   GtkWidget* label = gtk_label_new(WideToUTF8(node->GetTitle()).c_str());
   gtk_label_set_max_width_chars(GTK_LABEL(label), kMaxCharsOnAButton);
   gtk_label_set_ellipsize(GTK_LABEL(label), PANGO_ELLIPSIZE_END);
 
   GtkWidget* box = gtk_hbox_new(FALSE, kBarButtonPadding);
   gtk_box_pack_start(GTK_BOX(box), image, FALSE, FALSE, 0);
   gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 0);
   gtk_container_add(GTK_CONTAINER(button), box);
 
-  SetButtonTextColors(label);
+  SetButtonTextColors(label, properties);
   g_object_set_data(G_OBJECT(button), bookmark_utils::kBookmarkNode,
                     AsVoid(node));
 
+  gtk_chrome_button_set_use_gtk_rendering(GTK_CHROME_BUTTON(button),
+                                          properties->use_gtk_rendering);
+
   gtk_widget_show_all(box);
 }
 
 std::string BuildTooltipFor(const BookmarkNode* node) {
   // TODO(erg): Actually build the tooltip. For now, we punt and just return
   // the URL.
   return node->GetURL().possibly_invalid_spec();
 }
 
 const BookmarkNode* BookmarkNodeForWidget(GtkWidget* widget) {
   return reinterpret_cast<const BookmarkNode*>(
       g_object_get_data(G_OBJECT(widget), bookmark_utils::kBookmarkNode));
 }
 
-void SetButtonTextColors(GtkWidget* label) {
-  gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &kEnabledColor);
-  gtk_widget_modify_fg(label, GTK_STATE_ACTIVE, &kEnabledColor);
-  gtk_widget_modify_fg(label, GTK_STATE_PRELIGHT, &kHighlightColor);
-  gtk_widget_modify_fg(label, GTK_STATE_INSENSITIVE, &kDisabledColor);
+void SetButtonTextColors(GtkWidget* label, GtkThemeProperties* properties) {
+  if (properties->use_gtk_rendering) {
+    gtk_widget_modify_fg(label, GTK_STATE_NORMAL, NULL);
+    gtk_widget_modify_fg(label, GTK_STATE_ACTIVE, NULL);
+    gtk_widget_modify_fg(label, GTK_STATE_PRELIGHT, NULL);
+    gtk_widget_modify_fg(label, GTK_STATE_INSENSITIVE, NULL);
+  } else {
+    GdkColor color = properties->GetGdkColor(
+        BrowserThemeProvider::COLOR_BOOKMARK_TEXT);
+    gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &color);
+    gtk_widget_modify_fg(label, GTK_STATE_ACTIVE, &color);
+    gtk_widget_modify_fg(label, GTK_STATE_PRELIGHT, &color);
+    gtk_widget_modify_fg(label, GTK_STATE_INSENSITIVE, &color);
+  }
 }
 
 // DnD-related -----------------------------------------------------------------
 
 void WriteBookmarkToSelection(const BookmarkNode* node,
                               GtkSelectionData* selection_data,
                               guint target_type,
                               Profile* profile) {
   DCHECK(node);
   std::vector<const BookmarkNode*> nodes;
@@ skipping 50 matching lines @@
       default: {
         DLOG(ERROR) << "Unsupported drag received type: " << target_type;
       }
     }
   }
 
   return std::vector<const BookmarkNode*>();
 }
 
 }  // namespace bookmark_utils