evolution/e-util/e-plugin-util.c

/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) version 3.
 *
 * 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with the program; if not, see <http://www.gnu.org/licenses/>
 *
 *
 * Copyright (C) 1999-2010 Novell, Inc. (www.novell.com)
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <glib/gi18n.h>
#include <gtk/gtk.h>
#include <libsoup/soup.h>
#include <libedataserver/e-source.h>
#include <string.h>

#include "e-plugin-util.h"

/* name of a property on a widget with corresponding property name for an ESource */
#define EPU_SP_NAME "e-source-property-name"

#define EPU_CHECK_TRUE "epu-check-true-value"
#define EPU_CHECK_FALSE "epu-check-false-value"

static gboolean
epu_is_uri_proto (const gchar *uri,
                  const gchar *protocol)
{
	gboolean res;

	g_return_val_if_fail (uri != NULL, FALSE);
	g_return_val_if_fail (protocol != NULL, FALSE);

	res = uri && g_ascii_strncasecmp (uri, protocol, strlen (protocol)) == 0;

	if (res)
		res = strchr (protocol, ':') != NULL || uri[strlen (protocol)] == ':';

	return res;
}

/**
 * e_plugin_util_is_source_proto:
 * @source: #ESource object
 * @protocol: protocol to check on, like "http", "https", ...
 *
 * Returns whether given source's uri is of the given protocol.
 *
 * Returns: whether given source's uri is of the given protocol.
 **/
gboolean
e_plugin_util_is_source_proto (ESource *source,
                               const gchar *protocol)
{
	gchar *uri;
	gboolean res;

	g_return_val_if_fail (E_IS_SOURCE (source), FALSE);
	g_return_val_if_fail (protocol != NULL, FALSE);

	uri = e_source_get_uri (source);
	res = epu_is_uri_proto (uri, protocol);
	g_free (uri);

	return res;
}

/**
 * e_plugin_util_is_group_proto:
 * @group: #ESourceGroup object
 * @protocol: protocol to check on, like "http", "https", ...
 *
 * Returns whether given groups' base uri is of the given protocol.
 *
 * Returns: whether given groups' base uri is of the given protocol.
 **/
gboolean
e_plugin_util_is_group_proto (ESourceGroup *group,
                              const gchar *protocol)
{
	g_return_val_if_fail (E_IS_SOURCE_GROUP (group), FALSE);
	g_return_val_if_fail (protocol != NULL, FALSE);

	return epu_is_uri_proto (e_source_group_peek_base_uri (group), protocol);
}

/**
 * e_plugin_util_replace_at_sign:
 * @str: string to work with
 *
 * Replaces all '@' with '%40' in @str.
 *
 * Returns: a newly-allocated string
 **/
gchar *
e_plugin_util_replace_at_sign (const gchar *str)
{
	gchar *res, *at;

	if (!str)
		return NULL;

	res = g_strdup (str);
	while (at = strchr (res, '@'), at) {
		gchar *tmp = g_malloc0 (sizeof (gchar) * (1 + strlen (res) + 2));

		strncpy (tmp, res, at - res);
		strcat (tmp, "%40");
		strcat (tmp, at + 1);

		g_free (res);
		res = tmp;
	}

	return res;
}

/**
 * e_plugin_util_uri_no_proto:
 * @uri: #SoupURI object
 *
 * Returns uri encoded as string, without protocol part.
 * Returned pointer should be freed with g_free.
 *
 * Returns: uri encoded as string, without protocol part.
 **/
gchar *
e_plugin_util_uri_no_proto (SoupURI *uri)
{
	gchar *full_uri, *uri_noproto;
	const gchar *tmp;

	g_return_val_if_fail (uri != NULL, NULL);

	full_uri = soup_uri_to_string (uri, FALSE);
	g_return_val_if_fail (full_uri != NULL, NULL);

	tmp = strstr (full_uri, "://");
	if (tmp && tmp < strchr (full_uri, '/')) {
		uri_noproto = g_strdup (tmp + 3);
	} else {
		uri_noproto = full_uri;
		full_uri = NULL;
	}

	g_free (full_uri);

	return uri_noproto;
}

