Bug Summary

File:rc/sensors.c
Location:line 370, column 3
Description:Value stored to 's' is never read

Annotated Source Code

1/* GKrellM
2| Copyright (C) 1999-2010 Bill Wilson
3|
4| Author: Bill Wilson billw@gkrellm.net
5| Latest versions might be found at: http://gkrellm.net
6|
7|
8| GKrellM is free software: you can redistribute it and/or modify it
9| under the terms of the GNU General Public License as published by
10| the Free Software Foundation, either version 3 of the License, or
11| (at your option) any later version.
12|
13| GKrellM is distributed in the hope that it will be useful, but WITHOUT
14| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15| or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
16| License for more details.
17|
18| You should have received a copy of the GNU General Public License
19| along with this program. If not, see http://www.gnu.org/licenses/
20|
21|
22| Additional permission under GNU GPL version 3 section 7
23|
24| If you modify this program, or any covered work, by linking or
25| combining it with the OpenSSL project's OpenSSL library (or a
26| modified version of that library), containing parts covered by
27| the terms of the OpenSSL or SSLeay licenses, you are granted
28| additional permission to convey the resulting work.
29| Corresponding Source for a non-source form of such a combination
30| shall include the source code for the parts of OpenSSL used as well
31| as that of the covered work.
32*/
33
34#include "gkrellm.h"
35#include "gkrellm-private.h"
36#include "gkrellm-sysdeps.h"
37
38/* Useful info:
39| http://mbm.livewiredev.com/
40| Look up boards here for sensor chip and temperature sensor type
41| so sensor[1,2,3] can be set correctly in sensors.conf.
42*/
43
44 /* On Linux, the sensor id_name includes the parent chip directory, so
45 | "lm78/temp" will be a id_name, and not just "temp". This is to
46 | allow unique identification in case of multiple "temp" files.
47 | ie, more than 1 chip directory, each with a "temp" file.
48 */
49
50typedef struct _sensor
51 {
52 gchar *name; /* cpuX, mb, Vx name mapped to this sensor */
53 gchar *name_locale; /* gdk_draw compat */
54 gchar *default_label; /* Only voltages have default labels */
55 gchar *path; /* Pathname to sensor data or device file */
56 gchar *id_name; /* Unique sensor identifier for config */
57 gint type;
58
59 gint id;
60 gint iodev;
61 gint inter;
62
63 gint enabled;
64 gint group;
65 gint location; /* default, Proc panel, or cpu panel */
66 gfloat factor, /* Scale sensor reading */
67 offset; /* Add to sensor reading */
68 gfloat default_factor,
69 default_offset;
70 gchar *vref_name;
71 struct _sensor
72 *vref; /* A neg volt may be function of a ref volt */
73
74 gboolean has_config;
75
76 gfloat value,
77 raw_value;
78 gboolean value_valid;
79
80 GkrellmAlert *alert;
81 void (*cb_alert)();
82 gpointer cb_alert_data;
83 gpointer smon;
84 }
85 Sensor;
86
87
88static GList *sensor_list = NULL((void*)0);
89
90static GList *temp_order_list, /* For ordering from the config. */
91 *fan_order_list,
92 *volt_order_list;
93
94static gboolean using_new_config,
95 need_disk_temperature_update;
96
97static gboolean (*get_temperature)(gchar *name, gint id,
98 gint iodev, gint inter, gfloat *t);
99static gboolean (*get_fan)(gchar *name, gint id,
100 gint iodev, gint inter, gfloat *f);
101static gboolean (*get_voltage)(gchar *name, gint id,
102 gint iodev, gint inter, gfloat *v);
103
104static void read_sensors_config(void);
105static gboolean (*config_migrate)(gchar *current_name, gchar *config_name,
106 gint current, gint config);
107
108static gint sensor_config_version;
109static gint sensor_current_sysdep_private;
110static gint sensor_config_sysdep_private;
111
112void
113gkrellm_sensors_client_divert(gboolean (*get_temp_func)(),
114 gboolean (*get_fan_func)(), gboolean (*get_volt_func)())
115 {
116 get_temperature = get_temp_func;
117 get_fan = get_fan_func;
118 get_voltage = get_volt_func;
119 }
120
121void
122gkrellm_sensors_config_migrate_connect(gboolean (*migrate_func)(),
123 gint sysdep_private)
124 {
125 config_migrate = migrate_func;
126 sensor_current_sysdep_private = sysdep_private;
127 }
128
129static gboolean
130setup_sensor_interface(void)
131 {
132 if (!get_temperature && !_GK.client_mode && gkrellm_sys_sensors_init())
133 {
134 get_temperature = gkrellm_sys_sensors_get_temperature;
135 get_fan = gkrellm_sys_sensors_get_fan;
136 get_voltage = gkrellm_sys_sensors_get_voltage;
137 }
138 return get_temperature ? TRUE(!(0)) : FALSE(0);
139 }
140
141void
142gkrellm_sensors_set_group(gpointer sr, gint group)
143 {
144 Sensor *sensor = (Sensor *) sr;
145
146 if (sensor)
147 sensor->group = group;
148 }
149
150gpointer
151gkrellm_sensors_add_sensor(gint type, gchar *sensor_path, gchar *id_name,
152 gint id, gint iodev, gint inter,
153 gfloat factor, gfloat offset, gchar *vref, gchar *default_label)
154 {
155 Sensor *sensor;
156 gchar *r;
157
158 if (!id_name || !*id_name || type < 0 || type > 2)
159 return NULL((void*)0);
160
161 sensor = g_new0(Sensor, 1)(Sensor *) (__extension__ ({ gsize __n = (gsize) (1); gsize __s
= sizeof (Sensor); gpointer __p; if (__s == 1) __p = g_malloc0
(__n); else if (__builtin_constant_p (__n) && (__s ==
0 || __n <= (9223372036854775807L *2UL+1UL) / __s)) __p =
g_malloc0 (__n * __s); else __p = g_malloc0_n (__n, __s); __p
; }))
;
162 sensor->id_name = g_strdup(id_name);
163
164 if (sensor_path)
165 sensor->path = g_strdup(sensor_path);
166 else
167 sensor->path = g_strdup(id_name);
168 if (!default_label)
169 {
170 r = strrchr(id_name, '/');
171 default_label = r ? r+1 : id_name;
172 }
173 gkrellm_locale_dup_string(&sensor->name, default_label,
174 &sensor->name_locale);
175 sensor->default_label = g_strdup(default_label);
176
177 sensor->default_factor = factor;
178 sensor->factor
179 = (sensor->default_factor != 0.0 ? sensor->default_factor : 1.0);
180 sensor->default_offset = sensor->offset = offset;
181 sensor->type = type;
182 sensor->id = id;
183 sensor->iodev = iodev;
184 sensor->inter = inter;
185 if (type == SENSOR_VOLTAGE2 && vref)
186 sensor->vref_name = g_strdup(vref);
187 sensor_list = g_list_append(sensor_list, sensor);
188 return (gpointer) sensor;
189 }
190
191/* ======================================================================== */
192static gboolean use_threads,
193 thread_data_valid,
194 units_fahrenheit,
195 show_units = TRUE(!(0));
196
197static gboolean thread_busy;
198
199static gpointer
200read_sensors_thread(void *data)
201 {
202 GList *list;
203 Sensor *sensor;
204
205 for (list = sensor_list; list; list = list->next)
206 {
207 sensor = (Sensor *) list->data;
208 if (!sensor->enabled)
209 continue;
210 if (sensor->type == SENSOR_TEMPERATURE0 && get_temperature)
211 (*get_temperature)(sensor->path, sensor->id,
212 sensor->iodev, sensor->inter, &sensor->raw_value);
213 if (sensor->type == SENSOR_FAN1 && get_fan)
214 (*get_fan)(sensor->path, sensor->id,
215 sensor->iodev, sensor->inter, &sensor->raw_value);
216 if (sensor->type == SENSOR_VOLTAGE2 && get_voltage)
217 (*get_voltage)(sensor->path, sensor->id,
218 sensor->iodev, sensor->inter, &sensor->raw_value);
219 }
220 thread_busy = FALSE(0);
221 return NULL((void*)0);
222 }
223
224static void
225run_sensors_thread(void)
226 {
227 if (thread_busy)
228 return;
229 thread_busy = TRUE(!(0));
230 g_thread_new("read_sensors", read_sensors_thread, NULL((void*)0));
231 }
232
233 /* Sort so that sensors are ordered: temp, fan, voltage.
234 */
235static gint
236strcmp_sensor_path(Sensor *s1, Sensor *s2)
237 {
238 if (s1->type == SENSOR_TEMPERATURE0 && s2->type != SENSOR_TEMPERATURE0)
239 return -1;
240 if (s1->type != SENSOR_TEMPERATURE0 && s2->type == SENSOR_TEMPERATURE0)
241 return 1;
242
243 if (s1->type == SENSOR_FAN1 && s2->type != SENSOR_FAN1)
244 return -1;
245 if (s1->type != SENSOR_FAN1 && s2->type == SENSOR_FAN1)
246 return 1;
247
248 return strcmp(s1->id_name, s2->id_name)__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(s1->id_name) && __builtin_constant_p (s2->id_name
) && (__s1_len = strlen (s1->id_name), __s2_len = strlen
(s2->id_name), (!((size_t)(const void *)((s1->id_name)
+ 1) - (size_t)(const void *)(s1->id_name) == 1) || __s1_len
>= 4) && (!((size_t)(const void *)((s2->id_name
) + 1) - (size_t)(const void *)(s2->id_name) == 1) || __s2_len
>= 4)) ? __builtin_strcmp (s1->id_name, s2->id_name
) : (__builtin_constant_p (s1->id_name) && ((size_t
)(const void *)((s1->id_name) + 1) - (size_t)(const void *
)(s1->id_name) == 1) && (__s1_len = strlen (s1->
id_name), __s1_len < 4) ? (__builtin_constant_p (s2->id_name
) && ((size_t)(const void *)((s2->id_name) + 1) - (
size_t)(const void *)(s2->id_name) == 1) ? __builtin_strcmp
(s1->id_name, s2->id_name) : (__extension__ ({ const unsigned
char *__s2 = (const unsigned char *) (const char *) (s2->
id_name); int __result = (((const unsigned char *) (const char
*) (s1->id_name))[0] - __s2[0]); if (__s1_len > 0 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (s1->id_name))[1] - __s2[1]); if (__s1_len > 1
&& __result == 0) { __result = (((const unsigned char
*) (const char *) (s1->id_name))[2] - __s2[2]); if (__s1_len
> 2 && __result == 0) __result = (((const unsigned
char *) (const char *) (s1->id_name))[3] - __s2[3]); } } __result
; }))) : (__builtin_constant_p (s2->id_name) && ((
size_t)(const void *)((s2->id_name) + 1) - (size_t)(const void
*)(s2->id_name) == 1) && (__s2_len = strlen (s2->
id_name), __s2_len < 4) ? (__builtin_constant_p (s1->id_name
) && ((size_t)(const void *)((s1->id_name) + 1) - (
size_t)(const void *)(s1->id_name) == 1) ? __builtin_strcmp
(s1->id_name, s2->id_name) : (- (__extension__ ({ const
unsigned char *__s2 = (const unsigned char *) (const char *)
(s1->id_name); int __result = (((const unsigned char *) (
const char *) (s2->id_name))[0] - __s2[0]); if (__s2_len >
0 && __result == 0) { __result = (((const unsigned char
*) (const char *) (s2->id_name))[1] - __s2[1]); if (__s2_len
> 1 && __result == 0) { __result = (((const unsigned
char *) (const char *) (s2->id_name))[2] - __s2[2]); if (
__s2_len > 2 && __result == 0) __result = (((const
unsigned char *) (const char *) (s2->id_name))[3] - __s2[
3]); } } __result; })))) : __builtin_strcmp (s1->id_name, s2
->id_name)))); })
;
249 }
250
251static void
252append_sensor_to_order_list(Sensor *sr)
253 {
254 if (sr->type == SENSOR_TEMPERATURE0)
255 temp_order_list = g_list_append(temp_order_list, sr);
256 else if (sr->type == SENSOR_FAN1)
257 fan_order_list = g_list_append(fan_order_list, sr);
258 else if (sr->type == SENSOR_VOLTAGE2)
259 volt_order_list = g_list_append(volt_order_list, sr);
260 }
261
262
263 /* This is called as sensors are read from the config and I will want to
264 | re-order the sensors_list to reflect the config order. Re-ordering is
265 | done by appending found sensors to type specific lists and later the
266 | sensors_list will be rebuilt from the ordered type lists. If the
267 | id_name is found in the sensor_list, assign the label to it.
268 */
269static Sensor *
270map_sensor_label(gchar *label, gchar *name)
271 {
272 GList *list;
273 Sensor *sr;
274
275 for (list = sensor_list; list; list = list->next)
276 {
277 sr = (Sensor *) list->data;
278 if ( !sr->has_config
279 && ( !strcmp(sr->id_name, name)__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(sr->id_name) && __builtin_constant_p (name) &&
(__s1_len = strlen (sr->id_name), __s2_len = strlen (name
), (!((size_t)(const void *)((sr->id_name) + 1) - (size_t)
(const void *)(sr->id_name) == 1) || __s1_len >= 4) &&
(!((size_t)(const void *)((name) + 1) - (size_t)(const void *
)(name) == 1) || __s2_len >= 4)) ? __builtin_strcmp (sr->
id_name, name) : (__builtin_constant_p (sr->id_name) &&
((size_t)(const void *)((sr->id_name) + 1) - (size_t)(const
void *)(sr->id_name) == 1) && (__s1_len = strlen (
sr->id_name), __s1_len < 4) ? (__builtin_constant_p (name
) && ((size_t)(const void *)((name) + 1) - (size_t)(const
void *)(name) == 1) ? __builtin_strcmp (sr->id_name, name
) : (__extension__ ({ const unsigned char *__s2 = (const unsigned
char *) (const char *) (name); int __result = (((const unsigned
char *) (const char *) (sr->id_name))[0] - __s2[0]); if (
__s1_len > 0 && __result == 0) { __result = (((const
unsigned char *) (const char *) (sr->id_name))[1] - __s2[
1]); if (__s1_len > 1 && __result == 0) { __result
= (((const unsigned char *) (const char *) (sr->id_name))
[2] - __s2[2]); if (__s1_len > 2 && __result == 0)
__result = (((const unsigned char *) (const char *) (sr->
id_name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p
(name) && ((size_t)(const void *)((name) + 1) - (size_t
)(const void *)(name) == 1) && (__s2_len = strlen (name
), __s2_len < 4) ? (__builtin_constant_p (sr->id_name) &&
((size_t)(const void *)((sr->id_name) + 1) - (size_t)(const
void *)(sr->id_name) == 1) ? __builtin_strcmp (sr->id_name
, name) : (- (__extension__ ({ const unsigned char *__s2 = (const
unsigned char *) (const char *) (sr->id_name); int __result
= (((const unsigned char *) (const char *) (name))[0] - __s2
[0]); if (__s2_len > 0 && __result == 0) { __result
= (((const unsigned char *) (const char *) (name))[1] - __s2
[1]); if (__s2_len > 1 && __result == 0) { __result
= (((const unsigned char *) (const char *) (name))[2] - __s2
[2]); if (__s2_len > 2 && __result == 0) __result =
(((const unsigned char *) (const char *) (name))[3] - __s2[3
]); } } __result; })))) : __builtin_strcmp (sr->id_name, name
)))); })
280 || ( config_migrate
281 && (*config_migrate)(sr->id_name, name,
282 sensor_current_sysdep_private,
283 sensor_config_sysdep_private)
284 )
285 )
286 )
287 {
288 gkrellm_locale_dup_string(&sr->name, label, &sr->name_locale);
289 append_sensor_to_order_list(sr);
290 sr->has_config = TRUE(!(0));
291 return sr;
292 }
293 }
294 return NULL((void*)0);
295 }
296
297gboolean
298gkrellm_sensors_available(void)
299 {
300 return (sensor_list || _GK.demo) ? TRUE(!(0)) : FALSE(0);
301 }
302
303 /* The cpu and proc monitors both need a couple of sensor decals
304 | created on their panels. The left one will only display fan speeds
305 | while the right one will display both fan and temps depending on modes.
306 */
307void
308gkrellm_sensors_create_decals(GkrellmPanel *p, gint style_id,
309 GkrellmDecal **dsensor, GkrellmDecal **dfan)
310 {
311 GkrellmStyle *style;
312 GkrellmMargin *m;
313 GkrellmTextstyle *ts;
314 GkrellmDecal *ds = NULL((void*)0),
315 *df = NULL((void*)0);
316 gint w, w_avail;
317
318 if (sensor_list || _GK.demo)
319 {
320 style = gkrellm_panel_style(style_id);
321 m = gkrellm_get_style_margins(style);
322 ts = gkrellm_panel_alt_textstyle(style_id);
323 w_avail = gkrellm_chart_width() - m->left - m->right;
324
325 df = gkrellm_create_decal_text(p, "8888", ts, style, -1, -1, 0);
326
327 /* Sensor decal (fan and/or temp) carves out space remaining to right.
328 | Try to get enough for .1 deg resolution, otherwise what is left.
329 */
330 w = gkrellm_gdk_string_width(ts->font, "188.8F") + ts->effect;
331 if (w > w_avail - df->w - 3)
332 w = gkrellm_gdk_string_width(ts->font, "88.8C") + ts->effect;
333
334 ds = gkrellm_create_decal_text(p, "8.C", ts, style, -1, -1, w);
335 ds->x = w_avail + m->left - w;
336 df->x = m->left;
337 }
338 *dsensor = ds;
339 *dfan = df;
340 }
341
342void
343gkrellm_sensor_draw_fan_decal(GkrellmPanel *p, GkrellmDecal *d, gfloat f)
344 {
345 gchar buf[8];
346 gint w;
347
348 if (!p || !d)
349 return;
350 snprintf(buf, sizeof(buf), "%.0f", f);
351 w = gkrellm_gdk_string_width(d->text_style.font, buf)
352 + d->text_style.effect;
353 d->x_off = d->w - w;
354 if (d->x_off < 0)
355 d->x_off = 0;
356 gkrellm_draw_decal_text(p, d, buf, 0);
357 }
358
359void
360gkrellm_sensor_draw_temperature_decal(GkrellmPanel *p, GkrellmDecal *d,
361 gfloat t, gchar units)
362 {
363 gchar *s, buf[8];
364 gint w;
365
366 if (!p || !d)
367 return;
368 snprintf(buf, sizeof(buf), "%.1f%c", t, units);
369 if ((s = strchr(buf, '.')(__extension__ (__builtin_constant_p ('.') && !__builtin_constant_p
(buf) && ('.') == '\0' ? (char *) __rawmemchr (buf, '.'
) : __builtin_strchr (buf, '.')))
) == NULL((void*)0))
370 s = strchr(buf, ',')(__extension__ (__builtin_constant_p (',') && !__builtin_constant_p
(buf) && (',') == '\0' ? (char *) __rawmemchr (buf, ','
) : __builtin_strchr (buf, ',')))
; /* Locale may use commas */
Value stored to 's' is never read
371 w = gkrellm_gdk_string_width(d->text_style.font, buf)
372 + d->text_style.effect;
373 if (w > d->w + 1)
374 {
375 snprintf(buf, sizeof(buf), "%.0f%c", t, units);
376 w = gkrellm_gdk_string_width(d->text_style.font, buf)
377 + d->text_style.effect;
378 }
379
380 d->x_off = d->w - w;
381 if (d->x_off < 0)
382 d->x_off = 0;
383 gkrellm_draw_decal_text(p, d, buf, 0 /* no longer used */);
384 }
385
386static Sensor *
387lookup_sensor_from_id_name(gchar *name)
388 {
389 GList *list;
390 Sensor *s;
391
392 if (!name)
393 return NULL((void*)0);
394 for (list = sensor_list; list; list = list->next)
395 {
396 s = (Sensor *) list->data;
397 if ( !strcmp(s->id_name, name)__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(s->id_name) && __builtin_constant_p (name) &&
(__s1_len = strlen (s->id_name), __s2_len = strlen (name)
, (!((size_t)(const void *)((s->id_name) + 1) - (size_t)(const
void *)(s->id_name) == 1) || __s1_len >= 4) &&
(!((size_t)(const void *)((name) + 1) - (size_t)(const void *
)(name) == 1) || __s2_len >= 4)) ? __builtin_strcmp (s->
id_name, name) : (__builtin_constant_p (s->id_name) &&
((size_t)(const void *)((s->id_name) + 1) - (size_t)(const
void *)(s->id_name) == 1) && (__s1_len = strlen (
s->id_name), __s1_len < 4) ? (__builtin_constant_p (name
) && ((size_t)(const void *)((name) + 1) - (size_t)(const
void *)(name) == 1) ? __builtin_strcmp (s->id_name, name)
: (__extension__ ({ const unsigned char *__s2 = (const unsigned
char *) (const char *) (name); int __result = (((const unsigned
char *) (const char *) (s->id_name))[0] - __s2[0]); if (__s1_len
> 0 && __result == 0) { __result = (((const unsigned
char *) (const char *) (s->id_name))[1] - __s2[1]); if (__s1_len
> 1 && __result == 0) { __result = (((const unsigned
char *) (const char *) (s->id_name))[2] - __s2[2]); if (__s1_len
> 2 && __result == 0) __result = (((const unsigned
char *) (const char *) (s->id_name))[3] - __s2[3]); } } __result
; }))) : (__builtin_constant_p (name) && ((size_t)(const
void *)((name) + 1) - (size_t)(const void *)(name) == 1) &&
(__s2_len = strlen (name), __s2_len < 4) ? (__builtin_constant_p
(s->id_name) && ((size_t)(const void *)((s->id_name
) + 1) - (size_t)(const void *)(s->id_name) == 1) ? __builtin_strcmp
(s->id_name, name) : (- (__extension__ ({ const unsigned char
*__s2 = (const unsigned char *) (const char *) (s->id_name
); int __result = (((const unsigned char *) (const char *) (name
))[0] - __s2[0]); if (__s2_len > 0 && __result == 0
) { __result = (((const unsigned char *) (const char *) (name
))[1] - __s2[1]); if (__s2_len > 1 && __result == 0
) { __result = (((const unsigned char *) (const char *) (name
))[2] - __s2[2]); if (__s2_len > 2 && __result == 0
) __result = (((const unsigned char *) (const char *) (name))
[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (s->
id_name, name)))); })
398 || ( config_migrate
399 && (*config_migrate)(s->id_name, name,
400 sensor_current_sysdep_private,
401 sensor_config_sysdep_private)
402 )
403 )
404 return s;
405 }
406 return NULL((void*)0);
407 }
408
409 /* Given a in0, in1, ... name as a reference to use for a sensor,
410 | find the sensor with that name for the same chip as sr.
411 */
412static Sensor *
413lookup_vref(Sensor *sr, gchar *name)
414 {
415 GList *list;
416 Sensor *sv;
417 gchar *s, buf[128];
418
419 snprintf(buf, 96, "%s", sr->id_name);
420 s = strrchr(buf, '/');
421 if (s)
422 ++s;
423 else
424 s = buf;
425 snprintf(s, 31, "%s", name);
426 for (list = sensor_list; list; list = list->next)
427 {
428 sv = (Sensor *) list->data;
429 if ( sv->type == SENSOR_VOLTAGE2
430 && !strcmp(sv->id_name, buf)__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(sv->id_name) && __builtin_constant_p (buf) &&
(__s1_len = strlen (sv->id_name), __s2_len = strlen (buf)
, (!((size_t)(const void *)((sv->id_name) + 1) - (size_t)(
const void *)(sv->id_name) == 1) || __s1_len >= 4) &&
(!((size_t)(const void *)((buf) + 1) - (size_t)(const void *
)(buf) == 1) || __s2_len >= 4)) ? __builtin_strcmp (sv->
id_name, buf) : (__builtin_constant_p (sv->id_name) &&
((size_t)(const void *)((sv->id_name) + 1) - (size_t)(const
void *)(sv->id_name) == 1) && (__s1_len = strlen (
sv->id_name), __s1_len < 4) ? (__builtin_constant_p (buf
) && ((size_t)(const void *)((buf) + 1) - (size_t)(const
void *)(buf) == 1) ? __builtin_strcmp (sv->id_name, buf) :
(__extension__ ({ const unsigned char *__s2 = (const unsigned
char *) (const char *) (buf); int __result = (((const unsigned
char *) (const char *) (sv->id_name))[0] - __s2[0]); if (
__s1_len > 0 && __result == 0) { __result = (((const
unsigned char *) (const char *) (sv->id_name))[1] - __s2[
1]); if (__s1_len > 1 && __result == 0) { __result
= (((const unsigned char *) (const char *) (sv->id_name))
[2] - __s2[2]); if (__s1_len > 2 && __result == 0)
__result = (((const unsigned char *) (const char *) (sv->
id_name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p
(buf) && ((size_t)(const void *)((buf) + 1) - (size_t
)(const void *)(buf) == 1) && (__s2_len = strlen (buf
), __s2_len < 4) ? (__builtin_constant_p (sv->id_name) &&
((size_t)(const void *)((sv->id_name) + 1) - (size_t)(const
void *)(sv->id_name) == 1) ? __builtin_strcmp (sv->id_name
, buf) : (- (__extension__ ({ const unsigned char *__s2 = (const
unsigned char *) (const char *) (sv->id_name); int __result
= (((const unsigned char *) (const char *) (buf))[0] - __s2[
0]); if (__s2_len > 0 && __result == 0) { __result
= (((const unsigned char *) (const char *) (buf))[1] - __s2[
1]); if (__s2_len > 1 && __result == 0) { __result
= (((const unsigned char *) (const char *) (buf))[2] - __s2[
2]); if (__s2_len > 2 && __result == 0) __result =
(((const unsigned char *) (const char *) (buf))[3] - __s2[3]
); } } __result; })))) : __builtin_strcmp (sv->id_name, buf
)))); })
431 )
432 return sv;
433 }
434 return NULL((void*)0);
435 }
436
437static void
438cb_command_process(GkrellmAlert *alert, gchar *src, gchar *buf, gint size,
439 Sensor *sensor)
440 {
441 gchar c, *s, *fmt;
442 gint len;
443
444 if (!buf || size < 1)
445 return;
446 --size;
447 *buf = '\0';
448 if (!src)
449 return;
450 for (s = src; *s != '\0' && size > 0; ++s)
451 {
452 len = 1;
453 if (*s == '$' && *(s + 1) != '\0')
454 {
455 if ((c = *(s + 1)) == 'H')
456 len = snprintf(buf, size, "%s", gkrellm_sys_get_host_name());
457 else if (c == 's')
458 {
459 if (sensor->type == SENSOR_FAN1)
460 fmt = "%.0f";
461 else if (sensor->type == SENSOR_TEMPERATURE0)
462 fmt = "%.1f";
463 else /* SENSOR_VOLTAGE */
464 fmt = "%.2f";
465 len = snprintf(buf, size, fmt, sensor->value);
466 }
467 else if (c == 'l' || c == 'L')
468 len = snprintf(buf, size, "%s", sensor->name_locale);
469 ++s;
470 }
471 else
472 *buf = *s;
473 size -= len;
474 buf += len;
475 }
476 *buf = '\0';
477 }
478
479GkrellmAlert *
480gkrellm_sensor_alert(gpointer sr)
481 {
482 if (!sr)
483 return NULL((void*)0);
484 return ((Sensor *) sr)->alert;
485 }
486
487void
488gkrellm_sensor_alert_connect(gpointer sr, void (*cb_func)(), gpointer data)
489 {
490 Sensor *sensor = (Sensor *) sr;
491
492 if (!sensor)
493 return;
494 sensor->cb_alert = cb_func;
495 sensor->cb_alert_data = data;
496 gkrellm_alert_trigger_connect(sensor->alert, cb_func, data);
497 gkrellm_alert_command_process_connect(sensor->alert,
498 cb_command_process, sensor);
499 gkrellm_reset_alert_soft(sensor->alert);
500 }
501
502static gboolean
503sensor_read_temperature(Sensor *sensor, gfloat *temp, gchar *units)
504 {
505 gfloat t = 0;
506 gint found_temp = FALSE(0);
507
508 if (sensor && get_temperature)
509 {
510 found_temp = thread_data_valid ? TRUE(!(0))
511 : (*get_temperature)(sensor->path, sensor->id,
512 sensor->iodev, sensor->inter, &sensor->raw_value);
513 sensor->value = sensor->raw_value * sensor->factor + sensor->offset;
514 if (units_fahrenheit)
515 sensor->value = 1.8 * sensor->value + 32.0;
516 t = sensor->value;
517 }
518 if (! found_temp && _GK.demo)
519 {
520 t = 90.0 + (gfloat)(rand() & 0xf);
521 found_temp = TRUE(!(0));
522 }
523 if (temp)
524 *temp = t;
525 if (units)
526 {
527 if (show_units)
528 *units = units_fahrenheit ? 'F':'C';
529 else
530 *units = '\0';
531 }
532 if (sensor)
533 gkrellm_debug(DEBUG_SENSORS0x80, "sensor_temp: %s %s t=%.2f\n",
534 sensor->name_locale, sensor->path, sensor->value);
535 if (found_temp && sensor)
536 gkrellm_check_alert(sensor->alert, sensor->value);
537 return found_temp;
538 }
539
540gboolean
541gkrellm_sensor_read_temperature(gpointer sr, gfloat *temp, gchar *units)
542 {
543 return sensor_read_temperature((Sensor *) sr, temp, units);
544 }
545
546
547static gboolean
548sensor_read_fan(Sensor *sensor, gfloat *fan)
549 {
550 gfloat f = 0;
551 gint found_fan = FALSE(0);
552
553 if (sensor && get_fan)
554 {
555 found_fan = thread_data_valid ? TRUE(!(0))
556 : (*get_fan)(sensor->path, sensor->id,
557 sensor->iodev, sensor->inter, &sensor->raw_value);
558 sensor->value = sensor->raw_value * sensor->factor;
559 f = sensor->value;
560 }
561 if (! found_fan && _GK.demo)
562 {
563 f = 4980 + (gfloat)(rand() & 0x3f);
564 found_fan = TRUE(!(0));
565 }
566 if (fan)
567 *fan = f;
568 if (sensor)
569 gkrellm_debug(DEBUG_SENSORS0x80, "sensor_fan: %s %s rpm=%.0f\n",
570 sensor->name_locale, sensor->path, sensor->value);
571 if (found_fan && sensor)
572 gkrellm_check_alert(sensor->alert, sensor->value);
573 return found_fan;
574 }
575
576gboolean
577gkrellm_sensor_read_fan(gpointer sr, gfloat *fan)
578 {
579 return sensor_read_fan((Sensor *) sr, fan);
580 }
581
582
583static gboolean
584sensor_read_voltage(Sensor *sensor, gfloat *voltage)
585 {
586 gfloat v = 0;
587 gfloat offset;
588 gboolean found_voltage = FALSE(0);
589
590 if (sensor && get_voltage)
591 {
592 found_voltage = thread_data_valid ? TRUE(!(0))
593 : (*get_voltage)(sensor->path, sensor->id,
594 sensor->iodev, sensor->inter, &sensor->raw_value);
595 offset = sensor->offset;
596 if (sensor->vref) /* A negative voltage is level shifted by vref */
597 offset *= sensor->vref->value;
598 sensor->value = sensor->raw_value * sensor->factor + offset;
599 v = sensor->value;
600 }
601 if (! found_voltage && _GK.demo)
602 {
603 v = 2.9 + (gfloat)(rand() & 0x7) * 0.1;
604 found_voltage = TRUE(!(0));
605 }
606 if (voltage)
607 *voltage = v;
608 if (sensor)
609 gkrellm_debug(DEBUG_SENSORS0x80, "sensor_voltage: %s %s v=%.2f\n",
610 sensor->name_locale, sensor->path, sensor->value);
611 if (found_voltage && sensor)
612 gkrellm_check_alert(sensor->alert, sensor->value);
613 return found_voltage;
614 }
615
616gboolean
617gkrellm_sensor_read_voltage(gpointer sr, gfloat *voltage)
618 {
619 return sensor_read_voltage((Sensor *) sr, voltage);
620 }
621
622/* =================================================================== */
623/* The sensors monitor */
624
625static void sensor_reset_optionmenu(Sensor *sensor);
626
627#define SENSOR_STYLE_NAME"sensors" "sensors"
628
629/* Temperature and fan sensors can be located on different panels depending
630| on the sensor group.
631*/
632#define SENSOR_PANEL_LOCATION0 0
633
634#define PROC_PANEL_LOCATION1 1 /* SENSOR_GROUP_MAINBOARD */
635#define CPU_PANEL_LOCATION2 2 /* cpu0 if smp */
636
637#define DISK_PANEL_LOCATION1 1 /* SENSOR_GROUP_DISK */
638
639
640#define DO_TEMP1 1
641#define DO_FAN1 1
642#define DO_VOLT1 1
643
644typedef struct
645 {
646 GkrellmPanel **panel;
647 GkrellmDecal *name_decal,
648 *sensor_decal;
649 Sensor *sensor;
650 }
651 SensorMon;
652
653static GtkWidget
654 *temp_vbox,
655 *fan_vbox,
656 *volt_vbox;
657
658static GList *volt_list,
659 *temperature_list,
660 *fan_list,
661 *disk_temperature_list;
662
663static GkrellmPanel
664 *pVolt,
665 *pTemp,
666 *pFan;
667
668static gint style_id;
669static gint volt_mon_width,
670 volt_mon_height,
671 volt_name_width,
672 volt_bezel_width;
673
674
675 /* Display modes */
676#define DIGITAL_WITH_LABELS0 0
677#define DIGITAL_NO_LABELS1 1
678#define N_DISPLAY_MODES2 2
679
680#define MONITOR_PAD6 6
681#define NAME_PAD4 4
682
683GkrellmMonitor *mon_sensors;
684GkrellmMonitor *mon_config_sensors;
685
686static GkrellmPiximage
687 *bezel_piximage;
688
689static GkrellmStyle
690 *bezel_style; /* Just for the bezel image border */
691
692static gint display_mode,
693 have_negative_volts;
694
695static gint minus_width; /* If will be drawing neg voltages */
696
697 /* If drawing '-' sign, grub a pixel or two to tighten the layout */
698static gint pixel_grub;
699
700
701 /* Avoid writing decimal values into the config to avoid possible
702 | locale changing decimal point breakage (decimal point can be '.' or ',')
703 */
704#define SENSOR_FLOAT_FACTOR10000.0 10000.0
705static gfloat sensor_float_factor = 1.0,
706 gkrellm_float_factor = 1.0;
707
708void
709gkrellm_sensor_reset_location(gpointer sr)
710 {
711 GList *list;
712 Sensor *sensor;
713
714 for (list = sensor_list; list; list = list->next)
715 {
716 sensor = (Sensor *) list->data;
717 if (sr == sensor)
718 {
719 sensor->location = SENSOR_PANEL_LOCATION0;
720 sensor_reset_optionmenu(sensor);
721 break;
722 }
723 }
724 }
725
726
727static void
728sensor_relocation_error(gchar *pname)
729 {
730 gchar *msg;
731
732 msg = g_strdup_printf(
733 _("Can't find a %s panel to relocate sensor to.")dcgettext ("gkrellm", "Can't find a %s panel to relocate sensor to."
, 5)
,
734 pname ? pname : "?");
735 gkrellm_config_message_dialog(NULL((void*)0), msg);
736 g_free(msg);
737 }
738
739 /* When moving off some other panel, reset that panel.
740 */
741static void
742sensor_reset_location(Sensor *sr)
743 {
744 if (sr->group == SENSOR_GROUP_MAINBOARD0)
745 {
746 if (sr->location == PROC_PANEL_LOCATION1)
747 gkrellm_proc_set_sensor(NULL((void*)0), sr->type);
748 else if (sr->location >= CPU_PANEL_LOCATION2)
749 gkrellm_cpu_set_sensor(NULL((void*)0), sr->type,
750 sr->location - CPU_PANEL_LOCATION2);
751 }
752 else if (sr->group == SENSOR_GROUP_DISK1)
753 {
754 if (sr->location == DISK_PANEL_LOCATION1)
755 gkrellm_disk_temperature_remove(sr->id_name);
756 }
757 }
758
759void
760gkrellm_sensors_interface_remove(gint _interface)
761 {
762 GList *list;
763 Sensor *sensor;
764 gboolean removed_one;
765
766 do
767 {
768 removed_one = FALSE(0);
769 for (list = sensor_list; list; list = list->next)
770 {
771 sensor = (Sensor *) list->data;
772 if (sensor->inter == _interface)
773 {
774 sensor_reset_location(sensor);
775 g_free(sensor->id_name);
776 g_free(sensor->path);
777 g_free(sensor->name);
778 g_free(sensor->default_label);
779 g_free(sensor->vref_name);
780 sensor_list = g_list_remove(sensor_list, sensor);
781 g_free(sensor);
782 removed_one = TRUE(!(0));
783 break;
784 }
785 }
786 }
787 while (removed_one);
788 }
789
790static void
791add_sensor_monitor(Sensor *sr, GkrellmPanel **p, GList **smon_list)
792 {
793 SensorMon *smon;
794 gfloat t;
795 gchar units;
796 gboolean set_loc = FALSE(0);
797
798 sr->smon = NULL((void*)0);
799 if (!sr->enabled)
800 return;
801
802 if (sr->location != SENSOR_PANEL_LOCATION0)
803 {
804 if (sr->group == SENSOR_GROUP_MAINBOARD0)
805 {
806 if (sr->location == PROC_PANEL_LOCATION1)
807 set_loc = gkrellm_proc_set_sensor(sr, sr->type);
808 else
809 set_loc = gkrellm_cpu_set_sensor(sr, sr->type,
810 sr->location - CPU_PANEL_LOCATION2);
811 }
812 else if (sr->group == SENSOR_GROUP_DISK1)
813 {
814 if (sr->location == DISK_PANEL_LOCATION1)
815 {
816 gkrellm_freeze_alert(sr->alert);
817 sensor_read_temperature(sr, &t, &units);
818 gkrellm_thaw_alert(sr->alert);
819 set_loc = gkrellm_disk_temperature_display((gpointer) sr,
820 sr->id_name, t, units);
821 if (set_loc)
822 disk_temperature_list =
823 g_list_append(disk_temperature_list, sr);
824 }
825 }
826 if (set_loc)
827 return;
828 sr->location = SENSOR_PANEL_LOCATION0;
829 }
830 smon = g_new0(SensorMon, 1)(SensorMon *) (__extension__ ({ gsize __n = (gsize) (1); gsize
__s = sizeof (SensorMon); gpointer __p; if (__s == 1) __p = g_malloc0
(__n); else if (__builtin_constant_p (__n) && (__s ==
0 || __n <= (9223372036854775807L *2UL+1UL) / __s)) __p =
g_malloc0 (__n * __s); else __p = g_malloc0_n (__n, __s); __p
; }))
;
831 smon->sensor = sr;
832 smon->panel = p; /* Alerts need a GkrellmPanel ** */
833 *smon_list = g_list_append(*smon_list, smon);
834 sr->smon = (gpointer) smon;
835 }
836
837static void
838make_sensor_monitor_lists(gboolean do_temp, gboolean do_fan, gboolean do_volt)
839 {
840 GList *list;
841 Sensor *sr;
842
843 if (do_temp)
844 {
845 gkrellm_free_glist_and_data(&temperature_list);
846 g_list_free(disk_temperature_list);
847 disk_temperature_list = NULL((void*)0);
848 }
849 if (do_fan)
850 gkrellm_free_glist_and_data(&fan_list);
851 if (do_volt)
852 gkrellm_free_glist_and_data(&volt_list);
853
854 for (list = sensor_list; list; list = list->next)
855 {
856 sr = (Sensor *) list->data;
857 if (do_temp && sr->type == SENSOR_TEMPERATURE0)
858 add_sensor_monitor(sr, &pTemp, &temperature_list);
859 if (do_fan && sr->type == SENSOR_FAN1)
860 add_sensor_monitor(sr, &pFan, &fan_list);
861 if (do_volt && sr->type == SENSOR_VOLTAGE2)
862 {
863 if (!sr->has_config && sr->vref_name)
864 sr->vref = lookup_vref(sr, sr->vref_name);
865 add_sensor_monitor(sr, &pVolt, &volt_list);
866 }
867 }
868 }
869
870#include "pixmaps/sensors/bg_volt.xpm"
871
872static void
873cb_alert_trigger(GkrellmAlert *alert, SensorMon *smon)
874 {
875 GkrellmAlertdecal *ad;
876 GkrellmDecal *d;
877
878 ad = &alert->ad;
879 alert->panel = *smon->panel;
880
881 /* Make the GkrellmAlertdecal show up under the sensor decal
882 */
883 d = smon->sensor_decal;
884 if (d)
885 {
886 ad->x = d->x - 2;
887 ad->y = d->y - 2;
888 ad->w = d->w + 3;
889 ad->h = d->h + 4;
890 gkrellm_render_default_alert_decal(alert);
891 }
892 }
893
894
895static void
896draw_bezels(GkrellmPanel *p, GList *smon_list, gint w, gint h, gint x_adjust)
897 {
898 GList *list;
899 GkrellmBorder *b = &bezel_style->border;
900 SensorMon *smon;
901 GkrellmDecal *dv;
902 gint x;
903
904 if (!bezel_piximage)
905 return;
906 for (list = smon_list; list; list = list->next)
907 {
908 smon = (SensorMon *) list->data;
909 dv = smon->sensor_decal;
910 x = dv->x + x_adjust;
911 if (w == 0)
912 w = b->left + dv->w + b->right - x_adjust;
913 if (h == 0)
914 h = b->top + b->bottom + dv->h;
915 gkrellm_paste_piximage(bezel_piximage, p->bg_pixmap,
916 x - b->left, dv->y - b->top, w, h);
917 gkrellm_paste_piximage(bezel_piximage, p->pixmap,
918 x - b->left, dv->y - b->top, w, h);
919 }
920 gdk_draw_drawable(p->bg_text_layer_pixmap, _GK.draw1_GC, p->bg_pixmap,
921 0, 0, 0, 0, p->w, p->h);
922 }
923
924
925static gboolean
926any_negative_volts(void)
927 {
928 GList *list;
929 Sensor *s;
930 SensorMon *volt;
931 gfloat v;
932 gboolean tmp, result = FALSE(0);
933
934 /* This routine can be called before any volt decals exist, but reading
935 | voltages can trigger alerts which expect to find decals. Hence freeze.
936 */
937 tmp = thread_data_valid;
938 thread_data_valid = FALSE(0); /* Need results immediately */
939 for (list = volt_list; list; list = list->next)
940 {
941 volt = (SensorMon *) list->data;
942 gkrellm_freeze_alert(volt->sensor->alert);
943 s = volt->sensor->vref;
944 if (s && s->value == 0)
945 sensor_read_voltage(s, &v);
946 sensor_read_voltage(volt->sensor, &v);
947 gkrellm_thaw_alert(volt->sensor->alert);
948 if (v < 0.0)
949 {
950 result = TRUE(!(0));
951 break;
952 }
953 }
954 thread_data_valid = tmp;
955 return result;
956 }
957
958static void
959make_volt_decals(GkrellmPanel *p, GkrellmStyle *style)
960 {
961 GList *list;
962 GkrellmBorder *b = &bezel_style->border;
963 Sensor *sensor;
964 SensorMon *volt;
965 GkrellmDecal *dv, *dn;
966 GkrellmTextstyle *ts_volt, *ts_name;
967 gchar *fmt;
968 gint w_volt;
969
970 ts_name = gkrellm_meter_alt_textstyle(style_id);
971 ts_volt = gkrellm_meter_textstyle(style_id);
972
973 volt_mon_width = 0;
974 volt_mon_height = 0;
975 volt_name_width = 0;
976 w_volt = 0;
977
978 minus_width = 0;
979 have_negative_volts = FALSE(0);
980 fmt = "8.88";
981 if (any_negative_volts())
982 {
983 have_negative_volts = TRUE(!(0));
984 minus_width = 1;
985 fmt = "-8.88";
986 }
987
988 for (list = volt_list; list; list = list->next)
989 {
990 volt = (SensorMon *) list->data;
991 sensor = volt->sensor;
992 if (display_mode == DIGITAL_WITH_LABELS0)
993 {
994 volt->name_decal = dn = gkrellm_create_decal_text(p,
995 volt->sensor->name_locale, ts_name, style, 0, 0, 0);
996 if (dn->w > volt_name_width)
997 volt_name_width = dn->w;
998 }
999 dv = gkrellm_create_decal_text(p, fmt, ts_volt, style, 0, 0, 0);
1000 volt->sensor_decal = dv;
1001 if (minus_width == 1)
1002 minus_width = gkrellm_gdk_string_width(dv->text_style.font, "-");
1003 w_volt = dv->w; /* Same for all volt decals */
1004 if (dv->h > volt_mon_height)
1005 volt_mon_height = dv->h;
1006
1007 sensor->cb_alert = cb_alert_trigger;
1008 sensor->cb_alert_data = volt;
1009 gkrellm_alert_trigger_connect(sensor->alert, cb_alert_trigger, volt);
1010 gkrellm_alert_command_process_connect(sensor->alert,
1011 cb_command_process, sensor);
1012 gkrellm_reset_alert_soft(sensor->alert);
1013 }
1014 pixel_grub = minus_width ? 1 : 0;
1015 volt_bezel_width = b->left + w_volt + b->right - pixel_grub;
1016 volt_mon_height += b->top + b->bottom;
1017
1018 /* If name decal I let bezel left border encroach into NAME_PAD space
1019 */
1020 if (volt_name_width)
1021 volt_mon_width = volt_name_width + NAME_PAD4 + w_volt + b->right;
1022 else
1023 volt_mon_width = w_volt; /* borders encroach into MONITOR_PAD */
1024 }
1025
1026static void
1027layout_volt_decals(GkrellmPanel *p, GkrellmStyle *style)
1028 {
1029 GList *list;
1030 SensorMon *volt;
1031 GkrellmDecal *dv, *dn;
1032 GkrellmMargin *m;
1033 gint x, y, w, c, n, cols;
1034
1035 m = gkrellm_get_style_margins(style);
1036 w = gkrellm_chart_width() - m->left - m->right;
1037 cols = (w + MONITOR_PAD6) / (volt_mon_width + MONITOR_PAD6);
1038 if (cols < 1)
1039 cols = 1;
1040 n = g_list_length(volt_list);
1041 if (cols > n)
1042 cols = n;;
1043 volt_mon_width = w / cols; /* spread them out */
1044 x = (w - cols * volt_mon_width) / 2 + m->left;
1045
1046 gkrellm_get_top_bottom_margins(style, &y, NULL((void*)0));
1047 c = 0;
1048 for (list = volt_list; list; list = list->next)
1049 {
1050 volt = (SensorMon *) list->data;
1051 dn = volt->name_decal;
1052 dv = volt->sensor_decal;
1053 /* Right justify the volt decal in each volt_mon field
1054 */
1055 dv->x = x + (c+1) * volt_mon_width - dv->w - bezel_style->border.right;
1056 if (cols > 1 && !dn)
1057 dv->x -= (volt_mon_width - volt_bezel_width) / 2;
1058 dv->y = y + bezel_style->border.top;
1059 if (dn)
1060 {
1061 if (cols == 1)
1062 dn->x = m->left;
1063 else
1064 dn->x = dv->x - volt_name_width - NAME_PAD4;
1065 dn->y = y + bezel_style->border.top;
1066 if (dn->h < dv->h)
1067 dn->y += (dv->h - dn->h + 1) / 2;
1068 }
1069 if (++c >= cols)
1070 {
1071 c = 0;
1072 y += volt_mon_height;
1073 }
1074 }
1075 }
1076
1077static void
1078update_disk_temperatures(void)
1079 {
1080 GList *list;
1081 Sensor *sr;
1082 gfloat t;
1083 gchar units;
1084 gboolean display_failed = FALSE(0);
1085
1086 for (list = disk_temperature_list; list; list = list->next)
1087 {
1088 sr = (Sensor *) list->data;
1089 sensor_read_temperature(sr, &t, &units);
1090 if (!gkrellm_disk_temperature_display((gpointer) sr, sr->id_name,
1091 t, units))
1092 {
1093 /* disk panel was disabled, so put temp back on sensors panel
1094 */
1095 display_failed = TRUE(!(0));
1096 sr->location = SENSOR_PANEL_LOCATION0;
1097 sensor_reset_optionmenu(sr);
1098 }
1099 }
1100 if (display_failed)
1101 gkrellm_sensors_rebuild(TRUE(!(0)), FALSE(0), FALSE(0));
1102 }
1103
1104 /* Squeeze name decal text into a smaller font if it would overlap the
1105 | sensor decal. With smaller fonts, the y_ink value may be smaller which
1106 | would bump the text upward. So adjust decal offset by difference in
1107 | y_ink value. (GKrellM text decal heights don't include the y_ink
1108 | space).
1109 */
1110static gchar *
1111name_text_fit(Sensor *s, GkrellmDecal *dn, GkrellmDecal *ds)
1112 {
1113 gchar *string;
1114 gint x_limit, w0, w1, y_ink0, y_ink1, h0, h1;
1115
1116 x_limit = ds->x;
1117
1118 /* Check for '<' in case user is doing his own markup
1119 */
1120 if (*(s->name_locale) != '<' && dn->x + dn->w > x_limit)
1121 {
1122 gkrellm_text_markup_extents(dn->text_style.font, s->name_locale,
1123 strlen(s->name_locale), &w0, NULL((void*)0), NULL((void*)0), &y_ink0);
1124 string = g_strdup_printf("<small>%s</small>", s->name_locale);
1125 gkrellm_text_markup_extents(dn->text_style.font, string,
1126 strlen(string), &w1, &h0, NULL((void*)0), &y_ink1);
1127 h1 = h0;
1128 if (dn->x + w1 > x_limit)
1129 {
1130 g_free(string);
1131 string = g_strdup_printf("<small><small>%s</small></small>",
1132 s->name_locale);
1133 gkrellm_text_markup_extents(dn->text_style.font, string,
1134 strlen(string), &w1, &h1, NULL((void*)0), &y_ink1);
1135 }
1136 gkrellm_decal_text_set_offset(dn, 0,
1137 y_ink0 - y_ink1 + (h0 - h1 + 1) / 2);
1138 }
1139 else
1140 {
1141 gkrellm_decal_text_set_offset(dn, 0, 0);
1142 string = g_strdup(s->name_locale);
1143 }
1144 return string;
1145 }
1146
1147
1148static void
1149draw_temperatures(gboolean draw_name)
1150 {
1151 GList *list;
1152 SensorMon *smon;
1153 Sensor *sensor;
1154 gfloat t;
1155 gchar *name, units;
1156
1157 if (!pTemp)
1158 return;
1159 for (list = temperature_list; list; list = list->next)
1160 {
1161 smon = (SensorMon *) list->data;
1162 sensor = smon->sensor;
1163
1164 if (draw_name && smon->name_decal)
1165 {
1166 name = name_text_fit(sensor, smon->name_decal, smon->sensor_decal);
1167 gkrellm_draw_decal_markup(pTemp, smon->name_decal, name);
1168 g_free(name);
1169 }
1170 if (smon->sensor_decal)
1171 {
1172 sensor_read_temperature(sensor, &t, &units);
1173 gkrellm_sensor_draw_temperature_decal(pTemp, smon->sensor_decal,
1174 t, units);
1175 }
1176 }
1177 gkrellm_draw_panel_layers(pTemp);
1178 }
1179
1180static void
1181draw_fans(gboolean draw_name)
1182 {
1183 GList *list;
1184 SensorMon *smon;
1185 Sensor *sensor;
1186 gchar *name;
1187 gfloat f;
1188
1189 if (!pFan)
1190 return;
1191 for (list = fan_list; list; list = list->next)
1192 {
1193 smon = (SensorMon *) list->data;
1194 sensor = smon->sensor;
1195
1196 if (draw_name && smon->name_decal)
1197 {
1198 name = name_text_fit(sensor, smon->name_decal, smon->sensor_decal);
1199 gkrellm_draw_decal_markup(pFan, smon->name_decal, name);
1200 g_free(name);
1201 }
1202 if (smon->sensor_decal)
1203 {
1204 sensor_read_fan(sensor, &f);
1205 gkrellm_sensor_draw_fan_decal(pFan, smon->sensor_decal, f);
1206 }
1207 }
1208 gkrellm_draw_panel_layers(pFan);
1209 }
1210
1211 /* If s is NULL, draw 'em all
1212 */
1213static void
1214draw_voltages(Sensor *s, gint do_names)
1215 {
1216 GList *list;
1217 SensorMon *volt;
1218 Sensor *sensor;
1219 GkrellmDecal *ds, *dn;
1220 gchar *name, *fmt, buf[32];
1221 gfloat v;
1222
1223 if (!pVolt)
1224 return;
1225 for (list = volt_list; list; list = list->next)
1226 {
1227 volt = (SensorMon *) list->data;
1228 sensor = volt->sensor;
1229 if (s && s != sensor)
1230 continue;
1231 sensor->value_valid = FALSE(0); /* In case vref monitoring stops */
1232 dn = volt->name_decal;
1233 ds = volt->sensor_decal;
1234 if (do_names && dn)
1235 {
1236 name = name_text_fit(sensor, dn, ds);
1237 gkrellm_draw_decal_markup(pVolt, dn, name);
1238 g_free(name);
1239 }
1240 if (ds)
1241 {
1242 if (sensor->vref && !sensor->vref->value_valid)
1243 sensor_read_voltage(sensor->vref, NULL((void*)0));
1244 sensor_read_voltage(sensor, &v);
1245 sensor->value_valid = TRUE(!(0));
1246 if ((v < 10.0 && v > 0.0) || (v > -10.0 && v < 0.0))
1247 fmt = "%.2f";
1248 else
1249 fmt = "%.1f";
1250 snprintf(buf, sizeof(buf), fmt, v);
1251 ds->x_off = (v < 0.0) ? 0 : minus_width;
1252 gkrellm_draw_decal_text(pVolt, ds, buf, -1);
1253 }
1254 }
1255 gkrellm_draw_panel_layers(pVolt);
1256 }
1257
1258static void
1259update_sensors(void)
1260 {
1261 static gboolean first_time_done;
1262
1263 if (!GK.five_second_tick && first_time_done)
1264 {
1265 if (need_disk_temperature_update) /* delayed until disks created */
1266 update_disk_temperatures();
1267 need_disk_temperature_update = FALSE(0);
1268 return;
1269 }
1270 if (use_threads)
1271 {
1272 thread_data_valid = TRUE(!(0));
1273 run_sensors_thread();
1274 }
1275 draw_temperatures(FALSE(0));
1276 draw_fans(FALSE(0));
1277 draw_voltages(NULL((void*)0), FALSE(0));
1278 update_disk_temperatures();
1279 first_time_done = TRUE(!(0));
1280 }
1281
1282static gint
1283expose_event(GtkWidget *widget, GdkEventExpose *ev, GkrellmPanel *p)
1284 {
1285 gdk_draw_drawable(widget->window, gkrellm_draw_GC(1), p->pixmap,
1286 ev->area.x, ev->area.y, ev->area.x, ev->area.y,
1287 ev->area.width, ev->area.height);
1288 return FALSE(0);
1289 }
1290
1291static gint
1292cb_panel_press(GtkWidget *widget, GdkEventButton *ev, GkrellmPanel *p)
1293 {
1294 if (ev->button == 3)
1295 gkrellm_open_config_window(mon_config_sensors);
1296 return FALSE(0);
1297 }
1298
1299static GkrellmBorder default_bezel_border = {1,1,1,1};
1300
1301static void
1302assign_textstyles(GList *smon_list, GkrellmTextstyle **ts_name, GkrellmTextstyle **ts_sensor,
1303 gchar *format)
1304 {
1305 GList *list;
1306 GkrellmStyle *style;
1307 GkrellmMargin *margin;
1308 Sensor *sensor;
1309 SensorMon *smon;
1310 GkrellmTextstyle *ts, *ts_alt;
1311 gint w, w_name, w_sensor;
1312
1313 style = gkrellm_meter_style(style_id);
1314 margin = gkrellm_get_style_margins(style);
1315 ts = gkrellm_copy_textstyle(gkrellm_meter_textstyle(style_id));
1316 ts_alt = gkrellm_copy_textstyle(gkrellm_meter_alt_textstyle(style_id));
1317 w = gkrellm_chart_width() - margin->left - margin->right;
1318 w_sensor = gkrellm_gdk_string_width(ts->font, format);
1319 w_sensor += bezel_style->border.left + bezel_style->border.right;
1320 for (list = smon_list; list; list = list->next)
1321 {
1322 smon = (SensorMon *)list->data;
1323 sensor = smon->sensor;
1324 w_name = gkrellm_gdk_string_width(ts_alt->font, sensor->name_locale);
1325 if (w_name + w_sensor > w - 2)
1326 {
1327 ts->font = ts_alt->font; /* downsize the sensor font */
1328 break;
1329 }
1330 }
1331 *ts_name = ts_alt; /* Caller must free these */
1332 *ts_sensor = ts;
1333 }
1334
1335static gint
1336adjust_decal_positions(SensorMon *smon)
1337 {
1338 gint y, d, h_pad;
1339
1340 h_pad = bezel_style->border.top + bezel_style->border.bottom;
1341 d = smon->sensor_decal->h - smon->name_decal->h;
1342 y = smon->sensor_decal->y + smon->sensor_decal->h + h_pad;
1343 if (d >= 0)
1344 smon->name_decal->y += (d + 1) / 2;
1345 else
1346 {
1347 if (h_pad < -d)
1348 y = smon->name_decal->y + smon->name_decal->h;
1349 smon->sensor_decal->y += -d / 2;
1350 }
1351 return y;
1352 }
1353
1354static void
1355make_temperature_panel(GtkWidget *vbox, gint first_create)
1356 {
1357 Sensor *sensor;
1358 SensorMon *smon = NULL((void*)0);
1359 GkrellmStyle *style;
1360 GkrellmMargin *m;
1361 GkrellmDecal *d;
1362 GList *list;
1363 GkrellmTextstyle *ts_sensor, *ts_name;
1364 gchar *format;
1365 gint y;
1366
1367 if (!pTemp)
1368 return;
1369 style = gkrellm_meter_style(style_id);
1370 m = gkrellm_get_style_margins(style);
1371 if (show_units)
1372 format = units_fahrenheit ? "188.8F" : "88.8C";
1373 else
1374 format = units_fahrenheit ? "188.8" : "88.8";
1375 assign_textstyles(temperature_list, &ts_name, &ts_sensor, format);
1376 gkrellm_get_top_bottom_margins(style, &y, NULL((void*)0));
1377 y += bezel_style->border.top;
1378 for (list = temperature_list; list; list = list->next)
1379 {
1380 smon = (SensorMon *) list->data;
1381 sensor = smon->sensor;
1382 d = gkrellm_create_decal_text(pTemp, format,
1383 ts_sensor, style, -1, y, 0);
1384 d->x = gkrellm_chart_width() - d->w - m->right - 1;
1385 smon->sensor_decal = d;
1386
1387 smon->name_decal = gkrellm_create_decal_text(pTemp,
1388 sensor->name_locale, ts_name, style, -1, y, 0);
1389 y = adjust_decal_positions(smon);
1390 sensor->cb_alert = cb_alert_trigger;
1391 sensor->cb_alert_data = smon;
1392 gkrellm_alert_trigger_connect(sensor->alert, cb_alert_trigger, smon);
1393 gkrellm_alert_command_process_connect(sensor->alert,
1394 cb_command_process, sensor);
1395 gkrellm_reset_alert_soft(sensor->alert);
1396 }
1397 g_free(ts_name);
1398 g_free(ts_sensor);
1399 gkrellm_panel_configure(pTemp, NULL((void*)0), style);
1400 if (smon && smon->sensor_decal->y + smon->sensor_decal->h >
1401 smon->name_decal->y + smon->name_decal->h - bezel_style->border.bottom
1402 )
1403 gkrellm_panel_configure_add_height(pTemp, bezel_style->border.bottom);
1404 gkrellm_panel_create(vbox, mon_sensors, pTemp);
1405 draw_bezels(pTemp, temperature_list, 0, 0, 1);
1406 if (first_create)
1407 {
1408 g_signal_connect(G_OBJECT(pTemp->drawing_area), "expose_event",g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((pTemp->drawing_area)), (((GType) ((20
) << (2))))))))), ("expose_event"), (((GCallback) (expose_event
))), (pTemp), ((void*)0), (GConnectFlags) 0)
1409 G_CALLBACK(expose_event), pTemp)g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((pTemp->drawing_area)), (((GType) ((20
) << (2))))))))), ("expose_event"), (((GCallback) (expose_event
))), (pTemp), ((void*)0), (GConnectFlags) 0)
;
1410 g_signal_connect(G_OBJECT(pTemp->drawing_area), "button_press_event",g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((pTemp->drawing_area)), (((GType) ((20
) << (2))))))))), ("button_press_event"), (((GCallback)
(cb_panel_press))), (pTemp), ((void*)0), (GConnectFlags) 0)
1411 G_CALLBACK(cb_panel_press), pTemp)g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((pTemp->drawing_area)), (((GType) ((20
) << (2))))))))), ("button_press_event"), (((GCallback)
(cb_panel_press))), (pTemp), ((void*)0), (GConnectFlags) 0)
;
1412 }
1413 draw_temperatures(TRUE(!(0)));
1414 }
1415
1416static void
1417make_fan_panel(GtkWidget *vbox, gint first_create)
1418 {
1419 Sensor *sensor;
1420 SensorMon *smon = NULL((void*)0);
1421 GkrellmStyle *style;
1422 GkrellmMargin *m;
1423 GkrellmDecal *d;
1424 GList *list;
1425 GkrellmTextstyle *ts_sensor, *ts_name;
1426 gchar *format;
1427 gint y;
1428
1429 if (!pFan)
1430 return;
1431 style = gkrellm_meter_style(style_id);
1432 m = gkrellm_get_style_margins(style);
1433 format = "8888";
1434 assign_textstyles(temperature_list, &ts_name, &ts_sensor, format);
1435 gkrellm_get_top_bottom_margins(style, &y, NULL((void*)0));
1436 y += bezel_style->border.top;
1437 for (list = fan_list; list; list = list->next)
1438 {
1439 smon = (SensorMon *) list->data;
1440 sensor = smon->sensor;
1441 d = gkrellm_create_decal_text(pFan, format,
1442 ts_sensor, style, -1, y, 0);
1443 d->x = gkrellm_chart_width() - d->w - m->right - 1;
1444 smon->sensor_decal = d;
1445
1446 smon->name_decal = gkrellm_create_decal_text(pFan, sensor->name_locale,
1447 ts_name, style, -1, y, 0);
1448 y = adjust_decal_positions(smon);
1449 sensor->cb_alert = cb_alert_trigger;
1450 sensor->cb_alert_data = smon;
1451 gkrellm_alert_trigger_connect(sensor->alert, cb_alert_trigger, smon);
1452 gkrellm_alert_command_process_connect(sensor->alert,
1453 cb_command_process, sensor);
1454 gkrellm_reset_alert_soft(sensor->alert);
1455 }
1456 g_free(ts_name);
1457 g_free(ts_sensor);
1458 gkrellm_panel_configure(pFan, NULL((void*)0), style);
1459 if (smon && smon->sensor_decal->y + smon->sensor_decal->h >
1460 smon->name_decal->y + smon->name_decal->h - bezel_style->border.bottom
1461 )
1462 gkrellm_panel_configure_add_height(pFan, bezel_style->border.bottom);
1463 gkrellm_panel_create(vbox, mon_sensors, pFan);
1464 draw_bezels(pFan, fan_list, 0, 0, 0);
1465 if (first_create)
1466 {
1467 g_signal_connect(G_OBJECT(pFan->drawing_area), "expose_event",g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((pFan->drawing_area)), (((GType) ((20)
<< (2))))))))), ("expose_event"), (((GCallback) (expose_event
))), (pFan), ((void*)0), (GConnectFlags) 0)
1468 G_CALLBACK(expose_event), pFan)g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((pFan->drawing_area)), (((GType) ((20)
<< (2))))))))), ("expose_event"), (((GCallback) (expose_event
))), (pFan), ((void*)0), (GConnectFlags) 0)
;
1469 g_signal_connect(G_OBJECT(pFan->drawing_area), "button_press_event",g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((pFan->drawing_area)), (((GType) ((20)
<< (2))))))))), ("button_press_event"), (((GCallback) (
cb_panel_press))), (pFan), ((void*)0), (GConnectFlags) 0)
1470 G_CALLBACK(cb_panel_press), pFan)g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((pFan->drawing_area)), (((GType) ((20)
<< (2))))))))), ("button_press_event"), (((GCallback) (
cb_panel_press))), (pFan), ((void*)0), (GConnectFlags) 0)
;
1471 }
1472 draw_fans(TRUE(!(0)));
1473 }
1474
1475static void
1476make_volt_panel(GtkWidget *vbox, gint first_create)
1477 {
1478 GkrellmStyle *style;
1479
1480 if (!pVolt)
1481 return;
1482 style = gkrellm_meter_style(style_id);
1483 make_volt_decals(pVolt, style);
1484 layout_volt_decals(pVolt, style);
1485
1486 gkrellm_panel_configure(pVolt, NULL((void*)0), style);
1487
1488 /* Make the bottom margin reference against the bottom volt decals
1489 | bezel image. The volt decal height does not include the bezel so
1490 | gkrellm_panel_configure() did not account for the bezel.
1491 */
1492 gkrellm_panel_configure_add_height(pVolt, bezel_style->border.bottom);
1493 gkrellm_panel_create(vbox, mon_sensors, pVolt);
1494
1495 draw_bezels(pVolt, volt_list,
1496 volt_bezel_width, volt_mon_height, pixel_grub);
1497
1498 if (first_create)
1499 {
1500 g_signal_connect(G_OBJECT(pVolt->drawing_area), "expose_event",g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((pVolt->drawing_area)), (((GType) ((20
) << (2))))))))), ("expose_event"), (((GCallback) (expose_event
))), (pVolt), ((void*)0), (GConnectFlags) 0)
1501 G_CALLBACK(expose_event), pVolt)g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((pVolt->drawing_area)), (((GType) ((20
) << (2))))))))), ("expose_event"), (((GCallback) (expose_event
))), (pVolt), ((void*)0), (GConnectFlags) 0)
;
1502 g_signal_connect(G_OBJECT(pVolt->drawing_area), "button_press_event",g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((pVolt->drawing_area)), (((GType) ((20
) << (2))))))))), ("button_press_event"), (((GCallback)
(cb_panel_press))), (pVolt), ((void*)0), (GConnectFlags) 0)
1503 G_CALLBACK(cb_panel_press), pVolt)g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((pVolt->drawing_area)), (((GType) ((20
) << (2))))))))), ("button_press_event"), (((GCallback)
(cb_panel_press))), (pVolt), ((void*)0), (GConnectFlags) 0)
;
1504 }
1505 draw_voltages(NULL((void*)0), TRUE(!(0)));
1506 }
1507
1508
1509static void
1510destroy_sensors_monitor(gboolean do_temp, gboolean do_fan, gboolean do_volt)
1511 {
1512 if (do_temp)
1513 {
1514 gkrellm_panel_destroy(pTemp);
1515 pTemp = NULL((void*)0);
1516 }
1517 if (do_fan)
1518 {
1519 gkrellm_panel_destroy(pFan);
1520 pFan = NULL((void*)0);
1521 }
1522 if (do_volt)
1523 {
1524 gkrellm_panel_destroy(pVolt);
1525 pVolt = NULL((void*)0);
1526 }
1527 }
1528
1529static void
1530create_sensors_monitor(gboolean do_temp, gboolean do_fan, gboolean do_volt,
1531 gboolean first_create)
1532 {
1533 make_sensor_monitor_lists(do_temp, do_fan, do_volt);
1534 if (do_temp && temperature_list)
1535 {
1536 if (!pTemp)
1537 pTemp = gkrellm_panel_new0();
1538 make_temperature_panel(temp_vbox, first_create);
1539 }
1540 if (do_fan && fan_list)
1541 {
1542 if (!pFan)
1543 pFan = gkrellm_panel_new0();
1544 make_fan_panel(fan_vbox, first_create);
1545 }
1546 if (do_volt && volt_list)
1547 {
1548 if (!pVolt)
1549 pVolt = gkrellm_panel_new0();
1550 make_volt_panel(volt_vbox, first_create);
1551 }
1552 if (temperature_list || fan_list || volt_list)
1553 gkrellm_spacers_show(mon_sensors);
1554 else
1555 gkrellm_spacers_hide(mon_sensors);
1556 }
1557
1558void
1559gkrellm_sensors_rebuild(gboolean do_temp, gboolean do_fan, gboolean do_volt)
1560 {
1561 destroy_sensors_monitor(do_temp, do_fan, do_volt);
1562 create_sensors_monitor(do_temp, do_fan, do_volt, TRUE(!(0)));
1563 }
1564
1565static void
1566create_sensors(GtkWidget *vbox, gint first_create)
1567 {
1568 gchar **xpm;
1569 static gboolean config_loaded;
1570
1571 if (!config_loaded)
1572 read_sensors_config();
1573 if (first_create)
1574 {
1575 temp_vbox = gtk_vbox_new(FALSE(0), 0);
1576 gtk_box_pack_start(GTK_BOX(vbox)((((GtkBox*) g_type_check_instance_cast ((GTypeInstance*) ((vbox
)), ((gtk_box_get_type ()))))))
, temp_vbox, FALSE(0), FALSE(0), 0);
1577 gtk_widget_show(temp_vbox);
1578
1579 fan_vbox = gtk_vbox_new(FALSE(0), 0);
1580 gtk_box_pack_start(GTK_BOX(vbox)((((GtkBox*) g_type_check_instance_cast ((GTypeInstance*) ((vbox
)), ((gtk_box_get_type ()))))))
, fan_vbox, FALSE(0), FALSE(0), 0);
1581 gtk_widget_show(fan_vbox);
1582
1583 volt_vbox = gtk_vbox_new(FALSE(0), 0);
1584 gtk_box_pack_start(GTK_BOX(vbox)((((GtkBox*) g_type_check_instance_cast ((GTypeInstance*) ((vbox
)), ((gtk_box_get_type ()))))))
, volt_vbox, FALSE(0), FALSE(0), 0);
1585 gtk_widget_show(volt_vbox);
1586
1587 bezel_style = gkrellm_style_new0();
1588 }
1589 else /* To be done after disk panels created */
1590 need_disk_temperature_update = TRUE(!(0));
1591
1592 config_loaded = TRUE(!(0));
1593
1594 /* Here is where I define the volt panel theme image extensions. I ask
1595 | for a theme extension image:
1596 | THEME_DIR/sensors/bg_volt.png
1597 | and for a border for it from the gkrellmrc in the format:
1598 | set_piximage_border sensors_bg_volt l,r,t,b
1599 | There is no default for bg_volt image, ie it may end up being NULL.
1600 */
1601 xpm = gkrellm_using_default_theme() ? bg_volt_xpm : NULL((void*)0);
1602 if (bezel_piximage)
1603 gkrellm_destroy_piximage(bezel_piximage);
1604 bezel_piximage = NULL((void*)0);
1605 gkrellm_load_piximage("bg_volt", xpm, &bezel_piximage, SENSOR_STYLE_NAME"sensors");
1606 if (!gkrellm_set_gkrellmrc_piximage_border("sensors_bg_volt", bezel_piximage, bezel_style))
1607 bezel_style->border = default_bezel_border;
1608
1609 create_sensors_monitor(DO_TEMP1, DO_FAN1, DO_VOLT1, first_create);
1610 }
1611
1612 /* FIXME: monitor_sensors and monitor_config_sensors should be combined,
1613 | but the issue is apply_sensors_config() must be called before the CPU
1614 | and Proc apply, and I want create_sensors() called after the CPU and Proc
1615 | create. So for now, two GkrellmMonitor structs and have two sensor
1616 | monitor add_builtins() in main.c.
1617 */
1618static GkrellmMonitor monitor_sensors =
1619 {
1620 N_("Sensors")("Sensors"), /* Voltage config handled in Sensors tab */
1621 MON_VOLTAGE15, /* Id, 0 if a plugin */
1622 create_sensors, /* The create function */
1623 update_sensors, /* The update function */
1624 NULL((void*)0), /* The config tab create function */
1625 NULL((void*)0), /* Voltage apply handled in sensors apply */
1626
1627 NULL((void*)0), /* Voltage save config is in sensors save */
1628 NULL((void*)0), /* Voltage load config is in sensors load */
1629 NULL((void*)0), /* config keyword - use sensors */
1630
1631 NULL((void*)0), /* Undef 2 */
1632 NULL((void*)0), /* Undef 1 */
1633 NULL((void*)0), /* Undef 0 */
1634
1635 0, /* insert_before_id - place plugin before this mon */
1636
1637 NULL((void*)0), /* Handle if a plugin, filled in by GKrellM */
1638 NULL((void*)0) /* path if a plugin, filled in by GKrellM */
1639 };
1640
1641GkrellmMonitor *
1642gkrellm_init_sensor_monitor(void)
1643 {
1644 if (!sensor_list)
1645 return NULL((void*)0);
1646 monitor_sensors.name = _(monitor_sensors.name)dcgettext ("gkrellm", monitor_sensors.name, 5);
1647 style_id = gkrellm_add_meter_style(&monitor_sensors, SENSOR_STYLE_NAME"sensors");
1648 mon_sensors = &monitor_sensors;
1649 return &monitor_sensors;
1650 }
1651
1652/* =================================================================== */
1653/* Config for sensors monitor */
1654
1655 /* Don't use the user-config. Save into sensors-config and only if there
1656 | is a sensor_list. This preserves configs across a possible sensors
1657 | modules load screw up.
1658 |
1659 | 2.2.3 sets sensor_config_version to 1 to allow sensor relocation
1660 | to composite CPU on a SMP machine.
1661 |
1662 | 2.1.15 scales sensor factor/offset values by SENSOR_FLOAT_FACTOR to avoid
1663 | writting decimal points in the config. This is not backwards compatible
1664 | with the pre 2.1.15 sensor_config format hence the config file name
1665 | change to sensor-config. But sensor_config is forward compatible
1666 | since the float factor defaults to 1.0.
1667 */
1668#define SENSOR_CONFIG_VERSION1 1
1669
1670#define SENSOR_CONFIG_KEYWORD"sensor" "sensor"
1671#define SENSOR_CONFIG_FILE"sensor-config" "sensor-config"
1672#define SENSOR_2_1_14_CONFIG_FILE"sensors_config" "sensors_config"
1673
1674typedef struct
1675 {
1676 gchar *config_keyword,
1677 *config_label;
1678 gboolean value;
1679 void (*func)(gboolean value);
1680 }
1681 SysdepOption;
1682
1683static void cb_alert_config(GkrellmAlert *ap, Sensor *sr);
1684
1685static GList *sysdep_option_list;
1686
1687static void
1688create_sensor_alert(Sensor *s)
1689 {
1690 if (s->type == SENSOR_VOLTAGE2)
1691 s->alert = gkrellm_alert_create(NULL((void*)0), s->name,
1692 _("Sensor Volt Limits")dcgettext ("gkrellm", "Sensor Volt Limits", 5),
1693 TRUE(!(0)), TRUE(!(0)), TRUE(!(0)), 20, -20, 0.01, 0.5, 2);
1694 else if (s->type == SENSOR_TEMPERATURE0)
1695 s->alert = gkrellm_alert_create(NULL((void*)0), s->name,
1696 _("Sensor Temperature Limits (in displayed degree units)")dcgettext ("gkrellm", "Sensor Temperature Limits (in displayed degree units)"
, 5)
,
1697 TRUE(!(0)), FALSE(0), TRUE(!(0)), 300, 0, 1.0, 5.0, 1);
1698 else if (s->type == SENSOR_FAN1)
1699 s->alert = gkrellm_alert_create(NULL((void*)0), s->name,
1700 _("Sensor Fan RPM Limits")dcgettext ("gkrellm", "Sensor Fan RPM Limits", 5),
1701 FALSE(0), TRUE(!(0)), TRUE(!(0)), 20000, 0, 100, 1000, 0);
1702 else
1703 return;
1704 gkrellm_alert_delay_config(s->alert, 5, 60, 0);
1705 gkrellm_alert_trigger_connect(s->alert, s->cb_alert, s->cb_alert_data);
1706 gkrellm_alert_command_process_connect(s->alert, cb_command_process, s);
1707 gkrellm_alert_config_connect(s->alert, cb_alert_config, s);
1708 }
1709
1710void
1711gkrellm_sensors_sysdep_option(gchar *keyword, gchar *label, void (*func)())
1712 {
1713 SysdepOption *so = NULL((void*)0);
1714
1715 so = g_new0(SysdepOption, 1)(SysdepOption *) (__extension__ ({ gsize __n = (gsize) (1); gsize
__s = sizeof (SysdepOption); gpointer __p; if (__s == 1) __p
= g_malloc0 (__n); else if (__builtin_constant_p (__n) &&
(__s == 0 || __n <= (9223372036854775807L *2UL+1UL) / __s
)) __p = g_malloc0 (__n * __s); else __p = g_malloc0_n (__n, __s
); __p; }))
;
1716 sysdep_option_list = g_list_append(sysdep_option_list, so);
1717 so->config_keyword = g_strdup(keyword);
1718 so->config_label = g_strdup(label);
1719 so->func = func;
1720 }
1721
1722static void
1723save_sensors_config(FILE *f_not_used)
1724 {
1725 FILE *f;
1726 GList *list;
1727 Sensor *s;
1728 SysdepOption *so;
1729 gchar *config, quoted_name[128], buf[128];
1730 gfloat factor, offset;
1731
1732 if (!sensor_list || _GK.no_config)
1733 return;
1734 snprintf(buf, sizeof(buf), "%s/%s", GKRELLM_DIR".gkrellm2", SENSOR_CONFIG_FILE"sensor-config");
1735 config = gkrellm_make_config_file_name(gkrellm_homedir(), buf);
1736 f = g_fopenfopen(config, "w");
1737 g_free(config);
1738 if (!f)
1739 return;
1740
1741 fprintf(f, "%s sensor_config_version %d\n",
1742 SENSOR_CONFIG_KEYWORD"sensor", SENSOR_CONFIG_VERSION1);
1743 fprintf(f, "%s sensor_sysdep_private %d\n",
1744 SENSOR_CONFIG_KEYWORD"sensor", sensor_current_sysdep_private);
1745 fprintf(f, "%s sensor_float_factor %.0f\n",
1746 SENSOR_CONFIG_KEYWORD"sensor", SENSOR_FLOAT_FACTOR10000.0);
1747 fprintf(f, "%s gkrellm_float_factor %.0f\n",
1748 SENSOR_CONFIG_KEYWORD"sensor", GKRELLM_FLOAT_FACTOR1000.0);
1749 for (list = sysdep_option_list; list; list = list->next)
1750 {
1751 so = (SysdepOption *) list->data;
1752 fprintf(f, "%s sysdep_option %s %d\n", SENSOR_CONFIG_KEYWORD"sensor",
1753 so->config_keyword, so->value);
1754 }
1755
1756 for (list = sensor_list; list; list = list->next)
1757 {
1758 s = (Sensor *) list->data;
1759 if (s->name && *(s->name))
1760 {
1761 snprintf(quoted_name, sizeof(quoted_name), "\"%s\"", s->id_name);
1762 factor = (s->default_factor != 0.0 ? s->factor : 0.0);
1763 offset = (s->default_factor != 0.0 ? s->offset : 0.0);
1764 fprintf(f, "%s \"%s\" %s %.0f %.0f %d %d\n",
1765 SENSOR_CONFIG_KEYWORD"sensor",
1766 s->name, quoted_name,
1767 factor * SENSOR_FLOAT_FACTOR10000.0,
1768 offset * SENSOR_FLOAT_FACTOR10000.0,
1769 s->enabled, s->location);
1770 if (s->alert)
1771 gkrellm_save_alertconfig(f, s->alert,
1772 SENSOR_CONFIG_KEYWORD"sensor", quoted_name);
1773 }
1774 }
1775 for (list = sensor_list; list; list = list->next)
1776 {
1777 s = (Sensor *) list->data;
1778 if (s->vref)
1779 fprintf(f, "%s vref \"%s\" \"%s\"\n", SENSOR_CONFIG_KEYWORD"sensor",
1780 s->id_name, s->vref->id_name);
1781 }
1782
1783 fprintf(f, "%s units_fahrenheit %d\n", SENSOR_CONFIG_KEYWORD"sensor",
1784 units_fahrenheit);
1785 fprintf(f, "%s show_units %d\n", SENSOR_CONFIG_KEYWORD"sensor",
1786 show_units);
1787 fprintf(f, "%s volt_display_mode %d\n", SENSOR_CONFIG_KEYWORD"sensor",
1788 display_mode);
1789 /* _GK.mbmon_port is handled in config.c so that the port can be
1790 | loaded early for sensor initialization.
1791 */
1792 fclose(f);
1793 }
1794
1795static void
1796load_sensors_config(gchar *arg)
1797 {
1798 Sensor *s;
1799 SysdepOption *so;
1800 GList *list;
1801 gchar config[32], item[CFG_BUFSIZE512], item1[CFG_BUFSIZE512];
1802 gchar label[64], id_name[CFG_BUFSIZE512];
1803 gint n;
1804 gfloat f = 1.0,
1805 o = 0.0;
1806 gint e = 0,
1807 location = 0;
1808 gfloat save_factor;
1809
1810 n = sscanf(arg, "%31s %[^\n]", config, item);
1811 if (n != 2)
1812 return;
1813 gkrellm_debug(DEBUG_SENSORS0x80, "load_sensors_config: <%s> <%s>\n", config,
1814 item);
1815 if (!strcmp(config, "sensor_config_version")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(config) && __builtin_constant_p ("sensor_config_version"
) && (__s1_len = strlen (config), __s2_len = strlen (
"sensor_config_version"), (!((size_t)(const void *)((config) +
1) - (size_t)(const void *)(config) == 1) || __s1_len >= 4
) && (!((size_t)(const void *)(("sensor_config_version"
) + 1) - (size_t)(const void *)("sensor_config_version") == 1
) || __s2_len >= 4)) ? __builtin_strcmp (config, "sensor_config_version"
) : (__builtin_constant_p (config) && ((size_t)(const
void *)((config) + 1) - (size_t)(const void *)(config) == 1)
&& (__s1_len = strlen (config), __s1_len < 4) ? (
__builtin_constant_p ("sensor_config_version") && ((size_t
)(const void *)(("sensor_config_version") + 1) - (size_t)(const
void *)("sensor_config_version") == 1) ? __builtin_strcmp (config
, "sensor_config_version") : (__extension__ ({ const unsigned
char *__s2 = (const unsigned char *) (const char *) ("sensor_config_version"
); int __result = (((const unsigned char *) (const char *) (config
))[0] - __s2[0]); if (__s1_len > 0 && __result == 0
) { __result = (((const unsigned char *) (const char *) (config
))[1] - __s2[1]); if (__s1_len > 1 && __result == 0
) { __result = (((const unsigned char *) (const char *) (config
))[2] - __s2[2]); if (__s1_len > 2 && __result == 0
) __result = (((const unsigned char *) (const char *) (config
))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (
"sensor_config_version") && ((size_t)(const void *)((
"sensor_config_version") + 1) - (size_t)(const void *)("sensor_config_version"
) == 1) && (__s2_len = strlen ("sensor_config_version"
), __s2_len < 4) ? (__builtin_constant_p (config) &&
((size_t)(const void *)((config) + 1) - (size_t)(const void *
)(config) == 1) ? __builtin_strcmp (config, "sensor_config_version"
) : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned
char *) (const char *) (config); int __result = (((const unsigned
char *) (const char *) ("sensor_config_version"))[0] - __s2[
0]); if (__s2_len > 0 && __result == 0) { __result
= (((const unsigned char *) (const char *) ("sensor_config_version"
))[1] - __s2[1]); if (__s2_len > 1 && __result == 0
) { __result = (((const unsigned char *) (const char *) ("sensor_config_version"
))[2] - __s2[2]); if (__s2_len > 2 && __result == 0
) __result = (((const unsigned char *) (const char *) ("sensor_config_version"
))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (config
, "sensor_config_version")))); })
)
1816 sscanf(item, "%d", &sensor_config_version);
1817 else if (!strcmp(config, "sensor_sysdep_private")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(config) && __builtin_constant_p ("sensor_sysdep_private"
) && (__s1_len = strlen (config), __s2_len = strlen (
"sensor_sysdep_private"), (!((size_t)(const void *)((config) +
1) - (size_t)(const void *)(config) == 1) || __s1_len >= 4
) && (!((size_t)(const void *)(("sensor_sysdep_private"
) + 1) - (size_t)(const void *)("sensor_sysdep_private") == 1
) || __s2_len >= 4)) ? __builtin_strcmp (config, "sensor_sysdep_private"
) : (__builtin_constant_p (config) && ((size_t)(const
void *)((config) + 1) - (size_t)(const void *)(config) == 1)
&& (__s1_len = strlen (config), __s1_len < 4) ? (
__builtin_constant_p ("sensor_sysdep_private") && ((size_t
)(const void *)(("sensor_sysdep_private") + 1) - (size_t)(const
void *)("sensor_sysdep_private") == 1) ? __builtin_strcmp (config
, "sensor_sysdep_private") : (__extension__ ({ const unsigned
char *__s2 = (const unsigned char *) (const char *) ("sensor_sysdep_private"
); int __result = (((const unsigned char *) (const char *) (config
))[0] - __s2[0]); if (__s1_len > 0 && __result == 0
) { __result = (((const unsigned char *) (const char *) (config
))[1] - __s2[1]); if (__s1_len > 1 && __result == 0
) { __result = (((const unsigned char *) (const char *) (config
))[2] - __s2[2]); if (__s1_len > 2 && __result == 0
) __result = (((const unsigned char *) (const char *) (config
))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (
"sensor_sysdep_private") && ((size_t)(const void *)((
"sensor_sysdep_private") + 1) - (size_t)(const void *)("sensor_sysdep_private"
) == 1) && (__s2_len = strlen ("sensor_sysdep_private"
), __s2_len < 4) ? (__builtin_constant_p (config) &&
((size_t)(const void *)((config) + 1) - (size_t)(const void *
)(config) == 1) ? __builtin_strcmp (config, "sensor_sysdep_private"
) : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned
char *) (const char *) (config); int __result = (((const unsigned
char *) (const char *) ("sensor_sysdep_private"))[0] - __s2[
0]); if (__s2_len > 0 && __result == 0) { __result
= (((const unsigned char *) (const char *) ("sensor_sysdep_private"
))[1] - __s2[1]); if (__s2_len > 1 && __result == 0
) { __result = (((const unsigned char *) (const char *) ("sensor_sysdep_private"
))[2] - __s2[2]); if (__s2_len > 2 && __result == 0
) __result = (((const unsigned char *) (const char *) ("sensor_sysdep_private"
))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (config
, "sensor_sysdep_private")))); })
)
1818 sscanf(item, "%d", &sensor_config_sysdep_private);
1819 else if (!strcmp(config, "units_fahrenheit")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(config) && __builtin_constant_p ("units_fahrenheit"
) && (__s1_len = strlen (config), __s2_len = strlen (
"units_fahrenheit"), (!((size_t)(const void *)((config) + 1) -
(size_t)(const void *)(config) == 1) || __s1_len >= 4) &&
(!((size_t)(const void *)(("units_fahrenheit") + 1) - (size_t
)(const void *)("units_fahrenheit") == 1) || __s2_len >= 4
)) ? __builtin_strcmp (config, "units_fahrenheit") : (__builtin_constant_p
(config) && ((size_t)(const void *)((config) + 1) - (
size_t)(const void *)(config) == 1) && (__s1_len = strlen
(config), __s1_len < 4) ? (__builtin_constant_p ("units_fahrenheit"
) && ((size_t)(const void *)(("units_fahrenheit") + 1
) - (size_t)(const void *)("units_fahrenheit") == 1) ? __builtin_strcmp
(config, "units_fahrenheit") : (__extension__ ({ const unsigned
char *__s2 = (const unsigned char *) (const char *) ("units_fahrenheit"
); int __result = (((const unsigned char *) (const char *) (config
))[0] - __s2[0]); if (__s1_len > 0 && __result == 0
) { __result = (((const unsigned char *) (const char *) (config
))[1] - __s2[1]); if (__s1_len > 1 && __result == 0
) { __result = (((const unsigned char *) (const char *) (config
))[2] - __s2[2]); if (__s1_len > 2 && __result == 0
) __result = (((const unsigned char *) (const char *) (config
))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (
"units_fahrenheit") && ((size_t)(const void *)(("units_fahrenheit"
) + 1) - (size_t)(const void *)("units_fahrenheit") == 1) &&
(__s2_len = strlen ("units_fahrenheit"), __s2_len < 4) ? (
__builtin_constant_p (config) && ((size_t)(const void
*)((config) + 1) - (size_t)(const void *)(config) == 1) ? __builtin_strcmp
(config, "units_fahrenheit") : (- (__extension__ ({ const unsigned
char *__s2 = (const unsigned char *) (const char *) (config)
; int __result = (((const unsigned char *) (const char *) ("units_fahrenheit"
))[0] - __s2[0]); if (__s2_len > 0 && __result == 0
) { __result = (((const unsigned char *) (const char *) ("units_fahrenheit"
))[1] - __s2[1]); if (__s2_len > 1 && __result == 0
) { __result = (((const unsigned char *) (const char *) ("units_fahrenheit"
))[2] - __s2[2]); if (__s2_len > 2 && __result == 0
) __result = (((const unsigned char *) (const char *) ("units_fahrenheit"
))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (config
, "units_fahrenheit")))); })
)
1820 sscanf(item, "%d", &units_fahrenheit);
1821 else if (!strcmp(config, "show_units")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(config) && __builtin_constant_p ("show_units") &&
(__s1_len = strlen (config), __s2_len = strlen ("show_units"
), (!((size_t)(const void *)((config) + 1) - (size_t)(const void
*)(config) == 1) || __s1_len >= 4) && (!((size_t)
(const void *)(("show_units") + 1) - (size_t)(const void *)("show_units"
) == 1) || __s2_len >= 4)) ? __builtin_strcmp (config, "show_units"
) : (__builtin_constant_p (config) && ((size_t)(const
void *)((config) + 1) - (size_t)(const void *)(config) == 1)
&& (__s1_len = strlen (config), __s1_len < 4) ? (
__builtin_constant_p ("show_units") && ((size_t)(const
void *)(("show_units") + 1) - (size_t)(const void *)("show_units"
) == 1) ? __builtin_strcmp (config, "show_units") : (__extension__
({ const unsigned char *__s2 = (const unsigned char *) (const
char *) ("show_units"); int __result = (((const unsigned char
*) (const char *) (config))[0] - __s2[0]); if (__s1_len >
0 && __result == 0) { __result = (((const unsigned char
*) (const char *) (config))[1] - __s2[1]); if (__s1_len >
1 && __result == 0) { __result = (((const unsigned char
*) (const char *) (config))[2] - __s2[2]); if (__s1_len >
2 && __result == 0) __result = (((const unsigned char
*) (const char *) (config))[3] - __s2[3]); } } __result; }))
) : (__builtin_constant_p ("show_units") && ((size_t)
(const void *)(("show_units") + 1) - (size_t)(const void *)("show_units"
) == 1) && (__s2_len = strlen ("show_units"), __s2_len
< 4) ? (__builtin_constant_p (config) && ((size_t
)(const void *)((config) + 1) - (size_t)(const void *)(config
) == 1) ? __builtin_strcmp (config, "show_units") : (- (__extension__
({ const unsigned char *__s2 = (const unsigned char *) (const
char *) (config); int __result = (((const unsigned char *) (
const char *) ("show_units"))[0] - __s2[0]); if (__s2_len >
0 && __result == 0) { __result = (((const unsigned char
*) (const char *) ("show_units"))[1] - __s2[1]); if (__s2_len
> 1 && __result == 0) { __result = (((const unsigned
char *) (const char *) ("show_units"))[2] - __s2[2]); if (__s2_len
> 2 && __result == 0) __result = (((const unsigned
char *) (const char *) ("show_units"))[3] - __s2[3]); } } __result
; })))) : __builtin_strcmp (config, "show_units")))); })
)
1822 sscanf(item, "%d", &show_units);
1823 else if (!strcmp(config, "volt_display_mode")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(config) && __builtin_constant_p ("volt_display_mode"
) && (__s1_len = strlen (config), __s2_len = strlen (
"volt_display_mode"), (!((size_t)(const void *)((config) + 1)
- (size_t)(const void *)(config) == 1) || __s1_len >= 4) &&
(!((size_t)(const void *)(("volt_display_mode") + 1) - (size_t
)(const void *)("volt_display_mode") == 1) || __s2_len >= 4
)) ? __builtin_strcmp (config, "volt_display_mode") : (__builtin_constant_p
(config) && ((size_t)(const void *)((config) + 1) - (
size_t)(const void *)(config) == 1) && (__s1_len = strlen
(config), __s1_len < 4) ? (__builtin_constant_p ("volt_display_mode"
) && ((size_t)(const void *)(("volt_display_mode") + 1
) - (size_t)(const void *)("volt_display_mode") == 1) ? __builtin_strcmp
(config, "volt_display_mode") : (__extension__ ({ const unsigned
char *__s2 = (const unsigned char *) (const char *) ("volt_display_mode"
); int __result = (((const unsigned char *) (const char *) (config
))[0] - __s2[0]); if (__s1_len > 0 && __result == 0
) { __result = (((const unsigned char *) (const char *) (config
))[1] - __s2[1]); if (__s1_len > 1 && __result == 0
) { __result = (((const unsigned char *) (const char *) (config
))[2] - __s2[2]); if (__s1_len > 2 && __result == 0
) __result = (((const unsigned char *) (const char *) (config
))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (
"volt_display_mode") && ((size_t)(const void *)(("volt_display_mode"
) + 1) - (size_t)(const void *)("volt_display_mode") == 1) &&
(__s2_len = strlen ("volt_display_mode"), __s2_len < 4) ?
(__builtin_constant_p (config) && ((size_t)(const void
*)((config) + 1) - (size_t)(const void *)(config) == 1) ? __builtin_strcmp
(config, "volt_display_mode") : (- (__extension__ ({ const unsigned
char *__s2 = (const unsigned char *) (const char *) (config)
; int __result = (((const unsigned char *) (const char *) ("volt_display_mode"
))[0] - __s2[0]); if (__s2_len > 0 && __result == 0
) { __result = (((const unsigned char *) (const char *) ("volt_display_mode"
))[1] - __s2[1]); if (__s2_len > 1 && __result == 0
) { __result = (((const unsigned char *) (const char *) ("volt_display_mode"
))[2] - __s2[2]); if (__s2_len > 2 && __result == 0
) __result = (((const unsigned char *) (const char *) ("volt_display_mode"
))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (config
, "volt_display_mode")))); })
)
1824 sscanf(item, "%d", &display_mode);
1825 else if (!strcmp(config, "sensor_float_factor")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(config) && __builtin_constant_p ("sensor_float_factor"
) && (__s1_len = strlen (config), __s2_len = strlen (
"sensor_float_factor"), (!((size_t)(const void *)((config) + 1
) - (size_t)(const void *)(config) == 1) || __s1_len >= 4)
&& (!((size_t)(const void *)(("sensor_float_factor")
+ 1) - (size_t)(const void *)("sensor_float_factor") == 1) ||
__s2_len >= 4)) ? __builtin_strcmp (config, "sensor_float_factor"
) : (__builtin_constant_p (config) && ((size_t)(const
void *)((config) + 1) - (size_t)(const void *)(config) == 1)
&& (__s1_len = strlen (config), __s1_len < 4) ? (
__builtin_constant_p ("sensor_float_factor") && ((size_t
)(const void *)(("sensor_float_factor") + 1) - (size_t)(const
void *)("sensor_float_factor") == 1) ? __builtin_strcmp (config
, "sensor_float_factor") : (__extension__ ({ const unsigned char
*__s2 = (const unsigned char *) (const char *) ("sensor_float_factor"
); int __result = (((const unsigned char *) (const char *) (config
))[0] - __s2[0]); if (__s1_len > 0 && __result == 0
) { __result = (((const unsigned char *) (const char *) (config
))[1] - __s2[1]); if (__s1_len > 1 && __result == 0
) { __result = (((const unsigned char *) (const char *) (config
))[2] - __s2[2]); if (__s1_len > 2 && __result == 0
) __result = (((const unsigned char *) (const char *) (config
))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (
"sensor_float_factor") && ((size_t)(const void *)(("sensor_float_factor"
) + 1) - (size_t)(const void *)("sensor_float_factor") == 1) &&
(__s2_len = strlen ("sensor_float_factor"), __s2_len < 4)
? (__builtin_constant_p (config) && ((size_t)(const void
*)((config) + 1) - (size_t)(const void *)(config) == 1) ? __builtin_strcmp
(config, "sensor_float_factor") : (- (__extension__ ({ const
unsigned char *__s2 = (const unsigned char *) (const char *)
(config); int __result = (((const unsigned char *) (const char
*) ("sensor_float_factor"))[0] - __s2[0]); if (__s2_len >
0 && __result == 0) { __result = (((const unsigned char
*) (const char *) ("sensor_float_factor"))[1] - __s2[1]); if
(__s2_len > 1 && __result == 0) { __result = (((const
unsigned char *) (const char *) ("sensor_float_factor"))[2] -
__s2[2]); if (__s2_len > 2 && __result == 0) __result
= (((const unsigned char *) (const char *) ("sensor_float_factor"
))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (config
, "sensor_float_factor")))); })
)
1826 sscanf(item, "%f", &sensor_float_factor);
1827 else if (!strcmp(config, "gkrellm_float_factor")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(config) && __builtin_constant_p ("gkrellm_float_factor"
) && (__s1_len = strlen (config), __s2_len = strlen (
"gkrellm_float_factor"), (!((size_t)(const void *)((config) +
1) - (size_t)(const void *)(config) == 1) || __s1_len >= 4
) && (!((size_t)(const void *)(("gkrellm_float_factor"
) + 1) - (size_t)(const void *)("gkrellm_float_factor") == 1)
|| __s2_len >= 4)) ? __builtin_strcmp (config, "gkrellm_float_factor"
) : (__builtin_constant_p (config) && ((size_t)(const
void *)((config) + 1) - (size_t)(const void *)(config) == 1)
&& (__s1_len = strlen (config), __s1_len < 4) ? (
__builtin_constant_p ("gkrellm_float_factor") && ((size_t
)(const void *)(("gkrellm_float_factor") + 1) - (size_t)(const
void *)("gkrellm_float_factor") == 1) ? __builtin_strcmp (config
, "gkrellm_float_factor") : (__extension__ ({ const unsigned char
*__s2 = (const unsigned char *) (const char *) ("gkrellm_float_factor"
); int __result = (((const unsigned char *) (const char *) (config
))[0] - __s2[0]); if (__s1_len > 0 && __result == 0
) { __result = (((const unsigned char *) (const char *) (config
))[1] - __s2[1]); if (__s1_len > 1 && __result == 0
) { __result = (((const unsigned char *) (const char *) (config
))[2] - __s2[2]); if (__s1_len > 2 && __result == 0
) __result = (((const unsigned char *) (const char *) (config
))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (
"gkrellm_float_factor") && ((size_t)(const void *)(("gkrellm_float_factor"
) + 1) - (size_t)(const void *)("gkrellm_float_factor") == 1)
&& (__s2_len = strlen ("gkrellm_float_factor"), __s2_len
< 4) ? (__builtin_constant_p (config) && ((size_t
)(const void *)((config) + 1) - (size_t)(const void *)(config
) == 1) ? __builtin_strcmp (config, "gkrellm_float_factor") :
(- (__extension__ ({ const unsigned char *__s2 = (const unsigned
char *) (const char *) (config); int __result = (((const unsigned
char *) (const char *) ("gkrellm_float_factor"))[0] - __s2[0
]); if (__s2_len > 0 && __result == 0) { __result =
(((const unsigned char *) (const char *) ("gkrellm_float_factor"
))[1] - __s2[1]); if (__s2_len > 1 && __result == 0
) { __result = (((const unsigned char *) (const char *) ("gkrellm_float_factor"
))[2] - __s2[2]); if (__s2_len > 2 && __result == 0
) __result = (((const unsigned char *) (const char *) ("gkrellm_float_factor"
))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (config
, "gkrellm_float_factor")))); })
)
1828 sscanf(item, "%f", &gkrellm_float_factor);
1829 else if (!strcmp(config, "vref")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(config) && __builtin_constant_p ("vref") &&
(__s1_len = strlen (config), __s2_len = strlen ("vref"), (!(
(size_t)(const void *)((config) + 1) - (size_t)(const void *)
(config) == 1) || __s1_len >= 4) && (!((size_t)(const
void *)(("vref") + 1) - (size_t)(const void *)("vref") == 1)
|| __s2_len >= 4)) ? __builtin_strcmp (config, "vref") : (
__builtin_constant_p (config) && ((size_t)(const void
*)((config) + 1) - (size_t)(const void *)(config) == 1) &&
(__s1_len = strlen (config), __s1_len < 4) ? (__builtin_constant_p
("vref") && ((size_t)(const void *)(("vref") + 1) - (
size_t)(const void *)("vref") == 1) ? __builtin_strcmp (config
, "vref") : (__extension__ ({ const unsigned char *__s2 = (const
unsigned char *) (const char *) ("vref"); int __result = (((
const unsigned char *) (const char *) (config))[0] - __s2[0])
; if (__s1_len > 0 && __result == 0) { __result = (
((const unsigned char *) (const char *) (config))[1] - __s2[1
]); if (__s1_len > 1 && __result == 0) { __result =
(((const unsigned char *) (const char *) (config))[2] - __s2
[2]); if (__s1_len > 2 && __result == 0) __result =
(((const unsigned char *) (const char *) (config))[3] - __s2
[3]); } } __result; }))) : (__builtin_constant_p ("vref") &&
((size_t)(const void *)(("vref") + 1) - (size_t)(const void *
)("vref") == 1) && (__s2_len = strlen ("vref"), __s2_len
< 4) ? (__builtin_constant_p (config) && ((size_t
)(const void *)((config) + 1) - (size_t)(const void *)(config
) == 1) ? __builtin_strcmp (config, "vref") : (- (__extension__
({ const unsigned char *__s2 = (const unsigned char *) (const
char *) (config); int __result = (((const unsigned char *) (
const char *) ("vref"))[0] - __s2[0]); if (__s2_len > 0 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) ("vref"))[1] - __s2[1]); if (__s2_len > 1 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) ("vref"))[2] - __s2[2]); if (__s2_len > 2 &&
__result == 0) __result = (((const unsigned char *) (const char
*) ("vref"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp
(config, "vref")))); })
)
1830 {
1831 if ( sscanf(item, "\"%63[^\"]\" \"%64[^\"]\"", id_name, item1) == 2
1832 && (s = lookup_sensor_from_id_name(id_name)) != NULL((void*)0)
1833 )
1834 s->vref = lookup_sensor_from_id_name(item1);
1835 }
1836 else if (!strcmp(config, "sysdep_option")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(config) && __builtin_constant_p ("sysdep_option") &&
(__s1_len = strlen (config), __s2_len = strlen ("sysdep_option"
), (!((size_t)(const void *)((config) + 1) - (size_t)(const void
*)(config) == 1) || __s1_len >= 4) && (!((size_t)
(const void *)(("sysdep_option") + 1) - (size_t)(const void *
)("sysdep_option") == 1) || __s2_len >= 4)) ? __builtin_strcmp
(config, "sysdep_option") : (__builtin_constant_p (config) &&
((size_t)(const void *)((config) + 1) - (size_t)(const void *
)(config) == 1) && (__s1_len = strlen (config), __s1_len
< 4) ? (__builtin_constant_p ("sysdep_option") &&
((size_t)(const void *)(("sysdep_option") + 1) - (size_t)(const
void *)("sysdep_option") == 1) ? __builtin_strcmp (config, "sysdep_option"
) : (__extension__ ({ const unsigned char *__s2 = (const unsigned
char *) (const char *) ("sysdep_option"); int __result = (((
const unsigned char *) (const char *) (config))[0] - __s2[0])
; if (__s1_len > 0 && __result == 0) { __result = (
((const unsigned char *) (const char *) (config))[1] - __s2[1
]); if (__s1_len > 1 && __result == 0) { __result =
(((const unsigned char *) (const char *) (config))[2] - __s2
[2]); if (__s1_len > 2 && __result == 0) __result =
(((const unsigned char *) (const char *) (config))[3] - __s2
[3]); } } __result; }))) : (__builtin_constant_p ("sysdep_option"
) && ((size_t)(const void *)(("sysdep_option") + 1) -
(size_t)(const void *)("sysdep_option") == 1) && (__s2_len
= strlen ("sysdep_option"), __s2_len < 4) ? (__builtin_constant_p
(config) && ((size_t)(const void *)((config) + 1) - (
size_t)(const void *)(config) == 1) ? __builtin_strcmp (config
, "sysdep_option") : (- (__extension__ ({ const unsigned char
*__s2 = (const unsigned char *) (const char *) (config); int
__result = (((const unsigned char *) (const char *) ("sysdep_option"
))[0] - __s2[0]); if (__s2_len > 0 && __result == 0
) { __result = (((const unsigned char *) (const char *) ("sysdep_option"
))[1] - __s2[1]); if (__s2_len > 1 && __result == 0
) { __result = (((const unsigned char *) (const char *) ("sysdep_option"
))[2] - __s2[2]); if (__s2_len > 2 && __result == 0
) __result = (((const unsigned char *) (const char *) ("sysdep_option"
))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (config
, "sysdep_option")))); })
)
1837 {
1838 if (sscanf(item, "%63s %[^\n]", id_name, item1) == 2)
1839 {
1840 so = NULL((void*)0);
1841 for (list = sysdep_option_list; list; list = list->next)
1842 {
1843 so = (SysdepOption *) list->data;
1844 if (!strcmp(so->config_keyword, id_name)__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(so->config_keyword) && __builtin_constant_p (id_name
) && (__s1_len = strlen (so->config_keyword), __s2_len
= strlen (id_name), (!((size_t)(const void *)((so->config_keyword
) + 1) - (size_t)(const void *)(so->config_keyword) == 1) ||
__s1_len >= 4) && (!((size_t)(const void *)((id_name
) + 1) - (size_t)(const void *)(id_name) == 1) || __s2_len >=
4)) ? __builtin_strcmp (so->config_keyword, id_name) : (__builtin_constant_p
(so->config_keyword) && ((size_t)(const void *)((
so->config_keyword) + 1) - (size_t)(const void *)(so->config_keyword
) == 1) && (__s1_len = strlen (so->config_keyword)
, __s1_len < 4) ? (__builtin_constant_p (id_name) &&
((size_t)(const void *)((id_name) + 1) - (size_t)(const void
*)(id_name) == 1) ? __builtin_strcmp (so->config_keyword,
id_name) : (__extension__ ({ const unsigned char *__s2 = (const
unsigned char *) (const char *) (id_name); int __result = ((
(const unsigned char *) (const char *) (so->config_keyword
))[0] - __s2[0]); if (__s1_len > 0 && __result == 0
) { __result = (((const unsigned char *) (const char *) (so->
config_keyword))[1] - __s2[1]); if (__s1_len > 1 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (so->config_keyword))[2] - __s2[2]); if (__s1_len
> 2 && __result == 0) __result = (((const unsigned
char *) (const char *) (so->config_keyword))[3] - __s2[3]
); } } __result; }))) : (__builtin_constant_p (id_name) &&
((size_t)(const void *)((id_name) + 1) - (size_t)(const void
*)(id_name) == 1) && (__s2_len = strlen (id_name), __s2_len
< 4) ? (__builtin_constant_p (so->config_keyword) &&
((size_t)(const void *)((so->config_keyword) + 1) - (size_t
)(const void *)(so->config_keyword) == 1) ? __builtin_strcmp
(so->config_keyword, id_name) : (- (__extension__ ({ const
unsigned char *__s2 = (const unsigned char *) (const char *)
(so->config_keyword); int __result = (((const unsigned char
*) (const char *) (id_name))[0] - __s2[0]); if (__s2_len >
0 && __result == 0) { __result = (((const unsigned char
*) (const char *) (id_name))[1] - __s2[1]); if (__s2_len >
1 && __result == 0) { __result = (((const unsigned char
*) (const char *) (id_name))[2] - __s2[2]); if (__s2_len >
2 && __result == 0) __result = (((const unsigned char
*) (const char *) (id_name))[3] - __s2[3]); } } __result; })
))) : __builtin_strcmp (so->config_keyword, id_name)))); }
)
)
1845 break;
1846 so = NULL((void*)0);
1847 }
1848 if (so && so->func)
1849 {
1850 so->value = atoi(item1);
1851 (*so->func)(so->value);
1852 }
1853 }
1854 }
1855 else if (!strcmp(config, GKRELLM_ALERTCONFIG_KEYWORD)__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(config) && __builtin_constant_p ("alert_config") &&
(__s1_len = strlen (config), __s2_len = strlen ("alert_config"
), (!((size_t)(const void *)((config) + 1) - (size_t)(const void
*)(config) == 1) || __s1_len >= 4) && (!((size_t)
(const void *)(("alert_config") + 1) - (size_t)(const void *)
("alert_config") == 1) || __s2_len >= 4)) ? __builtin_strcmp
(config, "alert_config") : (__builtin_constant_p (config) &&
((size_t)(const void *)((config) + 1) - (size_t)(const void *
)(config) == 1) && (__s1_len = strlen (config), __s1_len
< 4) ? (__builtin_constant_p ("alert_config") && (
(size_t)(const void *)(("alert_config") + 1) - (size_t)(const
void *)("alert_config") == 1) ? __builtin_strcmp (config, "alert_config"
) : (__extension__ ({ const unsigned char *__s2 = (const unsigned
char *) (const char *) ("alert_config"); int __result = (((const
unsigned char *) (const char *) (config))[0] - __s2[0]); if (
__s1_len > 0 && __result == 0) { __result = (((const
unsigned char *) (const char *) (config))[1] - __s2[1]); if (
__s1_len > 1 && __result == 0) { __result = (((const
unsigned char *) (const char *) (config))[2] - __s2[2]); if (
__s1_len > 2 && __result == 0) __result = (((const
unsigned char *) (const char *) (config))[3] - __s2[3]); } }
__result; }))) : (__builtin_constant_p ("alert_config") &&
((size_t)(const void *)(("alert_config") + 1) - (size_t)(const
void *)("alert_config") == 1) && (__s2_len = strlen (
"alert_config"), __s2_len < 4) ? (__builtin_constant_p (config
) && ((size_t)(const void *)((config) + 1) - (size_t)
(const void *)(config) == 1) ? __builtin_strcmp (config, "alert_config"
) : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned
char *) (const char *) (config); int __result = (((const unsigned
char *) (const char *) ("alert_config"))[0] - __s2[0]); if (
__s2_len > 0 && __result == 0) { __result = (((const
unsigned char *) (const char *) ("alert_config"))[1] - __s2[
1]); if (__s2_len > 1 && __result == 0) { __result
= (((const unsigned char *) (const char *) ("alert_config"))
[2] - __s2[2]); if (__s2_len > 2 && __result == 0)
__result = (((const unsigned char *) (const char *) ("alert_config"
))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (config
, "alert_config")))); })
)
1856 {
1857 if ( sscanf(item, "\"%63[^\"]\" %[^\n]", id_name, item1) == 2
1858 && (s = lookup_sensor_from_id_name(id_name)) != NULL((void*)0)
1859 )
1860 {
1861 /* Since config files may be copied around, make sure to use the
1862 | gkrellm float factor in effect when the sensors config was
1863 | created.
1864 */
1865 save_factor = _GK.float_factor;
1866 _GK.float_factor = gkrellm_float_factor;
1867 if (!s->alert)
1868 create_sensor_alert(s);
1869 gkrellm_load_alertconfig(&s->alert, item1);
1870 _GK.float_factor = save_factor;
1871 }
1872 }
1873 else if ( sscanf(arg, "\"%63[^\"]\" \"%[^\"]\" %f %f %d %d",
1874 label, id_name, &f, &o, &e, &location) > 1
1875 && (s = map_sensor_label(label, id_name)) != NULL((void*)0)
1876 )
1877 {
1878 if (f != 0.0 && s->default_factor != 0.0)
1879 {
1880 s->factor = f / sensor_float_factor;
1881 s->offset = o / sensor_float_factor;
1882 }
1883 s->enabled = e;
1884
1885 if (s->type == SENSOR_VOLTAGE2)
1886 s->location = 0;
1887 else
1888 {
1889 s->location = location;
1890 if ( sensor_config_version == 0 && gkrellm_smp_cpus() > 0
1891 && location > PROC_PANEL_LOCATION1
1892 )
1893 /* gkrellm < 2.2.3 did not allow relocating to composite
1894 | CPU if on a SMP machine. But with hyperthreading, user
1895 | may want to do this.
1896 */
1897 s->location += 1;
1898 }
1899 if (!using_new_config && s->type != SENSOR_VOLTAGE2)
1900 s->enabled = TRUE(!(0)); /* Old config enabled with a label */
1901 }
1902 if (display_mode < 0 || display_mode >= N_DISPLAY_MODES2)
1903 display_mode = N_DISPLAY_MODES2 - 1;
1904 }
1905
1906static void
1907read_sensors_config(void)
1908 {
1909 FILE *f;
1910 Sensor *sr;
1911 GList *list;
1912 gchar *config;
1913 gchar buf[CFG_BUFSIZE512];
1914
1915 snprintf(buf, sizeof(buf), "%s/%s", GKRELLM_DIR".gkrellm2", SENSOR_CONFIG_FILE"sensor-config");
1916 config = gkrellm_make_config_file_name(gkrellm_homedir(), buf);
1917 f = g_fopenfopen(config, "r");
1918 g_free(config);
1919
1920 if (!f)
1921 {
1922 snprintf(buf, sizeof(buf), "%s/%s", GKRELLM_DIR".gkrellm2", SENSOR_2_1_14_CONFIG_FILE"sensors_config");
1923 config = gkrellm_make_config_file_name(gkrellm_homedir(), buf);
1924 f = g_fopenfopen(config, "r");
1925 g_free(config);
1926 }
1927 if (f)
1928 {
1929 using_new_config = TRUE(!(0));
1930 while (fgets(buf, sizeof(buf), f))
1931 load_sensors_config(buf + strlen(SENSOR_CONFIG_KEYWORD"sensor") + 1);
1932 fclose(f);
1933 }
1934
1935 /* In case not all sensors are in sensor_config (user edited?)
1936 */
1937 for (list = sensor_list; list; list = list->next)
1938 {
1939 sr = (Sensor *) list->data;
1940 if (sr->has_config) /* Was in sensor_config and is already */
1941 continue; /* appended to an order_list */
1942 append_sensor_to_order_list(sr);
1943 }
1944 g_list_free(sensor_list);
1945 sensor_list = temp_order_list;
1946 sensor_list = g_list_concat(sensor_list, fan_order_list);
1947 sensor_list = g_list_concat(sensor_list, volt_order_list);
1948 }
1949
1950enum
1951 {
1952 NAME_COLUMN,
1953 ENABLE_COLUMN,
1954 LABEL_COLUMN,
1955 SENSOR_COLUMN,
1956 VISIBLE_COLUMN,
1957 IMAGE_COLUMN,
1958 N_COLUMNS
1959 };
1960
1961static GtkTreeModel *sensor_model;
1962static GtkTreeView *treeview;
1963static GtkTreeRowReference *row_reference;
1964static GtkTreeSelection *selection;
1965
1966
1967static GtkWidget *optionmenu;
1968
1969static GtkWidget *display_mode_button[2];
1970static GtkWidget *factor_spin_button,
1971 *offset_spin_button;
1972static GtkWidget *alert_button,
1973 *mbmon_port_entry;
1974
1975static Sensor *dragged_sensor;
1976
1977static gint sensor_last_group;
1978
1979static gboolean (*original_row_drop_possible)();
1980
1981
1982
1983static void
1984set_tree_store_model_data(GtkTreeStore *tree, GtkTreeIter *iter, Sensor *s)
1985 {
1986 if (!s)
1987 return;
1988 gtk_tree_store_set(tree, iter,
1989 NAME_COLUMN, s->id_name ? s->id_name : "??",
1990 ENABLE_COLUMN, s->enabled,
1991 LABEL_COLUMN, s->name ? s->name : "??",
1992 SENSOR_COLUMN, s,
1993 VISIBLE_COLUMN, TRUE(!(0)),
1994 -1);
1995 if (s->alert)
1996 gtk_tree_store_set(tree, iter,
1997 IMAGE_COLUMN, gkrellm_alert_pixbuf(),
1998 -1);
1999 }
2000
2001static void
2002append_sensors_to_model(GtkTreeStore *tree, GtkTreeIter *citer,
2003 GtkTreeIter *iter, gint type)
2004 {
2005 GList *list;
2006 Sensor *s;
2007
2008 for (list = sensor_list; list; list = list->next)
2009 {
2010 s = (Sensor *) list->data;
2011 if (s->type != type)
2012 continue;
2013 gtk_tree_store_append(tree, citer, iter);
2014 set_tree_store_model_data(tree, citer, s);
2015 }
2016 }
2017
2018static GtkTreeModel *
2019create_model(void)
2020 {
2021 GtkTreeStore *tree;
2022 GtkTreeIter iter, citer;
2023
2024 tree = gtk_tree_store_new(N_COLUMNS,
2025 G_TYPE_STRING((GType) ((16) << (2))),
2026 G_TYPE_BOOLEAN((GType) ((5) << (2))),
2027 G_TYPE_STRING((GType) ((16) << (2))),
2028 G_TYPE_POINTER((GType) ((17) << (2))),
2029 G_TYPE_BOOLEAN((GType) ((5) << (2))),
2030 GDK_TYPE_PIXBUF(gdk_pixbuf_get_type ())
2031 );
2032
2033 gtk_tree_store_append(tree, &iter, NULL((void*)0));
2034 gtk_tree_store_set(tree, &iter,
2035 NAME_COLUMN, _("Temperatures")dcgettext ("gkrellm", "Temperatures", 5),
2036 VISIBLE_COLUMN, FALSE(0),
2037 -1);
2038 append_sensors_to_model(tree, &citer, &iter, SENSOR_TEMPERATURE0);
2039
2040 gtk_tree_store_append(tree, &iter, NULL((void*)0));
2041 gtk_tree_store_set(tree, &iter,
2042 NAME_COLUMN, _("Fans")dcgettext ("gkrellm", "Fans", 5),
2043 VISIBLE_COLUMN, FALSE(0),
2044 -1);
2045 append_sensors_to_model(tree, &citer, &iter, SENSOR_FAN1);
2046
2047 gtk_tree_store_append(tree, &iter, NULL((void*)0));
2048 gtk_tree_store_set(tree, &iter,
2049 NAME_COLUMN, _("Voltages")dcgettext ("gkrellm", "Voltages", 5),
2050 VISIBLE_COLUMN, FALSE(0),
2051 -1);
2052 append_sensors_to_model(tree, &citer, &iter, SENSOR_VOLTAGE2);
2053 return GTK_TREE_MODEL(tree)((((GtkTreeModel*) g_type_check_instance_cast ((GTypeInstance
*) ((tree)), ((gtk_tree_model_get_type ()))))))
;
2054 }
2055
2056void
2057gkrellm_sensors_model_update(void)
2058 {
2059 GtkTreeModel *model;
2060
2061 if (!gkrellm_config_window_shown())
2062 return;
2063 model = sensor_model;
2064 sensor_model = create_model();
2065 gtk_tree_view_set_model(treeview, sensor_model);
2066 if (model)
2067 g_object_unref(G_OBJECT(model)((((GObject*) g_type_check_instance_cast ((GTypeInstance*) ((
model)), (((GType) ((20) << (2))))))))
);
2068 }
2069
2070static void
2071change_row_reference(GtkTreeModel *model, GtkTreePath *path)
2072 {
2073 gtk_tree_row_reference_free(row_reference);
2074 if (model && path)
2075 row_reference = gtk_tree_row_reference_new(model, path);
2076 else
2077 row_reference = NULL((void*)0);
2078 }
2079
2080static Sensor *
2081get_referenced_sensor(void)
2082 {
2083 GtkTreeModel *model;
2084 GtkTreePath *path;
2085 GtkTreeIter iter;
2086 Sensor *s;
2087
2088 if (!row_reference)
2089 return NULL((void*)0);
2090 model = gtk_tree_view_get_model(treeview);
2091 path = gtk_tree_row_reference_get_path(row_reference);
2092 gtk_tree_model_get_iter(model, &iter, path);
2093 gtk_tree_model_get(model, &iter,
2094 SENSOR_COLUMN, &s, -1);
2095 return s;
2096 }
2097
2098static gboolean
2099get_child_iter(GtkTreeModel *model, gchar *parent_node, GtkTreeIter *citer)
2100 {
2101 GtkTreePath *path;
2102 GtkTreeIter iter;
2103
2104 path = gtk_tree_path_new_from_string(parent_node);
2105 gtk_tree_model_get_iter(model, &iter, path);
2106 gtk_tree_path_free(path);
2107 return gtk_tree_model_iter_children(model, citer, &iter);
2108 }
2109
2110
2111 /* Callback for a created or destroyed alert. Find the sensor in the model
2112 | and set the IMAGE_COLUMN.
2113 */
2114static void
2115cb_alert_config(GkrellmAlert *ap, Sensor *sr)
2116 {
2117 GtkTreeModel *model;
2118 GtkTreeIter iter;
2119 Sensor *s;
2120 GdkPixbuf *pixbuf;
2121 gchar node[2];
2122 gint i;
2123
2124 if (!gkrellm_config_window_shown())
2125 return;
2126 model = gtk_tree_view_get_model(treeview);
2127 pixbuf = ap->activated ? gkrellm_alert_pixbuf() : NULL((void*)0);
2128 for (i = 0; i < 3; ++i)
2129 {
2130 node[0] = '0' + i; /* toplevel temp, fan, or volt node */
2131 node[1] = '\0';
2132 if (get_child_iter(model, node, &iter))
2133 do
2134 {
2135 gtk_tree_model_get(model, &iter, SENSOR_COLUMN, &s, -1);
2136 if (s != sr)
2137 continue;
2138 gtk_tree_store_set(GTK_TREE_STORE(model)((((GtkTreeStore*) g_type_check_instance_cast ((GTypeInstance
*) ((model)), ((gtk_tree_store_get_type ()))))))
, &iter,
2139 IMAGE_COLUMN, pixbuf, -1);
2140 return;
2141 }
2142 while (gtk_tree_model_iter_next(model, &iter));
2143 }
2144 }
2145
2146 /* Allow destination drops only on depth 2 paths and don't allow drops from
2147 | source depths of 1 (top level nodes). Also disallow drags from one sensor
2148 | type to another. Note: from some reason if I allow drops on depth 3 nodes
2149 | (destination is on top of a second level node) I am not getting
2150 | "drag_end" callbacks.
2151 */
2152static gboolean
2153row_drop_possible(GtkTreeDragDest *drag_dest, GtkTreePath *path,
2154 GtkSelectionData *selection_data)
2155 {
2156 gint *src_indices, *dst_indices;
2157 GtkTreePath *src_path;
2158
2159 if (!row_reference)
2160 return FALSE(0);
2161
2162 src_path = gtk_tree_row_reference_get_path(row_reference);
2163 src_indices = gtk_tree_path_get_indices(src_path);
2164 dst_indices = gtk_tree_path_get_indices(path);
2165//g_debug("drop path: indices=[%d,%d]:%d, path=%s\n",
2166// dst_indices[0], dst_indices[1], gtk_tree_path_get_depth(path),
2167// gtk_tree_path_to_string(path));
2168
2169 if ( gtk_tree_path_get_depth(src_path) == 1 /* Dragging top level */
2170 || gtk_tree_path_get_depth(path) != 2
2171 || src_indices[0] != dst_indices[0] /* sensor types don't match */
2172 )
2173 return FALSE(0);
2174
2175 return (*original_row_drop_possible)(drag_dest, path,
2176 selection_data);
2177 }
2178
2179 /* At each drag, divert the original Gtk row_drop_possible function to my
2180 | custom row_drop_possible so I can control tree structure. The original
2181 | row_drop_possible function must be restored at "drag_end" else other
2182 | monitors doing drag n' drop could get screwed.
2183 */
2184static gboolean
2185cb_drag_begin(GtkWidget *widget, GdkDragContext *context, gpointer data)
2186 {
2187 GtkTreeModel *model;
2188 GtkTreePath *path;
2189 GtkTreeIter iter;
2190 GtkTreeDragDestIface *dest_iface;
2191
2192 model = gtk_tree_view_get_model(treeview);
2193 dest_iface = GTK_TREE_DRAG_DEST_GET_IFACE(GTK_TREE_DRAG_DEST(model))((((GtkTreeDragDestIface*) g_type_interface_peek (((GTypeInstance
*) ((((((GtkTreeDragDest*) g_type_check_instance_cast ((GTypeInstance
*) ((model)), ((gtk_tree_drag_dest_get_type ())))))))))->g_class
, ((gtk_tree_drag_dest_get_type ()))))))
;
2194 if (!original_row_drop_possible)
2195 original_row_drop_possible = dest_iface->row_drop_possible;
2196 dest_iface->row_drop_possible = row_drop_possible;
2197
2198 if (row_reference)
2199 {
2200 path = gtk_tree_row_reference_get_path(row_reference);
2201 gtk_tree_model_get_iter(model, &iter, path);
2202 gtk_tree_model_get(model, &iter, SENSOR_COLUMN, &dragged_sensor, -1);
2203 }
2204 else
2205 dragged_sensor = NULL((void*)0);
2206 return FALSE(0);
2207 }
2208
2209static gboolean
2210cb_drag_end(GtkWidget *widget, GdkDragContext *context, gpointer data)
2211 {
2212 GtkTreeModel *model;
2213 GtkTreeIter iter;
2214 GtkTreeDragDestIface *dest_iface;
2215 Sensor *s;
2216 gchar node[2];
2217 gint i, type = -1;
2218
2219 model = gtk_tree_view_get_model(treeview);
2220 dest_iface = GTK_TREE_DRAG_DEST_GET_IFACE(GTK_TREE_DRAG_DEST(model))((((GtkTreeDragDestIface*) g_type_interface_peek (((GTypeInstance
*) ((((((GtkTreeDragDest*) g_type_check_instance_cast ((GTypeInstance
*) ((model)), ((gtk_tree_drag_dest_get_type ())))))))))->g_class
, ((gtk_tree_drag_dest_get_type ()))))))
;
2221 dest_iface->row_drop_possible = original_row_drop_possible;
2222
2223 change_row_reference(NULL((void*)0), NULL((void*)0));
2224 gtk_tree_selection_unselect_all(selection);
2225
2226 g_list_free(sensor_list);
2227 sensor_list = NULL((void*)0);
2228
2229 /* Re-order the sensors list to match the model.
2230 */
2231 model = gtk_tree_view_get_model(treeview);
2232 for (i = 0; i < 3; ++i)
2233 {
2234 node[0] = '0' + i; /* toplevel temp, fan, or volt node */
2235 node[1] = '\0';
2236 if (get_child_iter(model, node, &iter))
2237 {
2238 do
2239 {
2240 gtk_tree_model_get(model, &iter, SENSOR_COLUMN, &s, -1);
2241 sensor_list = g_list_append(sensor_list, s);
2242 }
2243 while (gtk_tree_model_iter_next(model, &iter));
2244 }
2245 }
2246
2247 if (dragged_sensor)
2248 type = dragged_sensor->type;
2249 dragged_sensor = NULL((void*)0);
2250
2251 if (type < 0)
2252 gkrellm_sensors_rebuild(DO_TEMP1, DO_FAN1, DO_VOLT1);
2253 else
2254 gkrellm_sensors_rebuild(type == SENSOR_TEMPERATURE0,
2255 type == SENSOR_FAN1, type == SENSOR_VOLTAGE2);
2256
2257 return FALSE(0);
2258 }
2259
2260static void
2261sensor_reset_optionmenu(Sensor *sensor)
2262 {
2263 Sensor *sr;
2264
2265 if (!optionmenu)
2266 return;
2267 sr = get_referenced_sensor();
2268 if (sr == sensor)
2269 gtk_combo_box_set_active(GTK_COMBO_BOX(optionmenu)((((GtkComboBox*) g_type_check_instance_cast ((GTypeInstance*
) ((optionmenu)), ((gtk_combo_box_get_type ()))))))
,
2270 SENSOR_PANEL_LOCATION0);
2271 }
2272
2273static void
2274cb_location_menu(GtkComboBox *om, gpointer data)
2275 {
2276 GList *list;
2277 Sensor *sr, *s;
2278 gchar *pname = NULL((void*)0);
2279 gint location;
2280
2281 location = gtk_combo_box_get_active(om);
2282 sr = get_referenced_sensor();
2283 if (!sr || !sr->enabled || sr->location == location)
2284 return;
2285
2286 /* If trying to relocate, get a dst panel name so can report failures.
2287 */
2288 if (location != SENSOR_PANEL_LOCATION0)
2289 {
2290 if (sr->group == SENSOR_GROUP_MAINBOARD0)
2291 pname = (location == PROC_PANEL_LOCATION1)
2292 ? gkrellm_proc_get_sensor_panel_label()
2293 : gkrellm_cpu_get_sensor_panel_label(
2294 location - CPU_PANEL_LOCATION2);
2295 else if (sr->group == SENSOR_GROUP_DISK1)
2296 pname = _("Disk")dcgettext ("gkrellm", "Disk", 5);
2297 }
2298
2299 /* If moving off some other panel, reset that panel.
2300 */
2301 sensor_reset_location(sr);
2302
2303 /* For mainboard sensor group, if relocating to a panel with some other
2304 | sensor of same type on it, auto restore the other sensor to the sensor
2305 | panel. Disk sensor group should never conflict.
2306 */
2307 sr->location = location;
2308 if ( location != SENSOR_PANEL_LOCATION0
2309 && sr->group == SENSOR_GROUP_MAINBOARD0
2310 )
2311 for (list = sensor_list; list; list = list->next)
2312 {
2313 s = (Sensor *) list->data;
2314 if ( s->group == SENSOR_GROUP_MAINBOARD0
2315 && s != sr
2316 && s->type == sr->type
2317 && s->location == sr->location
2318 )
2319 s->location = SENSOR_PANEL_LOCATION0; /* is being replaced */
2320 }
2321 gkrellm_sensors_rebuild(DO_TEMP1, DO_FAN1, FALSE(0));
2322
2323 if (sr->location != location) /* location failed */
2324 {
2325 gtk_combo_box_set_active(GTK_COMBO_BOX(optionmenu)((((GtkComboBox*) g_type_check_instance_cast ((GTypeInstance*
) ((optionmenu)), ((gtk_combo_box_get_type ()))))))
,
2326 SENSOR_PANEL_LOCATION0);
2327 sensor_relocation_error(pname);
2328 }
2329 }
2330
2331
2332static void
2333create_location_menu(gint group)
2334 {
2335 gint n, n_cpus;
2336
2337 if (group == sensor_last_group)
2338 return;
2339 sensor_last_group = group;
2340
2341 gtk_combo_box_append_text(GTK_COMBO_BOX(optionmenu)((((GtkComboBox*) g_type_check_instance_cast ((GTypeInstance*
) ((optionmenu)), ((gtk_combo_box_get_type ()))))))
, "default");
2342
2343 if (group == SENSOR_GROUP_MAINBOARD0)
2344 {
2345 gtk_combo_box_append_text(GTK_COMBO_BOX(optionmenu)((((GtkComboBox*) g_type_check_instance_cast ((GTypeInstance*
) ((optionmenu)), ((gtk_combo_box_get_type ()))))))
,
2346 gkrellm_proc_get_sensor_panel_label());
2347
2348 n_cpus = gkrellm_smp_cpus() + 1;
2349 for (n = 0; n < n_cpus; ++n)
2350 {
2351 gtk_combo_box_append_text(GTK_COMBO_BOX(optionmenu)((((GtkComboBox*) g_type_check_instance_cast ((GTypeInstance*
) ((optionmenu)), ((gtk_combo_box_get_type ()))))))
,
2352 gkrellm_cpu_get_sensor_panel_label(n));
2353 }
2354 }
2355 else if (group == SENSOR_GROUP_DISK1)
2356 {
2357 gtk_combo_box_append_text(GTK_COMBO_BOX(optionmenu)((((GtkComboBox*) g_type_check_instance_cast ((GTypeInstance*
) ((optionmenu)), ((gtk_combo_box_get_type ()))))))
, _("Disk")dcgettext ("gkrellm", "Disk", 5));
2358 }
2359 g_signal_connect(G_OBJECT(optionmenu), "changed",g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((optionmenu)), (((GType) ((20) << (
2))))))))), ("changed"), (((GCallback) (cb_location_menu))), (
((void*)0)), ((void*)0), (GConnectFlags) 0)
2360 G_CALLBACK(cb_location_menu), NULL)g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((optionmenu)), (((GType) ((20) << (
2))))))))), ("changed"), (((GCallback) (cb_location_menu))), (
((void*)0)), ((void*)0), (GConnectFlags) 0)
;
2361 }
2362
2363static void
2364set_sensor_widget_states(Sensor *s)
2365 {
2366 gboolean f_sensitive = FALSE(0),
2367 o_sensitive = FALSE(0),
2368 p_sensitive = FALSE(0);
2369 gfloat factor = 1.0,
2370 offset = 0.0;
2371 gint location = SENSOR_PANEL_LOCATION0;
2372
2373 if (s && s->enabled)
2374 {
2375 f_sensitive = TRUE(!(0));
2376 if (s->type != SENSOR_FAN1)
2377 {
2378 o_sensitive = TRUE(!(0));
2379 offset = s->offset;
2380 }
2381 factor = s->factor;
2382 if (s->type != SENSOR_VOLTAGE2)
2383 {
2384 location = s->location;
2385 p_sensitive = TRUE(!(0));
2386 }
2387 }
2388 create_location_menu(s ? s->group : 0);
2389 gtk_combo_box_set_active(GTK_COMBO_BOX(optionmenu)((((GtkComboBox*) g_type_check_instance_cast ((GTypeInstance*
) ((optionmenu)), ((gtk_combo_box_get_type ()))))))
, location);
2390 gtk_spin_button_set_value(GTK_SPIN_BUTTON(factor_spin_button)((((GtkSpinButton*) g_type_check_instance_cast ((GTypeInstance
*) ((factor_spin_button)), ((gtk_spin_button_get_type ())))))
)
, factor);
2391 gtk_spin_button_set_value(GTK_SPIN_BUTTON(offset_spin_button)((((GtkSpinButton*) g_type_check_instance_cast ((GTypeInstance
*) ((offset_spin_button)), ((gtk_spin_button_get_type ())))))
)
, offset);
2392 gtk_widget_set_sensitive(optionmenu, p_sensitive);
2393 gtk_widget_set_sensitive(alert_button, f_sensitive);
2394
2395 if (s && s->default_factor == 0.0)
2396 f_sensitive = o_sensitive = FALSE(0);
2397
2398 gtk_widget_set_sensitive(factor_spin_button, f_sensitive);
2399 gtk_widget_set_sensitive(offset_spin_button, o_sensitive);
2400 }
2401
2402static void
2403cb_correction_modified(void)
2404 {
2405 Sensor *s;
2406
2407 s = get_referenced_sensor();
2408 if (!s || !s->enabled)
2409 return;
2410 s->factor = gtk_spin_button_get_value(GTK_SPIN_BUTTON(factor_spin_button)((((GtkSpinButton*) g_type_check_instance_cast ((GTypeInstance
*) ((factor_spin_button)), ((gtk_spin_button_get_type ())))))
)
);
2411 s->offset = gtk_spin_button_get_value(GTK_SPIN_BUTTON(offset_spin_button)((((GtkSpinButton*) g_type_check_instance_cast ((GTypeInstance
*) ((offset_spin_button)), ((gtk_spin_button_get_type ())))))
)
);
2412
2413 if (s->factor == 0)
2414 {
2415 s->factor = s->default_factor;
2416 s->offset = s->default_offset;
2417 gtk_spin_button_set_value(GTK_SPIN_BUTTON(factor_spin_button)((((GtkSpinButton*) g_type_check_instance_cast ((GTypeInstance
*) ((factor_spin_button)), ((gtk_spin_button_get_type ())))))
)
,
2418 s->factor);
2419 gtk_spin_button_set_value(GTK_SPIN_BUTTON(offset_spin_button)((((GtkSpinButton*) g_type_check_instance_cast ((GTypeInstance
*) ((offset_spin_button)), ((gtk_spin_button_get_type ())))))
)
,
2420 s->offset);
2421 }
2422 if (s->type == SENSOR_VOLTAGE2)
2423 draw_voltages(s, FALSE(0));
2424 else
2425 {
2426 gkrellm_cpu_draw_sensors(s);
2427 gkrellm_proc_draw_sensors(s);
2428 draw_temperatures(FALSE(0));
2429 }
2430 }
2431
2432static void
2433cb_tree_selection_changed(GtkTreeSelection *selection, gpointer data)
2434 {
2435 GtkTreeIter iter;
2436 GtkTreeModel *model;
2437 GtkTreePath *path;
2438 Sensor *s;
2439 gint depth;
2440
2441 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
2442 {
2443 change_row_reference(NULL((void*)0), NULL((void*)0));
2444 set_sensor_widget_states(NULL((void*)0));
2445 return;
2446 }
2447 path = gtk_tree_model_get_path(model, &iter);
2448 depth = gtk_tree_path_get_depth(path);
2449 change_row_reference(model, path);
2450 gtk_tree_path_free(path);
2451
2452 if (depth == 1)
2453 {
2454 set_sensor_widget_states(NULL((void*)0));
2455 return;
2456 }
2457 s = get_referenced_sensor();
2458 set_sensor_widget_states(s);
2459 }
2460
2461static void
2462label_edited_cb(GtkCellRendererText *cell, gchar *path_string,
2463 gchar *new_label, gpointer data)
2464 {
2465 GtkTreeModel *model;
2466 GtkTreeIter iter;
2467 GtkTreePath *path;
2468 Sensor *s;
2469
2470 model = sensor_model;
2471 path = gtk_tree_path_new_from_string(path_string);
2472 gtk_tree_model_get_iter(model, &iter, path);
2473 gtk_tree_path_free(path);
2474
2475 gtk_tree_model_get(model, &iter,
2476 SENSOR_COLUMN, &s,
2477 -1);
2478 if (!*new_label)
2479 new_label = s->default_label;
2480
2481 gtk_tree_store_set(GTK_TREE_STORE(model)((((GtkTreeStore*) g_type_check_instance_cast ((GTypeInstance
*) ((model)), ((gtk_tree_store_get_type ()))))))
, &iter,
2482 LABEL_COLUMN, new_label, -1);
2483
2484 if (gkrellm_locale_dup_string(&s->name, new_label, &s->name_locale))
2485 {
2486 gkrellm_sensors_rebuild(s->type == SENSOR_TEMPERATURE0,
2487 s->type == SENSOR_FAN1, s->type == SENSOR_VOLTAGE2);
2488 if (s->alert)
2489 {
2490 g_free(s->alert->name);
2491 s->alert->name = g_strdup(s->name);
2492// gkrellm_reset_alert(s->alert);
2493 }
2494 }
2495 }
2496
2497static void
2498enable_cb(GtkCellRendererText *cell, gchar *path_string, gpointer data)
2499 {
2500 GtkTreeModel *model;
2501 GtkTreeIter iter;
2502 GtkTreePath *path;
2503 Sensor *s;
2504 gboolean enabled;
2505
2506 model = sensor_model;
2507 path = gtk_tree_path_new_from_string(path_string);
2508 gtk_tree_model_get_iter(model, &iter, path);
2509
2510 gtk_tree_model_get(model, &iter,
2511 ENABLE_COLUMN, &enabled,
2512 SENSOR_COLUMN, &s,
2513 -1);
2514 s->enabled = !enabled;
2515 gtk_tree_store_set(GTK_TREE_STORE(model)((((GtkTreeStore*) g_type_check_instance_cast ((GTypeInstance
*) ((model)), ((gtk_tree_store_get_type ()))))))
, &iter,
2516 ENABLE_COLUMN, s->enabled,
2517 -1);
2518 change_row_reference(model, path);
2519 gtk_tree_path_free(path);
2520
2521 gkrellm_sensors_rebuild(s->type == SENSOR_TEMPERATURE0,
2522 s->type == SENSOR_FAN1, s->type == SENSOR_VOLTAGE2);
2523
2524 set_sensor_widget_states(s);
2525 }
2526
2527static void
2528fix_temp_alert(Sensor *s)
2529 {
2530 GkrellmAlert *a = s->alert;
2531
2532 if (s->type != SENSOR_TEMPERATURE0 || !a)
2533 return;
2534 if (units_fahrenheit)
2535 {
2536 if (a->high.warn_limit > 0)
2537 a->high.warn_limit = a->high.warn_limit * 9.0 / 5.0 + 32.0;
2538 if (a->high.alarm_limit > 0)
2539 a->high.alarm_limit = a->high.alarm_limit * 9.0 / 5.0 + 32.0;
2540 }
2541 else
2542 {
2543 if (a->high.warn_limit > 0)
2544 a->high.warn_limit = (a->high.warn_limit - 32.0) * 5.0 / 9.0;
2545 if (a->high.alarm_limit > 0)
2546 a->high.alarm_limit = (a->high.alarm_limit - 32.0) * 5.0 / 9.0;
2547 }
2548 gkrellm_alert_window_destroy(&s->alert);
2549 }
2550
2551static void
2552sysdep_option_cb(GtkWidget *button, SysdepOption *so)
2553 {
2554 if (!so)
2555 return;
2556 so->value = GTK_TOGGLE_BUTTON(button)((((GtkToggleButton*) g_type_check_instance_cast ((GTypeInstance
*) ((button)), ((gtk_toggle_button_get_type ()))))))
->active;
2557 }
2558
2559static void
2560cb_temperature_units(GtkWidget *button, gpointer data)
2561 {
2562 GList *list;
2563 gint units;
2564
2565 units = GTK_TOGGLE_BUTTON(button)((((GtkToggleButton*) g_type_check_instance_cast ((GTypeInstance
*) ((button)), ((gtk_toggle_button_get_type ()))))))
->active;
2566 if (units == units_fahrenheit)
2567 return;
2568 units_fahrenheit = units;
2569
2570 for (list = sensor_list; list; list = list->next)
2571 fix_temp_alert((Sensor *) list->data);
2572
2573 gkrellm_sensors_rebuild(DO_TEMP1, FALSE(0), FALSE(0));
2574 gkrellm_cpu_draw_sensors(NULL((void*)0));
2575 gkrellm_proc_draw_sensors(NULL((void*)0));
2576 }
2577
2578static void
2579cb_show_units(GtkWidget *button, gpointer data)
2580 {
2581 gint show;
2582
2583 show = GTK_TOGGLE_BUTTON(button)((((GtkToggleButton*) g_type_check_instance_cast ((GTypeInstance
*) ((button)), ((gtk_toggle_button_get_type ()))))))
->active;
2584 if (show == show_units)
2585 return;
2586 show_units = show;
2587
2588 gkrellm_sensors_rebuild(DO_TEMP1, FALSE(0), FALSE(0));
2589 gkrellm_cpu_draw_sensors(NULL((void*)0));
2590 gkrellm_proc_draw_sensors(NULL((void*)0));
2591 }
2592
2593static void
2594cb_voltages_display(GtkWidget *entry, gpointer data)
2595 {
2596 gint i;
2597
2598 for (i = 0; i < N_DISPLAY_MODES2; ++i)
2599 if (GTK_TOGGLE_BUTTON(display_mode_button[i])((((GtkToggleButton*) g_type_check_instance_cast ((GTypeInstance
*) ((display_mode_button[i])), ((gtk_toggle_button_get_type (
)))))))
->active)
2600 display_mode = i;
2601 gkrellm_sensors_rebuild(FALSE(0), FALSE(0), DO_VOLT1);
2602 }
2603
2604static void
2605cb_set_alert(GtkWidget *widget, gpointer data)
2606 {
2607 Sensor *s;
2608
2609 s = get_referenced_sensor();
2610 if (!s || !s->enabled)
2611 return;
2612 if (!s->alert)
2613 create_sensor_alert(s);
2614 gkrellm_alert_config_window(&s->alert);
2615 }
2616
2617
2618static void
2619sensors_apply(void)
2620 {
2621 gchar *str;
2622 gint port;
2623
2624 if (mbmon_port_entry)
2625 {
2626 str = gkrellm_gtk_entry_get_text(&mbmon_port_entry);
2627 if (isdigit((unsigned char)*str)((*__ctype_b_loc ())[(int) (((unsigned char)*str))] & (unsigned
short int) _ISdigit)
)
2628 {
2629 port = atoi(str);
2630 if (_GK.mbmon_port != port)
2631 {
2632 if (!gkrellm_sys_sensors_mbmon_port_change(port) && port > 0)
2633 gkrellm_message_dialog(NULL((void*)0),
2634 _("Can't read sensor data from mbmon daemon.\n"dcgettext ("gkrellm", "Can't read sensor data from mbmon daemon.\n"
"Check mbmon port number and '-r' option.\n" "Run gkrellm -d 0x80 for debug output.\n"
, 5)
2635 "Check mbmon port number and '-r' option.\n"dcgettext ("gkrellm", "Can't read sensor data from mbmon daemon.\n"
"Check mbmon port number and '-r' option.\n" "Run gkrellm -d 0x80 for debug output.\n"
, 5)
2636 "Run gkrellm -d 0x80 for debug output.\n")dcgettext ("gkrellm", "Can't read sensor data from mbmon daemon.\n"
"Check mbmon port number and '-r' option.\n" "Run gkrellm -d 0x80 for debug output.\n"
, 5)
);
2637 }
2638 }
2639 }
2640 }
2641
2642static void
2643mbmon_port_entry_activate_cb(GtkWidget *widget, gpointer data)
2644 {
2645 sensors_apply();
2646 }
2647
2648static void
2649cb_config_deleted(gpointer data)
2650 {
2651 treeview = NULL((void*)0);
2652 }
2653
2654static gchar *sensor_info_text0[] =
2655 {
2656 N_("<b>No sensors detected.\n")("<b>No sensors detected.\n"),
2657 "\n",
2658 };
2659
2660static gchar *sensor_info_text1[] =
2661 {
2662N_("<h>Setup\n")("<h>Setup\n"),
2663N_("Enter data scaling factors and offsets for the sensors if the default\n"("Enter data scaling factors and offsets for the sensors if the default\n"
"values are not correct for your motherboard. Do a man gkrellm or\n"
"see the GKrellM README for more information.\n")
2664"values are not correct for your motherboard. Do a man gkrellm or\n"("Enter data scaling factors and offsets for the sensors if the default\n"
"values are not correct for your motherboard. Do a man gkrellm or\n"
"see the GKrellM README for more information.\n")
2665"see the GKrellM README for more information.\n")("Enter data scaling factors and offsets for the sensors if the default\n"
"values are not correct for your motherboard. Do a man gkrellm or\n"
"see the GKrellM README for more information.\n")
,
2666N_("Enter a zero factor and a blank label to restore default values.\n")("Enter a zero factor and a blank label to restore default values.\n"
)
,
2667"\n",
2668N_("Drag and drop sensor rows to change the displayed order.\n")("Drag and drop sensor rows to change the displayed order.\n"
)
,
2669"\n",
2670N_("Temperature offset values must be in centigrade units.\n")("Temperature offset values must be in centigrade units.\n"),
2671"\n",
2672N_("Substitution variables may be used in alert commands.\n")("Substitution variables may be used in alert commands.\n"),
2673N_("\t$s current sensor value.\n")("\t$s current sensor value.\n"),
2674N_("\t$l sensor label.\n")("\t$l sensor label.\n"),
2675 };
2676
2677static void
2678sensors_tab_destroy(GtkWidget *w, gpointer data)
2679 {
2680 optionmenu = NULL((void*)0);
2681 }
2682
2683static void
2684create_sensors_tab(GtkWidget *tab_vbox)
2685 {
2686 GtkWidget *tabs;
2687 GtkWidget *button;
2688 GtkWidget *text;
2689 GtkWidget *vbox, *vbox1, *hbox, *box;
2690 GtkWidget *scrolled;
2691 GtkWidget *image;
2692 GtkWidget *label, *entry;
2693 GtkTreeModel *model;
2694 GtkCellRenderer *renderer;
2695 GList *list;
2696 SysdepOption *so;
2697 gchar buf[32];
2698 gint i;
2699
2700 row_reference = NULL((void*)0);
2701 sensor_last_group = -1;
2702
2703 tabs = gtk_notebook_new();
2704 gtk_notebook_set_tab_pos(GTK_NOTEBOOK(tabs)((((GtkNotebook*) g_type_check_instance_cast ((GTypeInstance*
) ((tabs)), ((gtk_notebook_get_type ()))))))
, GTK_POS_TOP);
2705 gtk_box_pack_start(GTK_BOX(tab_vbox)((((GtkBox*) g_type_check_instance_cast ((GTypeInstance*) ((tab_vbox
)), ((gtk_box_get_type ()))))))
, tabs, TRUE(!(0)), TRUE(!(0)), 0);
2706
2707 g_signal_connect(GTK_OBJECT(tabs), "destroy",g_signal_connect_data ((((((GtkObject*) g_type_check_instance_cast
((GTypeInstance*) ((tabs)), ((gtk_object_get_type ()))))))),
("destroy"), (((GCallback) (sensors_tab_destroy))), (((void*
)0)), ((void*)0), (GConnectFlags) 0)
2708 G_CALLBACK(sensors_tab_destroy), NULL)g_signal_connect_data ((((((GtkObject*) g_type_check_instance_cast
((GTypeInstance*) ((tabs)), ((gtk_object_get_type ()))))))),
("destroy"), (((GCallback) (sensors_tab_destroy))), (((void*
)0)), ((void*)0), (GConnectFlags) 0)
;
2709
2710/* --Setup tab */
2711 vbox = gkrellm_gtk_framed_notebook_page(tabs, _("Setup")dcgettext ("gkrellm", "Setup", 5));
2712 hbox = gtk_hbox_new(FALSE(0), 2);
2713 gtk_box_pack_start(GTK_BOX(vbox)((((GtkBox*) g_type_check_instance_cast ((GTypeInstance*) ((vbox
)), ((gtk_box_get_type ()))))))
, hbox, TRUE(!(0)), TRUE(!(0)), 0);
2714 vbox1 = gtk_vbox_new(FALSE(0), 0);
2715 gtk_box_pack_end(GTK_BOX(hbox)((((GtkBox*) g_type_check_instance_cast ((GTypeInstance*) ((hbox
)), ((gtk_box_get_type ()))))))
, vbox1, FALSE(0), FALSE(0), 5);
2716
2717 scrolled = gtk_scrolled_window_new(NULL((void*)0), NULL((void*)0));
2718 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled)((((GtkScrolledWindow*) g_type_check_instance_cast ((GTypeInstance
*) ((scrolled)), ((gtk_scrolled_window_get_type ()))))))
,
2719 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2720 gtk_box_pack_start(GTK_BOX(hbox)((((GtkBox*) g_type_check_instance_cast ((GTypeInstance*) ((hbox
)), ((gtk_box_get_type ()))))))
, scrolled, TRUE(!(0)), TRUE(!(0)), 0);
2721
2722 model = create_model();
2723 sensor_model = model;
2724
2725 treeview = GTK_TREE_VIEW(gtk_tree_view_new_with_model(model))((((GtkTreeView*) g_type_check_instance_cast ((GTypeInstance*
) ((gtk_tree_view_new_with_model(model))), ((gtk_tree_view_get_type
()))))))
;
2726 gtk_tree_view_set_rules_hint(treeview, TRUE(!(0)));
2727 gtk_tree_view_set_reorderable(treeview, TRUE(!(0)));
2728 g_signal_connect(G_OBJECT(treeview), "drag_begin",g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((treeview)), (((GType) ((20) << (2)
)))))))), ("drag_begin"), (((GCallback) (cb_drag_begin))), ((
(void*)0)), ((void*)0), (GConnectFlags) 0)
2729 G_CALLBACK(cb_drag_begin), NULL)g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((treeview)), (((GType) ((20) << (2)
)))))))), ("drag_begin"), (((GCallback) (cb_drag_begin))), ((
(void*)0)), ((void*)0), (GConnectFlags) 0)
;
2730 g_signal_connect(G_OBJECT(treeview), "drag_end",g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((treeview)), (((GType) ((20) << (2)
)))))))), ("drag_end"), (((GCallback) (cb_drag_end))), (((void
*)0)), ((void*)0), (GConnectFlags) 0)
2731 G_CALLBACK(cb_drag_end), NULL)g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((treeview)), (((GType) ((20) << (2)
)))))))), ("drag_end"), (((GCallback) (cb_drag_end))), (((void
*)0)), ((void*)0), (GConnectFlags) 0)
;
2732 g_signal_connect(G_OBJECT(treeview), "delete_event",g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((treeview)), (((GType) ((20) << (2)
)))))))), ("delete_event"), (((GCallback) (cb_config_deleted)
)), (((void*)0)), ((void*)0), (GConnectFlags) 0)
2733 G_CALLBACK(cb_config_deleted), NULL)g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((treeview)), (((GType) ((20) << (2)
)))))))), ("delete_event"), (((GCallback) (cb_config_deleted)
)), (((void*)0)), ((void*)0), (GConnectFlags) 0)
;
2734
2735 renderer = gtk_cell_renderer_text_new();
2736 gtk_tree_view_insert_column_with_attributes(treeview, -1, _("Sensor")dcgettext ("gkrellm", "Sensor", 5),
2737 renderer,
2738 "text", NAME_COLUMN,
2739 NULL((void*)0));
2740
2741 renderer = gtk_cell_renderer_toggle_new();
2742 gtk_tree_view_insert_column_with_attributes(treeview, -1, _("Enable")dcgettext ("gkrellm", "Enable", 5),
2743 renderer,
2744 "active", ENABLE_COLUMN,
2745 "visible", VISIBLE_COLUMN,
2746 NULL((void*)0));
2747 g_signal_connect(G_OBJECT(renderer), "toggled",g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((renderer)), (((GType) ((20) << (2)
)))))))), ("toggled"), (((GCallback) (enable_cb))), (((void*)
0)), ((void*)0), (GConnectFlags) 0)
2748 G_CALLBACK(enable_cb), NULL)g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((renderer)), (((GType) ((20) << (2)
)))))))), ("toggled"), (((GCallback) (enable_cb))), (((void*)
0)), ((void*)0), (GConnectFlags) 0)
;
2749
2750 renderer = gtk_cell_renderer_text_new();
2751 gtk_tree_view_insert_column_with_attributes(treeview, -1, _("Label")dcgettext ("gkrellm", "Label", 5),
2752 renderer,
2753 "text", LABEL_COLUMN,
2754 "editable", TRUE(!(0)),
2755 "visible", VISIBLE_COLUMN,
2756 NULL((void*)0));
2757 g_signal_connect(G_OBJECT(renderer), "edited",g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((renderer)), (((GType) ((20) << (2)
)))))))), ("edited"), (((GCallback) (label_edited_cb))), (((void
*)0)), ((void*)0), (GConnectFlags) 0)
2758 G_CALLBACK(label_edited_cb), NULL)g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((renderer)), (((GType) ((20) << (2)
)))))))), ("edited"), (((GCallback) (label_edited_cb))), (((void
*)0)), ((void*)0), (GConnectFlags) 0)
;
2759
2760 renderer = gtk_cell_renderer_pixbuf_new();
2761 gtk_tree_view_insert_column_with_attributes(treeview, -1, "",
2762 renderer,
2763 "pixbuf", IMAGE_COLUMN,
2764 NULL((void*)0));
2765
2766
2767 gtk_container_add(GTK_CONTAINER(scrolled)((((GtkContainer*) g_type_check_instance_cast ((GTypeInstance
*) ((scrolled)), ((gtk_container_get_type ()))))))
, GTK_WIDGET(treeview)((((GtkWidget*) g_type_check_instance_cast ((GTypeInstance*) (
(treeview)), ((gtk_widget_get_type ()))))))
);
2768
2769 selection = gtk_tree_view_get_selection(treeview);
2770 gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
2771 g_signal_connect(G_OBJECT(selection), "changed",g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((selection)), (((GType) ((20) << (2
))))))))), ("changed"), (((GCallback) (cb_tree_selection_changed
))), (((void*)0)), ((void*)0), (GConnectFlags) 0)
2772 G_CALLBACK(cb_tree_selection_changed), NULL)g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((selection)), (((GType) ((20) << (2
))))))))), ("changed"), (((GCallback) (cb_tree_selection_changed
))), (((void*)0)), ((void*)0), (GConnectFlags) 0)
;
2773
2774 box = gkrellm_gtk_framed_vbox(vbox1, _("Factor")dcgettext ("gkrellm", "Factor", 5), 4, FALSE(0), 0, 2);
2775 gkrellm_gtk_spin_button(box, &factor_spin_button, 1.0,
2776 -1000.0, 1000.0, 0.01, 1.0, 4, 60,
2777 cb_correction_modified, NULL((void*)0), FALSE(0), NULL((void*)0));
2778
2779 box = gkrellm_gtk_framed_vbox(vbox1, _("Offset")dcgettext ("gkrellm", "Offset", 5), 4, FALSE(0), 0, 2);
2780 gkrellm_gtk_spin_button(box, &offset_spin_button, 0.0,
2781 -10000.0, 10000.0, 1.0, 5.0, 3, 60,
2782 cb_correction_modified, NULL((void*)0), FALSE(0), NULL((void*)0));
2783
2784 box = gkrellm_gtk_framed_vbox(vbox1, _("Location")dcgettext ("gkrellm", "Location", 5), 2, FALSE(0), 0, 2);
2785
2786 optionmenu = gtk_combo_box_new_text();
2787
2788 gtk_box_pack_start(GTK_BOX(box)((((GtkBox*) g_type_check_instance_cast ((GTypeInstance*) ((box
)), ((gtk_box_get_type ()))))))
, optionmenu, FALSE(0), FALSE(0), 4);
2789
2790 box = gtk_hbox_new(FALSE(0), 0);
2791 gtk_container_set_border_width(GTK_CONTAINER(box)((((GtkContainer*) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((gtk_container_get_type ()))))))
, 2);
2792 image = gtk_image_new_from_pixbuf(gkrellm_alert_pixbuf());
2793 label = gtk_label_new(_("Alerts")dcgettext ("gkrellm", "Alerts", 5));
2794 gtk_box_pack_start(GTK_BOX(box)((((GtkBox*) g_type_check_instance_cast ((GTypeInstance*) ((box
)), ((gtk_box_get_type ()))))))
, image, FALSE(0), FALSE(0), 3);
2795 gtk_box_pack_start(GTK_BOX(box)((((GtkBox*) g_type_check_instance_cast ((GTypeInstance*) ((box
)), ((gtk_box_get_type ()))))))
, label, FALSE(0), FALSE(0), 3);
2796 alert_button = gtk_button_new();
2797 g_signal_connect(G_OBJECT(alert_button), "clicked",g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((alert_button)), (((GType) ((20) <<
(2))))))))), ("clicked"), (((GCallback) (cb_set_alert))), ((
(void*)0)), ((void*)0), (GConnectFlags) 0)
2798 G_CALLBACK(cb_set_alert), NULL)g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((alert_button)), (((GType) ((20) <<
(2))))))))), ("clicked"), (((GCallback) (cb_set_alert))), ((
(void*)0)), ((void*)0), (GConnectFlags) 0)
;
2799 gtk_widget_show_all(box);
2800 gtk_container_add(GTK_CONTAINER(alert_button)((((GtkContainer*) g_type_check_instance_cast ((GTypeInstance
*) ((alert_button)), ((gtk_container_get_type ()))))))
, box);
2801 gtk_box_pack_end(GTK_BOX(vbox1)((((GtkBox*) g_type_check_instance_cast ((GTypeInstance*) ((vbox1
)), ((gtk_box_get_type ()))))))
, alert_button, FALSE(0), FALSE(0), 4);
2802
2803// gkrellm_gtk_button_connected(vbox1, &alert_button, FALSE, FALSE, -5,
2804// cb_set_alert, NULL, "Alerts");
2805
2806 set_sensor_widget_states(NULL((void*)0));
2807
2808/* -- Options tab */
2809 vbox = gkrellm_gtk_framed_notebook_page(tabs, _("Options")dcgettext ("gkrellm", "Options", 5));
2810// box = gkrellm_gtk_framed_vbox(vbox, _("Temperatures"), 4, FALSE, 0, 2);
2811 box = gkrellm_gtk_category_vbox(vbox, _("Temperatures")dcgettext ("gkrellm", "Temperatures", 5), 4, 0, TRUE(!(0)));
2812 gkrellm_gtk_check_button_connected(box, &button,
2813 units_fahrenheit, FALSE(0), FALSE(0), 0,
2814 cb_temperature_units, NULL((void*)0),
2815 _("Display fahrenheit")dcgettext ("gkrellm", "Display fahrenheit", 5));
2816 gkrellm_gtk_check_button_connected(box, &button,
2817 show_units, FALSE(0), FALSE(0), 0,
2818 cb_show_units, NULL((void*)0),
2819 _("Show units")dcgettext ("gkrellm", "Show units", 5));
2820 if (!sensor_list)
2821 gtk_widget_set_sensitive(button, FALSE(0));
2822
2823// box = gkrellm_gtk_framed_vbox(vbox, _("Voltages"), 6, FALSE, 0, 2);
2824 box = gkrellm_gtk_category_vbox(vbox, _("Voltages")dcgettext ("gkrellm", "Voltages", 5), 4, 0, TRUE(!(0)));
2825 button = gtk_radio_button_new_with_label(NULL((void*)0),
2826 _("Normal with labels")dcgettext ("gkrellm", "Normal with labels", 5));
2827 gtk_box_pack_start(GTK_BOX(box)((((GtkBox*) g_type_check_instance_cast ((GTypeInstance*) ((box
)), ((gtk_box_get_type ()))))))
, button, FALSE(0), TRUE(!(0)), 0);
2828 display_mode_button[DIGITAL_WITH_LABELS0] = button;
2829 g_signal_connect(G_OBJECT(button), "toggled",g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((button)), (((GType) ((20) << (2)))
)))))), ("toggled"), (((GCallback) (cb_voltages_display))), (
((void*)0)), ((void*)0), (GConnectFlags) 0)
2830 G_CALLBACK(cb_voltages_display), NULL)g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((button)), (((GType) ((20) << (2)))
)))))), ("toggled"), (((GCallback) (cb_voltages_display))), (
((void*)0)), ((void*)0), (GConnectFlags) 0)
;
2831 if (!sensor_list)
2832 gtk_widget_set_sensitive(button, FALSE(0));
2833
2834 button = gtk_radio_button_new_with_label(
2835 gtk_radio_button_get_group(GTK_RADIO_BUTTON (button)((((GtkRadioButton*) g_type_check_instance_cast ((GTypeInstance
*) ((button)), ((gtk_radio_button_get_type ()))))))
),
2836 _("Compact with no labels")dcgettext ("gkrellm", "Compact with no labels", 5));
2837 gtk_box_pack_start(GTK_BOX(box)((((GtkBox*) g_type_check_instance_cast ((GTypeInstance*) ((box
)), ((gtk_box_get_type ()))))))
, button, FALSE(0), TRUE(!(0)), 0);
2838 display_mode_button[DIGITAL_NO_LABELS1] = button;
2839 if (!sensor_list)
2840 gtk_widget_set_sensitive(button, FALSE(0));
2841
2842 if (sysdep_option_list)
2843 {
2844 box = gkrellm_gtk_category_vbox(vbox, _("Options")dcgettext ("gkrellm", "Options", 5), 4, 0, TRUE(!(0)));
2845 for (list = sysdep_option_list; list; list = list->next)
2846 {
2847 so= (SysdepOption *) list->data;
2848 if (so->config_label)
2849 gkrellm_gtk_check_button_connected(box, NULL((void*)0),
2850 so->value, FALSE(0), FALSE(0), 0,
2851 sysdep_option_cb, so,
2852 so->config_label);
2853 }
2854 }
2855
2856 button = display_mode_button[display_mode];
2857 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button)((((GtkToggleButton*) g_type_check_instance_cast ((GTypeInstance
*) ((button)), ((gtk_toggle_button_get_type ()))))))
, TRUE(!(0)));
2858
2859 if (gkrellm_sys_sensors_mbmon_supported())
2860 {
2861 box = gkrellm_gtk_category_vbox(vbox, _("MBmon Daemon Port")dcgettext ("gkrellm", "MBmon Daemon Port", 5),
2862 4, 0, TRUE(!(0)));
2863 label = gtk_label_new("");
2864 gtk_label_set_use_markup(GTK_LABEL(label)((((GtkLabel*) g_type_check_instance_cast ((GTypeInstance*) (
(label)), ((gtk_label_get_type ()))))))
, TRUE(!(0)));
2865 gtk_label_set_markup(GTK_LABEL(label)((((GtkLabel*) g_type_check_instance_cast ((GTypeInstance*) (
(label)), ((gtk_label_get_type ()))))))
,
2866 _("<small>Daemon command must be: <b>mbmon -r -P port</b>\n"dcgettext ("gkrellm", "<small>Daemon command must be: <b>mbmon -r -P port</b>\n"
"where 'port' must match the port number entered here:</small>"
, 5)
2867 "where 'port' must match the port number entered here:</small>")dcgettext ("gkrellm", "<small>Daemon command must be: <b>mbmon -r -P port</b>\n"
"where 'port' must match the port number entered here:</small>"
, 5)
);
2868 gtk_box_pack_start(GTK_BOX(box)((((GtkBox*) g_type_check_instance_cast ((GTypeInstance*) ((box
)), ((gtk_box_get_type ()))))))
, label, FALSE(0), FALSE(0), 0);
2869 hbox = gtk_hbox_new(FALSE(0), 2);
2870 gtk_box_pack_start(GTK_BOX(box)((((GtkBox*) g_type_check_instance_cast ((GTypeInstance*) ((box
)), ((gtk_box_get_type ()))))))
, hbox, TRUE(!(0)), TRUE(!(0)), 0);
2871 entry = gtk_entry_new();
2872 gtk_entry_set_max_length(GTK_ENTRY(entry)((((GtkEntry*) g_type_check_instance_cast ((GTypeInstance*) (
(entry)), ((gtk_entry_get_type ()))))))
, 6);
2873 mbmon_port_entry = entry;
2874 if (_GK.mbmon_port > 0)
2875 {
2876 snprintf(buf, sizeof(buf), "%d", _GK.mbmon_port);
2877 gtk_entry_set_text(GTK_ENTRY(entry)((((GtkEntry*) g_type_check_instance_cast ((GTypeInstance*) (
(entry)), ((gtk_entry_get_type ()))))))
, buf);
2878 }
2879 gtk_box_pack_start(GTK_BOX(hbox)((((GtkBox*) g_type_check_instance_cast ((GTypeInstance*) ((hbox
)), ((gtk_box_get_type ()))))))
, entry, FALSE(0), FALSE(0), 4);
2880 label = gtk_label_new(
2881 _("See the README or do a \"man gkrellm\" for more information.\n")dcgettext ("gkrellm", "See the README or do a \"man gkrellm\" for more information.\n"
, 5)
);
2882 gtk_label_set_justify(GTK_LABEL(label)((((GtkLabel*) g_type_check_instance_cast ((GTypeInstance*) (
(label)), ((gtk_label_get_type ()))))))
, GTK_JUSTIFY_LEFT);
2883 gtk_box_pack_start(GTK_BOX(box)((((GtkBox*) g_type_check_instance_cast ((GTypeInstance*) ((box
)), ((gtk_box_get_type ()))))))
, label, FALSE(0), FALSE(0), 4);
2884
2885 g_signal_connect(G_OBJECT(mbmon_port_entry), "activate",g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((mbmon_port_entry)), (((GType) ((20) <<
(2))))))))), ("activate"), (((GCallback) (mbmon_port_entry_activate_cb
))), (((void*)0)), ((void*)0), (GConnectFlags) 0)
2886 G_CALLBACK(mbmon_port_entry_activate_cb), NULL)g_signal_connect_data ((((((GObject*) g_type_check_instance_cast
((GTypeInstance*) ((mbmon_port_entry)), (((GType) ((20) <<
(2))))))))), ("activate"), (((GCallback) (mbmon_port_entry_activate_cb
))), (((void*)0)), ((void*)0), (GConnectFlags) 0)
;
2887 }
2888
2889/* --Info tab */
2890 vbox = gkrellm_gtk_framed_notebook_page(tabs, _("Info")dcgettext ("gkrellm", "Info", 5));
2891 text = gkrellm_gtk_scrolled_text_view(vbox, NULL((void*)0),
2892 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2893
2894 if (!sensor_list)
2895 for (i = 0; i < sizeof(sensor_info_text0) / sizeof(gchar *); ++i)
2896 gkrellm_gtk_text_view_append(text, _(sensor_info_text0[i])dcgettext ("gkrellm", sensor_info_text0[i], 5));
2897
2898 for (i = 0; i < sizeof(sensor_info_text1) / sizeof(gchar *); ++i)
2899 gkrellm_gtk_text_view_append(text, _(sensor_info_text1[i])dcgettext ("gkrellm", sensor_info_text1[i], 5));
2900
2901 /* Present as instant apply, but still get our apply function called.
2902 */
2903 gkrellm_config_instant_apply(mon_config_sensors);
2904 }
2905
2906GkrellmMonitor *
2907gkrellm_get_sensors_mon(void)
2908 {
2909 return mon_config_sensors;
2910 }
2911
2912static GkrellmMonitor monitor_config_sensors =
2913 {
2914 N_("Sensors")("Sensors"), /* Name, for config tab. */
2915 -1, /* Id, 0 if a plugin */
2916 NULL((void*)0), /* The create function */
2917 NULL((void*)0), /* The update function */
2918 create_sensors_tab, /* The config tab create function */
2919 sensors_apply,
2920
2921 save_sensors_config, /* Save user conifg */
2922 load_sensors_config, /* Load user config */
2923 SENSOR_CONFIG_KEYWORD"sensor", /* config keyword */
2924
2925 NULL((void*)0), /* Undef 2 */
2926 NULL((void*)0), /* Undef 1 */
2927 NULL((void*)0), /* Undef 0 */
2928
2929 0, /* insert_before_id - place plugin before this mon */
2930
2931 NULL((void*)0), /* Handle if a plugin, filled in by GKrellM */
2932 NULL((void*)0) /* path if a plugin, filled in by GKrellM */
2933 };
2934
2935GkrellmMonitor *
2936gkrellm_init_sensors_config_monitor(void)
2937 {
2938 if (!setup_sensor_interface() && !_GK.demo)
2939 return NULL((void*)0);
2940 if (!_GK.client_mode)
2941 use_threads = TRUE(!(0));
2942 sensor_list = g_list_sort(sensor_list, (GCompareFunc) strcmp_sensor_path);
2943 monitor_config_sensors.name = _(monitor_config_sensors.name)dcgettext ("gkrellm", monitor_config_sensors.name, 5);
2944 mon_config_sensors = &monitor_config_sensors;
2945 return &monitor_config_sensors;
2946 }
2947