cpu.c

系统任务管理器

	{
	GList	*list;
	CpuMon	*cpu;

	for (list = cpu_mon_list; list; list = list->next)
		{
		cpu = (CpuMon *) list->data;
		if (*(cpu->launch.command) != '\0')
			fprintf(f, "%s launch %s %s\n", CPU_CONFIG_KEYWORD,
						cpu->name, cpu->launch.command);
		if (*(cpu->launch.tooltip_comment) != '\0')
			fprintf(f, "%s tooltip_comment %s %s\n", CPU_CONFIG_KEYWORD,
						cpu->name, cpu->launch.tooltip_comment);
		fprintf(f, "%s extra_info %s %d\n", CPU_CONFIG_KEYWORD,
					cpu->name, cpu->extra_info);
		gkrellm_save_chartconfig(f, cpu->chart_config,
					CPU_CONFIG_KEYWORD, cpu->name);
		}
	fprintf(f, "%s enable %d\n", CPU_CONFIG_KEYWORD, cpu_enabled);
	fprintf(f, "%s smp_mode %d\n", CPU_CONFIG_KEYWORD, smp_mode);
	fprintf(f, "%s omit_nice_mode %d\n", CPU_CONFIG_KEYWORD, omit_nice_mode);
	fprintf(f, "%s config_tracking %d\n", CPU_CONFIG_KEYWORD, config_tracking);
	fprintf(f, "%s sensor_mode %d\n", CPU_CONFIG_KEYWORD,
			sensor_separate_mode);
	fprintf(f, "%s text_format %s\n", CPU_CONFIG_KEYWORD, text_format);
	if (cpu_alert)
		{
		gkrellm_save_alertconfig(f, cpu_alert, CPU_CONFIG_KEYWORD, NULL);
		fprintf(f, "%s alert_includes_nice %d\n", CPU_CONFIG_KEYWORD,
					alert_includes_nice);
		}
	}

static void
load_cpu_config(gchar *arg)
	{
	GList	*list;
	CpuMon	*cpu;
	gchar	config[32], item[CFG_BUFSIZE],
			cpu_name[32], command[CFG_BUFSIZE];
	gint	n;

	n = sscanf(arg, "%31s %[^\n]", config, item);
	if (n == 2)
		{
		if (!strcmp(config, "enable"))
			sscanf(item, "%d", &cpu_enabled);
		else if (!strcmp(config, "smp_mode"))
			sscanf(item, "%d\n", &smp_mode);
		else if (!strcmp(config, "omit_nice_mode"))
			sscanf(item, "%d\n", &omit_nice_mode);
		else if (!strcmp(config, "config_tracking"))
			sscanf(item, "%d\n", &config_tracking);
		else if (!strcmp(config, "sensor_mode"))
			sscanf(item, "%d\n", &sensor_separate_mode);
		else if (!strcmp(config, "text_format"))
			gkrellm_locale_dup_string(&text_format, item, &text_format_locale);
		else if (!strcmp(config, "alert_includes_nice"))
			sscanf(item, "%d\n", &alert_includes_nice);
		else if (!strcmp(config, GKRELLM_CHARTCONFIG_KEYWORD))
			{
			sscanf(item, "%31s %[^\n]", cpu_name, command);
			for (list = cpu_mon_list; list; list = list->next)
				{
				cpu = (CpuMon *) list->data;
				if (strcmp(cpu->name, cpu_name) == 0)
					gkrellm_load_chartconfig(&cpu->chart_config, command,
							nice_time_unsupported ? 2 : 3);
				}
			}
		else if (!strcmp(config, GKRELLM_ALERTCONFIG_KEYWORD))
			{
			if (!cpu_alert)
				create_alert();
			gkrellm_load_alertconfig(&cpu_alert, item);
			dup_cpu_alert();
			}
		else if (!strcmp(config, "extra_info"))
			{
			sscanf(item, "%31s %[^\n]", cpu_name, command);
			for (list = cpu_mon_list; list; list = list->next)
				{
				cpu = (CpuMon *) list->data;
				if (strcmp(cpu->name, cpu_name) == 0)
					sscanf(command, "%d\n", &cpu->extra_info);
				}
			}
		else if (!strcmp(config, "launch"))
			{
			sscanf(item, "%31s %[^\n]", cpu_name, command);
			for (list = cpu_mon_list; list; list = list->next)
				{
				cpu = (CpuMon *) list->data;
				if (strcmp(cpu->name, cpu_name) == 0)
					cpu->launch.command = g_strdup(command);
				}
			}
		else if (!strcmp(config, "tooltip_comment"))
			{
			sscanf(item, "%31s %[^\n]", cpu_name, command);
			for (list = cpu_mon_list; list; list = list->next)
				{
				cpu = (CpuMon *) list->data;
				if (strcmp(cpu->name, cpu_name) == 0)
					cpu->launch.tooltip_comment = g_strdup(command);
				}
			}
		}
	}

