+AM_CPPFLAGS = \

+ -I$(srcdir) \

+ -DMULTILOAD_MENU_UI_DIR=\""$(datadir)/mate/ui/"\" \

+ $(MATE_APPLETS4_CFLAGS) \

+ $(GTOP_APPLETS_CFLAGS) \

+ $(GIO_CFLAGS) \

+ ${WARN_CFLAGS}

+

+libexec_PROGRAMS = mate-multiload-applet

+

+mate_multiload_applet_SOURCES = \

+ global.h \

+ linux-proc.h \

+ load-graph.h \

+ linux-proc.c \

+ load-graph.c \

+ main.c \

+ properties.c \

+ netspeed.c netspeed.h \

+ autoscaler.c \

+ autoscaler.h

+

+mate_multiload_applet_LDADD = \

+ $(MATE_APPLETS4_LIBS) \

+ $(GTOP_APPLETS_LIBS) \

+ $(GIO_LIBS) \

+ -lm

+

+-include $(top_srcdir)/git.mk

+#include <time.h>

+#include <glib.h>

+

+#include "autoscaler.h"

+

+/* i wish i could have used C99 initializers instead of writing this function */

+void autoscaler_init(AutoScaler *that, unsigned interval, unsigned floor)

+{

+ that->update_interval = interval;

+ that->floor = floor;

+ that->max = 0;

+ that->count = 0;

+ that->last_update = 0;

+ that->sum = 0.0f;

+ that->last_average = 0.0f;

+}

+

+

+unsigned autoscaler_get_max(AutoScaler *that, unsigned current)

+{

+ time_t now;

+

+ that->sum += current;

+ that->count++;

+ time(&now);

+

+ if((float)difftime(now, that->last_update) > that->update_interval)

+ {

+ float new_average = that->sum / that->count;

+ float average;

+

+ if(new_average < that->last_average)

+ average = ((that->last_average * 0.5f) + new_average) / 1.5f;

+ else

+ average = new_average;

+

+ that->max = average * 1.2f;

+

+ that->sum = 0.0f;

+ that->count = 0;

+ that->last_update = now;

+ that->last_average = average;

+ }

+

+ that->max = MAX(that->max, current);

+ that->max = MAX(that->max, that->floor);

+#if 0

+ printf("%p max = %u, current = %u, last_average = %f\n", that, that->max, current, that->last_average);

+#endif

+ return that->max;

+}

+#ifndef MATE_APPLETS_MULTILOAD_AUTOSCALER_H

+#define MATE_APPLETS_MULTILOAD_AUTOSCALER_H

+

+#include <glib.h>

+#include <time.h>

+

+typedef struct _AutoScaler AutoScaler;

+

+struct _AutoScaler

+{

+ /* const */ unsigned update_interval;

+ /* const */ unsigned floor;

+ unsigned max;

+ unsigned count;

+ time_t last_update;

+ float sum;

+ float last_average;

+};

+

+

+G_GNUC_INTERNAL void autoscaler_init(AutoScaler *that, unsigned interval, unsigned floor);

+

+G_GNUC_INTERNAL unsigned autoscaler_get_max(AutoScaler *that, unsigned current);

+

+

+#endif /* MATE_APPLETS_MULTILOAD_AUTOSCALER_H */

+#ifndef __GLOBAL_H__

+#define __GLOBAL_H__

+

+#include <glib.h>

+#include <glib/gi18n.h>

+#include <gdk-pixbuf/gdk-pixbuf.h>

+#include <gtk/gtk.h>

+#include <gio/gio.h>

+#include <mate-panel-applet.h>

+

+G_BEGIN_DECLS

+

+#define MIN_NET_THRESHOLD1 10

+#define MIN_NET_THRESHOLD2 11

+#define MIN_NET_THRESHOLD3 12

+#define MAX_NET_THRESHOLD1 999999998

+#define MAX_NET_THRESHOLD2 999999999

+#define MAX_NET_THRESHOLD3 1000000000

+

+#define VIEW_CPULOAD_KEY "view-cpuload"

+#define VIEW_MEMLOAD_KEY "view-memload"

+#define VIEW_NETLOAD_KEY "view-netload"

+#define VIEW_SWAPLOAD_KEY "view-swapload"

+#define VIEW_LOADAVG_KEY "view-loadavg"

+#define VIEW_DISKLOAD_KEY "view-diskload"

+

+typedef struct _MultiloadApplet MultiloadApplet;

+typedef struct _LoadGraph LoadGraph;

+typedef void (*LoadGraphDataFunc) (int, int [], LoadGraph *);

+

+#include "netspeed.h"

+

+typedef enum {

+ graph_cpuload = 0,

+ graph_memload,

+ graph_netload2,

+ graph_swapload,

+ graph_loadavg,

+ graph_diskload,

+ graph_n,

+} E_graph;

+

+typedef enum {

+ memload_user = 0,

+ memload_shared,

+ memload_buffer,

+ memload_cached,

+ memload_free,

+ memload_n

+} E_memload;

+

+typedef enum {

+ cpuload_usr = 0,

+ cpuload_sys,

+ cpuload_nice,

+ cpuload_iowait,

+ cpuload_free,

+ cpuload_n

+} E_cpuload;

+

+typedef enum {

+ diskload_read = 0,

+ diskload_write,

+ diskload_free,

+ diskload_n

+} E_diskload;

+

+typedef enum {

+ swapload_used = 0,

+ swapload_free,

+ swapload_n

+} E_swapload;

+

+struct _LoadGraph {

+ MultiloadApplet *multiload;

+

+ guint n, id;

+ guint speed, size;

+ guint orient, pixel_size;

+ guint draw_width, draw_height;

+ LoadGraphDataFunc get_data;

+

+ guint allocated;

+

+ GdkRGBA *colors;

+ gint **data;

+ guint data_size;

+ guint *pos;

+

+ GtkWidget *main_widget;

+ GtkWidget *frame, *box, *disp;

+ cairo_surface_t *surface;

+ int timer_index;

+

+ gboolean visible;

+ gboolean tooltip_update;

+ const gchar *name;

+};

+

+struct _MultiloadApplet

+{

+ MatePanelApplet *applet;

+

+ GSettings *settings;

+

+ LoadGraph *graphs [graph_n];

+

+ GtkWidget *box;

+

+ gboolean view_cpuload;

+ gboolean view_memload;

+ gboolean view_netload;

+ gboolean view_swapload;

+ gboolean view_loadavg;

+ gboolean view_diskload;

+

+ GtkWidget *about_dialog;

+ GtkWidget *check_boxes [graph_n];

+ GtkWidget *prop_dialog;

+ GtkWidget *notebook;

+ int last_clicked;

+

+ float cpu_used_ratio;

+ long cpu_time [cpuload_n];

+ long cpu_last [cpuload_n];

+ int cpu_initialized;

+

+ double loadavg1;

+

+ guint64 memload_user;

+ guint64 memload_cache;

+ guint64 memload_total;

+

+ float swapload_used_ratio;

+

+ float diskload_used_ratio;

+ gboolean nvme_diskstats;

+

+ NetSpeed *netspeed_in;

+ NetSpeed *netspeed_out;

+ guint net_threshold1;

+ guint net_threshold2;

+ guint net_threshold3;

+};

+

+#include "load-graph.h"

+#include "linux-proc.h"

+

+/* show properties dialog */

+G_GNUC_INTERNAL void

+multiload_properties_cb (GtkAction *action,

+ MultiloadApplet *ma);

+

+/* remove the old graphs and rebuild them */

+G_GNUC_INTERNAL void

+multiload_applet_refresh (MultiloadApplet *ma);

+

+/* update the tooltip to the graph's current "used" percentage */

+G_GNUC_INTERNAL void

+multiload_applet_tooltip_update (LoadGraph *g);

+

+G_END_DECLS

+

+#endif

+/* From wmload.c, v0.9.2, licensed under the GPL. */

+#include <config.h>

+#include <sys/types.h>

+#include <sys/statvfs.h>

+#include <math.h>

+#include <fcntl.h>

+#include <unistd.h>

+

+#include <glibtop.h>

+#include <glibtop/cpu.h>

+#include <glibtop/mem.h>

+#include <glibtop/swap.h>

+#include <glibtop/loadavg.h>

+#include <glibtop/netload.h>

+#include <glibtop/netlist.h>

+#include <glibtop/mountlist.h>

+#include <glibtop/fsusage.h>

+

+#include "linux-proc.h"

+#include "autoscaler.h"

+

+static const unsigned needed_cpu_flags =

+(1 << GLIBTOP_CPU_USER) +

+(1 << GLIBTOP_CPU_IDLE) +

+(1 << GLIBTOP_CPU_SYS) +

+(1 << GLIBTOP_CPU_NICE);

+

+#if 0

+static const unsigned needed_page_flags =

+(1 << GLIBTOP_SWAP_PAGEIN) +

+(1 << GLIBTOP_SWAP_PAGEOUT);

+#endif

+

+static const unsigned needed_mem_flags =

+(1 << GLIBTOP_MEM_USED) +

+(1 << GLIBTOP_MEM_FREE);

+

+static const unsigned needed_swap_flags =

+(1 << GLIBTOP_SWAP_USED) +

+(1 << GLIBTOP_SWAP_FREE);

+

+static const unsigned needed_loadavg_flags =

+(1 << GLIBTOP_LOADAVG_LOADAVG);

+

+static const unsigned needed_netload_flags =

+(1 << GLIBTOP_NETLOAD_IF_FLAGS) +

+(1 << GLIBTOP_NETLOAD_BYTES_TOTAL);

+

+void

+GetLoad (int Maximum,

+ int data [cpuload_n],

+ LoadGraph *g)

+{

+ MultiloadApplet *multiload;

+ glibtop_cpu cpu;

+ long cpu_aux [cpuload_n], used = 0, total = 0;

+ int current_scaled, used_scaled = 0;

+ int i;

+

+ glibtop_get_cpu (&cpu);

+

+ g_return_if_fail ((cpu.flags & needed_cpu_flags) == needed_cpu_flags);

+

+ multiload = g->multiload;

+

+ multiload->cpu_time [cpuload_usr] = cpu.user;

+ multiload->cpu_time [cpuload_nice] = cpu.nice;

+ multiload->cpu_time [cpuload_sys] = cpu.sys;

+ multiload->cpu_time [cpuload_iowait] = cpu.iowait + cpu.irq + cpu.softirq;

+ multiload->cpu_time [cpuload_free] = cpu.idle;

+

+ if (!multiload->cpu_initialized) {

+ memcpy (multiload->cpu_last, multiload->cpu_time, sizeof (multiload->cpu_last));

+ multiload->cpu_initialized = 1;

+ }

+

+ for (i = 0; i < cpuload_n; i++) {

+ cpu_aux [i] = multiload->cpu_time [i] - multiload->cpu_last [i];

+ total += cpu_aux [i];

+ }

+

+ for (i = 0; i < cpuload_free; i++) {

+ used += cpu_aux [i];

+ current_scaled = rint ((float)(cpu_aux [i] * Maximum) / (float)total);

+ used_scaled += current_scaled;

+ data [i] = current_scaled;

+ }

+ data [cpuload_free] = Maximum - used_scaled;

+

+ multiload->cpu_used_ratio = (float)(used) / (float)total;

+

+ memcpy (multiload->cpu_last, multiload->cpu_time, sizeof multiload->cpu_last);

+}

