1 files changed, 539 insertions, 0 deletions
diff --git a/multiload/main.c b/multiload/main.c
new file mode 100644
index 00000000..a51d0856
--- /dev/null
+++ b/multiload/main.c
@@ -0,0 +1,539 @@
+/* MATE multiload panel applet
+ * (C) 1997 The Free Software Foundation
+ *
+ * Authors: Tim P. Gerla
+ * Martin Baulig
+ * Todd Kulesza
+ *
+ * With code from wmload.c, v0.9.2, apparently by Ryan Land, [email protected].
+ *
+ */
+
+#include <config.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <signal.h>
+#include <dirent.h>
+#include <string.h>
+#include <time.h>
+
+#include <glibtop.h>
+#include <gdk/gdkkeysyms.h>
+#include <gtk/gtk.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <mateconf/mateconf-client.h>
+#include <libmate/mate-desktop-item.h> 
+#include <mate-panel-applet.h>
+#include <mate-panel-applet-mateconf.h>
+
+#include "global.h"
+
+static void
+about_cb (GtkAction *action,
+ MultiloadApplet *ma)
+{
+ const gchar * const authors[] =
+ {
+ "Martin Baulig <[email protected]>",
+ "Todd Kulesza <[email protected]>",
+ "Benoît Dejean <[email protected]>",
+ "Davyd Madeley <[email protected]>",
+ NULL
+ };
+
+ const gchar * const documenters[] =
+ {
+ "Chee Bin HOH <[email protected]>",
+ "Sun MATE Documentation Team <[email protected]>",
+ NULL
+ };
+
+ gtk_show_about_dialog (NULL,
+ "version", VERSION,
+ "copyright", "\xC2\xA9 1999-2005 Free Software Foundation "
+ "and others",
+ "comments", _("A system load monitor capable of displaying graphs "
+ "for CPU, ram, and swap space use, plus network "
+ "traffic."),
+ "authors", authors,
+ "documenters", documenters,
+ "translator-credits", _("translator-credits"),
+ "logo-icon-name", "utilities-system-monitor",
+ NULL);
+}
+
+static void
+help_cb (GtkAction *action,
+ MultiloadApplet *ma)
+{
+
+ GError *error = NULL;
+ 
+ gtk_show_uri (gtk_widget_get_screen (GTK_WIDGET (ma->applet)),
+ "ghelp:multiload",
+ 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;
+ }
+
+
+}
+
+/* run the full-scale system process monitor */
+
+static void
+start_procman (MultiloadApplet *ma)
+{
+ GError *error = NULL;
+ MateDesktopItem *ditem;
+ gchar *monitor;
+
+ g_return_if_fail (ma != NULL);
+
+ monitor = mate_panel_applet_mateconf_get_string (ma->applet, "system_monitor", NULL);
+ if (monitor == NULL)
+ monitor = g_strdup ("mate-system-monitor.desktop");
+
+ if ((ditem = mate_desktop_item_new_from_basename (monitor, 0, NULL))) {
+ mate_desktop_item_set_launch_time (ditem, gtk_get_current_event_time ());
+ mate_desktop_item_launch_on_screen (ditem, NULL,
+ MATE_DESKTOP_ITEM_LAUNCH_ONLY_ONE,
+ gtk_widget_get_screen (GTK_WIDGET (ma->applet)),
+ -1, &error);
+ mate_desktop_item_unref (ditem);
+ }
+ else { 
+ gdk_spawn_command_line_on_screen (
+ gtk_widget_get_screen (GTK_WIDGET (ma->applet)),
+ "mate-system-monitor", &error);
+ }
+ g_free (monitor);
+
+ if (error) {
+ GtkWidget *dialog;
+
+ dialog = gtk_message_dialog_new (NULL,
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_MESSAGE_ERROR,
+ GTK_BUTTONS_OK,
+ _("There was an error executing '%s': %s"),
+ "mate-system-monitor",
+ error->message);
+
+ g_signal_connect (dialog, "response",
+ G_CALLBACK (gtk_widget_destroy),
+ NULL);
+
+ gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
+ gtk_window_set_screen (GTK_WINDOW (dialog),
+ gtk_widget_get_screen (GTK_WIDGET (ma->applet)));
+
+ gtk_widget_show (dialog);
+
+ g_error_free (error);
+ }
+}
+ 
+static void
+start_procman_cb (GtkAction *action,
+ MultiloadApplet *ma)
+{
+ start_procman (ma);
+}
+
+static void
+multiload_change_size_cb(MatePanelApplet *applet, gint size, gpointer data)
+{
+ MultiloadApplet *ma = (MultiloadApplet *)data;
+ 
+ multiload_applet_refresh(ma);
+ 
+ return;
+}
+
+static void
+multiload_change_orient_cb(MatePanelApplet *applet, gint arg1, gpointer data)
+{
+ MultiloadApplet *ma = data;
+ multiload_applet_refresh((MultiloadApplet *)data);
+ gtk_widget_show (GTK_WIDGET (ma->applet)); 
+ return;
+}
+
+static void
+multiload_destroy_cb(GtkWidget *widget, gpointer data)
+{
+ gint i;
+ MultiloadApplet *ma = data;
+
+ for (i = 0; i < NGRAPHS; i++)
+ {
+ load_graph_stop(ma->graphs[i]);
+ if (ma->graphs[i]->colors)
+ {
+ g_free (ma->graphs[i]->colors);
+ ma->graphs[i]->colors = NULL;
+ }
+ gtk_widget_destroy(ma->graphs[i]->main_widget);
+ 
+ load_graph_unalloc(ma->graphs[i]);
+ g_free(ma->graphs[i]);
+ }
+ 
+ if (ma->about_dialog)
+ gtk_widget_destroy (ma->about_dialog);
+ 
+ if (ma->prop_dialog)
+ gtk_widget_destroy (ma->prop_dialog);
+
+ gtk_widget_destroy(GTK_WIDGET(ma->applet));
+
+ g_free (ma);
+
+ return;
+}
+
+
+static gboolean
+multiload_button_press_event_cb (GtkWidget *widget, GdkEventButton *event, MultiloadApplet *ma)
+{
+ g_return_val_if_fail (event != NULL, FALSE);
+ g_return_val_if_fail (ma != NULL, FALSE);
+
+ if (event->button == 1 && event->type == GDK_BUTTON_PRESS) {
+ start_procman (ma);
+ return TRUE;
+ }
+ return FALSE;
+}
+
+static gboolean
+multiload_key_press_event_cb (GtkWidget *widget, GdkEventKey *event, MultiloadApplet *ma)
+{
+ g_return_val_if_fail (event != NULL, FALSE);
+ g_return_val_if_fail (ma != NULL, FALSE);
+
+ switch (event->keyval) {
+ /* this list of keyvals taken from mixer applet, which seemed to have
+ a good list of keys to use */
+ case GDK_KP_Enter:
+ case GDK_ISO_Enter:
+ case GDK_3270_Enter:
+ case GDK_Return:
+ case GDK_space:
+ case GDK_KP_Space:
+ /* activate */
+ start_procman (ma);
+ return TRUE;
+
+ default:
+ break;
+ }
+
+ return FALSE;
+}
+
+/* update the tooltip to the graph's current "used" percentage */
+void
+multiload_applet_tooltip_update(LoadGraph *g)
+{
+ gchar *tooltip_text, *name;
+
+ g_assert(g);
+ g_assert(g->name);
+
+ /* label the tooltip intuitively */
+ if (!strncmp(g->name, "cpuload", strlen("cpuload")))
+ name = g_strdup(_("Processor"));
+ else if (!strncmp(g->name, "memload", strlen("memload")))
+ name = g_strdup(_("Memory"));
+ else if (!strncmp(g->name, "netload2", strlen("netload2")))
+ name = g_strdup(_("Network"));
+ else if (!strncmp(g->name, "swapload", strlen("swapload")))
+ name = g_strdup(_("Swap Space"));
+ else if (!strncmp(g->name, "loadavg", strlen("loadavg")))
+ name = g_strdup(_("Load Average"));
+ else if (!strncmp (g->name, "diskload", strlen("diskload")))
+ name = g_strdup(_("Disk"));
+ else
+ g_assert_not_reached();
+ 
+ if (!strncmp(g->name, "memload", strlen("memload"))) {
+ guint mem_user, mem_cache, user_percent, cache_percent;
+ mem_user = g->data[0][0];
+ mem_cache = g->data[0][1] + g->data[0][2] + g->data[0][3];
+ user_percent = 100.0f * mem_user / g->draw_height;
+ cache_percent = 100.0f * mem_cache / g->draw_height;
+ user_percent = MIN(user_percent, 100);
+ cache_percent = MIN(cache_percent, 100);
+
+ /* xgettext: use and cache are > 1 most of the time,
+ please assume that they always are.
+ */
+ tooltip_text = g_strdup_printf(_("%s:\n"
+ "%u%% in use by programs\n"
+ "%u%% in use as cache"),
+ name,
+ user_percent,
+ cache_percent);
+ } else if (!strcmp(g->name, "loadavg")) {
+
+ tooltip_text = g_strdup_printf(_("The system load average is %0.02f"),
+ g->loadavg1);
+
+ } else if (!strcmp(g->name, "netload2")) {
+ char *tx_in, *tx_out;
+ tx_in = netspeed_get(g->netspeed_in);
+ tx_out = netspeed_get(g->netspeed_out);
+ /* xgettext: same as in graphic tab of g-s-m */
+ tooltip_text = g_strdup_printf(_("%s:\n"
+ "Receiving %s\n"
+ "Sending %s"),
+ name, tx_in, tx_out);
+ g_free(tx_in);
+ g_free(tx_out);
+ } else {
+ const char *msg;
+ guint i, total_used, percent;
+
+ for (i = 0, total_used = 0; i < (g->n - 1); i++)
+ total_used += g->data[0][i];
+
+ percent = 100.0f * total_used / g->draw_height;
+ percent = MIN(percent, 100);
+
+ msg = ngettext("%s:\n"
+ "%u%% in use",
+ "%s:\n"
+ "%u%% in use",
+ percent);
+
+ tooltip_text = g_strdup_printf(msg,
+ name,
+ percent);
+ }
+
+ gtk_widget_set_tooltip_text(g->disp, tooltip_text);
+ 
+ g_free(tooltip_text);
+ g_free(name);
+}
+
+static void
+multiload_create_graphs(MultiloadApplet *ma)
+{
+ struct { const char *label;
+ const char *name;
+ int num_colours;
+ LoadGraphDataFunc callback;
+ } graph_types[] = {
+ { _("CPU Load"), "cpuload", 5, GetLoad },
+ { _("Memory Load"), "memload", 5, GetMemory },
+ { _("Net Load"), "netload2", 4, GetNet },
+ { _("Swap Load"), "swapload", 2, GetSwap },
+ { _("Load Average"), "loadavg", 2, GetLoadAvg },
+ { _("Disk Load"), "diskload", 3, GetDiskLoad }
+ };
+
+ gint speed, size;
+ gint i;
+
+ speed = mate_panel_applet_mateconf_get_int (ma->applet, "speed", NULL);
+ size = mate_panel_applet_mateconf_get_int (ma->applet, "size", NULL);
+ speed = MAX (speed, 50);
+ size = CLAMP (size, 10, 400);
+
+ for (i = 0; i < G_N_ELEMENTS (graph_types); i++)
+ {
+ gboolean visible;
+ char *key;
+
+ /* This is a special case to handle migration from an
+ * older version of netload to a newer one in the
+ * 2.25.1 release. */
+ if (g_strcmp0 ("netload2", graph_types[i].name) == 0) {
+ key = g_strdup ("view_netload");
+ } else {
+ key = g_strdup_printf ("view_%s", graph_types[i].name);
+ }
+ visible = mate_panel_applet_mateconf_get_bool (ma->applet, key, NULL);
+ g_free (key);
+
+ ma->graphs[i] = load_graph_new (ma,
+ graph_types[i].num_colours,
+ graph_types[i].label,
+ i,
+ speed,
+ size,
+ visible,
+ graph_types[i].name,
+ graph_types[i].callback);
+ }
+}
+
+/* remove the old graphs and rebuild them */
+void
+multiload_applet_refresh(MultiloadApplet *ma)
+{
+ gint i;
+ MatePanelAppletOrient orientation;
+
+ /* stop and free the old graphs */
+ for (i = 0; i < NGRAPHS; i++)
+ {
+ if (!ma->graphs[i])
+ continue;
+ 
+ load_graph_stop(ma->graphs[i]);
+ gtk_widget_destroy(ma->graphs[i]->main_widget);
+ 
+ load_graph_unalloc(ma->graphs[i]);
+ g_free(ma->graphs[i]);
+ }
+
+ if (ma->box)
+ gtk_widget_destroy(ma->box);
+ 
+ orientation = mate_panel_applet_get_orient(ma->applet);
+ 
+ if ( (orientation == MATE_PANEL_APPLET_ORIENT_UP) || 
+ (orientation == MATE_PANEL_APPLET_ORIENT_DOWN) ) {
+ ma->box = gtk_hbox_new(FALSE, 0);
+ }
+ else
+ ma->box = gtk_vbox_new(FALSE, 0);
+ 
+ gtk_container_add(GTK_CONTAINER(ma->applet), ma->box);
+ 
+ /* create the NGRAPHS graphs, passing in their user-configurable properties with mateconf. */
+ multiload_create_graphs (ma);
+
+ /* only start and display the graphs the user has turned on */
+
+ for (i = 0; i < NGRAPHS; i++) {
+ gtk_box_pack_start(GTK_BOX(ma->box), 
+ ma->graphs[i]->main_widget, 
+ TRUE, TRUE, 1);
+ if (ma->graphs[i]->visible) {
+ gtk_widget_show_all (ma->graphs[i]->main_widget);
+ load_graph_start(ma->graphs[i]);
+ }
+ }
+ gtk_widget_show (ma->box);
+ 
+ return;
+}
+
+static const GtkActionEntry multiload_menu_actions [] = {
+ { "MultiLoadProperties", GTK_STOCK_PROPERTIES, N_("_Preferences"),
+ NULL, NULL,
+ G_CALLBACK (multiload_properties_cb) },
+ { "MultiLoadRunProcman", GTK_STOCK_EXECUTE, N_("_Open System Monitor"),
+ NULL, NULL,
+ G_CALLBACK (start_procman_cb) },
+ { "MultiLoadHelp", GTK_STOCK_HELP, N_("_Help"),
+ NULL, NULL,
+ G_CALLBACK (help_cb) },
+ { "MultiLoadAbout", GTK_STOCK_ABOUT, N_("_About"),
+ NULL, NULL,
+ G_CALLBACK (about_cb) }
+}; 
+
+/* create a box and stuff the load graphs inside of it */
+static gboolean
+multiload_applet_new(MatePanelApplet *applet, const gchar *iid, gpointer data)
+{
+ MultiloadApplet *ma;
+ MateConfClient *client;
+ GtkActionGroup *action_group;
+ gchar *ui_path;
+ 
+ ma = g_new0(MultiloadApplet, 1);
+ 
+ ma->applet = applet;
+ 
+ ma->about_dialog = NULL;
+ ma->prop_dialog = NULL;
+ ma->last_clicked = 0;
+
+ g_set_application_name (_("System Monitor"));
+
+ gtk_window_set_default_icon_name ("utilities-system-monitor");
+ mate_panel_applet_set_background_widget (applet, GTK_WIDGET(applet));
+ 
+ mate_panel_applet_add_preferences (applet, "/schemas/apps/multiload/prefs", NULL);
+ mate_panel_applet_set_flags (applet, MATE_PANEL_APPLET_EXPAND_MINOR);
+
+ action_group = gtk_action_group_new ("Multiload Applet Actions");
+ gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
+ gtk_action_group_add_actions (action_group,
+ multiload_menu_actions,
+ G_N_ELEMENTS (multiload_menu_actions),
+ ma);
+ ui_path = g_build_filename (MULTILOAD_MENU_UI_DIR, "multiload-applet-menu.xml", NULL);
+ mate_panel_applet_setup_menu_from_file (applet, ui_path, action_group);
+ g_free (ui_path);
+
+
+ if (mate_panel_applet_get_locked_down (applet)) {
+ GtkAction *action;
+
+ action = gtk_action_group_get_action (action_group, "MultiLoadProperties");
+ gtk_action_set_visible (action, FALSE);
+ }
+
+ client = mateconf_client_get_default ();
+ if (mateconf_client_get_bool (client, "/desktop/mate/lockdown/inhibit_command_line", NULL) ||
+ mate_panel_applet_get_locked_down (applet)) {
+ GtkAction *action;
+
+ /* When the panel is locked down or when the command line is inhibited,
+ it seems very likely that running the procman would be at least harmful */
+ action = gtk_action_group_get_action (action_group, "MultiLoadRunProcman");
+ gtk_action_set_visible (action, FALSE);
+ }
+
+ g_object_unref (action_group);
+
+ g_signal_connect(G_OBJECT(applet), "change_size",
+ G_CALLBACK(multiload_change_size_cb), ma);
+ g_signal_connect(G_OBJECT(applet), "change_orient",
+ G_CALLBACK(multiload_change_orient_cb), ma);
+ g_signal_connect(G_OBJECT(applet), "destroy",
+ G_CALLBACK(multiload_destroy_cb), ma);
+ g_signal_connect(G_OBJECT(applet), "button_press_event",
+ G_CALLBACK(multiload_button_press_event_cb), ma);
+ g_signal_connect(G_OBJECT(applet), "key_press_event",
+ G_CALLBACK(multiload_key_press_event_cb), ma);
+ 
+ multiload_applet_refresh (ma);
+ 
+ gtk_widget_show(GTK_WIDGET(applet));
+ 
+ return TRUE;
+}
+
+static gboolean
+multiload_factory (MatePanelApplet *applet,
+ const gchar *iid,
+ gpointer data)
+{
+ gboolean retval = FALSE;
+ 
+ glibtop_init();
+
+ retval = multiload_applet_new(applet, iid, data);
+ 
+ return retval;
+}
+
+MATE_PANEL_APPLET_OUT_PROCESS_FACTORY ("MultiLoadAppletFactory",
+ PANEL_TYPE_APPLET,
+ "multiload",
+ multiload_factory,
+ NULL)