inet.c

系统任务管理器

	in->launch_table = gkrellm_gtk_launcher_table_new(vbox, 1);
	gkrellm_gtk_config_launcher(in->launch_table, 0,  &in->launch_entry,
				&in->tooltip_entry, in->name, &in->launch);
	g_signal_connect(G_OBJECT(in->launch_entry), "changed",
				G_CALLBACK(cb_launch_entry), in);
	g_signal_connect(G_OBJECT(in->tooltip_entry), "changed",
				G_CALLBACK(cb_launch_entry), in);
	gtk_widget_show_all(in->launch_table);
	}


static void
sync_inet_list(void)
	{
	GtkTreeModel	*model;
	GtkTreeIter		iter;
	InetMon			*in, *in_tmp;
	GList			*list, *new_inet_list;

	/* Just save all data and then later read it back in.  This avoids
	|  complicated detecting of name changes while ports the same, moving
	|  a inet down or up slots, etc.  Data is lost only if a port number
	|  for a monitor is changed.
	*/
	gkrellm_inet_save_data();
	new_inet_list = NULL;
	n_inet_monitors = 0;

	model = gtk_tree_view_get_model(treeview);
	if (gtk_tree_model_get_iter_first(model, &iter))
		{
		do
			{
			in = inet_new_from_model(model, &iter, NULL);
			new_inet_list = g_list_append(new_inet_list, in);
			gtk_tree_model_get(model, &iter, INET_COLUMN, &in_tmp, -1);
			fix_ports(in);

			/* If an existing inet still has the same port numbers, preserve
			|  its config.  Otherwise, it is same as making a new entry.
			|  (plus the data layers could go from 2 to 1 and then there would
			|   be an extra data layer in the config - not good).
			*/
			if (   in_tmp
				&& in_tmp->port0_0 == in->port0_0
				&& in_tmp->port0_1 == in->port0_1
				&& in_tmp->port1_0 == in->port1_0
				&& in_tmp->port1_1 == in->port1_1
			   )
				{
				in->chart_config_minute = in_tmp->chart_config_minute;
				in_tmp->chart_config_minute = NULL;
				in->chart_config_hour = in_tmp->chart_config_hour;
				in_tmp->chart_config_hour = NULL;
				in->extra_info = in_tmp->extra_info;
				in->hour_mode = in_tmp->hour_mode;
				}
			else
				{
				in->chart_config_minute = gkrellm_chartconfig_new0();
				in->chart_config_hour = gkrellm_chartconfig_new0();
				gkrellm_set_chartconfig_auto_grid_resolution(
							in->chart_config_minute, TRUE);
				gkrellm_set_chartconfig_auto_grid_resolution(
							in->chart_config_hour, TRUE);
				in->extra_info = TRUE;
				}
			if (in_tmp)
				{
				gkrellm_dup_string(&in->launch.command,
							in_tmp->launch.command);
				gkrellm_dup_string(&in->launch.tooltip_comment,
							in_tmp->launch.tooltip_comment);
				}
			gtk_list_store_set(GTK_LIST_STORE(model), &iter,
						INET_COLUMN, in, -1);
			}
		while (gtk_tree_model_iter_next(model, &iter));
		}
	while (inet_mon_list)
		{
		in = (InetMon *) inet_mon_list->data;
		destroy_inet_monitor(in);
		inet_mon_list = g_list_remove(inet_mon_list, in);
		}
	inet_mon_list = new_inet_list;
	for (list = inet_mon_list; list; list = list->next)
		create_inet_monitor(inet_vbox, (InetMon *)list->data, TRUE);

	gkrellm_inet_load_data();

	for (list = inet_mon_list; list; list = list->next)
		{
		in = (InetMon *) list->data;
		draw_inet_chart(in);
		add_launch_entry(launch_vbox, in);
		}
	if (inet_mon_list)
		gkrellm_spacers_show(mon_inet);
	else
		gkrellm_spacers_hide(mon_inet);
	}

static gboolean
cb_drag_end(GtkWidget *widget, GdkDragContext *context, gpointer data)
	{
	reset_entries();
	sync_inet_list();
	return FALSE;
	}