+

+void

+GetDiskLoad (int Maximum,

+ int data [diskload_n],

+ LoadGraph *g)

+{

+ static gboolean first_call = TRUE;

+ static guint64 lastread = 0, lastwrite = 0;

+ static AutoScaler scaler;

+

+ guint i;

+ int max;

+

+ guint64 read, write;

+ guint64 readdiff, writediff;

+

+ MultiloadApplet *multiload;

+

+ multiload = g->multiload;

+

+

+ if(first_call)

+ {

+ autoscaler_init(&scaler, 60, 500);

+ }

+

+ read = write = 0;

+

+ if (multiload->nvme_diskstats)

+ {

+ FILE *fdr;

+ char line[255];

+ guint64 s_read, s_write;

+

+ fdr = fopen("/proc/diskstats", "r");

+ if (!fdr)

+ {

+ multiload->nvme_diskstats = FALSE;

+ g_settings_set_boolean (multiload->settings, "diskload-nvme-diskstats", FALSE);

+ return;

+ }

+

+ while (fgets(line, 255, fdr))

+ {

+ /* Match main device, rather than individual partitions (e.g. nvme0n1) */

+ if (!g_regex_match_simple("\\snvme\\d+\\w+\\d+\\s", line, 0, 0))

+ {

+ continue;

+ }

+

+ /*

+ 6 - sectors read

+ 10 - sectors written

+ */

+ if (sscanf(line, "%*d %*d %*s %*d %*d %ld %*d %*d %*d %ld", &s_read, &s_write) == 2)

+ {

+ read += 512 * s_read;

+ write += 512 * s_write;

+ }

+ }

+ fclose(fdr);

+ }

+ else

+ {

+ glibtop_mountlist mountlist;

+ glibtop_mountentry *mountentries;

+

+ mountentries = glibtop_get_mountlist (&mountlist, FALSE);

+

+ for (i = 0; i < mountlist.number; i++)

+ {

+ struct statvfs statresult;

+ glibtop_fsusage fsusage;

+

+ if (strstr (mountentries[i].devname, "/dev/") == NULL)

+ continue;

+

+ if (strstr (mountentries[i].mountdir, "/media/") != NULL)

+ continue;

+

+ if (statvfs (mountentries[i].mountdir, &statresult) < 0)

+ {

+ g_debug ("Failed to get statistics for mount entry: %s. Reason: %s. Skipping entry.",

+ mountentries[i].mountdir, strerror(errno));

+ continue;

+ }

+

+ glibtop_get_fsusage(&fsusage, mountentries[i].mountdir);

+ read += fsusage.read; write += fsusage.write;

+ }

+

+ g_free(mountentries);

+ }

+

+ readdiff = read - lastread;

+ writediff = write - lastwrite;

+

+ lastread = read;

+ lastwrite = write;

+

+ if(first_call)

+ {

+ first_call = FALSE;

+ memset(data, 0, 3 * sizeof data[0]);

+ return;

+ }

+

+ max = autoscaler_get_max(&scaler, readdiff + writediff);

+

+ multiload->diskload_used_ratio = (float)(readdiff + writediff) / (float)max;

+

+ data [diskload_read] = rint ((float)Maximum * (float)readdiff / (float)max);

+ data [diskload_write] = rint ((float)Maximum * (float)writediff / (float)max);

+ data [diskload_free] = Maximum - (data [0] + data[1]);

+}

+

+/* GNU/Linux:

+ * aux [memload_user] = (mem.total - mem.free) - (mem.cached + mem.buffer)

+ * aux [memload_shared] = mem.shared;

+ * aux [memload_cached] = mem.cached - mem.shared;

+ * aux [memload_buffer] = mem.buffer;

+ *

+ * Other operating systems:

+ * aux [memload_user] = mem.user;

+ * aux [memload_shared] = mem.shared;

+ * aux [memload_cached] = mem.cached;

+ * aux [memload_buffer] = mem.buffer;

+ */

+void

+GetMemory (int Maximum,

+ int data [memload_n],

+ LoadGraph *g)

+{

+ MultiloadApplet *multiload;

+ glibtop_mem mem;

+ guint64 aux [memload_n], cache = 0;

+ int current_scaled, used_scaled = 0;

+ int i;

+

+ glibtop_get_mem (&mem);

+

+ g_return_if_fail ((mem.flags & needed_mem_flags) == needed_mem_flags);

+

+#ifndef __linux__

+ aux [memload_user] = mem.user;

+ aux [memload_cached] = mem.cached;

+#else

+ aux [memload_user] = mem.total - mem.free - mem.buffer - mem.cached;;

+ aux [memload_cached] = mem.cached - mem.shared;

+#endif /* __linux__ */

+ aux [memload_shared] = mem.shared;

+ aux [memload_buffer] = mem.buffer;

+

+ for (i = 0; i < memload_free; i++) {

+ current_scaled = rint ((float)(aux [i] * Maximum) / (float)mem.total);

+ if (i != memload_user) {

+ cache += aux [i];

+ }

+ used_scaled += current_scaled;

+ data [i] = current_scaled;

+ }

+ data [memload_free] = MAX (Maximum - used_scaled, 0);

+

+ multiload = g->multiload;

+ multiload->memload_user = aux [memload_user];

+ multiload->memload_cache = cache;

+ multiload->memload_total = mem.total;

+}

+

+void

+GetSwap (int Maximum,

+ int data [swapload_n],

+ LoadGraph *g)

+{

+ int used;

+ MultiloadApplet *multiload;

+ glibtop_swap swap;

+

+ glibtop_get_swap (&swap);

+ g_return_if_fail ((swap.flags & needed_swap_flags) == needed_swap_flags);

+

+ multiload = g->multiload;

+

+ if (swap.total == 0) {

+ used = 0;

+ multiload->swapload_used_ratio = 0.0f;

+ }

+ else {

+ float ratio;

+

+ ratio = (float)swap.used / (float)swap.total;

+ used = rint ((float) Maximum * ratio);

+ multiload->swapload_used_ratio = ratio;

+ }

+

+ data [0] = used;

+ data [1] = Maximum - used;

+}

+

+void

+GetLoadAvg (int Maximum,

+ int data [2],

+ LoadGraph *g)

+{

+ glibtop_loadavg loadavg;

+ MultiloadApplet *multiload;

+

+ glibtop_get_loadavg (&loadavg);

+

+ g_return_if_fail ((loadavg.flags & needed_loadavg_flags) == needed_loadavg_flags);

+

+ multiload = g->multiload;

+ multiload->loadavg1 = loadavg.loadavg[0];

+

+ data [0] = rint ((float) Maximum * loadavg.loadavg[0]);

+ data [1] = Maximum - data[0];

+}

+

+/*

+ * Return true if a network device (identified by its name) is virtual

+ * (ie: not corresponding to a physical device). In case it is a physical

+ * device or unknown, returns false.

+ */

+static gboolean

+is_net_device_virtual(char *device)

+{

+ /*

+ * There is not definitive way to find out. On some systems (Linux

+ * kernels ≳ 2.19 without option SYSFS_DEPRECATED), there exist a

+ * directory /sys/devices/virtual/net which only contains virtual

+ * devices. It's also possible to detect by the fact that virtual

+ * devices do not have a symlink "device" in

+ * /sys/class/net/name-of-dev/ . This second method is more complex

+ * but more reliable.

+ */

+ gboolean ret = FALSE;

+ char *path = malloc (strlen (device) + strlen ("/sys/class/net//device") + 1);

+

+ if (path == NULL)

+ return FALSE;

+

+ /* Check if /sys/class/net/name-of-dev/ exists (may be old linux kernel

+ * or not linux at all). */

+ do {

+ if (sprintf(path, "/sys/class/net/%s", device) < 0)

+ break;

+ if (access(path, F_OK) != 0)

+ break; /* unknown */

+

+ if (sprintf(path, "/sys/class/net/%s/device", device) < 0)

+ break;

+ if (access(path, F_OK) != 0)

+ ret = TRUE;

+ } while (0);

+

+ free (path);

+ return ret;

+}

+

+void

+GetNet (int Maximum,

+ int data [4],

+ LoadGraph *g)

+{

+ enum Types {

+ IN_COUNT = 0,

+ OUT_COUNT = 1,

+ LOCAL_COUNT = 2,

+ COUNT_TYPES = 3

+ };

+

+ static int ticks = 0;

+ static gulong past[COUNT_TYPES] = {0};

+ static AutoScaler scaler;

+

+ gulong present[COUNT_TYPES] = {0};

+

+ guint i;

+ gchar **devices;

+ glibtop_netlist netlist;

+

+ MultiloadApplet *multiload;

+

+ multiload = g->multiload;

+

+ if(ticks == 0)

+ {

+ autoscaler_init(&scaler, 60, 501);

+ }

+

+ devices = glibtop_get_netlist(&netlist);

+

+ for(i = 0; i < netlist.number; ++i)

+ {

+ glibtop_netload netload;

+

+ glibtop_get_netload(&netload, devices[i]);

+

+ g_return_if_fail((netload.flags & needed_netload_flags) == needed_netload_flags);

+

+ if (!(netload.if_flags & (1L << GLIBTOP_IF_FLAGS_UP)))

+ continue;

+

+ if (netload.if_flags & (1L << GLIBTOP_IF_FLAGS_LOOPBACK)) {

+ /* for loopback in and out are identical, so only count in */

+ present[LOCAL_COUNT] += netload.bytes_in;

+ continue;

+ }

+

+ /*

+ * Do not include virtual devices (VPN, PPPOE...) to avoid

+ * counting the same throughput several times.

+ */

+ if (is_net_device_virtual(devices[i]))

+ continue;

+

+ present[IN_COUNT] += netload.bytes_in;

+ present[OUT_COUNT] += netload.bytes_out;

+ }

+

+ g_strfreev(devices);

+ netspeed_add (multiload->netspeed_in, present[IN_COUNT]);

+ netspeed_add (multiload->netspeed_out, present[OUT_COUNT]);

+

+ if(ticks < 2) /* avoid initial spike */

+ {

+ ticks++;

+ memset(data, 0, COUNT_TYPES * sizeof data[0]);

+ }

+ else

+ {

+ int delta[COUNT_TYPES];

+

+ for (i = 0; i < COUNT_TYPES; i++)

+ {

+ /* protect against weirdness */

+ if (present[i] >= past[i])

+ delta[i] = (present[i] - past[i]);

+ else

+ delta[i] = 0;

+ }

+

+ for (i = 0; i < COUNT_TYPES; i++)

+ data[i] = delta[i];

+

+ }

+

+ memcpy(past, present, sizeof past);

+}

+#ifndef LINUX_PROC_H__

+#define LINUX_PROC_H__

+

+#include <load-graph.h>

+

+G_GNUC_INTERNAL void GetLoad (int Maximum, int data [cpuload_n], LoadGraph *g);

+G_GNUC_INTERNAL void GetDiskLoad (int Maximum, int data [diskload_n], LoadGraph *g);

+G_GNUC_INTERNAL void GetMemory (int Maximum, int data [memload_n], LoadGraph *g);

