inet.c

系统任务管理器

	GList		*list;
	InetMon		*in;
	gchar		buf[128];
	gchar		*l0, *l1;
	gint		i;

	for (i = 0, list = inet_mon_list; list; list = list->next, ++i)
		{
		in = (InetMon *) list->data;
		l0 = (*in->label0) ? in->label0: "NONE";
		l1 = (*in->label1) ? in->label1: "NONE";
		fprintf(f, "%s monitor %s %s %lu %lu %s %lu %lu %d %d %d\n",
				INET_CONFIG_KEYWORD, in->name,
				l0, in->port0_0, in->port0_1,
				l1, in->port1_0, in->port1_1,
				in->extra_info, in->data0_is_range, in->data1_is_range);
		snprintf(buf, sizeof(buf), "%s:minute", in->name);
		gkrellm_save_chartconfig(f, in->chart_config_minute,
				INET_CONFIG_KEYWORD, buf);
		snprintf(buf, sizeof(buf), "%s:hour", in->name);
		gkrellm_save_chartconfig(f, in->chart_config_hour,
				INET_CONFIG_KEYWORD, buf);
		if (in->launch.command)
			fprintf(f, "%s launch %s %s\n", INET_CONFIG_KEYWORD,
						in->name, in->launch.command);
		if (in->launch.tooltip_comment)
			fprintf(f, "%s tooltip %s %s\n", INET_CONFIG_KEYWORD,
						in->name, in->launch.tooltip_comment);
		}
	fprintf(f, "%s text_format all %s\n", INET_CONFIG_KEYWORD, text_format);
	if (!_GK.client_mode)
		fprintf(f, "%s update_interval %d\n",
					INET_CONFIG_KEYWORD, update_interval);
	}

static gint
fix_ports(InetMon *in)
	{
	gint	cd_length = 2;
	gulong	tmp;

	if (!*in->label0)
		{
		in->port0_1 = in->port0_1 = in->data0_is_range = 0;
		--cd_length;
		}
	if (!*in->label1)
		{
		in->port1_1 = in->port1_1 = in->data1_is_range = 0;
		--cd_length;
		}
	if (in->data0_is_range && (in->port0_1 < in->port0_0))
		{
		tmp = in->port0_1;
		in->port0_1 = in->port0_0;
		in->port0_0 = tmp;
		}
	if (in->data1_is_range && (in->port1_1 < in->port1_0))
		{
		tmp = in->port1_1;
		in->port1_1 = in->port1_0;
		in->port1_0 = tmp;
		}
	return cd_length;
	}

static void
load_inet_config(gchar *arg)
	{
	InetMon		*in;
	gchar		config[32], name[32];
	gchar		item[CFG_BUFSIZE];
	gchar		label0[16], label1[16];
	gchar		*hr_min;
	gint		n;

	if ((n = sscanf(arg, "%31s %31s %[^\n]", config, name, item)) != 3)
		return;
	hr_min = strrchr(name, (gint) ':');
	if (hr_min)
		*hr_min++ = '\0';
	if (!strcmp(config, "text_format"))
		{
		gkrellm_locale_dup_string(&text_format, item, &text_format_locale);
		return;
		}
	else if (!strcmp(config, "update_interval"))
		{
		sscanf(item, "%d", &update_interval);
		if (update_interval < 1)
			update_interval = 1;
		}
	else if (!strcmp(config, "monitor"))
		{
		in = g_new0(InetMon, 1);
		label0[0] = '\0';
		label1[0] = '\0';
		sscanf(item, "%15s %lu %lu %15s %lu %lu %d %d %d",
				label0, &in->port0_0, &in->port0_1,
				label1, &in->port1_0, &in->port1_1,
				&in->extra_info, &in->data0_is_range, &in->data1_is_range);
		if (!strcmp(label0, "NONE"))
			label0[0] = '\0';
		if (!strcmp(label1, "NONE"))
			label1[0] = '\0';
		in->label0 = g_strdup(label0);
		in->label1 = g_strdup(label1);
		in->cd_length = fix_ports(in);
		if (in->cd_length > 0)
			{
			in->name = g_strdup(name);
			in->chart_config_minute = gkrellm_chartconfig_new0();
			in->chart_config_hour = gkrellm_chartconfig_new0();
			inet_mon_list = g_list_append(inet_mon_list, in);
			}
		else	/* Bogus config line */
			{
			g_free(in->label0);
			g_free(in->label1);
			g_free(in);
			}
		return;
		}
	if ((in = lookup_inet(name)) == NULL)
		return;
	if (!strcmp(config, GKRELLM_CHARTCONFIG_KEYWORD))
		{
		if (hr_min && !strcmp(hr_min, "hour"))
			gkrellm_load_chartconfig(&in->chart_config_hour, item,
					in->cd_length);
		if (hr_min && !strcmp(hr_min, "minute"))
			gkrellm_load_chartconfig(&in->chart_config_minute, item,
					in->cd_length);
		}
	else if (!strcmp(config, "launch"))
		gkrellm_dup_string(&in->launch.command, item);
	else if (!strcmp(config, "tooltip"))
		gkrellm_dup_string(&in->launch.tooltip_comment, item);
	}