static void
epu_update_source_property (ESource *source,
                            GObject *object,
                            const gchar *value)
{
	const gchar *property_name;

	g_return_if_fail (E_IS_SOURCE (source));
	g_return_if_fail (G_IS_OBJECT (object));

	property_name = g_object_get_data (object, EPU_SP_NAME);
	g_return_if_fail (property_name != NULL);

	e_source_set_property (source, property_name, value);
}

static void
epu_entry_changed_cb (GObject *entry,
                      ESource *source)
{
	g_return_if_fail (GTK_IS_ENTRY (entry));

	epu_update_source_property (source, entry, gtk_entry_get_text (GTK_ENTRY (entry)));
}

static void
epu_check_toggled_cb (GObject *button,
                      ESource *source)
{
	const gchar *true_value, *false_value;

	g_return_if_fail (GTK_IS_TOGGLE_BUTTON (button));

	true_value = g_object_get_data (button, EPU_CHECK_TRUE);
	false_value = g_object_get_data (button, EPU_CHECK_FALSE);

	epu_update_source_property (source, button, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)) ? true_value : false_value);
}

/**
 * e_plugin_util_add_entry:
 * @parent: two-columns #GtkTable or #GtkContainer, where to add new entry
 * @label: label for the entry; can be NULL for no label
 * @source: #ESource object to which tight the entry change; can be NULL for no property binding
 * @source_property: source's property name to use for a value; can be NULL for no property binding
 *
 * Adds a #GtkEntry to the table at the last row or to the container, with a given label.
 * The entry will be always at the second column of the table.
 * Value of an entry will be prefilled with a property value of the given
 * source, and the source will be updated on any change of the entry automatically.
 * Entry is shown by default.
 *
 * Returns: pointer to newly added #GtkEntry
 **/