+G_GNUC_INTERNAL void GetSwap (int Maximum, int data [swapload_n], LoadGraph *g);

+G_GNUC_INTERNAL void GetLoadAvg (int Maximum, int data [2], LoadGraph *g);

+G_GNUC_INTERNAL void GetNet (int Maximum, int data [4], LoadGraph *g);

+

+#endif

+#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 <glib.h>

+#include <gdk/gdkx.h>

+#include <gtk/gtk.h>

+#include <gio/gio.h>

+#include <mate-panel-applet.h>

+#include <mate-panel-applet-gsettings.h>

+#include <math.h>

+

+#include "global.h"

+

+/*

+ Shifts data right

+

+ data[i+1] = data[i]

+

+ data[i] are int*, so we just move the pointer, not the data.

+ But moving data loses data[n-1], so we save data[n-1] and reuse

+ it as new data[0]. In fact, we rotate data[].

+

+*/

+

+static void

+shift_right(LoadGraph *g)

+{

+ unsigned i;

+ int* last_data;

+

+ /* data[g->draw_width - 1] becomes data[0] */

+ last_data = g->data[g->draw_width - 1];

+

+ /* data[i+1] = data[i] */

+ for(i = g->draw_width - 1; i != 0; --i)

+ g->data[i] = g->data[i - 1];

+

+ g->data[0] = last_data;

+}

+

+

+/* Redraws the backing pixmap for the load graph and updates the window */

+static void

+load_graph_draw (LoadGraph *g)

+{

+ guint i, j, k;

+ cairo_t *cr;

+ int load;

+ MultiloadApplet *multiload;

+

+ multiload = g->multiload;

+

+ /* we might get called before the configure event so that

+ * g->disp->allocation may not have the correct size

+ * (after the user resized the applet in the prop dialog). */

+

+ if (!g->surface)

+ g->surface = gdk_window_create_similar_surface (gtk_widget_get_window (g->disp),

+ CAIRO_CONTENT_COLOR,

+ g->draw_width, g->draw_height);

+

+ cr = cairo_create (g->surface);

+ cairo_set_line_width (cr, 1.0);

+ cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);

+ cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);

+

+ /* all graphs except Load and Net go this path */

+ if (g->id != graph_loadavg && g->id != graph_netload2)

+ {

+ for (i = 0; i < g->draw_width; i++)

+ g->pos [i] = g->draw_height - 1;

+

+ for (j = 0; j < g->n; j++)

+ {

+ gdk_cairo_set_source_rgba (cr, &(g->colors [j]));

+

+ for (i = 0; i < g->draw_width; i++)

+ {

+ if (g->data [i][j] != 0)

+ {

+ cairo_move_to (cr, g->draw_width - i - 0.5, g->pos[i] + 0.5);

+ cairo_line_to (cr, g->draw_width - i - 0.5, g->pos[i] - (g->data [i][j] - 0.5));

+ }

+ g->pos [i] -= g->data [i][j];

+ }

+ cairo_stroke (cr);

+ }

+ }

+ /* This is for network graph */

+ else if (g->id == graph_netload2)

+ {

+ guint maxnet = 1;

+ gint segments = 1;

+ gint combined;

+ guint net_threshold;

+

+ for (i = 0; i < g->draw_width; i++)

+ {

+ g->pos [i] = g->draw_height - 1;

+ combined = g->data[i][0] +

+ g->data[i][1] +

+ g->data[i][2];

+ if (combined > maxnet)

+ maxnet = combined;

+ }

+ //printf("max = %d ", maxnet);

+ guint level = 0;

+ if (maxnet > multiload->net_threshold3) {

+ net_threshold = multiload->net_threshold3;

+ level = 3;

+ }

+ else

+ if (maxnet > multiload->net_threshold2) {

+ net_threshold = multiload->net_threshold2;

+ level = 2;

+ }

+ else {

+ net_threshold = multiload->net_threshold1;

+ level = 1;

+ if (maxnet < multiload->net_threshold1)

+ level = 0;

+ }

+

+ //printf("level %d maxnet = %d ", level, maxnet);

+ maxnet = maxnet/net_threshold;

+ segments = MAX (maxnet+1,1);

+ float ratio = (float)g->draw_height/net_threshold/segments;

+ //printf("segments %d ratio = %f t1=%ld t2=%ld t3=%ld t=%ld\n", segments, ratio, multiload->net_threshold1, multiload->net_threshold2, multiload->net_threshold3, multiload->net_threshold);

+

+ for (j = 0; j < g->n-1; j++)

+ {

+ gdk_cairo_set_source_rgba (cr, &(g->colors [j]));

+

+ for (i = 0; i < g->draw_width; i++)

+ {

+ cairo_move_to (cr, g->draw_width - i - 0.5, g->pos[i] + 0.5);

+ cairo_line_to (cr, g->draw_width - i - 0.5, g->pos[i] - 0.5 - ((g->data [i][j] * ratio)));

+ g->pos [i] -= ((g->data [i][j] * ratio));

+ }

+ cairo_stroke (cr);

+ }

+

+ for (j = g->n-1; j < g->n; j++)

+ {

+ gdk_cairo_set_source_rgba (cr, &(g->colors [j]));

+ for (i = 0; i < g->draw_width; i++)

+ {

+ cairo_move_to (cr, g->draw_width - i - 0.5, g->pos[i] + 0.5);

+ cairo_line_to (cr, g->draw_width - i - 0.5, 0.5);

+ }

+ cairo_stroke (cr);

+ }

+

+ /* draw grid lines if needed */

+ gdk_cairo_set_source_rgba (cr, &(g->colors [4]));

+ double spacing;

+ for (k = 0; k < segments -1; k++)

+ {

+ spacing = ((double) g->draw_height/segments) * (k+1);

+ cairo_move_to (cr, 0.5, spacing);

+ cairo_line_to (cr, g->draw_width-0.5, spacing);

+ }

+ cairo_stroke (cr);

+ /* draw indicator if needed */

+ if (level > 0)

+ {

+ gdk_cairo_set_source_rgba (cr, &(g->colors [5]));

+ for (k = 0; k< level; k++ )

+ cairo_rectangle(cr, 0.5, (k*2) * g->draw_height/5, 5, g->draw_height/5);

+ cairo_fill(cr);

+ }

+ cairo_stroke (cr);

+ }

+ /* this is Load graph */

+ else

+ {

+ guint maxload = 1;

+ for (i = 0; i < g->draw_width; i++)

+ {

+ g->pos [i] = g->draw_height - 1;

+ /* find maximum value */

+ if (g->data[i][0] > maxload)

+ maxload = g->data[i][0];

+ }

+ load = ceil ((double) (maxload/g->draw_height)) + 1;

+ load = MAX (load,1);

+

+ for (j = 0; j < g->n; j++)

+ {

+ gdk_cairo_set_source_rgba (cr, &(g->colors [j]));

+

+ for (i = 0; i < g->draw_width; i++)

+ {

+ cairo_move_to (cr, g->draw_width - i - 0.5, g->pos[i] + 0.5);

+ if (j == 0)

+ {

+ cairo_line_to (cr, g->draw_width - i - 0.5, g->pos[i] - ((g->data [i][j] - 0.5)/load));

+ }

+ else

+ {

+ cairo_line_to (cr, g->draw_width - i - 0.5, 0.5);

+ }

+ g->pos [i] -= g->data [i][j] / load;

+ }

+ cairo_stroke (cr);

+ }

+

+ /* draw grid lines in Load graph if needed */

+ gdk_cairo_set_source_rgba (cr, &(g->colors [2]));

+

+ double spacing;

+ for (k = 0; k < load - 1; k++)

+ {

+ spacing = ((double) g->draw_height/load) * (k+1);

+ cairo_move_to (cr, 0.5, spacing);

+ cairo_line_to (cr, g->draw_width-0.5, spacing);

+ }

+

+ cairo_stroke (cr);

+ }

+ gtk_widget_queue_draw (g->disp);

+

+ cairo_destroy (cr);

+}

+

+/* Updates the load graph when the timeout expires */

+static gboolean

+load_graph_update (LoadGraph *g)

+{

+ if (g->data == NULL)

+ return TRUE;

+

+ shift_right(g);

+

+ if (g->tooltip_update)

+ multiload_applet_tooltip_update(g);

+

+ g->get_data (g->draw_height, g->data [0], g);

+

+ load_graph_draw (g);

+ return TRUE;

+}

+

+void

+load_graph_unalloc (LoadGraph *g)

+{

+ guint i;

+

+ if (!g->allocated)

+ return;

+

+ for (i = 0; i < g->draw_width; i++)

+ {

+ g_free (g->data [i]);

+ }

+

+ g_free (g->data);

+ g_free (g->pos);

+

+ g->pos = NULL;

+ g->data = NULL;

+

+ g->size = g_settings_get_int(g->multiload->settings, "size");

+ g->size = MAX (g->size, 10);

+

+ if (g->surface) {

+ cairo_surface_destroy (g->surface);

+ g->surface = NULL;

+ }

+

+ g->allocated = FALSE;

+}

+

+static void

+load_graph_alloc (LoadGraph *g)

+{

+ guint i;

+

+ if (g->allocated)

+ return;

+

+ g->data = g_new0 (gint *, g->draw_width);

+ g->pos = g_new0 (guint, g->draw_width);

+

+ g->data_size = sizeof (guint) * g->n;

+

+ for (i = 0; i < g->draw_width; i++) {

+ g->data [i] = g_malloc0 (g->data_size);

+ }

+

+ g->allocated = TRUE;

+}

+

+static gint

+load_graph_configure (GtkWidget *widget, GdkEventConfigure *event,

+ gpointer data_ptr)

+{

+ GtkAllocation allocation;

+ LoadGraph *c = (LoadGraph *) data_ptr;

+

+ load_graph_unalloc (c);

+

+ gtk_widget_get_allocation (c->disp, &allocation);

+

+ c->draw_width = allocation.width;

+ c->draw_height = allocation.height;

+ c->draw_width = MAX (c->draw_width, 1);

+ c->draw_height = MAX (c->draw_height, 1);

+

+ load_graph_alloc (c);

+

+ if (!c->surface)

+ c->surface = gdk_window_create_similar_surface (gtk_widget_get_window (c->disp),

+ CAIRO_CONTENT_COLOR,

+ c->draw_width, c->draw_height);

+ gtk_widget_queue_draw (widget);

+

+ return TRUE;

+}

+

+static gint

+load_graph_expose (GtkWidget *widget,

+ cairo_t *cr,

+ gpointer data_ptr)

+{

+ LoadGraph *g = (LoadGraph *) data_ptr;

+

+ cairo_set_source_surface (cr, g->surface, 0, 0);

+ cairo_paint (cr);

+

+ return FALSE;

+}

+

+static void

+load_graph_destroy (GtkWidget *widget, gpointer data_ptr)

+{

+ LoadGraph *g = (LoadGraph *) data_ptr;

+

+ load_graph_stop (g);

+

+ gtk_widget_destroy(widget);

+}

+

+static gboolean

+load_graph_clicked (GtkWidget *widget, GdkEventButton *event, LoadGraph *load)

+{

+ load->multiload->last_clicked = load->id;

+

+ return FALSE;

+}

+

+static gboolean

+load_graph_enter_cb(GtkWidget *widget, GdkEventCrossing *event, gpointer data)