/* --------------------------------------------------------------------- */

  /* Read saved inet data (from a previous gkrellm process).  Return the
  |  number of missing data slots (skew).
  */
static gint
read_inet_data(GkrellmChart *cp, FILE *f, gint minute_chart,
			gint min, gint hour, gint yday, gint width)
	{
	struct tm	*tm;
	gchar		data[64];
	gint		n, in, out, cur_slot, skew, day;

	tm = gkrellm_get_current_time();
	day = tm->tm_yday - yday;

	/* Check for new years wrap around. I don't handle leap year here, will
	|  get some email, then be safe for four more years...
	*/
	if (day < 0)
		day = tm->tm_yday + ((yday < 365) ? 365 - yday : 0);

	cur_slot = day * 24 + tm->tm_hour;
	n = hour;
	if (minute_chart)
		{
		cur_slot = cur_slot * 60 + tm->tm_min;
		n = n * 60 + min;
		}
	skew = cur_slot - n;

	gkrellm_reset_chart(cp);
	for (n = 0; n < width; ++n)
		{
		if (fgets(data, sizeof(data), f) == NULL)
			break;

		if (skew >= cp->w)	/* All stored data is off the chart	*/
			continue;

		/* Use chart data storing routines to load in data so I don't care
		|  if current chart width is less or greater than stored data width.
		|  Charts will circular buff fill until data runs out.
		*/
		out = in = 0;
		sscanf(data, "%d %d", &out, &in);
		gkrellm_store_chartdata(cp, 0, out, in);
		}
	/* Need to store zero data for time slots not in read data to bring
	|  the chart up to date wrt current time.  As in update_inet() I need
	|  to skip slots for hour or minute ticks.
	|  Warning: skew can be negative if quit gkrellm, change system clock
	|  to earlier time, then restart gkrellm.
	*/
	if ((n = skew) < cp->w)		/* Do this only if some data was stored  */
		{
		while (n-- > 0)
			{
			gkrellm_store_chartdata(cp, 0, 0, 0);
			if (minute_chart && min++ == 0)
				{
				gkrellm_store_chartdata(cp, 0, 0, 0);
				gkrellm_store_chartdata(cp, 0, 0, 0);
				if (min == 60)
					min = 0;
				}
			else if (!minute_chart && hour++ == 0)
				{
				gkrellm_store_chartdata(cp, 0, 0, 0);
				gkrellm_store_chartdata(cp, 0, 0, 0);
				if (hour == 24)
					hour = 0;
				}
			}
		}
	return skew;
	}

static void
write_inet_data(GkrellmChart *cp, FILE *f)
	{
	GList	*list;
	gint	n;

	for (n = 0; n < cp->w; ++n)
		{
		for (list = cp->cd_list; list; list = list->next)
			fprintf(f, "%d ",
			   gkrellm_get_chartdata_data((GkrellmChartdata *) list->data, n));
		fprintf(f, "\n");
		}
	}

static gchar *
make_inet_data_fname(InetMon *in)
	{
	static gchar	idata_fname[256];
	gchar			c_sep0, c_sep1;

	c_sep0 = in->data0_is_range ? '-': '_';
	c_sep1 = in->data1_is_range ? '-': '_';
	snprintf(idata_fname, sizeof(idata_fname), "%s%cinet_%ld%c%ld_%ld%c%ld",
		inet_data_dir, G_DIR_SEPARATOR,
		in->port0_0, c_sep0, in->port0_1, in->port1_0, c_sep1, in->port1_1);
	return idata_fname;
	}

