initial

1 files changed, 510 insertions, 0 deletions

diff --git a/src/util.cpp b/src/util.cpp
new file mode 100644
index 0000000..907bf80
--- /dev/null
+++ b/src/util.cpp
@@ -0,0 +1,510 @@
+#include <config.h>
+
+#include <glib/gi18n.h>
+#include <glib/gstring.h>
+#include <gtk/gtk.h>
+
+#include <glibtop/proctime.h>
+#include <glibtop/procstate.h>
+#include <unistd.h>
+
+#include <stddef.h>
+#include <cstring>
+
+#include "util.h"
+#include "procman.h"
+
+extern "C" {
+#include "e_date.h"
+}
+
+
+static const char*
+format_process_state(guint state)
+{
+  const char *status;
+
+  switch (state)
+    {
+    case GLIBTOP_PROCESS_RUNNING:
+      status = _("Running");
+      break;
+
+    case GLIBTOP_PROCESS_STOPPED:
+      status = _("Stopped");
+      break;
+
+    case GLIBTOP_PROCESS_ZOMBIE:
+      status = _("Zombie");
+      break;
+
+    case GLIBTOP_PROCESS_UNINTERRUPTIBLE:
+      status = _("Uninterruptible");
+      break;
+
+    default:
+      status = _("Sleeping");
+      break;
+    }
+
+  return status;
+}
+
+
+
+static char *
+mnemonic_safe_process_name(const char *process_name)
+{
+	const char *p;
+	GString *name;
+
+	name = g_string_new ("");
+
+	for(p = process_name; *p; ++p)
+	{
+		g_string_append_c (name, *p);
+
+		if(*p == '_')
+			g_string_append_c (name, '_');
+	}
+
+	return g_string_free (name, FALSE);
+}
+
+
+
+static inline unsigned divide(unsigned *q, unsigned *r, unsigned d)
+{
+	*q = *r / d;
+	*r = *r % d;
+	return *q != 0;
+}
+
+
+/*
+ * @param d: duration in centiseconds
+ * @type d: unsigned
+ */
+static char *
+format_duration_for_display(unsigned centiseconds)
+{
+	unsigned weeks = 0, days = 0, hours = 0, minutes = 0, seconds = 0;
+
+	(void)(divide(&seconds, &centiseconds, 100)
+	       && divide(&minutes, &seconds, 60)
+	       && divide(&hours, &minutes, 60)
+	       && divide(&days, &hours, 24)
+	       && divide(&weeks, &days, 7));
+
+	if (weeks)
+		/* xgettext: weeks, days */
+		return g_strdup_printf(_("%uw%ud"), weeks, days);
+
+	if (days)
+		/* xgettext: days, hours (0 -> 23) */
+		return g_strdup_printf(_("%ud%02uh"), days, hours);
+
+	if (hours)
+		/* xgettext: hours (0 -> 23), minutes, seconds */
+		return g_strdup_printf(_("%u:%02u:%02u"), hours, minutes, seconds);
+
+	/* xgettext: minutes, seconds, centiseconds */
+	return g_strdup_printf(_("%u:%02u.%02u"), minutes, seconds, centiseconds);
+}
+
+
+
+GtkWidget*
+procman_make_label_for_mmaps_or_ofiles(const char *format,
+					     const char *process_name,
+					     unsigned pid)
+{
+	GtkWidget *label;
+	char *name, *title;
+
+	name = mnemonic_safe_process_name (process_name);
+	title = g_strdup_printf(format, name, pid);
+	label = gtk_label_new_with_mnemonic (title);
+	gtk_misc_set_alignment (GTK_MISC (label), 0.0f, 0.5f);
+
+	g_free (title);
+	g_free (name);
+
+	return label;
+}
+
+
+
+/**
+ * procman::format_size:
+ * @size:
+ * 
+ * Formats the file size passed in @bytes in a way that is easy for
+ * the user to read. Gives the size in bytes, kibibytes, mebibytes or
+ * gibibytes, choosing whatever is appropriate.
+ * 
+ * Returns: a newly allocated string with the size ready to be shown.
+ **/
+
+gchar*
+procman::format_size(guint64 size, guint64 max_size, bool want_bits)
+{
+	enum {
+		K_INDEX,
+		M_INDEX,
+		G_INDEX
+	};
+
+	struct Format {
+		guint64 factor;
+		const char* string;
+	};
+
+	const Format all_formats[2][3] = {
+		{ { 1UL << 10,	N_("%.1f KiB") },
+		  { 1UL << 20,	N_("%.1f MiB") },
+		  { 1UL << 30,	N_("%.1f GiB") } },
+		{ { 1000,	N_("%.1f kbit") },
+		  { 1000000,	N_("%.1f Mbit") },
+		  { 1000000000,	N_("%.1f Gbit") } }
+	};
+
+	const Format (&formats)[3] = all_formats[want_bits ? 1 : 0];
+
+	if (want_bits) {
+	  size *= 8;
+	  max_size *= 8;
+	}
+
+	if (max_size == 0)
+		max_size = size;
+
+	if (max_size < formats[K_INDEX].factor) {
+		const char *format = (want_bits
+			  ? dngettext(GETTEXT_PACKAGE, "%u bit", "%u bits", (guint) size)
+			  : dngettext(GETTEXT_PACKAGE, "%u byte", "%u bytes",(guint) size));
+		return g_strdup_printf (format, (guint) size);
+	} else {
+		guint64 factor;
+		const char* format = NULL;
+
+		if (max_size < formats[M_INDEX].factor) {
+		  factor = formats[K_INDEX].factor;
+		  format = formats[K_INDEX].string;
+		} else if (max_size < formats[G_INDEX].factor) {
+		  factor = formats[M_INDEX].factor;
+		  format = formats[M_INDEX].string;
+		} else {
+		  factor = formats[G_INDEX].factor;
+		  format = formats[G_INDEX].string;
+		}
+
+		return g_strdup_printf(_(format), size / (double)factor);
+	}
+}
+
+
+
+gboolean
+load_symbols(const char *module, ...)
+{
+	GModule *mod;
+	gboolean found_all = TRUE;
+	va_list args;
+
+	mod = g_module_open(module, static_cast<GModuleFlags>(G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL));
+
+	if (!mod)
+		return FALSE;
+
+	procman_debug("Found %s", module);
+
+	va_start(args, module);
+
+	while (1) {
+		const char *name;
+		void **symbol;
+
+		name = va_arg(args, char*);
+
+		if (!name)
+			break;
+
+		symbol = va_arg(args, void**);
+
+		if (g_module_symbol(mod, name, symbol)) {
+			procman_debug("Loaded %s from %s", name, module);
+		}
+		else {
+			procman_debug("Could not load %s from %s", name, module);
+			found_all = FALSE;
+			break;
+		}
+	}
+
+	va_end(args);
+
+
+	if (found_all)
+		g_module_make_resident(mod);
+	else
+		g_module_close(mod);
+
+	return found_all;
+}
+
+
+static gboolean
+is_debug_enabled(void)
+{
+	static gboolean init;
+	static gboolean enabled;
+
+	if (!init) {
+		enabled = g_getenv("MATE_SYSTEM_MONITOR_DEBUG") != NULL;
+		init = TRUE;
+	}
+
+	return enabled;
+}
+
+
+static double get_relative_time(void)
+{
+	static unsigned long start_time;
+	GTimeVal tv;
+
+	if (G_UNLIKELY(!start_time)) {
+		glibtop_proc_time buf;
+		glibtop_get_proc_time(&buf, getpid());
+		start_time = buf.start_time;
+	}
+
+	g_get_current_time(&tv);
+	return (tv.tv_sec - start_time) + 1e-6 * tv.tv_usec;
+}
+
+
+void
+procman_debug_real(const char *file, int line, const char *func,
+		   const char *format, ...)
+{
+	va_list args;
+	char *msg;
+
+	if (G_LIKELY(!is_debug_enabled()))
+		return;
+
+	va_start(args, format);
+	msg = g_strdup_vprintf(format, args);
+	va_end(args);
+
+	g_debug("[%.3f %s:%d %s] %s", get_relative_time(), file, line, func, msg);
+
+	g_free(msg);
+}
+
+
+
+namespace procman
+{
+  void size_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
+			   GtkTreeModel *model, GtkTreeIter *iter,
+			   gpointer user_data)
+  {
+    const guint index = GPOINTER_TO_UINT(user_data);
+
+    guint64 size;
+    GValue value = { 0 };
+
+    gtk_tree_model_get_value(model, iter, index, &value);
+
+    switch (G_VALUE_TYPE(&value)) {
+    case G_TYPE_ULONG:
+      size = g_value_get_ulong(&value);
+      break;
+
+    case G_TYPE_UINT64:
+      size = g_value_get_uint64(&value);
+      break;
+
+    default:
+      g_assert_not_reached();
+    }
+
+    g_value_unset(&value);
+
+    char *str = procman::format_size(size);
+    g_object_set(renderer, "text", str, NULL);
+    g_free(str);
+  }
+
+
+  /*
+    Same as above but handles size == 0 as not available
+   */
+  void size_na_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
+			      GtkTreeModel *model, GtkTreeIter *iter,
+			      gpointer user_data)
+  {
+    const guint index = GPOINTER_TO_UINT(user_data);
+
+    guint64 size;
+    GValue value = { 0 };
+
+    gtk_tree_model_get_value(model, iter, index, &value);
+
+    switch (G_VALUE_TYPE(&value)) {
+    case G_TYPE_ULONG:
+      size = g_value_get_ulong(&value);
+      break;
+
+    case G_TYPE_UINT64:
+      size = g_value_get_uint64(&value);
+      break;
+
+    default:
+      g_assert_not_reached();
+    }
+
+    g_value_unset(&value);
+
+    if (size == 0)
+      g_object_set(renderer, "markup", _("<i>N/A</i>"), NULL);
+    else {
+      char *str = procman::format_size(size);
+      g_object_set(renderer, "text", str, NULL);
+      g_free(str);
+    }
+
+  }
+
+
+  void duration_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
+			       GtkTreeModel *model, GtkTreeIter *iter,
+			       gpointer user_data)
+  {
+    const guint index = GPOINTER_TO_UINT(user_data);
+
+    unsigned time;
+    GValue value = { 0 };
+
+    gtk_tree_model_get_value(model, iter, index, &value);
+
+    switch (G_VALUE_TYPE(&value)) {
+    case G_TYPE_ULONG:
+      time = g_value_get_ulong(&value);
+      break;
+
+    case G_TYPE_UINT64:
+      time = g_value_get_uint64(&value);
+      break;
+
+    default:
+      g_assert_not_reached();
+    }
+
+    g_value_unset(&value);
+
+    time = 100 * time / ProcData::get_instance()->frequency;
+    char *str = format_duration_for_display(time);
+    g_object_set(renderer, "text", str, NULL);
+    g_free(str);
+  }
+
+
+  void time_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
+			   GtkTreeModel *model, GtkTreeIter *iter,
+			   gpointer user_data)
+  {
+    const guint index = GPOINTER_TO_UINT(user_data);
+
+    time_t time;
+    GValue value = { 0 };
+
+    gtk_tree_model_get_value(model, iter, index, &value);
+
+    switch (G_VALUE_TYPE(&value)) {
+    case G_TYPE_ULONG:
+      time = g_value_get_ulong(&value);
+      break;
+
+    default:
+      g_assert_not_reached();
+    }
+
+    g_value_unset(&value);
+
+    char *str = procman_format_date_for_display(time);
+    g_object_set(renderer, "text", str, NULL);
+    g_free(str);
+  }
+
+  void status_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
+			     GtkTreeModel *model, GtkTreeIter *iter,
+			     gpointer user_data)
+  {
+    const guint index = GPOINTER_TO_UINT(user_data);
+
+    guint state;
+    GValue value = { 0 };
+
+    gtk_tree_model_get_value(model, iter, index, &value);
+
+    switch (G_VALUE_TYPE(&value)) {
+    case G_TYPE_UINT:
+      state = g_value_get_uint(&value);
+      break;
+
+    default:
+      g_assert_not_reached();
+    }
+
+    g_value_unset(&value);
+
+    const char *str = format_process_state(state);
+    g_object_set(renderer, "text", str, NULL);
+  }
+
+
+  template<>
+  void tree_store_update<const char>(GtkTreeModel* model, GtkTreeIter* iter, int column, const char* new_value)
+  {
+    char* current_value;
+
+    gtk_tree_model_get(model, iter, column, &current_value, -1);
+
+    if (!current_value or std::strcmp(current_value, new_value) != 0)
+      gtk_tree_store_set(GTK_TREE_STORE(model), iter, column, new_value, -1);
+
+    g_free(current_value);
+  }
+
+
+
+
+  std::string format_rate(guint64 rate, guint64 max_rate, bool want_bits)
+  {
+    char* bytes = procman::format_size(rate, max_rate, want_bits);
+    // xgettext: rate, 10MiB/s or 10Mbit/s
+    std::string formatted_rate(make_string(g_strdup_printf(_("%s/s"), bytes)));
+    g_free(bytes);
+    return formatted_rate;
+  }
+
+
+  std::string format_network(guint64 rate, guint64 max_rate)
+  {
+    return procman::format_size(rate, max_rate, ProcData::get_instance()->config.network_in_bits);
+  }
+
+
+  std::string format_network_rate(guint64 rate, guint64 max_rate)
+  {
+    return procman::format_rate(rate, max_rate, ProcData::get_instance()->config.network_in_bits);
+  }
+
+}
+
+
+