#include "config.h"
#include "cfg.h"
+#include <hdd.h>
#include "psensor.h"
#include "graph.h"
#include "ui.h"
#include "ui_color.h"
#include "lmsensor.h"
#include "notify_cmd.h"
+#include <pmutex.h>
+#include <pudisks2.h>
#include "slog.h"
#include "ui_pref.h"
#include "ui_graph.h"
#endif
#ifdef HAVE_GTOP
-#include "cpu.h"
+#include <pgtop2.h>
#endif
static const char *program_name;
printf(_("Copyright (C) %s jeanfi@gmail.com\n"
"License GPLv2: GNU GPL version 2 or later "
"<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>\n"
- "This is free software: you are free to change and "
+ "This is free software: you are free to change and"
" redistribute it.\n"
"There is NO WARRANTY, to the extent permitted by law.\n"),
"2010-2014");
" -u, --url=URL the URL of the psensor-server,\n"
" example: http://hostname:3131"));
puts(_(
-" --use-libatasmart use atasmart library for disk monitoring instead of\n"
-" hddtemp daemon"));
- puts(_(
" -n, --new-instance force the creation of a new Psensor application"));
puts("");
}
}
-static void update_measures(struct ui_psensor *ui)
+static void *update_measures(void *data)
{
struct psensor **sensors;
struct config *cfg;
int period;
+ struct ui_psensor *ui;
+ ui = (struct ui_psensor *)data;
cfg = ui->config;
while (1) {
- pthread_mutex_lock(&ui->sensors_mutex);
+ pmutex_lock(&ui->sensors_mutex);
sensors = ui->sensors;
if (!sensors)
- return;
+ pthread_exit(NULL);
update_psensor_values_size(sensors, cfg);
- psensor_list_update_measures(sensors);
+ lmsensor_psensor_list_update(sensors);
#ifdef HAVE_REMOTE_SUPPORT
remote_psensor_list_update(sensors);
#endif
#ifdef HAVE_LIBATIADL
amd_psensor_list_update(sensors);
#endif
+#ifdef HAVE_LIBUDISKS2
+ udisks2_psensor_list_update(sensors);
+#endif
+#ifdef HAVE_GTOP
+ gtop2_psensor_list_update(sensors);
+#endif
+#ifdef HAVE_ATASMART
+ atasmart_psensor_list_update(sensors);
+#endif
+
+ hddtemp_psensor_list_update(sensors);
psensor_log_measures(sensors);
period = cfg->sensor_update_interval;
- pthread_mutex_unlock(&ui->sensors_mutex);
+ pmutex_unlock(&ui->sensors_mutex);
sleep(period);
}
ret = TRUE;
cfg = ui->config;
- pthread_mutex_lock(&ui->sensors_mutex);
+ pmutex_lock(&ui->sensors_mutex);
graph_update(ui->sensors, ui->w_graph, ui->config, ui->main_window);
#ifdef HAVE_UNITY
ui_unity_launcher_entry_update(ui->sensors,
!cfg->unity_launcher_count_disabled,
- cfg->temperature_unit == CELCIUS);
+ cfg->temperature_unit == CELSIUS);
#endif
if (ui->graph_update_interval != cfg->graph_update_interval) {
ret = FALSE;
}
- pthread_mutex_unlock(&ui->sensors_mutex);
+ pmutex_unlock(&ui->sensors_mutex);
if (ret == FALSE)
g_timeout_add(1000 * ui->graph_update_interval,
static void associate_colors(struct psensor **sensors)
{
- /* number of uniq colors */
-#define COLORS_COUNT 8
-
- unsigned int colors[COLORS_COUNT][3] = {
- {0x0000, 0x0000, 0x0000}, /* black */
- {0xffff, 0x0000, 0x0000}, /* red */
- {0x0000, 0x0000, 0xffff}, /* blue */
- {0x0000, 0xffff, 0x0000}, /* green */
-
- {0x7fff, 0x7fff, 0x7fff}, /* grey */
- {0x7fff, 0x0000, 0x0000}, /* dark red */
- {0x0000, 0x0000, 0x7fff}, /* dark blue */
- {0x0000, 0x7fff, 0x0000} /* dark green */
+ GdkRGBA rgba;
+ /* copied from the default colors of the gtk color color
+ * chooser. */
+ const char *default_colors[27] = {
+ "#ef2929", /* Scarlet Red */
+ "#fcaf3e", /* Orange */
+ "#fce94f", /* Butter */
+ "#8ae234", /* Chameleon */
+ "#729fcf", /* Sky Blue */
+ "#ad7fa8", /* Plum */
+ "#e9b96e", /* Chocolate */
+ "#888a85", /* Aluminum 1 */
+ "#eeeeec", /* Aluminum 2 */
+ "#cc0000",
+ "#f57900",
+ "#edd400",
+ "#73d216",
+ "#3465a4",
+ "#75507b",
+ "#c17d11",
+ "#555753",
+ "#d3d7cf",
+ "#a40000",
+ "#ce5c00",
+ "#c4a000",
+ "#4e9a06",
+ "#204a87",
+ "#5c3566",
+ "#8f5902",
+ "#2e3436",
+ "#babdb6"
};
- struct psensor **cur;
int i;
+ struct psensor **cur;
struct color c;
- for (cur = sensors, i = 0; *cur; cur++) {
- color_set(&c,
- colors[i % COLORS_COUNT][0],
- colors[i % COLORS_COUNT][1],
- colors[i % COLORS_COUNT][2]);
+ for (cur = sensors, i = 0; *cur; cur++, i++) {
+ gdk_rgba_parse(&rgba, default_colors[i % 27]);
+ c.red = rgba.red;
+ c.green = rgba.green;
+ c.blue = rgba.blue;
(*cur)->color = config_get_sensor_color((*cur)->id, &c);
}
associate_cb_alarm_raised(struct psensor **sensors, struct ui_psensor *ui)
{
struct psensor **sensor_cur = sensors;
+
while (*sensor_cur) {
struct psensor *s = *sensor_cur;
s->alarm_low_threshold
= config_get_sensor_alarm_low_threshold(s->id);
- if (is_temp_type(s->type) || is_fan_type(s->type)) {
- s->alarm_enabled
+ s->alarm_enabled
= config_get_sensor_alarm_enabled(s->id);
- } else {
- s->alarm_high_threshold = 0;
- s->alarm_enabled = 0;
- }
sensor_cur++;
}
static void associate_preferences(struct psensor **sensors)
{
struct psensor **sensor_cur = sensors;
+
while (*sensor_cur) {
char *n;
struct psensor *s = *sensor_cur;
- s->graph_enabled = config_is_sensor_enabled(s->id);
+ s->graph_enabled = config_is_sensor_graph_enabled(s->id);
n = config_get_sensor_name(s->id);
static void log_init()
{
- char *home, *path, *dir;
+ const char *dir;
+ char *path;
- home = getenv("HOME");
+ dir = get_psensor_user_dir();
- if (!home)
- return ;
-
- dir = malloc(strlen(home)+1+strlen(".psensor")+1);
- sprintf(dir, "%s/%s", home, ".psensor");
- mkdir(dir, 0777);
+ if (!dir)
+ return;
path = malloc(strlen(dir)+1+strlen("log")+1);
sprintf(path, "%s/%s", dir, "log");
log_open(path);
- free(dir);
free(path);
}
static struct option long_options[] = {
- {"use-libatasmart", no_argument, 0, 0},
{"version", no_argument, 0, 'v'},
{"help", no_argument, 0, 'h'},
{"url", required_argument, 0, 'u'},
*/
static void cleanup(struct ui_psensor *ui)
{
- pthread_mutex_lock(&ui->sensors_mutex);
+ pmutex_lock(&ui->sensors_mutex);
log_debug("Cleanup...");
- psensor_cleanup();
-
#ifdef HAVE_NVIDIA
nvidia_cleanup();
#endif
ui_status_cleanup();
- pthread_mutex_unlock(&ui->sensors_mutex);
+ pmutex_unlock(&ui->sensors_mutex);
config_cleanup();
* Creates the list of sensors.
*
* 'url': remote psensor server url, null for local monitoring.
- * 'use_libatasmart': whether the libatasmart must be used.
*/
-static struct psensor **create_sensors_list(const char *url,
- unsigned int use_libatasmart)
+static struct psensor **create_sensors_list(const char *url)
{
struct psensor **sensors;
exit(EXIT_FAILURE);
#endif
} else {
- sensors = get_all_sensors(use_libatasmart, 600);
+ sensors = malloc(sizeof(struct psensor *));
+ *sensors = NULL;
+
+ if (config_is_lmsensor_enabled())
+ lmsensor_psensor_list_append(&sensors, 600);
+
+ if (config_is_hddtemp_enabled())
+ hddtemp_psensor_list_append(&sensors, 600);
+
+#ifdef HAVE_ATASMART
+ if (config_is_libatasmart_enabled())
+ atasmart_psensor_list_append(&sensors, 600);
+#endif
+
#ifdef HAVE_NVIDIA
- sensors = nvidia_psensor_list_add(sensors, 600);
+ if (config_is_nvctrl_enabled())
+ nvidia_psensor_list_append(&sensors, 600);
#endif
#ifdef HAVE_LIBATIADL
- sensors = amd_psensor_list_add(sensors, 600);
+ if (config_is_atiadlsdk_enabled())
+ amd_psensor_list_append(&sensors, 600);
#endif
#ifdef HAVE_GTOP
- sensors = cpu_psensor_list_add(sensors, 600);
+ if (config_is_gtop2_enabled())
+ gtop2_psensor_list_append(&sensors, 600);
+#endif
+#ifdef HAVE_LIBUDISKS2
+ if (config_is_udisks2_enabled())
+ udisks2_psensor_list_append(&sensors, 600);
#endif
}
int main(int argc, char **argv)
{
struct ui_psensor ui;
- GError *error;
- GThread *thread;
- int optc, cmdok, opti, use_libatasmart, new_instance;
+ pthread_t thread;
+ int optc, cmdok, opti, new_instance, ret;
char *url = NULL;
GApplication *app;
textdomain(PACKAGE);
#endif
- use_libatasmart = new_instance = 0;
+ new_instance = 0;
cmdok = 1;
while ((optc = getopt_long(argc, argv, "vhd:u:n", long_options,
&opti)) != -1) {
switch (optc) {
- case 0:
- if (!strcmp(long_options[opti].name, "use-libatasmart"))
- use_libatasmart = 1;
- break;
case 'u':
if (optarg)
url = strdup(optarg);
g_thread_init(NULL);
#endif
+#ifdef HAVE_APPINDICATOR_029
+ /* gdk_thread_enter/leave only used to workaround mutex bug
+ * of appindicator < 0.2.9, so do not call gdk_threads_init
+ * if useless. Calling this function leads to
+ * crash "Attempt to unlock mutex that was not locked" with
+ * GLib 2.41.2 (new checking) probably due to bugs in GTK
+ * itself.
+ */
gdk_threads_init();
+#endif
gtk_init(NULL, NULL);
- pthread_mutex_init(&ui.sensors_mutex, NULL);
+ pmutex_init(&ui.sensors_mutex);
ui.config = config_load();
- psensor_init();
-
- ui.sensors = create_sensors_list(url, use_libatasmart);
+ ui.sensors = create_sensors_list(url);
associate_cb_alarm_raised(ui.sensors, &ui);
if (ui.config->slog_enabled)
ui_enable_alpha_channel(&ui);
- thread = g_thread_create((GThreadFunc) update_measures,
- &ui, TRUE, &error);
+ ret = pthread_create(&thread, NULL, update_measures, &ui);
- if (!thread)
- g_error_free(error);
+ if (ret)
+ log_err(_("Failed to create thread for monitoring sensors"));
ui.graph_update_interval = ui.config->graph_update_interval;
else
initial_window_show(&ui);
+ log_debug("translators: %s\n", _("translator-credits"));
+
/* main loop */
gtk_main();