+{

+ LoadGraph *graph;

+ graph = (LoadGraph *)data;

+

+ graph->tooltip_update = TRUE;

+ multiload_applet_tooltip_update(graph);

+

+ return TRUE;

+}

+

+static gboolean

+load_graph_leave_cb(GtkWidget *widget, GdkEventCrossing *event, gpointer data)

+{

+ LoadGraph *graph;

+ graph = (LoadGraph *)data;

+

+ graph->tooltip_update = FALSE;

+

+ return TRUE;

+}

+

+static void

+load_graph_load_config (LoadGraph *g)

+{

+ gchar *name, *temp;

+ guint i;

+

+ if (!g->colors)

+ g->colors = g_new0(GdkRGBA, g->n);

+

+ for (i = 0; i < g->n; i++)

+ {

+ name = g_strdup_printf ("%s-color%u", g->name, i);

+ temp = g_settings_get_string(g->multiload->settings, name);

+ if (!temp)

+ temp = g_strdup ("#000000");

+ gdk_rgba_parse(&(g->colors[i]), temp);

+ g_free(temp);

+ g_free(name);

+ }

+}

+

+LoadGraph *

+load_graph_new (MultiloadApplet *ma, guint n, const gchar *label,

+ guint id, guint speed, guint size, gboolean visible,

+ const gchar *name, LoadGraphDataFunc get_data)

+{

+ LoadGraph *g;

+ MatePanelAppletOrient orient;

+

+ g = g_new0 (LoadGraph, 1);

+ g->visible = visible;

+ g->name = name;

+ g->n = n;

+ g->id = id;

+ g->speed = MAX (speed, 50);

+ g->size = MAX (size, 10);

+ g->pixel_size = mate_panel_applet_get_size (ma->applet);

+ g->tooltip_update = FALSE;

+ g->multiload = ma;

+

+ g->main_widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);

+

+ g->box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);

+

+ orient = mate_panel_applet_get_orient (g->multiload->applet);

+ switch (orient)

+ {

+ case MATE_PANEL_APPLET_ORIENT_UP:

+ case MATE_PANEL_APPLET_ORIENT_DOWN:

+ {

+ g->orient = FALSE;

+ break;

+ }

+ case MATE_PANEL_APPLET_ORIENT_LEFT:

+ case MATE_PANEL_APPLET_ORIENT_RIGHT:

+ {

+ g->orient = TRUE;

+ break;

+ }

+ default:

+ g_assert_not_reached ();

+ }

+

+ g->frame = gtk_frame_new (NULL);

+ gtk_frame_set_shadow_type (GTK_FRAME (g->frame), GTK_SHADOW_IN);

+ gtk_container_add (GTK_CONTAINER (g->frame), g->box);

+ gtk_box_pack_start (GTK_BOX (g->main_widget), g->frame, TRUE, TRUE, 0);

+

+ load_graph_load_config (g);

+

+ g->get_data = get_data;

+

+ g->timer_index = -1;

+

+ if (g->orient)

+ gtk_widget_set_size_request (g->main_widget, -1, g->size);

+ else

+ gtk_widget_set_size_request (g->main_widget, g->size, -1);

+

+ g->disp = gtk_drawing_area_new ();

+ gtk_widget_set_events (g->disp, GDK_EXPOSURE_MASK |

+ GDK_ENTER_NOTIFY_MASK |

+ GDK_LEAVE_NOTIFY_MASK |

+ GDK_BUTTON_PRESS_MASK);

+

+ g_signal_connect (G_OBJECT (g->disp), "draw",

+ G_CALLBACK (load_graph_expose), g);

+ g_signal_connect (G_OBJECT(g->disp), "configure_event",

+ G_CALLBACK (load_graph_configure), g);

+ g_signal_connect (G_OBJECT(g->disp), "destroy",

+ G_CALLBACK (load_graph_destroy), g);

+ g_signal_connect (G_OBJECT(g->disp), "button-press-event",

+ G_CALLBACK (load_graph_clicked), g);

+ g_signal_connect (G_OBJECT(g->disp), "enter-notify-event",

+ G_CALLBACK(load_graph_enter_cb), g);

+ g_signal_connect (G_OBJECT(g->disp), "leave-notify-event",

+ G_CALLBACK(load_graph_leave_cb), g);

+

+ gtk_box_pack_start (GTK_BOX (g->box), g->disp, TRUE, TRUE, 0);

+ gtk_widget_show_all(g->box);

+

+ return g;

+}

+

+void

+load_graph_start (LoadGraph *g)

+{

+ if (g->timer_index != -1)

+ g_source_remove (g->timer_index);

+

+ g->timer_index = g_timeout_add (g->speed,

+ (GSourceFunc) load_graph_update, g);

+}

+

+void

+load_graph_stop (LoadGraph *g)

+{

+ if (g->timer_index != -1)

+ g_source_remove (g->timer_index);

+

+ g->timer_index = -1;

+}

+#ifndef LOAD_GRAPH_H__

+#define LOAD_GRAPH_H__

+

+#include "global.h"

+

+/* Create new load graph. */

+G_GNUC_INTERNAL LoadGraph *

+load_graph_new (MultiloadApplet *multiload, guint n, const gchar *label,

+ guint id, guint speed, guint size, gboolean visible,

+ const gchar *name, LoadGraphDataFunc get_data);

+

+/* Start load graph. */

+G_GNUC_INTERNAL void

+load_graph_start (LoadGraph *g);

+

+/* Stop load graph. */

+G_GNUC_INTERNAL void

+load_graph_stop (LoadGraph *g);

+

+/* free load graph */

+G_GNUC_INTERNAL void

+load_graph_unalloc (LoadGraph *g);

+

+#endif

+/* 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 <gtk/gtk.h>

+#include <gdk/gdkkeysyms.h>

+#include <gdk-pixbuf/gdk-pixbuf.h>

+#include <gio/gio.h>

+#include <gio/gdesktopappinfo.h>

+#include <mate-panel-applet.h>

+#include <mate-panel-applet-gsettings.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* documenters[] =

+ {

+ "Chee Bin HOH <[email protected]>",

+ N_("Sun GNOME Documentation Team <[email protected]>"),

+ N_("MATE Documentation Team"),

+ NULL

+ };

+

+#ifdef ENABLE_NLS

+ const char **p;

+ for (p = documenters; *p; ++p)

+ *p = _(*p);

+#endif

+

+ gtk_show_about_dialog (NULL,

+ "title", _("About System Monitor"),

+ "version", VERSION,

+ "copyright", _("Copyright \xc2\xa9 1999-2005 Free Software Foundation and others\n"

+ "Copyright \xc2\xa9 2012-2020 MATE developers"),

+ "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_on_window (NULL,

+ "help:mate-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;

+ GDesktopAppInfo *appinfo;

+ gchar *monitor;

+ GdkAppLaunchContext *launch_context;

+ GdkDisplay *display;

+ GAppInfo *app_info;

+ GdkScreen *screen;

+

+ g_return_if_fail (ma != NULL);

+

+ monitor = g_settings_get_string (ma->settings, "system-monitor");

+ if (monitor == NULL)

+ monitor = g_strdup ("mate-system-monitor.desktop");

+

+ screen = gtk_widget_get_screen (GTK_WIDGET (ma->applet));

+ appinfo = g_desktop_app_info_new (monitor);

+ if (appinfo) {

+ GdkAppLaunchContext *context;

+ display = gdk_screen_get_display (screen);

+ context = gdk_display_get_app_launch_context (display);

+ gdk_app_launch_context_set_screen (context, screen);

+ g_app_info_launch (G_APP_INFO (appinfo), NULL, G_APP_LAUNCH_CONTEXT (context), &error);

+ g_object_unref (context);

+ g_object_unref (appinfo);

+ }

+ else {

+ app_info = g_app_info_create_from_commandline ("mate-system-monitor",

+ _("Start system-monitor"),

+ G_APP_INFO_CREATE_NONE,

+ &error);

+

+ if (!error) {

+ display = gdk_screen_get_display (screen);

+ launch_context = gdk_display_get_app_launch_context (display);

+ gdk_app_launch_context_set_screen (launch_context, screen);

+ g_app_info_launch (app_info, NULL, G_APP_LAUNCH_CONTEXT (launch_context), &error);

+

+ g_object_unref (launch_context);

+ }

+ }

+ 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), screen);

+

+ 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 < graph_n; 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]);

+ }

+

+ netspeed_delete (ma->netspeed_in);

+ netspeed_delete (ma->netspeed_out);

+

+ 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_KEY_KP_Enter:

+ case GDK_KEY_ISO_Enter:

+ case GDK_KEY_3270_Enter:

+ case GDK_KEY_Return:

+ case GDK_KEY_space:

+ case GDK_KEY_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;

+ MultiloadApplet *multiload;

+ const char *tooltip_label [graph_n] = {

+ [graph_cpuload] = N_("Processor"),

+ [graph_memload] = N_("Memory"),

+ [graph_netload2] = N_("Network"),

+ [graph_swapload] = N_("Swap Space"),

+ [graph_loadavg] = N_("Load Average"),

+ [graph_diskload] = N_("Disk")

+ };

+ const char *name;

+

+ g_assert(g);

+

+ multiload = g->multiload;

+

+ /* label the tooltip intuitively */

+ name = gettext (tooltip_label [g->id]);

+

+ switch (g->id) {

+ case graph_memload: {

+ float user_percent, cache_percent;

+

+ user_percent = MIN ((float)(100 * multiload->memload_user) / (float)(multiload->memload_total), 100.0f);

+ cache_percent = MIN ((float)(100 * multiload->memload_cache) / (float)(multiload->memload_total), 100.0f);

+ tooltip_text = g_strdup_printf (_("%s:\n"

+ "%.01f%% in use by programs\n"

+ "%.01f%% in use as cache"),

+ name,

+ user_percent,

+ cache_percent);

+ break;

+ }

+ case graph_loadavg: {

+ tooltip_text = g_strdup_printf (_("The system load average is %0.02f"),

+ multiload->loadavg1);

+ break;

+ }

+ case graph_netload2: {

+ char *tx_in, *tx_out;

+

+ tx_in = netspeed_get(multiload->netspeed_in);

+ tx_out = netspeed_get(multiload->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);

+ break;

+ }

+ default: {

+ float ratio;

+ float percent;

+

+ if (g->id == graph_cpuload)

+ ratio = multiload->cpu_used_ratio;

+ else if (g->id == graph_swapload)

+ ratio = multiload->swapload_used_ratio;

+ else if (g->id == graph_diskload)

+ ratio = multiload->diskload_used_ratio;

+ else

+ g_assert_not_reached ();

+

+ percent = CLAMP (ratio * 100.0f, 0.0f, 100.0f);

+ tooltip_text = g_strdup_printf(_("%s:\n"

+ "%.01f%% in use"),

+ name,

+ percent);

+ }

+ }

+

+ gtk_widget_set_tooltip_text(g->disp, tooltip_text);

+

+ g_free(tooltip_text);

+}

+

+static void

+multiload_create_graphs(MultiloadApplet *ma)

