mem.c

系统任务管理器

				mem.launch.command);
	fprintf(f, "%s mem_tooltip %s\n", MEM_CONFIG_KEYWORD,
				mem.launch.tooltip_comment);
	fprintf(f, "%s mem_data_format %s\n", MEM_CONFIG_KEYWORD,mem.data_format);

	fprintf(f, "%s swap_launch %s\n", MEM_CONFIG_KEYWORD,
				swap.launch.command);
	fprintf(f, "%s swap_tooltip %s\n", MEM_CONFIG_KEYWORD,
				swap.launch.tooltip_comment);
	fprintf(f, "%s swap_data_format %s\n", MEM_CONFIG_KEYWORD,
				swap.data_format);

	fprintf(f, "%s text_format %s\n", MEM_CONFIG_KEYWORD, text_format);

	if (mem.alert)
		gkrellm_save_alertconfig(f, mem.alert, MEM_CONFIG_KEYWORD, "mem");
	if (swap.alert)
		gkrellm_save_alertconfig(f, swap.alert, MEM_CONFIG_KEYWORD, "swap");
	}

static void
load_meminfo_config(gchar *arg)
	{
	MeminfoMeter *m = NULL;
	gchar		config[32], name[16], item[CFG_BUFSIZE], item1[CFG_BUFSIZE];
	gint		n;

	n = sscanf(arg, "%31s %[^\n]", config, item);
	if (n == 2)
		{
		if (strcmp(config, "mem_meter") == 0)
			{
			sscanf(item, "%d %d %d", &mem.enabled,
					&mem.label_is_data, &mem.all_krells);
			if (mem.label_is_data)
				mem.restore_label = TRUE;
			}
		else if (strcmp(config, "swap_meter") == 0)
			{
			sscanf(item, "%d %d", &swap.enabled, &swap.label_is_data);
			if (swap.label_is_data)
				swap.restore_label = TRUE;
			}
		else if (strcmp(config, "swap_chart") == 0)
			sscanf(item, "%d %d", &swap_chart.enabled, &swap_chart.extra_info);
		else if (!strcmp(config, GKRELLM_CHARTCONFIG_KEYWORD))
			gkrellm_load_chartconfig(&swap_chart.chart_config, item, 2);
		else if (!strcmp(config, "mem_launch"))
			mem.launch.command = g_strdup(item);
		else if (!strcmp(config, "mem_tooltip"))
			mem.launch.tooltip_comment = g_strdup(item);
		else if (!strcmp(config, "mem_data_format"))
			gkrellm_locale_dup_string(&mem.data_format, item,
						&mem.data_format_shadow);
		else if (!strcmp(config, "swap_launch"))
			swap.launch.command = g_strdup(item);
		else if (!strcmp(config, "swap_tooltip"))
			swap.launch.tooltip_comment = g_strdup(item);
		else if (!strcmp(config, "swap_data_format"))
			gkrellm_locale_dup_string(&swap.data_format, item,
						&swap.data_format_shadow);
		else if (!strcmp(config, "text_format"))
			gkrellm_locale_dup_string(&text_format, item, &text_format_locale);
		else if (!strcmp(config, GKRELLM_ALERTCONFIG_KEYWORD))
			{
			if (sscanf(item, "%15s %[^\n]", name, item1) == 2)
				{
				if (!strcmp(name, "mem"))
					m = &mem;
				else if (!strcmp(name, "swap"))
					m = & swap;
				if (m)
					{
					if (!m->alert)
						create_alert(m);
					gkrellm_load_alertconfig(&m->alert, item1);
					}
				}
			}
		}
	}

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

static GtkWidget	*mem_launch_entry,
					*mem_tooltip_entry,
					*swap_launch_entry,
					*swap_tooltip_entry;

static GtkWidget	*mem_format_combo,
					*swap_format_combo;

static GtkWidget	*text_format_combo;

static GtkWidget	*mem_alert_button,
					*swap_alert_button;


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

	s = gkrellm_gtk_entry_get_text(&(GTK_COMBO(text_format_combo)->entry));
	gkrellm_locale_dup_string(&text_format, s, &text_format_locale);
	refresh_chart(&swap_chart);
	}

static void
cb_mem_enable(GtkWidget *button, gpointer data)
    {
	gboolean enabled;

	enabled = GTK_TOGGLE_BUTTON(button)->active;
	gkrellm_panel_enable_visibility(mem.panel, enabled, &mem.enabled);
	spacer_visibility();
	gtk_widget_set_sensitive(mem_alert_button, enabled);
	}