void
gkrellm_inet_save_data(void)
	{
	FILE		*f;
	struct tm	*tm;
	GList		*list;
	InetMon		*in;
	gchar		*fname, buf[64];

	tm = gkrellm_get_current_time();
	for (list = inet_mon_list; list; list = list->next)
		{
		in = (InetMon *) list->data;
		fname = make_inet_data_fname(in);
		if ((f = fopen(fname, "w")) == NULL)
			continue;

		fputs("minute hour yday width\n", f);
		snprintf(buf, sizeof(buf), "%d %d %d %d\n", tm->tm_min,
				tm->tm_hour, tm->tm_yday, in->chart->w);
		fputs(buf, f);

		/* Save any accumulated hits which have not been stored into the
		|  chart data array, and then save the chart data.
		*/
		fputs("hits0_minute hits1_minute hits0_hour hits1_hour\n", f);
		fprintf(f, "%ld %ld %ld %ld\n",
					in->hits0_minute, in->hits1_minute,
					in->hits0_hour, in->hits1_hour);
		write_inet_data(in->chart_minute, f);
		write_inet_data(in->chart_hour, f);
		fclose(f);
		}
	}

void
gkrellm_inet_load_data(void)
	{
	FILE		*f;
	GList		*list;
	InetMon		*in;
	gchar		buf[96], *fname;
	gint		min, hour, yday, len, skew;

	for (list = inet_mon_list; list; list = list->next)
		{
		in = (InetMon *) list->data;
		fname = make_inet_data_fname(in);
		if ((f = fopen(fname, "r")) == NULL)
			{
			gkrellm_reset_chart(in->chart);
			draw_inet_chart(in);
			continue;
			}
		fgets(buf, sizeof(buf), f);		/* Comment line */
		fgets(buf, sizeof(buf), f);
		sscanf(buf, "%d %d %d %d", &min, &hour, &yday, &len);
		fgets(buf, sizeof(buf), f);		/* Comment line */
		fgets(buf, sizeof(buf), f);
		sscanf(buf, "%ld %ld %ld %ld",
					&in->hits0_minute, &in->hits1_minute,
					&in->hits0_hour, &in->hits1_hour);

		skew = read_inet_data(in->chart_minute, f, 1, min, hour, yday, len);
		if (skew > 0)  /* Current minute slot is different from saved */
			in->hits0_minute = in->hits1_minute = 0;

		skew = read_inet_data(in->chart_hour, f, 0, min, hour, yday, len);
		if (skew > 0)  /* Current hour slot is different from saved */
			in->hits0_hour = in->hits1_hour = 0;

		fclose(f);
		gkrellm_rescale_chart(in->chart);
		}
	}

/* --------------------------------------------------------------------- */
#define	DEFAULT_TEXT_FORMAT	"\\t$a\\f $l\\N$A\\f $L"

enum
	{
	LABEL0_COLUMN,
	PORT00_COLUMN,
	PORT01_COLUMN,
	RANGE0_COLUMN,
	SPACER_COLUMN,
	LABEL1_COLUMN,
	PORT10_COLUMN,
	PORT11_COLUMN,
	RANGE1_COLUMN,
	DUMMY_COLUMN,
	INET_COLUMN,
	N_COLUMNS
	};

static GtkTreeView	*treeview;
static GtkTreeRowReference *row_reference;
static GtkTreeSelection	*selection;


static GtkWidget	*label0_entry,
					*label1_entry;
static GtkWidget	*port0_0_entry,
					*port0_1_entry,
					*port1_0_entry,
					*port1_1_entry;

static GtkWidget	*launch_vbox;

static GtkWidget	*data0_range_button,
					*data1_range_button;

static GtkWidget	*text_format_combo;


static void
set_list_store_model_data(GtkListStore *store, GtkTreeIter *iter, InetMon *in)
	{
	gchar			p00[16], p01[16], p10[16], p11[16];

	snprintf(p00, sizeof(p00), "%d", (int) in->port0_0);
	snprintf(p01, sizeof(p01), "%d", (int) in->port0_1);
	snprintf(p10, sizeof(p10), "%d", (int) in->port1_0);
	snprintf(p11, sizeof(p11), "%d", (int) in->port1_1);
	gtk_list_store_set(store, iter,
			LABEL0_COLUMN, in->label0,
			PORT00_COLUMN, p00,
			PORT01_COLUMN, p01,
			SPACER_COLUMN, "",
			RANGE0_COLUMN, in->data0_is_range,
			LABEL1_COLUMN, in->label1,
			PORT10_COLUMN, p10,
			PORT11_COLUMN, p11,
			RANGE1_COLUMN, in->data1_is_range,
			DUMMY_COLUMN, "",
			-1);
	}

