disk.c

系统任务管理器

					}
				}
			return;
			}
		if (!disk)
			return;
		if (!strcmp(config, GKRELLM_CHARTCONFIG_KEYWORD))
			gkrellm_load_chartconfig(&disk->chart_config, item1, 2);
		else if (!strcmp(config, GKRELLM_ALERTCONFIG_KEYWORD))
			{
			if (!disk->alert)
				create_alert(disk);
			gkrellm_load_alertconfig(&disk->alert, item1);
			}
		else if (!strcmp(config, "extra_alert_config"))
			sscanf(item1, "%d %d",
							&disk->alert_uses_read, &disk->alert_uses_write);
		else if (!strcmp(config, "launch"))
			disk->launch.command = g_strdup(item1);
		else if (!strcmp(config, "tooltip_comment"))
			disk->launch.tooltip_comment = g_strdup(item1);
		}
	}


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

enum
	{
	NAME_COLUMN,
	ENABLE_COLUMN,
	DISK_COLUMN,
	IMAGE_COLUMN,
	N_COLUMNS
	};

static GtkTreeView			*treeview;

static GtkTreeRowReference	*row_reference;
static GtkTreeSelection		*selection;

static GtkWidget			*launch_vbox,
							*text_format_combo;

static GtkWidget			*alert_button;



static GtkTreeModel *
create_model(void)
	{
	GtkTreeStore	*tree;
	GtkTreeIter		iter, citer;
	GList			*list, *clist;
	DiskMon			*disk;

	tree = gtk_tree_store_new(N_COLUMNS,
				G_TYPE_STRING,
                G_TYPE_BOOLEAN,
				G_TYPE_POINTER,
				GDK_TYPE_PIXBUF);
	for (list = disk_mon_list; list; )
		{
		disk = (DiskMon *) list->data;
		gtk_tree_store_append(tree, &iter, NULL);
		if (list == disk_mon_list)
			gtk_tree_store_set(tree, &iter,
				NAME_COLUMN, _("Composite chart combines data for all disks"),
				ENABLE_COLUMN, disk->enabled,
				DISK_COLUMN, disk,
				-1);
		else
			{
			gtk_tree_store_set(tree, &iter,
					NAME_COLUMN, disk->label,
					ENABLE_COLUMN, disk->enabled,
					DISK_COLUMN, disk,
					-1);
			if (disk->alert)
				gtk_tree_store_set(tree, &iter,
						IMAGE_COLUMN, gkrellm_alert_pixbuf(), -1);
			}
		for (clist = list->next; clist; clist = clist->next)
			{
			disk = (DiskMon *) clist->data;
			if (disk->subdisk == -1)
				break;
			gtk_tree_store_append(tree, &citer, &iter);
			gtk_tree_store_set(tree, &citer,
					NAME_COLUMN, disk->name,
					ENABLE_COLUMN, disk->enabled,
					DISK_COLUMN, disk,
					-1);
			if (disk->alert)
				gtk_tree_store_set(tree, &citer,
						IMAGE_COLUMN, gkrellm_alert_pixbuf(), -1);
			}
		list = clist;
		}

	return GTK_TREE_MODEL(tree);
	}

static void
cb_launch_entry(GtkWidget *widget, DiskMon *disk)
	{
	if (disk->enabled)
		gkrellm_apply_launcher(&disk->launch_entry, &disk->tooltip_entry,
				disk->chart->panel, &disk->launch, gkrellm_launch_button_cb);
	}

static void
add_launch_entry(GtkWidget *vbox, DiskMon *disk)
	{
	disk->launch_table = gkrellm_gtk_launcher_table_new(vbox, 1);
	gkrellm_gtk_config_launcher(disk->launch_table, 0,  &disk->launch_entry,
				&disk->tooltip_entry, disk->label,
				&disk->launch);
	g_signal_connect(G_OBJECT(disk->launch_entry), "changed",
				G_CALLBACK(cb_launch_entry), disk);
	g_signal_connect(G_OBJECT(disk->tooltip_entry), "changed",
				G_CALLBACK(cb_launch_entry), disk);
	gtk_widget_show_all(disk->launch_table);
    }

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 void
cb_alert_config(GkrellmAlert *ap, DiskMon *disk)
	{
	GtkTreeModel	*model;
	GtkTreeIter		iter, citer;
	DiskMon			*disk_test;
	GdkPixbuf		*pixbuf;
	gboolean		valid;

	disk->alert_uses_read =
				GTK_TOGGLE_BUTTON(disk->alert_config_read_button)->active;
	disk->alert_uses_write =
				GTK_TOGGLE_BUTTON(disk->alert_config_write_button)->active;
	if (!gkrellm_config_window_shown())
		return;
	model = gtk_tree_view_get_model(treeview);
	pixbuf = ap->activated ? gkrellm_alert_pixbuf() : NULL;
	valid = gtk_tree_model_get_iter_first(model, &iter);
	while (valid)
		{
		gtk_tree_model_get(model, &iter, DISK_COLUMN, &disk_test, -1);
		if (disk == disk_test)
			{
			gtk_tree_store_set(GTK_TREE_STORE(model), &iter,
						IMAGE_COLUMN, pixbuf, -1);
			return;
			}
		if (gtk_tree_model_iter_children(model, &citer, &iter))
			do
				{
				gtk_tree_model_get(model, &citer, DISK_COLUMN, &disk_test, -1);
				if (disk == disk_test)
					{
					gtk_tree_store_set(GTK_TREE_STORE(model), &citer,
								IMAGE_COLUMN, pixbuf, -1);
					return;
					}
				}
			while (gtk_tree_model_iter_next(model, &citer));

		valid = gtk_tree_model_iter_next(model, &iter);
		}
	}