static void
cb_swap_enable(GtkWidget *button, gpointer data)
    {
	gboolean enabled;

	enabled = GTK_TOGGLE_BUTTON(button)->active;
	gkrellm_panel_enable_visibility(swap.panel, enabled, &swap.enabled);
	spacer_visibility();
	gtk_widget_set_sensitive(swap_alert_button, enabled);
	}

static void
cb_swap_chart_enable(GtkWidget *button, gpointer data)
    {
	gboolean enabled;

	enabled = GTK_TOGGLE_BUTTON(button)->active;
	if (enabled && !swap_chart.enabled)
		create_chart(&swap_chart, TRUE);
	else if (!enabled && swap_chart.enabled)
		destroy_chart(&swap_chart);
	setup_scaling(NULL, &swap_chart);
	spacer_visibility();
	}

static void
cb_launch_entry(GtkWidget *widget, gpointer data)
	{
	if (GPOINTER_TO_INT(data) == 0)
		gkrellm_apply_launcher(&mem_launch_entry, &mem_tooltip_entry,
					mem.panel, &mem.launch, gkrellm_launch_button_cb);
	else
		gkrellm_apply_launcher(&swap_launch_entry, &swap_tooltip_entry,
					swap.panel, &swap.launch, gkrellm_launch_button_cb);
	}

static void
cb_all_krells(GtkWidget *button, gpointer data)
    {
	gboolean enabled;

	enabled = GTK_TOGGLE_BUTTON(button)->active;
	if (enabled && !mem.all_krells)
		{		/* krell list order needs to be: cache, buffer, used */
		gkrellm_insert_krell(mem.panel, mem.krell_buffers, FALSE);
		gkrellm_insert_krell(mem.panel, mem.krell_cache, FALSE);
		}
	else if (!enabled && mem.all_krells)
		{
		gkrellm_remove_krell(mem.panel, mem.krell_buffers);
		gkrellm_remove_krell(mem.panel, mem.krell_cache);
		}
	mem.all_krells = enabled;
	}

static void
cb_mem_format(GtkWidget *widget, gpointer data)
	{
	gchar	*s;

	s = gkrellm_gtk_entry_get_text(&(GTK_COMBO(mem_format_combo)->entry));

	/* In case Pango markup tags, don't accept line unless valid markup.
	|  Ie, markup like <span ...> xxx </span> or <b> xxx </b>
	*/
	if (   strchr(s, '<') != NULL
		&& !pango_parse_markup(s, -1, 0, NULL, NULL, NULL, NULL)
	   )
		return;

	if (gkrellm_locale_dup_string(&mem.data_format, s,
				&mem.data_format_shadow))
		mem.decal_label->value = -1;	/* Force redraw */
	}

static void
cb_swap_format(GtkWidget *widget, gpointer data)
	{
	gchar	*s;

	s = gkrellm_gtk_entry_get_text(&(GTK_COMBO(swap_format_combo)->entry));

	if (   strchr(s, '<') != NULL
		&& !pango_parse_markup(s, -1, 0, NULL, NULL, NULL, NULL)
	   )
		return;

	if (gkrellm_locale_dup_string(&swap.data_format, s,
				&swap.data_format_shadow))
		swap.decal_label->value = -1;
	}

static void
cb_set_alert(GtkWidget *button, MeminfoMeter *m)
	{
	if (!m->alert)
		create_alert(m);
	gkrellm_alert_config_window(&m->alert);
	}

#define	DEFAULT_TEXT_FORMAT	"$T"

static gchar	*mem_info_text[] =
{
N_("<h>Used and Free\n"),
N_("The used and free memory here are calculated from the kernel reported\n"
"used and free by subtracting or adding the buffers and cache memory.  See\n"
"the README and compare to the \"-/+ buffers/cache:\" line from the free\n"
"command.  If you show three memory krells, the kernel \"raw free\" is\n"
"the space after the rightmost krell.\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$T    total swap in blocks + swap out blocks\n"),
N_("\t$i    swap in blocks\n"),
N_("\t$o    swap out blocks\n"),
"\n",
N_("<h>Panel Labels\n"),
N_("Substitution variables for the format string for the Mem and Swap\n"
"panels (a MiB is a binary megabyte - 2^20):\n"),

N_("For memory and swap:\n"),
N_("\t$t    total MiB\n"),
N_("\t$u    used MiB\n"),
N_("\t$f    free MiB\n"),
N_("\t$U    used %\n"),
N_("\t$F    free %\n"),
N_("\t$l    the panel label"),
"\n",
N_("For memory only:\n"),
N_("\t$s    shared MiB\n"),
N_("\t$b    buffered MiB\n"),
N_("\t$c    cached MiB\n"),
"\n",
N_("Substitution variables may be used in alert commands.\n"),

"\n",
N_("<h>Mouse Button Actions:\n"),
N_("<b>\tLeft "),
N_("click on a panel to scroll a programmable display of\n"
"\t\tof memory or swap usage.\n")


};