static void
cb_alert_config(GkrellmAlert *ap, gpointer data)
	{
#if !defined(WIN32)
	alert_includes_nice = GTK_TOGGLE_BUTTON(alert_config_nice_button)->active;
#endif
	dup_cpu_alert();
	}

#if !defined(WIN32)
static void
cb_alert_config_create(GkrellmAlert *ap, GtkWidget *vbox, gpointer data)
	{
	gkrellm_gtk_check_button(vbox, &alert_config_nice_button,
			alert_includes_nice, FALSE, 2,
			_("nice time"));
	}
#endif

static void
cb_set_alert(GtkWidget *button, gpointer data)
	{
	if (!cpu_alert)
		create_alert();
	gkrellm_alert_config_window(&cpu_alert);
	}

static gboolean
fix_panel(CpuMon *cpu)
	{
	gboolean	result;

	if ((result = adjust_sensors_display(cpu, FALSE)) && cpu->launch.button)
		{
		gkrellm_destroy_button(cpu->launch.button);
		cpu->launch.button = 
			gkrellm_put_label_in_panel_button(cpu->chart->panel,
				gkrellm_launch_button_cb, &cpu->launch, cpu->launch.pad);
		}
	return result;
	}

gboolean
gkrellm_cpu_set_sensor(gpointer sr, gint type, gint n)
	{
	CpuMon	*cpu;

	if (   (cpu = (CpuMon *) g_list_nth_data(cpu_mon_list, n)) == NULL
		|| !cpu->enabled
	   )
		return FALSE;

	if (type == SENSOR_TEMPERATURE)
		cpu->sensor_temp = sr;
	else if (type == SENSOR_FAN)
		cpu->sensor_fan = sr;
	else
		return FALSE;
	return fix_panel(cpu);
	}

static void
cb_sensor_separate(GtkWidget *button, gpointer data)
    {
	GList	*list;

	sensor_separate_mode = GTK_TOGGLE_BUTTON(button)->active;
	for (list = cpu_mon_list; list; list = list->next)
		fix_panel((CpuMon *) list->data);
	}

static void
cb_omit_nice(GtkWidget *button, gpointer data)
    {
	omit_nice_mode = GTK_TOGGLE_BUTTON(button)->active;
	}

static void
cb_text_format(GtkWidget *widget, gpointer data)
	{
	GList	*list;
	CpuMon	*cpu;
	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 = cpu_mon_list; list; list = list->next)
		{
		cpu = (CpuMon *) list->data;
		cpu->new_text_format = TRUE;
		refresh_cpu_chart(cpu);
		}
	}

static void
cb_enable(GtkWidget *button, gpointer data)
    {
	GList	*list;
	CpuMon	*cpu;

	cpu_enabled = GTK_TOGGLE_BUTTON(button)->active;
	for (list = cpu_mon_list; list; list = list->next)
		{
		cpu = (CpuMon *) list->data;
		if (enable_cpu_visibility(cpu) && cpu->enabled)
			gkrellm_reset_and_draw_chart(cpu->chart);
		gkrellm_apply_launcher(&cpu->launch_entry, &cpu->tooltip_entry,
					cpu->chart->panel, &cpu->launch, gkrellm_launch_button_cb);
		gkrellm_reset_alert_soft(cpu->alert);
		}
	if (cpu_enabled)
		gkrellm_spacers_show(mon_cpu);
	else
		gkrellm_spacers_hide(mon_cpu);
	}