static void
cb_enter(GtkWidget *widget, gpointer data)
	{
	GtkTreeModel	*model;
	GtkTreePath		*path = NULL;
	GtkTreeIter		iter;
	InetMon			*in;

	in = g_new0(InetMon, 1);

	in->data0_is_range = GTK_TOGGLE_BUTTON(data0_range_button)->active;
	in->data1_is_range = GTK_TOGGLE_BUTTON(data1_range_button)->active;

	in->label0 = gkrellm_gtk_entry_get_text(&label0_entry);
	if (*(in->label0))
		{
		in->port0_0 = atoi(gkrellm_gtk_entry_get_text(&port0_0_entry));
		in->port0_1 = atoi(gkrellm_gtk_entry_get_text(&port0_1_entry));
		}
	in->label1 = gkrellm_gtk_entry_get_text(&label1_entry);
	if (*(in->label1))
		{
		in->port1_0 = atoi(gkrellm_gtk_entry_get_text(&port1_0_entry));
		in->port1_1 = atoi(gkrellm_gtk_entry_get_text(&port1_1_entry));
		}
	
	/* Validate the values
	*/
	if (   (!*(in->label0) && !*(in->label1))
		|| (*(in->label0) && in->port0_0 == 0 && in->port0_1 == 0)
		|| (*(in->label1) && in->port1_0 == 0 && in->port1_1 == 0)
	   )
		{
		g_free(in);
		return;
		}

	model = gtk_tree_view_get_model(treeview);
	if (row_reference)
		{
		path = gtk_tree_row_reference_get_path(row_reference);
		gtk_tree_model_get_iter(model, &iter, path);
		}
	else
		{
		gtk_list_store_append(GTK_LIST_STORE(model), &iter);
		gtk_list_store_set(GTK_LIST_STORE(model), &iter, INET_COLUMN, NULL,-1);
		}
	in->config_modified = TRUE;
	set_list_store_model_data(GTK_LIST_STORE(model), &iter, in);
	g_free(in);
	reset_entries();
	sync_inet_list();
	}

static void
cb_delete(GtkWidget *widget, gpointer data)
	{
	GtkTreeModel	*model;
	GtkTreePath		*path;
	GtkTreeIter		iter;

	if (!row_reference)
		return;
	model = gtk_tree_view_get_model(treeview);
	path = gtk_tree_row_reference_get_path(row_reference);
	gtk_tree_model_get_iter(model, &iter, path);
	gtk_list_store_remove(GTK_LIST_STORE(model), &iter);

	reset_entries();
	sync_inet_list();
	}

static void
cb_text_format(GtkWidget *widget, gpointer data)
	{
	GList   *list;
	gchar   *s;

	s = gkrellm_gtk_entry_get_text(&(GTK_COMBO(text_format_combo)->entry));
	gkrellm_locale_dup_string(&text_format, s, &text_format_locale);
	for (list = inet_mon_list; list; list = list->next)
		draw_inet_chart((InetMon *) list->data);
	}

static void
cb_update_interval(GtkWidget *entry, GtkSpinButton *spin)
    {
    update_interval = gtk_spin_button_get_value_as_int(spin);
    }

static gchar	*inet_info_text[] =
{
N_("Inet charts show historical TCP port hits on a minute or hourly\n"
	"chart. Below the chart there is a strip where marks are drawn for\n"
	"port hits in second intervals.   The inet krell has a full scale\n"
	"value of 5 hits and samples once per second.  The extra info\n"
	"display shows current TCP port connections.\n\n"
	"For each internet monitor, you can specify two labeled data sets with\n"
	"one or two non-zero port numbers entered for each data set.  Two\n"
	"ports are allowed because some internet ports are related and you\n"
	"might want to group them.  Check /etc/services for port numbers.\n\n"
	"For example, if you created an inet monitor:\n"),

N_("<i>\thttp 80 8080   ftp 21\n"),

N_("Http hits on the standard http port 80 and www web caching service\n"
	"on port 8080 are combined and plotted in the one color.  Ftp hits\n"
	"on the single ftp port 21 are plotted in another color.\n\n"),

N_("If the range button is checked, then all port numbers between Port0 and\n"
   "Port1 are monitored and included in the plot.\n\n"),

N_("<h>Chart Labels\n"),
N_("Substitution variables for the format string for chart labels:\n"),
N_("\t$M    maximum chart value\n"),
N_("\t$a    current active connections for Data0\n"),
N_("\t$cN   total connections in last N minutes (or hours) for Data0\n"),
N_("\t$l    label for Data0\n"),
N_("\t$A    current active connections for Data1\n"),
N_("\t$CN   total connections in last N minutes (or hours) for Data1\n"),
N_("\t$L    label for Data1\n"),

"\n",
N_("<h>Mouse Button Actions:\n"),
N_("<b>\tLeft "),
N_("click on an inet chart to toggle the extra info display of\n"
	"\t\tcurrent TCP port connections.\n"),
N_("<b>\tMiddle "),
N_("click on an inet chart to toggle hour/minute charts.\n")
};


