sensors.c

系统任务管理器

		}
	}

static void
create_sensors_monitor(gboolean do_temp, gboolean do_fan, gboolean do_volt,
			gboolean first_create)
	{
	make_sensor_monitor_lists(do_temp, do_fan, do_volt);
	if (do_temp && temperature_list)
		{
		if (!pTemp)
			pTemp = gkrellm_panel_new0();
		make_temperature_panel(temp_vbox, first_create);
		}
	if (do_fan && fan_list)
		{
		if (!pFan)
			pFan = gkrellm_panel_new0();
		make_fan_panel(fan_vbox, first_create);
		}
	if (do_volt && volt_list)
		{
		if (!pVolt)
			pVolt = gkrellm_panel_new0();
		make_volt_panel(volt_vbox, first_create);
		}
	if (temperature_list || fan_list || volt_list)
		gkrellm_spacers_show(mon_sensors);
	else
		gkrellm_spacers_hide(mon_sensors);
	}

void
gkrellm_sensors_rebuild(gboolean do_temp, gboolean do_fan, gboolean do_volt)
	{
	destroy_sensors_monitor(do_temp, do_fan, do_volt);
	create_sensors_monitor(do_temp, do_fan, do_volt, TRUE);
	}

static void
create_sensors(GtkWidget *vbox, gint first_create)
	{
	gchar			**xpm;
	static gboolean	config_loaded;

	if (!config_loaded)
		read_sensors_config();
	if (first_create)
		{
		temp_vbox = gtk_vbox_new(FALSE, 0);
		gtk_box_pack_start(GTK_BOX(vbox), temp_vbox, FALSE, FALSE, 0);
		gtk_widget_show(temp_vbox);

		fan_vbox = gtk_vbox_new(FALSE, 0);
		gtk_box_pack_start(GTK_BOX(vbox), fan_vbox, FALSE, FALSE, 0);
		gtk_widget_show(fan_vbox);

		volt_vbox = gtk_vbox_new(FALSE, 0);
		gtk_box_pack_start(GTK_BOX(vbox), volt_vbox, FALSE, FALSE, 0);
		gtk_widget_show(volt_vbox);

		bezel_style = gkrellm_style_new0();
		}
	else		/* To be done after disk panels created */
		need_disk_temperature_update = TRUE;

	config_loaded = TRUE;

	/* Here is where I define the volt panel theme image extensions.  I ask
	|  for a theme extension image:
	|      THEME_DIR/sensors/bg_volt.png
	|  and for a border for it from the gkrellmrc in the format:
	|      set_piximage_border sensors_bg_volt l,r,t,b
	| There is no default for bg_volt image, ie it may end up being NULL. 
	*/
	xpm = gkrellm_using_default_theme() ? bg_volt_xpm : NULL;
	if (bezel_piximage)
		gkrellm_destroy_piximage(bezel_piximage);
	bezel_piximage = NULL;
	gkrellm_load_piximage("bg_volt", xpm, &bezel_piximage, SENSOR_STYLE_NAME);
	if (!gkrellm_set_gkrellmrc_piximage_border("sensors_bg_volt", bezel_piximage, bezel_style))
		bezel_style->border = default_bezel_border;

	create_sensors_monitor(DO_TEMP, DO_FAN, DO_VOLT, first_create);
	}

  /* FIXME: monitor_sensors and monitor_config_sensors should be combined,
  |  but the issue is apply_sensors_config() must be called before the CPU
  |  and Proc apply, and I want create_sensors() called after the CPU and Proc
  |  create.  So for now, two GkrellmMonitor structs and have two sensor
  |  monitor add_builtins() in main.c.
  */