static void
cb_smp_mode(GtkWidget *button, gpointer data)
	{
	GList		*list;
	CpuMon		*cpu;
	gint		i = GPOINTER_TO_INT(data);
	gboolean	prev_enabled, rebuild_temps = FALSE, rebuild_fans = FALSE;

	if (GTK_TOGGLE_BUTTON(button)->active)
		smp_mode = i;
	for (list = cpu_mon_list; list; list = list->next)
		{
		cpu = (CpuMon *) list->data;
		prev_enabled = cpu->enabled;
		if (enable_cpu_visibility(cpu) && cpu->enabled)
			gkrellm_reset_and_draw_chart(cpu->chart);
		if (prev_enabled && !cpu->enabled)
			{
			if (cpu->sensor_temp)
				{
				gkrellm_sensor_reset_location(cpu->sensor_temp);
				rebuild_temps |= TRUE;
				}
			if (cpu->sensor_fan)
				{
				gkrellm_sensor_reset_location(cpu->sensor_fan);
				rebuild_fans |= TRUE;
				}
			cpu->sensor_temp = NULL;
			cpu->sensor_fan = NULL;
			fix_panel(cpu);
			}
		gkrellm_apply_launcher(&cpu->launch_entry, &cpu->tooltip_entry,
					cpu->chart->panel, &cpu->launch, gkrellm_launch_button_cb);
		}
	if (rebuild_temps || rebuild_fans)
		gkrellm_sensors_rebuild(rebuild_temps, rebuild_fans, FALSE);
	}

static void
cb_config_tracking(GtkWidget *button, gpointer data)
	{
	config_tracking = GTK_TOGGLE_BUTTON(button)->active;
	}

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

#define	DEFAULT_TEXT_FORMAT	"$T"

static gchar	*cpu_info_text[] =
{
N_("<h>Chart Labels\n"),
N_("Substitution variables for the format string for chart labels:\n"),
N_("\t$L    the CPU label\n"),
N_("\t$T    total CPU time percent usage\n"),
N_("\t$s    sys time percent usage\n"),
N_("\t$u    user time percent usage\n"),
N_("\t$n    nice time percent usage\n"),
"\n",
N_("Substitution variables may be used in alert commands.\n")
};

static void
create_cpu_tab(GtkWidget *tab_vbox)
	{
	GtkWidget	*tabs;
	GtkWidget	*button;
	GtkWidget	*hbox, *hbox1, *vbox, *vbox1;
	GtkWidget	*text;
	GtkWidget	*table;
	GSList		*group;
	GList		*list;
	CpuMon		*cpu;
	gchar		buf[128];
	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"));
	gkrellm_gtk_check_button_connected(vbox, NULL, cpu_enabled,
			FALSE, FALSE, 10,
			cb_enable, NULL,
			_("Enable CPU"));
	if (!nice_time_unsupported)
		gkrellm_gtk_check_button_connected(vbox, NULL,
				omit_nice_mode, FALSE, FALSE, 0,
				cb_omit_nice, NULL,
		_("Exclude nice CPU time from krell even if nice is shown on chart"));
	if (gkrellm_sensors_available())
		gkrellm_gtk_check_button_connected(vbox, NULL,
					sensor_separate_mode, FALSE, FALSE, 0,
					cb_sensor_separate, NULL,
		_("Draw fan and temperature values separately (not alternating)."));

	if (n_smp_cpus > 0)
		{
		gkrellm_gtk_check_button_connected(vbox, &button,
				config_tracking, FALSE, FALSE, 10,
				cb_config_tracking, NULL,
		_("Apply any CPU chart config height change to all CPU charts"));

		vbox1 = gkrellm_gtk_framed_vbox(vbox, _("SMP Charts Select"),
				4, FALSE, 0, 2);

		button = gtk_radio_button_new_with_label(NULL, _("Real CPUs."));
		gtk_box_pack_start(GTK_BOX(vbox1), button, TRUE, TRUE, 0);
		smp_button[0] = button;
		group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (button));

		button = gtk_radio_button_new_with_label(group, _("Composite CPU."));
		gtk_box_pack_start(GTK_BOX(vbox1), button, TRUE, TRUE, 0);
		group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (button));
		smp_button[1] = button;

		button = gtk_radio_button_new_with_label(group,
					_("Composite and real"));
		gtk_box_pack_start(GTK_BOX(vbox1), button, TRUE, TRUE, 0);
		smp_button[2] = button;

		button = smp_button[smp_mode];
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);

		for (i = 0; i < 3; ++i)
			g_signal_connect(G_OBJECT(smp_button[i]), "toggled",
						G_CALLBACK(cb_smp_mode), GINT_TO_POINTER(i));
		}

