Initial gtk3 support

chrome/browser/ui/libgtk2ui/gtk2_ui.cc

 // Copyright (c) 2012 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/ui/libgtk2ui/gtk2_ui.h"
 
 #include <math.h>
 #include <set>
 
 #include <pango/pango.h>
@@ skipping 163 matching lines @@
   IDR_OMNIBOX_STAR,
   IDR_OMNIBOX_STAR_DARK,
   IDR_OMNIBOX_TTS,
   IDR_OMNIBOX_TTS_DARK,
 };
 
 // This table converts button ids into a pair of gtk-stock id and state.
 struct IDRGtkMapping {
   int idr;
   const char* stock_id;
-  GtkStateType gtk_state;
+  GtkStateFlags gtk_state;
 } const kGtkIcons[] = {
-  { IDR_BACK,      GTK_STOCK_GO_BACK,    GTK_STATE_NORMAL },
-  { IDR_BACK_D,    GTK_STOCK_GO_BACK,    GTK_STATE_INSENSITIVE },
+  { IDR_BACK,      GTK_STOCK_GO_BACK,    GTK_STATE_FLAG_NORMAL },
+  { IDR_BACK_D,    GTK_STOCK_GO_BACK,    GTK_STATE_FLAG_INSENSITIVE },
 
-  { IDR_FORWARD,   GTK_STOCK_GO_FORWARD, GTK_STATE_NORMAL },
-  { IDR_FORWARD_D, GTK_STOCK_GO_FORWARD, GTK_STATE_INSENSITIVE },
+  { IDR_FORWARD,   GTK_STOCK_GO_FORWARD, GTK_STATE_FLAG_NORMAL },
+  { IDR_FORWARD_D, GTK_STOCK_GO_FORWARD, GTK_STATE_FLAG_INSENSITIVE },
 
-  { IDR_HOME,      GTK_STOCK_HOME,       GTK_STATE_NORMAL },
+  { IDR_HOME,      GTK_STOCK_HOME,       GTK_STATE_FLAG_NORMAL },
 
-  { IDR_RELOAD,    GTK_STOCK_REFRESH,    GTK_STATE_NORMAL },
-  { IDR_RELOAD_D,  GTK_STOCK_REFRESH,    GTK_STATE_INSENSITIVE },
+  { IDR_RELOAD,    GTK_STOCK_REFRESH,    GTK_STATE_FLAG_NORMAL },
+  { IDR_RELOAD_D,  GTK_STOCK_REFRESH,    GTK_STATE_FLAG_INSENSITIVE },
 
-  { IDR_STOP,      GTK_STOCK_STOP,       GTK_STATE_NORMAL },
-  { IDR_STOP_D,    GTK_STOCK_STOP,       GTK_STATE_INSENSITIVE },
+  { IDR_STOP,      GTK_STOCK_STOP,       GTK_STATE_FLAG_NORMAL },
+  { IDR_STOP_D,    GTK_STOCK_STOP,       GTK_STATE_FLAG_INSENSITIVE },
 };
 
 // The image resources that will be tinted by the 'button' tint value.
 const int kOtherToolbarButtonIDs[] = {
   IDR_TOOLBAR_BEZEL_HOVER,
   IDR_TOOLBAR_BEZEL_PRESSED,
   IDR_BROWSER_ACTIONS_OVERFLOW,
 
   // TODO(erg): The dropdown arrow should be tinted because we're injecting
   // various background GTK colors, but the code that accesses them needs to be
@@ skipping 556 matching lines @@
   if (theme_thumb_active && theme_thumb_inactive && theme_trough_color) {
     *thumb_active_color = *theme_thumb_active;
     *thumb_inactive_color = *theme_thumb_inactive;
     *track_color = *theme_trough_color;
 
     gdk_color_free(theme_thumb_active);
     gdk_color_free(theme_thumb_inactive);
     gdk_color_free(theme_trough_color);
     return;
   }
-
-  // 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);
-  gtk_widget_realize(scrollbar);
-
-  // Draw scrollbar thumb part and track into offscreen image
-  const int kWidth  = 100;
-  const int kHeight = 20;
-  GtkStyle* style   = gtk_rc_get_style(scrollbar);
-  GdkWindow* gdk_window = gtk_widget_get_window(window);
-  GdkPixmap* pm     = gdk_pixmap_new(gdk_window, kWidth, kHeight, -1);
-  GdkRectangle rect = { 0, 0, kWidth, kHeight };
-  unsigned char data[3 * kWidth * kHeight];
-  for (int i = 0; i < 3; ++i) {
-    if (i < 2) {
-      // Thumb part
-      gtk_paint_slider(style, pm,
-                       i == 0 ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL,
-                       GTK_SHADOW_OUT, &rect, scrollbar, "slider", 0, 0,
-                       kWidth, kHeight, GTK_ORIENTATION_HORIZONTAL);
-    } else {
-      // Track
-      gtk_paint_box(style, pm, GTK_STATE_ACTIVE, GTK_SHADOW_IN, &rect,
-                    scrollbar, "trough-upper", 0, 0, kWidth, kHeight);
-    }
-    GdkPixbuf* pb = gdk_pixbuf_new_from_data(data, GDK_COLORSPACE_RGB,
-                                             FALSE, 8, kWidth, kHeight,
-                                             3 * kWidth, 0, 0);
-    gdk_pixbuf_get_from_drawable(pb, pm, NULL, 0, 0, 0, 0, kWidth, kHeight);
-
-    // Sample pixels
-    int components[3] = { 0 };
-    for (int y = 2; y < kHeight - 2; ++y) {
-      for (int c = 0; c < 3; ++c) {
-        // Sample a vertical slice of pixels at about one-thirds from the
-        // left edge. This allows us to avoid any fixed graphics that might be
-        // located at the edges or in the center of the scrollbar.
-        // Each pixel is made up of a red, green, and blue component; taking up
-        // a total of three bytes.
-        components[c] += data[3 * (kWidth / 3 + y * kWidth) + c];
-      }
-    }
-    GdkColor* color = i == 0 ? thumb_active_color :
-                      i == 1 ? thumb_inactive_color :
-                               track_color;
-    color->pixel = 0;
-    // We sampled pixels across the full height of the image, ignoring a two
-    // pixel border. In some themes, the border has a completely different
-    // color which we do not want to factor into our average color computation.
-    //
-    // We now need to scale the colors from the 0..255 range, to the wider
-    // 0..65535 range, and we need to actually compute the average color; so,
-    // we divide by the total number of pixels in the sample.
-    color->red   = components[0] * 65535 / (255 * (kHeight - 4));
-    color->green = components[1] * 65535 / (255 * (kHeight - 4));
-    color->blue  = components[2] * 65535 / (255 * (kHeight - 4));
-
-    g_object_unref(pb);
-  }
-  g_object_unref(pm);
-
-  gtk_widget_destroy(window);
-
-  // Override any of the default colors with ones that were specified by the
-  // theme.
-  if (theme_thumb_active) {
-    *thumb_active_color = *theme_thumb_active;
-    gdk_color_free(theme_thumb_active);
-  }
-
-  if (theme_thumb_inactive) {
-    *thumb_inactive_color = *theme_thumb_inactive;
-    gdk_color_free(theme_thumb_inactive);
-  }
-
-  if (theme_trough_color) {
-    *track_color = *theme_trough_color;
-    gdk_color_free(theme_trough_color);
-  }
 }
 
 void Gtk2UI::LoadGtkValues() {
   // TODO(erg): GtkThemeService had a comment here about having to muck with
   // the raw Prefs object to remove prefs::kCurrentThemeImages or else we'd
   // regress startup time. Figure out how to do that when we can't access the
   // prefs system from here.
 
   GtkStyle* frame_style = gtk_rc_get_style(fake_frame_);
 
@@ skipping 267 matching lines @@
     case IDR_FORWARD:
     case IDR_FORWARD_D:
     case IDR_HOME:
     case IDR_RELOAD:
     case IDR_RELOAD_D:
     case IDR_STOP:
     case IDR_STOP_D: {
       return GenerateGTKIcon(id);
     }
     case IDR_TOOLBAR_BEZEL_HOVER:
-      return GenerateToolbarBezel(GTK_STATE_PRELIGHT, IDR_TOOLBAR_BEZEL_HOVER);
+      return GenerateToolbarBezel(GTK_STATE_FLAG_PRELIGHT, IDR_TOOLBAR_BEZEL_HOVER);
     case IDR_TOOLBAR_BEZEL_PRESSED:
-      return GenerateToolbarBezel(GTK_STATE_ACTIVE, IDR_TOOLBAR_BEZEL_PRESSED);
+      return GenerateToolbarBezel(GTK_STATE_FLAG_ACTIVE, IDR_TOOLBAR_BEZEL_PRESSED);
     default: {
       return GenerateTintedIcon(id, button_tint_);
     }
   }
 
   return SkBitmap();
 }
 
 SkBitmap Gtk2UI::GenerateFrameImage(
     int color_id,
@@ skipping 47 matching lines @@
 SkBitmap Gtk2UI::GenerateTintedIcon(
     int base_id,
     const color_utils::HSL& tint) const {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   return SkBitmapOperations::CreateHSLShiftedBitmap(
       rb.GetImageNamed(base_id).AsBitmap(), tint);
 }
 
 SkBitmap Gtk2UI::GenerateGTKIcon(int base_id) const {
   const char* stock_id = NULL;
-  GtkStateType gtk_state = GTK_STATE_NORMAL;
+  GtkStateFlags gtk_state = GTK_STATE_FLAG_NORMAL;
   for (unsigned int i = 0; i < arraysize(kGtkIcons); ++i) {
     if (kGtkIcons[i].idr == base_id) {
       stock_id = kGtkIcons[i].stock_id;
       gtk_state = kGtkIcons[i].gtk_state;
       break;
     }
   }
   DCHECK(stock_id);
 
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   SkBitmap default_bitmap = rb.GetImageNamed(base_id).AsBitmap();
 
   gtk_widget_ensure_style(fake_frame_);
   GtkStyle* style = gtk_widget_get_style(fake_frame_);
   GtkIconSet* icon_set = gtk_style_lookup_icon_set(style, stock_id);
   if (!icon_set)
     return default_bitmap;
 
   // Ask GTK to render the icon to a buffer, which we will steal from.
   GdkPixbuf* gdk_icon = gtk_icon_set_render_icon(
       icon_set,
       style,
       base::i18n::IsRTL() ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR,
-      gtk_state,
+      gtk_state == GTK_STATE_FLAG_INSENSITIVE ? GTK_STATE_INSENSITIVE : GTK_STATE_NORMAL,
       GTK_ICON_SIZE_SMALL_TOOLBAR,
       fake_frame_,
       NULL);
 
   if (!gdk_icon) {
     // This can theoretically happen if an icon theme doesn't provide a
     // specific image. This should realistically never happen, but I bet there
     // are some theme authors who don't reliably provide all icons.
     return default_bitmap;
   }
 
   SkBitmap retval;
   retval.allocN32Pixels(default_bitmap.width(), default_bitmap.height());
   retval.eraseColor(0);
 
   const SkBitmap icon = GdkPixbufToImageSkia(gdk_icon);
   g_object_unref(gdk_icon);
 
   SkCanvas canvas(retval);
 
-  if (gtk_state == GTK_STATE_ACTIVE || gtk_state == GTK_STATE_PRELIGHT) {
-    SkBitmap border = DrawGtkButtonBorder(gtk_state,
-                                          false,
-                                          false,
-                                          default_bitmap.width(),
-                                          default_bitmap.height());
-    canvas.drawBitmap(border, 0, 0);
-  }
-
   canvas.drawBitmap(icon,
                     (default_bitmap.width() / 2) - (icon.width() / 2),
                     (default_bitmap.height() / 2) - (icon.height() / 2));
 
   return retval;
 }
 
 SkBitmap Gtk2UI::GenerateToolbarBezel(int gtk_state, int sizing_idr) const {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   SkBitmap default_bitmap =
       rb.GetImageNamed(sizing_idr).AsBitmap();
 
   SkBitmap retval;
   retval.allocN32Pixels(default_bitmap.width(), default_bitmap.height());
   retval.eraseColor(0);
 
   SkCanvas canvas(retval);
   SkBitmap border = DrawGtkButtonBorder(
       gtk_state,
-      false,
-      false,
       default_bitmap.width(),
       default_bitmap.height());
   canvas.drawBitmap(border, 0, 0);
 
   return retval;
 }
 
 void Gtk2UI::GetNormalButtonTintHSL(color_utils::HSL* tint) const {
   GtkStyle* window_style = gtk_rc_get_style(fake_window_);
   const GdkColor accent_gdk_color = window_style->bg[GTK_STATE_SELECTED];
@@ skipping 19 matching lines @@
 void Gtk2UI::GetSelectedEntryForegroundHSL(color_utils::HSL* tint) const {
   // The simplest of all the tints. We just use the selected text in the entry
   // since the icons tinted this way will only be displayed against
   // base[GTK_STATE_SELECTED].
   GtkStyle* style = gtk_rc_get_style(fake_entry_.get());
   const GdkColor color = style->text[GTK_STATE_SELECTED];
   color_utils::SkColorToHSL(GdkColorToSkColor(color), tint);
 }
 
 SkBitmap Gtk2UI::DrawGtkButtonBorder(int gtk_state,
-                                     bool focused,
-                                     bool call_to_action,
                                      int width,
                                      int height) const {
+  SkBitmap border;
+  border.allocN32Pixels(width, height);
+  border.eraseColor(0);
+
   // Create a temporary GTK button to snapshot
   GtkWidget* window = gtk_offscreen_window_new();
-  GtkWidget* button = gtk_button_new();
+  GtkWidget* button = gtk_toggle_button_new();
+
+  if (gtk_state & GTK_STATE_FLAG_ACTIVE)
+    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), true);
+
   gtk_widget_set_size_request(button, width, height);
   gtk_container_add(GTK_CONTAINER(window), button);
   gtk_widget_realize(window);
   gtk_widget_realize(button);
   gtk_widget_show(button);
   gtk_widget_show(window);
 
-  if (call_to_action)
-    GTK_WIDGET_SET_FLAGS(button, GTK_HAS_DEFAULT);
+  gtk_widget_set_state_flags(button, (GtkStateFlags)gtk_state, FALSE);
 
-  if (focused) {
-    // We can't just use gtk_widget_grab_focus() here because that sets
-    // gtk_widget_is_focus(), but not gtk_widget_has_focus(), which is what the
-    // GtkButton's paint checks.
-    GTK_WIDGET_SET_FLAGS(button, GTK_HAS_FOCUS);
-  }
+  cairo_surface_t* surface = cairo_image_surface_create_for_data(
+    static_cast<unsigned char*>(border.getAddr(0, 0)),
+    CAIRO_FORMAT_ARGB32,
+    width, height,
+    width * 4);
+  cairo_t* cr = cairo_create(surface);
 
-  gtk_widget_set_state(button, static_cast<GtkStateType>(gtk_state));
+  gtk_widget_draw(button, cr);
 
-  GdkPixmap* pixmap;
-  {
-    // http://crbug.com/346740
-    ANNOTATE_SCOPED_MEMORY_LEAK;
-    pixmap = gtk_widget_get_snapshot(button, NULL);
-  }
-  int w, h;
-  gdk_drawable_get_size(GDK_DRAWABLE(pixmap), &w, &h);
-  DCHECK_EQ(w, width);
-  DCHECK_EQ(h, height);
-
-  // We render the Pixmap to a Pixbuf. This can be slow, as we're scrapping
-  // bits from X.
-  GdkColormap* colormap = gdk_drawable_get_colormap(pixmap);
-  GdkPixbuf* pixbuf = gdk_pixbuf_get_from_drawable(NULL,
-                                                   GDK_DRAWABLE(pixmap),
-                                                   colormap,
-                                                   0, 0, 0, 0, w, h);
-
-  // Finally, we convert our pixbuf into a type we can use.
-  SkBitmap border = GdkPixbufToImageSkia(pixbuf);
-  g_object_unref(pixbuf);
-  g_object_unref(pixmap);
+  cairo_destroy(cr);
+  cairo_surface_destroy(surface);
   gtk_widget_destroy(window);
 
   return border;
 }
 
 void Gtk2UI::ClearAllThemeData() {
   gtk_images_.clear();
 }
 
 void Gtk2UI::UpdateDefaultFont(const PangoFontDescription* desc) {
@@ skipping 48 matching lines @@
   float scale = GetFontDPI() / GetBaseDPI();
   // Round to 1 decimal, e.g. to 1.4.
   return roundf(scale * 10) / 10;
 }
 
 }  // namespace libgtk2ui
 
 views::LinuxUI* BuildGtk2UI() {
   return new libgtk2ui::Gtk2UI;
 }