static GkrellmMonitor	monitor_sensors =
	{
	N_("Sensors"),		/* Voltage config handled in Sensors tab */
	MON_VOLTAGE,		/* Id,  0 if a plugin		*/
	create_sensors,		/* The create function		*/
	update_sensors,		/* The update function		*/
	NULL,				/* The config tab create function	*/
	NULL,				/* Voltage apply handled in sensors apply */

	NULL,				/* Voltage save config is in sensors save */
	NULL,				/* Voltage load config is in sensors load */
	NULL,				/* config keyword - use sensors */

	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_sensor_monitor(void)
	{
	if (!sensor_list)
		return NULL;
	monitor_sensors.name = _(monitor_sensors.name);
	style_id = gkrellm_add_meter_style(&monitor_sensors, SENSOR_STYLE_NAME);
	mon_sensors = &monitor_sensors;
	return &monitor_sensors;
	}

/* =================================================================== */
/* Config for sensors monitor */

  /* Don't use the user-config.  Save into sensors-config and only if there
  |  is a sensor_list.  This preserves configs across a possible sensors
  |  modules load screw up.
  */
  /* 2.1.15 scales sensor factor/offset values by SENSOR_FLOAT_FACTOR to avoid
  |  writting decimal points in the config.  This is not backwards compatible
  |  with the pre 2.1.15 sensor_config format hence the config file name
  |  change to sensor-config.  But sensor_config is forward compatible
  |  since the float factor defaults to 1.0.
  */
  /* gkrellm 2.2.3 sets sensor_config_version to 1 to allow sensor relocation
  |  to composite CPU on a SMP machine.
  */
#define	SENSOR_CONFIG_VERSION		1

#define	SENSOR_CONFIG_KEYWORD		"sensor"
#define	SENSOR_CONFIG_FILE			"sensor-config"
#define	SENSOR_2_1_14_CONFIG_FILE	"sensors_config"

static void		cb_alert_config(GkrellmAlert *ap, Sensor *sr);

static void
create_sensor_alert(Sensor *s)
	{
	if (s->type == SENSOR_VOLTAGE)
		s->alert = gkrellm_alert_create(NULL, s->name,
				_("Sensor Volt Limits"),
				TRUE, TRUE, TRUE, 20, -20, 0.01, 0.5, 2);
	else if (s->type == SENSOR_TEMPERATURE)
		s->alert = gkrellm_alert_create(NULL, s->name,
				_("Sensor Temperature Limits (in displayed degree units)"),
				TRUE, FALSE, TRUE, 300, 0, 1.0, 5.0, 1);
	else if (s->type == SENSOR_FAN)
		s->alert = gkrellm_alert_create(NULL, s->name,
				_("Sensor Fan RPM Limits"),
				FALSE, TRUE, TRUE, 20000, 0, 100, 1000, 0);
	else
		return;
	gkrellm_alert_delay_config(s->alert, 5, 60, 0);
	gkrellm_alert_trigger_connect(s->alert, s->cb_alert, s->cb_alert_data);
	gkrellm_alert_command_process_connect(s->alert, cb_command_process, s);
	gkrellm_alert_config_connect(s->alert, cb_alert_config, s);
	}

static void
save_sensors_config(FILE *f_not_used)
	{
	FILE	*f;
	GList	*list;
	Sensor	*s;
	gchar	*config, quoted_name[128], buf[128];

	if (!sensor_list)
		return;
	sprintf(buf, "%s/%s", GKRELLM_DIR, SENSOR_CONFIG_FILE);
	config = gkrellm_make_config_file_name(gkrellm_homedir(), buf);
	f = fopen(config, "w");
	g_free(config);
	if (!f)
		return;

	fprintf(f, "%s sensor_config_version %d\n",
				SENSOR_CONFIG_KEYWORD, SENSOR_CONFIG_VERSION);
	fprintf(f, "%s sensor_float_factor %.0f\n",
				SENSOR_CONFIG_KEYWORD, SENSOR_FLOAT_FACTOR);
	fprintf(f, "%s gkrellm_float_factor %.0f\n",
				SENSOR_CONFIG_KEYWORD, GKRELLM_FLOAT_FACTOR);
	for (list = sensor_list; list; list = list->next)
		{
		s = (Sensor *) list->data;
		if (s->name && *(s->name))
			{
			snprintf(quoted_name, sizeof(quoted_name), "\"%s\"", s->id_name);
			fprintf(f, "%s \"%s\" %s %.0f %.0f %d %d\n",
				SENSOR_CONFIG_KEYWORD,
				s->name, quoted_name,
				s->factor * SENSOR_FLOAT_FACTOR,
				s->offset * SENSOR_FLOAT_FACTOR,
				s->enabled, s->location);
			if (s->alert)
				gkrellm_save_alertconfig(f, s->alert,
						SENSOR_CONFIG_KEYWORD, quoted_name);
			}
		}
	for (list = sensor_list; list; list = list->next)
		{
		s = (Sensor *) list->data;
		if (s->vref)
			fprintf(f, "%s vref \"%s\" \"%s\"\n", SENSOR_CONFIG_KEYWORD,
					s->id_name, s->vref->id_name);
		}
	fprintf(f, "%s units_fahrenheit %d\n", SENSOR_CONFIG_KEYWORD,
				units_fahrenheit);
	fprintf(f, "%s volt_display_mode %d\n", SENSOR_CONFIG_KEYWORD,
				display_mode);
	/* _GK.mbmon_port is handled in config.c so that the port can be
	|  loaded early for sensor initialization.
	*/
	fclose(f);
	}

static void
load_sensors_config(gchar *arg)
	{
	Sensor		*s;
	gchar		config[32], item[CFG_BUFSIZE], item1[CFG_BUFSIZE];
	gchar		label[64], id_name[CFG_BUFSIZE];
	gint		n;
	gfloat		f	= 1.0,
				o	= 0.0;
	gint		e	= 0,
				location = 0;
	gfloat		save_factor;

	n = sscanf(arg, "%31s %[^\n]", config, item);
	if (n != 2)
		return;
	if (_GK.debug_level & DEBUG_SENSORS)
		printf("load_sensors_config: <%s> <%s>\n", config, item);
	if (!strcmp(config, "sensor_config_version"))
		sscanf(item, "%d", &sensor_config_version);
	else if (!strcmp(config, "units_fahrenheit"))
		sscanf(item, "%d", &units_fahrenheit);
	else if (!strcmp(config, "volt_display_mode"))
		sscanf(item, "%d", &display_mode);
	else if (!strcmp(config, "sensor_float_factor"))
		sscanf(item, "%f", &sensor_float_factor);
	else if (!strcmp(config, "gkrellm_float_factor"))
		sscanf(item, "%f", &gkrellm_float_factor);
	else if (!strcmp(config, "vref"))
		{
		if (   sscanf(item, "\"%63[^\"]\" \"%64[^\"]\"", id_name, item1) == 2
			&& (s = lookup_sensor_from_id_name(id_name)) != NULL
		   )
			s->vref = lookup_sensor_from_id_name(item1);
		}
	else if (!strcmp(config, GKRELLM_ALERTCONFIG_KEYWORD))
		{
		if (   sscanf(item, "\"%63[^\"]\" %[^\n]", id_name, item1) == 2
			&& (s = lookup_sensor_from_id_name(id_name)) != NULL
		   )
			{
			/* Since config files may be copied around, make sure to use the
			|  gkrellm float factor in effect when the sensors config was
			|  created.
			*/
			save_factor = _GK.float_factor;
			_GK.float_factor = gkrellm_float_factor;
			if (!s->alert)
				create_sensor_alert(s);
			gkrellm_load_alertconfig(&s->alert, item1);
			_GK.float_factor = save_factor;
			}
		}
	else if (   sscanf(arg, "\"%63[^\"]\" \"%[^\"]\" %f %f %d %d",
						label, id_name, &f, &o, &e, &location) > 1
			 && (s = map_sensor_label(label, id_name)) != NULL
			)
		{
		s->factor = f / sensor_float_factor;
		s->offset = o / sensor_float_factor;
		s->enabled = e;

		if (s->type == SENSOR_VOLTAGE)
			s->location = 0;
		else
			{
			s->location = location;
			if (   sensor_config_version == 0 && gkrellm_smp_cpus() > 0
				&& location > PROC_PANEL_LOCATION
			   )
				/* gkrellm < 2.2.3 did not allow relocating to composite
				|  CPU if on a SMP machine.  But with hyperthreading, user
				|  may want to do this.
				*/
				s->location += 1;
			}
		if (!using_new_config && s->type != SENSOR_VOLTAGE)
			s->enabled = TRUE;		/* Old config enabled with a label */
		}
	if (display_mode < 0 || display_mode >= N_DISPLAY_MODES)
		display_mode = N_DISPLAY_MODES - 1;
	}

static void
read_sensors_config(void)
	{
	FILE	*f;
	Sensor	*sr;
	GList	*list;
	gchar	*config;
	gchar	buf[CFG_BUFSIZE];

	sprintf(buf, "%s/%s", GKRELLM_DIR, SENSOR_CONFIG_FILE);
	config = gkrellm_make_config_file_name(gkrellm_homedir(), buf);
	f = fopen(config, "r");
	g_free(config);

	if (!f)
		{
		sprintf(buf, "%s/%s", GKRELLM_DIR, SENSOR_2_1_14_CONFIG_FILE);
		config = gkrellm_make_config_file_name(gkrellm_homedir(), buf);
		f = fopen(config, "r");
		g_free(config);
		}
	if (f)
		{
		using_new_config = TRUE;
		while (fgets(buf, sizeof(buf), f))
			load_sensors_config(buf + strlen(SENSOR_CONFIG_KEYWORD) + 1);
		fclose(f);
		}

	/* In case not all sensors are in sensor_config (user edited?)
	*/
	for (list = sensor_list; list; list = list->next)
		{
		sr = (Sensor *) list->data;
		if (sr->has_config)		/* Was in sensor_config and is already	*/
			continue;			/* appended to an order_list			*/
		append_sensor_to_order_list(sr);
		}
	g_list_free(sensor_list);
	sensor_list = temp_order_list;
	sensor_list = g_list_concat(sensor_list, fan_order_list);
	sensor_list = g_list_concat(sensor_list, volt_order_list);
	}

enum
	{
	NAME_COLUMN,
	ENABLE_COLUMN,
	LABEL_COLUMN,
	SENSOR_COLUMN,
	VISIBLE_COLUMN,
	IMAGE_COLUMN,
	N_COLUMNS
	};

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


static GtkWidget	*optionmenu,
					*optionmenu_menu;

static GtkWidget	*display_mode_button[2];
static GtkWidget	*factor_spin_button,
					*offset_spin_button;
static GtkWidget	*alert_button,
					*mbmon_port_entry;

static Sensor		*dragged_sensor;

static gint			sensor_last_group;

static gboolean		(*original_row_drop_possible)();



static void
set_tree_store_model_data(GtkTreeStore *tree, GtkTreeIter *iter, Sensor *s)
	{
	if (!s)
		return;
	gtk_tree_store_set(tree, iter,
			NAME_COLUMN, s->id_name ? s->id_name : "??",
			ENABLE_COLUMN, s->enabled,
			LABEL_COLUMN, s->name ? s->name : "??",
			SENSOR_COLUMN, s,
			VISIBLE_COLUMN, TRUE,
			-1);
	if (s->alert)
		gtk_tree_store_set(tree, iter,
				IMAGE_COLUMN, gkrellm_alert_pixbuf(),
				-1);
	}

static void
append_sensors_to_model(GtkTreeStore *tree, GtkTreeIter *citer,
			GtkTreeIter *iter, gint type)
	{
	GList	*list;
	Sensor	*s;

	for (list = sensor_list; list; list = list->next)
		{
		s = (Sensor *) list->data;
		if (s->type != type)
			continue;
		gtk_tree_store_append(tree, citer, iter);
		set_tree_store_model_data(tree, citer, s);
		}
	}

static GtkTreeModel *
create_model(void)
	{
	GtkTreeStore	*tree;
	GtkTreeIter		iter, citer;

	tree = gtk_tree_store_new(N_COLUMNS,
				G_TYPE_STRING,
                G_TYPE_BOOLEAN,
                G_TYPE_STRING,
                G_TYPE_POINTER,
				G_TYPE_BOOLEAN,
				GDK_TYPE_PIXBUF
				);

	gtk_tree_store_append(tree, &iter, NULL);
	gtk_tree_store_set(tree, &iter,
				NAME_COLUMN, _("Temperatures"),
				VISIBLE_COLUMN, FALSE,
				-1);
	append_sensors_to_model(tree, &citer, &iter, SENSOR_TEMPERATURE);

	gtk_tree_store_append(tree, &iter, NULL);
	gtk_tree_store_set(tree, &iter,
				NAME_COLUMN, _("Fans"),
				VISIBLE_COLUMN, FALSE,
				-1);
	append_sensors_to_model(tree, &citer, &iter, SENSOR_FAN);

	gtk_tree_store_append(tree, &iter, NULL);
	gtk_tree_store_set(tree, &iter,
				NAME_COLUMN, _("Voltages"),
				VISIBLE_COLUMN, FALSE,
				-1);
	append_sensors_to_model(tree, &citer, &iter, SENSOR_VOLTAGE);
	return GTK_TREE_MODEL(tree);
	}

void
gkrellm_sensors_model_update(void)
	{
	GtkTreeModel	*model;

	if (!gkrellm_config_window_shown())
		return;
	model = sensor_model;
	sensor_model = create_model();
	gtk_tree_view_set_model(treeview, sensor_model);
	if (model)
		g_object_unref(G_OBJECT(model));
	}

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 Sensor *
get_referenced_sensor(void)
	{
	GtkTreeModel	*model;
	GtkTreePath		*path;
	GtkTreeIter		iter;
	Sensor			*s;

	if (!row_reference)
		return NULL;
	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,
			SENSOR_COLUMN, &s, -1);
	return s;