<default>'#0000ff'</default>

<summary>Indicator color</summary>

</key>

<range min="10" max="999999998"/>

<default>1000000</default>

<summary>Network threshold 1 in bytes</summary>

</key>

<range min="11" max="999999999"/>

<default>10000000</default>

<summary>Network threshold 2 in bytes</summary>

</key>

<range min="12" max="1000000000"/>

<default>100000000</default>

<summary>Network threshold 3 in bytes</summary>

#include <glib.h>

#include "autoscaler.h"

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

{

that->update_interval = interval;

that->floor = floor;

that->max = 0;

that->count = 0;

that->last_update = 0;

that->last_average = 0.0f;

}

{

that->sum += current;

that->count++;

{

float average;

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

else

average = new_average;

that->count = 0;

that->last_update = now;

that->last_average = average;

#define MATE_APPLETS_MULTILOAD_AUTOSCALER_H

#include <glib.h>

typedef struct _AutoScaler AutoScaler;

struct _AutoScaler

{

float last_average;

};

#endif /* MATE_APPLETS_MULTILOAD_AUTOSCALER_H */

typedef struct _MultiloadApplet MultiloadApplet;

typedef struct _LoadGraph LoadGraph;

#include "netspeed.h"

struct _LoadGraph {

MultiloadApplet *multiload;

guint speed, size;

guint orient, pixel_size;

LoadGraphDataFunc get_data;

guint allocated;

GdkRGBA *colors;

GtkWidget *main_widget;

GtkWidget *frame, *box, *disp;

GtkWidget *check_boxes [graph_n];

GtkWidget *prop_dialog;

GtkWidget *notebook;

double loadavg1;

NetSpeed *netspeed_in;

NetSpeed *netspeed_out;

};

#include "load-graph.h"

#include <config.h>

#include <sys/types.h>

#include <sys/statvfs.h>

#include <fcntl.h>

#include <unistd.h>

(1 << GLIBTOP_NETLOAD_BYTES_TOTAL);

void

LoadGraph *g)

{

MultiloadApplet *multiload;

glibtop_cpu cpu;

glibtop_get_cpu (&cpu);

if (!multiload->cpu_initialized) {

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

}

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

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

used += cpu_aux [i];

used_scaled += current_scaled;

data [i] = current_scaled;

}

}

void

LoadGraph *g)

{

static gboolean first_call = TRUE;

static guint64 lastread = 0, lastwrite = 0;

static AutoScaler scaler;

guint64 read, write;

guint64 readdiff, writediff;

MultiloadApplet *multiload;

}

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

}

g_free(mountentries);

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

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

}

* aux [memload_buffer] = mem.buffer;

*/

void

LoadGraph *g)

{

MultiloadApplet *multiload;

glibtop_mem mem;

guint64 aux [memload_n], cache = 0;

int i;

glibtop_get_mem (&mem);

aux [memload_buffer] = mem.buffer;

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

if (i != memload_user) {

cache += aux [i];

}

}

void

LoadGraph *g)

{

MultiloadApplet *multiload;

glibtop_swap swap;

float ratio;

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

multiload->swapload_used_ratio = ratio;

}

}

void

LoadGraph *g)

{

glibtop_loadavg loadavg;

multiload = g->multiload;

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

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

}

}

void

LoadGraph *g)

{

enum Types {

{

/* protect against weirdness */

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

else

data[i] = 0;

data[COUNT_TYPES] += data[i];

#include <load-graph.h>

#endif

static void

shift_right(LoadGraph *g)

{

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

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

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

g->data[0] = last_data;

}

{

guint i, j, k;

cairo_t *cr;

MultiloadApplet *multiload;

multiload = g->multiload;

if (!g->surface)

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

CAIRO_CONTENT_COLOR,

cr = cairo_create (g->surface);

cairo_set_line_width (cr, 1.0);

cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);

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

/* This is for network graph */

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

{

maxnet = g->data[i][3];

}

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

if (maxnet > multiload->net_threshold3) {

net_threshold = multiload->net_threshold3;

level = 3;

}

else {

net_threshold = multiload->net_threshold1;

}

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

maxnet = maxnet/net_threshold;

segments = MAX (maxnet+1,1);

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

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

{

}

cairo_stroke (cr);

}

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

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

{

}

cairo_stroke (cr);

}

/* draw grid lines if needed */

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

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

{

cairo_move_to (cr, 0.5, spacing);

}

cairo_stroke (cr);

/* draw indicator if needed */

{

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

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

cairo_fill(cr);

}

cairo_stroke (cr);

}

/* this is Load graph */

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