+{

+ struct { const char *label;

+ const char *visibility_key;

+ const char *name;

+ int num_colours;

+ LoadGraphDataFunc callback;

+ } graph_types [graph_n] = {

+ [graph_cpuload] = { _("CPU Load"), VIEW_CPULOAD_KEY, "cpuload", cpuload_n, GetLoad },

+ [graph_memload] = { _("Memory Load"), VIEW_MEMLOAD_KEY, "memload", memload_n, GetMemory },

+ [graph_netload2] = { _("Net Load"), VIEW_NETLOAD_KEY, "netload2", 6, GetNet },

+ [graph_swapload] = { _("Swap Load"), VIEW_SWAPLOAD_KEY, "swapload", swapload_n, GetSwap },

+ [graph_loadavg] = { _("Load Average"), VIEW_LOADAVG_KEY, "loadavg", 3, GetLoadAvg },

+ [graph_diskload] = { _("Disk Load"), VIEW_DISKLOAD_KEY, "diskload", diskload_n, GetDiskLoad }

+ };

+

+ gint speed, size;

+ guint net_threshold1;

+ guint net_threshold2;

+ guint net_threshold3;

+ gint i;

+

+ speed = g_settings_get_int (ma->settings, "speed");

+ size = g_settings_get_int (ma->settings, "size");

+ net_threshold1 = CLAMP (g_settings_get_uint (ma->settings, "netthreshold1"), MIN_NET_THRESHOLD1, MAX_NET_THRESHOLD1);

+ net_threshold2 = CLAMP (g_settings_get_uint (ma->settings, "netthreshold2"), MIN_NET_THRESHOLD2, MAX_NET_THRESHOLD2);

+ net_threshold3 = CLAMP (g_settings_get_uint (ma->settings, "netthreshold3"), MIN_NET_THRESHOLD3, MAX_NET_THRESHOLD3);

+ if (net_threshold1 >= net_threshold2)

+ {

+ net_threshold1 = net_threshold2 - 1;

+ }

+ if (net_threshold2 >= net_threshold3)

+ {

+ net_threshold3 = net_threshold2 + 1;

+ }

+ speed = MAX (speed, 50);

+ size = CLAMP (size, 10, 400);

+

+ for (i = 0; i < graph_n; i++)

+ {

+ ma->graphs[i] = load_graph_new (ma,

+ graph_types[i].num_colours,

+ graph_types[i].label,

+ i,

+ speed,

+ size,

+ g_settings_get_boolean (ma->settings, graph_types[i].visibility_key),

+ graph_types[i].name,

+ graph_types[i].callback);

+ }

+ ma->nvme_diskstats = g_settings_get_boolean (ma->settings, "diskload-nvme-diskstats");

+ /* for Network graph, colors[4] is grid line color, it should not be used in loop in load-graph.c */

+ /* for Network graph, colors[5] is indicator color, it should not be used in loop in load-graph.c */

+ ma->graphs[graph_netload2]->n = 4;

+ ma->net_threshold1 = net_threshold1;

+ ma->net_threshold2 = net_threshold2;

+ ma->net_threshold3 = net_threshold3;

+ ma->netspeed_in = netspeed_new (ma->graphs [graph_netload2]);

+ ma->netspeed_out = netspeed_new (ma->graphs [graph_netload2]);

+ /* for Load graph, colors[2] is grid line color, it should not be used in loop in load-graph.c */

+ ma->graphs[graph_loadavg]->n = 2;

+}

+

+/* 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 < graph_n; 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_box_new (GTK_ORIENTATION_HORIZONTAL, 0);

+ }

+ else

+ ma->box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);

+

+ gtk_container_add(GTK_CONTAINER(ma->applet), ma->box);

+

+ /* create the N graphs, passing in their user-configurable properties with gsettings. */

+ multiload_create_graphs (ma);

+

+ /* only start and display the graphs the user has turned on */

+

+ for (i = 0; i < graph_n; 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", "document-properties", N_("_Preferences"),

+ NULL, NULL,

+ G_CALLBACK (multiload_properties_cb) },

+ { "MultiLoadRunProcman", "system-run", N_("_Open System Monitor"),

+ NULL, NULL,

+ G_CALLBACK (start_procman_cb) },

+ { "MultiLoadHelp", "help-browser", N_("_Help"),

+ NULL, NULL,

+ G_CALLBACK (help_cb) },

+ { "MultiLoadAbout", "help-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)

+{

+ GtkStyleContext *context;

+ MultiloadApplet *ma;

+ GSettings *lockdown_settings;

+ GtkActionGroup *action_group;

+

+ context = gtk_widget_get_style_context (GTK_WIDGET (applet));

+ gtk_style_context_add_class (context, "multiload-applet");

+

+ 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");

+

+ ma->settings = mate_panel_applet_settings_new (applet, "org.mate.panel.applet.multiload");

+ 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);

+ mate_panel_applet_setup_menu_from_file (applet,

+ MULTILOAD_MENU_UI_DIR "multiload-applet-menu.xml",

+ action_group);

+

+ 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);

+ }

+

+ lockdown_settings = g_settings_new ("org.mate.lockdown");

+ if (g_settings_get_boolean (lockdown_settings, "disable-command-line") ||

+ 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 (lockdown_settings);

+

+ 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)

+#include <config.h>

+#include <glib.h>

+#include <time.h>

+

+#include "netspeed.h"

+

+enum { N_STATES = 4 };

+

+struct _NetSpeed

+{

+ LoadGraph *graph;

+ gulong states[N_STATES];

+ size_t cur;

+};

+

+NetSpeed* netspeed_new(LoadGraph *g)

+{

+ NetSpeed *ns = g_new0(NetSpeed, 1);

+ ns->graph = g;

+ return ns;

+}

+

+void netspeed_delete(NetSpeed *ns)

+{

+ g_free(ns);

+}

+

+void netspeed_add(NetSpeed *ns, gulong tx)

+{

+ ns->cur = (ns->cur + 1) % N_STATES;

+ ns->states[ns->cur] = tx;

+}

+

+/* Something very similar to g_format_size() but for rates.

+ * This should give the same display as in g-s-m */

+static char*

+format_rate_for_display(guint rate)

+{

+ char *bytes;

+ char *text;

+

+ bytes = g_format_size (rate);

+ text = g_strdup_printf (_("%s/s"), bytes);

+ g_free (bytes);

+

+ return text;

+}

+

+char* netspeed_get(NetSpeed *ns)

+{

+ gulong older, newer;

+ guint rate;

+

+ newer = ns->states[ns->cur];

+ older = ns->states[(ns->cur + 1) % N_STATES];

+

+ if ((older != 0) && (newer > older))

+ rate = (newer - older) * 1000 / ((N_STATES - 1) * ns->graph->speed);

+ else

+ /* We end up here if we haven't got enough data yet or the

+ network interface has jumped back (or there has never

+ been any activity on any interface). A value of 0 is

+ likely to be accurate, but if it is wrong it will be

+ clearly wrong. In any event, it should fix itself in a

+ few seconds. */

+ rate = 0;

+

+ return format_rate_for_display(rate);

+}

+

+#ifndef H_MULTILOAD_NETSPEED_

+#define H_MULTILOAD_NETSPEED_

+

+#include <glib.h>

+

+typedef struct _NetSpeed NetSpeed;

+

+#include "global.h"

+

+NetSpeed* netspeed_new(LoadGraph *graph);

+void netspeed_delete(NetSpeed *ns);

+void netspeed_add(NetSpeed *ns, gulong tx);

+char* netspeed_get(NetSpeed *ns);

+

+#endif /* H_MULTILOAD_NETSPEED_ */

+/* MATE cpuload/memload panel applet

+ * (C) 2002 The Free Software Foundation

+ *

+ * Authors:

+ * Todd Kulesza

+ *

+ *

+ */

+

+#ifdef HAVE_CONFIG_H

+#include <config.h>

+#endif

+

+#include <string.h>

+

+#include <gtk/gtk.h>

+

+#include <gio/gio.h>

+#include <mate-panel-applet.h>

+#include <mate-panel-applet-gsettings.h>

+

+#include "global.h"

+

+#define PROP_CPU 0

+#define PROP_MEM 1

+#define PROP_NET 2

+#define PROP_SWAP 3

+#define PROP_AVG 4

+#define PROP_DISK 5

+

+#define PROP_SPEED 6

+#define PROP_SIZE 7

+#define PROP_NET_THRESHOLD1 8

+#define PROP_NET_THRESHOLD2 9

+#define PROP_NET_THRESHOLD3 10

+#define HIG_IDENTATION " "

+#define NEVER_SENSITIVE "never_sensitive"

+

+/* set sensitive and setup NEVER_SENSITIVE appropriately */

+static void

+hard_set_sensitive (GtkWidget *w, gboolean sensitivity)

+{

+ gtk_widget_set_sensitive (w, sensitivity);

+ g_object_set_data (G_OBJECT (w), NEVER_SENSITIVE,

+ GINT_TO_POINTER ( ! sensitivity));

+}

+

+

+/* set sensitive, but always insensitive if NEVER_SENSITIVE is set */

+static void

+soft_set_sensitive (GtkWidget *w, gboolean sensitivity)

+{

+ if (g_object_get_data (G_OBJECT (w), NEVER_SENSITIVE))

+ gtk_widget_set_sensitive (w, FALSE);

+ else

+ gtk_widget_set_sensitive (w, sensitivity);

+}

+

+static void

+properties_set_insensitive(MultiloadApplet *ma)

+{

+ gint i, total_graphs, last_graph;

+

+ total_graphs = 0;

+ last_graph = 0;

+

+ for (i = 0; i < graph_n; i++)

+ if (ma->graphs[i]->visible)

+ {

+ last_graph = i;

+ total_graphs++;

+ }

+

+ if (total_graphs < 2)

+ soft_set_sensitive(ma->check_boxes[last_graph], FALSE);

+

+ return;

+}

+

+static void

+properties_close_cb (GtkWidget *widget, gint arg, MultiloadApplet *ma)

+{

+ GError *error = NULL;

+

+ switch (arg)

+ {

+ case GTK_RESPONSE_HELP:

+

+ gtk_show_uri_on_window (NULL,

+ "help:mate-multiload/multiload-prefs",

+ 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;

+ }

+ break;

+

+ case GTK_RESPONSE_CLOSE:

+ default:

+ gtk_widget_destroy (widget);

+ ma->prop_dialog = NULL;

+ }

+}

+

+static void

+property_toggled_cb(GtkWidget *widget, gpointer name)

+{

+ MultiloadApplet *ma;

+ gint prop_type, i;

+ gboolean active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));

+

+ ma = g_object_get_data(G_OBJECT(widget), "MultiloadApplet");

+ prop_type = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "prop_type"));

+

+ /* FIXME: the first toggle button to be checked/dechecked does not work, but after that everything is cool. what gives? */

+ /* FIXME: check if this is still valid for gsettings */

+ g_settings_set_boolean (ma->settings, (gchar *)name, active);

+ g_settings_set_boolean (ma->settings, (gchar *)name, active);

+

+ if (active)

+ {

+ for (i = 0; i < graph_n; i++)

+ soft_set_sensitive(ma->check_boxes[i], TRUE);

+ gtk_widget_show_all (ma->graphs[prop_type]->main_widget);

+ ma->graphs[prop_type]->visible = TRUE;

+ load_graph_start(ma->graphs[prop_type]);

+ }

+ else

