Merge tag 'upstream/1.0.1'
[psensor-pkg-debian.git] / src / ui.c
index 6d1b509..967f31e 100644 (file)
--- a/src/ui.c
+++ b/src/ui.c
@@ -1,5 +1,5 @@
 /*
 /*
- * Copyright (C) 2010-2012 jeanfi@gmail.com
+ * Copyright (C) 2010-2014 jeanfi@gmail.com
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  * 02110-1301 USA
  */
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  * 02110-1301 USA
  */
+#include <stdlib.h>
+
 #include "cfg.h"
 #include "cfg.h"
+#include "slog.h"
 #include "ui.h"
 #include "ui_graph.h"
 #include "ui_pref.h"
 #include "ui.h"
 #include "ui_graph.h"
 #include "ui_pref.h"
@@ -75,37 +78,38 @@ on_delete_event_cb(GtkWidget *widget, GdkEvent *event, gpointer data)
 
 void ui_show_about_dialog()
 {
 
 void ui_show_about_dialog()
 {
-       gtk_show_about_dialog(NULL,
-                             "comments",
-                             _("Psensor is a GTK+ application for monitoring "
-                               "hardware sensors"),
-                             "copyright",
-                             _("Copyright(c) 2010-2012\njeanfi@gmail.com"),
-                             "logo-icon-name", "psensor",
-                             "program-name", "Psensor",
-                             "title", _("About Psensor"),
-                             "version", VERSION,
-                             "website", PACKAGE_URL,
-                             "website-label", _("Psensor Homepage"),
-                             NULL);
+       gtk_show_about_dialog
+               (NULL,
+                "comments",
+                _("Psensor is a GTK+ application for monitoring hardware "
+                  "sensors"),
+                "copyright",
+                _("Copyright(c) 2010-2014\njeanfi@gmail.com"),
+                "logo-icon-name", "psensor",
+                "program-name", "Psensor",
+                "title", _("About Psensor"),
+                "version", VERSION,
+                "website", PACKAGE_URL,
+                "website-label", _("Psensor Homepage"),
+                NULL);
 }
 
 }
 
-static void cb_about(GtkMenuItem *mi, gpointer data)
+void ui_cb_about(GtkMenuItem *mi, gpointer data)
 {
        ui_show_about_dialog();
 }
 
 {
        ui_show_about_dialog();
 }
 
-static void cb_menu_quit(GtkMenuItem *mi, gpointer data)
+void ui_cb_menu_quit(GtkMenuItem *mi, gpointer data)
 {
        ui_psensor_quit((struct ui_psensor *)data);
 }
 
 {
        ui_psensor_quit((struct ui_psensor *)data);
 }
 
-static void cb_preferences(GtkMenuItem *mi, gpointer data)
+void ui_cb_preferences(GtkMenuItem *mi, gpointer data)
 {
        ui_pref_dialog_run((struct ui_psensor *)data);
 }
 
 {
        ui_pref_dialog_run((struct ui_psensor *)data);
 }
 
-static void cb_sensor_preferences(GtkMenuItem *mi, gpointer data)
+void ui_cb_sensor_preferences(GtkMenuItem *mi, gpointer data)
 {
        struct ui_psensor *ui = data;
 
 {
        struct ui_psensor *ui = data;
 
@@ -122,130 +126,95 @@ void ui_psensor_quit(struct ui_psensor *ui)
        gtk_main_quit();
 }
 
        gtk_main_quit();
 }
 
