GTK: give the findbox curvy edges....

chrome/browser/gtk/find_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/find_bar_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 
 #include "base/gfx/gtk_util.h"
 #include "base/string_util.h"
 #include "chrome/browser/find_bar_controller.h"
 #include "chrome/browser/gtk/browser_window_gtk.h"
 #include "chrome/browser/gtk/custom_button.h"
+#include "chrome/browser/gtk/nine_box.h"
 #include "chrome/browser/gtk/tab_contents_container_gtk.h"
 #include "chrome/browser/tab_contents/web_contents.h"
 #include "chrome/common/gtk_util.h"
 #include "chrome/common/l10n_util.h"
 #include "grit/generated_resources.h"
 
 namespace {
 
 const GdkColor kBackgroundColor = GDK_COLOR_RGB(0xe6, 0xed, 0xf4);
 const GdkColor kBorderColor = GDK_COLOR_RGB(0xbe, 0xc8, 0xd4);
@@ skipping 11 matching lines @@
 
 gboolean KeyPressEvent(GtkWindow* window, GdkEventKey* event,
                        FindBarGtk* find_bar) {
   if (GDK_Escape == event->keyval) {
     find_bar->EscapePressed();
     return TRUE;
   }
   return FALSE;
 }
 
+// Get the ninebox that draws the background of |container_|. It is also used
+// to change the shape of |container_|. The pointer is shared by all instances
+// of FindBarGtk.
+const NineBox* GetDialogBackground() {
+  static NineBox* dialog_backgroun = NULL;
+  if (!dialog_background) {
+    dialog_background = new NineBox(
+      IDR_FIND_DLG_LEFT_BACKGROUND,
+      IDR_FIND_DLG_MIDDLE_BACKGROUND,
+      IDR_FIND_DLG_RIGHT_BACKGROUND,
+      NULL, NULL, NULL, NULL, NULL, NULL);
+    dialog_background->ChangeWhiteToTransparent();
+  }
+
+  return dialog_background;
 }
 
-FindBarGtk::FindBarGtk(BrowserWindowGtk* browser) {
+// Used to handle custom painting of |container_|.
+gboolean OnExpose(GtkWidget* widget, GdkEventExpose* e, gpointer userdata) {
+  GetDialogBackground()->RenderToWidget(widget);
+  GtkWidget* child = gtk_bin_get_child(GTK_BIN(widget));
+  if (child)
+    gtk_container_propagate_expose(GTK_CONTAINER(widget), child, e);
+  return TRUE;
+}
+
+}  // namespace
+
+FindBarGtk::FindBarGtk(BrowserWindowGtk* browser)
+    : container_shaped_(false) {
   InitWidgets();
 
   // Insert the widget into the browser gtk hierarchy.
   browser->AddFindBar(this);
 
   // Hook up signals after the widget has been added to the hierarchy so the
   // widget will be realized.
   g_signal_connect(find_text_, "changed",
                    G_CALLBACK(EntryContentsChanged), this);
   g_signal_connect(find_text_, "key-press-event",
                    G_CALLBACK(KeyPressEvent), this);
   g_signal_connect(widget(), "size-allocate",
-                   G_CALLBACK(OnSizeAllocate), this);
+                   G_CALLBACK(OnFixedSizeAllocate), this);
+  // We can't call ContourWidget() until after |container| has been
+  // allocated, hence we connect to this signal.
+  g_signal_connect(container_, "size-allocate",
+                   G_CALLBACK(OnContainerSizeAllocate), this);
 }
 
 FindBarGtk::~FindBarGtk() {
   fixed_.Destroy();
 }
 
 void FindBarGtk::InitWidgets() {
   // The find bar is basically an hbox with a gtkentry (text box) followed by 3
   // buttons (previous result, next result, close).  We wrap the hbox in a gtk
   // alignment and a gtk event box to get the padding and light blue
   // background. We put that event box in a fixed in order to control its
   // position.
   GtkWidget* hbox = gtk_hbox_new(false, 0);
   container_ = gfx::CreateGtkBorderBin(hbox, &kBackgroundColor,
       kBarPadding, kBarPadding, kBarPadding, kBarPadding);
-  fixed_.Own(gtk_fixed_new());
+  gtk_widget_set_app_paintable(container_, TRUE);
+  g_signal_connect(container_, "expose-event",
+                   G_CALLBACK(OnExpose), NULL);
 
   // |fixed_| has to be at least one pixel tall. We color this pixel the same
   // color as the border that separates the toolbar from the web contents.
   // TODO(estade): find a better solution. (Ideally the tool bar shouldn't draw
   // its own border, but the border is part of the background bitmap, so
   // changing that would affect all platforms.)
+  fixed_.Own(gtk_fixed_new());
   border_ = gtk_event_box_new();
   gtk_widget_set_size_request(border_, 1, 1);
   gtk_widget_modify_bg(border_, GTK_STATE_NORMAL, &kBorderColor);
 
   gtk_fixed_put(GTK_FIXED(widget()), border_, 0, 0);
   gtk_fixed_put(GTK_FIXED(widget()), container_, 0, kVerticalOffset);
   gtk_widget_set_size_request(widget(), -1, 0);
 
   close_button_.reset(CustomDrawButton::AddBarCloseButton(hbox));
   g_signal_connect(G_OBJECT(close_button_->widget()), "clicked",
@@ skipping 137 matching lines @@
         gtk_entry_get_text(GTK_ENTRY(find_bar->find_text_)));
     find_bar->find_bar_controller_->web_contents()->StartFinding(
         UTF8ToUTF16(find_text_utf8),
         button == find_bar->find_next_button_->widget());
   } else {
     NOTREACHED();
   }
 }
 
 // static
-void FindBarGtk::OnSizeAllocate(GtkWidget* fixed,
-                                GtkAllocation* allocation,
-                                FindBarGtk* findbar) {
+void FindBarGtk::OnFixedSizeAllocate(GtkWidget* fixed,
+                                     GtkAllocation* allocation,
+                                     FindBarGtk* findbar) {
   // Set the background widget to the size of |fixed|.
   if (findbar->border_->allocation.width != allocation->width) {
     // Typically it's not a good idea to use this function outside of container
     // implementations, but GtkFixed doesn't do any sizing on its children so
     // in this case it's safe.
     gtk_widget_size_allocate(findbar->border_, allocation);
   }
 
   // Reposition |container_|.
   GtkWidget* container = findbar->container_;
   DCHECK(container);
   if (!GTK_WIDGET_VISIBLE(container))
     return;
 
   int xposition = findbar->GetDialogPosition(gfx::Rect()).x();
   if (xposition == container->allocation.x) {
     return;
   } else {
     gtk_fixed_move(GTK_FIXED(fixed), container, xposition, kVerticalOffset);
   }
 }
+
+// static
+void FindBarGtk::OnContainerSizeAllocate(GtkWidget* container,
+                                         GtkAllocation* allocation,
+                                         FindBarGtk* findbar) {
+  if (!findbar->container_shaped_) {
+    GetDialogBackground()->ContourWidget(container);
+    findbar->container_shaped_ = true;
+  }
+}