shell/eggfindbar.c

   1 /* Copyright (C) 2004 Red Hat, Inc.
   2
   3 This library is free software; you can redistribute it and/or
   4 modify it under the terms of the GNU Library General Public License as
   5 published by the Free Software Foundation; either version 2 of the
   6 License, or (at your option) any later version.
   7
   8 This library is distributed in the hope that it will be useful,
   9 but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 Library General Public License for more details.
  12
  13 You should have received a copy of the GNU Library General Public
  14 License along with the Gnome Library; see the file COPYING.LIB.  If not,
  15 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  16 Boston, MA 02111-1307, USA.
  17 */
  18
  19 #include <config.h>
  20
  21 #include "eggfindbar.h"
  22
  23 #include <glib/gi18n.h>
  24 #include <gtk/gtkhbox.h>
  25 #include <gtk/gtkentry.h>
  26 #include <gtk/gtkcheckbutton.h>
  27 #include <gtk/gtkvseparator.h>
  28 #include <gtk/gtkstock.h>
  29 #include <gtk/gtklabel.h>
  30 #include <gdk/gdkkeysyms.h>
  31 #include <gtk/gtkbindings.h>
  32
  33 #include <string.h>
  34
  35 struct _EggFindBarPrivate
  36 {
  37   gchar *search_string;
  38   GtkWidget *hbox;
  39   GtkWidget *find_entry;
  40   GtkWidget *next_button;
  41   GtkWidget *previous_button;
  42   GtkWidget *case_button;
  43   GtkWidget *status_separator;
  44   GtkWidget *status_label;
  45   gulong set_focus_handler;
  46   guint case_sensitive : 1;
  47 };
  48
  49 #define EGG_FIND_BAR_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), EGG_TYPE_FIND_BAR, EggFindBarPrivate))
  50
  51
  52 enum
  53   {
  54     PROP_0,
  55     PROP_SEARCH_STRING,
  56     PROP_CASE_SENSITIVE
  57   };
  58
  59 static void egg_find_bar_finalize      (GObject        *object);
  60 static void egg_find_bar_get_property  (GObject        *object,
  61                                         guint           prop_id,
  62                                         GValue         *value,
  63                                         GParamSpec     *pspec);
  64 static void egg_find_bar_set_property  (GObject        *object,
  65                                         guint           prop_id,
  66                                         const GValue   *value,
  67                                         GParamSpec     *pspec);
  68 static void egg_find_bar_size_request  (GtkWidget      *widget,
  69                                         GtkRequisition *requisition);
  70 static void egg_find_bar_size_allocate (GtkWidget      *widget,
  71                                         GtkAllocation  *allocation);
  72 static void egg_find_bar_show          (GtkWidget *widget);
  73 static void egg_find_bar_hide          (GtkWidget *widget);
  74 static void egg_find_bar_grab_focus    (GtkWidget *widget);
  75
  76 G_DEFINE_TYPE (EggFindBar, egg_find_bar, GTK_TYPE_BIN);
  77
  78 enum
  79   {
  80     NEXT,
  81     PREVIOUS,
  82     CLOSE,
  83     LAST_SIGNAL
  84   };
  85
  86 static guint find_bar_signals[LAST_SIGNAL] = { 0 };
  87
  88 static void
  89 egg_find_bar_class_init (EggFindBarClass *klass)
  90 {
  91   GObjectClass *object_class;
  92   GtkWidgetClass *widget_class;
  93   GtkBinClass *bin_class;
  94   GtkBindingSet *binding_set;
  95
  96   egg_find_bar_parent_class = g_type_class_peek_parent (klass);
  97
  98   object_class = (GObjectClass *)klass;
  99   widget_class = (GtkWidgetClass *)klass;
 100   bin_class = (GtkBinClass *)klass;
 101
 102   object_class->set_property = egg_find_bar_set_property;
 103   object_class->get_property = egg_find_bar_get_property;
 104
 105   object_class->finalize = egg_find_bar_finalize;
 106
 107   widget_class->size_request = egg_find_bar_size_request;
 108   widget_class->size_allocate = egg_find_bar_size_allocate;
 109   widget_class->show = egg_find_bar_show;
 110   widget_class->hide = egg_find_bar_hide;
 111   widget_class->grab_focus = egg_find_bar_grab_focus;
 112
 113   find_bar_signals[NEXT] =
 114     g_signal_new ("next",
 115                   G_OBJECT_CLASS_TYPE (object_class),
 116                   G_SIGNAL_RUN_FIRST,
 117                   G_STRUCT_OFFSET (EggFindBarClass, next),
 118                   NULL, NULL,
 119                   g_cclosure_marshal_VOID__VOID,
 120                   G_TYPE_NONE, 0);
 121   find_bar_signals[PREVIOUS] =
 122     g_signal_new ("previous",
 123                   G_OBJECT_CLASS_TYPE (object_class),
 124                   G_SIGNAL_RUN_FIRST,
 125                   G_STRUCT_OFFSET (EggFindBarClass, previous),
 126                   NULL, NULL,
 127                   g_cclosure_marshal_VOID__VOID,
 128                   G_TYPE_NONE, 0);
 129   find_bar_signals[CLOSE] =
 130     g_signal_new ("close",
 131                   G_OBJECT_CLASS_TYPE (object_class),
 132                   G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 133                   G_STRUCT_OFFSET (EggFindBarClass, close),
 134                   NULL, NULL,
 135                   g_cclosure_marshal_VOID__VOID,
 136                   G_TYPE_NONE, 0);
 137
 138   /**
 139    * EggFindBar:search_string:
 140    *
 141    * The current string to search for. NULL or empty string
 142    * both mean no current string.
 143    *
 144    */
 145   g_object_class_install_property (object_class,
 146                                    PROP_SEARCH_STRING,
 147                                    g_param_spec_string ("search_string",
 148                                                         _("Search string"),
 149                                                         _("The name of the string to be found"),
 150                                                         NULL,
 151                                                         G_PARAM_READWRITE));
 152
 153   /**
 154    * EggFindBar:case_sensitive:
 155    *
 156    * TRUE for a case sensitive search.
 157    *
 158    */
 159   g_object_class_install_property (object_class,
 160                                    PROP_CASE_SENSITIVE,
 161                                    g_param_spec_boolean ("case_sensitive",
 162                                                          _("Case sensitive"),
 163                                                          _("TRUE for a case sensitive search"),
 164                                                          FALSE,
 165                                                          G_PARAM_READWRITE));
 166
 167   /* Style properties */
 168   gtk_widget_class_install_style_property (widget_class,
 169                                            g_param_spec_boxed ("all_matches_color",
 170                                                                _("Highlight color"),
 171                                                                _("Color of highlight for all matches"),
 172                                                                GDK_TYPE_COLOR,
 173                                                                G_PARAM_READABLE));
 174
 175   gtk_widget_class_install_style_property (widget_class,
 176                                            g_param_spec_boxed ("current_match_color",
 177                                                                _("Current color"),
 178                                                                _("Color of highlight for the current match"),
 179                                                                GDK_TYPE_COLOR,
 180                                                                G_PARAM_READABLE));
 181
 182   g_type_class_add_private (object_class, sizeof (EggFindBarPrivate));
 183
 184   binding_set = gtk_binding_set_by_class (klass);
 185
 186   gtk_binding_entry_add_signal (binding_set, GDK_Escape, 0,
 187                                 "close", 0);
 188 }
 189
 190 static void
 191 egg_find_bar_emit_next (EggFindBar *find_bar)
 192 {
 193   g_signal_emit (find_bar, find_bar_signals[NEXT], 0);
 194 }
 195
 196 static void
 197 egg_find_bar_emit_previous (EggFindBar *find_bar)
 198 {
 199   g_signal_emit (find_bar, find_bar_signals[PREVIOUS], 0);
 200 }
 201
 202 static void
 203 next_clicked_callback (GtkButton *button,
 204                        void      *data)
 205 {
 206   EggFindBar *find_bar = EGG_FIND_BAR (data);
 207
 208   egg_find_bar_emit_next (find_bar);
 209 }
 210
 211 static void
 212 previous_clicked_callback (GtkButton *button,
 213                            void      *data)
 214 {
 215   EggFindBar *find_bar = EGG_FIND_BAR (data);
 216
 217   egg_find_bar_emit_previous (find_bar);
 218 }
 219
 220 static void
 221 case_sensitive_toggled_callback (GtkCheckButton *button,
 222                                  void           *data)
 223 {
 224   EggFindBar *find_bar = EGG_FIND_BAR (data);
 225
 226   egg_find_bar_set_case_sensitive (find_bar,
 227                                    gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)));
 228 }
 229
 230 static void
 231 entry_activate_callback (GtkEntry *entry,
 232                           void     *data)
 233 {
 234   EggFindBar *find_bar = EGG_FIND_BAR (data);
 235   EggFindBarPrivate *priv = (EggFindBarPrivate *)find_bar->priv;
 236
 237   /* We activate the "next" button here so we'll get a nice
 238      animation */
 239   gtk_widget_activate (priv->next_button);
 240 }
 241
 242 static void
 243 entry_changed_callback (GtkEntry *entry,
 244                         void     *data)
 245 {
 246   EggFindBar *find_bar = EGG_FIND_BAR (data);
 247   char *text;
 248
 249   /* paranoid strdup because set_search_string() sets
 250    * the entry text
 251    */
 252   text = g_strdup (gtk_entry_get_text (entry));
 253
 254   egg_find_bar_set_search_string (find_bar, text);
 255
 256   g_free (text);
 257 }
 258
 259 static void
 260 set_focus_cb (GtkWidget *window,
 261               GtkWidget *widget,
 262               EggFindBar *bar)
 263 {
 264   GtkWidget *wbar = GTK_WIDGET (bar);
 265
 266   while (widget != NULL && widget != wbar)
 267     {
 268       widget = widget->parent;
 269     }
 270
 271   /* if widget == bar, the new focus widget is in the bar, so we
 272    * don't deactivate.
 273    */
 274   if (widget != wbar)
 275     {
 276       g_signal_emit (bar, find_bar_signals[CLOSE], 0);
 277     }
 278 }
 279
 280 static void
 281 egg_find_bar_init (EggFindBar *find_bar)
 282 {
 283   EggFindBarPrivate *priv;
 284   GtkWidget *label;
 285   GtkWidget *separator;
 286   GtkWidget *image_back;
 287   GtkWidget *image_forward;
 288
 289   /* Data */
 290   priv = EGG_FIND_BAR_GET_PRIVATE (find_bar);
 291   find_bar->priv = priv;
 292
 293   priv->search_string = NULL;
 294
 295   /* Widgets */
 296   gtk_widget_push_composite_child ();
 297   priv->hbox = gtk_hbox_new (FALSE, 6);
 298   gtk_container_set_border_width (GTK_CONTAINER (priv->hbox), 3);
 299
 300   label = gtk_label_new_with_mnemonic (_("F_ind:"));
 301   separator = gtk_vseparator_new ();
 302
 303   priv->find_entry = gtk_entry_new ();
 304   gtk_label_set_mnemonic_widget (GTK_LABEL (label), priv->find_entry);
 305
 306   priv->previous_button = gtk_button_new_with_mnemonic (_("_Previous"));
 307   gtk_button_set_focus_on_click (GTK_BUTTON (priv->previous_button), FALSE);
 308   priv->next_button = gtk_button_new_with_mnemonic (_("_Next"));
 309   gtk_button_set_focus_on_click (GTK_BUTTON (priv->next_button), FALSE);
 310
 311   image_back = gtk_image_new_from_stock (GTK_STOCK_GO_BACK,
 312                                          GTK_ICON_SIZE_BUTTON);
 313   image_forward = gtk_image_new_from_stock (GTK_STOCK_GO_FORWARD,
 314                                             GTK_ICON_SIZE_BUTTON);
 315
 316   gtk_button_set_image (GTK_BUTTON (priv->previous_button),
 317                         image_back);
 318   gtk_button_set_image (GTK_BUTTON (priv->next_button),
 319                         image_forward);
 320
 321   priv->case_button = gtk_check_button_new_with_mnemonic (_("C_ase Sensitive"));
 322
 323   priv->status_separator = gtk_vseparator_new ();
 324
 325   priv->status_label = gtk_label_new (NULL);
 326   gtk_label_set_ellipsize (GTK_LABEL (priv->status_label),
 327                            PANGO_ELLIPSIZE_END);
 328   gtk_misc_set_alignment (GTK_MISC (priv->status_label), 0.0, 0.5);
 329
 330 #if 0
 331  {
 332    GtkWidget *button_label;
 333    /* This hack doesn't work because GtkCheckButton doesn't pass the
 334     * larger size allocation to the label, it always gives the label
 335     * its exact request. If you un-ifdef this, set the box back
 336     * on case_button to TRUE, TRUE below
 337     */
 338    button_label = gtk_bin_get_child (GTK_BIN (priv->case_button));
 339    gtk_label_set_ellipsize (GTK_LABEL (button_label),
 340                             PANGO_ELLIPSIZE_END);
 341  }
 342 #endif
 343
 344   gtk_box_pack_start (GTK_BOX (priv->hbox),
 345                       label, FALSE, FALSE, 0);
 346   gtk_box_pack_start (GTK_BOX (priv->hbox),
 347                       priv->find_entry, FALSE, FALSE, 0);
 348   gtk_box_pack_start (GTK_BOX (priv->hbox),
 349                       priv->previous_button, FALSE, FALSE, 0);
 350   gtk_box_pack_start (GTK_BOX (priv->hbox),
 351                       priv->next_button, FALSE, FALSE, 0);
 352   gtk_box_pack_start (GTK_BOX (priv->hbox),
 353                       separator, FALSE, FALSE, 0);
 354   gtk_box_pack_start (GTK_BOX (priv->hbox),
 355                       priv->case_button, FALSE, FALSE, 0);
 356   gtk_box_pack_start (GTK_BOX (priv->hbox),
 357                       priv->status_separator, FALSE, FALSE, 0);
 358   gtk_box_pack_start (GTK_BOX (priv->hbox),
 359                       priv->status_label, TRUE, TRUE, 0);
 360
 361   gtk_container_add (GTK_CONTAINER (find_bar), priv->hbox);
 362
 363   gtk_widget_show (priv->hbox);
 364   gtk_widget_show (priv->find_entry);
 365   gtk_widget_show (priv->previous_button);
 366   gtk_widget_show (priv->next_button);
 367   gtk_widget_show (separator);
 368   gtk_widget_show (label);
 369   gtk_widget_show (image_back);
 370   gtk_widget_show (image_forward);
 371   /* don't show status separator/label until they are set */
 372
 373   gtk_widget_pop_composite_child ();
 374
 375   g_signal_connect (priv->find_entry, "changed",
 376                     G_CALLBACK (entry_changed_callback),
 377                     find_bar);
 378   g_signal_connect (priv->find_entry, "activate",
 379                     G_CALLBACK (entry_activate_callback),
 380                     find_bar);
 381   g_signal_connect (priv->next_button, "clicked",
 382                     G_CALLBACK (next_clicked_callback),
 383                     find_bar);
 384   g_signal_connect (priv->previous_button, "clicked",
 385                     G_CALLBACK (previous_clicked_callback),
 386                     find_bar);
 387   g_signal_connect (priv->case_button, "toggled",
 388                     G_CALLBACK (case_sensitive_toggled_callback),
 389                     find_bar);
 390 }
 391
 392 static void
 393 egg_find_bar_finalize (GObject *object)
 394 {
 395   EggFindBar *find_bar = EGG_FIND_BAR (object);
 396   EggFindBarPrivate *priv = (EggFindBarPrivate *)find_bar->priv;
 397
 398   g_free (priv->search_string);
 399
 400   G_OBJECT_CLASS (egg_find_bar_parent_class)->finalize (object);
 401 }
 402
 403 static void
 404 egg_find_bar_set_property (GObject      *object,
 405                            guint         prop_id,
 406                            const GValue *value,
 407                            GParamSpec   *pspec)
 408 {
 409   EggFindBar *find_bar = EGG_FIND_BAR (object);
 410
 411   switch (prop_id)
 412     {
 413     case PROP_SEARCH_STRING:
 414       egg_find_bar_set_search_string (find_bar, g_value_get_string (value));
 415       break;
 416     case PROP_CASE_SENSITIVE:
 417       egg_find_bar_set_case_sensitive (find_bar, g_value_get_boolean (value));
 418       break;
 419     default:
 420       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 421       break;
 422     }
 423 }
 424
 425 static void
 426 egg_find_bar_get_property (GObject    *object,
 427                            guint       prop_id,
 428                            GValue     *value,
 429                            GParamSpec *pspec)
 430 {
 431   EggFindBar *find_bar = EGG_FIND_BAR (object);
 432   EggFindBarPrivate *priv = (EggFindBarPrivate *)find_bar->priv;
 433
 434   switch (prop_id)
 435     {
 436     case PROP_SEARCH_STRING:
 437       g_value_set_string (value, priv->search_string);
 438       break;
 439     case PROP_CASE_SENSITIVE:
 440       g_value_set_boolean (value, priv->case_sensitive);
 441       break;
 442     default:
 443       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 444       break;
 445     }
 446 }
 447
 448 static void
 449 egg_find_bar_size_request (GtkWidget      *widget,
 450                            GtkRequisition *requisition)
 451 {
 452   GtkBin *bin = GTK_BIN (widget);
 453   GtkRequisition child_requisition;
 454   if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
 455     {
 456       gtk_widget_size_request (bin->child, &child_requisition);
 457
 458       *requisition = child_requisition;
 459     }
 460   else
 461     {
 462       requisition->width = 0;
 463       requisition->height = 0;
 464     }
 465 }
 466
 467 static void
 468 egg_find_bar_size_allocate (GtkWidget     *widget,
 469                             GtkAllocation *allocation)
 470 {
 471   GtkBin *bin = GTK_BIN (widget);
 472
 473   widget->allocation = *allocation;
 474
 475   if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
 476     gtk_widget_size_allocate (bin->child, allocation);
 477 }
 478
 479 static void
 480 egg_find_bar_show (GtkWidget *widget)
 481 {
 482   EggFindBar *bar = EGG_FIND_BAR (widget);
 483   EggFindBarPrivate *priv = bar->priv;
 484
 485   GTK_WIDGET_CLASS (egg_find_bar_parent_class)->show (widget);
 486
 487   if (priv->set_focus_handler == 0)
 488     {
 489       GtkWidget *toplevel;
 490
 491       toplevel = gtk_widget_get_toplevel (widget);
 492
 493       priv->set_focus_handler =
 494         g_signal_connect (toplevel, "set-focus",
 495                           G_CALLBACK (set_focus_cb), bar);
 496     }
 497 }
 498
 499 static void
 500 egg_find_bar_hide (GtkWidget *widget)
 501 {
 502   EggFindBar *bar = EGG_FIND_BAR (widget);
 503   EggFindBarPrivate *priv = bar->priv;
 504
 505   if (priv->set_focus_handler != 0)
 506     {
 507       GtkWidget *toplevel;
 508
 509       toplevel = gtk_widget_get_toplevel (widget);
 510
 511       g_signal_handlers_disconnect_by_func
 512         (toplevel, (void (*)) G_CALLBACK (set_focus_cb), bar);
 513       priv->set_focus_handler = 0;
 514     }
 515
 516   GTK_WIDGET_CLASS (egg_find_bar_parent_class)->hide (widget);
 517 }
 518
 519 static void
 520 egg_find_bar_grab_focus (GtkWidget *widget)
 521 {
 522   EggFindBar *find_bar = EGG_FIND_BAR (widget);
 523   EggFindBarPrivate *priv = find_bar->priv;
 524
 525   gtk_widget_grab_focus (priv->find_entry);
 526 }
 527
 528 /**
 529  * egg_find_bar_new:
 530  *
 531  * Creates a new #EggFindBar.
 532  *
 533  * Returns: a newly created #EggFindBar
 534  *
 535  * Since: 2.6
 536  */
 537 GtkWidget *
 538 egg_find_bar_new (void)
 539 {
 540   EggFindBar *find_bar;
 541
 542   find_bar = g_object_new (EGG_TYPE_FIND_BAR, NULL);
 543
 544   return GTK_WIDGET (find_bar);
 545 }
 546
 547 /**
 548  * egg_find_bar_set_search_string:
 549  *
 550  * Sets the string that should be found/highlighted in the document.
 551  * Empty string is converted to NULL.
 552  *
 553  * Since: 2.6
 554  */
 555 void
 556 egg_find_bar_set_search_string  (EggFindBar *find_bar,
 557                                  const char *search_string)
 558 {
 559   EggFindBarPrivate *priv;
 560
 561   g_return_if_fail (EGG_IS_FIND_BAR (find_bar));
 562
 563   priv = (EggFindBarPrivate *)find_bar->priv;
 564
 565   g_object_freeze_notify (G_OBJECT (find_bar));
 566
 567   if (priv->search_string != search_string)
 568     {
 569       char *old;
 570
 571       old = priv->search_string;
 572
 573       if (search_string && *search_string == '\0')
 574         search_string = NULL;
 575
 576       /* Only update if the string has changed; setting the entry
 577        * will emit changed on the entry which will re-enter
 578        * this function, but we'll handle that fine with this
 579        * short-circuit.
 580        */
 581       if ((old && search_string == NULL) ||
 582           (old == NULL && search_string) ||
 583           (old && search_string &&
 584            strcmp (old, search_string) != 0))
 585         {
 586           priv->search_string = g_strdup (search_string);
 587           g_free (old);
 588
 589           gtk_entry_set_text (GTK_ENTRY (priv->find_entry),
 590                               priv->search_string ?
 591                               priv->search_string :
 592                               "");
 593
 594           g_object_notify (G_OBJECT (find_bar),
 595                            "search_string");
 596         }
 597     }
 598
 599   g_object_thaw_notify (G_OBJECT (find_bar));
 600 }
 601
 602
 603 /**
 604  * egg_find_bar_get_search_string:
 605  *
 606  * Gets the string that should be found/highlighted in the document.
 607  *
 608  * Returns: the string
 609  *
 610  * Since: 2.6
 611  */
 612 const char*
 613 egg_find_bar_get_search_string  (EggFindBar *find_bar)
 614 {
 615   EggFindBarPrivate *priv;
 616
 617   g_return_val_if_fail (EGG_IS_FIND_BAR (find_bar), NULL);
 618
 619   priv = find_bar->priv;
 620
 621   return priv->search_string ? priv->search_string : "";
 622 }
 623
 624 /**
 625  * egg_find_bar_set_case_sensitive:
 626  *
 627  * Sets whether the search is case sensitive
 628  *
 629  * Since: 2.6
 630  */
 631 void
 632 egg_find_bar_set_case_sensitive (EggFindBar *find_bar,
 633                                  gboolean    case_sensitive)
 634 {
 635   EggFindBarPrivate *priv;
 636
 637   g_return_if_fail (EGG_IS_FIND_BAR (find_bar));
 638
 639   priv = (EggFindBarPrivate *)find_bar->priv;
 640
 641   g_object_freeze_notify (G_OBJECT (find_bar));
 642
 643   case_sensitive = case_sensitive != FALSE;
 644
 645   if (priv->case_sensitive != case_sensitive)
 646     {
 647       priv->case_sensitive = case_sensitive;
 648
 649       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->case_button),
 650                                     priv->case_sensitive);
 651
 652       g_object_notify (G_OBJECT (find_bar),
 653                        "case_sensitive");
 654     }
 655
 656   g_object_thaw_notify (G_OBJECT (find_bar));
 657 }
 658
 659 /**
 660  * egg_find_bar_get_case_sensitive:
 661  *
 662  * Gets whether the search is case sensitive
 663  *
 664  * Returns: TRUE if it's case sensitive
 665  *
 666  * Since: 2.6
 667  */
 668 gboolean
 669 egg_find_bar_get_case_sensitive (EggFindBar *find_bar)
 670 {
 671   EggFindBarPrivate *priv;
 672
 673   g_return_val_if_fail (EGG_IS_FIND_BAR (find_bar), FALSE);
 674
 675   priv = (EggFindBarPrivate *)find_bar->priv;
 676
 677   return priv->case_sensitive;
 678 }
 679
 680 static void
 681 get_style_color (EggFindBar *find_bar,
 682                  const char *style_prop_name,
 683                  GdkColor   *color)
 684 {
 685   GdkColor *style_color;
 686
 687   gtk_widget_ensure_style (GTK_WIDGET (find_bar));
 688   gtk_widget_style_get (GTK_WIDGET (find_bar),
 689                         "color", &style_color, NULL);
 690   if (style_color)
 691     {
 692       *color = *style_color;
 693       gdk_color_free (style_color);
 694     }
 695 }
 696
 697 /**
 698  * egg_find_bar_get_all_matches_color:
 699  *
 700  * Gets the color to use to highlight all the
 701  * known matches.
 702  *
 703  * Since: 2.6
 704  */
 705 void
 706 egg_find_bar_get_all_matches_color (EggFindBar *find_bar,
 707                                     GdkColor   *color)
 708 {
 709   GdkColor found_color = { 0, 0, 0, 0x0f0f };
 710
 711   get_style_color (find_bar, "all_matches_color", &found_color);
 712
 713   *color = found_color;
 714 }
 715
 716 /**
 717  * egg_find_bar_get_current_match_color:
 718  *
 719  * Gets the color to use to highlight the match
 720  * we're currently on.
 721  *
 722  * Since: 2.6
 723  */
 724 void
 725 egg_find_bar_get_current_match_color (EggFindBar *find_bar,
 726                                       GdkColor   *color)
 727 {
 728   GdkColor found_color = { 0, 0, 0, 0xffff };
 729
 730   get_style_color (find_bar, "current_match_color", &found_color);
 731
 732   *color = found_color;
 733 }
 734
 735 /**
 736  * egg_find_bar_set_status_text:
 737  *
 738  * Sets some text to display if there's space; typical text would
 739  * be something like "5 results on this page" or "No results"
 740  *
 741  * @text: the text to display
 742  *
 743  * Since: 2.6
 744  */
 745 void
 746 egg_find_bar_set_status_text (EggFindBar *find_bar,
 747                               const char *text)
 748 {
 749   EggFindBarPrivate *priv;
 750
 751   g_return_if_fail (EGG_IS_FIND_BAR (find_bar));
 752
 753   priv = (EggFindBarPrivate *)find_bar->priv;
 754
 755   if (text == NULL || *text == '\0')
 756     {
 757       gtk_widget_hide (priv->status_label);
 758       gtk_widget_hide (priv->status_separator);
 759       gtk_label_set_text (GTK_LABEL (priv->status_label), NULL);
 760     }
 761   else
 762     {
 763       gtk_label_set_text (GTK_LABEL (priv->status_label), text);
 764       gtk_widget_show (priv->status_label);
 765       gtk_widget_show (priv->status_separator);
 766     }
 767 }