-static const char *menu_desc =
-"<ui>"
-"  <menubar name='MainMenu'>"
-"    <menu name='Psensor' action='PsensorMenuAction'>"
-"      <menuitem name='Preferences' action='PreferencesAction' />"
-"      <menuitem name='SensorPreferences' action='SensorPreferencesAction' />"
-"      <separator />"
-"      <menuitem name='Quit' action='QuitAction' />"
-"    </menu>"
-"    <menu name='Help' action='HelpMenuAction'>"
-"      <menuitem name='About' action='AboutAction' />"
-"    </menu>"
-"  </menubar>"
-"</ui>";
-
-static GtkActionEntry entries[] = {
-       { "PsensorMenuAction", NULL, "_Psensor" },
-
-       { "PreferencesAction", GTK_STOCK_PREFERENCES,
-         N_("_Preferences"), NULL,
-         N_("Preferences"),
-         G_CALLBACK(cb_preferences) },
-
-       { "SensorPreferencesAction", GTK_STOCK_PREFERENCES,
-         N_("_Sensor Preferences"), NULL,
-         N_("Sensor Preferences"),
-         G_CALLBACK(cb_sensor_preferences) },
-
-       { "QuitAction",
-         GTK_STOCK_QUIT, N_("_Quit"), NULL, N_("Quit"),
-         G_CALLBACK(cb_menu_quit) },
-
-       { "HelpMenuAction", NULL, "_Help" },
-
-       { "AboutAction", GTK_STOCK_PREFERENCES,
-         N_("_About"), NULL,
-         N_("About"),
-         G_CALLBACK(cb_about) }
-};
-static guint n_entries = G_N_ELEMENTS(entries);
-
-static GtkWidget *get_menu(struct ui_psensor *ui)
+void ui_enable_alpha_channel(struct ui_psensor *ui)
 {
 {
-       GtkActionGroup      *action_group;
-       GtkUIManager        *menu_manager;
-       GError              *error;
-
-       action_group = gtk_action_group_new("PsensorActions");
-       gtk_action_group_set_translation_domain(action_group, PACKAGE);
-       menu_manager = gtk_ui_manager_new();
-
-       gtk_action_group_add_actions(action_group, entries, n_entries, ui);
-       gtk_ui_manager_insert_action_group(menu_manager, action_group, 0);
+       GdkScreen *screen;
+       GdkVisual *visual;
+       struct config *cfg;
 
 
-       error = NULL;
-       gtk_ui_manager_add_ui_from_string(menu_manager, menu_desc, -1, &error);
+       cfg = ui->config;
 
 
-       if (error)
-               g_error(_("building menus failed: %s"), error->message);
+       screen = gtk_widget_get_screen(ui->main_window);
 
 
-       return gtk_ui_manager_get_widget(menu_manager, "/MainMenu");
+       log_debug("Config alpha channel enabled: %d",
+                 cfg->alpha_channel_enabled);
+       if (cfg->alpha_channel_enabled && gdk_screen_is_composited(screen)) {
+               log_debug("Screen is composited");
+               visual = gdk_screen_get_rgba_visual(screen);
+               if (visual) {
+                       gtk_widget_set_visual(ui->main_window, visual);
+               } else {
+                       cfg->alpha_channel_enabled = 0;
+                       log_err("Enable alpha channel has failed");
+               }
+       } else {
+               cfg->alpha_channel_enabled = 0;
+       }
 }
 
 }
 