+ {

+ load_graph_stop(ma->graphs[prop_type]);

+ gtk_widget_hide (ma->graphs[prop_type]->main_widget);

+ ma->graphs[prop_type]->visible = FALSE;

+ properties_set_insensitive(ma);

+ }

+

+ return;

+}

+

+static void

+spin_button_changed_cb(GtkWidget *widget, gpointer name)

+{

+ MultiloadApplet *ma;

+ gint value;

+ gint prop_type, i;

+

+ ma = g_object_get_data(G_OBJECT(widget), "MultiloadApplet");

+ prop_type = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "prop_type"));

+ value = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));

+

+ switch(prop_type)

+ {

+ case PROP_SPEED:

+ g_settings_set_int (ma->settings, (gchar *)name, value);

+ for (i = 0; i < graph_n; i++)

+ {

+ load_graph_stop(ma->graphs[i]);

+ ma->graphs[i]->speed = value;

+ if (ma->graphs[i]->visible)

+ load_graph_start(ma->graphs[i]);

+ }

+

+ break;

+

+ case PROP_SIZE:

+ for (i = 0; i < graph_n; i++)

+ {

+ g_settings_set_int (ma->settings, (gchar *)name, value);

+ ma->graphs[i]->size = value ;

+

+ if (ma->graphs[i]->orient)

+ gtk_widget_set_size_request (

+ ma->graphs[i]->main_widget,

+ ma->graphs[i]->pixel_size,

+ ma->graphs[i]->size);

+ else

+ gtk_widget_set_size_request (

+ ma->graphs[i]->main_widget,

+ ma->graphs[i]->size,

+ ma->graphs[i]->pixel_size);

+ }

+ break;

+

+ case PROP_NET_THRESHOLD1:

+ g_settings_set_uint (ma->settings, (gchar *)name, value);

+ if (value >= ma->net_threshold2)

+ {

+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),

+ (gdouble)g_settings_get_uint (ma->settings,

+ "netthreshold2") - 1);

+ ma->net_threshold1 = g_settings_get_uint (ma->settings,

+ "netthreshold2") - 1;

+ }

+ else

+ ma->net_threshold1 = value;

+ break;

+

+ case PROP_NET_THRESHOLD2:

+ g_settings_set_uint (ma->settings, (gchar *)name, value);

+ if (value >= ma->net_threshold3)

+ {

+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),

+ (gdouble)g_settings_get_uint (ma->settings,

+ "netthreshold3") - 1);

+ ma->net_threshold2 = g_settings_get_uint (ma->settings,

+ "netthreshold3") - 1;

+ }

+ else if (value <= ma->net_threshold1)

+ {

+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),

+ (gdouble)g_settings_get_uint (ma->settings,

+ "netthreshold1") + 1);

+ ma->net_threshold2 = g_settings_get_uint (ma->settings,

+ "netthreshold1") + 1;

+ }

+ else

+ ma->net_threshold2 = value;

+ break;

+

+ case PROP_NET_THRESHOLD3:

+ g_settings_set_uint (ma->settings, (gchar *)name, value);

+ if (value <= ma->net_threshold2)

+ {

+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),

+ (gdouble)g_settings_get_uint (ma->settings,

+ "netthreshold2") + 1);

+ ma->net_threshold3 = g_settings_get_uint (ma->settings,

+ "netthreshold2") + 1;

+ }

+ else

+ ma->net_threshold3 = value;

+ break;

+ default:

+ g_assert_not_reached();

+ }

+

+ return;

+}

+

+/* create a new page in the notebook widget, add it, and return a pointer to it */

+static GtkWidget *

+add_page(GtkWidget *notebook, gchar *label)

+{

+ GtkWidget *page;

+ GtkWidget *page_label;

+

+ page = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);

+ gtk_box_set_homogeneous (GTK_BOX (page), TRUE);

+ page_label = gtk_label_new(label);

+ gtk_container_set_border_width(GTK_CONTAINER(page), 6);

+

+ gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, page_label);

+

+ return page;

+}

+

+/* save the selected color to gsettings and apply it on the applet */

+static void

+color_picker_set_cb(GtkColorChooser *color_picker, gchar *key)

+{

+ gchar *color_string;

+ guint8 prop_type;

+ GdkRGBA color;

+ MultiloadApplet *ma;

+

+ ma = g_object_get_data (G_OBJECT (color_picker), "MultiloadApplet");

+

+ if (strstr(key, "cpuload"))

+ prop_type = PROP_CPU;

+ else if (strstr(key, "memload"))

+ prop_type = PROP_MEM;

+ else if (strstr(key, "netload2"))

+ prop_type = PROP_NET;

+ else if (strstr(key, "swapload"))

+ prop_type = PROP_SWAP;

+ else if (strstr(key, "loadavg"))

+ prop_type = PROP_AVG;

+ else if (strstr(key, "diskload"))

+ prop_type = PROP_DISK;

+ else

+ g_assert_not_reached();

+

+ gtk_color_chooser_get_rgba(color_picker, &color);

+

+ color_string = gdk_rgba_to_string (&color);

+ g_settings_set_string(ma->settings, key, color_string);

+

+ gdk_rgba_parse(&(ma->graphs[prop_type]->colors[g_ascii_digit_value(key[strlen(key) - 1]) ]),

+ color_string);

+

+ return;

+}

+

+/* create a color selector */

+static void

+add_color_selector(GtkWidget *page, gchar *name, gchar *key, MultiloadApplet *ma)

+{

+ GtkWidget *vbox;

+ GtkWidget *label;

+ GtkWidget *color_picker;

+ GdkRGBA color;

+ gchar *color_string;

+

+ color_string = g_settings_get_string (ma->settings, key);

+ if (!color_string)

+ color_string = g_strdup ("#000000");

+ gdk_rgba_parse (&color, color_string);

+ g_free (color_string);

+

+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);

+ label = gtk_label_new_with_mnemonic(name);

+ color_picker = gtk_color_button_new();

+ gtk_label_set_mnemonic_widget (GTK_LABEL (label), color_picker);

+

+ gtk_box_pack_start(GTK_BOX(vbox), color_picker, FALSE, FALSE, 0);

+ gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);

+

+ gtk_box_pack_start(GTK_BOX(page), vbox, FALSE, FALSE, 0);

+

+ g_object_set_data (G_OBJECT (color_picker), "MultiloadApplet", ma);

+

+ gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(color_picker), &color);

+

+ g_signal_connect(G_OBJECT(color_picker), "color_set", G_CALLBACK(color_picker_set_cb), key);

+

+ if ( ! g_settings_is_writable (ma->settings, key))

+ hard_set_sensitive (vbox, FALSE);

+

+ return;

+}

+

+/* save the checkbox option to gsettings and apply it on the applet */

+static void

+nvme_checkbox_toggled_cb (GtkCheckButton *checkbox,

+ MultiloadApplet *ma)

+{

+ gboolean option;

+

+ option = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbox));

+ ma->nvme_diskstats = option;

+ g_settings_set_boolean (ma->settings, "diskload-nvme-diskstats", option);

+

+ return;

+}

+

+/* creates the properties dialog using up-to-the-minute info from gsettings */

+static void

+fill_properties(GtkWidget *dialog, MultiloadApplet *ma)

+{

+ GtkWidget *page;

+ GtkWidget *hbox, *vbox;

+ GtkWidget *categories_vbox;

+ GtkWidget *category_vbox;

+ GtkWidget *control_vbox;

+ GtkWidget *control_hbox;

+ GtkWidget *check_box;

+ GtkWidget *indent;

+ GtkWidget *spin_button;

+ GtkWidget *label;

+ MatePanelAppletOrient orient;

+ GtkSizeGroup *label_size;

+ GtkSizeGroup *spin_size;

+ gchar *label_text;

+ gchar *title;

+

+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);

+ gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);

+ gtk_widget_show (vbox);

+

+ gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),

+ vbox, TRUE, TRUE, 0);

+

+ categories_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18);

+ gtk_box_pack_start (GTK_BOX (vbox), categories_vbox, TRUE, TRUE, 0);

+ gtk_widget_show (categories_vbox);

+

+ category_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);

+ gtk_box_pack_start (GTK_BOX (categories_vbox), category_vbox, TRUE, TRUE, 0);

+ gtk_widget_show (category_vbox);

+

+ title = g_strconcat ("<span weight=\"bold\">", _("Monitored Resources"), "</span>", NULL);

+ label = gtk_label_new_with_mnemonic (_(title));

+ gtk_label_set_use_markup (GTK_LABEL (label), TRUE);

+ gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);

+ gtk_label_set_xalign (GTK_LABEL (label), 0.0);

+ gtk_box_pack_start (GTK_BOX (category_vbox), label, FALSE, FALSE, 0);

+ g_free (title);

+

+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);

+ gtk_box_pack_start (GTK_BOX (category_vbox), hbox, TRUE, TRUE, 0);

+ gtk_widget_show (hbox);

+

+ indent = gtk_label_new (HIG_IDENTATION);

+ gtk_label_set_justify (GTK_LABEL (indent), GTK_JUSTIFY_LEFT);

+ gtk_box_pack_start (GTK_BOX (hbox), indent, FALSE, FALSE, 0);

+ gtk_widget_show (indent);

+

+ control_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);

+ gtk_box_pack_start (GTK_BOX (hbox), control_vbox, TRUE, TRUE, 0);

+ gtk_widget_show (control_vbox);

+

+ control_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);

+ gtk_box_pack_start (GTK_BOX (control_vbox), control_hbox, TRUE, TRUE, 0);

+ gtk_widget_show (control_hbox);

+

+ check_box = gtk_check_button_new_with_mnemonic(_("_Processor"));

+ ma->check_boxes[0] = check_box;

+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_box),

+ g_settings_get_boolean (ma->settings,

+ VIEW_CPULOAD_KEY));

+ g_object_set_data(G_OBJECT(check_box), "MultiloadApplet", ma);

+ g_object_set_data(G_OBJECT(check_box), "prop_type", GINT_TO_POINTER(PROP_CPU));

+ g_signal_connect(G_OBJECT(check_box), "toggled",

+ G_CALLBACK(property_toggled_cb), VIEW_CPULOAD_KEY);

+ gtk_box_pack_start (GTK_BOX (control_hbox), check_box, FALSE, FALSE, 0);

+

+ if ( ! g_settings_is_writable (ma->settings, VIEW_CPULOAD_KEY))

+ hard_set_sensitive (check_box, FALSE);

+

+ check_box = gtk_check_button_new_with_mnemonic(_("_Memory"));

+ ma->check_boxes[1] = check_box;

+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_box),

+ g_settings_get_boolean (ma->settings, VIEW_MEMLOAD_KEY));

+ g_object_set_data(G_OBJECT(check_box), "MultiloadApplet", ma);

+ g_object_set_data(G_OBJECT(check_box), "prop_type", GINT_TO_POINTER(PROP_MEM));

+ g_signal_connect(G_OBJECT(check_box), "toggled",

+ G_CALLBACK(property_toggled_cb), VIEW_MEMLOAD_KEY);

+ gtk_box_pack_start (GTK_BOX (control_hbox), check_box, FALSE, FALSE, 0);

+

+ if ( ! g_settings_is_writable (ma->settings, VIEW_MEMLOAD_KEY))