GtkWidget *
e_plugin_util_add_entry (GtkWidget *parent,
                         const gchar *label,
                         ESource *source,
                         const gchar *source_property)
{
	GtkWidget *entry, *lbl = NULL;
	const gchar *value;
	gint row = -1;

	g_return_val_if_fail (parent != NULL, NULL);
	g_return_val_if_fail (GTK_IS_TABLE (parent) || GTK_IS_CONTAINER (parent), NULL);

	if (source || source_property) {
		g_return_val_if_fail (E_IS_SOURCE (source), NULL);
		g_return_val_if_fail (source_property != NULL, NULL);
		g_return_val_if_fail (*source_property != 0, NULL);
	}

	if (GTK_IS_TABLE (parent))
		g_object_get (parent, "n-rows", &row, NULL);

	if (label) {
		lbl = gtk_label_new_with_mnemonic (label);
		gtk_widget_show (lbl);
		gtk_misc_set_alignment (GTK_MISC (lbl), 0.0, 0.5);
		if (row != -1)
			gtk_table_attach (GTK_TABLE (parent), lbl, 0, 1, row, row + 1, GTK_FILL, 0, 0, 0);
		else
			gtk_container_add (GTK_CONTAINER (parent), lbl);
	}

	if (source)
		value = e_source_get_property (source, source_property);
	else
		value = NULL;

	entry = gtk_entry_new ();
	gtk_widget_show (entry);
	gtk_entry_set_text (GTK_ENTRY (entry), value ? value : "");
	if (row != -1)
		gtk_table_attach (GTK_TABLE (parent), entry, 1, 2, row, row + 1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
	else
		gtk_container_add (GTK_CONTAINER (parent), entry);

	if (lbl)
		gtk_label_set_mnemonic_widget (GTK_LABEL (lbl), entry);

	if (source) {
		g_object_set_data_full (G_OBJECT (entry), EPU_SP_NAME, g_strdup (source_property), g_free);
		g_signal_connect (
			entry, "changed",
			G_CALLBACK (epu_entry_changed_cb), source);
	}

	return entry;
}

/**
 * e_plugin_util_add_check:
 * @parent: either two-columns #GtkTable or #GtkContainer where to add new check box; or NULL to just create it
 * @label: label for the check; cannot be NULL
 * @source: #ESource object to which tight the check change; can be NULL for no property binding
 * @source_property: source's property name to use for a value; can be NULL for no property binding
 * @true_value: what value use for a checked state in a source
 * @false_value: what value use for an unchecked state in a source
 *
 * Adds a #GtkCheckButton to the parent (if provided) at the last row, with a given label.
 * The check will be always at the second column of the table.
 * Value of a check will be prefilled with a property value of the given
 * source, and the source will be updated on any change of the check automatically.
 * Check is shown by default.
 *
 * Returns: pointer to newly added #GtkCheckButton
 **/
GtkWidget *
e_plugin_util_add_check (GtkWidget *parent,
                         const gchar *label,
                         ESource *source,
                         const gchar *source_property,
                         const gchar *true_value,
                         const gchar *false_value)
{
	GtkWidget *check;
	const gchar *value;
	guint row;

	g_return_val_if_fail (parent == NULL || GTK_IS_TABLE (parent) || GTK_IS_CONTAINER (parent), NULL);
	g_return_val_if_fail (label != NULL, NULL);

	if (source || source_property) {
		g_return_val_if_fail (source != NULL, NULL);
		g_return_val_if_fail (E_IS_SOURCE (source), NULL);
		g_return_val_if_fail (source_property != NULL, NULL);
		g_return_val_if_fail (*source_property != 0, NULL);
	}

	if (source)
		value = e_source_get_property (source, source_property);
	else
		value = NULL;

	check = gtk_check_button_new_with_mnemonic (label);
	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check),
		value && (value == true_value ||
			  (true_value && g_str_equal (value, true_value)) ||
			  (!source && g_str_equal (value, "1"))));
	gtk_widget_show (check);

	if (parent && GTK_IS_TABLE (parent)) {
		g_object_get (parent, "n-rows", &row, NULL);

		gtk_table_attach (GTK_TABLE (parent), check, 1, 2, row , row + 1, GTK_FILL, 0, 0, 0);
	} else if (parent) {
		gtk_container_add (GTK_CONTAINER (parent), check);
	}

	if (source) {
		g_object_set_data_full (G_OBJECT (check), EPU_SP_NAME, g_strdup (source_property), g_free);
		g_object_set_data_full (G_OBJECT (check), EPU_CHECK_TRUE, g_strdup (true_value), g_free);
		g_object_set_data_full (G_OBJECT (check), EPU_CHECK_FALSE, g_strdup (false_value), g_free);
		g_signal_connect (
			check, "toggled",
			G_CALLBACK (epu_check_toggled_cb), source);
	}

	return check;
}

static void
epu_update_refresh_value (GtkWidget *spin,
                          GtkWidget *combobox,
                          ESource *source)
{
	gchar *value;
	gint setting = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin));
	switch (gtk_combo_box_get_active (GTK_COMBO_BOX (combobox))) {
	case 0:
		/* minutes */
		break;
	case 1:
		/* hours */
		setting *= 60;
		break;
	case 2:
		/* days */
		setting *= 1440;
		break;
	case 3:
		/* weeks */
		setting *= 10080;
		break;
	default:
		g_warning ("%s: Time unit out of range", G_STRFUNC);
		break;
	}

	value = g_strdup_printf ("%d", setting);
	epu_update_source_property (source, G_OBJECT (spin), value);
	g_free (value);
}

static void
epu_refresh_spin_changed_cb (GtkWidget *spin,
                             ESource *source)
{
	g_return_if_fail (spin != NULL);
	g_return_if_fail (GTK_IS_SPIN_BUTTON (spin));

	epu_update_refresh_value (spin, g_object_get_data (G_OBJECT (spin), "refresh-combo"), source);
}

static void
epu_refresh_combo_changed_cb (GtkWidget *combobox,
                              ESource *source)
{
	g_return_if_fail (combobox != NULL);
	g_return_if_fail (GTK_IS_COMBO_BOX (combobox));

	epu_update_refresh_value (g_object_get_data (G_OBJECT (combobox), "refresh-spin"), combobox, source);
}