static void
create_inet_tab(GtkWidget *tab_vbox)
	{
	GtkWidget		*tabs;
	GtkWidget		*table;
	GtkWidget		*hbox, *vbox, *vbox1;
	GtkWidget		*separator;
	GtkWidget		*scrolled;
	GtkWidget		*text;
	GtkWidget		*label;
	GtkWidget		*button;
	GtkTreeModel	*model;
	GtkCellRenderer	*renderer;
	GList			*list;
	InetMon			*in;
	gint			i;
	
	row_reference = NULL;

	tabs = gtk_notebook_new();
	gtk_notebook_set_tab_pos(GTK_NOTEBOOK(tabs), GTK_POS_TOP);
	gtk_box_pack_start(GTK_BOX(tab_vbox), tabs, TRUE, TRUE, 0);

	vbox = gkrellm_gtk_framed_notebook_page(tabs, _("Ports"));

	table = gtk_table_new(6, 7, FALSE /*homogeneous*/);
	gtk_table_set_col_spacings(GTK_TABLE(table), 5);
	gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 3);

	label = gtk_label_new(_("Data0"));
	gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 3, 0, 1);
	separator = gtk_hseparator_new();
	gtk_table_attach_defaults(GTK_TABLE(table), separator, 0, 3, 1, 2);
	label = gtk_label_new(_("Data1"));
	gtk_table_attach_defaults(GTK_TABLE(table), label, 4, 7, 0, 1);
	separator = gtk_hseparator_new();
	gtk_table_attach_defaults(GTK_TABLE(table), separator, 4, 7, 1, 2);

	separator = gtk_vseparator_new();
	gtk_table_attach_defaults(GTK_TABLE(table), separator, 3, 4, 0, 6);

	label = gtk_label_new(_("Label"));
	gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 2, 3);
	label = gtk_label_new(_("Port0"));
	gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, 2, 3);
	label = gtk_label_new(_("Port1"));
	gtk_table_attach_defaults(GTK_TABLE(table), label, 2, 3, 2, 3);
	label = gtk_label_new(_("Label"));
	gtk_table_attach_defaults(GTK_TABLE(table), label, 4, 5, 2, 3);
	label = gtk_label_new(_("Port0"));
	gtk_table_attach_defaults(GTK_TABLE(table), label, 5, 6, 2, 3);
	label = gtk_label_new(_("Port1"));
	gtk_table_attach_defaults(GTK_TABLE(table), label, 6, 7, 2, 3);

	label0_entry = gtk_entry_new();
	gtk_entry_set_max_length(GTK_ENTRY(label0_entry), 8);
	gtk_widget_set_size_request(label0_entry, 32, -1);
	gtk_table_attach_defaults(GTK_TABLE(table), label0_entry, 0, 1, 3, 4);
	port0_0_entry = gtk_entry_new();
	gtk_entry_set_max_length(GTK_ENTRY(port0_0_entry), 8);
	gtk_widget_set_size_request(port0_0_entry, 32, -1);
	gtk_table_attach_defaults(GTK_TABLE(table), port0_0_entry, 1, 2, 3, 4);
	port0_1_entry = gtk_entry_new();
	gtk_entry_set_max_length(GTK_ENTRY(port0_1_entry), 8);
	gtk_widget_set_size_request(port0_1_entry, 32, -1);
	gtk_table_attach_defaults(GTK_TABLE(table), port0_1_entry, 2, 3, 3, 4);

	label1_entry = gtk_entry_new();
	gtk_entry_set_max_length(GTK_ENTRY(label1_entry), 8);
	gtk_widget_set_size_request(label1_entry, 32, -1);
	gtk_table_attach_defaults(GTK_TABLE(table), label1_entry, 4, 5, 3, 4);
	port1_0_entry = gtk_entry_new();
	gtk_entry_set_max_length(GTK_ENTRY(port1_0_entry), 8);
	gtk_widget_set_size_request(port1_0_entry, 32, -1);
	gtk_table_attach_defaults(GTK_TABLE(table), port1_0_entry, 5, 6, 3, 4);
	port1_1_entry = gtk_entry_new();
	gtk_entry_set_max_length(GTK_ENTRY(port1_1_entry), 8);
	gtk_widget_set_size_request(port1_1_entry, 32, -1);
	gtk_table_attach_defaults(GTK_TABLE(table), port1_1_entry, 6, 7, 3, 4);

	hbox = gtk_hbox_new(FALSE, 2);
	gtk_table_attach_defaults(GTK_TABLE(table), hbox, 0, 3, 4, 5);
	gkrellm_gtk_check_button(hbox, &data0_range_button, 0, TRUE, 0,
		_("Port0 - Port1 is a range"));

	hbox = gtk_hbox_new(FALSE, 2);
	gtk_table_attach_defaults(GTK_TABLE(table), hbox, 4, 7, 4, 5);
	gkrellm_gtk_check_button(hbox, &data1_range_button, 0, TRUE, 0,
		_("Port0 - Port1 is a range"));

	separator = gtk_hseparator_new();
	gtk_table_attach_defaults(GTK_TABLE(table), separator, 0, 7, 5, 6);

	hbox = gtk_hbutton_box_new();
	gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
	gtk_box_set_spacing(GTK_BOX(hbox), 5);
	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

	button = gtk_button_new_from_stock(GTK_STOCK_DELETE);
	g_signal_connect(G_OBJECT(button), "clicked",
			G_CALLBACK(cb_delete), NULL);
	gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);

	/* everybody knows about CNTL click, right? */