+ hard_set_sensitive (check_box, FALSE);

+

+ check_box = gtk_check_button_new_with_mnemonic(_("_Network"));

+ ma->check_boxes[2] = check_box;

+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_box),

+ g_settings_get_boolean (ma->settings, VIEW_NETLOAD_KEY));

+ g_object_set_data(G_OBJECT(check_box), "MultiloadApplet", ma);

+ g_object_set_data(G_OBJECT(check_box), "prop_type", GINT_TO_POINTER(PROP_NET));

+ g_signal_connect(G_OBJECT(check_box), "toggled",

+ G_CALLBACK(property_toggled_cb), VIEW_NETLOAD_KEY);

+ gtk_box_pack_start (GTK_BOX (control_hbox), check_box, FALSE, FALSE, 0);

+

+ if ( ! g_settings_is_writable (ma->settings, VIEW_NETLOAD_KEY))

+ hard_set_sensitive (check_box, FALSE);

+

+ check_box = gtk_check_button_new_with_mnemonic (_("S_wap Space"));

+ ma->check_boxes[3] = check_box;

+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_box),

+ g_settings_get_boolean (ma->settings, VIEW_SWAPLOAD_KEY));

+ g_object_set_data(G_OBJECT(check_box), "MultiloadApplet", ma);

+ g_object_set_data(G_OBJECT(check_box), "prop_type", GINT_TO_POINTER(PROP_SWAP));

+ g_signal_connect(G_OBJECT(check_box), "toggled",

+ G_CALLBACK(property_toggled_cb), VIEW_SWAPLOAD_KEY);

+ gtk_box_pack_start (GTK_BOX (control_hbox), check_box, FALSE, FALSE, 0);

+

+ if ( ! g_settings_is_writable (ma->settings, VIEW_SWAPLOAD_KEY))

+ hard_set_sensitive (check_box, FALSE);

+

+ check_box = gtk_check_button_new_with_mnemonic(_("_Load"));

+ ma->check_boxes[4] = check_box;

+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_box),

+ g_settings_get_boolean (ma->settings, VIEW_LOADAVG_KEY));

+ g_object_set_data(G_OBJECT(check_box), "MultiloadApplet", ma);

+ g_object_set_data(G_OBJECT(check_box), "prop_type", GINT_TO_POINTER(PROP_AVG));

+ g_signal_connect(G_OBJECT(check_box), "toggled",

+ G_CALLBACK(property_toggled_cb), VIEW_LOADAVG_KEY);

+ gtk_box_pack_start(GTK_BOX(control_hbox), check_box, FALSE, FALSE, 0);

+

+ if ( ! g_settings_is_writable (ma->settings, VIEW_LOADAVG_KEY))

+ hard_set_sensitive (check_box, FALSE);

+

+ check_box = gtk_check_button_new_with_mnemonic(_("_Harddisk"));

+ ma->check_boxes[5] = check_box;

+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_box),

+ g_settings_get_boolean (ma->settings, VIEW_DISKLOAD_KEY));

+ g_object_set_data (G_OBJECT (check_box), "MultiloadApplet", ma);

+ g_object_set_data (G_OBJECT (check_box), "prop_type",

+ GINT_TO_POINTER (PROP_DISK));

+ g_signal_connect (G_OBJECT (check_box), "toggled",

+ G_CALLBACK (property_toggled_cb), VIEW_DISKLOAD_KEY);

+ gtk_box_pack_start (GTK_BOX (control_hbox), check_box, FALSE, FALSE, 0);

+

+ if ( ! g_settings_is_writable (ma->settings, VIEW_DISKLOAD_KEY))

+ hard_set_sensitive (check_box, FALSE);

+

+ category_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);

+ gtk_box_pack_start (GTK_BOX (categories_vbox), category_vbox, TRUE, TRUE, 0);

+ gtk_widget_show (category_vbox);

+

+ title = g_strconcat ("<span weight=\"bold\">", _("Options"), "</span>", NULL);

+ label = gtk_label_new (title);

+ gtk_label_set_use_markup (GTK_LABEL (label), TRUE);

+ gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);

+ gtk_label_set_xalign (GTK_LABEL (label), 0.0);

+ gtk_box_pack_start (GTK_BOX (category_vbox), label, FALSE, FALSE, 0);

+ gtk_widget_show (label);

+ g_free (title);

+

+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);

+ gtk_box_pack_start (GTK_BOX (category_vbox), hbox, TRUE, TRUE, 0);

+ gtk_widget_show (hbox);

+

+ indent = gtk_label_new (HIG_IDENTATION);

+ gtk_label_set_justify (GTK_LABEL (indent), GTK_JUSTIFY_LEFT);

+ gtk_box_pack_start (GTK_BOX (hbox), indent, FALSE, FALSE, 0);

+ gtk_widget_show (indent);

+

+ control_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);

+ gtk_box_pack_start (GTK_BOX (hbox), control_vbox, TRUE, TRUE, 0);

+ gtk_widget_show (control_vbox);

+

+ control_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);

+ gtk_box_pack_start (GTK_BOX (control_vbox), control_hbox, TRUE, TRUE, 0);

+ gtk_widget_show (control_hbox);

+

+ label_size = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);

+

+ orient = mate_panel_applet_get_orient(ma->applet);

+ if ( (orient == MATE_PANEL_APPLET_ORIENT_UP) || (orient == MATE_PANEL_APPLET_ORIENT_DOWN) )

+ label_text = g_strdup(_("System m_onitor width: "));

+ else

+ label_text = g_strdup(_("System m_onitor height: "));

+

+ label = gtk_label_new_with_mnemonic(label_text);

+ gtk_label_set_xalign (GTK_LABEL (label), 0.0f);

+ gtk_size_group_add_widget (label_size, label);

+ gtk_box_pack_start (GTK_BOX (control_hbox), label, FALSE, FALSE, 0);

+

+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);

+ gtk_box_pack_start (GTK_BOX (control_hbox), hbox, TRUE, TRUE, 0);

+ gtk_widget_show (hbox);

+

+ spin_size = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);

+

+ spin_button = gtk_spin_button_new_with_range(10, 1000, 5);

+ gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button);

+ g_object_set_data(G_OBJECT(spin_button), "MultiloadApplet", ma);

+ g_object_set_data(G_OBJECT(spin_button), "prop_type",

+ GINT_TO_POINTER(PROP_SIZE));

+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin_button),

+ (gdouble)g_settings_get_int(ma->settings, "size"));

+ g_signal_connect(G_OBJECT(spin_button), "value_changed",

+ G_CALLBACK(spin_button_changed_cb), "size");

+

+ if ( ! g_settings_is_writable (ma->settings, "size")) {

+ hard_set_sensitive (label, FALSE);

+ hard_set_sensitive (hbox, FALSE);

+ }

+

+ gtk_size_group_add_widget (spin_size, spin_button);

+ gtk_box_pack_start (GTK_BOX (hbox), spin_button, FALSE, FALSE, 0);

+

+ label = gtk_label_new (_("pixels"));

+ gtk_label_set_xalign (GTK_LABEL (label), 0.0f);

+ gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);

+

+ control_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);

+ gtk_box_pack_start (GTK_BOX (control_vbox), control_hbox, TRUE, TRUE, 0);

+ gtk_widget_show (control_hbox);

+

+ label = gtk_label_new_with_mnemonic(_("Sys_tem monitor update interval: "));

+ gtk_label_set_xalign (GTK_LABEL (label), 0.0f);

+ gtk_size_group_add_widget (label_size, label);

+ gtk_box_pack_start (GTK_BOX (control_hbox), label, FALSE, FALSE, 0);

+

+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);

+ gtk_box_pack_start (GTK_BOX (control_hbox), hbox, TRUE, TRUE, 0);

+ gtk_widget_show (hbox);

+

+ spin_button = gtk_spin_button_new_with_range(50, 10000, 50);

+ gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button);

+ g_object_set_data(G_OBJECT(spin_button), "MultiloadApplet", ma);

+ g_object_set_data(G_OBJECT(spin_button), "prop_type",

+ GINT_TO_POINTER(PROP_SPEED));

+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin_button),

+ (gdouble)g_settings_get_int (ma->settings, "speed"));

+ g_signal_connect(G_OBJECT(spin_button), "value_changed",

+ G_CALLBACK(spin_button_changed_cb), "speed");

+ gtk_size_group_add_widget (spin_size, spin_button);

+ gtk_box_pack_start (GTK_BOX (hbox), spin_button, FALSE, FALSE, 0);

+

+ if ( ! g_settings_is_writable (ma->settings, "speed")) {

+ hard_set_sensitive (label, FALSE);

+ hard_set_sensitive (hbox, FALSE);

+ }

+

+ label = gtk_label_new(_("milliseconds"));

+ gtk_label_set_xalign (GTK_LABEL (label), 0.0f);

+ gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);

+

+ g_free(label_text);

+

+

+ category_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);

+ gtk_box_pack_start (GTK_BOX (categories_vbox), category_vbox, TRUE, TRUE, 0);

+ gtk_widget_show (category_vbox);

+

+ title = g_strconcat ("<span weight=\"bold\">", _("Colors"), "</span>", NULL);

+ label = gtk_label_new (title);

+ gtk_label_set_use_markup (GTK_LABEL (label), TRUE);

+ gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);

+ gtk_label_set_xalign (GTK_LABEL (label), 0.0);

+ gtk_box_pack_start (GTK_BOX (category_vbox), label, FALSE, FALSE, 0);

+ gtk_widget_show (label);

+ g_free (title);

+

+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);

+ gtk_box_pack_start (GTK_BOX (category_vbox), hbox, TRUE, TRUE, 0);

+ gtk_widget_show (hbox);

+

+ indent = gtk_label_new (HIG_IDENTATION);

+ gtk_label_set_justify (GTK_LABEL (indent), GTK_JUSTIFY_LEFT);

+ gtk_box_pack_start (GTK_BOX (hbox), indent, FALSE, FALSE, 0);

+ gtk_widget_show (indent);

+

+ control_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);

+ gtk_box_pack_start (GTK_BOX (hbox), control_vbox, TRUE, TRUE, 0);

+ gtk_widget_show (control_vbox);

+

+ ma->notebook = gtk_notebook_new();

+ gtk_container_add (GTK_CONTAINER (control_vbox), ma->notebook);

+

+ page = add_page(ma->notebook, _("Processor"));

+ gtk_container_set_border_width (GTK_CONTAINER (page), 12);

+ add_color_selector(page, _("_User"), "cpuload-color0", ma);

+ add_color_selector(page, _("S_ystem"), "cpuload-color1", ma);

+ add_color_selector(page, _("N_ice"), "cpuload-color2", ma);

+ add_color_selector(page, _("I_OWait"), "cpuload-color3", ma);

+ add_color_selector(page, _("I_dle"), "cpuload-color4", ma);

+

+ page = add_page(ma->notebook, _("Memory"));

+ gtk_container_set_border_width (GTK_CONTAINER (page), 12);

+ add_color_selector(page, _("_User"), "memload-color0", ma);

+ add_color_selector(page, _("Sh_ared"), "memload-color1", ma);

+ add_color_selector(page, _("_Buffers"), "memload-color2", ma);

+ add_color_selector (page, _("Cach_ed"), "memload-color3", ma);