{

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

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

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

}

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

{

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

{

if (j == 0)

{

}

else

{

}

}

cairo_stroke (cr);

}

{

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

cairo_move_to (cr, 0.5, spacing);

cairo_stroke (cr);

}

gtk_widget_queue_draw (g->disp);

cairo_destroy (cr);

load_graph_update (LoadGraph *g)

{

if (g->data == NULL)

shift_right(g);

if (g->tooltip_update)

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

void

load_graph_unalloc (LoadGraph *g)

{

if (!g->allocated)

return;

static void

load_graph_alloc (LoadGraph *g)

{

if (g->allocated)

return;

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

}

g->allocated = TRUE;

gtk_widget_get_allocation (c->disp, &allocation);

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

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

if (!c->surface)

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

CAIRO_CONTENT_COLOR,

gtk_widget_queue_draw (widget);

return TRUE;

LoadGraph *

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

const gchar *name, LoadGraphDataFunc get_data)

{

LoadGraph *g;

g->timer_index = -1;

if (g->orient)

else

g->disp = gtk_drawing_area_new ();

gtk_widget_set_events (g->disp, GDK_EXPOSURE_MASK |

void

load_graph_start (LoadGraph *g)

{

if (g->timer_index != -1)

(GSourceFunc) load_graph_update, g);

}

void

load_graph_stop (LoadGraph *g)

{

if (g->timer_index != -1)

g->timer_index = -1;

}

/* Create new load graph. */

G_GNUC_INTERNAL LoadGraph *

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

const gchar *name, LoadGraphDataFunc get_data);

/* Start load graph. */

static void

multiload_destroy_cb(GtkWidget *widget, gpointer data)

{

MultiloadApplet *ma = data;

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

struct { const char *label;

const char *visibility_key;

const char *name;

LoadGraphDataFunc callback;

} graph_types [graph_n] = {

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

guint size;

guint speed;

gint i;

speed = CLAMP (g_settings_get_uint (ma->settings, REFRESH_RATE_KEY), REFRESH_RATE_MIN, REFRESH_RATE_MAX);

size = CLAMP (g_settings_get_uint (ma->settings, GRAPH_SIZE_KEY), GRAPH_SIZE_MIN, GRAPH_SIZE_MAX);

if (net_threshold1 >= net_threshold2)

{

net_threshold1 = net_threshold2 - 1;

void

multiload_applet_refresh(MultiloadApplet *ma)

{

MatePanelAppletOrient orientation;

/* stop and free the old graphs */

#include <config.h>

#include <glib.h>

#include "netspeed.h"

struct _NetSpeed

{

LoadGraph *graph;

size_t cur;

};

{

ns->graph = g;

return ns;

}

g_free(ns);

}

{

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

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

}

{

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

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

few seconds. */

rate = 0;

static void

properties_set_insensitive(MultiloadApplet *ma)

{

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

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

property_toggled_cb(GtkWidget *widget, gpointer name)

{

MultiloadApplet *ma;

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

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

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

{

MultiloadApplet *ma = user_data;

gint value;

value = gtk_spin_button_get_value_as_int (spin_button);

g_settings_set_uint (ma->settings, REFRESH_RATE_KEY, (guint) value);

{

MultiloadApplet *ma = user_data;

gint value;

value = gtk_spin_button_get_value_as_int (spin_button);

g_settings_set_uint (ma->settings, GRAPH_SIZE_KEY, (guint) value);

ma->graphs[i]->size = (guint) value;

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

gtk_widget_set_size_request (ma->graphs[i]->main_widget,

} else {

gtk_widget_set_size_request (ma->graphs[i]->main_widget,

}

}

}

gpointer user_data)

{

MultiloadApplet *ma = user_data;

}

}

gpointer user_data)

{

MultiloadApplet *ma = user_data;

}

}

gpointer user_data)

{

MultiloadApplet *ma = user_data;

}

}

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

gchar *label_text;

gchar *title;

guint spin_value_uint;

vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);

gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);

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_signal_connect (GTK_SPIN_BUTTON (spin_button), "value-changed",

G_CALLBACK (on_net_threshold1_spin_button_value_changed), ma);

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_signal_connect (GTK_SPIN_BUTTON (spin_button), "value-changed",

G_CALLBACK (on_net_threshold2_spin_button_value_changed), ma);

gtk_size_group_add_widget (spin_size, spin_button);

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_signal_connect (GTK_SPIN_BUTTON (spin_button), "value-changed",

G_CALLBACK (on_net_threshold3_spin_button_value_changed), ma);

gtk_size_group_add_widget (spin_size, spin_button);