-static unsigned int enable_alpha_channel(GtkWidget *w)
+static void
+slog_enabled_cbk(GConfClient *client, guint id, GConfEntry *e, gpointer data)
 {
 {
-       GdkScreen *screen = gtk_widget_get_screen(w);
+       struct ui_psensor *ui;
+       struct psensor **sensors;
+       pthread_mutex_t *mutex;
 
 
-#if (GTK_CHECK_VERSION(3, 0, 0))
-       GdkVisual *visual = gdk_screen_get_rgba_visual(screen);
+       ui = (struct ui_psensor *)data;
+       sensors = ui->sensors;
+       mutex = &ui->sensors_mutex;
 
 
-       if (visual) {
-               gtk_widget_set_visual(w, visual);
-               return 1;
-       }
-#else
-       GdkColormap *colormap = gdk_screen_get_rgba_colormap(screen);
+       log_debug("slog_enabled_cbk");
 
 
-       if (colormap) {
-               gtk_widget_set_colormap(w, colormap);
-               return 1;
-       }
-#endif
-       return 0;
+       if (is_slog_enabled())
+               slog_activate(NULL, sensors, mutex, config_get_slog_interval());
+       else
+               slog_close();
 }
 
 void ui_window_create(struct ui_psensor *ui)
 {
 }
 
 void ui_window_create(struct ui_psensor *ui)
 {
-       GtkWidget *window, *menubar;
-       GdkScreen *screen;
+       GtkWidget *window;
        GdkPixbuf *icon;
        GtkIconTheme *icon_theme;
        struct config *cfg;
        GdkPixbuf *icon;
        GtkIconTheme *icon_theme;
        struct config *cfg;
+       guint ok;
+       GtkBuilder *builder;
+       GError *error;
 
 
-       window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+       builder = gtk_builder_new();
+
+       error = NULL;
+       ok = gtk_builder_add_from_file
+               (builder,
+                PACKAGE_DATA_DIR G_DIR_SEPARATOR_S "psensor.glade",
+                &error);
+
+       if (!ok) {
+               log_printf(LOG_ERR, error->message);
+               g_error_free(error);
+               return ;
+       }
 
 
+       window = GTK_WIDGET(gtk_builder_get_object(builder, "window"));
+       gtk_builder_connect_signals(builder, ui);
        cfg = ui->config;
        if (cfg->window_restore_enabled)
                gtk_window_move(GTK_WINDOW(window),
                                cfg->window_x,
                                cfg->window_y);
 
        cfg = ui->config;
        if (cfg->window_restore_enabled)
                gtk_window_move(GTK_WINDOW(window),
                                cfg->window_x,
                                cfg->window_y);
 
+       config_slog_enabled_notify_add(slog_enabled_cbk, ui);
+
        gtk_window_set_default_size(GTK_WINDOW(window),
                                    cfg->window_w,
                                    cfg->window_h);
 
        gtk_window_set_default_size(GTK_WINDOW(window),
                                    cfg->window_w,
                                    cfg->window_h);
 
-       gtk_window_set_title(GTK_WINDOW(window),
-                            _("Psensor - Temperature Monitor"));
-       gtk_window_set_role(GTK_WINDOW(window), "psensor");
-
-       screen = gtk_widget_get_screen(window);
-
-       if (cfg->alpha_channel_enabled && gdk_screen_is_composited(screen)) {
-               if (!enable_alpha_channel(window))
-                       cfg->alpha_channel_enabled = 0;
-       } else {
-               cfg->alpha_channel_enabled = 0;
-       }
-
        icon_theme = gtk_icon_theme_get_default();
        icon = gtk_icon_theme_load_icon(icon_theme, "psensor", 48, 0, NULL);
        if (icon)
                gtk_window_set_icon(GTK_WINDOW(window), icon);
        else
        icon_theme = gtk_icon_theme_get_default();
        icon = gtk_icon_theme_load_icon(icon_theme, "psensor", 48, 0, NULL);
        if (icon)
                gtk_window_set_icon(GTK_WINDOW(window), icon);
        else
-               fprintf(stderr, _("ERROR: Failed to load psensor icon.\n"));
+               log_err(_("Failed to load Psensor icon."));
 
        g_signal_connect(window,
                         "delete_event", G_CALLBACK(on_delete_event_cb), ui);
 
        g_signal_connect(window,
                         "delete_event", G_CALLBACK(on_delete_event_cb), ui);
@@ -256,20 +225,34 @@ void ui_window_create(struct ui_psensor *ui)
        gtk_window_set_keep_below(GTK_WINDOW(window),
                                  cfg->window_keep_below_enabled);
 
        gtk_window_set_keep_below(GTK_WINDOW(window),
                                  cfg->window_keep_below_enabled);
 
-       /* main box */
-       menubar = get_menu(ui);
-
-       ui->main_box = gtk_vbox_new(FALSE, 1);
-
-       gtk_box_pack_start(GTK_BOX(ui->main_box), menubar,
-                          FALSE, TRUE, 0);
-
-       gtk_container_add(GTK_CONTAINER(window), ui->main_box);
-
+       ui->menu_bar = GTK_WIDGET(gtk_builder_get_object(builder, "menu_bar"));
+       ui->main_box = GTK_WIDGET(gtk_builder_get_object(builder, "main_box"));
+       ui->popup_menu = GTK_WIDGET(gtk_builder_get_object(builder,
+                                                          "popup_menu"));
+       g_object_ref(G_OBJECT(ui->popup_menu));
        ui->main_window = window;
        ui->main_window = window;
-       ui->menu_bar = menubar;
-
+       ui->w_graph = GTK_WIDGET(gtk_builder_get_object(builder,
+                                                       "graph"));
+       ui_graph_create(ui);
+
+       ui->sensor_box = GTK_PANED(gtk_builder_get_object(builder,
+                                                         "sensor_box"));
+       ui->sensors_store = GTK_LIST_STORE(gtk_builder_get_object
+                                          (builder, "sensors_store"));
+       ui->sensors_tree = GTK_TREE_VIEW(gtk_builder_get_object
+                                        (builder, "sensors_tree"));
+       ui->sensors_scrolled_tree
+               = GTK_SCROLLED_WINDOW(gtk_builder_get_object
+                                     (builder, "sensors_scrolled_tree"));
+
+       ui_sensorlist_create(ui);
+
+       log_debug("ui_window_create(): show_all");
        gtk_widget_show_all(ui->main_box);
        gtk_widget_show_all(ui->main_box);
+
+       g_object_unref(G_OBJECT(builder));
+
+       log_debug("ui_window_create() ends");
 }
 
 static void menu_bar_show(unsigned int show, struct ui_psensor *ui)
 }
 
 static void menu_bar_show(unsigned int show, struct ui_psensor *ui)
