moving from https://github.com/perberos/mate-desktop-environment

1 files changed, 716 insertions, 0 deletions

diff --git a/libslab/libslab-utils.c b/libslab/libslab-utils.c
new file mode 100644
index 00000000..80bf6472
--- /dev/null
+++ b/libslab/libslab-utils.c
@@ -0,0 +1,716 @@
+#include "libslab-utils.h"
+
+#ifdef HAVE_CONFIG_H
+#	include <config.h>
+#endif
+
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <time.h>
+#include <sys/stat.h>
+#include <sys/resource.h>
+#include <sys/time.h>
+#include <mateconf/mateconf-value.h>
+#include <gtk/gtk.h>
+
+#define DESKTOP_ITEM_TERMINAL_EMULATOR_FLAG "TerminalEmulator"
+#define ALTERNATE_DOCPATH_KEY               "DocPath"
+
+static FILE *checkpoint_file;
+
+gboolean
+libslab_gtk_image_set_by_id (GtkImage *image, const gchar *id)
+{
+	GdkPixbuf *pixbuf;
+
+	gint size;
+	gint width;
+	gint height;
+
+	GtkIconTheme *icon_theme;
+
+	gboolean found;
+
+	gchar *tmp;
+
+
+	if (! id)
+		return FALSE;
+
+	g_object_get (G_OBJECT (image), "icon-size", & size, NULL);
+
+	if (size == GTK_ICON_SIZE_INVALID)
+		size = GTK_ICON_SIZE_DND;
+
+	gtk_icon_size_lookup (size, & width, & height);
+
+	if (g_path_is_absolute (id)) {
+		pixbuf = gdk_pixbuf_new_from_file_at_size (id, width, height, NULL);
+
+		found = (pixbuf != NULL);
+
+		if (found) {
+			gtk_image_set_from_pixbuf (image, pixbuf);
+
+			g_object_unref (pixbuf);
+		}
+		else
+			gtk_image_set_from_stock (image, "gtk-missing-image", size);
+	}
+	else {
+		tmp = g_strdup (id);
+
+		if ( /* file extensions are not copesetic with loading by "name" */
+			g_str_has_suffix (tmp, ".png") ||
+			g_str_has_suffix (tmp, ".svg") ||
+			g_str_has_suffix (tmp, ".xpm")
+		)
+
+			tmp [strlen (tmp) - 4] = '\0';
+
+		if (gtk_widget_has_screen (GTK_WIDGET (image)))
+			icon_theme = gtk_icon_theme_get_for_screen (
+				gtk_widget_get_screen (GTK_WIDGET (image)));
+		else
+			icon_theme = gtk_icon_theme_get_default ();
+
+		found = gtk_icon_theme_has_icon (icon_theme, tmp);
+
+		if (found)
+			gtk_image_set_from_icon_name (image, tmp, size);
+		else
+			gtk_image_set_from_stock (image, "gtk-missing-image", size);
+
+		g_free (tmp);
+	}
+
+	return found;
+}
+
+MateDesktopItem *
+libslab_mate_desktop_item_new_from_unknown_id (const gchar *id)
+{
+	MateDesktopItem *item;
+	gchar            *basename;
+
+	GError *error = NULL;
+
+
+	if (! id)
+		return NULL;
+
+	item = mate_desktop_item_new_from_uri (id, 0, & error);
+
+	if (! error)
+		return item;
+	else {
+		g_error_free (error);
+		error = NULL;
+	}
+
+	item = mate_desktop_item_new_from_file (id, 0, & error);
+
+	if (! error)
+		return item;
+	else {
+		g_error_free (error);
+		error = NULL;
+	}
+
+	item = mate_desktop_item_new_from_basename (id, 0, & error);
+
+	if (! error)
+		return item;
+	else {
+		g_error_free (error);
+		error = NULL;
+	}
+
+	basename = g_strrstr (id, "/");
+
+	if (basename) {
+		basename++;
+
+		item = mate_desktop_item_new_from_basename (basename, 0, &error);
+
+		if (! error)
+			return item;
+		else {
+			g_error_free (error);
+			error = NULL;
+		}
+	}
+
+	return NULL;
+}
+
+gboolean
+libslab_mate_desktop_item_launch_default (MateDesktopItem *item)
+{
+	GError *error = NULL;
+
+	if (! item)
+		return FALSE;
+
+	mate_desktop_item_launch (item, NULL, MATE_DESKTOP_ITEM_LAUNCH_ONLY_ONE, & error);
+
+	if (error) {
+		g_warning ("error launching %s [%s]\n",
+			mate_desktop_item_get_location (item), error->message);
+
+		g_error_free (error);
+
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+gchar *
+libslab_mate_desktop_item_get_docpath (MateDesktopItem *item)
+{
+	gchar *path;
+
+	path = g_strdup (mate_desktop_item_get_localestring (item, MATE_DESKTOP_ITEM_DOC_PATH));
+
+	if (! path)
+		path = g_strdup (mate_desktop_item_get_localestring (item, ALTERNATE_DOCPATH_KEY));
+
+	return path;
+}
+
+/* Ugh, here we don't have knowledge of the screen that is being used.  So, do
+ * what we can to find it.
+ */
+GdkScreen *
+libslab_get_current_screen (void)
+{
+	GdkEvent *event;
+	GdkScreen *screen = NULL;
+
+	event = gtk_get_current_event ();
+	if (event) {
+		if (event->any.window)
+			screen = gdk_drawable_get_screen (GDK_DRAWABLE (event->any.window));
+
+		gdk_event_free (event);
+	}
+
+	if (!screen)
+		screen = gdk_screen_get_default ();
+
+	return screen;
+}
+
+gboolean
+libslab_mate_desktop_item_open_help (MateDesktopItem *item)
+{
+	gchar *doc_path;
+	gchar *help_uri;
+
+	GError *error = NULL;
+
+	gboolean retval = FALSE;
+
+
+	if (! item)
+		return retval;
+
+	doc_path = libslab_mate_desktop_item_get_docpath (item);
+
+	if (doc_path) {
+		help_uri = g_strdup_printf ("ghelp:%s", doc_path);
+
+		if (!gtk_show_uri (libslab_get_current_screen (), help_uri, gtk_get_current_event_time (), &error)) {
+			g_warning ("error opening %s [%s]\n", help_uri, error->message);
+
+			g_error_free (error);
+
+			retval = FALSE;
+		}
+		else
+			retval = TRUE;
+
+		g_free (help_uri);
+		g_free (doc_path);
+	}
+
+	return retval;
+}
+
+guint32
+libslab_get_current_time_millis ()
+{
+	GTimeVal t_curr;
+
+	g_get_current_time (& t_curr);
+
+	return 1000L * t_curr.tv_sec + t_curr.tv_usec / 1000L;
+}
+
+gint
+libslab_strcmp (const gchar *a, const gchar *b)
+{
+	if (! a && ! b)
+		return 0;
+
+	if (! a)
+		return strcmp ("", b);
+
+	if (! b)
+		return strcmp (a, "");
+
+	return strcmp (a, b);
+}
+
+gint
+libslab_strlen (const gchar *a)
+{
+	if (! a)
+		return 0;
+
+	return strlen (a);
+}
+
+gpointer
+libslab_get_mateconf_value (const gchar *key)
+{
+	MateConfClient *client;
+	MateConfValue  *value;
+	GError      *error = NULL;
+
+	gpointer retval = NULL;
+
+	GList  *list;
+	GSList *slist;
+
+	MateConfValue *value_i;
+	GSList     *node;
+
+
+	client = mateconf_client_get_default ();
+	value  = mateconf_client_get (client, key, & error);
+
+	if (error || ! value)
+		libslab_handle_g_error (& error, "%s: error getting %s", G_STRFUNC, key);
+	else {
+		switch (value->type) {
+			case MATECONF_VALUE_STRING:
+				retval = (gpointer) g_strdup (mateconf_value_get_string (value));
+				break;
+
+			case MATECONF_VALUE_INT:
+				retval = GINT_TO_POINTER (mateconf_value_get_int (value));
+				break;
+
+			case MATECONF_VALUE_BOOL:
+				retval = GINT_TO_POINTER (mateconf_value_get_bool (value));
+				break;
+
+			case MATECONF_VALUE_LIST:
+				list = NULL;
+				slist = mateconf_value_get_list (value);
+
+				for (node = slist; node; node = node->next) {
+					value_i = (MateConfValue *) node->data;
+
+					if (value_i->type == MATECONF_VALUE_STRING)
+						list = g_list_append (
+							list, g_strdup (
+								mateconf_value_get_string (value_i)));
+					else if (value_i->type == MATECONF_VALUE_INT)
+						list = g_list_append (
+							list, GINT_TO_POINTER (
+								mateconf_value_get_int (value_i)));
+					else
+						;
+				}
+
+				retval = (gpointer) list;
+
+				break;
+
+			default:
+				break;
+		}
+	}
+
+	g_object_unref (client);
+
+	if (value)
+		mateconf_value_free (value);
+
+	return retval;
+}
+
+void
+libslab_set_mateconf_value (const gchar *key, gconstpointer data)
+{
+	MateConfClient *client;
+	MateConfValue  *value;
+
+	MateConfValueType type;
+	MateConfValueType list_type;
+
+	GSList *slist = NULL;
+
+	GError *error = NULL;
+
+	MateConfValue *value_i;
+	GList      *node;
+
+
+	client = mateconf_client_get_default ();
+	value  = mateconf_client_get (client, key, & error);
+
+	if (error) {
+		libslab_handle_g_error (&error, "%s: error getting %s", G_STRFUNC, key);
+
+		goto exit;
+	}
+
+	type = value->type;
+	list_type = ((type == MATECONF_VALUE_LIST) ?
+		mateconf_value_get_list_type (value) : MATECONF_VALUE_INVALID);
+
+	mateconf_value_free (value);
+	value = mateconf_value_new (type);
+
+	if (type == MATECONF_VALUE_LIST)
+		mateconf_value_set_list_type (value, list_type);
+
+	switch (type) {
+		case MATECONF_VALUE_STRING:
+			mateconf_value_set_string (value, g_strdup ((gchar *) data));
+			break;
+
+		case MATECONF_VALUE_INT:
+			mateconf_value_set_int (value, GPOINTER_TO_INT (data));
+			break;
+
+		case MATECONF_VALUE_BOOL:
+			mateconf_value_set_bool (value, GPOINTER_TO_INT (data));
+			break;
+
+		case MATECONF_VALUE_LIST:
+			for (node = (GList *) data; node; node = node->next) {
+				value_i = mateconf_value_new (list_type);
+
+				if (list_type == MATECONF_VALUE_STRING)
+					mateconf_value_set_string (value_i, (const gchar *) node->data);
+				else if (list_type == MATECONF_VALUE_INT)
+					mateconf_value_set_int (value_i, GPOINTER_TO_INT (node->data));
+				else
+					g_assert_not_reached ();
+
+				slist = g_slist_append (slist, value_i);
+			}
+
+			mateconf_value_set_list_nocopy (value, slist);
+
+			break;
+
+		default:
+			break;
+	}
+
+	mateconf_client_set (client, key, value, & error);
+
+	if (error)
+		libslab_handle_g_error (&error, "%s: error setting %s", G_STRFUNC, key);
+
+exit:
+
+	mateconf_value_free (value);
+	g_object_unref (client);
+}
+
+guint
+libslab_mateconf_notify_add (const gchar *key, MateConfClientNotifyFunc callback, gpointer user_data)
+{
+	MateConfClient *client;
+	guint        conn_id;
+
+	GError *error = NULL;
+
+
+	client  = mateconf_client_get_default ();
+	conn_id = mateconf_client_notify_add (client, key, callback, user_data, NULL, & error);
+
+	if (error)
+		libslab_handle_g_error (
+			& error, "%s: error adding mateconf notify for (%s)", G_STRFUNC, key);
+
+	g_object_unref (client);
+
+	return conn_id;
+}
+
+void
+libslab_mateconf_notify_remove (guint conn_id)
+{
+	MateConfClient *client;
+
+	GError *error = NULL;
+
+
+	if (conn_id == 0)
+		return;
+
+	client = mateconf_client_get_default ();
+	mateconf_client_notify_remove (client, conn_id);
+
+	if (error)
+		libslab_handle_g_error (
+			& error, "%s: error removing mateconf notify", G_STRFUNC);
+
+	g_object_unref (client);
+}
+
+void
+libslab_handle_g_error (GError **error, const gchar *msg_format, ...)
+{
+	gchar   *msg;
+	va_list  args;
+
+
+	va_start (args, msg_format);
+	msg = g_strdup_vprintf (msg_format, args);
+	va_end (args);
+
+	if (*error) {
+		g_log (
+			G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
+			"\nGError raised: [%s]\nuser_message: [%s]\n", (*error)->message, msg);
+
+		g_error_free (*error);
+
+		*error = NULL;
+	}
+	else
+		g_log (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "\nerror raised: [%s]\n", msg);
+
+	g_free (msg);
+}
+
+gboolean
+libslab_desktop_item_is_a_terminal (const gchar *uri)
+{
+	MateDesktopItem *d_item;
+	const gchar      *categories;
+
+	gboolean is_terminal = FALSE;
+
+
+	d_item = libslab_mate_desktop_item_new_from_unknown_id (uri);
+
+	if (! d_item)
+		return FALSE;
+
+	categories = mate_desktop_item_get_string (d_item, MATE_DESKTOP_ITEM_CATEGORIES);
+
+	is_terminal = (categories && strstr (categories, DESKTOP_ITEM_TERMINAL_EMULATOR_FLAG));
+
+	mate_desktop_item_unref (d_item);
+
+	return is_terminal;
+}
+
+gboolean
+libslab_desktop_item_is_logout (const gchar *uri)
+{
+	MateDesktopItem *d_item;
+	gboolean is_logout = FALSE;
+
+
+	d_item = libslab_mate_desktop_item_new_from_unknown_id (uri);
+
+	if (! d_item)
+		return FALSE;
+
+	is_logout = strstr ("Logout", mate_desktop_item_get_string (d_item, MATE_DESKTOP_ITEM_NAME)) != NULL;
+
+	mate_desktop_item_unref (d_item);
+
+	return is_logout;
+}
+
+gboolean
+libslab_desktop_item_is_lockscreen (const gchar *uri)
+{
+	MateDesktopItem *d_item;
+	gboolean is_logout = FALSE;
+
+
+	d_item = libslab_mate_desktop_item_new_from_unknown_id (uri);
+
+	if (! d_item)
+		return FALSE;
+
+	is_logout = strstr ("Lock Screen", mate_desktop_item_get_string (d_item, MATE_DESKTOP_ITEM_NAME)) != NULL;
+
+	mate_desktop_item_unref (d_item);
+
+	return is_logout;
+}
+
+gchar *
+libslab_string_replace_once (const gchar *string, const gchar *key, const gchar *value)
+{
+	GString *str_built;
+	gint pivot;
+
+
+	pivot = strstr (string, key) - string;
+
+	str_built = g_string_new_len (string, pivot);
+	g_string_append (str_built, value);
+	g_string_append (str_built, & string [pivot + strlen (key)]);
+
+	return g_string_free (str_built, FALSE);
+}
+
+void
+libslab_spawn_command (const gchar *cmd)
+{
+	gchar **argv;
+
+	GError *error = NULL;
+
+
+	if (! cmd || strlen (cmd) < 1)
+		return;
+
+	argv = g_strsplit (cmd, " ", -1);
+
+	g_spawn_async (NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, & error);
+
+	if (error)
+		libslab_handle_g_error (& error, "%s: error spawning [%s]", G_STRFUNC, cmd);
+
+	g_strfreev (argv);
+}
+
+static guint thumbnail_factory_idle_id;
+static MateDesktopThumbnailFactory *thumbnail_factory;
+
+static void
+create_thumbnail_factory (void)
+{
+	/* The thumbnail_factory may already have been created by an applet
+	 * instance that was launched before the current one.
+	 */
+	if (thumbnail_factory != NULL)
+		return;
+
+	libslab_checkpoint ("create_thumbnail_factory(): start");
+
+	thumbnail_factory = mate_desktop_thumbnail_factory_new (MATE_DESKTOP_THUMBNAIL_SIZE_NORMAL);
+
+	libslab_checkpoint ("create_thumbnail_factory(): end");
+}
+
+static gboolean
+init_thumbnail_factory_idle_cb (gpointer data)
+{
+	create_thumbnail_factory ();
+	thumbnail_factory_idle_id = 0;
+	return FALSE;
+}
+
+void
+libslab_thumbnail_factory_preinit (void)
+{
+	thumbnail_factory_idle_id = g_idle_add (init_thumbnail_factory_idle_cb, NULL);
+}
+
+MateDesktopThumbnailFactory *
+libslab_thumbnail_factory_get (void)
+{
+	if (thumbnail_factory_idle_id != 0) {
+		g_source_remove (thumbnail_factory_idle_id);
+		thumbnail_factory_idle_id = 0;
+
+		create_thumbnail_factory ();
+	}
+
+	g_assert (thumbnail_factory != NULL);
+	return thumbnail_factory;
+}
+
+void
+libslab_checkpoint_init (const char *checkpoint_config_file_basename,
+			 const char *checkpoint_file_basename)
+{
+	char *filename;
+	struct stat st;
+	int result;
+	time_t t;
+	struct tm tm;
+	char *checkpoint_full_basename;
+
+	g_return_if_fail (checkpoint_config_file_basename != NULL);
+	g_return_if_fail (checkpoint_file_basename != NULL);
+
+	filename = g_build_filename (g_get_home_dir (), checkpoint_config_file_basename, NULL);
+
+	result = stat (filename, &st);
+	g_free (filename);
+
+	if (result != 0)
+		return;
+
+	t = time (NULL);
+	tm = *localtime (&t);
+
+	checkpoint_full_basename = g_strdup_printf ("%s-%04d-%02d-%02d-%02d-%02d-%02d.checkpoint",
+						    checkpoint_file_basename,
+						    tm.tm_year + 1900,
+						    tm.tm_mon + 1,
+						    tm.tm_mday,
+						    tm.tm_hour,
+						    tm.tm_min,
+						    tm.tm_sec);
+
+	filename = g_build_filename (g_get_home_dir (), checkpoint_full_basename, NULL);
+	g_free (checkpoint_full_basename);
+
+	checkpoint_file = fopen (filename, "w");
+	g_free (filename);
+}
+
+void
+libslab_checkpoint (const char *format, ...)
+{
+	va_list args;
+	struct timeval tv;
+	struct tm tm;
+	struct rusage rusage;
+
+	if (!checkpoint_file)
+		return;
+
+	gettimeofday (&tv, NULL);
+	tm = *localtime (&tv.tv_sec);
+
+	getrusage (RUSAGE_SELF, &rusage);
+
+	fprintf (checkpoint_file,
+		 "%02d:%02d:%02d.%04d (user:%d.%04d, sys:%d.%04d) - ",
+		 (int) tm.tm_hour,
+		 (int) tm.tm_min,
+		 (int) tm.tm_sec,
+		 (int) (tv.tv_usec / 100),
+		 (int) rusage.ru_utime.tv_sec,
+		 (int) (rusage.ru_utime.tv_usec / 100),
+		 (int) rusage.ru_stime.tv_sec,
+		 (int) (rusage.ru_stime.tv_usec / 100));
+
+	va_start (args, format);
+	vfprintf (checkpoint_file, format, args);
+	va_end (args);
+
+	fputs ("\n", checkpoint_file);
+	fflush (checkpoint_file);
+}