static GtkTreeModel *
create_model(void)
	{
	GtkListStore	*store;
	GtkTreeIter		iter;
	GList			*list;
	InetMon			*in;

	store = gtk_list_store_new(N_COLUMNS,
				G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN,
				G_TYPE_STRING,
				G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN,
				G_TYPE_STRING, G_TYPE_POINTER);
	for (list = inet_mon_list; list; list = list->next)
		{
		in = (InetMon *) list->data;
		in->config_modified = FALSE;
		gtk_list_store_append(store, &iter);
		set_list_store_model_data(store, &iter, in);
		gtk_list_store_set(store, &iter, INET_COLUMN, in, -1);
		}
	return GTK_TREE_MODEL(store);
	}

static void
change_row_reference(GtkTreeModel *model, GtkTreePath *path)
	{
	gtk_tree_row_reference_free(row_reference);
	if (model && path)
		row_reference = gtk_tree_row_reference_new(model, path);
	else
		row_reference = NULL;
	}

static InetMon *
inet_new_from_model(GtkTreeModel *model, GtkTreeIter *iter, gchar *ports[])
	{
	InetMon		*in;
	gchar		*_ports[4];
	gint		i;
	gboolean	free_ports = FALSE;

	if (!ports)
		{
		ports = _ports;
		free_ports = TRUE;
		}
	in = g_new0(InetMon, 1);
	gtk_tree_model_get(model, iter,
			LABEL0_COLUMN, &in->label0,
			PORT00_COLUMN, &ports[0],
			PORT01_COLUMN, &ports[1],
			RANGE0_COLUMN, &in->data0_is_range,
			LABEL1_COLUMN, &in->label1,
			PORT10_COLUMN, &ports[2],
			PORT11_COLUMN, &ports[3],
			RANGE1_COLUMN, &in->data1_is_range,
			-1);
	in->port0_0 = atoi(ports[0]);
	in->port0_1 = atoi(ports[1]);
	in->port1_0 = atoi(ports[2]);
	in->port1_1 = atoi(ports[3]);
	for (i = 0; i < 4 && free_ports; ++i)
		g_free(ports[i]);

	return in;
	}

static void
reset_entries(void)
	{
	gtk_entry_set_text(GTK_ENTRY(label0_entry), "");
	gtk_entry_set_text(GTK_ENTRY(port0_0_entry), "0");
	gtk_entry_set_text(GTK_ENTRY(port0_1_entry), "0");
	gtk_entry_set_text(GTK_ENTRY(label1_entry), "");
	gtk_entry_set_text(GTK_ENTRY(port1_0_entry), "0");
	gtk_entry_set_text(GTK_ENTRY(port1_1_entry), "0");
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data0_range_button), 0);
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data1_range_button), 0);

	change_row_reference(NULL, NULL);
	gtk_tree_selection_unselect_all(selection);
	}


static void
cb_tree_selection_changed(GtkTreeSelection *selection, gpointer data)
	{
	GtkTreeIter		iter;
	GtkTreeModel	*model;
	GtkTreePath		*path;
	InetMon			*in;
	gchar			*ports[4];
	gint			i;

	if (!gtk_tree_selection_get_selected(selection, &model, &iter))
		{
		reset_entries();
		return;
		}
	path = gtk_tree_model_get_path(model, &iter);
	change_row_reference(model, path);
	gtk_tree_path_free(path);

	in = inet_new_from_model(model, &iter, ports);

	gtk_entry_set_text(GTK_ENTRY(label0_entry), in->label0);
	gtk_entry_set_text(GTK_ENTRY(port0_0_entry), ports[0]);
	gtk_entry_set_text(GTK_ENTRY(port0_1_entry), ports[1]);
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data0_range_button),
			in->data0_is_range);

	gtk_entry_set_text(GTK_ENTRY(label1_entry), in->label1);
	gtk_entry_set_text(GTK_ENTRY(port1_0_entry), ports[2]);
	gtk_entry_set_text(GTK_ENTRY(port1_1_entry), ports[3]);
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data1_range_button),
			in->data1_is_range);
	g_free(in->label0);
	g_free(in->label1);
	for (i = 0; i < 4; ++i)
		g_free(ports[i]);
	}

static void
cb_launch_entry(GtkWidget *widget, InetMon *in)
	{
	gkrellm_apply_launcher(&in->launch_entry, &in->tooltip_entry,
				in->panel, &in->launch, gkrellm_launch_button_cb);
    }

static void
add_launch_entry(GtkWidget *vbox, InetMon *in)
	{