GTK Themes: Theme the bookmark bubble. (And first run bubble).

chrome/browser/gtk/info_bubble_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/info_bubble_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
 
 #include "app/gfx/path.h"
 #include "base/basictypes.h"
 #include "base/gfx/gtk_util.h"
 #include "base/gfx/rect.h"
 #include "base/logging.h"
+#include "chrome/browser/gtk/gtk_theme_provider.h"
 #include "chrome/common/notification_service.h"
 
 namespace {
 
 // The height of the arrow, and the width will be about twice the height.
 const int kArrowSize = 5;
 // Number of pixels to the start of the arrow from the edge of the window.
 const int kArrowX = 13;
 // Number of pixels between the tip of the arrow and the region we're
 // pointing to.
@@ skipping 91 matching lines @@
   g_object_unref(gc);
   return FALSE;  // Propagate so our children paint, etc.
 }
 
 }  // namespace
 
 // static
 InfoBubbleGtk* InfoBubbleGtk::Show(GtkWindow* transient_toplevel,
                                    const gfx::Rect& rect,
                                    GtkWidget* content,
+                                   GtkThemeProvider* provider,
                                    InfoBubbleGtkDelegate* delegate) {
-  InfoBubbleGtk* bubble = new InfoBubbleGtk();
+  InfoBubbleGtk* bubble = new InfoBubbleGtk(provider);
   bubble->Init(transient_toplevel, rect, content);
   bubble->set_delegate(delegate);
   return bubble;
 }
 
-InfoBubbleGtk::InfoBubbleGtk()
+InfoBubbleGtk::InfoBubbleGtk(GtkThemeProvider* provider)
     : delegate_(NULL),
       window_(NULL),
+      theme_provider_(provider),
       accel_group_(gtk_accel_group_new()),
       screen_x_(0),
       screen_y_(0) {
 }
 
 InfoBubbleGtk::~InfoBubbleGtk() {
   g_object_unref(accel_group_);
 }
 
 void InfoBubbleGtk::Init(GtkWindow* transient_toplevel,
                          const gfx::Rect& rect,
                          GtkWidget* content) {
   DCHECK(!window_);
   screen_x_ = rect.x() + (rect.width() / 2) - kArrowX;
   screen_y_ = rect.y() + rect.height() + kArrowToContentPadding;
 
   window_ = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   gtk_window_set_transient_for(GTK_WINDOW(window_), transient_toplevel);
   gtk_window_set_decorated(GTK_WINDOW(window_), FALSE);
   gtk_window_set_resizable(GTK_WINDOW(window_), FALSE);
   gtk_widget_set_app_paintable(window_, TRUE);
   // Have GTK double buffer around the expose signal.
   gtk_widget_set_double_buffered(window_, TRUE);
-  // Set the background color, so we don't need to paint it manually.
-  gtk_widget_modify_bg(window_, GTK_STATE_NORMAL, &kBackgroundColor);
   // Make sure that our window can be focused.
   GTK_WIDGET_SET_FLAGS(window_, GTK_CAN_FOCUS);
 
   // Attach our accelerator group to the window with an escape accelerator.
   gtk_accel_group_connect(accel_group_, GDK_Escape,
       static_cast<GdkModifierType>(0), static_cast<GtkAccelFlags>(0),
       g_cclosure_new(G_CALLBACK(&HandleEscapeThunk), this, NULL));
   gtk_window_add_accel_group(GTK_WINDOW(window_), accel_group_);
 
   GtkWidget* alignment = gtk_alignment_new(0.0, 0.0, 1.0, 1.0);
@@ skipping 42 matching lines @@
   // Before adding the grab, we need to ensure that the bubble is added
   // to the window group of the top level window. This ensures that the
   // grab only affects the current browser window, and not all the open
   // browser windows in the application.
   gtk_window_group_add_window(gtk_window_get_group(transient_toplevel),
                               GTK_WINDOW(window_));
   gtk_grab_add(window_);
 
   registrar_.Add(this, NotificationType::ACTIVE_WINDOW_CHANGED,
                  NotificationService::AllSources());
+  registrar_.Add(this, NotificationType::BROWSER_THEME_CHANGED,
+                 NotificationService::AllSources());
+  theme_provider_->InitThemesFor(this);
 }
 
 void InfoBubbleGtk::Observe(NotificationType type,
                             const NotificationSource& source,
                             const NotificationDetails& details) {
-  DCHECK(type.value == NotificationType::ACTIVE_WINDOW_CHANGED);
-
-  // If we are no longer the active toplevel for whatever reason (whether
-  // another toplevel gained focus or our browser did), close.
-  if (window_->window != Details<const GdkWindow>(details).ptr())
-    Close();
+  switch (type.value) {
+    case NotificationType::ACTIVE_WINDOW_CHANGED:
+      // If we are no longer the active toplevel for whatever reason (whether
+      // another toplevel gained focus or our browser did), close.
+      if (window_->window != Details<const GdkWindow>(details).ptr())
+        Close();
+      break;
+    case NotificationType::BROWSER_THEME_CHANGED:
+      if (theme_provider_->UseGtkTheme()) {
+        gtk_widget_modify_bg(window_, GTK_STATE_NORMAL, NULL);
+      } else {
+        // Set the background color, so we don't need to paint it manually.
+        gtk_widget_modify_bg(window_, GTK_STATE_NORMAL, &kBackgroundColor);
+      }
+      break;
+    default:
+      NOTREACHED();
+  }
 }
 
 // static
 GtkWindow* InfoBubbleGtk::GetToplevelForInfoBubble(
-    const GdkWindow* bubble_window){
+    const GdkWindow* bubble_window) {
   if (!bubble_window)
     return NULL;
 
   return reinterpret_cast<GtkWindow*>(
       g_object_get_data(G_OBJECT(bubble_window), kInfoBubbleToplevelKey));
 }
 
 void InfoBubbleGtk::Close(bool closed_by_escape) {
   // Notify the delegate that we're about to close.  This gives the chance
   // to save state / etc from the hosted widget before it's destroyed.
@@ skipping 30 matching lines @@
   return TRUE;
 }
 
 gboolean InfoBubbleGtk::HandleDestroy() {
   // We are self deleting, we have a destroy signal setup to catch when we
   // destroy the widget manually, or the window was closed via X.  This will
   // delete the InfoBubbleGtk object.
   delete this;
   return FALSE;  // Propagate.
 }