static void
cb_alert_config_button(GtkWidget *button, DiskMon *disk)
	{
	gboolean	read, write;

	read = GTK_TOGGLE_BUTTON(disk->alert_config_read_button)->active;
	write = GTK_TOGGLE_BUTTON(disk->alert_config_write_button)->active;
	if (!read && !write)
		{
		gtk_toggle_button_set_active(
				GTK_TOGGLE_BUTTON(disk->alert_config_read_button), TRUE);
		gtk_toggle_button_set_active(
				GTK_TOGGLE_BUTTON(disk->alert_config_write_button), TRUE);
		}
	}

static void
cb_alert_config_create(GkrellmAlert *ap, GtkWidget *vbox, DiskMon *disk)
	{
    gkrellm_gtk_check_button_connected(vbox, &disk->alert_config_read_button,
				disk->alert_uses_read, FALSE, FALSE, 2,
				cb_alert_config_button, disk, _("Read bytes"));
    gkrellm_gtk_check_button_connected(vbox, &disk->alert_config_write_button,
				disk->alert_uses_write, FALSE, FALSE, 2,
				cb_alert_config_button, disk, _("Write bytes"));
	}

static void
cb_set_alert(GtkWidget *button, gpointer data)
	{
	GtkTreeModel	*model;
	GtkTreePath		*path;
	GtkTreeIter		iter;
	DiskMon			*disk;

	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_tree_model_get(model, &iter, DISK_COLUMN, &disk, -1);

	if (!disk->alert)
		create_alert(disk);
	gkrellm_alert_config_window(&disk->alert);
	}


static void
cb_tree_selection_changed(GtkTreeSelection *selection, gpointer data)
	{
	GtkTreeIter     iter;
	GtkTreeModel    *model;
	GtkTreePath     *path;
	DiskMon			*disk;
	gint            *indices, depth;

	if (!gtk_tree_selection_get_selected(selection, &model, &iter))
		{
		gtk_widget_set_sensitive(alert_button, FALSE);
		return;
		}
	path = gtk_tree_model_get_path(model, &iter);
	indices = gtk_tree_path_get_indices(path);
	depth = gtk_tree_path_get_depth(path);
// printf("selection: indices=[%d,%d]:%d, path=%s\n",
//          indices[0], indices[1], gtk_tree_path_get_depth(path),
//          gtk_tree_path_to_string(path));
	change_row_reference(model, path);

	gtk_tree_model_get(model, &iter,
			DISK_COLUMN, &disk, -1);

	if (!disk->enabled || (depth == 1 && indices[0] == 0))
		gtk_widget_set_sensitive(alert_button, FALSE);
	else
		gtk_widget_set_sensitive(alert_button, TRUE);
	gtk_tree_path_free(path);
	}

static void
cb_enable(GtkCellRendererText *cell, gchar *path_string, gpointer data)
	{
	GtkTreeModel	*model;
	GtkTreeIter		iter;
	GtkTreePath		*path;
	GList			*list;
	DiskMon			*disk;
	gboolean		enabled;

	model = GTK_TREE_MODEL(data);
	path = gtk_tree_path_new_from_string(path_string);
	gtk_tree_model_get_iter(model, &iter, path);
	gtk_tree_path_free(path);

	gtk_tree_model_get(model, &iter,
				ENABLE_COLUMN, &enabled,
				DISK_COLUMN, &disk,
				-1);
	gtk_tree_store_set(GTK_TREE_STORE(model), &iter,
				ENABLE_COLUMN, !enabled, 
				-1);
	if (enabled)
		{
		destroy_disk_monitor(disk);
		gtk_widget_set_sensitive(alert_button, FALSE);
		}
	else
		{
		create_disk_monitor(disk, TRUE);
		add_launch_entry(launch_vbox, disk);
		gtk_widget_set_sensitive(alert_button, TRUE);
		}
	disk->enabled = !enabled;
	enabled = FALSE;
	for (list = disk_mon_list; list; list = list->next)
		if (((DiskMon *) list->data)->enabled)
			enabled = TRUE;
	if (enabled)
		gkrellm_spacers_show(mon_disk);
	else
		gkrellm_spacers_hide(mon_disk);
	}

