GTK: Fix highlight and image colors in the new wrench menu.

chrome/browser/gtk/gtk_theme_provider.cc

 // Copyright (c) 2010 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/gtk_theme_provider.h"
 
 #include <gtk/gtk.h>
 
 #include <set>
 
@@ skipping 183 matching lines @@
 GdkPixbuf* GtkThemeProvider::default_bookmark_icon_ = NULL;
 
 // static
 GtkThemeProvider* GtkThemeProvider::GetFrom(Profile* profile) {
   return static_cast<GtkThemeProvider*>(profile->GetThemeProvider());
 }
 
 GtkThemeProvider::GtkThemeProvider()
     : BrowserThemeProvider(),
       fake_window_(gtk_window_new(GTK_WINDOW_TOPLEVEL)),
-      fake_frame_(meta_frames_new()) {
+      fake_frame_(meta_frames_new()),
+      fullscreen_icon_set_(NULL) {
   fake_label_.Own(gtk_label_new(""));
   fake_entry_.Own(gtk_entry_new());
+  fake_menu_item_.Own(gtk_menu_item_new());
 
   // Only realized widgets receive style-set notifications, which we need to
   // broadcast new theme images and colors. Only realized widgets have style
   // properties, too, which we query for some colors.
   gtk_widget_realize(fake_frame_);
   gtk_widget_realize(fake_window_);
   signals_.Connect(fake_frame_, "style-set",
                    G_CALLBACK(&OnStyleSetThunk), this);
 }
 
 GtkThemeProvider::~GtkThemeProvider() {
   profile()->GetPrefs()->RemovePrefObserver(prefs::kUsesSystemTheme, this);
   gtk_widget_destroy(fake_window_);
   gtk_widget_destroy(fake_frame_);
   fake_label_.Destroy();
   fake_entry_.Destroy();
+  fake_menu_item_.Destroy();
+
+  FreeIconSets();
 
   // We have to call this because FreePlatformCached() in ~BrowserThemeProvider
   // doesn't call the right virutal FreePlatformCaches.
   FreePlatformCaches();
 }
 
 void GtkThemeProvider::Init(Profile* profile) {
   profile->GetPrefs()->AddPrefObserver(prefs::kUsesSystemTheme, this);
   use_gtk_ = profile->GetPrefs()->GetBoolean(prefs::kUsesSystemTheme);
 
   BrowserThemeProvider::Init(profile);
 }
 
 SkBitmap* GtkThemeProvider::GetBitmapNamed(int id) const {
+  // Try to get our cached version:
+  ImageCache::const_iterator it = gtk_images_.find(id);
+  if (it != gtk_images_.end())
+    return it->second;
+
   if (use_gtk_ && IsOverridableImage(id)) {
-    // Try to get our cached version:
-    ImageCache::const_iterator it = gtk_images_.find(id);
-    if (it != gtk_images_.end())
-      return it->second;
-
     // We haven't built this image yet:
     SkBitmap* bitmap = GenerateGtkThemeBitmap(id);
     gtk_images_[id] = bitmap;
     return bitmap;
   }
 
   return BrowserThemeProvider::GetBitmapNamed(id);
 }
 
 SkColor GtkThemeProvider::GetColor(int id) const {
@@ skipping 97 matching lines @@
   // the base color counts more than once.
   GdkColor color;
   color.pixel = 0;
   color.red = (text.red + (bg.red * kBgWeight)) / (1 + kBgWeight);
   color.green = (text.green + (bg.green * kBgWeight)) / (1 + kBgWeight);
   color.blue = (text.blue + (bg.blue * kBgWeight)) / (1 + kBgWeight);
 
   return color;
 }
 
+GtkIconSet* GtkThemeProvider::GetIconSetForId(int id) const {
+  if (id == IDR_FULLSCREEN_MENU_BUTTON)
+    return fullscreen_icon_set_;
+
+  return NULL;
+}
+
 void GtkThemeProvider::GetScrollbarColors(GdkColor* thumb_active_color,
                                           GdkColor* thumb_inactive_color,
                                           GdkColor* track_color) {
   // Create window containing scrollbar elements
   GtkWidget* window    = gtk_window_new(GTK_WINDOW_POPUP);
   GtkWidget* fixed     = gtk_fixed_new();
   GtkWidget* scrollbar = gtk_hscrollbar_new(NULL);
   gtk_container_add(GTK_CONTAINER(window), fixed);
   gtk_container_add(GTK_CONTAINER(fixed),  scrollbar);
   gtk_widget_realize(window);
@@ skipping 158 matching lines @@
   BrowserThemeProvider::ClearAllThemeData();
 }
 
 void GtkThemeProvider::LoadThemePrefs() {
   if (use_gtk_) {
     LoadGtkValues();
   } else {
     LoadDefaultValues();
     BrowserThemeProvider::LoadThemePrefs();
   }
+
+  RebuildMenuIconSets();
 }
 
 void GtkThemeProvider::NotifyThemeChanged(Extension* extension) {
   BrowserThemeProvider::NotifyThemeChanged(extension);
 
   // Notify all GtkChromeButtons of their new rendering mode:
   for (std::vector<GtkWidget*>::iterator it = chrome_buttons_.begin();
        it != chrome_buttons_.end(); ++it) {
     gtk_chrome_button_set_use_gtk_rendering(
         GTK_CHROME_BUTTON(*it), use_gtk_);
@@ skipping 13 matching lines @@
   GdkPixbuf* default_bookmark_icon = default_bookmark_icon_;
   default_folder_icon_ = NULL;
   default_bookmark_icon_ = NULL;
 
   if (profile()->GetPrefs()->GetBoolean(prefs::kUsesSystemTheme)) {
     ClearAllThemeData();
     LoadGtkValues();
     NotifyThemeChanged(NULL);
   }
 
+  RebuildMenuIconSets();
+
   // Free the old icons only after the theme change notification has gone
   // through.
   if (default_folder_icon)
     g_object_unref(default_folder_icon);
   if (default_bookmark_icon)
     g_object_unref(default_bookmark_icon);
 }
 
 void GtkThemeProvider::LoadGtkValues() {
   // Before we start setting images and values, we have to clear out old, stale
@@ skipping 173 matching lines @@
   thumb_active_color_ = SkColorSetRGB(244, 244, 244);
   thumb_inactive_color_ = SkColorSetRGB(234, 234, 234);
   track_color_ = SkColorSetRGB(211, 211, 211);
 
   active_selection_bg_color_ = SkColorSetRGB(30, 144, 255);
   active_selection_fg_color_ = SK_ColorWHITE;
   inactive_selection_bg_color_ = SkColorSetRGB(200, 200, 200);
   inactive_selection_fg_color_ = SkColorSetRGB(50, 50, 50);
 }
 
+void GtkThemeProvider::RebuildMenuIconSets() {
+  FreeIconSets();
+
+  GtkStyle* style = gtk_rc_get_style(fake_menu_item_.get());
+
+  fullscreen_icon_set_ = gtk_icon_set_new();
+  BuildIconFromIDRWithColor(IDR_FULLSCREEN_MENU_BUTTON,
+                            style,
+                            GTK_STATE_PRELIGHT,
+                            fullscreen_icon_set_);
+  BuildIconFromIDRWithColor(IDR_FULLSCREEN_MENU_BUTTON,
+                            style,
+                            GTK_STATE_NORMAL,
+                            fullscreen_icon_set_);
+}
+
+void GtkThemeProvider::BuildIconFromIDRWithColor(int id,
+                                                 GtkStyle* style,
+                                                 GtkStateType state,
+                                                 GtkIconSet* icon_set) {
+  SkColor color = GdkToSkColor(&style->fg[state]);
+  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+  SkBitmap original = *rb.GetBitmapNamed(id);
+
+  SkBitmap fill_color;
+  fill_color.setConfig(SkBitmap::kARGB_8888_Config,
+                       original.width(), original.height(), 0);
+  fill_color.allocPixels();
+  fill_color.eraseColor(color);
+  SkBitmap masked = SkBitmapOperations::CreateMaskedBitmap(
+      fill_color, original);
+
+  GtkIconSource* icon = gtk_icon_source_new();
+  GdkPixbuf* pixbuf = gfx::GdkPixbufFromSkBitmap(&masked);
+  gtk_icon_source_set_pixbuf(icon, pixbuf);
+  g_object_unref(pixbuf);
+
+  gtk_icon_source_set_direction_wildcarded(icon, TRUE);
+  gtk_icon_source_set_size_wildcarded(icon, TRUE);
+
+  gtk_icon_source_set_state(icon, state);
+  // All fields default to wildcarding being on and setting a property doesn't
+  // turn off wildcarding. You need to do this yourself. This is stated once in
+  // the documentation in the gtk_icon_source_new() function, and no where else.
+  gtk_icon_source_set_state_wildcarded(
+      icon, state == GTK_STATE_NORMAL);
+
+  gtk_icon_set_add_source(icon_set, icon);
+  gtk_icon_source_free(icon);
+}
+
 void GtkThemeProvider::SetThemeColorFromGtk(int id, const GdkColor* color) {
   colors_[id] = GdkToSkColor(color);
 }
 
 void GtkThemeProvider::SetThemeTintFromGtk(int id, const GdkColor* color) {
   color_utils::HSL default_tint = GetDefaultTint(id);
   color_utils::HSL hsl;
   color_utils::SkColorToHSL(GdkToSkColor(color), &hsl);
 
   if (default_tint.s != -1)
@@ skipping 21 matching lines @@
   for (PerDisplaySurfaceMap::iterator it = per_display_map->begin();
        it != per_display_map->end(); ++it) {
     for (CairoCachedSurfaceMap::iterator jt = it->second.begin();
          jt != it->second.end(); ++jt) {
       delete jt->second;
     }
   }
   per_display_map->clear();
 }
 
+void GtkThemeProvider::FreeIconSets() {
+  if (fullscreen_icon_set_) {
+    gtk_icon_set_unref(fullscreen_icon_set_);
+    fullscreen_icon_set_ = NULL;
+  }
+}
+
 SkBitmap* GtkThemeProvider::GenerateGtkThemeBitmap(int id) const {
   switch (id) {
     case IDR_THEME_TOOLBAR: {
       GtkStyle* style = gtk_rc_get_style(fake_window_);
       GdkColor* color = &style->bg[GTK_STATE_NORMAL];
       SkBitmap* bitmap = new SkBitmap;
       bitmap->setConfig(SkBitmap::kARGB_8888_Config,
                         kToolbarImageWidth, kToolbarImageHeight);
       bitmap->allocPixels();
       bitmap->eraseRGB(color->red >> 8, color->green >> 8, color->blue >> 8);
@@ skipping 160 matching lines @@
   cairo_set_line_width(cr, 1.0);
   cairo_move_to(cr, start_x, widget->allocation.y);
   cairo_line_to(cr, start_x,
                     widget->allocation.y + widget->allocation.height);
   cairo_stroke(cr);
   cairo_destroy(cr);
   cairo_pattern_destroy(pattern);
 
   return TRUE;
 }