static void
create_meminfo_tab(GtkWidget *tab_vbox)
	{
	GtkWidget		*tabs;
	GtkWidget		*vbox, *vbox1;
	GtkWidget		*table;
	GtkWidget		*hbox;
	GtkWidget		*text, *label;
	GList			*list;
	gint			i;

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

	vbox1 = gkrellm_gtk_framed_vbox(vbox, _("Swap"), 4, FALSE, 0, 2);
    gkrellm_gtk_check_button_connected(vbox1, NULL,
				swap_chart.enabled, FALSE, FALSE, 0,
				cb_swap_chart_enable, NULL,
				_("Enable swap pages in/out chart"));
	hbox = gtk_hbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(vbox1), hbox, FALSE, TRUE, 5);
    gkrellm_gtk_check_button_connected(hbox, NULL,
				swap.enabled, FALSE, FALSE, 0,
				cb_swap_enable, GINT_TO_POINTER(1),
				_("Enable swap meter"));
	gkrellm_gtk_alert_button(hbox, &swap_alert_button, FALSE, FALSE, 4, FALSE,
				cb_set_alert, &swap);
	if (!swap.enabled)
		gtk_widget_set_sensitive(swap_alert_button, FALSE);

	vbox1 = gkrellm_gtk_framed_vbox(vbox, _("Memory"), 4, FALSE, 0, 2);
	hbox = gtk_hbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(vbox1), hbox, FALSE, TRUE, 5);
    gkrellm_gtk_check_button_connected(hbox, NULL,
				mem.enabled, FALSE, FALSE, 0,
				cb_mem_enable, NULL,
				_("Enable memory meter"));
	gkrellm_gtk_alert_button(hbox, &mem_alert_button, FALSE, FALSE, 4, FALSE,
				cb_set_alert, &mem);
	if (!mem.enabled)
		gtk_widget_set_sensitive(mem_alert_button, FALSE);
    gkrellm_gtk_check_button_connected(vbox1, NULL,
				mem.all_krells, FALSE, FALSE, 0,
				cb_all_krells, NULL,
		_("Show three memory krells:   [used | buffers | cache | raw free]"));

