power.c

Go to the documentation of this file.

/*
 * File Name: power.c
 */

/*
 * This file is part of settings.
 *
 * settings is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * settings is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * Copyright (C) 2008 iRex Technologies B.V.
 * All rights reserved.
 */

//----------------------------------------------------------------------------
// Include Files
//----------------------------------------------------------------------------

// system include files, between < >

#include <gtk/gtk.h>
#include <gdk/gdk.h>

#include <libergtk/ergtk.h>

#include "i18n.h"
#include "log.h"
#include "settings.h"
#include "settings_utils.h"
#include "settings_style.h"
#include "power.h"


//----------------------------------------------------------------------------
// Type Declarations
//----------------------------------------------------------------------------

typedef struct
{
    gboolean standby_if_plugged;
    int minutes_standby;
} PowerSettings;


//----------------------------------------------------------------------------
// Global Constants
//----------------------------------------------------------------------------
#define NUM_STANDBY_MODES   3
#define NUM_STANDBY_TIMES   4 
#define STANDBY_NEVER       (-1)


//----------------------------------------------------------------------------
// Static Variables
//----------------------------------------------------------------------------

static PowerSettings g_orig_power_settings;
static PowerSettings g_cur_power_settings;

static GtkWidget* g_power_settings_window               = NULL;
static GtkWidget* g_plugged_radios[NUM_STANDBY_MODES]   = {NULL, NULL, NULL};
static GtkWidget* g_standby_radios[NUM_STANDBY_TIMES]   = {NULL, NULL, NULL, NULL};

static int        standby_times[NUM_STANDBY_TIMES]      = {15, 30, 45, 60}; // minutes


//============================================================================
// Local Function Definitions
//============================================================================

static GtkWidget* create_auto_shutdown_widgets  (GtkBox* parent);

static void on_plugged_changed              (GtkWidget *widget, gpointer data);
static void on_standby_changed              (GtkWidget *widget, gpointer data);

static void greyout_radio_buttons           (GtkWidget** widget_list, 
                                             gboolean to_grey,
                                             int length );
static gint read_radio_buttons              (GtkWidget** widget_list, int length);

static void init_widgets_with_settings      (void);

static void on_listview_row_activated       (GtkTreeView            *view,
                                             GtkTreePath            *path,
                                             GtkTreeViewColumn      *column,
                                             gpointer               user_data );

static void on_listview_navigate_cursor     (erGtkListView          *er_listview,
                                             erGtkListViewKeyPress  keycode,
                                             gpointer               user_data );

static gboolean on_focus_in                 (GtkWidget* widget, gpointer data );
static gboolean on_focus_out                (GtkWidget* widget, gpointer data );


//============================================================================
// Functions Implementation
//============================================================================

void load_power_settings()
{
    g_orig_power_settings.standby_if_plugged = get_value_bool(GCONF_STANDBY_IF_PLUGGED);
    g_orig_power_settings.minutes_standby    = get_value_int (GCONF_MIN_STANDBY);

    g_cur_power_settings = g_orig_power_settings;
    LOGPRINTF("Loading power settings, done.");
}


void save_power_settings()
{
    if (g_cur_power_settings.standby_if_plugged != g_orig_power_settings.standby_if_plugged)
    {
        set_value_bool(GCONF_STANDBY_IF_PLUGGED, g_cur_power_settings.standby_if_plugged);
    }

    if (g_cur_power_settings.minutes_standby != g_orig_power_settings.minutes_standby)
    {
        set_value_int(GCONF_MIN_STANDBY, g_cur_power_settings.minutes_standby);
    }

    LOGPRINTF("Saving power settings, done.");
}    
    

GtkWidget* create_power_window(GtkWidget* parent)
{
    // create top window
    GtkWidget* top_window = parent;
    gtk_window_maximize(GTK_WINDOW(top_window));
    gtk_window_set_resizable(GTK_WINDOW(top_window), FALSE);
    gtk_container_set_border_width(GTK_CONTAINER(top_window),WINDOW_BORDER_PADDING  );
    gtk_window_set_modal(GTK_WINDOW(top_window), TRUE);

    // top level vbox (vboxtop)
    GtkWidget* vboxtop = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(top_window), vboxtop);

    // add header container the title and subtitle of this settings page
    create_title(GTK_VBOX(vboxtop), _("Settings"), _("Power Management"));
    
    // add the back/exit bar below the title 
    GtkWidget* view = create_settingsview();
    gtk_box_pack_start(GTK_BOX(vboxtop), view, FALSE, FALSE, 0); 
    g_signal_connect(view, "row-activated", G_CALLBACK(on_listview_row_activated), NULL ) ;
    g_signal_connect(view, "navigate-cursor", G_CALLBACK(on_listview_navigate_cursor), NULL ) ;
    g_signal_connect(view, "focus-in-event", G_CALLBACK(on_focus_in), NULL );
    g_signal_connect(view, "focus-out-event", G_CALLBACK(on_focus_out), NULL );
 
    GtkWidget* vbox = GTK_WIDGET( create_frame(GTK_VBOX(vboxtop)) );
    create_auto_shutdown_widgets(GTK_BOX(vbox));


    // Update widget with current settings.
    init_widgets_with_settings();

    g_power_settings_window = top_window;

    gtk_widget_grab_focus(view);

    gtk_widget_show_all(top_window);
    return top_window;
}


