1 files changed, 1333 insertions, 0 deletions
diff --git a/mate-dictionary/src/gdict-applet.c b/mate-dictionary/src/gdict-applet.c
new file mode 100644
index 00000000..442381a6
--- /dev/null
+++ b/mate-dictionary/src/gdict-applet.c
@@ -0,0 +1,1333 @@
+/* gdict-applet.c - MATE Dictionary Applet
+ *
+ * Copyright (c) 2005 Emmanuele Bassi <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ * 
+ * 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 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
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <glib/gi18n.h>
+#include <gdk/gdkkeysyms.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <gtk/gtk.h>
+#include <mateconf/mateconf-client.h>
+
+#include "gdict-applet.h"
+#include "gdict-about.h"
+#include "gdict-pref-dialog.h"
+#include "gdict-print.h"
+#include "gdict-common.h"
+#include "gdict-aligned-window.h"
+
+#define GDICT_APPLET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDICT_TYPE_APPLET, GdictAppletClass))
+#define GDICT_APPLET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDICT_TYPE_APPLET, GdictAppletClass))
+
+struct _GdictAppletClass
+{
+ MatePanelAppletClass parent_class;
+};
+
+#define GDICT_APPLET_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GDICT_TYPE_APPLET, GdictAppletPrivate))
+
+struct _GdictAppletPrivate
+{
+ guint size;
+ GtkOrientation orient;
+ 
+ MateConfClient *mateconf_client;
+ guint notify_id;
+ guint font_notify_id;
+
+ gchar *database;
+ gchar *strategy;
+ gchar *source_name; 
+ gchar *print_font;
+ gchar *defbox_font;
+
+ gchar *word; 
+ GdictContext *context;
+ guint lookup_start_id;
+ guint lookup_end_id;
+ guint error_id;
+
+ GdictSourceLoader *loader;
+
+ GtkWidget *box;
+ GtkWidget *toggle;
+ GtkWidget *image;
+ GtkWidget *entry;
+ GtkWidget *window;
+ GtkWidget *frame;
+ GtkWidget *defbox;
+
+ guint idle_draw_id;
+
+ GdkPixbuf *icon;
+
+ gint window_width;
+ gint window_height;
+
+ guint is_window_showing : 1;
+};
+
+#define WINDOW_MIN_WIDTH 300
+#define WINDOW_MIN_HEIGHT 200
+#define WINDOW_NUM_COLUMNS 47
+#define WINDOW_NUM_ROWS 20
+
+G_DEFINE_TYPE (GdictApplet, gdict_applet, PANEL_TYPE_APPLET);
+
+
+static const GtkTargetEntry drop_types[] =
+{
+ { "text/plain", 0, 0 },
+ { "TEXT", 0, 0 },
+ { "STRING", 0, 0 },
+ { "UTF8_STRING", 0, 0 },
+};
+static const guint n_drop_types = G_N_ELEMENTS (drop_types);
+
+
+static void
+set_atk_name_description (GtkWidget *widget,
+ const char *name,
+ const char *description)
+{ 
+ AtkObject *aobj;
+ 
+ aobj = gtk_widget_get_accessible (widget);
+ if (!GTK_IS_ACCESSIBLE (aobj))
+ return;
+
+ atk_object_set_name (aobj, name);
+ atk_object_set_description (aobj, description);
+}
+
+static void
+set_window_default_size (GdictApplet *applet)
+{
+ GdictAppletPrivate *priv = applet->priv;
+ GtkWidget *widget, *defbox;
+ gint width, height;
+ gint font_size;
+ GdkScreen *screen;
+ gint monitor_num;
+ GtkRequisition req;
+ GdkRectangle monitor;
+
+ if (!priv->window)
+ return;
+ 
+ widget = priv->window;
+ defbox = priv->defbox;
+
+ /* Size based on the font size */
+ font_size = pango_font_description_get_size (gtk_widget_get_style (defbox)->font_desc);
+ font_size = PANGO_PIXELS (font_size);
+
+ width = font_size * WINDOW_NUM_COLUMNS;
+ height = font_size * WINDOW_NUM_ROWS;
+
+ /* Use at least the requisition size of the window... */
+ gtk_widget_size_request (widget, &req);
+ width = MAX (width, req.width);
+ height = MAX (height, req.height);
+
+ /* ... but make it no larger than half the monitor size */
+ screen = gtk_widget_get_screen (widget);
+ monitor_num = gdk_screen_get_monitor_at_window (screen,
+ gtk_widget_get_window (widget));
+
+ gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
+
+ width = MIN (width, monitor.width / 2);
+ height = MIN (height, monitor.height / 2);
+
+ /* Set size */
+ gtk_widget_set_size_request (priv->frame, width, height);
+}
+
+static void
+clear_cb (GtkWidget *widget,
+ GdictApplet *applet)
+{
+ GdictAppletPrivate *priv = applet->priv;
+
+ gtk_entry_set_text (GTK_ENTRY (priv->entry), "");
+
+ if (!priv->defbox)
+ return;
+ 
+ gdict_defbox_clear (GDICT_DEFBOX (priv->defbox));
+}
+
+static void
+print_cb (GtkWidget *widget,
+ GdictApplet *applet)
+{
+ GdictAppletPrivate *priv = applet->priv;
+
+ if (!priv->defbox)
+ return;
+ 
+ gdict_show_print_dialog (GTK_WINDOW (priv->window),
+ GDICT_DEFBOX (priv->defbox));
+}
+
+static void
+save_cb (GtkWidget *widget,
+ GdictApplet *applet)
+{
+ GdictAppletPrivate *priv = applet->priv;
+ GtkWidget *dialog;
+
+ if (!priv->defbox)
+ return;
+ 
+ dialog = gtk_file_chooser_dialog_new (_("Save a Copy"),
+ GTK_WINDOW (priv->window),
+ GTK_FILE_CHOOSER_ACTION_SAVE,
+ GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+ GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
+ NULL);
+ gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
+ 
+ /* default to user's $HOME */
+ gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), g_get_home_dir ());
+ gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), _("Untitled document"));
+ 
+ if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
+ {
+ gchar *filename;
+ gchar *text;
+ gsize len;
+ GError *write_error = NULL;
+ 
+ filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
+ 
+ text = gdict_defbox_get_text (GDICT_DEFBOX (priv->defbox), &len);
+ 
+ g_file_set_contents (filename,
+ text,
+ len,
+ &write_error);
+ if (write_error)
+ {
+ gchar *message;
+ 
+ message = g_strdup_printf (_("Error while writing to '%s'"), filename);
+ 
+ gdict_show_error_dialog (GTK_WINDOW (priv->window),
+ message,
+ write_error->message);
+ 
+ g_error_free (write_error);
+ g_free (message);
+ }
+ 
+ g_free (text);
+ g_free (filename);
+ }
+
+ gtk_widget_destroy (dialog);
+}
+
+static void
+gdict_applet_set_menu_items_sensitive (GdictApplet *applet,
+ gboolean is_sensitive)
+{
+ MateComponentUIComponent *popup_component;
+ 
+ popup_component = mate_panel_applet_get_popup_component (MATE_PANEL_APPLET (applet));
+ if (!MATECOMPONENT_IS_UI_COMPONENT (popup_component))
+ return;
+
+ matecomponent_ui_component_set_prop (popup_component,
+ "/commands/Clear",
+ "sensitive", (is_sensitive ? "1" : "0"),
+ NULL);
+ matecomponent_ui_component_set_prop (popup_component,
+ "/commands/Print",
+ "sensitive", (is_sensitive ? "1" : "0"),
+ NULL);
+ matecomponent_ui_component_set_prop (popup_component,
+ "/commands/Save",
+ "sensitive", (is_sensitive ? "1" : "0"),
+ NULL);
+}
+
+static gboolean
+window_key_press_event_cb (GtkWidget *widget,
+ GdkEventKey *event,
+ gpointer user_data)
+{
+ GdictApplet *applet = GDICT_APPLET (user_data);
+ 
+ if (event->keyval == GDK_Escape)
+ {
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (applet->priv->toggle), FALSE);
+ gtk_toggle_button_toggled (GTK_TOGGLE_BUTTON (applet->priv->toggle));
+
+ return TRUE;
+ }
+ else if ((event->keyval == GDK_l) &&
+ (event->state & GDK_CONTROL_MASK))
+ {
+ gtk_widget_grab_focus (applet->priv->entry);
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static void
+window_show_cb (GtkWidget *window,
+ GdictApplet *applet)
+{
+ set_window_default_size (applet);
+}
+
+static void
+gdict_applet_build_window (GdictApplet *applet)
+{
+ GdictAppletPrivate *priv = applet->priv;
+ GtkWidget *window;
+ GtkWidget *frame;
+ GtkWidget *vbox;
+ GtkWidget *bbox;
+ GtkWidget *button;
+
+ if (!priv->entry)
+ {
+ g_warning ("No entry widget defined");
+
+ return;
+ }
+ 
+ window = gdict_aligned_window_new (priv->toggle);
+ g_signal_connect (window, "key-press-event",
+ G_CALLBACK (window_key_press_event_cb),
+ applet);
+ g_signal_connect (window, "show",
+ G_CALLBACK (window_show_cb),
+ applet);
+
+ frame = gtk_frame_new (NULL);
+ gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
+ gtk_container_add (GTK_CONTAINER (window), frame);
+ gtk_widget_show (frame);
+ priv->frame = frame;
+ 
+ vbox = gtk_vbox_new (FALSE, 12);
+ gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
+ gtk_container_add (GTK_CONTAINER (frame), vbox);
+ gtk_widget_show (vbox);
+ 
+ priv->defbox = gdict_defbox_new ();
+ if (priv->context)
+ gdict_defbox_set_context (GDICT_DEFBOX (priv->defbox), priv->context);
+ 
+ gtk_box_pack_start (GTK_BOX (vbox), priv->defbox, TRUE, TRUE, 0);
+ gtk_widget_show (priv->defbox);
+ gtk_widget_set_can_focus (priv->defbox, TRUE);
+ gtk_widget_set_can_default (priv->defbox, TRUE);
+ 
+ bbox = gtk_hbutton_box_new ();
+ gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END);
+ gtk_box_set_spacing (GTK_BOX (bbox), 6);
+ gtk_box_pack_end (GTK_BOX (vbox), bbox, FALSE, FALSE, 0);
+ gtk_widget_show (bbox);
+ 
+ button = gtk_button_new_from_stock (GTK_STOCK_CLEAR);
+ gtk_widget_set_tooltip_text (button, _("Clear the definitions found"));
+ set_atk_name_description (button,
+ _("Clear definition"),
+ _("Clear the text of the definition"));
+ 
+ g_signal_connect (button, "clicked", G_CALLBACK (clear_cb), applet);
+ gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
+ gtk_widget_show (button);
+
+ button = gtk_button_new_from_stock (GTK_STOCK_PRINT);
+ gtk_widget_set_tooltip_text (button, _("Print the definitions found"));
+ set_atk_name_description (button,
+ _("Print definition"),
+ _("Print the text of the definition"));
+ 
+ g_signal_connect (button, "clicked", G_CALLBACK (print_cb), applet);
+ gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
+ gtk_widget_show (button);
+
+ button = gtk_button_new_from_stock (GTK_STOCK_SAVE);
+ gtk_widget_set_tooltip_text (button, _("Save the definitions found"));
+ set_atk_name_description (button,
+ _("Save definition"),
+ _("Save the text of the definition to a file"));
+ 
+ g_signal_connect (button, "clicked", G_CALLBACK (save_cb), applet);
+ gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
+ gtk_widget_show (button);
+ 
+ gtk_window_set_default (GTK_WINDOW (window), priv->defbox);
+ 
+ priv->window = window;
+ priv->is_window_showing = FALSE;
+}
+
+static gboolean
+gdict_applet_icon_toggled_cb (GtkWidget *widget,
+ GdictApplet *applet)
+{
+ GdictAppletPrivate *priv = applet->priv;
+
+ if (!priv->window)
+ gdict_applet_build_window (applet);
+ 
+ if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
+ {
+ gtk_window_set_screen (GTK_WINDOW (priv->window),
+ gtk_widget_get_screen (GTK_WIDGET (applet)));
+ gtk_window_present (GTK_WINDOW (priv->window));
+ gtk_widget_grab_focus (priv->defbox);
+ 
+ priv->is_window_showing = TRUE;
+ }
+ else
+ {
+ /* force hiding the find pane */
+ gdict_defbox_set_show_find (GDICT_DEFBOX (priv->defbox), FALSE);
+
+ gtk_widget_grab_focus (priv->entry);
+ gtk_widget_hide (priv->window);
+ 
+ priv->is_window_showing = FALSE;
+ }
+
+ return FALSE;
+}
+
+static void
+gdict_applet_entry_activate_cb (GtkWidget *widget,
+ GdictApplet *applet)
+{
+ GdictAppletPrivate *priv = applet->priv;
+ gchar *text;
+ 
+ text = gtk_editable_get_chars (GTK_EDITABLE (widget), 0, -1);
+ if (!text)
+ return;
+ 
+ g_free (priv->word);
+ priv->word = text;
+ 
+ if (!priv->window)
+ gdict_applet_build_window (applet);
+
+ gdict_defbox_lookup (GDICT_DEFBOX (priv->defbox), priv->word);
+}
+
+static gboolean
+gdict_applet_entry_key_press_cb (GtkWidget *widget,
+ GdkEventKey *event,
+ gpointer user_data)
+{
+ GdictAppletPrivate *priv = GDICT_APPLET (user_data)->priv;
+ 
+ if (event->keyval == GDK_Escape)
+ {
+ if (priv->is_window_showing)
+ {
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->toggle), FALSE);
+ gtk_toggle_button_toggled (GTK_TOGGLE_BUTTON (priv->toggle));
+ 
+ return TRUE;
+ }
+ }
+ else if (event->keyval == GDK_Tab)
+ {
+ if (priv->is_window_showing)
+ gtk_widget_grab_focus (priv->defbox);
+ }
+
+ return FALSE;
+}
+
+static gboolean
+gdict_applet_icon_button_press_event_cb (GtkWidget *widget,
+ GdkEventButton *event,
+ GdictApplet *applet)
+{
+ GdictAppletPrivate *priv = applet->priv;
+ 
+ /* we don't want to block the applet's popup menu unless the
+ * user is toggling the button
+ */
+ if (event->button != 1)
+ g_signal_stop_emission_by_name (priv->toggle, "button-press-event");
+
+ return FALSE;
+}
+
+static gboolean
+gdict_applet_entry_button_press_event_cb (GtkWidget *widget,
+ GdkEventButton *event,
+ GdictApplet *applet)
+{
+ mate_panel_applet_request_focus (MATE_PANEL_APPLET (applet), event->time);
+
+ return FALSE;
+}
+
+static gboolean
+gdict_applet_draw (GdictApplet *applet)
+{
+ GdictAppletPrivate *priv = applet->priv;
+ GtkWidget *box;
+ GtkWidget *hbox;
+ gchar *text = NULL;
+
+ if (priv->entry)
+ text = gtk_editable_get_chars (GTK_EDITABLE (priv->entry), 0, -1);
+ 
+ if (priv->box)
+ gtk_widget_destroy (priv->box);
+
+ switch (priv->orient)
+ {
+ case GTK_ORIENTATION_VERTICAL:
+ box = gtk_vbox_new (FALSE, 0);
+ break;
+ case GTK_ORIENTATION_HORIZONTAL:
+ box = gtk_hbox_new (FALSE, 0);
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+ 
+ gtk_container_add (GTK_CONTAINER (applet), box);
+ gtk_widget_show (box);
+
+ /* toggle button */
+ priv->toggle = gtk_toggle_button_new ();
+ gtk_widget_set_tooltip_text (priv->toggle, _("Click to view the dictionary window"));
+ set_atk_name_description (priv->toggle,
+ _("Toggle dictionary window"),
+ _("Show or hide the definition window"));
+ 
+ gtk_button_set_relief (GTK_BUTTON (priv->toggle),
+ GTK_RELIEF_NONE);
+ g_signal_connect (priv->toggle, "toggled",
+ G_CALLBACK (gdict_applet_icon_toggled_cb),
+ applet);
+ g_signal_connect (priv->toggle, "button-press-event",
+ G_CALLBACK (gdict_applet_icon_button_press_event_cb),
+ applet);
+ gtk_box_pack_start (GTK_BOX (box), priv->toggle, FALSE, FALSE, 0);
+ gtk_widget_show (priv->toggle);
+
+ hbox = gtk_hbox_new (FALSE, 0);
+ gtk_container_set_border_width (GTK_CONTAINER (hbox), 0);
+ gtk_container_add (GTK_CONTAINER (priv->toggle), hbox);
+ gtk_widget_show (hbox);
+
+ if (priv->icon)
+ {
+ GdkPixbuf *scaled;
+ 
+ priv->image = gtk_image_new ();
+ gtk_image_set_pixel_size (GTK_IMAGE (priv->image), priv->size - 10);
+
+ scaled = gdk_pixbuf_scale_simple (priv->icon,
+ priv->size - 5,
+ priv->size - 5,
+ GDK_INTERP_BILINEAR);
+ 
+ gtk_image_set_from_pixbuf (GTK_IMAGE (priv->image), scaled);
+ g_object_unref (scaled);
+ 
+ gtk_box_pack_start (GTK_BOX (hbox), priv->image, FALSE, FALSE, 0);
+ 
+ gtk_widget_show (priv->image);
+ }
+ else
+ {
+ priv->image = gtk_image_new ();
+
+ gtk_image_set_pixel_size (GTK_IMAGE (priv->image), priv->size - 10);
+ gtk_image_set_from_stock (GTK_IMAGE (priv->image),
+ GTK_STOCK_MISSING_IMAGE,
+ -1);
+ 
+ gtk_box_pack_start (GTK_BOX (hbox), priv->image, FALSE, FALSE, 0);
+ gtk_widget_show (priv->image);
+ }
+
+ /* entry */
+ priv->entry = gtk_entry_new ();
+ gtk_widget_set_tooltip_text (priv->entry, _("Type the word you want to look up"));
+ set_atk_name_description (priv->entry,
+ _("Dictionary entry"),
+ _("Look up words in dictionaries"));
+ 
+ gtk_editable_set_editable (GTK_EDITABLE (priv->entry), TRUE);
+ gtk_entry_set_width_chars (GTK_ENTRY (priv->entry), 12);
+ g_signal_connect (priv->entry, "activate",
+ G_CALLBACK (gdict_applet_entry_activate_cb),
+ applet);
+ g_signal_connect (priv->entry, "button-press-event",
+ G_CALLBACK (gdict_applet_entry_button_press_event_cb),
+ applet);
+ g_signal_connect (priv->entry, "key-press-event",
+ G_CALLBACK (gdict_applet_entry_key_press_cb),
+ applet);
+ gtk_box_pack_end (GTK_BOX (box), priv->entry, FALSE, FALSE, 0);
+ gtk_widget_show (priv->entry);
+
+ if (text)
+ {
+ gtk_entry_set_text (GTK_ENTRY (priv->entry), text);
+
+ g_free (text);
+ }
+ 
+ priv->box = box;
+
+#if 0
+ gtk_widget_grab_focus (priv->entry);
+#endif
+ 
+ gtk_widget_show_all (GTK_WIDGET (applet));
+
+ return FALSE;
+}
+
+static void
+gdict_applet_queue_draw (GdictApplet *applet)
+{
+ if (!applet->priv->idle_draw_id)
+ applet->priv->idle_draw_id = g_idle_add ((GSourceFunc) gdict_applet_draw,
+ applet);
+}
+
+static void
+gdict_applet_lookup_start_cb (GdictContext *context,
+ GdictApplet *applet)
+{
+ GdictAppletPrivate *priv = applet->priv;
+
+ if (!priv->window)
+ gdict_applet_build_window (applet);
+
+ if (!priv->is_window_showing)
+ {
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->toggle), TRUE);
+ 
+ gtk_window_present (GTK_WINDOW (priv->window));
+ gtk_widget_grab_focus (priv->defbox);
+
+ priv->is_window_showing = TRUE;
+ }
+
+ gdict_applet_set_menu_items_sensitive (applet, FALSE);
+}
+
+static void
+gdict_applet_lookup_end_cb (GdictContext *context,
+ GdictApplet *applet)
+{
+ gdict_applet_set_menu_items_sensitive (applet, TRUE);
+
+ gtk_window_present (GTK_WINDOW (applet->priv->window));
+}
+
+static void
+gdict_applet_error_cb (GdictContext *context,
+ const GError *error,
+ GdictApplet *applet)
+{
+ /* disable menu items */
+ gdict_applet_set_menu_items_sensitive (applet, FALSE);
+}
+
+static void
+gdict_applet_cmd_lookup (MateComponentUIComponent *component,
+ GdictApplet *applet,
+ const gchar *cname)
+{
+ GdictAppletPrivate *priv = applet->priv;
+ gchar *text = NULL;;
+ 
+ text = gtk_editable_get_chars (GTK_EDITABLE (priv->entry), 0, -1);
+ if (!text)
+ return;
+ 
+ g_free (priv->word);
+ priv->word = text;
+ 
+ if (!priv->window)
+ gdict_applet_build_window (applet);
+ 
+ gdict_defbox_lookup (GDICT_DEFBOX (priv->defbox), priv->word);
+}
+
+static void
+gdict_applet_cmd_clear (MateComponentUIComponent *component,
+ GdictApplet *applet,
+ const gchar *cname)
+{
+ clear_cb (NULL, applet);
+}
+
+static void
+gdict_applet_cmd_print (MateComponentUIComponent *component,
+ GdictApplet *applet,
+ const gchar *cname)
+{
+ print_cb (NULL, applet);
+}
+
+static void
+gdict_applet_cmd_preferences (MateComponentUIComponent *component,
+ GdictApplet *applet,
+ const gchar *cname)
+{
+ gdict_show_pref_dialog (GTK_WIDGET (applet),
+ _("Dictionary Preferences"),
+ applet->priv->loader);
+}
+
+static void
+gdict_applet_cmd_about (MateComponentUIComponent *component,
+ GdictApplet *applet,
+ const gchar *cname)
+{
+ gdict_show_about_dialog (GTK_WIDGET (applet));
+}
+
+static void
+gdict_applet_cmd_help (MateComponentUIComponent *component,
+ GdictApplet *applet,
+ const gchar *cname)
+{
+ GError *err = NULL;
+
+ gtk_show_uri (gtk_widget_get_screen (GTK_WIDGET (applet)),
+ "ghelp:mate-dictionary#mate-dictionary-applet",
+ gtk_get_current_event_time (), &err);
+ 
+ if (err)
+ {
+ gdict_show_error_dialog (NULL,
+ _("There was an error while displaying help"),
+ err->message);
+ g_error_free (err);
+ }
+}
+
+static void
+gdict_applet_change_background (MatePanelApplet *applet,
+ MatePanelAppletBackgroundType type,
+ GdkColor *color,
+ GdkPixmap *pixmap)
+{
+ if (MATE_PANEL_APPLET_CLASS (gdict_applet_parent_class)->change_background)
+ MATE_PANEL_APPLET_CLASS (gdict_applet_parent_class)->change_background (applet,
+ type,
+ color,
+ pixmap);
+}
+
+static void
+gdict_applet_change_orient (MatePanelApplet *applet,
+ MatePanelAppletOrient orient)
+{
+ GdictAppletPrivate *priv = GDICT_APPLET (applet)->priv;
+ guint new_size;
+ GtkAllocation allocation;
+ 
+ gtk_widget_get_allocation (GTK_WIDGET (applet), &allocation);
+ switch (orient)
+ {
+ case MATE_PANEL_APPLET_ORIENT_LEFT:
+ case MATE_PANEL_APPLET_ORIENT_RIGHT:
+ priv->orient = GTK_ORIENTATION_VERTICAL;
+ new_size = allocation.width;
+ break;
+ case MATE_PANEL_APPLET_ORIENT_UP:
+ case MATE_PANEL_APPLET_ORIENT_DOWN:
+ priv->orient = GTK_ORIENTATION_HORIZONTAL;
+ new_size = allocation.height;
+ break;
+ }
+ 
+ if (new_size != priv->size)
+ priv->size = new_size;
+ 
+ gdict_applet_queue_draw (GDICT_APPLET (applet));
+ 
+ if (MATE_PANEL_APPLET_CLASS (gdict_applet_parent_class)->change_orient)
+ MATE_PANEL_APPLET_CLASS (gdict_applet_parent_class)->change_orient (applet,
+ orient);
+}
+
+static void
+gdict_applet_size_allocate (GtkWidget *widget,
+ GdkRectangle *allocation)
+{
+ GdictApplet *applet = GDICT_APPLET (widget);
+ GdictAppletPrivate *priv = applet->priv;
+ guint new_size;
+ 
+ if (priv->orient == GTK_ORIENTATION_HORIZONTAL)
+ new_size = allocation->height;
+ else
+ new_size = allocation->width;
+ 
+ if (priv->size != new_size)
+ {
+ priv->size = new_size;
+
+ gtk_image_set_pixel_size (GTK_IMAGE (priv->image), priv->size - 10);
+
+ /* re-scale the icon, if it was found */
+ if (priv->icon)
+ {
+ GdkPixbuf *scaled;
+
+ scaled = gdk_pixbuf_scale_simple (priv->icon,
+ priv->size - 5,
+ priv->size - 5,
+ GDK_INTERP_BILINEAR);
+ 
+ gtk_image_set_from_pixbuf (GTK_IMAGE (priv->image), scaled);
+ g_object_unref (scaled);
+ }
+ }
+
+ if (GTK_WIDGET_CLASS (gdict_applet_parent_class)->size_allocate)
+ GTK_WIDGET_CLASS (gdict_applet_parent_class)->size_allocate (widget,
+ allocation);
+}
+
+static void
+gdict_applet_style_set (GtkWidget *widget,
+ GtkStyle *old_style)
+{
+ if (GTK_WIDGET_CLASS (gdict_applet_parent_class)->style_set)
+ GTK_WIDGET_CLASS (gdict_applet_parent_class)->style_set (widget,
+ old_style);
+#if 0
+ set_window_default_size (GDICT_APPLET (widget));
+#endif
+}
+
+static void
+gdict_applet_set_database (GdictApplet *applet,
+ const gchar *database)
+{
+ GdictAppletPrivate *priv = applet->priv;
+ 
+ g_free (priv->database);
+
+ if (database)
+ priv->database = g_strdup (database);
+ else
+ priv->database = gdict_mateconf_get_string_with_default (priv->mateconf_client,
+ GDICT_MATECONF_DATABASE_KEY,
+ GDICT_DEFAULT_DATABASE);
+ if (priv->defbox)
+ gdict_defbox_set_database (GDICT_DEFBOX (priv->defbox),
+ priv->database);
+}
+
+static void
+gdict_applet_set_strategy (GdictApplet *applet,
+ const gchar *strategy)
+{
+ GdictAppletPrivate *priv = applet->priv;
+ 
+ g_free (priv->strategy);
+
+ if (strategy)
+ priv->strategy = g_strdup (strategy);
+ else
+ priv->strategy = gdict_mateconf_get_string_with_default (priv->mateconf_client,
+ GDICT_MATECONF_STRATEGY_KEY,
+ GDICT_DEFAULT_STRATEGY);
+}
+
+static GdictContext *
+get_context_from_loader (GdictApplet *applet)
+{
+ GdictAppletPrivate *priv = applet->priv;
+ GdictSource *source;
+ GdictContext *retval;
+
+ if (!priv->source_name)
+ priv->source_name = g_strdup (GDICT_DEFAULT_SOURCE_NAME);
+
+ source = gdict_source_loader_get_source (priv->loader,
+ priv->source_name);
+ if (!source)
+ {
+ gchar *detail;
+ 
+ detail = g_strdup_printf (_("No dictionary source available with name '%s'"),
+ priv->source_name);
+
+ gdict_show_error_dialog (NULL,
+ _("Unable to find dictionary source"),
+ NULL);
+ 
+ g_free (detail);
+
+ return NULL;
+ }
+ 
+ gdict_applet_set_database (applet, gdict_source_get_database (source));
+ gdict_applet_set_strategy (applet, gdict_source_get_strategy (source));
+ 
+ retval = gdict_source_get_context (source);
+ if (!retval)
+ {
+ gchar *detail;
+ 
+ detail = g_strdup_printf (_("No context available for source '%s'"),
+ gdict_source_get_description (source));
+ 
+ gdict_show_error_dialog (NULL,
+ _("Unable to create a context"),
+ detail);
+ 
+ g_free (detail);
+ g_object_unref (source);
+ 
+ return NULL;
+ }
+ 
+ g_object_unref (source);
+ 
+ return retval;
+}
+
+static void
+gdict_applet_set_print_font (GdictApplet *applet,
+ const gchar *print_font)
+{
+ GdictAppletPrivate *priv = applet->priv;
+
+ g_free (priv->print_font);
+
+ if (print_font)
+ priv->print_font = g_strdup (print_font);
+ else
+ priv->print_font = gdict_mateconf_get_string_with_default (priv->mateconf_client,
+ GDICT_MATECONF_PRINT_FONT_KEY,
+ GDICT_DEFAULT_PRINT_FONT);
+}
+
+static void
+gdict_applet_set_defbox_font (GdictApplet *applet,
+ const gchar *defbox_font)
+{
+ GdictAppletPrivate *priv = applet->priv;
+
+ g_free (priv->defbox_font);
+
+ if (defbox_font)
+ priv->defbox_font = g_strdup (defbox_font);
+ else
+ priv->defbox_font = gdict_mateconf_get_string_with_default (priv->mateconf_client,
+ DOCUMENT_FONT_KEY,
+ GDICT_DEFAULT_DEFBOX_FONT);
+
+ if (priv->defbox)
+ gdict_defbox_set_font_name (GDICT_DEFBOX (priv->defbox),
+ priv->defbox_font);
+}
+
+static void
+gdict_applet_set_context (GdictApplet *applet,
+ GdictContext *context)
+{
+ GdictAppletPrivate *priv = applet->priv;
+ 
+ if (priv->context)
+ {
+ g_signal_handler_disconnect (priv->context, priv->lookup_start_id);
+ g_signal_handler_disconnect (priv->context, priv->lookup_end_id);
+ g_signal_handler_disconnect (priv->context, priv->error_id);
+ 
+ priv->lookup_start_id = 0;
+ priv->lookup_end_id = 0;
+ priv->error_id = 0;
+ 
+ g_object_unref (priv->context);
+ priv->context = NULL;
+ }
+
+ if (priv->defbox)
+ gdict_defbox_set_context (GDICT_DEFBOX (priv->defbox), context);
+
+ if (!context)
+ return;
+ 
+ /* attach our callbacks */
+ priv->lookup_start_id = g_signal_connect (context, "lookup-start",
+ G_CALLBACK (gdict_applet_lookup_start_cb),
+ applet);
+ priv->lookup_end_id = g_signal_connect (context, "lookup-end",
+ G_CALLBACK (gdict_applet_lookup_end_cb),
+ applet);
+ priv->error_id = g_signal_connect (context, "error",
+ G_CALLBACK (gdict_applet_error_cb),
+ applet);
+ 
+ priv->context = context;
+}
+
+static void
+gdict_applet_set_source_name (GdictApplet *applet,
+ const gchar *source_name)
+{
+ GdictAppletPrivate *priv = applet->priv;
+ GdictContext *context;
+
+ g_free (priv->source_name);
+
+ if (source_name)
+ priv->source_name = g_strdup (source_name);
+ else
+ priv->source_name = gdict_mateconf_get_string_with_default (priv->mateconf_client,
+ GDICT_MATECONF_SOURCE_KEY,
+ GDICT_DEFAULT_SOURCE_NAME);
+ 
+ context = get_context_from_loader (applet);
+ gdict_applet_set_context (applet, context);
+}
+
+static void
+gdict_applet_mateconf_notify_cb (MateConfClient *client,
+ guint cnxn_id,
+ MateConfEntry *entry,
+ gpointer user_data)
+{
+ GdictApplet *applet = GDICT_APPLET (user_data);
+
+ if (strcmp (entry->key, GDICT_MATECONF_PRINT_FONT_KEY) == 0)
+ {
+ if (entry->value && (entry->value->type == MATECONF_VALUE_STRING))
+ gdict_applet_set_print_font (applet, mateconf_value_get_string (entry->value));
+ else
+ gdict_applet_set_print_font (applet, GDICT_DEFAULT_PRINT_FONT);
+ }
+ else if (strcmp (entry->key, GDICT_MATECONF_SOURCE_KEY) == 0)
+ {
+ if (entry->value && (entry->value->type == MATECONF_VALUE_STRING))
+ gdict_applet_set_source_name (applet, mateconf_value_get_string (entry->value));
+ else
+ gdict_applet_set_source_name (applet, GDICT_DEFAULT_SOURCE_NAME);
+ }
+ else if (strcmp (entry->key, GDICT_MATECONF_DATABASE_KEY) == 0)
+ {
+ if (entry->value && (entry->value->type == MATECONF_VALUE_STRING))
+ gdict_applet_set_database (applet, mateconf_value_get_string (entry->value));
+ else
+ gdict_applet_set_database (applet, GDICT_DEFAULT_DATABASE);
+ }
+ else if (strcmp (entry->key, GDICT_MATECONF_STRATEGY_KEY) == 0)
+ {
+ if (entry->value && (entry->value->type == MATECONF_VALUE_STRING))
+ gdict_applet_set_strategy (applet, mateconf_value_get_string (entry->value));
+ else
+ gdict_applet_set_strategy (applet, GDICT_DEFAULT_STRATEGY);
+ }
+ else if (strcmp (entry->key, DOCUMENT_FONT_KEY) == 0)
+ {
+ if (entry->value && (entry->value->type == MATECONF_VALUE_STRING))
+ gdict_applet_set_defbox_font (applet, mateconf_value_get_string (entry->value));
+ else
+ gdict_applet_set_defbox_font (applet, GDICT_DEFAULT_DEFBOX_FONT);
+ }
+}
+
+static void
+gdict_applet_finalize (GObject *object)
+{
+ GdictApplet *applet = GDICT_APPLET (object);
+ GdictAppletPrivate *priv = applet->priv;
+
+ if (priv->idle_draw_id)
+ g_source_remove (priv->idle_draw_id);
+
+ if (priv->notify_id)
+ mateconf_client_notify_remove (priv->mateconf_client, priv->notify_id);
+
+ if (priv->font_notify_id)
+ mateconf_client_notify_remove (priv->mateconf_client, priv->font_notify_id);
+ 
+ if (priv->mateconf_client)
+ g_object_unref (priv->mateconf_client);
+ 
+ if (priv->context)
+ {
+ if (priv->lookup_start_id)
+ {
+ g_signal_handler_disconnect (priv->context, priv->lookup_start_id);
+ g_signal_handler_disconnect (priv->context, priv->lookup_end_id);
+ g_signal_handler_disconnect (priv->context, priv->error_id);
+ }
+
+ g_object_unref (priv->context);
+ }
+ 
+ if (priv->loader)
+ g_object_unref (priv->loader);
+ 
+ if (priv->icon)
+ g_object_unref (priv->icon);
+ 
+ g_free (priv->source_name);
+ g_free (priv->print_font);
+ g_free (priv->defbox_font);
+ g_free (priv->word);
+ 
+ G_OBJECT_CLASS (gdict_applet_parent_class)->finalize (object);
+}
+
+static void
+gdict_applet_class_init (GdictAppletClass *klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+ MatePanelAppletClass *applet_class = MATE_PANEL_APPLET_CLASS (klass);
+ 
+ gobject_class->finalize = gdict_applet_finalize;
+ 
+ widget_class->size_allocate = gdict_applet_size_allocate;
+ widget_class->style_set = gdict_applet_style_set;
+ 
+ applet_class->change_background = gdict_applet_change_background;
+ applet_class->change_orient = gdict_applet_change_orient;
+ 
+ g_type_class_add_private (gobject_class, sizeof (GdictAppletPrivate));
+}
+
+static void
+gdict_applet_init (GdictApplet *applet)
+{
+ GdictAppletPrivate *priv;
+ gchar *data_dir;
+ GError *mateconf_error;
+
+ priv = GDICT_APPLET_GET_PRIVATE (applet);
+ applet->priv = priv;
+ 
+ if (!priv->loader)
+ priv->loader = gdict_source_loader_new ();
+
+ /* add our data dir inside $HOME to the loader's search paths */
+ data_dir = gdict_get_data_dir ();
+ gdict_source_loader_add_search_path (priv->loader, data_dir);
+ g_free (data_dir);
+ 
+ gtk_window_set_default_icon_name ("accessories-dictionary");
+ 
+ mate_panel_applet_set_flags (MATE_PANEL_APPLET (applet),
+ MATE_PANEL_APPLET_EXPAND_MINOR);
+ 
+ /* get the default mateconf client */
+ if (!priv->mateconf_client)
+ priv->mateconf_client = mateconf_client_get_default ();
+ 
+ mateconf_error = NULL;
+ mateconf_client_add_dir (priv->mateconf_client,
+ GDICT_MATECONF_DIR,
+ MATECONF_CLIENT_PRELOAD_ONELEVEL,
+ &mateconf_error);
+ if (mateconf_error)
+ {
+ gdict_show_gerror_dialog (NULL,
+ _("Unable to connect to MateConf"),
+ mateconf_error);
+ mateconf_error = NULL;
+ }
+ 
+ priv->notify_id = mateconf_client_notify_add (priv->mateconf_client,
+ GDICT_MATECONF_DIR,
+ gdict_applet_mateconf_notify_cb,
+ applet, NULL,
+ &mateconf_error);
+ if (mateconf_error)
+ {
+ gdict_show_gerror_dialog (NULL,
+ _("Unable to get notification for preferences"),
+ mateconf_error);
+
+ mateconf_error = NULL;
+ }
+ 
+ priv->font_notify_id = mateconf_client_notify_add (priv->mateconf_client,
+ DOCUMENT_FONT_KEY,
+ gdict_applet_mateconf_notify_cb,
+ applet, NULL,
+ &mateconf_error);
+ if (mateconf_error)
+ {
+ gdict_show_gerror_dialog (NULL,
+ _("Unable to get notification for the document font"),
+ mateconf_error);
+
+ mateconf_error = NULL;
+ }
+ 
+#ifndef GDICT_APPLET_STAND_ALONE
+ mate_panel_applet_set_background_widget (MATE_PANEL_APPLET (applet),
+ GTK_WIDGET (applet));
+
+ priv->size = mate_panel_applet_get_size (MATE_PANEL_APPLET (applet));
+
+ switch (mate_panel_applet_get_orient (MATE_PANEL_APPLET (applet)))
+ {
+ case MATE_PANEL_APPLET_ORIENT_LEFT:
+ case MATE_PANEL_APPLET_ORIENT_RIGHT:
+ priv->orient = GTK_ORIENTATION_VERTICAL;
+ break;
+ case MATE_PANEL_APPLET_ORIENT_UP:
+ case MATE_PANEL_APPLET_ORIENT_DOWN:
+ priv->orient = GTK_ORIENTATION_HORIZONTAL;
+ break;
+ }
+#else
+ priv->size = 24;
+ priv->orient = GTK_ORIENTATION_HORIZONTAL;
+ g_message ("(in %s) applet { size = %d, orient = %s }",
+ G_STRFUNC,
+ priv->size,
+ (priv->orient == GTK_ORIENTATION_HORIZONTAL ? "H" : "V"));
+#endif /* !GDICT_APPLET_STAND_ALONE */
+
+ priv->icon = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (),
+ "accessories-dictionary",
+ 48,
+ 0,
+ NULL);
+ 
+ /* force first draw */
+ gdict_applet_draw (applet);
+
+ /* force retrieval of the configuration from MateConf */
+ gdict_applet_set_source_name (applet, NULL);
+ gdict_applet_set_defbox_font (applet, NULL);
+ gdict_applet_set_print_font (applet, NULL);
+}
+
+#ifndef GDICT_APPLET_STAND_ALONE
+static const MateComponentUIVerb gdict_applet_menu_verbs[] =
+{
+ MATECOMPONENT_UI_UNSAFE_VERB ("LookUp", gdict_applet_cmd_lookup),
+ 
+ MATECOMPONENT_UI_UNSAFE_VERB ("Clear", gdict_applet_cmd_clear),
+ MATECOMPONENT_UI_UNSAFE_VERB ("Print", gdict_applet_cmd_print),
+ 
+ MATECOMPONENT_UI_UNSAFE_VERB ("Preferences", gdict_applet_cmd_preferences),
+ MATECOMPONENT_UI_UNSAFE_VERB ("Help", gdict_applet_cmd_help),
+ MATECOMPONENT_UI_UNSAFE_VERB ("About", gdict_applet_cmd_about),
+
+ MATECOMPONENT_UI_VERB_END
+};
+
+static gboolean
+gdict_applet_factory (MatePanelApplet *applet,
+ const gchar *iid,
+ gpointer data)
+{
+ gboolean retval = FALSE;
+
+ if (((!strcmp (iid, "OAFIID:MATE_DictionaryApplet")) ||
+ (!strcmp (iid, "OAFIID:MATE_GDictApplet"))) &&
+ gdict_create_data_dir ())
+ {
+ /* Set up the menu */
+ mate_panel_applet_setup_menu_from_file (applet, UIDATADIR,
+ "MATE_DictionaryApplet.xml",
+ NULL,
+ gdict_applet_menu_verbs,
+ applet);
+
+ gtk_widget_show (GTK_WIDGET (applet));
+
+ /* set the menu items insensitive */
+ gdict_applet_set_menu_items_sensitive (GDICT_APPLET (applet), FALSE);
+ 
+ retval = TRUE;
+ }
+
+ return retval;
+}
+
+/* this defines the main () for the applet */
+MATE_PANEL_APPLET_MATECOMPONENT_FACTORY ("OAFIID:MATE_DictionaryApplet_Factory",
+ GDICT_TYPE_APPLET,
+ "mate-dictionary-applet",
+ VERSION,
+ gdict_applet_factory,
+ NULL);
+
+#else /* GDICT_APPLET_STAND_ALONE */
+
+int
+main (int argc, char *argv[])
+{
+ GtkWidget *window;
+ GtkWidget *applet;
+
+ /* gettext stuff */
+ bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR);
+ bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+ textdomain (GETTEXT_PACKAGE);
+
+ gtk_init (&argc, &argv);
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
+
+ applet = GTK_WIDGET (g_object_new (GDICT_TYPE_APPLET, NULL));
+ g_message ("(in %s) typeof(applet) = '%s'",
+ G_STRFUNC,
+ g_type_name (G_OBJECT_TYPE (applet)));
+
+ gdict_applet_queue_draw (GDICT_APPLET (applet));
+ 
+ gtk_container_set_border_width (GTK_CONTAINER (window), 12);
+ gtk_container_add (GTK_CONTAINER (window), applet);
+ 
+ gtk_widget_show_all (window);
+ 
+ gtk_main ();
+ 
+ return 0;
+}
+
+#endif /* !GDICT_APPLET_STAND_ALONE */