//	button = gtk_button_new_from_stock(GTK_STOCK_NEW);
//	g_signal_connect(G_OBJECT(button), "clicked",
//			G_CALLBACK(reset_entries), NULL);
//	gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);

	button = gtk_button_new_from_stock(GTK_STOCK_ADD);
	g_signal_connect(G_OBJECT(button), "clicked",
			G_CALLBACK(cb_enter), NULL);
	gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);

	separator = gtk_hseparator_new();
	gtk_box_pack_start(GTK_BOX(vbox), separator, FALSE, FALSE, 2);

	scrolled = gtk_scrolled_window_new(NULL, NULL);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
			GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 0);


	model = create_model();
	treeview = GTK_TREE_VIEW(gtk_tree_view_new_with_model(model));
	g_object_unref(G_OBJECT(model));
	gtk_tree_view_set_rules_hint(treeview, TRUE);
	gtk_tree_view_set_reorderable(treeview, TRUE);
	g_signal_connect(G_OBJECT(treeview), "drag_end",
				G_CALLBACK(cb_drag_end), NULL);

	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_insert_column_with_attributes(treeview, -1, _("Label"),
				renderer,
				"text", LABEL0_COLUMN, NULL);
	renderer = gtk_cell_renderer_text_new();
	g_object_set(G_OBJECT(renderer), "xalign", 1.0, NULL);
	gtk_tree_view_insert_column_with_attributes(treeview, -1, _("Port0"),
				renderer,
				"text", PORT00_COLUMN, NULL);
	renderer = gtk_cell_renderer_text_new();
	g_object_set(G_OBJECT(renderer), "xalign", 1.0, NULL);
	gtk_tree_view_insert_column_with_attributes(treeview, -1, _("Port1"),
				renderer,
				"text", PORT01_COLUMN, NULL);

	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_insert_column_with_attributes(treeview, -1, "    ",
				renderer,
				"text", SPACER_COLUMN, NULL);

	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_insert_column_with_attributes(treeview, -1, _("Label"),
				renderer,
				"text", LABEL1_COLUMN, NULL);
	renderer = gtk_cell_renderer_text_new();
	g_object_set(G_OBJECT(renderer), "xalign", 1.0, NULL);
	gtk_tree_view_insert_column_with_attributes(treeview, -1, _("Port0"),
				renderer,
				"text", PORT10_COLUMN, NULL);
	renderer = gtk_cell_renderer_text_new();
	g_object_set(G_OBJECT(renderer), "xalign", 1.0, NULL);
	gtk_tree_view_insert_column_with_attributes(treeview, -1, _("Port1"),
				renderer,
				"text", PORT11_COLUMN, NULL);

	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_insert_column_with_attributes(treeview, -1, "    ",
				renderer,
				"text", DUMMY_COLUMN, NULL);


	gtk_container_add(GTK_CONTAINER(scrolled), GTK_WIDGET(treeview));
	selection = gtk_tree_view_get_selection(treeview);
	gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
	g_signal_connect(G_OBJECT(selection), "changed",
				G_CALLBACK(cb_tree_selection_changed), NULL);