static void
cb_text_format(GtkWidget *widget, gpointer data)
	{
	GList	*list;
	DiskMon	*disk;
	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 = disk_mon_list; list; list = list->next)
		{
		disk = (DiskMon *) list->data;
		disk->new_text_format = TRUE;
		draw_disk_chart(disk);
		}
	}


#define	DEFAULT_TEXT_FORMAT	"$T"

static gchar	*disk_info_text[] =
{
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$T    total read bytes + write bytes\n"),
N_("\t$r    read bytes\n"),
N_("\t$w    write bytes\n"),
"\n",
N_("Substitution variables may be used in alert commands.\n")
};

static void
create_disk_tab(GtkWidget *tab_vbox)
	{
	GtkWidget		*tabs;
	GtkWidget		*vbox, *vbox1, *hbox;
	GtkWidget		*text;
	GtkWidget		*scrolled;
	GtkTreeModel	*model;
	GtkCellRenderer	*renderer;
	GList			*list;
	DiskMon			*disk;
	gint			i;

	check_for_new_disks();
	if (n_disks == 0)
		return;

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

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

	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));
	gtk_tree_view_set_rules_hint(treeview, TRUE);

	renderer = gtk_cell_renderer_toggle_new();
	gtk_tree_view_insert_column_with_attributes(treeview, -1, _("Enable"),
				renderer,
				"active", ENABLE_COLUMN,
				NULL);
	g_signal_connect(G_OBJECT(renderer), "toggled",
				G_CALLBACK(cb_enable), model);

	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_insert_column_with_attributes(treeview, -1, _("Disk"),
				renderer,
				"text", NAME_COLUMN,
				NULL);

	renderer = gtk_cell_renderer_pixbuf_new();
	gtk_tree_view_insert_column_with_attributes(treeview, -1, "",
				renderer,
				"pixbuf", IMAGE_COLUMN,
				NULL);

	gtk_container_add(GTK_CONTAINER(scrolled), GTK_WIDGET(treeview));
	g_object_unref(G_OBJECT(model));
	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);

	hbox = gtk_hbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3);
	gkrellm_gtk_alert_button(hbox, &alert_button, FALSE, FALSE, 4, FALSE,
				cb_set_alert, NULL);
	gtk_widget_set_sensitive(alert_button, FALSE);

/* -- Setup tab */
	vbox = gkrellm_gtk_framed_notebook_page(tabs, _("Setup"));
	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, "\\c\\f$M\\n$T");
	list = g_list_append(list, "\\c\\f$M\\b$T");
	list = g_list_append(list,
					_("\\f\\ww\\r\\f$M\\D2\\f\\ar\\. $r\\D1\\f\\aw\\. $w"));
	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);

	vbox = gkrellm_gtk_framed_vbox_end(vbox, _("Launch Commands"),
						4, TRUE, 0, 2);
	launch_vbox = gkrellm_gtk_scrolled_vbox(vbox, NULL,
						GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_widget_show(launch_vbox);
	gtk_widget_realize(launch_vbox);
	for (i = 0, list = disk_mon_list; list; list = list->next, ++i)
		{
		disk = (DiskMon *) list->data;
		if (disk->enabled)
			add_launch_entry(launch_vbox, disk);
		}

/* --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(disk_info_text)/sizeof(gchar *); ++i)
		gkrellm_gtk_text_view_append(text, _(disk_info_text[i]));
	}

static GkrellmMonitor	monitor_disk =
	{
	N_("Disk"),			/* Name, for config tab.	*/
	MON_DISK,			/* Id,  0 if a plugin		*/
	create_disk,		/* The create function		*/
	update_disk,		/* The update function		*/
	create_disk_tab,	/* The config tab create function	*/
	NULL,				/* Instant apply */

	save_disk_config,	/* Save user conifg			*/
	load_disk_config,	/* Load user config			*/
	DISK_CONFIG_KEYWORD, /* 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_disk_monitor(void)
	{
	DiskMon	*disk;

	monitor_disk.name = _(monitor_disk.name);

	disk = disk_new("Disk", _("Disk"));
	disk_mon_list = g_list_append(disk_mon_list, disk);

	composite_disk = disk;
	gkrellm_locale_dup_string(&text_format, DEFAULT_TEXT_FORMAT,
				&text_format_locale);
	mon_disk = &monitor_disk;

	if (setup_disk_interface())
		{
		if (n_disks > 0)
			composite_disk->enabled = TRUE;
		style_id = gkrellm_add_chart_style(&monitor_disk, DISK_STYLE_NAME);
		return &monitor_disk;
		}
	return NULL;
	}