//============================================================================
// Local Functions Implementation
//============================================================================

static gboolean on_focus_in(GtkWidget* widget, gpointer data )
{
    g_assert(widget != NULL ) ;
    ergtk_list_view_set_cursor( ERGTK_LIST_VIEW(widget), 0); // row = 0;
    return FALSE;
}


static gboolean on_focus_out(GtkWidget* widget, gpointer data )
{
    g_assert(widget != NULL ) ;
    GtkTreeSelection* my_selection = gtk_tree_view_get_selection((GtkTreeView*) widget);
    g_assert( my_selection != NULL ) ;
    gtk_tree_selection_unselect_all(my_selection);
    return FALSE;
}


static void on_listview_row_activated ( GtkTreeView       *view,
                                        GtkTreePath       *path,
                                        GtkTreeViewColumn *column,
                                        gpointer          user_data )
{
    save_power_settings();
    main_quit();

    return;
}


static void on_listview_navigate_cursor ( erGtkListView         *er_listview,
                                          erGtkListViewKeyPress keycode,
                                          gpointer              user_data )
{
    GtkTreeSelection* my_selection = gtk_tree_view_get_selection((GtkTreeView*) er_listview);
    g_assert( my_selection != NULL ) ;

    // determine new cursor position
    switch (keycode)
    {
        case ERGTK_LIST_VIEW_PRESS_SHORT_DOWN:
        case ERGTK_LIST_VIEW_PRESS_LONG_DOWN:
            gtk_widget_grab_focus(GTK_WIDGET(g_plugged_radios[0])); // down: to first widget
            gtk_tree_selection_unselect_all(my_selection);
            break;
        default:
            LOGPRINTF("illegal erGtkListViewKeyPress [%d]", keycode);
            ;  // ignore
            break;
    }
}


// Widget Hierarchy
// |--Top Level vbox
//    |--title   ("Automatic shutdown")
//    |--subject ("To save power...")
//    |--vbox
//       |--radio never
//       |--radio on
//       |--radio off
//    |--label ("Choose the automatic shutdown time")
//    |--vbox
//       |--radio 15
//       |--radio 30
//       |--radio 45
//       |--radio 60
static GtkWidget* create_auto_shutdown_widgets(GtkBox* parent)
{
    // Top level vbox.
    GtkWidget* top_level_vbox = gtk_vbox_new(FALSE, ITEM_SPACING);
    gtk_box_pack_start(parent, top_level_vbox, FALSE, FALSE, 0);

    // Subject "Automatic Shutdown".
    GtkWidget* subject = subject_create();
    gtk_label_set_label(GTK_LABEL(subject), _("Automatic Shutdown") );
    gtk_box_pack_start(GTK_BOX(top_level_vbox), subject, FALSE, FALSE, 0);

    // Description "To save power..."
    GtkWidget* desc = description_create();
    gtk_label_set_label(GTK_LABEL(desc), _("To save power, automatic shutdown can be enabled.") );    
    gtk_box_pack_start(GTK_BOX(top_level_vbox), desc, FALSE, FALSE, 0);
        
    // The vbox containing radio buttons for plugged.
    GtkWidget* vbox = gtk_vbox_new(TRUE, 0);
    gtk_box_pack_start(GTK_BOX(top_level_vbox), vbox, FALSE, FALSE, 0);
    
    int i = 0;
    for (i=0; i<NUM_STANDBY_MODES; i++)
    {
        switch (i)
        {
            case 0:
            {
                // the radio button "Never"
                g_plugged_radios[i] = gtk_radio_button_new_with_label(NULL, _("Never use automatic shutdown"));
                break;
            }
            case 1:
            {
                // The radio button "Always".
                g_plugged_radios[i] = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(g_plugged_radios[0]), _("Always use automatic shutdown"));
                break;
            }
            case 2:
            {
                // The radio button "Only when running on battery".
                g_plugged_radios[i] = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(g_plugged_radios[1]), _("Only use automatic shutdown when running on battery"));
                break;
            }
            default:
            {
                // never happens
                break;
            }
        }

        // Add signal handler.
        g_signal_connect_after(G_OBJECT(g_plugged_radios[i]),
            "toggled",
            G_CALLBACK(on_plugged_changed),
            (gpointer)i);

        gtk_box_pack_start(GTK_BOX(vbox), g_plugged_radios[i], FALSE, FALSE, 0);

    }

    // Subject "Choose the automatic shutdown time".
    GtkWidget* choose = description_create(NULL);
    gtk_label_set_label(GTK_LABEL(choose), _("Choose the automatic shutdown time:"));
    gtk_box_pack_start(GTK_BOX(top_level_vbox), choose, FALSE, FALSE, 0);

    // The vbox containing radio buttons for minutes.
    vbox = gtk_vbox_new(TRUE, 0);
    gtk_box_pack_start(GTK_BOX(top_level_vbox), vbox, FALSE, FALSE, 0);

    for (i = 0; i < NUM_STANDBY_TIMES; i++)
    {
        // The radio button "after ...".
        // TRANSLATORS: this is an ngettext(3) call which needs a singular and plural translation
        gchar* name = g_strdup_printf(ngettext("after %d minute", "after %d minutes", standby_times[i]), standby_times[i]);
        if (i == 0)
        {
            g_standby_radios[i] = gtk_radio_button_new_with_label(NULL, name);
        }
        else 
        {
            g_standby_radios[i] = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(g_standby_radios[0]), name);
        }
        g_free(name);

        // Add signal handler.
        g_signal_connect_after(G_OBJECT(g_standby_radios[i]),
            "toggled",
            G_CALLBACK(on_standby_changed),
            (gpointer)i);

        gtk_box_pack_start(GTK_BOX(vbox), g_standby_radios[i], FALSE, FALSE, 0);
    }

    return top_level_vbox;
}