@@ -283,53 +266,55 @@ static void menu_bar_show(unsigned int show, struct ui_psensor *ui)
 void ui_window_update(struct ui_psensor *ui)
 {
        struct config *cfg;
 void ui_window_update(struct ui_psensor *ui)
 {
        struct config *cfg;
-       int init = 1;
 
 
-       cfg = ui->config;
+       log_debug("ui_window_update()");
 
 
-       if (ui->sensor_box) {
-               g_object_ref(GTK_WIDGET(ui->ui_sensorlist->widget));
+       cfg = ui->config;
 
 
-               gtk_container_remove(GTK_CONTAINER(ui->sensor_box),
-                                    ui->ui_sensorlist->widget);
+       g_object_ref(GTK_WIDGET(ui->sensors_scrolled_tree));
+       g_object_ref(GTK_WIDGET(ui->w_graph));
 
 
-               gtk_container_remove(GTK_CONTAINER(ui->main_box),
-                                    ui->sensor_box);
+       gtk_container_remove(GTK_CONTAINER(ui->sensor_box),
+                            GTK_WIDGET(ui->sensors_scrolled_tree));
 
 
-               ui->w_graph = ui_graph_create(ui);
+       gtk_container_remove(GTK_CONTAINER(ui->sensor_box), ui->w_graph);
 
 
-               init = 0;
-       }
+       gtk_container_remove(GTK_CONTAINER(ui->main_box),
+                            GTK_WIDGET(ui->sensor_box));
 
        if (cfg->sensorlist_position == SENSORLIST_POSITION_RIGHT
            || cfg->sensorlist_position == SENSORLIST_POSITION_LEFT)
 
        if (cfg->sensorlist_position == SENSORLIST_POSITION_RIGHT
            || cfg->sensorlist_position == SENSORLIST_POSITION_LEFT)
-               ui->sensor_box = gtk_hpaned_new();
+               ui->sensor_box
+                       = GTK_PANED(gtk_paned_new(GTK_ORIENTATION_HORIZONTAL));
        else
        else
-               ui->sensor_box = gtk_vpaned_new();
+               ui->sensor_box
+                       = GTK_PANED(gtk_paned_new(GTK_ORIENTATION_VERTICAL));
 
 
-       gtk_box_pack_end(GTK_BOX(ui->main_box), ui->sensor_box, TRUE, TRUE, 2);
+       gtk_box_pack_end(GTK_BOX(ui->main_box),
+                        GTK_WIDGET(ui->sensor_box), TRUE, TRUE, 2);
 
        if (cfg->sensorlist_position == SENSORLIST_POSITION_RIGHT
            || cfg->sensorlist_position == SENSORLIST_POSITION_BOTTOM) {
 
        if (cfg->sensorlist_position == SENSORLIST_POSITION_RIGHT
            || cfg->sensorlist_position == SENSORLIST_POSITION_BOTTOM) {
-               gtk_paned_pack1(GTK_PANED(ui->sensor_box),
+               gtk_paned_pack1(ui->sensor_box,
                                GTK_WIDGET(ui->w_graph), TRUE, TRUE);
                                GTK_WIDGET(ui->w_graph), TRUE, TRUE);
-               gtk_paned_pack2(GTK_PANED(ui->sensor_box),
-                               ui->ui_sensorlist->widget, FALSE, TRUE);
+               gtk_paned_pack2(ui->sensor_box,
+                               GTK_WIDGET(ui->sensors_scrolled_tree),
+                               FALSE, TRUE);
        } else {
        } else {
-               gtk_paned_pack1(GTK_PANED(ui->sensor_box),
-                               ui->ui_sensorlist->widget, FALSE, TRUE);
-               gtk_paned_pack2(GTK_PANED(ui->sensor_box),
+               gtk_paned_pack1(ui->sensor_box,
+                               GTK_WIDGET(ui->sensors_scrolled_tree),
+                               FALSE, TRUE);
+               gtk_paned_pack2(ui->sensor_box,
                                GTK_WIDGET(ui->w_graph), TRUE, TRUE);
        }
 
        if (cfg->window_restore_enabled)
                                GTK_WIDGET(ui->w_graph), TRUE, TRUE);
        }
 
        if (cfg->window_restore_enabled)
-               gtk_paned_set_position(GTK_PANED(ui->sensor_box),
-                                      ui->config->window_divider_pos);
+               gtk_paned_set_position(ui->sensor_box, cfg->window_divider_pos);
 
 
-       if (!init)
-               g_object_unref(GTK_WIDGET(ui->ui_sensorlist->widget));
+       g_object_unref(GTK_WIDGET(ui->sensors_scrolled_tree));
+       g_object_unref(GTK_WIDGET(ui->w_graph));
 
 
-       gtk_widget_show_all(ui->sensor_box);
+       gtk_widget_show_all(GTK_WIDGET(ui->sensor_box));
 
        if (cfg->menu_bar_disabled)
                menu_bar_show(0, ui);
 
        if (cfg->menu_bar_disabled)
                menu_bar_show(0, ui);
@@ -340,5 +325,33 @@ void ui_window_update(struct ui_psensor *ui)
 void ui_window_show(struct ui_psensor *ui)
 {
        log_debug("ui_window_show()");
 void ui_window_show(struct ui_psensor *ui)
 {
        log_debug("ui_window_show()");
+       ui_window_update(ui);
        gtk_window_present(GTK_WINDOW(ui->main_window));
 }
        gtk_window_present(GTK_WINDOW(ui->main_window));
 }
+
+static int cmp_sensors(const void *p1, const void *p2)
+{
+       const struct psensor *s1, *s2;
+       int pos1, pos2;
+
+       s1 = *(void **)p1;
+       s2 = *(void **)p2;
+
+       pos1 = config_get_sensor_position(s1->id);
+       pos2 = config_get_sensor_position(s2->id);
+
+       return pos1 - pos2;
+}
+
+struct psensor **ui_get_sensors_ordered_by_position(const struct ui_psensor *ui)
+{
+       struct psensor **result;
+
+       result = psensor_list_copy(ui->sensors);
+       qsort(result,
+             psensor_list_size(result),
+             sizeof(struct psensor *),
+             cmp_sensors);
+
+       return result;
+}