+ add_color_selector(page, _("F_ree"), "memload-color4", ma);

+

+ page = add_page(ma->notebook, _("Network"));

+ gtk_container_set_border_width (GTK_CONTAINER (page), 12);

+ add_color_selector (page, _("_In"), "netload2-color0", ma);

+ add_color_selector(page, _("_Out"), "netload2-color1", ma);

+ add_color_selector (page, _("_Local"), "netload2-color2", ma);

+ add_color_selector(page, _("_Background"), "netload2-color3", ma);

+ add_color_selector(page, _("_Gridline"), "netload2-color4", ma);

+ add_color_selector(page, _("_Indicator"), "netload2-color5", ma);

+

+ page = add_page(ma->notebook, _("Swap Space"));

+ gtk_container_set_border_width (GTK_CONTAINER (page), 12);

+ add_color_selector(page, _("_Used"), "swapload-color0", ma);

+ add_color_selector(page, _("_Free"), "swapload-color1", ma);

+

+ page = add_page(ma->notebook, _("Load"));

+ gtk_container_set_border_width (GTK_CONTAINER (page), 12);

+ add_color_selector(page, _("_Average"), "loadavg-color0", ma);

+ add_color_selector(page, _("_Background"), "loadavg-color1", ma);

+ add_color_selector(page, _("_Gridline"), "loadavg-color2", ma);

+

+ page = add_page (ma->notebook, _("Harddisk"));

+ gtk_container_set_border_width (GTK_CONTAINER (page), 12);

+ add_color_selector (page, _("_Read"), "diskload-color0", ma);

+ add_color_selector (page, _("_Write"), "diskload-color1", ma);

+ add_color_selector (page, _("_Background"), "diskload-color2", ma);

+ GtkWidget *nvme_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);

+ GtkWidget *nvme_checkbox = gtk_check_button_new_with_mnemonic (_("Use diskstats for NVMe"));

+ ma->nvme_diskstats = g_settings_get_boolean (ma->settings, "diskload-nvme-diskstats");

+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (nvme_checkbox),

+ ma->nvme_diskstats);

+ g_signal_connect (G_OBJECT (nvme_checkbox), "toggled",

+ G_CALLBACK (nvme_checkbox_toggled_cb), ma);

+ gtk_box_pack_start (GTK_BOX(nvme_box), nvme_checkbox, FALSE, FALSE, 0);

+ gtk_box_pack_start (GTK_BOX(page), nvme_box, FALSE, FALSE, 0);

+ gtk_widget_show (nvme_box);

+

+ title = g_strconcat ("<span weight=\"bold\">", _("Network speed thresholds"), "</span>", NULL);

+ label = gtk_label_new (title);

+ gtk_label_set_use_markup (GTK_LABEL (label), TRUE);

+ gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);

+ gtk_label_set_xalign (GTK_LABEL (label), 0.0);

+ gtk_box_pack_start (GTK_BOX (category_vbox), label, FALSE, FALSE, 0);

+ gtk_widget_show (label);

+ g_free (title);

+

+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);

+ gtk_box_pack_start (GTK_BOX (category_vbox), hbox, TRUE, TRUE, 0);

+ gtk_widget_show (hbox);

+

+ indent = gtk_label_new (HIG_IDENTATION);

+ gtk_label_set_justify (GTK_LABEL (indent), GTK_JUSTIFY_LEFT);

+ gtk_box_pack_start (GTK_BOX (hbox), indent, FALSE, FALSE, 0);

+ gtk_widget_show (indent);

+

+ control_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);

+ gtk_box_pack_start (GTK_BOX (hbox), control_vbox, TRUE, TRUE, 0);

+ gtk_widget_show (control_vbox);

+

+ control_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);

+ gtk_box_pack_start (GTK_BOX (control_vbox), control_hbox, TRUE, TRUE, 0);

+ gtk_widget_show (control_hbox);

+

+ label_size = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);

+

+ label_text = g_strdup(_("Threshold 1: "));

+ label = gtk_label_new_with_mnemonic(label_text);

+ gtk_label_set_xalign (GTK_LABEL (label), 0.0f);

+ gtk_size_group_add_widget (label_size, label);

+ gtk_box_pack_start (GTK_BOX (control_hbox), label, FALSE, FALSE, 0);

+

+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);

+ gtk_box_pack_start (GTK_BOX (control_hbox), hbox, TRUE, TRUE, 0);

+ gtk_widget_show (hbox);

+

+ spin_size = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);

+

+ spin_button = gtk_spin_button_new_with_range (MIN_NET_THRESHOLD1, MAX_NET_THRESHOLD1, 5);

+ gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button);

+ g_object_set_data(G_OBJECT(spin_button), "MultiloadApplet", ma);

+ g_object_set_data(G_OBJECT(spin_button), "prop_type",

+ GUINT_TO_POINTER(PROP_NET_THRESHOLD1));

+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin_button),

+ (gdouble)g_settings_get_uint(ma->settings, "netthreshold1"));

+ g_signal_connect(G_OBJECT(spin_button), "value_changed",

+ G_CALLBACK(spin_button_changed_cb), "netthreshold1");

+

+ if ( ! g_settings_is_writable (ma->settings, "netthreshold1"))

+ {

+ hard_set_sensitive (label, FALSE);

+ hard_set_sensitive (hbox, FALSE);

+ }

+

+ gtk_size_group_add_widget (spin_size, spin_button);

+ gtk_box_pack_start (GTK_BOX (hbox), spin_button, FALSE, FALSE, 0);

+

+ label = gtk_label_new (_("bytes"));

+ gtk_label_set_xalign (GTK_LABEL (label), 0.0f);

+ gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);

+

+ control_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);

+ gtk_box_pack_start (GTK_BOX (control_vbox), control_hbox, TRUE, TRUE, 0);

+ gtk_widget_show (control_hbox);

+

+ label = gtk_label_new_with_mnemonic(_("Threshold 2: "));

+ gtk_label_set_xalign (GTK_LABEL (label), 0.0f);

+ gtk_size_group_add_widget (label_size, label);

+ gtk_box_pack_start (GTK_BOX (control_hbox), label, FALSE, FALSE, 0);

+

+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);

+ gtk_box_pack_start (GTK_BOX (control_hbox), hbox, TRUE, TRUE, 0);

+ gtk_widget_show (hbox);

+

+ spin_button = gtk_spin_button_new_with_range (MIN_NET_THRESHOLD2, MAX_NET_THRESHOLD2, 5);

+ gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button);

+ g_object_set_data(G_OBJECT(spin_button), "MultiloadApplet", ma);

+ g_object_set_data(G_OBJECT(spin_button), "prop_type",

+ GINT_TO_POINTER(PROP_NET_THRESHOLD2));

+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin_button),

+ (gdouble)g_settings_get_uint (ma->settings, "netthreshold2"));

+ g_signal_connect(G_OBJECT(spin_button), "value_changed",

+ G_CALLBACK(spin_button_changed_cb), "netthreshold2");

+ gtk_size_group_add_widget (spin_size, spin_button);

+ gtk_box_pack_start (GTK_BOX (hbox), spin_button, FALSE, FALSE, 0);

+

+ if ( ! g_settings_is_writable (ma->settings, "netthreshold2"))

+ {

+ hard_set_sensitive (label, FALSE);

+ hard_set_sensitive (hbox, FALSE);

+ }

+

+ label = gtk_label_new(_("bytes"));

+ gtk_label_set_xalign (GTK_LABEL (label), 0.0f);

+ gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);

+

+ control_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);

+ gtk_box_pack_start (GTK_BOX (control_vbox), control_hbox, TRUE, TRUE, 0);

+ gtk_widget_show (control_hbox);

+

+ label = gtk_label_new_with_mnemonic(_("Threshold 3: "));

+ gtk_label_set_xalign (GTK_LABEL (label), 0.0f);

+ gtk_size_group_add_widget (label_size, label);

+ gtk_box_pack_start (GTK_BOX (control_hbox), label, FALSE, FALSE, 0);

+

+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);

+ gtk_box_pack_start (GTK_BOX (control_hbox), hbox, TRUE, TRUE, 0);

+ gtk_widget_show (hbox);

+

+ spin_button = gtk_spin_button_new_with_range (MIN_NET_THRESHOLD3, MAX_NET_THRESHOLD3, 5);

+ gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button);

+ g_object_set_data(G_OBJECT(spin_button), "MultiloadApplet", ma);

+ g_object_set_data(G_OBJECT(spin_button), "prop_type",

+ GINT_TO_POINTER(PROP_NET_THRESHOLD3));

+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin_button),

+ (gdouble)g_settings_get_uint (ma->settings, "netthreshold3"));

+ g_signal_connect(G_OBJECT(spin_button), "value_changed",

+ G_CALLBACK(spin_button_changed_cb), "netthreshold3");

+ gtk_size_group_add_widget (spin_size, spin_button);

+ gtk_box_pack_start (GTK_BOX (hbox), spin_button, FALSE, FALSE, 0);

+

+ if ( ! g_settings_is_writable (ma->settings, "netthreshold3"))

+ {

+ hard_set_sensitive (label, FALSE);

+ hard_set_sensitive (hbox, FALSE);

+ }

+

+ label = gtk_label_new(_("bytes"));

+ gtk_label_set_xalign (GTK_LABEL (label), 0.0f);

+ gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);

+

+ g_free(label_text);

+

+ category_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);

+ gtk_box_pack_start (GTK_BOX (categories_vbox), category_vbox, TRUE, TRUE, 0);

+

+ control_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);

+ gtk_box_pack_start (GTK_BOX (control_vbox), control_hbox, TRUE, TRUE, 0);

+ gtk_widget_show (control_hbox);

+

+ gtk_widget_show (category_vbox);

+

+ return;

+}

+

+/* show properties dialog */

+void

+multiload_properties_cb (GtkAction *action,

+ MultiloadApplet *ma)

+{

+ GtkWidget *dialog = NULL;

+

+ if (ma->prop_dialog) {

+ dialog = ma->prop_dialog;

+

+ gtk_window_set_screen (GTK_WINDOW (dialog),

+ gtk_widget_get_screen (GTK_WIDGET (ma->applet)));

+

+ gtk_notebook_set_current_page (GTK_NOTEBOOK (ma->notebook),

+ ma->last_clicked);

+ gtk_window_present (GTK_WINDOW (dialog));

+ return;

+ }

+

+ dialog = gtk_dialog_new_with_buttons (_("System Monitor Preferences"),

+ NULL, 0,

+ "gtk-help", GTK_RESPONSE_HELP,

+ "gtk-close", GTK_RESPONSE_CLOSE,

+ NULL);

+ gtk_window_set_screen (GTK_WINDOW (dialog),

+ gtk_widget_get_screen (GTK_WIDGET (ma->applet)));

+ gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE);

+ gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);

+ gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);

+ gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), 2);

+

+ fill_properties(dialog, ma);

+

+ properties_set_insensitive(ma);

+

+ g_signal_connect(G_OBJECT(dialog), "response",

+ G_CALLBACK(properties_close_cb), ma);

+

+ ma->prop_dialog = dialog;

+

+ gtk_widget_show_all(dialog);

+

+ gtk_notebook_set_current_page (GTK_NOTEBOOK (ma->notebook),

+ ma->last_clicked);

+}