initial

1 files changed, 876 insertions, 0 deletions

diff --git a/charpick/charpick.c b/charpick/charpick.c
new file mode 100644
index 00000000..6de91c57
--- /dev/null
+++ b/charpick/charpick.c
@@ -0,0 +1,876 @@
+/* charpick.c  This is a mate panel applet that allow users to select
+ * accented (and other) characters to be pasted into other apps.
+ */
+
+#include <config.h>
+#include <string.h>
+#include <mate-panel-applet.h>
+#ifdef HAVE_GUCHARMAP
+#	include <gucharmap/gucharmap.h>
+#endif
+#include "charpick.h"
+
+/* The comment for each char list has the html entity names of the chars */
+/* All gunicar codes should end in 0 */
+
+
+/* This is the default list used when starting charpick the first time */
+/* aacute, agrave, eacute, iacute, oacute, frac12, copy*/
+/* static const gchar *def_list = "áàéíñóœ©"; */
+static const gunichar def_code[] = {225, 224, 233, 237, 241, 243, 189, 169, 1579, 8364, 0};
+
+/* aacute, agrave, acirc, atilde, auml. aring, aelig, ordf */
+/* static const gchar *a_list = "áàâãäåæª"; */
+static const gunichar a_code[] = {225, 224, 226, 227, 228, 229, 230, 170, 0};
+/* static const gchar *cap_a_list = "ÁÀÂÃÄÅƪ"; */
+static const gunichar cap_a_code[] = {192, 193, 194, 195, 196, 197, 198, 170, 0}; 
+/* ccedil, cent, copy */
+/* static const gchar *c_list = "çÇ¢©"; */
+static const gunichar c_code[] = {231, 199, 162, 169, 0};
+/* eacute, egrave, ecirc, euml, aelig */
+/* static const gchar *e_list = "éèêëæ"; */
+static const gunichar e_code[] = {232, 233, 234, 235, 230, 0};
+/* static const gchar *cap_e_list = "ÉÈÊËÆ"; */
+static const gunichar cap_e_code[] = {200, 201, 202, 203, 198, 0};
+/* iacute, igrave, icirc, iuml */
+/* static const gchar *i_list = "íìîï"; */
+static const gunichar i_code[] = {236, 237, 238, 239, 0};
+/* static const gchar *cap_i_list = "ÍÌÎÏ"; */
+static const gunichar cap_i_code[] = {204, 205, 206, 207, 0};
+/* ntilde (this is the most important line in this program.) */
+/* static const gchar *n_list = "ñ, Ñ"; */
+static const gunichar n_code[] = {241, 209, 0};
+/* oacute, ograve, ocirc, otilde, ouml, oslash, ordm */
+/* static const gchar *o_list = "óòôõöøº"; */
+static const gunichar o_code[] = {242, 243, 244, 245, 246, 248, 176, 0};
+/* static const gchar *cap_o_list = "ÓÒÔÕÖغ"; */
+static const gunichar cap_o_code[] = {210, 211, 212, 213, 214, 216, 176, 0};
+/* szlig, sect, dollar */
+/* static const gchar *s_list = "ߧ$"; */
+static const gunichar s_code[] = {223, 167, 36, 0};
+/* eth, thorn */
+/* static const gchar *t_list = "ðÐþÞ"; */
+static const gunichar t_code[] = {240, 208, 254, 222, 0};
+/* uacute, ugrave, ucirc, uuml */
+/* static const gchar *u_list = "úùûü"; */
+static const gunichar u_code[] = {249, 250, 251, 252, 0};
+/* static const gchar *cap_u_list = "ÚÙÛÜ"; */
+static const gunichar cap_u_code[] = {217, 218, 219, 220, 0};
+/* yacute, yuml, yen Yes, there is no capital yuml in iso 8859-1.*/
+/* static const gchar *y_list = "ýÝÿ¥"; */
+static const gunichar y_code[] = {253, 221, 255, 165, 0};
+
+/* extra characters unrelated to the latin alphabet. All characters in 
+   ISO-8859-1 should now be accounted for.*/
+/* not shy macr plusmn */
+/* static const gchar *dash_list = "¬­¯±"; */
+static const gunichar dash_code[] = {172, 173, 175, 177, 0};
+/* laquo raquo uml */
+/* static const gchar *quote_list = "«»š·×"; */
+static const gunichar quote_code[] = {171, 187, 168, 183, 215, 0};
+/* curren, pound, yen, cent, dollar */
+/* static const gchar *currency_list = "€£¥¢$"; */
+static const gunichar currency_code[] = {164, 163, 165, 162, 36, 8364, 0}; 
+/* sup1 frac12 */
+/* static const gchar *one_list = "¹œŒ"; */
+static const gunichar one_code[] = {185, 178, 179, 188, 189, 190, 0};
+/* µ ¶ ® ¿ ¡ |  */
+static const gunichar misc_code[] = {181, 182, 174, 191, 161, 124, 0};
+
+/* language/region specific character groups */
+/* South Africa: Venda, Tswana and Northern Sotho */
+/* static const gchar *ZA_list = "ḓḽṋṱḒḼṊṰṅṄšŠ"; */
+static const gunichar ZA_code[] = {7699, 7741, 7755, 7793, 7698, 7740, 7754, 7792, 7749, 7748, 353, 352, 0};
+/* South Africa: Afrikaans */
+/* static const gchar *af_ZA_list = "áéíóúýêîôûèäëïöüÁÉÍÓÚÝÊÎÔÛÈÄËÏÖÜ"; */
+static const gunichar af_ZA_code[] = {225, 233, 237, 243, 250, 253, 234, 238, 244, 251, 232, 228, 235, 239, 246, 252, 193, 201, 205, 211, 218, 221, 202, 206, 212, 219, 200, 196, 203, 207, 214, 220, 0};
+
+
+static const gunichar * const chartable[] = {
+	def_code,
+	a_code,
+	cap_a_code,
+	c_code,
+	e_code,
+	cap_e_code,
+	i_code,
+	cap_i_code,
+	n_code,
+	o_code,
+	cap_o_code,
+	s_code,
+	t_code,
+	u_code,
+	cap_u_code,
+	y_code,
+	dash_code,
+	quote_code,
+	currency_code,
+	one_code,
+	misc_code,
+	ZA_code,
+	af_ZA_code
+};
+
+gboolean
+key_writable (MatePanelApplet *applet, const char *key)
+{
+	gboolean writable;
+	char *fullkey;
+	static MateConfClient *client = NULL;
+	if (client == NULL)
+		client = mateconf_client_get_default ();
+
+	fullkey = mate_panel_applet_mateconf_get_full_key (applet, key);
+
+	writable = mateconf_client_key_is_writable (client, fullkey, NULL);
+
+	g_free (fullkey);
+
+	return writable;
+}
+
+
+/* sets the picked character as the selection when it gets a request */
+static void
+charpick_selection_handler(GtkWidget *widget,
+			   GtkSelectionData *selection_data,
+			   guint info,
+			   guint time,
+		           gpointer data)
+{
+  charpick_data *p_curr_data = data;
+  gint num;
+  gchar tmp[7];
+  num = g_unichar_to_utf8 (p_curr_data->selected_unichar, tmp);
+  tmp[num] = '\0';
+  
+  gtk_selection_data_set_text (selection_data, tmp, -1);
+
+  return;
+}
+
+/* untoggles the active toggle_button when we lose the selection */
+static gint
+selection_clear_cb (GtkWidget *widget, GdkEventSelection *event,
+                    gpointer data)
+{
+  charpick_data *curr_data = data;
+  
+  if (curr_data->last_toggle_button)
+    gtk_toggle_button_set_active (curr_data->last_toggle_button, FALSE);
+
+  curr_data->last_toggle_button = NULL;
+  return TRUE;
+}
+
+
+static gint
+toggle_button_toggled_cb(GtkToggleButton *button, gpointer data)
+{
+  charpick_data *curr_data = data;
+  gint button_index;
+  gboolean toggled;
+   
+  button_index = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (button), "index")); 
+  toggled = gtk_toggle_button_get_active (button); 
+
+  if (toggled)
+  { 
+    gunichar unichar;
+    if (curr_data->last_toggle_button && (button != curr_data->last_toggle_button))
+    	gtk_toggle_button_set_active (curr_data->last_toggle_button,
+    				      FALSE);
+    				      
+    curr_data->last_toggle_button = button; 
+    gtk_widget_grab_focus(curr_data->applet);
+    unichar = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (button), "unichar"));
+    curr_data->selected_unichar = unichar;
+    /* set this? widget as the selection owner */
+    gtk_selection_owner_set (curr_data->applet,
+	  		     GDK_SELECTION_PRIMARY,
+                             GDK_CURRENT_TIME); 
+    gtk_selection_owner_set (curr_data->applet,
+	  		     GDK_SELECTION_CLIPBOARD,
+                             GDK_CURRENT_TIME); 
+    curr_data->last_index = button_index;
+  }	
+	     
+  return TRUE;
+}
+
+/* This is a hack around the fact that gtk+ doesn't
+ * propogate button presses on button2/3.
+ */
+static gboolean
+button_press_hack (GtkWidget      *widget,
+		   GdkEventButton *event,
+		   GtkWidget      *applet)
+{
+    if (event->button == 3 || event->button == 2) {
+	gtk_propagate_event (applet, (GdkEvent *) event);
+
+	return TRUE;
+    }
+
+    return FALSE;
+}
+
+static gint
+key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
+{
+#if 0
+  charpick_data *p_curr_data = data;
+  const gunichar *code = NULL;
+  gchar inputchar = event->keyval;
+
+  switch (inputchar)
+    {
+    case 'a' : code = a_code;
+               break;
+    case 'A' : code = cap_a_code;
+               break;
+    case 'c' : 
+    case 'C' : code = c_code;
+               break;
+    case 'e' : code = e_code;
+               break;
+    case 'E' : code = cap_e_code;
+               break;
+    case 'i' : code = i_code;
+               break;
+    case 'I' : code =  cap_i_code;
+               break;
+    case 'n' : 
+    case 'N' : code = n_code;
+               break;
+    case 'o' : code = o_code;
+               break;
+    case 'O' : code = cap_o_code;
+               break;
+    case 's' : code = s_code;
+               break;
+    case 't' : 
+    case 'T' : code = t_code;
+               break;
+    case 'u' : code = u_code;
+               break;
+    case 'U' : code = cap_u_code;
+               break;
+    case 'y' : 
+    case 'Y' : code = y_code;
+               break;
+    case '-' : code = dash_code;
+               break;
+    case '\"' : code = quote_code;
+               break;
+    case '$' : code = currency_code;
+               break;
+    case '1' : 
+    case '2' :
+    case '3' : code = one_code;
+               break;
+    case 'd' : code = NULL;
+               break;
+    default :
+    		return FALSE;
+    }
+  /* FIXME: what's wrong here ? */
+  if (code)
+    p_curr_data->charlist = g_ucs4_to_utf8 (code, -1, NULL, NULL, NULL);
+  else
+    p_curr_data->charlist = "hello";
+  p_curr_data->last_index = NO_LAST_INDEX;
+  p_curr_data->last_toggle_button = NULL;
+  build_table(p_curr_data);
+#endif
+  return FALSE;
+}
+
+static void
+menuitem_activated (GtkMenuItem *menuitem, charpick_data *curr_data)
+{
+	gchar *string;
+	MatePanelApplet *applet = MATE_PANEL_APPLET (curr_data->applet);
+	
+	string = g_object_get_data (G_OBJECT (menuitem), "string");
+	if (g_ascii_strcasecmp (curr_data->charlist, string) == 0)
+		return;
+	
+	curr_data->charlist = string;
+	build_table (curr_data);
+	if (key_writable (applet, "current_list"))
+		mate_panel_applet_mateconf_set_string (applet, "current_list", curr_data->charlist, NULL);
+}
+
+void
+populate_menu (charpick_data *curr_data)
+{
+	GList *list = curr_data->chartable;
+	GSList *group = NULL;
+	GtkMenu *menu;
+	GtkWidget *menuitem;
+
+	if (curr_data->menu)
+		gtk_widget_destroy (curr_data->menu);
+
+	curr_data->menu = gtk_menu_new ();
+	menu  = GTK_MENU (curr_data->menu);
+	
+	while (list) {
+		gchar *string = list->data;
+		menuitem = gtk_radio_menu_item_new_with_label (group, string);
+		group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem));
+		gtk_widget_show (menuitem);
+		g_object_set_data (G_OBJECT (menuitem), "string", string);
+		g_signal_connect (G_OBJECT (menuitem), "activate",
+				   G_CALLBACK (menuitem_activated), curr_data);
+		gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
+		if (g_ascii_strcasecmp (curr_data->charlist, string) == 0)
+			gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
+		list = g_list_next (list);
+	}
+	build_table(curr_data);
+}
+
+static void
+get_menu_pos (GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer data)
+{
+	charpick_data *curr_data = data;
+	GtkRequisition  reqmenu;
+	gint tempx, tempy, width, height;
+	gint screen_width, screen_height;
+	
+	gtk_widget_size_request (GTK_WIDGET (menu), &reqmenu);
+	gdk_window_get_origin (GDK_WINDOW (gtk_widget_get_window(curr_data->applet)), &tempx, &tempy);
+     	gdk_window_get_geometry (GDK_WINDOW (gtk_widget_get_window(curr_data->applet)), NULL, NULL,
+     				 &width, &height, NULL);
+     			      
+     	switch (mate_panel_applet_get_orient (MATE_PANEL_APPLET (curr_data->applet))) {
+     	case MATE_PANEL_APPLET_ORIENT_DOWN:
+        	tempy += height;
+     		break;
+     	case MATE_PANEL_APPLET_ORIENT_UP:
+        	tempy -= reqmenu.height;
+     		break;
+     	case MATE_PANEL_APPLET_ORIENT_LEFT:
+     		tempx -= reqmenu.width;
+		break;
+     	case MATE_PANEL_APPLET_ORIENT_RIGHT:
+     		tempx += width;
+		break;
+     	}
+	screen_width = gdk_screen_width ();
+     	screen_height = gdk_screen_height ();
+     	*x = CLAMP (tempx, 0, MAX (0, screen_width - reqmenu.width));
+     	*y = CLAMP (tempy, 0, MAX (0, screen_height - reqmenu.height));
+}
+
+static void
+chooser_button_clicked (GtkButton *button, charpick_data *curr_data)
+{
+	if (gtk_widget_get_visible (curr_data->menu))
+		gtk_menu_popdown (GTK_MENU (curr_data->menu));
+	else {
+		gtk_menu_set_screen (GTK_MENU (curr_data->menu),
+				gtk_widget_get_screen (GTK_WIDGET (curr_data->applet)));
+		
+		gtk_menu_popup (GTK_MENU (curr_data->menu), NULL, NULL, get_menu_pos, curr_data,
+				0, gtk_get_current_event_time());
+	}				    
+}
+
+/* Force the button not to have any focus padding and let the focus
+   indication be drawn on the label itself when space is tight. Taken from the clock applet.
+   FIXME : This is an Evil Hack and should be fixed when the focus padding can be overridden at the gtk+ level */
+
+static inline void force_no_focus_padding (GtkWidget *widget)
+{
+  gboolean first_time=TRUE;
+
+  if (first_time) {
+    gtk_rc_parse_string ("\n"
+			 "   style \"charpick-applet-button-style\"\n"
+			 "   {\n"
+			 "      GtkWidget::focus-line-width=0\n"
+			 "      GtkWidget::focus-padding=0\n"
+			 "   }\n"
+			 "\n"
+			 "    widget \"*.charpick-applet-button\" style \"charpick-applet-button-style\"\n"
+			 "\n");
+    first_time = FALSE;
+  }
+
+  gtk_widget_set_name (widget, "charpick-applet-button");
+}
+
+/* creates table of buttons, sets up their callbacks, and packs the table in
+   the event box */
+
+void
+build_table(charpick_data *p_curr_data)
+{
+  GtkWidget *box, *button_box, **row_box;
+  GtkWidget *button, *arrow;
+  gint i = 0, len = g_utf8_strlen (p_curr_data->charlist, -1);
+  GtkWidget **toggle_button;
+  gchar *charlist;
+  gint max_width=1, max_height=1;
+  gint size_ratio;
+
+  toggle_button = g_new (GtkWidget *, len);
+  
+  if (p_curr_data->box)
+    gtk_widget_destroy(p_curr_data->box);
+    
+  if (p_curr_data->panel_vertical)
+    box = gtk_vbox_new (FALSE, 0);
+  else 
+    box = gtk_hbox_new (FALSE, 0);
+  gtk_widget_show (box);
+  p_curr_data->box = box;
+  
+  button = gtk_button_new ();
+  if (g_list_length (p_curr_data->chartable) != 1)
+  {
+    gtk_widget_set_tooltip_text (button, _("Available palettes"));
+  
+    switch (mate_panel_applet_get_orient (MATE_PANEL_APPLET (p_curr_data->applet))) {
+       	case MATE_PANEL_APPLET_ORIENT_DOWN:
+          	arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_OUT);
+       		break;
+       	case MATE_PANEL_APPLET_ORIENT_UP:
+          	arrow = gtk_arrow_new (GTK_ARROW_UP, GTK_SHADOW_OUT);  
+       		break;
+       	case MATE_PANEL_APPLET_ORIENT_LEFT:
+       		arrow = gtk_arrow_new (GTK_ARROW_LEFT, GTK_SHADOW_OUT);  
+  		break;
+       	case MATE_PANEL_APPLET_ORIENT_RIGHT:
+       		arrow = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_OUT);  
+  		break;
+    default:
+  	  g_assert_not_reached ();
+    }
+    gtk_container_add (GTK_CONTAINER (button), arrow);
+    gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
+    /* FIXME : evil hack (see force_no_focus_padding) */
+    force_no_focus_padding (button);
+    gtk_box_pack_start (GTK_BOX (box), button, TRUE, TRUE, 0);
+    g_signal_connect (G_OBJECT (button), "clicked",
+                              G_CALLBACK (chooser_button_clicked),
+			      p_curr_data);
+    g_signal_connect (G_OBJECT (button), "button_press_event",
+                               G_CALLBACK (button_press_hack),
+			       p_curr_data->applet);
+  
+  }
+  
+  charlist = g_strdup (p_curr_data->charlist);
+  for (i = 0; i < len; i++) {
+    gchar label[7];
+    GtkRequisition req;
+    gchar *atk_desc;
+    gchar *name;
+    
+    g_utf8_strncpy (label, charlist, 1);
+    charlist = g_utf8_next_char (charlist);
+
+#ifdef HAVE_GUCHARMAP
+    /* TRANSLATOR: This sentance reads something like 'Insert "PILCROW SIGN"'
+     *             hopefully, the name of the unicode character has already
+     *             been translated.
+     */
+    name = g_strdup_printf (_("Insert \"%s\""),
+		    gucharmap_get_unicode_name (g_utf8_get_char (label)));
+#else
+    name = g_strdup (_("Insert special character"));
+#endif
+   
+    toggle_button[i] = gtk_toggle_button_new_with_label (label);
+    atk_desc =  g_strdup_printf (_("insert special character %s"), label);
+    set_atk_name_description (toggle_button[i], NULL, atk_desc);
+    g_free (atk_desc);
+    gtk_widget_show (toggle_button[i]);
+    gtk_button_set_relief(GTK_BUTTON(toggle_button[i]), GTK_RELIEF_NONE);
+    /* FIXME : evil hack (see force_no_focus_padding) */
+    force_no_focus_padding (toggle_button[i]);
+    gtk_widget_set_tooltip_text (toggle_button[i], name);
+    g_free (name);
+                      
+    gtk_widget_size_request (toggle_button[i], &req);
+    
+    max_width = MAX (max_width, req.width);
+    max_height = MAX (max_height, req.height-2);
+  
+    g_object_set_data (G_OBJECT (toggle_button[i]), "unichar", 
+				GINT_TO_POINTER(g_utf8_get_char (label)));
+    g_signal_connect (GTK_OBJECT (toggle_button[i]), "toggled",
+		      G_CALLBACK (toggle_button_toggled_cb),
+                        p_curr_data);
+    g_signal_connect (GTK_OBJECT (toggle_button[i]), "button_press_event", 
+                      G_CALLBACK (button_press_hack), p_curr_data->applet);
+  }
+  
+  if (p_curr_data->panel_vertical) {
+    size_ratio = p_curr_data->panel_size / max_width;
+    button_box = gtk_hbox_new (TRUE, 0);
+  } else {
+    size_ratio = p_curr_data->panel_size / max_height;
+    button_box = gtk_vbox_new (TRUE, 0);
+  }
+
+  gtk_box_pack_start (GTK_BOX (box), button_box, TRUE, TRUE, 0);
+  
+  size_ratio = MAX (size_ratio, 1);
+  row_box = g_new0 (GtkWidget *, size_ratio);
+  for (i=0; i < size_ratio; i++) {
+  	if (!p_curr_data->panel_vertical) row_box[i] = gtk_hbox_new (TRUE, 0);
+  	else row_box[i] = gtk_vbox_new (TRUE, 0);
+  	gtk_box_pack_start (GTK_BOX (button_box), row_box[i], TRUE, TRUE, 0);
+  }
+  
+  for (i = 0; i <len; i++) {  	
+  	int delta = len/size_ratio;
+  	int index;
+  
+	if (delta > 0)
+	  	index = i / delta;
+	else
+		index = i;
+
+	index = CLAMP (index, 0, size_ratio-1);	
+  	gtk_box_pack_start (GTK_BOX (row_box[index]), toggle_button[i], TRUE, TRUE, 0);
+  }
+ 
+  g_free (toggle_button);
+  
+  gtk_container_add (GTK_CONTAINER(p_curr_data->applet), box);
+  gtk_widget_show_all (p_curr_data->box);
+
+  p_curr_data->last_index = NO_LAST_INDEX;
+  p_curr_data->last_toggle_button = NULL;
+  
+}
+
+static void applet_size_allocate(MatePanelApplet *applet, GtkAllocation *allocation, gpointer data)
+{
+  charpick_data *curr_data = data;
+  if (curr_data->panel_vertical) {
+    if (curr_data->panel_size == allocation->width)
+      return;
+    curr_data->panel_size = allocation->width;
+  } else {
+    if (curr_data->panel_size == allocation->height)
+      return;
+    curr_data->panel_size = allocation->height;
+  }
+
+  build_table (curr_data);
+  return;
+}
+
+static void applet_change_orient(MatePanelApplet *applet, MatePanelAppletOrient o, gpointer data)
+{
+  charpick_data *curr_data = data;
+  if (o == MATE_PANEL_APPLET_ORIENT_UP ||
+      o == MATE_PANEL_APPLET_ORIENT_DOWN)
+    curr_data->panel_vertical = FALSE;
+  else
+    curr_data->panel_vertical = TRUE;
+  build_table (curr_data);
+  return;
+}
+
+
+static void
+about (GtkAction     *action,
+       charpick_data *curr_data)
+{
+  static const char * const authors[] = {
+	  "Alexandre Muñiz <[email protected]>",
+	  "Kevin Vandersloot",
+	  NULL
+  };
+
+  static const gchar * const documenters[] = {
+          "Dan Mueth <[email protected]>",
+          "Sun MATE Documentation Team <[email protected]>",
+	  NULL
+  };
+
+  gtk_show_about_dialog (NULL,
+	"version",	VERSION,
+	"copyright",	"\xC2\xA9 1998, 2004-2005 MATE Applets Maintainers "
+			"and others",
+	"comments",	_("Mate Panel applet for selecting strange "
+			  "characters that are not on my keyboard. "
+			  "Released under GNU General Public Licence."),
+	"authors",	authors,
+	"documenters",	documenters,
+	"translator-credits",	_("translator-credits"),
+	"logo-icon-name",	"accessories-character-map",
+	NULL);
+}
+
+
+static void
+help_cb (GtkAction     *action,
+	 charpick_data *curr_data)
+{
+  GError *error = NULL;
+
+  gtk_show_uri (gtk_widget_get_screen (GTK_WIDGET (curr_data->applet)),
+                "ghelp:char-palette",
+                gtk_get_current_event_time (),
+                &error);
+
+  if (error) { /* FIXME: the user needs to see this */
+    g_warning ("help error: %s\n", error->message);
+    g_error_free (error);
+    error = NULL;
+  }
+}
+
+static void
+applet_destroy (GtkWidget *widget, gpointer data)
+{
+  charpick_data *curr_data = data;
+
+  g_return_if_fail (curr_data);
+   
+  if (curr_data->about_dialog)
+    gtk_widget_destroy (curr_data->about_dialog);   
+  if (curr_data->propwindow)
+    gtk_widget_destroy (curr_data->propwindow);
+  if (curr_data->box)
+    gtk_widget_destroy (curr_data->box);
+  if (curr_data->menu)
+    gtk_widget_destroy (curr_data->menu);
+  g_free (curr_data);
+  
+}
+
+void 
+save_chartable (charpick_data *curr_data)
+{
+	MatePanelApplet *applet = MATE_PANEL_APPLET (curr_data->applet);
+	MateConfValue *value;
+	GList *list = curr_data->chartable;
+	GSList *slist = NULL;
+	
+	while (list) {
+		gchar *charlist = list->data;
+		MateConfValue *v1;
+		v1 = mateconf_value_new_from_string (MATECONF_VALUE_STRING, charlist, NULL);
+		slist = g_slist_append (slist, v1);
+		list = g_list_next (list);
+	}
+	
+	value = mateconf_value_new (MATECONF_VALUE_LIST);
+	mateconf_value_set_list_type (value, MATECONF_VALUE_STRING);
+	mateconf_value_set_list_nocopy (value, slist);
+	mate_panel_applet_mateconf_set_value (applet, "chartable", value, NULL);
+	mateconf_value_free (value);
+}
+
+static void
+get_chartable (charpick_data *curr_data)
+{
+	MatePanelApplet *applet = MATE_PANEL_APPLET (curr_data->applet);
+	MateConfValue *value;
+	gint i, n;
+	
+	value = mate_panel_applet_mateconf_get_value (applet, "chartable", NULL);
+	if (value) {
+		GSList *slist = mateconf_value_get_list (value);
+		while (slist) {
+			MateConfValue *v1 = slist->data;
+			gchar *charlist;
+			
+			charlist = g_strdup (mateconf_value_get_string (v1));
+			curr_data->chartable = g_list_append (curr_data->chartable, charlist);
+			
+			slist = g_slist_next (slist);
+		}
+		mateconf_value_free (value);
+	}
+	else {
+		n = G_N_ELEMENTS (chartable);
+		for (i=0; i<n; i++) {
+			gchar *string;
+		
+			string = g_ucs4_to_utf8 (chartable[i], -1, NULL, NULL, NULL);
+			curr_data->chartable = g_list_append (curr_data->chartable, string);
+		
+		}
+		if ( ! key_writable (MATE_PANEL_APPLET (curr_data->applet), "chartable"))
+			save_chartable (curr_data);
+	}
+	
+
+}
+
+static const GtkActionEntry charpick_applet_menu_actions [] = {
+	{ "Preferences", GTK_STOCK_PROPERTIES, N_("_Preferences"),
+	  NULL, NULL,
+	  G_CALLBACK (show_preferences_dialog) },
+	{ "Help", GTK_STOCK_HELP, N_("_Help"),
+	  NULL, NULL,
+	  G_CALLBACK (help_cb) },
+	{ "About", GTK_STOCK_ABOUT, N_("_About"),
+	  NULL, NULL,
+	  G_CALLBACK (about) }
+};
+
+void
+set_atk_name_description (GtkWidget *widget, const gchar *name,
+                          const gchar *description)
+{
+  AtkObject *aobj;
+  aobj = gtk_widget_get_accessible (widget);
+  /* return if gail is not loaded */
+  if (GTK_IS_ACCESSIBLE (aobj) == FALSE)
+     return;
+  if (name)
+     atk_object_set_name (aobj, name);
+  if (description)
+     atk_object_set_description (aobj, description);
+}
+
+static void
+make_applet_accessible (GtkWidget *applet)
+{
+  set_atk_name_description (applet, _("Character Palette"), _("Insert characters"));
+}
+
+static gboolean
+charpicker_applet_fill (MatePanelApplet *applet)
+{
+  MatePanelAppletOrient orientation;
+  charpick_data *curr_data;
+  GdkAtom utf8_atom;
+  GList *list;
+  gchar *string;
+  GtkActionGroup *action_group;
+  gchar *ui_path;
+
+  g_set_application_name (_("Character Palette"));
+  
+  gtk_window_set_default_icon_name ("accessories-character-map");
+
+  mate_panel_applet_set_background_widget (applet, GTK_WIDGET (applet));
+
+  mate_panel_applet_add_preferences (applet, "/schemas/apps/charpick/prefs", NULL);
+  mate_panel_applet_set_flags (applet, MATE_PANEL_APPLET_EXPAND_MINOR);
+   
+  curr_data = g_new0 (charpick_data, 1);
+  curr_data->last_index = NO_LAST_INDEX;
+  curr_data->applet = GTK_WIDGET (applet);
+  curr_data->about_dialog = NULL;
+  curr_data->add_edit_dialog = NULL;
+ 
+  get_chartable (curr_data);
+  
+  string  = mate_panel_applet_mateconf_get_string (applet, "current_list", NULL);
+  if (string) {
+  	list = curr_data->chartable;
+  	while (list) {
+  		if (g_ascii_strcasecmp (list->data, string) == 0)
+  			curr_data->charlist = list->data;
+  		list = g_list_next (list);
+  	}
+	/* FIXME: yeah leak, but this code is full of leaks and evil
+	   point shuffling.  This should really be rewritten
+	   -George */
+	if (curr_data->charlist == NULL)
+		curr_data->charlist = string;
+	else
+		g_free (string);
+  } else {
+  	curr_data->charlist = curr_data->chartable->data;  
+  }
+ 
+  curr_data->panel_size = mate_panel_applet_get_size (applet);
+  
+  orientation = mate_panel_applet_get_orient (applet);
+  curr_data->panel_vertical = (orientation == MATE_PANEL_APPLET_ORIENT_LEFT) 
+                              || (orientation == MATE_PANEL_APPLET_ORIENT_RIGHT);
+  build_table (curr_data);
+    
+  g_signal_connect (G_OBJECT (curr_data->applet), "key_press_event",
+		             G_CALLBACK (key_press_event), curr_data);
+
+  utf8_atom = gdk_atom_intern ("UTF8_STRING", FALSE);
+  gtk_selection_add_target (curr_data->applet, 
+			    GDK_SELECTION_PRIMARY,
+                            utf8_atom,
+			    0);
+  gtk_selection_add_target (curr_data->applet, 
+			    GDK_SELECTION_CLIPBOARD,
+                            utf8_atom,
+			    0);
+  g_signal_connect (GTK_OBJECT (curr_data->applet), "selection_get",
+		      G_CALLBACK (charpick_selection_handler),
+		      curr_data);
+  g_signal_connect (GTK_OBJECT (curr_data->applet), "selection_clear_event",
+		      G_CALLBACK (selection_clear_cb),
+		      curr_data);
+ 
+  make_applet_accessible (GTK_WIDGET (applet));
+
+  /* session save signal */ 
+  g_signal_connect (G_OBJECT (applet), "change_orient",
+		    G_CALLBACK (applet_change_orient), curr_data);
+
+  g_signal_connect (G_OBJECT (applet), "size_allocate",
+		    G_CALLBACK (applet_size_allocate), curr_data);
+		    
+  g_signal_connect (G_OBJECT (applet), "destroy",
+  		    G_CALLBACK (applet_destroy), curr_data);
+  
+  gtk_widget_show_all (GTK_WIDGET (applet));
+
+  action_group = gtk_action_group_new ("Charpicker Applet Actions");
+  gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
+  gtk_action_group_add_actions (action_group,
+				charpick_applet_menu_actions,
+				G_N_ELEMENTS (charpick_applet_menu_actions),
+				curr_data);
+  ui_path = g_build_filename (CHARPICK_MENU_UI_DIR, "charpick-applet-menu.xml", NULL);
+  mate_panel_applet_setup_menu_from_file (MATE_PANEL_APPLET (applet),
+                                     ui_path, action_group);
+  g_free (ui_path);
+
+  if (mate_panel_applet_get_locked_down (MATE_PANEL_APPLET (applet))) {
+	  GtkAction *action;
+
+	  action = gtk_action_group_get_action (action_group, "Preferences");
+	  gtk_action_set_visible (action, FALSE);
+  }
+  g_object_unref (action_group);
+
+  register_stock_for_edit ();			             
+  populate_menu (curr_data);
+  
+  return TRUE;
+}
+
+static gboolean
+charpicker_applet_factory (MatePanelApplet *applet,
+			   const gchar          *iid,
+			   gpointer              data)
+{
+	gboolean retval = FALSE;
+    
+	if (!strcmp (iid, "CharpickerApplet"))
+		retval = charpicker_applet_fill (applet); 
+    
+	return retval;
+}
+
+MATE_PANEL_APPLET_OUT_PROCESS_FACTORY ("CharpickerAppletFactory",
+				  PANEL_TYPE_APPLET,
+				  "char-palette",
+				  charpicker_applet_factory,
+				  NULL)
+