/* -- Setup tab */
	vbox = gkrellm_gtk_framed_notebook_page(tabs, _("Setup"));
	hbox = gtk_hbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 5);
	vbox1 = gkrellm_gtk_framed_vbox(hbox, _("Format String for Chart Labels"),
			 4, FALSE, 0, 2);
	hbox1 = gtk_hbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(vbox1), hbox1, 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(hbox1), 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, _("\\fu \\.$u\\n\\fs \\.$s"));
	list = g_list_append(list, _("\\ww\\D2\\f\\au\\.$u\\D1\\f\\as\\.$s"));
	list = g_list_append(list, _("\\ww\\D3\\f\\au\\.$u\\D0\\f\\as\\.$s"));
	if (!nice_time_unsupported)
		list = g_list_append(list,
			"\\ww\\C\\f$L\\D5\\f\\an\\.$n\\D2\\f\\au\\.$u\\D1\\f\\as\\.$s");
	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 = gtk_vbox_new(FALSE, 0);
	gtk_box_pack_end(GTK_BOX(hbox), vbox1, FALSE, TRUE, 4);
	gkrellm_gtk_alert_button(vbox1, NULL, FALSE, FALSE, 4, FALSE,
			cb_set_alert, NULL);

	vbox1 = gkrellm_gtk_framed_vbox_end(vbox, _("Launch Commands"),
				4, TRUE, 0,2);
	vbox1 = gkrellm_gtk_scrolled_vbox(vbox1, NULL,
				GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	table = gkrellm_gtk_launcher_table_new(vbox1, n_cpus);
	for (i = 0, list = cpu_mon_list; list; list = list->next, ++i)
		{
		cpu = (CpuMon *) list->data;
		snprintf(buf, sizeof(buf), _("%s"), cpu->name);
		gkrellm_gtk_config_launcher(table, i,  &cpu->launch_entry,
				&cpu->tooltip_entry, buf, &cpu->launch);
		g_signal_connect(G_OBJECT(cpu->launch_entry), "changed",
				G_CALLBACK(cb_launch_entry), cpu);
		g_signal_connect(G_OBJECT(cpu->tooltip_entry), "changed",
				G_CALLBACK(cb_launch_entry), cpu);
		}

/* --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(cpu_info_text)/sizeof(gchar *); ++i)
		{
		if (nice_time_unsupported && strstr(cpu_info_text[i], "nice"))
			continue;
		gkrellm_gtk_text_view_append(text, _(cpu_info_text[i]));
		}

	}

gchar *
gkrellm_cpu_get_sensor_panel_label(gint n)
	{
	CpuMon	*cpu;
	gchar	*s = "cpu?";

	cpu = (CpuMon *) g_list_nth_data(cpu_mon_list, n);
	if (cpu)
		s = cpu->panel_label;
	return s;
	}

GkrellmMonitor *
gkrellm_get_cpu_mon(void)
	{
	return mon_cpu;
	}

static GkrellmMonitor	monitor_cpu =
	{
	N_("CPU"),				/* Name, for config tab.	*/
	MON_CPU,			/* Id,  0 if a plugin		*/
	create_cpu,			/* The create function		*/
	update_cpu,			/* The update function		*/
	create_cpu_tab,		/* The config tab create function	*/
	NULL,				/* Apply the config function		*/

	save_cpu_config,	/* Save user conifg			*/
	load_cpu_config,	/* Load user config			*/
	CPU_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_cpu_monitor(void)
	{
	GList	*list;

	monitor_cpu.name = _(monitor_cpu.name);
	style_id = gkrellm_add_chart_style(&monitor_cpu, CPU_STYLE_NAME);
	gkrellm_locale_dup_string(&text_format, DEFAULT_TEXT_FORMAT,
				&text_format_locale);

	mon_cpu = &monitor_cpu;

	if (setup_cpu_interface())
		{
		for (list = cpu_mon_list; list; list = list->next)
			((CpuMon *)(list->data))->extra_info = TRUE;
		return &monitor_cpu;
		}
	return NULL;
	}