diff options
Diffstat (limited to 'widgets/misc')
| -rw-r--r-- | widgets/misc/Makefile.am | 26 | ||||
| -rw-r--r-- | widgets/misc/e-action-combo-box.c | 479 | ||||
| -rw-r--r-- | widgets/misc/e-action-combo-box.h | 79 | ||||
| -rw-r--r-- | widgets/misc/e-filter-bar.h | 8 | ||||
| -rw-r--r-- | widgets/misc/e-icon-entry.c | 369 | ||||
| -rw-r--r-- | widgets/misc/e-icon-entry.h | 65 | ||||
| -rw-r--r-- | widgets/misc/e-search-bar.c | 2072 | ||||
| -rw-r--r-- | widgets/misc/e-search-bar.h | 213 | ||||
| -rw-r--r-- | widgets/misc/test-preferences-window.c | 2 |
9 files changed, 1666 insertions, 1647 deletions
diff --git a/widgets/misc/Makefile.am b/widgets/misc/Makefile.am index a59e16a811..ee91224f5e 100644 --- a/widgets/misc/Makefile.am +++ b/widgets/misc/Makefile.am @@ -15,8 +15,8 @@ INCLUDES = \ privsolib_LTLIBRARIES = \ - libemiscwidgets.la \ - libefilterbar.la + libemiscwidgets.la +# libefilterbar.la widgetsincludedir = $(privincludedir)/misc @@ -35,6 +35,7 @@ glade_DATA = e-send-options.glade \ widgetsinclude_HEADERS = \ $(pilot_headers) \ e-account-combo-box.h \ + e-action-combo-box.h \ e-activity-handler.h \ e-attachment.h \ e-attachment-bar.h \ @@ -83,6 +84,7 @@ libemiscwidgets_la_SOURCES = \ $(widgetsinclude_HEADERS) \ $(pilot_sources) \ e-account-combo-box.c \ + e-action-combo-box.c \ e-activity-handler.c \ e-calendar.c \ e-attachment.c \ @@ -139,16 +141,16 @@ libemiscwidgets_la_LIBADD = $(top_builddir)/e-util/libeutil.la \ $(EVOLUTON_MAIL_LIBS) \ $(ICONV_LIBS) -libefilterbar_la_SOURCES = \ - e-filter-bar.c \ - e-filter-bar.h - -libefilterbar_la_LDFLAGS = $(NO_UNDEFINED) - -libefilterbar_la_LIBADD = \ - $(WIN32_BOOTSTRAP_LIBS) \ - libemiscwidgets.la \ - $(E_WIDGETS_LIBS) +#libefilterbar_la_SOURCES = \ +# e-filter-bar.c \ +# e-filter-bar.h +# +#libefilterbar_la_LDFLAGS = $(NO_UNDEFINED) +# +#libefilterbar_la_LIBADD = \ +# $(WIN32_BOOTSTRAP_LIBS) \ +# libemiscwidgets.la \ +# $(E_WIDGETS_LIBS) noinst_PROGRAMS = \ test-calendar \ diff --git a/widgets/misc/e-action-combo-box.c b/widgets/misc/e-action-combo-box.c new file mode 100644 index 0000000000..5e32268431 --- /dev/null +++ b/widgets/misc/e-action-combo-box.c @@ -0,0 +1,479 @@ +/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */ +/* e-action-combo-box.c + * + * Copyright (C) 2008 Novell, Inc. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of version 2 of the GNU Lesser General Public + * License as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this program; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#include "e-action-combo-box.h" + +#include <glib/gi18n.h> + +#define E_ACTION_COMBO_BOX_GET_PRIVATE(obj) \ + (G_TYPE_INSTANCE_GET_PRIVATE \ + ((obj), E_ACTION_TYPE_COMBO_BOX, EActionComboBoxPrivate)) + +enum { + COLUMN_ACTION, + COLUMN_SORT +}; + +enum { + PROP_0, + PROP_ACTION +}; + +struct _EActionComboBoxPrivate { + GtkRadioAction *action; + GtkActionGroup *action_group; + GHashTable *index; + guint changed_handler_id; /* action::changed */ + guint group_sensitive_handler_id; /* action-group::sensitive */ + guint group_visible_handler_id; /* action-group::visible */ +}; + +static gpointer parent_class; + +static void +action_combo_box_action_changed_cb (GtkRadioAction *action, + GtkRadioAction *current, + EActionComboBox *combo_box) +{ + GtkTreeRowReference *reference; + GtkTreeModel *model; + GtkTreePath *path; + GtkTreeIter iter; + gboolean valid; + + reference = g_hash_table_lookup ( + combo_box->priv->index, GINT_TO_POINTER ( + gtk_radio_action_get_current_value (current))); + g_return_if_fail (reference != NULL); + + model = gtk_tree_row_reference_get_model (reference); + path = gtk_tree_row_reference_get_path (reference); + valid = gtk_tree_model_get_iter (model, &iter, path); + gtk_tree_path_free (path); + g_return_if_fail (valid); + + gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo_box), &iter); +} + +static void +action_combo_box_action_group_notify_cb (GtkActionGroup *action_group, + GParamSpec *pspec, + EActionComboBox *combo_box) +{ + g_object_set ( + combo_box, "sensitive", + gtk_action_group_get_sensitive (action_group), "visible", + gtk_action_group_get_visible (action_group), NULL); +} + +static void +action_combo_box_render_pixbuf (GtkCellLayout *layout, + GtkCellRenderer *renderer, + GtkTreeModel *model, + GtkTreeIter *iter, + EActionComboBox *combo_box) +{ + GtkRadioAction *action; + gchar *icon_name; + gchar *stock_id; + gboolean sensitive; + gboolean visible; + + gtk_tree_model_get (model, iter, COLUMN_ACTION, &action, -1); + + g_object_get ( + G_OBJECT (action), + "icon-name", &icon_name, + "sensitive", &sensitive, + "stock-id", &stock_id, + "visible", &visible, + NULL); + + g_object_set ( + G_OBJECT (renderer), + "icon-name", icon_name, + "sensitive", sensitive, + "stock-id", stock_id, + "stock-size", GTK_ICON_SIZE_MENU, + "visible", visible, + NULL); + + g_free (icon_name); + g_free (stock_id); +} + +static void +action_combo_box_render_text (GtkCellLayout *layout, + GtkCellRenderer *renderer, + GtkTreeModel *model, + GtkTreeIter *iter, + EActionComboBox *combo_box) +{ + GtkRadioAction *action; + gchar **strv; + gchar *label; + gboolean sensitive; + gboolean visible; + + gtk_tree_model_get (model, iter, COLUMN_ACTION, &action, -1); + + g_object_get ( + G_OBJECT (action), + "label", &label, + "sensitive", &sensitive, + "visible", &visible, + NULL); + + /* Strip out underscores. */ + strv = g_strsplit (label, "_", -1); + g_free (label); + label = g_strjoinv (NULL, strv); + g_strfreev (strv); + + g_object_set ( + G_OBJECT (renderer), + "sensitive", sensitive, + "text", label, + "visible", visible, + NULL); + + g_free (label); +} + +static void +action_combo_box_update_model (EActionComboBox *combo_box) +{ + GtkListStore *list_store; + GSList *list; + + g_hash_table_remove_all (combo_box->priv->index); + + if (combo_box->priv->action == NULL) { + gtk_combo_box_set_model (GTK_COMBO_BOX (combo_box), NULL); + return; + } + + list_store = gtk_list_store_new ( + 2, GTK_TYPE_RADIO_ACTION, G_TYPE_INT); + + list = gtk_radio_action_get_group (combo_box->priv->action); + + while (list != NULL) { + GtkTreeRowReference *reference; + GtkRadioAction *action = list->data; + GtkTreePath *path; + GtkTreeIter iter; + gint value; + + gtk_list_store_append (list_store, &iter); + g_object_get (G_OBJECT (action), "value", &value, NULL); + gtk_list_store_set ( + list_store, &iter, COLUMN_ACTION, + list->data, COLUMN_SORT, value, -1); + + path = gtk_tree_model_get_path ( + GTK_TREE_MODEL (list_store), &iter); + reference = gtk_tree_row_reference_new ( + GTK_TREE_MODEL (list_store), path); + g_hash_table_insert ( + combo_box->priv->index, + GINT_TO_POINTER (value), reference); + gtk_tree_path_free (path); + + list = g_slist_next (list); + } + + gtk_tree_sortable_set_sort_column_id ( + GTK_TREE_SORTABLE (list_store), + COLUMN_SORT, GTK_SORT_ASCENDING); + gtk_combo_box_set_model ( + GTK_COMBO_BOX (combo_box), GTK_TREE_MODEL (list_store)); + + action_combo_box_action_changed_cb ( + combo_box->priv->action, + combo_box->priv->action, + combo_box); +} + +static void +action_combo_box_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + switch (property_id) { + case PROP_ACTION: + e_action_combo_box_set_action ( + E_ACTION_COMBO_BOX (object), + g_value_get_object (value)); + return; + } + + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); +} + +static void +action_combo_box_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + switch (property_id) { + case PROP_ACTION: + g_value_set_object ( + value, e_action_combo_box_get_action ( + E_ACTION_COMBO_BOX (object))); + return; + } + + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); +} + +static void +action_combo_box_dispose (GObject *object) +{ + EActionComboBoxPrivate *priv = E_ACTION_COMBO_BOX_GET_PRIVATE (object); + + if (priv->action != NULL) { + g_object_unref (priv->action); + priv->action = NULL; + } + + if (priv->action_group != NULL) { + g_object_unref (priv->action_group); + priv->action_group = NULL; + } + + g_hash_table_remove_all (priv->index); + + /* Chain up to parent's dispose() method. */ + G_OBJECT_CLASS (parent_class)->dispose (object); +} + +static void +action_combo_box_finalize (GObject *object) +{ + EActionComboBoxPrivate *priv = E_ACTION_COMBO_BOX_GET_PRIVATE (object); + + g_hash_table_destroy (priv->index); + + /* Chain up to parent's finalize() method. */ + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static void +action_combo_box_changed (GtkComboBox *combo_box) +{ + GtkRadioAction *action; + GtkTreeModel *model; + GtkTreeIter iter; + gint value; + + /* This method is virtual, so no need to chain up. */ + + if (!gtk_combo_box_get_active_iter (combo_box, &iter)) + return; + + model = gtk_combo_box_get_model (combo_box); + gtk_tree_model_get (model, &iter, COLUMN_ACTION, &action, -1); + g_object_get (G_OBJECT (action), "value", &value, NULL); + gtk_radio_action_set_current_value (action, value); +} + +static void +action_combo_box_class_init (EActionComboBoxClass *class) +{ + GObjectClass *object_class; + GtkComboBoxClass *combo_box_class; + + parent_class = g_type_class_peek_parent (class); + g_type_class_add_private (class, sizeof (EActionComboBoxPrivate)); + + object_class = G_OBJECT_CLASS (class); + object_class->set_property = action_combo_box_set_property; + object_class->get_property = action_combo_box_get_property; + object_class->dispose = action_combo_box_dispose; + object_class->finalize = action_combo_box_finalize; + + combo_box_class = GTK_COMBO_BOX_CLASS (class); + combo_box_class->changed = action_combo_box_changed; + + g_object_class_install_property ( + object_class, + PROP_ACTION, + g_param_spec_object ( + "action", + _("Action"), + _("A GtkRadioAction"), + GTK_TYPE_RADIO_ACTION, + G_PARAM_READWRITE)); +} + +static void +action_combo_box_init (EActionComboBox *combo_box) +{ + GtkCellRenderer *renderer; + + combo_box->priv = E_ACTION_COMBO_BOX_GET_PRIVATE (combo_box); + + renderer = gtk_cell_renderer_pixbuf_new (); + gtk_cell_layout_pack_start ( + GTK_CELL_LAYOUT (combo_box), renderer, FALSE); + gtk_cell_layout_set_cell_data_func ( + GTK_CELL_LAYOUT (combo_box), renderer, + (GtkCellLayoutDataFunc) action_combo_box_render_pixbuf, + combo_box, NULL); + + renderer = gtk_cell_renderer_text_new (); + gtk_cell_layout_pack_start ( + GTK_CELL_LAYOUT (combo_box), renderer, TRUE); + gtk_cell_layout_set_cell_data_func ( + GTK_CELL_LAYOUT (combo_box), renderer, + (GtkCellLayoutDataFunc) action_combo_box_render_text, + combo_box, NULL); + + combo_box->priv->index = g_hash_table_new_full ( + g_direct_hash, g_direct_equal, + (GDestroyNotify) NULL, + (GDestroyNotify) gtk_tree_row_reference_free); +} + +GType +e_action_combo_box_get_type (void) +{ + static GType type = 0; + + if (G_UNLIKELY (type == 0)) { + static const GTypeInfo type_info = { + sizeof (EActionComboBoxClass), + (GBaseInitFunc) NULL, + (GBaseFinalizeFunc) NULL, + (GClassInitFunc) action_combo_box_class_init, + (GClassFinalizeFunc) NULL, + NULL, /* class_data */ + sizeof (EActionComboBox), + 0, /* n_preallocs */ + (GInstanceInitFunc) action_combo_box_init, + NULL /* value_table */ + }; + + type = g_type_register_static ( + GTK_TYPE_COMBO_BOX, "EActionComboBox", + &type_info, 0); + } + + return type; +} + +GtkWidget * +e_action_combo_box_new (void) +{ + return e_action_combo_box_new_with_action (NULL); +} + +GtkWidget * +e_action_combo_box_new_with_action (GtkRadioAction *action) +{ + return g_object_new (E_ACTION_TYPE_COMBO_BOX, "action", action, NULL); +} + +GtkRadioAction * +e_action_combo_box_get_action (EActionComboBox *combo_box) +{ + g_return_val_if_fail (E_ACTION_IS_COMBO_BOX (combo_box), NULL); + + return combo_box->priv->action; +} + +void +e_action_combo_box_set_action (EActionComboBox *combo_box, + GtkRadioAction *action) +{ + g_return_if_fail (E_ACTION_IS_COMBO_BOX (combo_box)); + + if (action != NULL) + g_return_if_fail (GTK_IS_RADIO_ACTION (action)); + + if (combo_box->priv->action != NULL) { + g_signal_handler_disconnect ( + combo_box->priv->action, + combo_box->priv->changed_handler_id); + g_object_unref (combo_box->priv->action); + } + + if (combo_box->priv->action_group != NULL) { + g_signal_handler_disconnect ( + combo_box->priv->action_group, + combo_box->priv->group_sensitive_handler_id); + g_signal_handler_disconnect ( + combo_box->priv->action_group, + combo_box->priv->group_visible_handler_id); + g_object_unref (combo_box->priv->action_group); + combo_box->priv->action_group = NULL; + } + + if (action != NULL) + g_object_get ( + g_object_ref (action), "action-group", + &combo_box->priv->action_group, NULL); + combo_box->priv->action = action; + action_combo_box_update_model (combo_box); + + if (combo_box->priv->action != NULL) + combo_box->priv->changed_handler_id = g_signal_connect ( + combo_box->priv->action, "changed", + G_CALLBACK (action_combo_box_action_changed_cb), + combo_box); + + if (combo_box->priv->action_group != NULL) { + combo_box->priv->group_sensitive_handler_id = + g_signal_connect ( + combo_box->priv->action_group, + "notify::sensitive", G_CALLBACK ( + action_combo_box_action_group_notify_cb), + combo_box); + combo_box->priv->group_visible_handler_id = + g_signal_connect ( + combo_box->priv->action_group, + "notify::visible", G_CALLBACK ( + action_combo_box_action_group_notify_cb), + combo_box); + } +} + +gint +e_action_combo_box_get_current_value (EActionComboBox *combo_box) +{ + g_return_val_if_fail (E_ACTION_IS_COMBO_BOX (combo_box), 0); + g_return_val_if_fail (combo_box->priv->action != NULL, 0); + + return gtk_radio_action_get_current_value (combo_box->priv->action); +} + +void +e_action_combo_box_set_current_value (EActionComboBox *combo_box, + gint current_value) +{ + g_return_if_fail (E_ACTION_IS_COMBO_BOX (combo_box)); + g_return_if_fail (combo_box->priv->action != NULL); + + gtk_radio_action_set_current_value ( + combo_box->priv->action, current_value); +} diff --git a/widgets/misc/e-action-combo-box.h b/widgets/misc/e-action-combo-box.h new file mode 100644 index 0000000000..452c3fa265 --- /dev/null +++ b/widgets/misc/e-action-combo-box.h @@ -0,0 +1,79 @@ +/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */ +/* e-action-combo-box.h + * + * Copyright (C) 2008 Novell, Inc. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of version 2 of the GNU Lesser General Public + * License as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this program; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef E_ACTION_COMBO_BOX_H +#define E_ACTION_COMBO_BOX_H + +/* This is a GtkComboBox that is driven by a group of GtkRadioActions. + * Just plug in a GtkRadioAction and the widget will handle the rest. + * (Based on GtkhtmlComboBox.) */ + +#include <gtk/gtk.h> + +/* Standard GObject macros */ +#define E_ACTION_TYPE_COMBO_BOX \ + (e_action_combo_box_get_type ()) +#define E_ACTION_COMBO_BOX(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_ACTION_TYPE_COMBO_BOX, EActionComboBox)) +#define E_ACTION_COMBO_BOX_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_ACTION_TYPE_COMBO_BOX, EActionComboBoxClass)) +#define E_ACTION_IS_COMBO_BOX(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_ACTION_TYPE_COMBO_BOX)) +#define E_ACTION_IS_COMBO_BOX_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_ACTION_TYPE_COMBO_BOX)) +#define E_ACTION_COMBO_BOX_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_ACTION_TYPE_COMBO_BOX, EActionComboBoxClass)) + +G_BEGIN_DECLS + +typedef struct _EActionComboBox EActionComboBox; +typedef struct _EActionComboBoxClass EActionComboBoxClass; +typedef struct _EActionComboBoxPrivate EActionComboBoxPrivate; + +struct _EActionComboBox { + GtkComboBox parent; + EActionComboBoxPrivate *priv; +}; + +struct _EActionComboBoxClass { + GtkComboBoxClass parent_class; +}; + +GType e_action_combo_box_get_type (void); +GtkWidget * e_action_combo_box_new (void); +GtkWidget * e_action_combo_box_new_with_action + (GtkRadioAction *action); +GtkRadioAction *e_action_combo_box_get_action (EActionComboBox *combo_box); +void e_action_combo_box_set_action (EActionComboBox *combo_box, + GtkRadioAction *action); +gint e_action_combo_box_get_current_value + (EActionComboBox *combo_box); +void e_action_combo_box_set_current_value + (EActionComboBox *combo_box, + gint current_value); + +G_END_DECLS + +#endif /* E_ACTION_COMBO_BOX_H */ diff --git a/widgets/misc/e-filter-bar.h b/widgets/misc/e-filter-bar.h index dfc033f1fc..5caf803485 100644 --- a/widgets/misc/e-filter-bar.h +++ b/widgets/misc/e-filter-bar.h @@ -101,10 +101,10 @@ enum { #define E_FILTERBAR_SAVE { N_("_Save Search..."), E_FILTERBAR_SAVE_ID, 0 } #define E_FILTERBAR_EDIT { N_("_Edit Saved Searches..."), E_FILTERBAR_EDIT_ID, 0 } #define E_FILTERBAR_ADVANCED { N_("_Advanced Search..."), E_FILTERBAR_ADVANCED_ID, 0 } -#define E_FILTERBAR_ALL_ACCOUNTS { N_("All Accounts"), E_FILTERBAR_ALL_ACCOUNTS_ID, ESB_ITEMTYPE_RADIO } -#define E_FILTERBAR_CURRENT_ACCOUNT { N_("Current Account"), E_FILTERBAR_CURRENT_ACCOUNT_ID, ESB_ITEMTYPE_RADIO } -#define E_FILTERBAR_CURRENT_FOLDER { N_("Current Folder"), E_FILTERBAR_CURRENT_FOLDER_ID, ESB_ITEMTYPE_RADIO } -#define E_FILTERBAR_CURRENT_MESSAGE { N_("Current Message"), E_FILTERBAR_CURRENT_MESSAGE_ID, ESB_ITEMTYPE_RADIO } +#define E_FILTERBAR_ALL_ACCOUNTS { N_("All Accounts"), E_FILTERBAR_ALL_ACCOUNTS_ID } +#define E_FILTERBAR_CURRENT_ACCOUNT { N_("Current Account"), E_FILTERBAR_CURRENT_ACCOUNT_ID } +#define E_FILTERBAR_CURRENT_FOLDER { N_("Current Folder"), E_FILTERBAR_CURRENT_FOLDER_ID } +#define E_FILTERBAR_CURRENT_MESSAGE { N_("Current Message"), E_FILTERBAR_CURRENT_MESSAGE_ID } #define E_FILTERBAR_SEPARATOR { NULL, 0, 0 } #ifdef JUST_FOR_TRANSLATORS diff --git a/widgets/misc/e-icon-entry.c b/widgets/misc/e-icon-entry.c index 7f0dbaaaee..500b27e6db 100644 --- a/widgets/misc/e-icon-entry.c +++ b/widgets/misc/e-icon-entry.c @@ -32,25 +32,65 @@ * */ -#include "config.h" - #include "e-icon-entry.h" -#define E_ICON_ENTRY_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), E_TYPE_ICON_ENTRY, EIconEntryPrivate)) +#define E_ICON_ENTRY_GET_PRIVATE(obj) \ + (G_TYPE_INSTANCE_GET_PRIVATE \ + ((obj), E_TYPE_ICON_ENTRY, EIconEntryPrivate)) -struct _EIconEntryPrivate -{ +struct _EIconEntryPrivate { + GtkWidget *entry; GtkWidget *hbox; }; -static GtkWidgetClass *parent_class = NULL; +static gpointer parent_class; -/* private helper functions */ +static void +icon_entry_proxy_set_cursor (GtkWidget *widget, + GdkEventCrossing *event) +{ + if (event->type == GDK_ENTER_NOTIFY) { + GdkCursor *cursor; + + cursor = gdk_cursor_new (GDK_HAND1); + gdk_window_set_cursor (widget->window, cursor); + gdk_cursor_unref (cursor); + } else + gdk_window_set_cursor (widget->window, NULL); +} +static GtkWidget * +icon_entry_create_proxy (GtkAction *action) +{ + GtkWidget *proxy; + GtkWidget *widget; + + proxy = gtk_event_box_new (); + gtk_event_box_set_visible_window (GTK_EVENT_BOX (proxy), FALSE); + gtk_container_set_border_width (GTK_CONTAINER (proxy), 2); + gtk_action_connect_proxy (action, proxy); + gtk_widget_show (widget); + + widget = gtk_action_create_icon (action, GTK_ICON_SIZE_MENU); + gtk_container_add (GTK_CONTAINER (proxy), widget); + gtk_widget_show (widget); + + g_signal_connect_swapped ( + proxy, "button-press-event", + G_CALLBACK (gtk_action_activate), action); + g_signal_connect_after ( + proxy, "enter-notify-event", + G_CALLBACK (icon_entry_proxy_set_cursor), NULL); + g_signal_connect_after ( + proxy, "leave-notify-event", + G_CALLBACK (icon_entry_proxy_set_cursor), NULL); + + return proxy; +} static gboolean -entry_focus_change_cb (GtkWidget *widget, - GdkEventFocus *event, - GtkWidget *entry) +icon_entry_focus_change_cb (GtkWidget *widget, + GdkEventFocus *event, + GtkWidget *entry) { gtk_widget_queue_draw (entry); @@ -58,37 +98,35 @@ entry_focus_change_cb (GtkWidget *widget, } static void -e_icon_entry_get_borders (GtkWidget *widget, - GtkWidget *entry, - int *xborder, - int *yborder) +icon_entry_get_borders (GtkWidget *widget, + GtkWidget *entry, + gint *xborder, + gint *yborder) { - int focus_width; + gint focus_width; gboolean interior_focus; g_return_if_fail (entry->style != NULL); - gtk_widget_style_get (entry, - "focus-line-width", &focus_width, - "interior-focus", &interior_focus, - NULL); + gtk_widget_style_get ( + entry, "focus-line-width", &focus_width, + "interior-focus", &interior_focus, NULL); *xborder = entry->style->xthickness; *yborder = entry->style->ythickness; - if (!interior_focus) - { + if (!interior_focus) { *xborder += focus_width; *yborder += focus_width; } } static void -e_icon_entry_paint (GtkWidget *widget, +icon_entry_paint (GtkWidget *widget, GdkEventExpose *event) { EIconEntry *entry = E_ICON_ENTRY (widget); - GtkWidget *entry_widget = entry->entry; + GtkWidget *entry_widget = entry->priv->entry; int x = 0, y = 0, width, height, focus_width; gboolean interior_focus; @@ -133,36 +171,29 @@ e_icon_entry_paint (GtkWidget *widget, } } -/* Class implementation */ - static void -e_icon_entry_init (EIconEntry *entry) +icon_entry_dispose (GObject *object) { EIconEntryPrivate *priv; - GtkWidget *widget = (GtkWidget *) entry; - - priv = entry->priv = E_ICON_ENTRY_GET_PRIVATE (entry); - GTK_WIDGET_UNSET_FLAGS (widget, GTK_NO_WINDOW); + priv = E_ICON_ENTRY_GET_PRIVATE (object); - priv->hbox = gtk_hbox_new (FALSE, /* FIXME */ 0); - gtk_container_add (GTK_CONTAINER (entry), priv->hbox); + if (priv->entry != NULL) { + g_object_unref (priv->entry); + priv->entry = NULL; + } - entry->entry = gtk_entry_new (); - gtk_entry_set_has_frame (GTK_ENTRY (entry->entry), FALSE); - gtk_box_pack_start (GTK_BOX (priv->hbox), entry->entry, TRUE, TRUE, /* FIXME */ 0); + if (priv->hbox != NULL) { + g_object_unref (priv->hbox); + priv->hbox = NULL; + } - /* We need to queue a redraw when focus changes, to comply with themes - * (like Clearlooks) which draw focused and unfocused entries differently. - */ - g_signal_connect_after (entry->entry, "focus-in-event", - G_CALLBACK (entry_focus_change_cb), entry); - g_signal_connect_after (entry->entry, "focus-out-event", - G_CALLBACK (entry_focus_change_cb), entry); + /* Chain up to parent's dispose() method. */ + G_OBJECT_CLASS (parent_class)->dispose (object); } static void -e_icon_entry_realize (GtkWidget *widget) +icon_entry_realize (GtkWidget *widget) { GdkWindowAttr attributes; gint attributes_mask; @@ -185,34 +216,41 @@ e_icon_entry_realize (GtkWidget *widget) attributes.wclass = GDK_INPUT_OUTPUT; attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP; - widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), - &attributes, attributes_mask); + widget->window = gdk_window_new ( + gtk_widget_get_parent_window (widget), + &attributes, attributes_mask); + gdk_window_set_user_data (widget->window, widget); widget->style = gtk_style_attach (widget->style, widget->window); - gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL); + gtk_style_set_background ( + widget->style, widget->window, GTK_STATE_NORMAL); } static void -e_icon_entry_size_request (GtkWidget *widget, - GtkRequisition *requisition) +icon_entry_size_request (GtkWidget *widget, + GtkRequisition *requisition) { - EIconEntry *entry = E_ICON_ENTRY (widget); - GtkContainer *container = GTK_CONTAINER (widget); - GtkBin *bin = GTK_BIN (widget); - int xborder, yborder; + EIconEntryPrivate *priv; + GtkContainer *container; + GtkWidget *child; + gint xborder, yborder; - requisition->width = requisition->height = container->border_width * 2; + priv = E_ICON_ENTRY_GET_PRIVATE (widget); + container = GTK_CONTAINER (widget); - gtk_widget_ensure_style (entry->entry); - e_icon_entry_get_borders (widget, entry->entry, &xborder, &yborder); + requisition->width = container->border_width * 2; + requisition->height = container->border_width * 2; - if (GTK_WIDGET_VISIBLE (bin->child)) - { + gtk_widget_ensure_style (priv->entry); + icon_entry_get_borders (widget, priv->entry, &xborder, &yborder); + + child = GTK_BIN (widget)->child; + if (GTK_WIDGET_VISIBLE (child)) { GtkRequisition child_requisition; - gtk_widget_size_request (bin->child, &child_requisition); + gtk_widget_size_request (child, &child_requisition); requisition->width += child_requisition.width; requisition->height += child_requisition.height; } @@ -222,68 +260,112 @@ e_icon_entry_size_request (GtkWidget *widget, } static void -e_icon_entry_size_allocate (GtkWidget *widget, - GtkAllocation *allocation) +icon_entry_size_allocate (GtkWidget *widget, + GtkAllocation *allocation) { - EIconEntry *entry = E_ICON_ENTRY (widget); - GtkContainer *container = GTK_CONTAINER (widget); - GtkBin *bin = GTK_BIN (widget); + EIconEntryPrivate *priv; + GtkContainer *container; GtkAllocation child_allocation; - int xborder, yborder; + gint xborder, yborder; + gint width, height; + + priv = E_ICON_ENTRY_GET_PRIVATE (widget); + container = GTK_CONTAINER (widget); widget->allocation = *allocation; - e_icon_entry_get_borders (widget, entry->entry, &xborder, &yborder); + icon_entry_get_borders (widget, priv->entry, &xborder, &yborder); + + if (GTK_WIDGET_REALIZED (widget)) { + width = allocation->width - container->border_width * 2; + height = allocation->height - container->border_width * 2; - if (GTK_WIDGET_REALIZED (widget)) - { child_allocation.x = container->border_width; child_allocation.y = container->border_width; - child_allocation.width = MAX (allocation->width - container->border_width * 2, 0); - child_allocation.height = MAX (allocation->height - container->border_width * 2, 0); - - gdk_window_move_resize (widget->window, - allocation->x + child_allocation.x, - allocation->y + child_allocation.y, - child_allocation.width, - child_allocation.height); + child_allocation.width = MAX (width, 0); + child_allocation.height = MAX (height, 0); + + gdk_window_move_resize ( + widget->window, + allocation->x + child_allocation.x, + allocation->y + child_allocation.y, + child_allocation.width, + child_allocation.height); } + width = allocation->width - (container->border_width + xborder) * 2; + height = allocation->height - (container->border_width + yborder) * 2; + child_allocation.x = container->border_width + xborder; child_allocation.y = container->border_width + yborder; - child_allocation.width = MAX (allocation->width - (container->border_width + xborder) * 2, 0); - child_allocation.height = MAX (allocation->height - (container->border_width + yborder) * 2, 0); + child_allocation.width = MAX (width, 0); + child_allocation.height = MAX (height, 0); - gtk_widget_size_allocate (bin->child, &child_allocation); + gtk_widget_size_allocate (GTK_BIN (widget)->child, &child_allocation); } static gboolean -e_icon_entry_expose (GtkWidget *widget, - GdkEventExpose *event) +icon_entry_expose (GtkWidget *widget, + GdkEventExpose *event) { - if (GTK_WIDGET_DRAWABLE (widget) && - event->window == widget->window) - { - e_icon_entry_paint (widget, event); - } + if (GTK_WIDGET_DRAWABLE (widget) && event->window == widget->window) + icon_entry_paint (widget, event); - return parent_class->expose_event (widget, event); + /* Chain up to parent's expose() method. */ + return GTK_WIDGET_CLASS (parent_class)->expose_event (widget, event); } static void -e_icon_entry_class_init (EIconEntryClass *klass) +icon_entry_class_init (EIconEntryClass *class) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); - GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + GObjectClass *object_class; + GtkWidgetClass *widget_class; - parent_class = GTK_WIDGET_CLASS (g_type_class_peek_parent (klass)); + parent_class = g_type_class_peek_parent (class); + g_type_class_add_private (class, sizeof (EIconEntryPrivate)); - widget_class->realize = e_icon_entry_realize; - widget_class->size_request = e_icon_entry_size_request; - widget_class->size_allocate = e_icon_entry_size_allocate; - widget_class->expose_event = e_icon_entry_expose; + object_class = G_OBJECT_CLASS (class); + object_class->dispose = icon_entry_dispose; - g_type_class_add_private (object_class, sizeof (EIconEntryPrivate)); + widget_class = GTK_WIDGET_CLASS (class); + widget_class->realize = icon_entry_realize; + widget_class->size_request = icon_entry_size_request; + widget_class->size_allocate = icon_entry_size_allocate; + widget_class->expose_event = icon_entry_expose; +} + +static void +icon_entry_init (EIconEntry *icon_entry) +{ + GtkWidget *widget; + GtkWidget *container; + + icon_entry->priv = E_ICON_ENTRY_GET_PRIVATE (icon_entry); + + GTK_WIDGET_UNSET_FLAGS (icon_entry, GTK_NO_WINDOW); + + widget = gtk_hbox_new (FALSE, 0); + gtk_container_add (GTK_CONTAINER (icon_entry), widget); + icon_entry->priv->hbox = g_object_ref (widget); + gtk_widget_show (widget); + + container = widget; + + widget = gtk_entry_new (); + gtk_entry_set_has_frame (GTK_ENTRY (widget), FALSE); + gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0); + icon_entry->priv->entry = g_object_ref (widget); + gtk_widget_show (widget); + + /* We need to queue a redraw when focus changes, to comply with + * themes (like Clearlooks) which draw focused and unfocused + * entries differently. */ + g_signal_connect_after ( + widget, "focus-in-event", + G_CALLBACK (icon_entry_focus_change_cb), icon_entry); + g_signal_connect_after ( + widget, "focus-out-event", + G_CALLBACK (icon_entry_focus_change_cb), icon_entry); } GType @@ -293,92 +375,67 @@ e_icon_entry_get_type (void) if (G_UNLIKELY (type == 0)) { - static const GTypeInfo our_info = - { + static const GTypeInfo type_info = { sizeof (EIconEntryClass), - NULL, - NULL, - (GClassInitFunc) e_icon_entry_class_init, - NULL, - NULL, + (GBaseInitFunc) NULL, + (GBaseFinalizeFunc) NULL, + (GClassInitFunc) icon_entry_class_init, + (GClassFinalizeFunc) NULL, + NULL, /* class_data */ sizeof (EIconEntry), - 0, - (GInstanceInitFunc) e_icon_entry_init + 0, /* n_preallocs */ + (GInstanceInitFunc) icon_entry_init, + NULL /* value_table */ }; - type = g_type_register_static (GTK_TYPE_BIN, - "EIconEntry", - &our_info, 0); + type = g_type_register_static ( + GTK_TYPE_BIN, "EIconEntry", &type_info, 0); } return type; } -/* public functions */ - GtkWidget * e_icon_entry_new (void) { return GTK_WIDGET (g_object_new (E_TYPE_ICON_ENTRY, NULL)); } -void -e_icon_entry_pack_widget (EIconEntry *entry, - GtkWidget *widget, - gboolean start) +GtkWidget * +e_icon_entry_get_entry (EIconEntry *icon_entry) { - EIconEntryPrivate *priv; - - g_return_if_fail (E_IS_ICON_ENTRY (entry)); - - priv = entry->priv; + g_return_val_if_fail (E_IS_ICON_ENTRY (icon_entry), NULL); - if (start) - { - gtk_box_pack_start (GTK_BOX (priv->hbox), widget, FALSE, FALSE, /* FIXME */ 2); - gtk_box_reorder_child (GTK_BOX (priv->hbox), widget, 0); - } - else - { - gtk_box_pack_end (GTK_BOX (priv->hbox), widget, FALSE, FALSE, /* FIXME */ 2); - } + return icon_entry->priv->entry; } -static void -set_cursor (GtkWidget *widget, GdkEventCrossing *event, gpointer dummy) +void +e_icon_entry_add_action_start (EIconEntry *icon_entry, + GtkAction *action) { + GtkWidget *proxy; + GtkBox *box; - if (event->type == GDK_ENTER_NOTIFY) - gdk_window_set_cursor (widget->window, gdk_cursor_new (GDK_HAND1)); - else - gdk_window_set_cursor (widget->window, gdk_cursor_new (GDK_LEFT_PTR)); - + g_return_if_fail (E_IS_ICON_ENTRY (icon_entry)); + g_return_if_fail (GTK_IS_ACTION (action)); + box = GTK_BOX (icon_entry->priv->hbox); + proxy = icon_entry_create_proxy (action); + gtk_box_pack_start (box, proxy, FALSE, FALSE, 2); + gtk_box_reorder_child (box, proxy, 0); } -GtkWidget * -e_icon_entry_create_button (const char *stock) +void +e_icon_entry_add_action_end (EIconEntry *icon_entry, + GtkAction *action) { - GtkWidget *eventbox; - GtkWidget *image; - - eventbox = gtk_event_box_new (); - gtk_container_set_border_width (GTK_CONTAINER (eventbox), 2); - gtk_event_box_set_visible_window (GTK_EVENT_BOX (eventbox), FALSE); + GtkWidget *proxy; + GtkBox *box; - image = gtk_image_new_from_stock (stock, GTK_ICON_SIZE_MENU); - gtk_container_add (GTK_CONTAINER (eventbox), image); - - g_signal_connect_after (eventbox, "enter-notify-event", (GCallback) set_cursor, NULL); - g_signal_connect_after (eventbox, "leave-notify-event", (GCallback) set_cursor, NULL); - - return eventbox; -} - -GtkWidget * -e_icon_entry_get_entry (EIconEntry *entry) -{ - g_return_val_if_fail (E_IS_ICON_ENTRY (entry), NULL); + g_return_if_fail (E_IS_ICON_ENTRY (icon_entry)); + g_return_if_fail (GTK_IS_ACTION (action)); - return entry->entry; + box = GTK_BOX (icon_entry->priv->hbox); + proxy = icon_entry_create_proxy (action); + gtk_box_pack_end (box, proxy, FALSE, FALSE, 2); } diff --git a/widgets/misc/e-icon-entry.h b/widgets/misc/e-icon-entry.h index 894cb16c4f..110720ab19 100644 --- a/widgets/misc/e-icon-entry.h +++ b/widgets/misc/e-icon-entry.h @@ -41,44 +41,47 @@ G_BEGIN_DECLS -#define E_TYPE_ICON_ENTRY (e_icon_entry_get_type()) -#define E_ICON_ENTRY(object) (G_TYPE_CHECK_INSTANCE_CAST((object), E_TYPE_ICON_ENTRY, EIconEntry)) -#define E_ICON_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), E_TYPE_ICON_ENTRY, EIconEntryClass)) -#define E_IS_ICON_ENTRY(object) (G_TYPE_CHECK_INSTANCE_TYPE((object), E_TYPE_ICON_ENTRY)) -#define E_IS_ICON_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), E_TYPE_ICON_ENTRY)) -#define E_ICON_ENTRY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), E_TYPE_ICON_ENTRY, EIconEntryClass)) - +/* Standard GObject macros */ +#define E_TYPE_ICON_ENTRY \ + (e_icon_entry_get_type()) +#define E_ICON_ENTRY(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_ICON_ENTRY, EIconEntry)) +#define E_ICON_ENTRY_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_ICON_ENTRY, EIconEntryClass)) +#define E_IS_ICON_ENTRY(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_ICON_ENTRY)) +#define E_IS_ICON_ENTRY_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_ICON_ENTRY)) +#define E_ICON_ENTRY_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_ICON_ENTRY, EIconEntryClass)) + +typedef struct _EIconEntry EIconEntry; typedef struct _EIconEntryClass EIconEntryClass; -typedef struct _EIconEntry EIconEntry; -typedef struct _EIconEntryPrivate EIconEntryPrivate; - -struct _EIconEntryClass -{ - GtkBinClass parent_class; -}; - +typedef struct _EIconEntryPrivate EIconEntryPrivate; + struct _EIconEntry { - GtkBin parent_object; - - /*< public >*/ - GtkWidget *entry; - - /*< private >*/ + GtkBin parent; EIconEntryPrivate *priv; }; -GType e_icon_entry_get_type (void); - -GtkWidget *e_icon_entry_new (void); - -void e_icon_entry_pack_widget (EIconEntry *entry, - GtkWidget *widget, - gboolean start); - -GtkWidget *e_icon_entry_get_entry (EIconEntry *entry); +struct _EIconEntryClass +{ + GtkBinClass parent_class; +}; -GtkWidget *e_icon_entry_create_button (const char *stock); +GType e_icon_entry_get_type (void); +GtkWidget * e_icon_entry_new (void); +GtkWidget * e_icon_entry_get_entry (EIconEntry *entry); +void e_icon_entry_add_action_start (EIconEntry *entry, + GtkAction *action); +void e_icon_entry_add_action_end (EIconEntry *entry, + GtkAction *action); G_END_DECLS diff --git a/widgets/misc/e-search-bar.c b/widgets/misc/e-search-bar.c index bd8ba20072..fcfe002843 100644 --- a/widgets/misc/e-search-bar.c +++ b/widgets/misc/e-search-bar.c @@ -24,306 +24,159 @@ * Boston, MA 02110-1301, USA. */ +#include "e-search-bar.h" -#ifdef HAVE_CONFIG_H -#include <config.h> -#endif - -#include <gdk/gdkkeysyms.h> - -#include <misc/e-unicode.h> -#include <misc/e-gui-utils.h> - -#include <glib/gi18n.h> - -#include <bonobo/bonobo-ui-util.h> +#include "config.h" #include <stdlib.h> #include <string.h> - -#include "e-icon-entry.h" -#include "e-search-bar.h" -#include "e-util/e-util.h" -#include "e-util/e-util-marshal.h" - - -enum { - QUERY_CHANGED, - MENU_ACTIVATED, - SEARCH_ACTIVATED, - SEARCH_CLEARED, - LAST_SIGNAL +#include <glib/gi18n.h> +#include <gdk/gdkkeysyms.h> +#include <e-util/e-util.h> +#include <e-util/e-util-marshal.h> + +#include <e-action-combo-box.h> +#include <e-gui-utils.h> +#include <e-icon-entry.h> +#include <e-unicode.h> + +#define E_SEARCH_BAR_GET_PRIVATE(obj) \ + (G_TYPE_INSTANCE_GET_PRIVATE \ + ((obj), E_TYPE_SEARCH_BAR, ESearchBarPrivate)) + +struct _ESearchBarPrivate { + GtkWidget *filter_label; + GtkWidget *filter_combo_box; + GtkWidget *search_label; + GtkWidget *search_entry; + GtkWidget *scope_label; + GtkWidget *scope_combo_box; + + GtkRadioAction *search_action; + GtkWidget *search_popup_menu; + + GtkActionGroup *action_group; }; -static gint esb_signals [LAST_SIGNAL] = { 0, }; - -static GtkHBoxClass *parent_class = NULL; - -/* The arguments we take */ enum { PROP_0, - PROP_ITEM_ID, - PROP_SUBITEM_ID, - PROP_TEXT, + PROP_FILTER_ACTION, + PROP_FILTER_VALUE, + PROP_FILTER_VISIBLE, + PROP_SEARCH_ACTION, + PROP_SEARCH_TEXT, + PROP_SEARCH_VALUE, + PROP_SEARCH_VISIBLE, + PROP_SCOPE_ACTION, + PROP_SCOPE_VALUE, + PROP_SCOPE_VISIBLE }; - -/* Forward decls. */ - -static int find_id (GtkWidget *menu, int idin, const char *type, GtkWidget **widget); - -static void emit_search_activated (ESearchBar *esb); -static void emit_query_changed (ESearchBar *esb); - - -/* Utility functions. */ - -static void -set_find_now_sensitive (ESearchBar *search_bar, - gboolean sensitive) -{ - if (search_bar->ui_component != NULL) - bonobo_ui_component_set_prop (search_bar->ui_component, - "/commands/ESearchBar:FindNow", - "sensitive", sensitive ? "1" : "0", NULL); -} +static gpointer parent_class; static void -update_clear_menuitem_sensitive (ESearchBar *search_bar) +action_search_clear_cb (GtkAction *action, + ESearchBar *search_bar) { - if (search_bar->ui_component != NULL) { - gboolean sensitive = GTK_WIDGET_SENSITIVE (search_bar->clear_button) || search_bar->viewitem_id != 0; - - bonobo_ui_component_set_prop (search_bar->ui_component, - "/commands/ESearchBar:Clear", - "sensitive", sensitive ? "1" : "0", NULL); - } + e_search_bar_set_search_text (search_bar, ""); + gtk_action_set_sensitive (action, FALSE); } static void -clear_button_state_changed (GtkWidget *clear_button, GtkStateType state, ESearchBar *search_bar) -{ - g_return_if_fail (clear_button != NULL && search_bar != NULL); - - update_clear_menuitem_sensitive (search_bar); -} - -static char * -verb_name_from_id (int id) +action_search_find_cb (GtkAction *action, + ESearchBar *search_bar) { - return g_strdup_printf ("ESearchBar:Activate:%d", id); + gtk_action_set_sensitive (action, FALSE); } -/* This implements the "clear" action, i.e. clears the text and then emits - * ::search_activated. */ - static void -clear_search (ESearchBar *esb) -{ - e_search_bar_set_text (esb, ""); - esb->block_search = TRUE; - if (esb->item_id < 0) - e_search_bar_set_item_id (esb, esb->last_search_option); - e_search_bar_set_viewitem_id (esb, 0); - esb->block_search = FALSE; - emit_search_activated (esb); -} +action_search_type_cb (GtkAction *action, + ESearchBar *search_bar) +{ + gtk_menu_popup ( + GTK_MENU (search_bar->priv->search_popup_menu), + NULL, NULL, NULL, NULL, 0, gtk_get_current_event_time ()); +} + +static GtkActionEntry search_entries[] = { + + { "search-clear", + GTK_STOCK_CLEAR, + NULL, + "<Shift><Control>q", + N_("Clear the most recent search"), + G_CALLBACK (action_search_clear_cb) }, + + { "search-find", + GTK_STOCK_FIND, + N_("_Find Now"), + NULL, + N_("Execute the search"), + G_CALLBACK (action_search_find_cb) }, + + { "search-type", + GTK_STOCK_FIND, + NULL, + NULL, + NULL, + G_CALLBACK (action_search_type_cb) } +}; static void -free_menu_items (ESearchBar *esb) +search_bar_update_search_popup (ESearchBar *search_bar) { - GSList *p; - - if (esb->menu_items == NULL) - return; + GtkAction *action; + GtkMenuShell *menu_shell; + GSList *list, *iter; - for (p = esb->menu_items; p != NULL; p = p->next) { - ESearchBarItem *item; + action = gtk_action_group_get_action ( + search_bar->priv->action_group, "search-type"); - item = (ESearchBarItem *) p->data; - - /* (No submitems for the menu_items, so no need to free that - member.) */ - - g_free (item->text); - g_free (item); + if (search_bar->priv->search_popup_menu != NULL) { + g_object_unref (search_bar->priv->search_popup_menu); + search_bar->priv->search_popup_menu = NULL; } - g_slist_free (esb->menu_items); - esb->menu_items = NULL; -} - - -/* Signals. */ - -static void -emit_query_changed (ESearchBar *esb) -{ - g_signal_emit (esb, esb_signals [QUERY_CHANGED], 0); - update_clear_menuitem_sensitive (esb); -} - -static void -emit_search_activated(ESearchBar *esb) -{ - if (esb->pending_activate) { - g_source_remove (esb->pending_activate); - esb->pending_activate = 0; + if (search_bar->priv->search_action == NULL) { + gtk_action_set_sensitive (action, FALSE); + return; } - g_signal_emit (esb, esb_signals [SEARCH_ACTIVATED], 0); - - set_find_now_sensitive (esb, FALSE); - update_clear_menuitem_sensitive (esb); -} - -static void -emit_menu_activated (ESearchBar *esb, int item) -{ - g_signal_emit (esb, - esb_signals [MENU_ACTIVATED], 0, - item); -} - - -/* Callbacks -- Standard verbs. */ - -static void -search_now_verb_cb (BonoboUIComponent *ui_component, - void *data, - const char *verb_name) -{ - ESearchBar *esb; - GtkStyle *style = gtk_widget_get_default_style (); - char *text; + search_bar->priv->search_popup_menu = gtk_menu_new (); + menu_shell = GTK_MENU_SHELL (search_bar->priv->search_popup_menu); + list = gtk_radio_action_get_group (search_bar->priv->search_action); - esb = E_SEARCH_BAR (data); - text = e_search_bar_get_text (esb); + for (iter = list; iter != NULL; iter = iter->next) { + GtkAction *action = iter->data; + GtkWidget *widget; - if (text && *text) { - gtk_widget_modify_base (esb->entry, GTK_STATE_NORMAL, &(style->base[GTK_STATE_SELECTED])); - gtk_widget_modify_text (esb->entry, GTK_STATE_NORMAL, &(style->text[GTK_STATE_SELECTED])); - gtk_widget_modify_base (esb->icon_entry, GTK_STATE_NORMAL, &(style->base[GTK_STATE_SELECTED])); - gtk_widget_modify_base (esb->viewoption, GTK_STATE_NORMAL, &(style->base[GTK_STATE_SELECTED])); - } else { - gtk_widget_modify_base (esb->entry, GTK_STATE_NORMAL, NULL); - gtk_widget_modify_text (esb->entry, GTK_STATE_NORMAL, NULL); - gtk_widget_modify_base (esb->icon_entry, GTK_STATE_NORMAL, NULL); - gtk_widget_set_sensitive (esb->clear_button, FALSE); + widget = gtk_action_create_menu_item (action); + gtk_menu_shell_append (menu_shell, widget); + gtk_widget_show (widget); } - g_free (text); - emit_search_activated (esb); -} - -static void -clear_verb_cb (BonoboUIComponent *ui_component, - void *data, - const char *verb_name) -{ - ESearchBar *esb; - esb = E_SEARCH_BAR (data); - - gtk_widget_modify_base (esb->entry, GTK_STATE_NORMAL, NULL); - gtk_widget_modify_text (esb->entry, GTK_STATE_NORMAL, NULL); - gtk_widget_modify_base (esb->icon_entry, GTK_STATE_NORMAL, NULL); - gtk_widget_set_sensitive (esb->clear_button, FALSE); - - clear_search (esb); - gtk_entry_set_text (GTK_ENTRY (esb->entry), ""); - gtk_widget_grab_focus (esb->entry); -} - -static void -setup_standard_verbs (ESearchBar *search_bar) -{ - bonobo_ui_component_add_verb (search_bar->ui_component, "ESearchBar:Clear", - clear_verb_cb, search_bar); - bonobo_ui_component_add_verb (search_bar->ui_component, "ESearchBar:FindNow", - search_now_verb_cb, search_bar); - - bonobo_ui_component_set (search_bar->ui_component, "/", - ("<commands>" - " <cmd name=\"ESearchBar:Clear\"/>" - " <cmd name=\"ESearchBar:FindNow\"/>" - "</commands>"), - NULL); - - /* Make sure the entries are created with the correct sensitivity. */ - set_find_now_sensitive (search_bar, FALSE); - update_clear_menuitem_sensitive (search_bar); -} - -/* Callbacks -- The verbs for all the definable items. */ - -static void -search_verb_cb (BonoboUIComponent *ui_component, - void *data, - const char *verb_name) -{ - ESearchBar *esb; - const char *p; - int id; - - esb = E_SEARCH_BAR (data); - - p = strrchr (verb_name, ':'); - g_return_if_fail (p != NULL); - - id = atoi (p + 1); - - emit_menu_activated (esb, id); -} - -/* Get the selected menu item's label */ -static const gchar * -get_selected_item_label (GtkWidget *menu) -{ - GtkWidget *label, *item; - const gchar *text = NULL; - - item = gtk_menu_get_active ((GtkMenu *)menu); - label = gtk_bin_get_child ((GtkBin *)item); - - if (GTK_IS_LABEL (label)) - text = gtk_label_get_text ((GtkLabel *)label); - - return text; + gtk_action_set_sensitive (action, TRUE); } static gboolean -entry_focus_in_cb (GtkWidget *widget, - GdkEventFocus *event, - ESearchBar *esb) -{ - GtkStyle *entry_style, *default_style; - - entry_style = gtk_widget_get_style (esb->entry); - default_style = gtk_widget_get_default_style (); - - if (gdk_color_equal (&(entry_style->text[GTK_STATE_NORMAL]), &(default_style->text[GTK_STATE_INSENSITIVE]))) { - gtk_entry_set_text (GTK_ENTRY (esb->entry), ""); - gtk_widget_modify_text (esb->entry, GTK_STATE_NORMAL, NULL); - } - - return FALSE; -} - -static gboolean -paint_search_text (GtkWidget *widget, ESearchBar *esb) +paint_search_text (GtkWidget *widget, + ESearchBar *search_bar) { +#if 0 GtkStyle *style = gtk_widget_get_default_style (); - const gchar *text = NULL; - GtkWidget *menu_widget = esb->option_menu; + const gchar *text; + GtkWidget *menu_widget = search_bar->option_menu; text = gtk_entry_get_text (GTK_ENTRY (widget)); if (text && *text) return FALSE; - if (!GTK_WIDGET_SENSITIVE (esb->option_button)) { - menu_widget = esb->scopeoption_menu; - text = g_object_get_data (G_OBJECT(gtk_menu_get_active ( GTK_MENU (esb->scopeoption_menu))),"string"); - } else if (!GTK_IS_RADIO_MENU_ITEM (gtk_menu_get_active ( GTK_MENU (esb->option_menu)))) + style = gtk_widget_get_default_style (); + + if (!GTK_WIDGET_SENSITIVE (search_bar->option_button)) { + menu_widget = search_bar->scopeoption_menu; + text = g_object_get_data (G_OBJECT(gtk_menu_get_active ( GTK_MENU (search_bar->scopeoption_menu))),"string"); + } else if (!GTK_IS_RADIO_MENU_ITEM (gtk_menu_get_active ( GTK_MENU (search_bar->option_menu)))) return FALSE; else /* no query in search entry .. so set the current option */ text = get_selected_item_label (menu_widget); @@ -332,1263 +185,894 @@ paint_search_text (GtkWidget *widget, ESearchBar *esb) if (text && *text) { gchar *t; - if (!GTK_WIDGET_HAS_FOCUS(esb->entry)) { - gtk_entry_set_text (GTK_ENTRY (esb->entry), text); - gtk_widget_modify_text (esb->entry, GTK_STATE_NORMAL, &(style->text[GTK_STATE_INSENSITIVE])); + if (!GTK_WIDGET_HAS_FOCUS(search_bar->entry)) { + gtk_entry_set_text (GTK_ENTRY (search_bar->entry), text); + gtk_widget_modify_text (search_bar->entry, GTK_STATE_NORMAL, &(style->text[GTK_STATE_INSENSITIVE])); } t = g_strdup_printf ("%s: %s\n%s", _("Search"), text, _("Click here to change the search type")); - gtk_widget_set_tooltip_text (esb->option_button, t); + gtk_widget_set_tooltip_text (search_bar->option_button, t); g_free (t); - gtk_widget_set_sensitive (esb->clear_button, FALSE); + gtk_widget_set_sensitive (search_bar->clear_button, FALSE); } return FALSE; +#endif + + return FALSE; } void e_search_bar_paint (ESearchBar *search_bar) { - paint_search_text (search_bar->entry, search_bar); -} + EIconEntry *icon_entry; + GtkWidget *entry; -static gboolean -entry_focus_out_cb (GtkWidget *widget, - GdkEventFocus *event, - ESearchBar *esb) -{ - return paint_search_text (widget, esb); + icon_entry = E_ICON_ENTRY (search_bar->priv->search_entry); + entry = e_icon_entry_get_entry (icon_entry); + paint_search_text (entry, search_bar); } static void -entry_activated_cb (GtkWidget *widget, - ESearchBar *esb) +search_bar_entry_activated_cb (ESearchBar *search_bar, + GtkWidget *entry) { - const char *text = gtk_entry_get_text (GTK_ENTRY (esb->entry)); - GtkStyle *style = gtk_widget_get_default_style (); + GtkStyle *style; + GtkAction *action; + GtkActionGroup *action_group; + gboolean sensitive; + const gchar *text; - if (text && *text) { - gtk_widget_modify_base (esb->entry, GTK_STATE_NORMAL, &(style->base[GTK_STATE_SELECTED])); - gtk_widget_modify_text (esb->entry, GTK_STATE_NORMAL, &(style->text[GTK_STATE_SELECTED])); - gtk_widget_modify_base (esb->icon_entry, GTK_STATE_NORMAL, &(style->base[GTK_STATE_SELECTED])); - gtk_widget_modify_base (esb->viewoption, GTK_STATE_NORMAL, &(style->base[GTK_STATE_SELECTED])); - } else { - gtk_widget_modify_base (esb->entry, GTK_STATE_NORMAL, NULL); - gtk_widget_modify_text (esb->entry, GTK_STATE_NORMAL, NULL); - gtk_widget_modify_base (esb->icon_entry, GTK_STATE_NORMAL, NULL); - gtk_widget_set_sensitive (esb->clear_button, FALSE); - } - - emit_search_activated (esb); -} - -static void -entry_changed_cb (GtkWidget *widget, - ESearchBar *esb) -{ - const char *text = gtk_entry_get_text (GTK_ENTRY (esb->entry)); - GtkStyle *entry_style, *default_style; - - entry_style = gtk_widget_get_style (esb->entry); - default_style = gtk_widget_get_default_style (); + style = gtk_widget_get_default_style (); + text = gtk_entry_get_text (GTK_ENTRY (entry)); + action_group = e_search_bar_get_action_group (search_bar); if (text && *text) { - if (gdk_color_equal (&(entry_style->text[GTK_STATE_NORMAL]), &(default_style->text[GTK_STATE_INSENSITIVE]))) - gtk_widget_set_sensitive (esb->clear_button, FALSE); - else - gtk_widget_set_sensitive (esb->clear_button, TRUE); + gtk_widget_modify_base ( + entry, GTK_STATE_NORMAL, + &(style->base[GTK_STATE_SELECTED])); + gtk_widget_modify_text ( + entry, GTK_STATE_NORMAL, + &(style->text[GTK_STATE_SELECTED])); + gtk_widget_modify_base ( + search_bar->priv->search_entry, + GTK_STATE_NORMAL, + &(style->base[GTK_STATE_SELECTED])); + gtk_widget_modify_base ( + search_bar->priv->filter_combo_box, + GTK_STATE_NORMAL, + &(style->base[GTK_STATE_SELECTED])); + sensitive = TRUE; } else { - /* selected color means some search text is active */ - gtk_widget_set_sensitive (esb->clear_button, gdk_color_equal (&(entry_style->base[GTK_STATE_NORMAL]), &(default_style->base[GTK_STATE_SELECTED]))); + gtk_widget_modify_base ( + entry, GTK_STATE_NORMAL, NULL); + gtk_widget_modify_text ( + entry, GTK_STATE_NORMAL, NULL); + gtk_widget_modify_base ( + search_bar->priv->search_entry, + GTK_STATE_NORMAL, NULL); + sensitive = FALSE; } -} -static void -viewitem_activated_cb(GtkWidget *widget, ESearchBar *esb) -{ - gint viewid; - GtkStyle *entry_style, *default_style; - - widget = gtk_menu_get_active (GTK_MENU (esb->viewoption_menu)); - - viewid = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), "EsbItemId")); - esb->viewitem_id = viewid; - - entry_style = gtk_widget_get_style (esb->entry); - default_style = gtk_widget_get_default_style (); - - /* If the text is grayed, Its not the query string */ - if (gdk_color_equal (&(entry_style->text[GTK_STATE_NORMAL]), &(default_style->text[GTK_STATE_INSENSITIVE]))) { - gtk_entry_set_text (GTK_ENTRY (esb->entry), ""); - gtk_widget_modify_text (esb->entry, GTK_STATE_NORMAL, NULL); - } + action = gtk_action_group_get_action ( + action_group, E_SEARCH_BAR_ACTION_CLEAR); + gtk_action_set_sensitive (action, sensitive); - esb->block_search = TRUE; - emit_search_activated (esb); - esb->block_search = FALSE; + action = gtk_action_group_get_action ( + action_group, E_SEARCH_BAR_ACTION_FIND); + gtk_action_activate (action); } static void -scopeitem_activated_cb(GtkWidget *widget, ESearchBar *esb) -{ - gint scopeid; - GtkStyle *entry_style, *default_style; - - widget = gtk_menu_get_active (GTK_MENU (esb->scopeoption_menu)); - - scopeid = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), "EsbItemId")); - esb->scopeitem_id = scopeid; - - entry_style = gtk_widget_get_style (esb->entry); - default_style = gtk_widget_get_default_style (); - - /* If the text is grayed, Its not the query string */ - if (gdk_color_equal (&(entry_style->text[GTK_STATE_NORMAL]), &(default_style->text[GTK_STATE_INSENSITIVE]))) { - gtk_widget_grab_focus (esb->entry); - gtk_entry_set_text (GTK_ENTRY (esb->entry), ""); - gtk_widget_modify_text (esb->entry, GTK_STATE_NORMAL, NULL); +search_bar_entry_changed_cb (ESearchBar *search_bar, + GtkWidget *entry) +{ + GtkActionGroup *action_group; + GtkAction *action; + GtkStyle *style1; + GtkStyle *style2; + GdkColor *color1; + GdkColor *color2; + gboolean sensitive; + const gchar *text; + + style1 = gtk_widget_get_style (entry); + style2 = gtk_widget_get_default_style (); + + text = gtk_entry_get_text (GTK_ENTRY (entry)); + + if (text != NULL && *text != '\0') { + color1 = &style1->text[GTK_STATE_NORMAL]; + color2 = &style2->text[GTK_STATE_INSENSITIVE]; + sensitive = !gdk_color_equal (color1, color2); + } else { + color1 = &style1->text[GTK_STATE_NORMAL]; + color2 = &style2->text[GTK_STATE_SELECTED]; + sensitive = gdk_color_equal (color1, color2); } - esb->block_search = TRUE; - emit_search_activated (esb); - esb->block_search = FALSE; + action_group = search_bar->priv->action_group; + action = gtk_action_group_get_action ( + action_group, E_SEARCH_BAR_ACTION_CLEAR); + gtk_action_set_sensitive (action, sensitive); } -static void -option_activated_cb (GtkWidget *widget, - ESearchBar *esb) +static gboolean +search_bar_entry_focus_in_cb (ESearchBar *search_bar, + GdkEventFocus *event, + GtkWidget *entry) { - int id; - const char *text; + GtkStyle *style1; + GtkStyle *style2; + GdkColor *color1; + GdkColor *color2; - id = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), "EsbItemId")); + style1 = gtk_widget_get_style (entry); + style2 = gtk_widget_get_default_style (); - e_search_bar_set_item_id (esb, id); + color1 = &style1->text[GTK_STATE_NORMAL]; + color2 = &style2->text[GTK_STATE_INSENSITIVE]; - if (GTK_IS_RADIO_MENU_ITEM (gtk_menu_get_active ( GTK_MENU (esb->option_menu)))) { - gchar *t; - text = get_selected_item_label (esb->option_menu); - if (text && *text) - t = g_strdup_printf ("%s: %s\n%s", _("Search"), text, _("Click here to change the search type")); - else - t = g_strdup_printf ("%s: %s", _("Search"), _("Click here to change the search type")); - - gtk_widget_set_tooltip_text (esb->option_button, t); - g_free (t); + if (gdk_color_equal (color1, color2)) { + gtk_entry_set_text (GTK_ENTRY (entry), ""); + gtk_widget_modify_text (entry, GTK_STATE_NORMAL, NULL); } - if (!esb->block_search) { - emit_query_changed (esb); - } - if (!esb->block_search && id > 0) { - emit_search_activated (esb); - } -} - -static void -option_button_clicked_cb (GtkWidget *widget, GdkEventButton *event, - ESearchBar *esb) -{ - gtk_menu_popup (GTK_MENU (esb->option_menu), NULL, NULL, NULL, NULL,1,gtk_get_current_event_time()); - - gtk_widget_grab_focus (esb->entry); -} - -static void -clear_button_clicked_cb (GtkWidget *widget, GdkEventButton *event, - ESearchBar *esb) -{ - gtk_widget_modify_base (esb->entry, GTK_STATE_NORMAL, NULL); - gtk_widget_modify_text (esb->entry, GTK_STATE_NORMAL, NULL); - gtk_widget_modify_base (esb->icon_entry, GTK_STATE_NORMAL, NULL); - gtk_widget_set_sensitive (esb->clear_button, FALSE); - - clear_search (esb); - gtk_entry_set_text (GTK_ENTRY (esb->entry), ""); - gtk_widget_grab_focus (esb->entry); + return FALSE; } static gboolean -entry_key_press_cb (GtkWidget *widget, - GdkEventKey *key_event, - ESearchBar *esb) +search_bar_entry_focus_out_cb (ESearchBar *search_bar, + GdkEventFocus *event, + GtkWidget *entry) { - if (((key_event->state & gtk_accelerator_get_default_mod_mask ()) == - GDK_MOD1_MASK) && (key_event->keyval == GDK_Down)) { - option_button_clicked_cb (NULL, NULL, esb); - return TRUE; - } - - return FALSE; + return paint_search_text (entry, search_bar); } -#if 0 -static void -scopeoption_changed_cb (GtkWidget *option_menu, ESearchBar *search_bar) +static gboolean +search_bar_entry_key_press_cb (ESearchBar *search_bar, + GdkEventKey *key_event, + GtkWidget *entry) { - char *text = NULL; - - text = e_search_bar_get_text (search_bar); - if (!(text && *text)) - gtk_widget_grab_focus (search_bar->entry); - - if(!search_bar->block_search) - emit_query_changed (search_bar); + guint state; - g_free (text); -} +#if 0 /* FIXME */ + state = key_event->state & gtk_accelerator_get_default_mod_mask (); + if (state == GDK_MOD1_MASK && key_event->keyval == GDK_Down) { + search_bar_option_clicked_cb (search_bar, NULL, NULL); + return TRUE; + } #endif - -/* Widgetry creation. */ -#if 0 -/* This function exists to fix the irreparable GtkOptionMenu stupidity. In - fact, this lame-ass widget adds a 1-pixel-wide empty border around the - button for no reason. So we have add a 1-pixel-wide border around the the - buttons we have in the search bar to make things look right. This is done - through an event box. */ -static GtkWidget * -put_in_spacer_widget (GtkWidget *widget) -{ - GtkWidget *holder; - - holder = gtk_event_box_new (); - gtk_container_set_border_width (GTK_CONTAINER (holder), 1); - gtk_container_add (GTK_CONTAINER (holder), widget); - - return holder; + return FALSE; } -#endif static void -append_xml_menu_item (GString *xml, - const char *name, - const char *label, - const char *stock, - const char *verb, - const char *accelerator) -{ - char *encoded_label; - - encoded_label = bonobo_ui_util_encode_str (label); - g_string_append_printf (xml, "<menuitem name=\"%s\" verb=\"%s\" label=\"%s\"", - name, verb, encoded_label); - g_free (encoded_label); - - if (accelerator != NULL) - g_string_append_printf (xml, " accel=\"%s\"", accelerator); - if (stock != NULL) - g_string_append_printf (xml, " pixtype=\"stock\" pixname=\"%s\"", stock); +search_bar_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + switch (property_id) { + case PROP_FILTER_ACTION: + e_search_bar_set_filter_action ( + E_SEARCH_BAR (object), + g_value_get_object (value)); + return; + + case PROP_FILTER_VALUE: + e_search_bar_set_filter_value ( + E_SEARCH_BAR (object), + g_value_get_int (value)); + return; + + case PROP_FILTER_VISIBLE: + e_search_bar_set_filter_visible ( + E_SEARCH_BAR (object), + g_value_get_boolean (value)); + return; + + case PROP_SEARCH_ACTION: + e_search_bar_set_search_action ( + E_SEARCH_BAR (object), + g_value_get_object (value)); + return; + + case PROP_SEARCH_TEXT: + e_search_bar_set_search_text ( + E_SEARCH_BAR (object), + g_value_get_string (value)); + return; + + case PROP_SEARCH_VALUE: + e_search_bar_set_search_value ( + E_SEARCH_BAR (object), + g_value_get_int (value)); + return; + + case PROP_SEARCH_VISIBLE: + e_search_bar_set_search_visible ( + E_SEARCH_BAR (object), + g_value_get_boolean (value)); + return; + + case PROP_SCOPE_ACTION: + e_search_bar_set_scope_action ( + E_SEARCH_BAR (object), + g_value_get_object (value)); + return; + + case PROP_SCOPE_VALUE: + e_search_bar_set_scope_value ( + E_SEARCH_BAR (object), + g_value_get_int (value)); + return; + + case PROP_SCOPE_VISIBLE: + e_search_bar_set_scope_visible ( + E_SEARCH_BAR (object), + g_value_get_boolean (value)); + return; + } - g_string_append (xml, "/>"); + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); } static void -remove_bonobo_menus (ESearchBar *esb) -{ - if (bonobo_ui_component_get_container (esb->ui_component) == CORBA_OBJECT_NIL) - return; +search_bar_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + switch (property_id) { + case PROP_FILTER_ACTION: + g_value_set_object ( + value, e_search_bar_get_filter_action ( + E_SEARCH_BAR (object))); + return; + + case PROP_FILTER_VALUE: + g_value_set_int ( + value, e_search_bar_get_filter_value ( + E_SEARCH_BAR (object))); + return; + + case PROP_FILTER_VISIBLE: + g_value_set_boolean ( + value, e_search_bar_get_filter_visible ( + E_SEARCH_BAR (object))); + return; + + case PROP_SEARCH_ACTION: + g_value_set_object ( + value, e_search_bar_get_search_action ( + E_SEARCH_BAR (object))); + return; + + case PROP_SEARCH_TEXT: + g_value_set_string ( + value, e_search_bar_get_search_text ( + E_SEARCH_BAR (object))); + return; + + case PROP_SEARCH_VALUE: + g_value_set_int ( + value, e_search_bar_get_search_value ( + E_SEARCH_BAR (object))); + return; + + case PROP_SEARCH_VISIBLE: + g_value_set_boolean ( + value, e_search_bar_get_search_visible ( + E_SEARCH_BAR (object))); + return; + + case PROP_SCOPE_ACTION: + g_value_set_object ( + value, e_search_bar_get_scope_action ( + E_SEARCH_BAR (object))); + return; + + case PROP_SCOPE_VALUE: + g_value_set_int ( + value, e_search_bar_get_scope_value ( + E_SEARCH_BAR (object))); + return; + + case PROP_SCOPE_VISIBLE: + g_value_set_boolean ( + value, e_search_bar_get_scope_visible ( + E_SEARCH_BAR (object))); + return; + } - bonobo_ui_component_rm (esb->ui_component, "/menu/SearchPlaceholder", NULL); + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); } static void -setup_bonobo_menus (ESearchBar *esb) +search_bar_dispose (GObject *object) { - GString *xml; - GSList *p; - char *verb_name; - char *encoded_title; - - xml = g_string_new (""); - - encoded_title = bonobo_ui_util_encode_str (_("_Search")); - g_string_append_printf (xml, "<submenu name=\"Search\" label=\"%s\">", encoded_title); - g_free (encoded_title); - - g_string_append (xml, "<placeholder name=\"SearchBar\">"); - - append_xml_menu_item (xml, "FindNow", _("_Find Now"), "gtk-find", "ESearchBar:FindNow", NULL); - append_xml_menu_item (xml, "Clear", _("_Clear"), "gtk-clear", "ESearchBar:Clear", "*Control**Shift*q"); + ESearchBarPrivate *priv; - for (p = esb->menu_items; p != NULL; p = p->next) { - const ESearchBarItem *item; + priv = E_SEARCH_BAR_GET_PRIVATE (object); - item = (const ESearchBarItem *) p->data; - - verb_name = verb_name_from_id (item->id); - bonobo_ui_component_add_verb (esb->ui_component, verb_name, search_verb_cb, esb); - - if (item->text == NULL) - g_string_append (xml, "<separator/>"); - else - append_xml_menu_item (xml, verb_name, item->text, NULL, verb_name, NULL); - - g_free (verb_name); + if (priv->filter_label != NULL) { + g_object_unref (priv->filter_label); + priv->filter_label = NULL; } - g_string_append (xml, "</placeholder>"); - g_string_append (xml, "</submenu>"); - - remove_bonobo_menus (esb); - bonobo_ui_component_set (esb->ui_component, "/menu/SearchPlaceholder", xml->str, NULL); - - g_string_free (xml, TRUE); - - if (esb->clear_button) { - g_signal_connect (esb->clear_button, "state-changed", G_CALLBACK (clear_button_state_changed), esb); + if (priv->filter_combo_box != NULL) { + g_object_unref (priv->filter_combo_box); + priv->filter_combo_box = NULL; } -} - -static void -update_bonobo_menus (ESearchBar *esb) -{ - setup_bonobo_menus (esb); -} -static void -set_menu (ESearchBar *esb, - ESearchBarItem *items) -{ - int i; - - free_menu_items (esb); - - if (items == NULL) - return; - - for (i = 0; items[i].id != -1; i++) { - ESearchBarItem *new_item; - - new_item = g_new (ESearchBarItem, 1); - new_item->text = items[i].text ? g_strdup (_(items[i].text)) : NULL; - new_item->id = items[i].id; - new_item->type = items[i].type; - - esb->menu_items = g_slist_append (esb->menu_items, new_item); + if (priv->search_label != NULL) { + g_object_unref (priv->search_label); + priv->search_label = NULL; } - if (esb->ui_component != NULL) - update_bonobo_menus (esb); -} - -/* /\* Callback used when an option item is destroyed. We have to destroy its */ -/* * suboption items. */ -/* *\/ */ -/* static void */ -/* option_item_destroy_cb (GtkObject *object, gpointer data) */ -/* { */ -/* /\* ESearchBarSubitem *subitems; *\/ */ - -/* /\* subitems = data; *\/ */ - -/* /\* g_assert (subitems != NULL); *\/ */ -/* /\* free_subitems (subitems); *\/ */ -/* /\* g_object_set_data (G_OBJECT (object), "EsbChoiceSubitems", NULL); *\/ */ -/* } */ - -static void -set_option (ESearchBar *esb, ESearchBarItem *items) -{ - GtkWidget *menu; - GSList *group = NULL; - int i; - - if (esb->option_menu) - gtk_widget_destroy (esb->option_menu); - - esb->option_menu = menu = gtk_menu_new (); - for (i = 0; items[i].id != -1; i++) { - GtkWidget *item; - - /* Create a new group */ - if (items[i].id == 0) - group = NULL; - - if (items[i].text) { - char *str; - str = e_str_without_underscores (_(items[i].text)); - switch (items[i].type) { - case ESB_ITEMTYPE_NORMAL: - item = gtk_menu_item_new_with_label (str); - break; - case ESB_ITEMTYPE_CHECK: - item = gtk_check_menu_item_new_with_label (str); - break; - case ESB_ITEMTYPE_RADIO: - item = gtk_radio_menu_item_new_with_label (group, str); - group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM (item)); - break; - default: - /* Fixme : this should be a normal item */ - item = gtk_radio_menu_item_new_with_label (group, str); - group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM (item)); - break; - } - g_free (str); - } else { - item = gtk_menu_item_new (); - gtk_widget_set_sensitive (item, FALSE); - } - - gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); + if (priv->search_entry != NULL) { + g_object_unref (priv->search_entry); + priv->search_entry = NULL; + } - g_object_set_data (G_OBJECT (item), "EsbItemId", GINT_TO_POINTER(items[i].id)); + if (priv->scope_label != NULL) { + g_object_unref (priv->scope_label); + priv->scope_label = NULL; + } - g_signal_connect (item, "activate", - G_CALLBACK (option_activated_cb), - esb); + if (priv->scope_combo_box != NULL) { + g_object_unref (priv->scope_combo_box); + priv->scope_combo_box = NULL; } - gtk_widget_show_all (menu); - g_object_set_data (G_OBJECT(esb->option_menu), "group", group); - entry_focus_out_cb (esb->entry, NULL, esb); -} + if (priv->search_action != NULL) { + g_object_unref (priv->search_action); + priv->search_action = NULL; + } -static int -find_id (GtkWidget *menu, int idin, const char *type, GtkWidget **widget) -{ - GList *l = GTK_MENU_SHELL (menu)->children; - int row = -1, i = 0, id; - - if (widget) - *widget = NULL; - while (l) { - id = GPOINTER_TO_INT (g_object_get_data (l->data, type)); - if (id == idin) { - row = i; - if (widget) - *widget = l->data; - break; - } - i++; - l = l->next; + if (priv->action_group != NULL) { + g_object_unref (priv->action_group); + priv->action_group = NULL; } - return row; -} - -/* GtkObject methods. */ + /* Chain up to parent's dispose() method. */ + G_OBJECT_CLASS (parent_class)->dispose (object); +} static void -impl_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) +search_bar_class_init (ESearchBarClass *class) { - ESearchBar *esb = E_SEARCH_BAR (object); - - switch (prop_id) { - case PROP_ITEM_ID: - g_value_set_int (value, e_search_bar_get_item_id (esb)); - break; - - case PROP_TEXT: - g_value_take_string (value, e_search_bar_get_text (esb)); - break; + GObjectClass *object_class; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); - break; - } + parent_class = g_type_class_peek_parent (class); + g_type_class_add_private (class, sizeof (ESearchBarPrivate)); + + object_class = G_OBJECT_CLASS (class); + object_class->set_property = search_bar_set_property; + object_class->get_property = search_bar_get_property; + object_class->dispose = search_bar_dispose; + + g_object_class_install_property ( + object_class, + PROP_FILTER_ACTION, + g_param_spec_object ( + "filter-action", + NULL, + NULL, + GTK_TYPE_RADIO_ACTION, + G_PARAM_READWRITE)); + + g_object_class_install_property ( + object_class, + PROP_FILTER_VALUE, + g_param_spec_int ( + "filter-value", + NULL, + NULL, + G_MININT, + G_MAXINT, + 0, + G_PARAM_READWRITE)); + + g_object_class_install_property ( + object_class, + PROP_FILTER_VISIBLE, + g_param_spec_boolean ( + "filter-visible", + NULL, + NULL, + TRUE, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT)); + + g_object_class_install_property ( + object_class, + PROP_SEARCH_ACTION, + g_param_spec_object ( + "search-action", + NULL, + NULL, + GTK_TYPE_RADIO_ACTION, + G_PARAM_READWRITE)); + + g_object_class_install_property ( + object_class, + PROP_SEARCH_TEXT, + g_param_spec_string ( + "search-text", + NULL, + NULL, + NULL, + G_PARAM_READWRITE)); + + g_object_class_install_property ( + object_class, + PROP_SEARCH_VALUE, + g_param_spec_int ( + "search-value", + NULL, + NULL, + G_MININT, + G_MAXINT, + 0, + G_PARAM_READWRITE)); + + g_object_class_install_property ( + object_class, + PROP_SEARCH_VISIBLE, + g_param_spec_boolean ( + "search-visible", + NULL, + NULL, + TRUE, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT)); + + g_object_class_install_property ( + object_class, + PROP_SCOPE_ACTION, + g_param_spec_object ( + "scope-action", + NULL, + NULL, + GTK_TYPE_RADIO_ACTION, + G_PARAM_READWRITE)); + + g_object_class_install_property ( + object_class, + PROP_SCOPE_VALUE, + g_param_spec_int ( + "scope-value", + NULL, + NULL, + G_MININT, + G_MAXINT, + 0, + G_PARAM_READWRITE)); + + g_object_class_install_property ( + object_class, + PROP_SCOPE_VISIBLE, + g_param_spec_boolean ( + "scope-visible", + NULL, + NULL, + FALSE, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT)); } static void -impl_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) +search_bar_init (ESearchBar *search_bar) { - ESearchBar *esb = E_SEARCH_BAR(object); + EIconEntry *icon_entry; + GtkActionGroup *action_group; + GtkAction *action; + GtkLabel *label; + GtkWidget *mnemonic; + GtkWidget *widget; - switch (prop_id) { - case PROP_ITEM_ID: - e_search_bar_set_item_id (esb, g_value_get_int (value)); - break; + search_bar->priv = E_SEARCH_BAR_GET_PRIVATE (search_bar); - case PROP_TEXT: - e_search_bar_set_text (esb, g_value_get_string (value)); - break; + gtk_box_set_spacing (GTK_BOX (search_bar), 3); + gtk_box_set_homogeneous (GTK_BOX (search_bar), FALSE); - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); - break; - } + /*** Filter Widgets ***/ + + /* Translators: The "Show: " label is followed by the Quick Search + * Dropdown Menu where you can choose to display "All Messages", + * "Unread Messages", "Message with 'Important' Label" and so on... */ + widget = gtk_label_new_with_mnemonic (_("Sho_w: ")); + gtk_box_pack_start (GTK_BOX (search_bar), widget, FALSE, FALSE, 0); + search_bar->priv->filter_label = g_object_ref (widget); + gtk_widget_show (widget); + + label = GTK_LABEL (widget); + + widget = e_action_combo_box_new (); + gtk_label_set_mnemonic_widget (label, widget); + gtk_box_pack_start (GTK_BOX (search_bar), widget, FALSE, TRUE, 0); + search_bar->priv->filter_combo_box = g_object_ref (widget); + gtk_widget_show (widget); + + /*** Scope Widgets ***/ + + widget = e_action_combo_box_new (); + gtk_box_pack_end (GTK_BOX (search_bar), widget, FALSE, FALSE, 0); + search_bar->priv->scope_combo_box = g_object_ref (widget); + gtk_widget_show (widget); + + mnemonic = widget; + + /* Translators: The " in " label is part of the Quick Search Bar, + * example: Search: [_________________] in [ Current Folder ] */ + widget = gtk_label_new_with_mnemonic (_(" i_n ")); + gtk_label_set_mnemonic_widget (GTK_LABEL (widget), mnemonic); + gtk_box_pack_end (GTK_BOX (search_bar), widget, FALSE, FALSE, 0); + search_bar->priv->scope_label = g_object_ref (widget); + gtk_widget_show (widget); + + /*** Search Widgets ***/ + + widget = e_icon_entry_new (); + gtk_box_pack_end (GTK_BOX (search_bar), widget, FALSE, FALSE, 0); + search_bar->priv->search_entry = g_object_ref (widget); + gtk_widget_show (widget); + + icon_entry = E_ICON_ENTRY (widget); + + /* Translators: The "Search: " label is followed by the Quick Search + * Text input field where one enters the term to search for. */ + widget = gtk_label_new_with_mnemonic (_("Sear_ch: ")); + gtk_box_pack_end (GTK_BOX (search_bar), widget, FALSE, FALSE, 0); + search_bar->priv->search_label = g_object_ref (widget); + gtk_widget_show (widget); + + label = GTK_LABEL (widget); + + widget = e_icon_entry_get_entry (icon_entry); + gtk_label_set_mnemonic_widget (label, widget); + g_signal_connect_swapped ( + widget, "activate", + G_CALLBACK (search_bar_entry_activated_cb), search_bar); + g_signal_connect_swapped ( + widget, "changed", + G_CALLBACK (search_bar_entry_changed_cb), search_bar); + g_signal_connect_swapped ( + widget, "focus-in-event", + G_CALLBACK (search_bar_entry_focus_in_cb), search_bar); + g_signal_connect_swapped ( + widget, "focus-out-event", + G_CALLBACK (search_bar_entry_focus_out_cb), search_bar); + g_signal_connect_swapped ( + widget, "key-press-event", + G_CALLBACK (search_bar_entry_key_press_cb), search_bar); + + action_group = gtk_action_group_new ("search"); + gtk_action_group_set_translation_domain ( + action_group, GETTEXT_PACKAGE); + gtk_action_group_add_actions ( + action_group, search_entries, + G_N_ELEMENTS (search_entries), search_bar); + search_bar->priv->action_group = action_group; + + action = gtk_action_group_get_action ( + action_group, E_SEARCH_BAR_ACTION_TYPE); + e_icon_entry_add_action_start (icon_entry, action); + gtk_action_set_sensitive (action, FALSE); + + action = gtk_action_group_get_action ( + action_group, E_SEARCH_BAR_ACTION_CLEAR); + e_icon_entry_add_action_end (icon_entry, action); + gtk_action_set_sensitive (action, FALSE); } -static void -impl_dispose (GObject *object) +GType +e_search_bar_get_type (void) { - ESearchBar *esb = E_SEARCH_BAR (object); - - g_return_if_fail (object != NULL); - g_return_if_fail (E_IS_SEARCH_BAR (object)); - - /* These three we do need to unref, because we explicitly hold - references to them. */ + static GType type = 0; - if (esb->ui_component != NULL) { - bonobo_object_unref (BONOBO_OBJECT (esb->ui_component)); - esb->ui_component = NULL; - } -/* if (esb->entry) { */ -/* g_object_unref (esb->entry); */ -/* esb->entry = NULL; */ -/* } */ - if (esb->suboption) { - g_object_unref (esb->suboption); - esb->suboption = NULL; - } + if (G_UNLIKELY (type == 0)) { + static const GTypeInfo type_info = { + sizeof (ESearchBarClass), + (GBaseInitFunc) NULL, + (GBaseFinalizeFunc) NULL, + (GClassInitFunc) search_bar_class_init, + (GClassFinalizeFunc) NULL, + NULL, /* class_data */ + sizeof (ESearchBar), + 0, /* n_preallocs */ + (GInstanceInitFunc) search_bar_init, + NULL /* value_table */ + }; - if (esb->pending_activate) { - g_source_remove (esb->pending_activate); - esb->pending_activate = 0; + type = g_type_register_static ( + GTK_TYPE_HBOX, "ESearchBar", &type_info, 0); } - free_menu_items (esb); - - if (G_OBJECT_CLASS (parent_class)->dispose) - G_OBJECT_CLASS (parent_class)->dispose (object); + return type; } - -static void -class_init (ESearchBarClass *klass) +GtkWidget * +e_search_bar_new (void) { - GObjectClass *object_class; - - object_class = G_OBJECT_CLASS (klass); - - parent_class = g_type_class_ref (gtk_hbox_get_type ()); - - object_class->set_property = impl_set_property; - object_class->get_property = impl_get_property; - object_class->dispose = impl_dispose; - - klass->set_menu = set_menu; - klass->set_option = set_option; - - g_object_class_install_property (object_class, PROP_ITEM_ID, - g_param_spec_int ("item_id", - _("Item ID"), - /*_( */"XXX blurb" /*)*/, - 0, 0, 0, - G_PARAM_READWRITE | G_PARAM_LAX_VALIDATION)); - - g_object_class_install_property (object_class, PROP_TEXT, - g_param_spec_string ("text", - _("Text"), - /*_( */"XXX blurb" /*)*/, - NULL, - G_PARAM_READWRITE)); - - esb_signals [QUERY_CHANGED] = - g_signal_new ("query_changed", - G_OBJECT_CLASS_TYPE (object_class), - G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET (ESearchBarClass, query_changed), - NULL, NULL, - g_cclosure_marshal_VOID__VOID, - G_TYPE_NONE, 0); - - esb_signals [MENU_ACTIVATED] = - g_signal_new ("menu_activated", - G_OBJECT_CLASS_TYPE (object_class), - G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET (ESearchBarClass, menu_activated), - NULL, NULL, - g_cclosure_marshal_VOID__INT, - G_TYPE_NONE, 1, G_TYPE_INT); - - esb_signals [SEARCH_ACTIVATED] = - g_signal_new ("search_activated", - G_OBJECT_CLASS_TYPE (object_class), - G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET (ESearchBarClass, search_activated), - NULL, NULL, - g_cclosure_marshal_VOID__VOID, - G_TYPE_NONE, 0); - - esb_signals [SEARCH_CLEARED] = - g_signal_new ("search_cleared", - G_OBJECT_CLASS_TYPE (object_class), - G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET (ESearchBarClass, search_cleared), - NULL, NULL, - g_cclosure_marshal_VOID__VOID, - G_TYPE_NONE, 0); + return g_object_new (E_TYPE_SEARCH_BAR, NULL); } -static void -init (ESearchBar *esb) +GtkActionGroup * +e_search_bar_get_action_group (ESearchBar *search_bar) { - esb->ui_component = NULL; - esb->menu_items = NULL; - - esb->option = NULL; - esb->entry = NULL; - esb->suboption = NULL; - - esb->option_menu = NULL; - esb->suboption_menu = NULL; - esb->option_button = NULL; - esb->clear_button = NULL; - esb->entry_box = NULL; - - esb->scopeoption_menu = NULL; - esb->scopeoption = NULL; - esb->scopeoption_box = NULL; - - esb->pending_activate = 0; - - esb->item_id = 0; - esb->scopeitem_id = 0; - esb->last_search_option = 0; - esb->block_search = FALSE; -} - - -/* Object construction. */ + g_return_val_if_fail (E_IS_SEARCH_BAR (search_bar), NULL); -static gint -idle_activate_hack (gpointer ptr) -{ - ESearchBar *esb = E_SEARCH_BAR (ptr); - esb->pending_activate = 0; - emit_search_activated (esb); - return FALSE; + return search_bar->priv->action_group; } -void -e_search_bar_construct (ESearchBar *search_bar, - ESearchBarItem *menu_items, - ESearchBarItem *option_items) +GtkRadioAction * +e_search_bar_get_filter_action (ESearchBar *search_bar) { - GtkWidget *label, *hbox, *bighbox; - - g_return_if_fail (search_bar != NULL); - g_return_if_fail (E_IS_SEARCH_BAR (search_bar)); - g_return_if_fail (option_items != NULL); + EActionComboBox *combo_box; - gtk_box_set_spacing (GTK_BOX (search_bar), 3); + g_return_val_if_fail (E_IS_SEARCH_BAR (search_bar), NULL); - gtk_box_set_homogeneous (GTK_BOX (search_bar), FALSE); + combo_box = E_ACTION_COMBO_BOX (search_bar->priv->filter_combo_box); - bighbox = gtk_hbox_new (FALSE, 0); - search_bar->entry_box = gtk_hbox_new (0, FALSE); - search_bar->icon_entry = e_icon_entry_new (); - search_bar->entry = e_icon_entry_get_entry (E_ICON_ENTRY (search_bar->icon_entry)); - - g_signal_connect (search_bar->entry, "changed", - G_CALLBACK (entry_changed_cb), search_bar); - g_signal_connect (search_bar->entry, "activate", - G_CALLBACK (entry_activated_cb), search_bar); - g_signal_connect (search_bar->entry, "focus-in-event", - G_CALLBACK (entry_focus_in_cb), search_bar); - g_signal_connect (search_bar->entry, "focus-out-event", - G_CALLBACK (entry_focus_out_cb), search_bar); - g_signal_connect (search_bar->entry, "key-press-event", - G_CALLBACK (entry_key_press_cb), search_bar); - - search_bar->clear_button = e_icon_entry_create_button ("gtk-clear"); - g_signal_connect (G_OBJECT (search_bar->clear_button), "button-press-event", G_CALLBACK(clear_button_clicked_cb), search_bar); - e_icon_entry_pack_widget (E_ICON_ENTRY (search_bar->icon_entry), search_bar->clear_button, FALSE); - - search_bar->option_button = e_icon_entry_create_button ("gtk-find"); - g_signal_connect (G_OBJECT (search_bar->option_button), "button-press-event", G_CALLBACK(option_button_clicked_cb), search_bar); - e_icon_entry_pack_widget (E_ICON_ENTRY (search_bar->icon_entry), search_bar->option_button, TRUE); - - gtk_box_pack_start (GTK_BOX(search_bar->entry_box), search_bar->icon_entry, FALSE, FALSE, 0); - - gtk_widget_show_all (search_bar->entry_box); - gtk_widget_set_sensitive (search_bar->clear_button, FALSE); - - /* Current View filter */ - search_bar->viewoption_box = gtk_hbox_new (0, FALSE); - - /* To Translators: The "Show: " label is followed by the Quick Search Dropdown Menu where you can choose - to display "All Messages", "Unread Messages", "Message with 'Important' Label" and so on... */ - label = gtk_label_new_with_mnemonic (_("Sho_w: ")); - gtk_widget_show (label); - gtk_box_pack_start (GTK_BOX(search_bar->viewoption_box), label, FALSE, FALSE, 0); - - search_bar->viewoption = gtk_option_menu_new (); - gtk_label_set_mnemonic_widget ((GtkLabel *)label, search_bar->viewoption); - gtk_box_pack_start (GTK_BOX(search_bar->viewoption_box), search_bar->viewoption, FALSE, TRUE, 0); - gtk_widget_show_all (search_bar->viewoption_box); - gtk_box_pack_start (GTK_BOX(search_bar), search_bar->viewoption_box, FALSE, FALSE, 0); - - hbox = gtk_hbox_new (FALSE, 0); - gtk_box_pack_start (GTK_BOX(search_bar), hbox, FALSE, FALSE, 0); - - /* Search entry */ - hbox = gtk_hbox_new (FALSE, 0); - /* To Translators: The "Show: " label is followed by the Quick Search Text input field where one enters - the term to search for */ - label = gtk_label_new_with_mnemonic (_("Sear_ch: ")); - gtk_widget_show (label); - gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0); - gtk_box_pack_start (GTK_BOX(hbox), search_bar->entry_box, FALSE, FALSE, 0); - gtk_widget_show (search_bar->entry_box); - gtk_label_set_mnemonic_widget ((GtkLabel *)label, search_bar->entry); - - /* Search Scope Widgets */ - search_bar->scopeoption_box = gtk_hbox_new (0, FALSE); - gtk_box_set_spacing (GTK_BOX (search_bar->scopeoption_box), 3); - /* To Translators: The " in " label is part of the Quick Search Bar, example: - Search: | <user's_search_term> | in | Current Folder/All Accounts/Current Account */ - label = gtk_label_new_with_mnemonic (_(" i_n ")); - gtk_widget_show (label); - gtk_box_pack_start (GTK_BOX(search_bar->scopeoption_box), label, FALSE, FALSE, 0); - - search_bar->scopeoption = gtk_option_menu_new (); -/* g_signal_connect (GTK_OPTION_MENU (search_bar->scopeoption), "changed", scopeoption_changed_cb, search_bar); */ - gtk_box_pack_start (GTK_BOX(search_bar->scopeoption_box), search_bar->scopeoption, FALSE, FALSE, 0); - gtk_widget_show_all (search_bar->scopeoption_box); - gtk_widget_hide (hbox); - gtk_label_set_mnemonic_widget ((GtkLabel *)label, search_bar->scopeoption); - - gtk_box_pack_end (GTK_BOX(hbox), search_bar->scopeoption_box, FALSE, FALSE, 0); - gtk_widget_hide (search_bar->scopeoption_box); - - gtk_box_pack_end (GTK_BOX(search_bar), hbox, FALSE, FALSE, 0); - gtk_widget_show (hbox); - - /* Set the menu */ - e_search_bar_set_menu (search_bar, menu_items); - e_search_bar_set_option (search_bar, option_items); - - /* - * If the default choice for the option menu has subitems, then we need to - * activate the search immediately. However, the developer won't have - * connected to the activated signal until after the object is constructed, - * so we can't emit here. Thus we launch a one-shot idle function that will - * emit the changed signal, so that the proper callback will get invoked. - */ - - search_bar->pending_activate = g_idle_add (idle_activate_hack, search_bar); + return e_action_combo_box_get_action (combo_box); } void -e_search_bar_set_menu (ESearchBar *search_bar, ESearchBarItem *menu_items) +e_search_bar_set_filter_action (ESearchBar *search_bar, + GtkRadioAction *action) { - g_return_if_fail (search_bar != NULL); - g_return_if_fail (E_IS_SEARCH_BAR (search_bar)); + EActionComboBox *combo_box; - ((ESearchBarClass *) GTK_OBJECT_GET_CLASS (search_bar))->set_menu (search_bar, menu_items); -} - -void -e_search_bar_add_menu (ESearchBar *search_bar, ESearchBarItem *menu_item) -{ - g_return_if_fail (search_bar != NULL); g_return_if_fail (E_IS_SEARCH_BAR (search_bar)); - set_menu (search_bar, menu_item); + combo_box = E_ACTION_COMBO_BOX (search_bar->priv->filter_combo_box); + + e_action_combo_box_set_action (combo_box, action); + g_object_notify (G_OBJECT (search_bar), "filter-action"); } -void -e_search_bar_set_option (ESearchBar *search_bar, ESearchBarItem *option_items) +gint +e_search_bar_get_filter_value (ESearchBar *search_bar) { - g_return_if_fail (search_bar != NULL); - g_return_if_fail (E_IS_SEARCH_BAR (search_bar)); - g_return_if_fail (option_items != NULL); + EActionComboBox *combo_box; - ((ESearchBarClass *) GTK_OBJECT_GET_CLASS (search_bar))->set_option (search_bar, option_items); -} + g_return_val_if_fail (E_IS_SEARCH_BAR (search_bar), 0); -void -e_search_bar_set_viewoption_menufunc (ESearchBar *search_bar, ESearchBarMenuFunc *menu_gen_func, void *data) -{ - g_signal_connect (search_bar->viewoption, "button_press_event", G_CALLBACK (menu_gen_func), data); + combo_box = E_ACTION_COMBO_BOX (search_bar->priv->filter_combo_box); + + return e_action_combo_box_get_current_value (combo_box); } -/** - * e_search_bar_set_viewoption_menu: - * @search_bar: A search bar. - * @option_id: Identifier of the main option menu item under which the subitems - * are to be set. - * @subitems: Array of subitem information. - * - * Sets the items for the secondary option menu of a search bar. - **/ void -e_search_bar_set_viewoption_menu (ESearchBar *search_bar, GtkWidget *menu) +e_search_bar_set_filter_value (ESearchBar *search_bar, + gint value) { + EActionComboBox *combo_box; - if (search_bar->viewoption_menu != NULL) - gtk_option_menu_remove_menu (GTK_OPTION_MENU (search_bar->viewoption)); + g_return_if_fail (E_IS_SEARCH_BAR (search_bar)); - search_bar->viewoption_menu = menu; - gtk_option_menu_set_menu (GTK_OPTION_MENU (search_bar->viewoption), search_bar->viewoption_menu); + combo_box = E_ACTION_COMBO_BOX (search_bar->priv->filter_combo_box); - g_signal_connect (search_bar->viewoption_menu, - "selection-done", - G_CALLBACK (viewitem_activated_cb), - search_bar); + e_action_combo_box_set_current_value (combo_box, value); + g_object_notify (G_OBJECT (search_bar), "filter-value"); } -GtkWidget * -e_search_bar_get_selected_viewitem (ESearchBar *search_bar) +gboolean +e_search_bar_get_filter_visible (ESearchBar *search_bar) { - GtkWidget *widget = NULL; - - widget = gtk_menu_get_active (GTK_MENU (search_bar->viewoption_menu)); + g_return_val_if_fail (E_IS_SEARCH_BAR (search_bar), FALSE); - return widget; + return GTK_WIDGET_VISIBLE (search_bar->priv->filter_combo_box); } -/** - * e_search_bar_set_viewoption: - * @search_bar: A search bar. - * @option_id: Identifier of the main option menu item under which the subitems - * are to be set. - * @subitems: Array of subitem information. - * - * Sets the items for the secondary option menu of a search bar. - **/ void -e_search_bar_set_viewoption (ESearchBar *search_bar, int option_id, ESearchBarItem *subitems) +e_search_bar_set_filter_visible (ESearchBar *search_bar, + gboolean visible) { - GtkWidget *menu; - GtkWidget *menu_item; - gint i; - - /* Create the menu if it is not there. right scenario ????*/ + g_return_if_fail (E_IS_SEARCH_BAR (search_bar)); - if (search_bar->viewoption_menu == NULL) { - search_bar->viewoption_menu = menu = gtk_menu_new (); + if (visible) { + gtk_widget_show (search_bar->priv->filter_label); + gtk_widget_show (search_bar->priv->filter_combo_box); } else { - gtk_option_menu_remove_menu (GTK_OPTION_MENU (search_bar->viewoption)); - search_bar->viewoption_menu = menu = gtk_menu_new (); + gtk_widget_hide (search_bar->priv->filter_label); + gtk_widget_hide (search_bar->priv->filter_combo_box); } - /* Create the items */ - - for (i = 0; subitems[i].id != -1; ++i) { - if (subitems[i].text) { - char *str = NULL; - str = e_str_without_underscores (subitems[i].text); - menu_item = gtk_menu_item_new_with_label (str); - g_free (str); - } else { - menu_item = gtk_menu_item_new (); - gtk_widget_set_sensitive (menu_item, FALSE); - } - - g_object_set_data (G_OBJECT (menu_item), "EsbItemId", - GINT_TO_POINTER (subitems[i].id)); - - g_signal_connect (menu_item, - "activate", - G_CALLBACK (viewitem_activated_cb), - search_bar); - - gtk_widget_show (menu_item); - gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item); - } - gtk_option_menu_set_menu (GTK_OPTION_MENU (search_bar->viewoption), menu); - + g_object_notify (G_OBJECT (search_bar), "filter-visible"); } -/** - * e_search_bar_set_scopeoption: - * @search_bar: A search bar. - * are to be set. - * @scopeitems: Array of scope information. - * - * Sets the items for the search scope option menu of a search bar. - **/ -void -e_search_bar_set_scopeoption (ESearchBar *search_bar, ESearchBarItem *scopeitems) +GtkRadioAction * +e_search_bar_get_search_action (ESearchBar *search_bar) { - GtkWidget *menu; - GtkWidget *menu_item; - gint i; - - gtk_widget_show (search_bar->scopeoption_box); - if (search_bar->scopeoption_menu != NULL) { - gtk_option_menu_remove_menu (GTK_OPTION_MENU (search_bar->scopeoption)); - } - - search_bar->scopeoption_menu = menu = gtk_menu_new (); - - /* Generate items */ - for (i = 0; scopeitems[i].id != -1; ++i) { - if (scopeitems[i].text) { - char *str; - str = e_str_without_underscores (_(scopeitems[i].text)); - menu_item = gtk_menu_item_new_with_label (str); - g_object_set_data_full (G_OBJECT (menu_item), "string",str, g_free); - } else { - menu_item = gtk_menu_item_new (); - gtk_widget_set_sensitive (menu_item, FALSE); - } - - g_object_set_data (G_OBJECT (menu_item), "EsbItemId", - GINT_TO_POINTER (scopeitems[i].id)); - - g_signal_connect (menu_item, - "activate", - G_CALLBACK (scopeitem_activated_cb), - search_bar); + g_return_val_if_fail (E_IS_SEARCH_BAR (search_bar), NULL); - gtk_widget_show (menu_item); - gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item); - } - gtk_option_menu_set_menu (GTK_OPTION_MENU (search_bar->scopeoption), menu); + return search_bar->priv->search_action; } -/** - * e_search_bar_set_scopeoption_menu: - * @search_bar: A search bar. - * @menu: the scope option menu - * - * Sets the items for the secondary option menu of a search bar. - **/ void -e_search_bar_set_scopeoption_menu (ESearchBar *search_bar, GtkMenu *menu) +e_search_bar_set_search_action (ESearchBar *search_bar, + GtkRadioAction *action) { + g_return_if_fail (E_IS_SEARCH_BAR (search_bar)); - if (search_bar->scopeoption_menu != NULL) - gtk_option_menu_remove_menu (GTK_OPTION_MENU (search_bar->scopeoption)); + if (action != NULL) { + g_return_if_fail (GTK_IS_RADIO_ACTION (action)); + g_object_ref (action); + } - search_bar->scopeoption_menu = GTK_WIDGET (menu); - gtk_option_menu_set_menu (GTK_OPTION_MENU (search_bar->scopeoption), search_bar->scopeoption_menu); + search_bar->priv->search_action = action; + search_bar_update_search_popup (search_bar); - g_signal_connect (search_bar->scopeoption_menu, - "selection-done", - G_CALLBACK (scopeitem_activated_cb), - search_bar); + g_object_notify (G_OBJECT (search_bar), "search-action"); } -GtkWidget * -e_search_bar_new (ESearchBarItem *menu_items, - ESearchBarItem *option_items) +const gchar * +e_search_bar_get_search_text (ESearchBar *search_bar) { - GtkWidget *widget; + EIconEntry *icon_entry; + GtkWidget *entry; + GtkStyle *style1; + GtkStyle *style2; + GdkColor *color1; + GdkColor *color2; - g_return_val_if_fail (option_items != NULL, NULL); + g_return_val_if_fail (E_IS_SEARCH_BAR (search_bar), NULL); - widget = g_object_new (e_search_bar_get_type (), NULL); + icon_entry = E_ICON_ENTRY (search_bar->priv->search_entry); + entry = e_icon_entry_get_entry (icon_entry); - e_search_bar_construct (E_SEARCH_BAR (widget), menu_items, option_items); + style1 = gtk_widget_get_style (entry); + style2 = gtk_widget_get_default_style (); - return widget; -} + color1 = &style1->text[GTK_STATE_NORMAL]; + color2 = &style2->text[GTK_STATE_INSENSITIVE]; -void -e_search_bar_set_ui_component (ESearchBar *search_bar, - BonoboUIComponent *ui_component) -{ - g_return_if_fail (E_IS_SEARCH_BAR (search_bar)); - - if (search_bar->ui_component != NULL) { - remove_bonobo_menus (search_bar); - bonobo_object_unref (BONOBO_OBJECT (search_bar->ui_component)); - } + if (gdk_color_equal (color1, color2)) + return ""; - search_bar->ui_component = ui_component; - if (ui_component != NULL) { - bonobo_object_ref (BONOBO_OBJECT (ui_component)); - setup_standard_verbs (search_bar); - setup_bonobo_menus (search_bar); - } + return gtk_entry_get_text (GTK_ENTRY (entry)); } void -e_search_bar_set_menu_sensitive (ESearchBar *search_bar, int id, gboolean state) +e_search_bar_set_search_text (ESearchBar *search_bar, + const gchar *text) { - char *verb_name; - char *path; + EIconEntry *icon_entry; + GtkWidget *entry; - verb_name = verb_name_from_id (id); - path = g_strconcat ("/commands/", verb_name, NULL); - g_free (verb_name); + g_return_if_fail (E_IS_SEARCH_BAR (search_bar)); - bonobo_ui_component_set_prop (search_bar->ui_component, path, - "sensitive", state ? "1" : "0", - NULL); + icon_entry = E_ICON_ENTRY (search_bar->priv->search_entry); + entry = e_icon_entry_get_entry (icon_entry); - g_free (path); + gtk_entry_set_text (GTK_ENTRY (entry), text); + g_object_notify (G_OBJECT (search_bar), "search-text"); } -GType -e_search_bar_get_type (void) +gint +e_search_bar_get_search_value (ESearchBar *search_bar) { - static GType type = 0; - - if (!type) { - static const GTypeInfo info = { - sizeof (ESearchBarClass), - NULL, /* base_init */ - NULL, /* base_finalize */ - (GClassInitFunc) class_init, - NULL, /* class_finalize */ - NULL, /* class_data */ - sizeof (ESearchBar), - 0, /* n_preallocs */ - (GInstanceInitFunc) init, - }; - - type = g_type_register_static (gtk_hbox_get_type (), "ESearchBar", &info, 0); - } + g_return_val_if_fail (E_IS_SEARCH_BAR (search_bar), 0); - return type; + /* FIXME */ + return 0; } void -e_search_bar_set_viewitem_id (ESearchBar *search_bar, int id) +e_search_bar_set_search_value (ESearchBar *search_bar, + gint value) { - int row; - g_return_if_fail (E_IS_SEARCH_BAR (search_bar)); - row = find_id (search_bar->viewoption_menu, id, "EsbItemId", NULL); - if (row == -1) - return; - search_bar->viewitem_id = id; - gtk_option_menu_set_history (GTK_OPTION_MENU (search_bar->viewoption), row); + /* FIXME */ - emit_query_changed (search_bar); + g_object_notify (G_OBJECT (search_bar), "search-value"); } -/** - * e_search_bar_set_item_id: - * @search_bar: A search bar. - * @id: Identifier of the item to set. - * - * Sets the active item in the options menu of a search bar. - **/ -void -e_search_bar_set_item_id (ESearchBar *search_bar, int id) +gboolean +e_search_bar_get_search_visible (ESearchBar *search_bar) { - int row; - - g_return_if_fail (E_IS_SEARCH_BAR (search_bar)); - - row = find_id (search_bar->option_menu, id, "EsbItemId", NULL); - if (row == -1) - return; - - if (id>=0) - search_bar->last_search_option = id; - search_bar->item_id = id; - gtk_menu_set_active ((GtkMenu *)search_bar->option_menu, row); - - if (!search_bar->block_search) - emit_query_changed (search_bar); + g_return_val_if_fail (E_IS_SEARCH_BAR (search_bar), FALSE); - update_clear_menuitem_sensitive (search_bar); + return GTK_WIDGET_VISIBLE (search_bar->priv->search_entry); } void -e_search_bar_set_item_menu (ESearchBar *search_bar, int id) +e_search_bar_set_search_visible (ESearchBar *search_bar, + gboolean visible) { - int row; - GtkWidget *item; g_return_if_fail (E_IS_SEARCH_BAR (search_bar)); - row = find_id (search_bar->option_menu, id, "EsbItemId", &item); - if (row == -1) - return; + if (visible) { + gtk_widget_show (search_bar->priv->search_label); + gtk_widget_show (search_bar->priv->search_entry); + } else { + gtk_widget_hide (search_bar->priv->search_label); + gtk_widget_hide (search_bar->priv->search_entry); + } - gtk_menu_set_active ((GtkMenu *)search_bar->option_menu, row); - if (id>=0) - gtk_check_menu_item_set_active ((GtkCheckMenuItem *)item, TRUE); + g_object_notify (G_OBJECT (search_bar), "search-visible"); } -/** - * e_search_bar_set_search_scope: - * @search_bar: A search bar. - * @id: Identifier of the item to set. - * - * Sets the active item in the options menu of a search bar. - **/ -void -e_search_bar_set_search_scope (ESearchBar *search_bar, int id) +GtkRadioAction * +e_search_bar_get_scope_action (ESearchBar *search_bar) { - int row; - - g_return_if_fail (E_IS_SEARCH_BAR (search_bar)); + EActionComboBox *combo_box; - row = find_id (search_bar->scopeoption_menu, id, "EsbItemId", NULL); - if (row == -1) - return; + g_return_val_if_fail (E_IS_SEARCH_BAR (search_bar), NULL); - search_bar->scopeitem_id = id; - gtk_option_menu_set_history (GTK_OPTION_MENU (search_bar->scopeoption), row); + combo_box = E_ACTION_COMBO_BOX (search_bar->priv->scope_combo_box); - if (!search_bar->block_search) - emit_query_changed (search_bar); + return e_action_combo_box_get_action (combo_box); } - -/** - * e_search_bar_get_item_id: - * @search_bar: A search bar. - * - * Queries the currently selected item in the options menu of a search bar. - * - * Return value: Identifier of the selected item in the options menu. - **/ -int -e_search_bar_get_item_id (ESearchBar *search_bar) +void +e_search_bar_set_scope_action (ESearchBar *search_bar, + GtkRadioAction *action) { - GtkWidget *menu_item; - gint item_id; + EActionComboBox *combo_box; - g_return_val_if_fail (search_bar != NULL, -1); - g_return_val_if_fail (E_IS_SEARCH_BAR (search_bar), -1); + g_return_if_fail (E_IS_SEARCH_BAR (search_bar)); + g_return_if_fail (GTK_IS_RADIO_ACTION (action)); - menu_item = gtk_menu_get_active (GTK_MENU (search_bar->option_menu)); - item_id = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (menu_item), "EsbItemId")); - search_bar->item_id = item_id; + combo_box = E_ACTION_COMBO_BOX (search_bar->priv->scope_combo_box); - return search_bar->item_id; + e_action_combo_box_set_action (combo_box, action); + g_object_notify (G_OBJECT (search_bar), "scope-action"); } -/** - * e_search_bar_get_search_scope: - * @search_bar: A search bar. - * - * Queries the currently selected search type in the options menu of a search bar. - * - * Return value: Identifier of the selected item in the options menu. - **/ -int -e_search_bar_get_search_scope (ESearchBar *search_bar) +gint +e_search_bar_get_scope_value (ESearchBar *search_bar) { - GtkWidget *menu_item; - gint scopeitem_id; - - g_return_val_if_fail (search_bar != NULL, -1); - g_return_val_if_fail (E_IS_SEARCH_BAR (search_bar), -1); + EActionComboBox *combo_box; - menu_item = gtk_menu_get_active (GTK_MENU (search_bar->scopeoption_menu)); - scopeitem_id = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (menu_item), "EsbItemId")); + g_return_val_if_fail (E_IS_SEARCH_BAR (search_bar), 0); - search_bar->scopeitem_id = scopeitem_id; + combo_box = E_ACTION_COMBO_BOX (search_bar->priv->scope_combo_box); - return search_bar->scopeitem_id; + return e_action_combo_box_get_current_value (combo_box); } -/** - * e_search_bar_get_viewitem_id: - * @search_bar: A search bar. - * - * Queries the currently selected item in the viewoptions menu of a search bar. - * - * Return value: Identifier of the selected item in the viewoptions menu. - * If the search bar currently contains an entry rather than a a viewoption menu, - * a value less than zero is returned. - **/ -int -e_search_bar_get_viewitem_id (ESearchBar *search_bar) +void +e_search_bar_set_scope_value (ESearchBar *search_bar, + gint value) { - GtkWidget *menu_item; - gint viewitem_id; - - g_return_val_if_fail (search_bar != NULL, -1); - g_return_val_if_fail (E_IS_SEARCH_BAR (search_bar), -1); + EActionComboBox *combo_box; - if (!search_bar->viewoption_menu) - return -1; - - menu_item = gtk_menu_get_active (GTK_MENU (search_bar->viewoption_menu)); - viewitem_id = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (menu_item), "EsbItemId")); + g_return_if_fail (E_IS_SEARCH_BAR (search_bar)); - search_bar->viewitem_id = viewitem_id; + combo_box = E_ACTION_COMBO_BOX (search_bar->priv->scope_combo_box); - return search_bar->viewitem_id; + e_action_combo_box_set_current_value (combo_box, value); + g_object_notify (G_OBJECT (search_bar), "scope-value"); } -/** - * e_search_bar_set_ids: - * @search_bar: A search bar. - * @item_id: Identifier of the item to set. - * @subitem_id: Identifier of the subitem to set. - * - * Sets the item and subitem ids for a search bar. This is intended to switch - * to an item that has subitems. - **/ -void -e_search_bar_set_ids (ESearchBar *search_bar, int item_id, int subitem_id) +gboolean +e_search_bar_get_scope_visible (ESearchBar *search_bar) { - int item_row; - GtkWidget *item_widget; - - g_return_if_fail (search_bar != NULL); - g_return_if_fail (E_IS_SEARCH_BAR (search_bar)); - - item_row = find_id (search_bar->option_menu, item_id, "EsbChoiceId", &item_widget); - if (item_row == -1 || !item_widget) - return; - - search_bar->item_id = item_id; - gtk_option_menu_set_history (GTK_OPTION_MENU (search_bar->option), item_row); + g_return_val_if_fail (E_IS_SEARCH_BAR (search_bar), FALSE); + return GTK_WIDGET_VISIBLE (search_bar->priv->scope_combo_box); } -/** - * e_search_bar_set_text: - * @search_bar: A search bar. - * @text: Text to set in the search bar's entry line. - * - * Sets the text string inside the entry line of a search bar. - **/ void -e_search_bar_set_text (ESearchBar *search_bar, const char *text) +e_search_bar_set_scope_visible (ESearchBar *search_bar, + gboolean visible) { g_return_if_fail (E_IS_SEARCH_BAR (search_bar)); - gtk_entry_set_text (GTK_ENTRY (search_bar->entry), text); -} - -/** - * e_search_bar_get_text: - * @search_bar: A search bar. - * - * Queries the text of the entry line in a search bar. - * - * Return value: The text string that is in the entry line of the search bar. - * This must be freed using g_free(). If a suboption menu is active instead - * of an entry, NULL is returned. - **/ -char * -e_search_bar_get_text (ESearchBar *search_bar) -{ - GtkStyle *entry_style, *default_style; - - g_return_val_if_fail (search_bar != NULL, NULL); - g_return_val_if_fail (E_IS_SEARCH_BAR (search_bar), NULL); - - entry_style = gtk_widget_get_style (search_bar->entry); - default_style = gtk_widget_get_default_style (); - - if (gdk_color_equal (&(entry_style->text[GTK_STATE_NORMAL]), &(default_style->text[GTK_STATE_INSENSITIVE]))) - return g_strdup (""); - return g_strdup (gtk_entry_get_text (GTK_ENTRY (search_bar->entry))); -} - -void e_search_bar_scope_enable (ESearchBar *esb, int did, gboolean state) -{ - GtkWidget *widget=NULL; - GList *l ; - int id; - gpointer *pointer; - - g_return_if_fail (esb != NULL); - g_return_if_fail (E_IS_SEARCH_BAR (esb)); - - l = GTK_MENU_SHELL (esb->scopeoption_menu)->children; - while (l) { - pointer = g_object_get_data (l->data, "EsbItemId"); - if (pointer) { - id = GPOINTER_TO_INT (pointer); - if (id == did) { - widget = l->data; - break; - } - } - l = l->next; + if (visible) { + gtk_widget_show (search_bar->priv->scope_label); + gtk_widget_show (search_bar->priv->scope_combo_box); + } else { + gtk_widget_hide (search_bar->priv->scope_label); + gtk_widget_hide (search_bar->priv->scope_combo_box); } - if (widget) - gtk_widget_set_sensitive (widget, state); + g_object_notify (G_OBJECT (search_bar), "scope-visible"); } diff --git a/widgets/misc/e-search-bar.h b/widgets/misc/e-search-bar.h index f4a8ec93c2..56883e27bc 100644 --- a/widgets/misc/e-search-bar.h +++ b/widgets/misc/e-search-bar.h @@ -17,172 +17,87 @@ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ -#ifndef __E_SEARCH_BAR_H__ -#define __E_SEARCH_BAR_H__ + +#ifndef E_SEARCH_BAR_H +#define E_SEARCH_BAR_H #include <gtk/gtk.h> -#include <bonobo/bonobo-ui-component.h> +/* Standard GObject macros */ +#define E_TYPE_SEARCH_BAR \ + (e_search_bar_get_type ()) +#define E_SEARCH_BAR(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_SEARCH_BAR, ESearchBar)) +#define E_SEARCH_BAR_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_SEARCH_BAR, ESearchBarClass)) +#define E_IS_SEARCH_BAR(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_SEARCH_BAR)) +#define E_IS_SEARCH_BAR_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_SEARCH_BAR)) +#define E_SEARCH_BAR_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_SEARCH_BAR, ESearchBarClass)) + +/* Action Names */ +#define E_SEARCH_BAR_ACTION_CLEAR "search-clear" +#define E_SEARCH_BAR_ACTION_FIND "search-find" +#define E_SEARCH_BAR_ACTION_TYPE "search-type" G_BEGIN_DECLS -/* ESearchBar - A card displaying information about a contact. - * - * The following arguments are available: - * - * name type read/write description - * --------------------------------------------------------------------------------- - * item_id int RW Which option item is currently selected. - * subitem_id int RW Which option subitem is currently selected. - * text string RW Text in the entry box. - */ - -#define E_SEARCH_BAR_TYPE (e_search_bar_get_type ()) -#define E_SEARCH_BAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), E_SEARCH_BAR_TYPE, ESearchBar)) -#define E_SEARCH_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), E_SEARCH_BAR_TYPE, ESearchBarClass)) -#define E_IS_SEARCH_BAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), E_SEARCH_BAR_TYPE)) -#define E_IS_SEARCH_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), E_SEARCH_BAR_TYPE)) - -enum _ESearchBarItemType { - ESB_ITEMTYPE_NORMAL, - ESB_ITEMTYPE_CHECK, - ESB_ITEMTYPE_RADIO, -}; -typedef enum _ESearchBarItemType ESearchBarItemType; - -typedef struct { - char *text; - int id; - int type; -} ESearchBarItem; - -typedef struct _ESearchBar ESearchBar; -typedef struct _ESearchBarClass ESearchBarClass; - -typedef void (*ESearchBarMenuFunc)(ESearchBar *esb, ESearchBarItem *menu_items); +typedef struct _ESearchBar ESearchBar; +typedef struct _ESearchBarClass ESearchBarClass; +typedef struct _ESearchBarPrivate ESearchBarPrivate; struct _ESearchBar { GtkHBox parent; - - BonoboUIComponent *ui_component; - - GSList *menu_items; - - /* item specific fields */ - GtkWidget *option; - GtkWidget *entry; - GtkWidget *suboption; /* an option menu for the choices associated with some options */ - - /* PRIVATE */ - GtkWidget *dropdown_holder; /* holds the dropdown */ - GtkWidget *option_menu; - GtkWidget *suboption_menu; - GtkWidget *option_button; - GtkWidget *clear_button; - GtkWidget *entry_box; - GtkWidget *icon_entry; - - /* show option widgets */ - GtkWidget *viewoption_box; - GtkWidget *viewoption; /* an option menu for the choices associated with some search options */ - GtkWidget *viewoption_menu; - - /* search scope widgets */ - GtkWidget *scopeoption_box; - GtkWidget *scopeoption; /* an option menu for the choices associated with scope search */ - GtkWidget *scopeoption_menu; - - guint pending_activate; - - /* The currently-selected item & subitem */ - int item_id; - int viewitem_id; /* Current View Id */ - int scopeitem_id; /* Scope of search */ - int last_search_option; - - gboolean block_search; + ESearchBarPrivate *priv; }; struct _ESearchBarClass { GtkHBoxClass parent_class; - - void (*set_menu) (ESearchBar *, ESearchBarItem *); - void (*set_option) (ESearchBar *, ESearchBarItem *); - - /* signals */ - void (*search_activated) (ESearchBar *search); - void (*search_cleared) (ESearchBar *search); - void (*query_changed) (ESearchBar *search); - void (*menu_activated) (ESearchBar *search, int item); -}; - -enum { - E_SEARCHBAR_FIND_NOW_ID = -1, - E_SEARCHBAR_CLEAR_ID = -2 }; - -GType e_search_bar_get_type (void); -void e_search_bar_construct (ESearchBar *search_bar, - ESearchBarItem *menu_items, - ESearchBarItem *option_items); -GtkWidget *e_search_bar_new (ESearchBarItem *menu_items, - ESearchBarItem *option_items); - -void e_search_bar_set_ui_component (ESearchBar *search_bar, - BonoboUIComponent *ui_component); - -void e_search_bar_set_menu (ESearchBar *search_bar, - ESearchBarItem *menu_items); -void e_search_bar_add_menu (ESearchBar *search_bar, - ESearchBarItem *menu_item); - -void e_search_bar_set_option (ESearchBar *search_bar, - ESearchBarItem *option_items); -void e_search_bar_paint (ESearchBar *search_bar); -void e_search_bar_set_viewoption (ESearchBar *search_bar, - int option_id, - ESearchBarItem *subitems); - -void e_search_bar_set_menu_sensitive (ESearchBar *search_bar, - int id, - gboolean state); - -void e_search_bar_set_item_id (ESearchBar *search_bar, - int id); -void e_search_bar_set_item_menu (ESearchBar *search_bar, - int id); -int e_search_bar_get_item_id (ESearchBar *search_bar); - -int e_search_bar_get_viewitem_id (ESearchBar *search_bar); - -void e_search_bar_set_viewitem_id (ESearchBar *search_bar, int id); +GType e_search_bar_get_type (void); +GtkWidget * e_search_bar_new (void); +GtkActionGroup *e_search_bar_get_action_group (ESearchBar *search_bar); +GtkRadioAction *e_search_bar_get_filter_action (ESearchBar *search_bar); +void e_search_bar_set_filter_action (ESearchBar *search_bar, + GtkRadioAction *action); +gint e_search_bar_get_filter_value (ESearchBar *search_bar); +void e_search_bar_set_filter_value (ESearchBar *search_bar, + gint value); +gboolean e_search_bar_get_filter_visible (ESearchBar *search_bar); +void e_search_bar_set_filter_visible (ESearchBar *search_bar, + gboolean visible); +GtkRadioAction *e_search_bar_get_search_action (ESearchBar *search_bar); +void e_search_bar_set_search_action (ESearchBar *search_bar, + GtkRadioAction *action); +const gchar * e_search_bar_get_search_text (ESearchBar *search_bar); +void e_search_bar_set_search_text (ESearchBar *search_bar, + const gchar *text); +gint e_search_bar_get_search_value (ESearchBar *search_bar); +void e_search_bar_set_search_value (ESearchBar *search_bar, + gint value); +gboolean e_search_bar_get_search_visible (ESearchBar *search_bar); +void e_search_bar_set_search_visible (ESearchBar *search_bar, + gboolean visible); +GtkRadioAction *e_search_bar_get_scope_action (ESearchBar *search_bar); +void e_search_bar_set_scope_action (ESearchBar *search_bar, + GtkRadioAction *action); +gint e_search_bar_get_scope_value (ESearchBar *search_bar); +void e_search_bar_set_scope_value (ESearchBar *search_bar, + gint value); +gboolean e_search_bar_get_scope_visible (ESearchBar *search_bar); +void e_search_bar_set_scope_visible (ESearchBar *search_bar, + gboolean visible); -void e_search_bar_set_ids (ESearchBar *search_bar, - int item_id, - int subitem_id); - -void e_search_bar_set_scopeoption (ESearchBar *search_bar, ESearchBarItem *scopeitems); - -void e_search_bar_set_scopeoption_menu (ESearchBar *search_bar, GtkMenu *menu); - -void e_search_bar_set_search_scope (ESearchBar *search_bar, int id); - -void e_search_bar_set_viewoption_menu (ESearchBar *search_bar, GtkWidget *menu); - -void e_search_bar_set_viewoption_menufunc (ESearchBar *search_bar, ESearchBarMenuFunc *menu_gen_func, void *data); - -GtkWidget *e_search_bar_get_selected_viewitem (ESearchBar *search_bar); - -int e_search_bar_get_search_scope (ESearchBar *search_bar); - -void e_search_bar_set_text (ESearchBar *search_bar, - const char *text); -char *e_search_bar_get_text (ESearchBar *search_bar); -void e_search_bar_scope_enable (ESearchBar *search_bar, int did, gboolean state); G_END_DECLS - -#endif /* __E_SEARCH_BAR_H__ */ +#endif /* E_SEARCH_BAR_H */ diff --git a/widgets/misc/test-preferences-window.c b/widgets/misc/test-preferences-window.c index ddc99ff3ba..dc3d40be59 100644 --- a/widgets/misc/test-preferences-window.c +++ b/widgets/misc/test-preferences-window.c @@ -44,7 +44,7 @@ add_pages (EPreferencesWindow *preferences_window) e_preferences_window_add_page ( preferences_window, page_name, - "gtk-properties", caption, i, widget); + "gtk-properties", caption, widget, i); g_free (caption); g_free (page_name); |