/* --Setup tab */
	vbox = gkrellm_gtk_framed_notebook_page(tabs, _("Setup"));

	if (!_GK.client_mode)
		gkrellm_gtk_spin_button(vbox, NULL,
					(gfloat) update_interval, 1, 20, 1, 1, 0, 55,
            		cb_update_interval, NULL, FALSE,
            		_("Seconds between updates"));

	vbox1 = gkrellm_gtk_framed_vbox(vbox, _("Format String for Chart Labels"),
				4, FALSE, 0, 2);
	hbox = gtk_hbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(vbox1), hbox, FALSE, TRUE, 5);
	text_format_combo = gtk_combo_new();
	gtk_widget_set_size_request (GTK_WIDGET(text_format_combo), 350, -1);
	gtk_box_pack_start(GTK_BOX(hbox), text_format_combo, FALSE, TRUE, 0);
	list = NULL;
	list = g_list_append(list, text_format);
	list = g_list_append(list, DEFAULT_TEXT_FORMAT);
	list = g_list_append(list,
				"\\r\\f $M\\t$a\\f $l\\N$A\\f $L");
	list = g_list_append(list,
				"\\r\\f $M\\D1$a\\f $l\\D2$A\\f $L");
	gtk_combo_set_popdown_strings(GTK_COMBO(text_format_combo), list);
	gtk_combo_set_case_sensitive(GTK_COMBO(text_format_combo), TRUE);
	g_list_free(list);
	gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(text_format_combo)->entry),
			text_format);
	g_signal_connect(G_OBJECT(GTK_COMBO(text_format_combo)->entry), "changed",
			G_CALLBACK(cb_text_format), NULL);

	vbox1 = gkrellm_gtk_framed_vbox_end(vbox, _("Launch Commands"),
				4, TRUE, 0, 2);
	launch_vbox = gkrellm_gtk_scrolled_vbox(vbox1, NULL,
				GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_widget_show(launch_vbox);
	gtk_widget_realize(launch_vbox);
	for (i = 0, list = inet_mon_list; list; list = list->next, ++i)
		{
		in = (InetMon *) list->data;
		add_launch_entry(launch_vbox, in);
		}

/* --Info tab */
	vbox = gkrellm_gtk_framed_notebook_page(tabs, _("Info"));
	text = gkrellm_gtk_scrolled_text_view(vbox, NULL,
				GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	for (i = 0; i < sizeof(inet_info_text)/sizeof(gchar *); ++i)
		gkrellm_gtk_text_view_append(text, _(inet_info_text[i]));

	reset_entries();
	}



static GkrellmMonitor	monitor_inet =
	{
	N_("Internet"),			/* Name, for config tab.	*/
	MON_INET,			/* Id,  0 if a plugin		*/
	create_inet,		/* The create function		*/
	update_inet,		/* The update function		*/
	create_inet_tab,	/* The config tab create function	*/
	NULL,				/* Instant apply	*/

	save_inet_config,	/* Save user conifg			*/
	load_inet_config,	/* Load user config			*/
	"inet",				/* config keyword			*/

	NULL,				/* Undef 2	*/
	NULL,				/* Undef 1	*/
	NULL,				/* Undef 0	*/

	0,					/* insert_before_id - place plugin before this mon */

	NULL,				/* Handle if a plugin, filled in by GKrellM		*/
	NULL				/* path if a plugin, filled in by GKrellM		*/
	};

GkrellmMonitor *
gkrellm_init_inet_monitor(void)
	{
	monitor_inet.name = _(monitor_inet.name);
	style_id = gkrellm_add_chart_style(&monitor_inet, INET_STYLE_NAME);
	gkrellm_locale_dup_string(&text_format, DEFAULT_TEXT_FORMAT,
					&text_format_locale);
	mon_inet = &monitor_inet;
	if (setup_inet_interface())
		{	/* Make the "data-suffix/inet" directory */
		inet_data_dir = gkrellm_make_data_file_name("inet", NULL);
		return &monitor_inet;
		}
	return FALSE;
	}