static void on_plugged_changed(GtkWidget *widget, gpointer data)
{
    int index = (int)data;
    gboolean is_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));

    if (is_active == TRUE )
    {
        switch (index)
        {
            case 0:
            {
                g_cur_power_settings.minutes_standby = STANDBY_NEVER ; // -1 indicates never
                break;
            }
            case 1:
            {
                g_cur_power_settings.standby_if_plugged =  TRUE;
                break;
            }
            case 2:
            {
                g_cur_power_settings.standby_if_plugged =  FALSE;
            }
            default:
                break;
        }
        
        // minutes
        if (index == 0)
        {
            // greyout minutes
            greyout_radio_buttons(g_standby_radios, TRUE, NUM_STANDBY_TIMES);
        }
        else
        {
            // restore minutes (or read minutes buttons)
            g_cur_power_settings.minutes_standby = 
                standby_times[read_radio_buttons(g_standby_radios, NUM_STANDBY_TIMES)];
            
            // ungreyout minutes
            if ( ! GTK_WIDGET_IS_SENSITIVE(GTK_WIDGET(g_standby_radios[0])))
            {
                greyout_radio_buttons(g_standby_radios, FALSE, NUM_STANDBY_TIMES);
            }
        }
    }
}


static void on_standby_changed(GtkWidget *widget, gpointer data)
{
    int index = (int)data;
    g_cur_power_settings.minutes_standby = standby_times[index];
}


static void greyout_radio_buttons(GtkWidget** widget_list, gboolean to_grey, int length )
{
    int i = 0;
    for ( i = 0; i < length; i++ )
    {
        gtk_widget_set_sensitive(widget_list[i], !to_grey);  // to_grey means set to insensitive
    }
}

static gint read_radio_buttons(GtkWidget** widget_list, int length)
{
    int i = 0;
    for ( i = 0; i < length; i++ )
    {
        if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(widget_list[i])) ) 
            break; 
    }
    return i;
}

static void init_widgets_with_settings()
{
    int i;
    int to_be_activated = 0;

    //Note: first minutes radiobutton, then plugged radiobutton, because of depencency and callbacks
    
    //minutes
    for (i = 0; i < NUM_STANDBY_TIMES; i++)
    {
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_standby_radios[i]), 
                (standby_times[i]==g_cur_power_settings.minutes_standby));
    }
    
    // plugged
    if ( STANDBY_NEVER == g_cur_power_settings.minutes_standby )
    {
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_plugged_radios[0]), TRUE);
        greyout_radio_buttons(g_standby_radios, TRUE, NUM_STANDBY_TIMES);
    }
    else 
    {
        to_be_activated = g_cur_power_settings.standby_if_plugged == TRUE ? 1 : 2;

        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_plugged_radios[to_be_activated]),
                                 TRUE);
    }
}