/**
 * e_plugin_util_add_refresh:
 * @parent: two-columns #GtkTable where to add new "refresh" setup widgets or NULL to just create an hbox
 * @label: label for the widgets; can be NULL, but for parent == NULL is ignored
 * @source: #ESource object to which tight the refresh change; cannot be NULL
 * @source_property: source's property name to use for a value; cannot be NULL
 *
 * Adds widgets to setup Refresh interval. The stored value is in minutes.
 * Returns pointer to an HBox, which contains two widgets, spin and a combo box.
 * Both can be accessed by g_object_get_data with a name "refresh-spin" and "refresh-combo".
 *
 * Returns: a new refresh control widget
 **/
GtkWidget *
e_plugin_util_add_refresh (GtkWidget *parent,
                           const gchar *label,
                           ESource *source,
                           const gchar *source_property)
{
	GtkWidget *lbl = NULL, *hbox, *spin, *combo;
	const gchar *value;
	gint row = -1, value_num, item_num = 0;

	g_return_val_if_fail (parent == NULL || GTK_IS_TABLE (parent), NULL);
	g_return_val_if_fail (E_IS_SOURCE (source), NULL);
	g_return_val_if_fail (source_property != NULL, NULL);
	g_return_val_if_fail (*source_property != 0, NULL);

	if (parent)
		g_object_get (parent, "n-rows", &row, NULL);

	value = e_source_get_property (source, source_property);
	if (!value) {
		value = "30";
		e_source_set_property (source, source_property, value);
	}

	if (label && parent) {
		lbl = gtk_label_new_with_mnemonic (label);
		gtk_widget_show (lbl);
		gtk_misc_set_alignment (GTK_MISC (lbl), 0.0, 0.5);
		gtk_table_attach (GTK_TABLE (parent), lbl, 0, 1, row, row + 1, GTK_FILL, 0, 0, 0);
	}

	hbox = gtk_hbox_new (FALSE, 6);
	gtk_widget_show (hbox);

	spin = gtk_spin_button_new_with_range (0, 100, 1);
	gtk_widget_show (spin);
	gtk_box_pack_start (GTK_BOX (hbox), spin, FALSE, TRUE, 0);

	combo = gtk_combo_box_text_new ();
	gtk_widget_show (combo);
	gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), _("minutes"));
	gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), _("hours"));
	gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), _("days"));
	gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), _("weeks"));
	gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, TRUE, 0);

	value_num = value ? atoi (value) : 30;

	if (value_num && !(value_num % 10080)) {
		/* weeks */
		item_num = 3;
		value_num /= 10080;
	} else if (value_num && !(value_num % 1440)) {
		/* days */
		item_num = 2;
		value_num /= 1440;
	} else if (value_num && !(value_num % 60)) {
		/* hours */
		item_num = 1;
		value_num /= 60;
	}

	gtk_combo_box_set_active (GTK_COMBO_BOX (combo), item_num);
	gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin), value_num);

	if (lbl)
		gtk_label_set_mnemonic_widget (GTK_LABEL (lbl), spin);

	g_object_set_data_full (G_OBJECT (spin), EPU_SP_NAME, g_strdup (source_property), g_free);

	g_object_set_data (G_OBJECT (combo), "refresh-spin", spin);
	g_object_set_data (G_OBJECT (spin), "refresh-combo", combo);
	g_object_set_data (G_OBJECT (hbox), "refresh-spin", spin);
	g_object_set_data (G_OBJECT (hbox), "refresh-combo", combo);
	g_signal_connect (
		combo, "changed",
		G_CALLBACK (epu_refresh_combo_changed_cb), source);
	g_signal_connect (
		spin, "value-changed",
		G_CALLBACK (epu_refresh_spin_changed_cb), source);

	if (parent)
		gtk_table_attach (GTK_TABLE (parent), hbox, 1, 2, row, row + 1, GTK_EXPAND | GTK_FILL, 0, 0, 0);

	return hbox;
}