/* -- 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), 300, -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, "$T\\C\\f$M");
	list = g_list_append(list, "\\c\\f$M\\b$T");
	list = g_list_append(list,
				"\\ww\\C\\f$M\\D2\\f\\ai\\.$i\\D1\\f\\ao\\.$o");
	list = g_list_append(list,
				"\\ww\\C\\f$M\\D3\\f\\ai\\.$i\\D0\\f\\ao\\.$o");
	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(vbox, _("Format String for Panel Labels"),
			4, FALSE, 0, 2);
	hbox = gtk_hbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(vbox1), hbox, FALSE, FALSE, 0);
	mem_format_combo = gtk_combo_new();
	gtk_box_pack_start(GTK_BOX(hbox), mem_format_combo, FALSE, TRUE, 0);
	list = NULL;
	list = g_list_append(list, mem.data_format);
	list = g_list_append(list, DEFAULT_FORMAT);
	list = g_list_append(list, _("$t - $u used"));
	list = g_list_append(list, _("$t - $U"));
	list = g_list_append(list, _("$t - $u used  $s sh  $b bf  $c ca"));
	gtk_combo_set_popdown_strings(GTK_COMBO(mem_format_combo), list);
	gtk_combo_set_case_sensitive(GTK_COMBO(mem_format_combo), TRUE);
	g_list_free(list);
	gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(mem_format_combo)->entry),
			mem.data_format);
	g_signal_connect(G_OBJECT(GTK_COMBO(mem_format_combo)->entry), "changed",
			G_CALLBACK(cb_mem_format), NULL);
	label = gtk_label_new(_("Mem"));
	gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
	gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 2);

	swap_format_combo = gtk_combo_new();
	gtk_box_pack_start(GTK_BOX(hbox), swap_format_combo, FALSE, TRUE, 0);
	list = NULL;
	list = g_list_append(list, swap.data_format);
	list = g_list_append(list, DEFAULT_FORMAT);
	list = g_list_append(list, _("$t - $u used"));
	list = g_list_append(list, _("$t - $U"));
	gtk_combo_set_popdown_strings(GTK_COMBO(swap_format_combo), list);
	gtk_combo_set_case_sensitive(GTK_COMBO(swap_format_combo), TRUE);
	g_list_free(list);
	gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(swap_format_combo)->entry),
			swap.data_format);
	g_signal_connect(G_OBJECT(GTK_COMBO(swap_format_combo)->entry), "changed",
			G_CALLBACK(cb_swap_format), NULL);
	label = gtk_label_new(_("Swap"));
	gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
	gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 2);

	vbox1 = gkrellm_gtk_framed_vbox_end(vbox, _("Launch Commands"),
				4, FALSE, 0, 2);
	table = gkrellm_gtk_launcher_table_new(vbox1, 2);
	gkrellm_gtk_config_launcher(table, 0,  &mem_launch_entry,
				&mem_tooltip_entry, _("Mem"), &(mem.launch));
	g_signal_connect(G_OBJECT(mem_launch_entry), "changed",
				G_CALLBACK(cb_launch_entry), GINT_TO_POINTER(0));
	g_signal_connect(G_OBJECT(mem_tooltip_entry), "changed",
				G_CALLBACK(cb_launch_entry), GINT_TO_POINTER(0));

	gkrellm_gtk_config_launcher(table, 1,  &swap_launch_entry,
				&swap_tooltip_entry, _("Swap"), &(swap.launch));
	g_signal_connect(G_OBJECT(swap_launch_entry), "changed",
				G_CALLBACK(cb_launch_entry), GINT_TO_POINTER(1));
	g_signal_connect(G_OBJECT(swap_tooltip_entry), "changed",
				G_CALLBACK(cb_launch_entry), GINT_TO_POINTER(1));

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


  /* The meminfo monitor is a bit of a hybrid.  To provide for easy theming,
  |  the mem, swap, and swap_chart monitors are created as separate monitors,
  |  but they all have several common routines (update, config, ...).  Where
  |  a common routine is used, it is entered in only one of the GkrellmMonitor
  |  structures, and NULL is entered in the others.
  */
static GkrellmMonitor	monitor_mem =
	{
	N_("Memory"),		/* Name, for config tab.	*/
	MON_MEM,			/* Id,  0 if a plugin		*/
	create_mem,			/* The create function		*/
	update_meminfo,		/* The update function		*/
	create_meminfo_tab, /* The config tab create function	*/
	NULL, 				/* Instant apply */

	save_meminfo_config, /* Save user conifg			*/
	load_meminfo_config, /* Load user config			*/
	MEM_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_mem_monitor(void)
	{
	monitor_mem.name = _(monitor_mem.name);
	mon_mem = &monitor_mem;
	mem.style_id = gkrellm_add_meter_style(mon_mem, MEM_STYLE_NAME);

	gkrellm_locale_dup_string(&mem.data_format, DEFAULT_FORMAT,
			&mem.data_format_shadow);
	mem.enabled = TRUE;

	if (setup_meminfo_interface())
		return &monitor_mem;
	return NULL;
	}


static GkrellmMonitor	monitor_swap =
	{
	NULL,			/* Name, for config tab. Done in mon_mem*/
	MON_SWAP,		/* Id,  0 if a plugin		*/
	NULL,			/* The create function		*/
	NULL,			/* The update function		*/
	NULL,			/* The config tab create function	*/
	NULL,			/* Apply the config function		*/
	NULL,			/* Save user conifg			*/
	NULL,			/* Load user config			*/
	NULL,			/* 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_swap_monitor(void)
	{
	mon_swap = &monitor_swap;
	swap.style_id = gkrellm_add_meter_style(mon_swap, SWAP_STYLE_NAME);

	gkrellm_locale_dup_string(&swap.data_format, DEFAULT_FORMAT,
			&swap.data_format_shadow);
	swap.enabled = TRUE;

	swap_chart.enabled = FALSE;
	swap_chart.extra_info = TRUE;
	gkrellm_locale_dup_string(&text_format, DEFAULT_TEXT_FORMAT,
					&text_format_locale);

	if (setup_meminfo_interface())	/* XXX */
		return &monitor_swap;
	return NULL;
	}