datetime_base.c

Go to the documentation of this file.

/*
 * File Name: datetime_base.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) 2009 iRex Technologies B.V.
 * All rights reserved.
 */

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

#include "config.h"

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

#include <liberutilstime/time_utils.h>

#include "i18n.h"
#include "log.h"
#include "ipc.h"
#include "settings.h"
#include "settings_utils.h"
#include "settings_style.h"
#include "datetime_base.h"

//----------------------------------------------------------------------------
// Global Constants
//----------------------------------------------------------------------------

#define BUF_LEN            256

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

static const GdkColor grey =  {0, 0x5500, 0x5500, 0x5500};
static const GdkColor white = {0, 0xFF00, 0xFF00, 0xFF00};


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

// Functions of creating widgets.
static void create_timezone_widget(DateTimeWidgets * widgets);
static void create_time_widget(DateTimeWidgets * widgets);
static void create_date_widget(DateTimeWidgets * widgets);

static void init_widgets (DateTimeWidgets * widgets, DateTimeSettings * data);

// Signal handlers.

// 
static void install_spinbutton_keypress_handler(DateTimeWidgets * widgets);

// The 'input' and 'output' signal handlers of spin buttons.
static gint on_timezone_input(GtkSpinButton* spin, gdouble* new_val);
static gint on_timezone_output(GtkSpinButton* spin);

static gint on_minutes_output(GtkSpinButton* spin);

static gint on_am_pm_input(GtkSpinButton* spin, gdouble* new_val);
static gint on_am_pm_output(GtkSpinButton* spin);

static gint on_month_input(GtkSpinButton* spin, gdouble* new_val);
static gint on_month_output(GtkSpinButton* spin, DateTimeWidgets* widgets);
static gint on_date_change(GtkSpinButton* spin, DateTimeWidgets* widgets);

static gboolean on_key_pressed(GtkWidget* widget, 
                               GdkEventKey *event, 
                               gpointer user_data);

static void check_clock(DateTimeWidgets * widgets);
static void check_orientation(DateTimeWidgets * widgets);

// Get the datetime user set in the widgets. 
static time_t get_time_from_dialog(DateTimeWidgets * widgets);
static int get_days_of_month(int year, int month);


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

void datetime_base_load_datetime(DateTimeSettings * data)
{
    LOGPRINTF("entry");
    if (data)
    {
        time_t curtime = time(NULL);
        curtime -= curtime % 60; // datetime in minutes

        data->orig_datetime = curtime;
        data->cur_datetime = curtime;
    }
}

gboolean datetime_base_save_datetime(DateTimeWidgets * widgets, 
                                     DateTimeSettings * data)
{
    gboolean ret = FALSE;
    LOGPRINTF("entry");
    
    if (widgets && data)
    {
        // Set timezone and DST.
        gboolean is_dst = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->dst_button));
        GtkAdjustment* adj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(widgets->timezone_button));
        int tzindex = (int)gtk_adjustment_get_value(adj);
        set_timezone(timezones[tzindex].tzname, is_dst);

        // Set time if necessary.
        data->cur_datetime = get_time_from_dialog(widgets);
        if (data->cur_datetime != data->orig_datetime)
        {
            ret = set_date_time(data->cur_datetime);
        }
        else
        {
            ret = TRUE; // nothing to do.
        }
    }
    return ret;
}

// Widget Hierarchy
//    |--vbox
//       |--time
//       |--date
void datetime_base_create_widgets(DateTimeWidgets * widgets,
                                  DateTimeSettings * data)
{
    LOGPRINTF("entry");

    if (widgets && data)
    {
        check_clock(widgets);

        // check the current orientation of the device. 
        // Adjust key behavior accordingly
        check_orientation(widgets);

        // Create widgets.
        widgets->parent = gtk_vbox_new(FALSE, 0);
        create_timezone_widget(widgets);
        create_time_widget(widgets);
        create_date_widget(widgets);

        // Install handlers.
        install_spinbutton_keypress_handler(widgets);
        
        // Init widgets with settings.
        init_widgets(widgets, data);
    }
}

void datetime_base_locale_changed(DateTimeWidgets * widgets, 
        DateTimeSettings * data)
{
    LOGPRINTF("entry");

    struct tm* local_time = localtime(&data->cur_datetime);

    if (widgets->twelve_clock)
    {
        if (local_time->tm_hour < 12)
        {
            gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->am_pm_button), 0);
        }
        else
        {
            gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->am_pm_button), 1);
        }
    }

    gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->month_button), 
                              local_time->tm_mon + 1);
} 

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

static void check_orientation(DateTimeWidgets * widgets)
{
    LOGPRINTF("entry");

    // use sync ipc call to check orientation of device
    widgets->is_portrait = ipc_sys_is_in_portrait_mode();
}

static void check_clock(DateTimeWidgets * widgets)
{
    LOGPRINTF("entry");

    // Set the default value.
    widgets->twelve_clock = FALSE;

    // Construct the list of locales which use 12h clock.
    GList *list = NULL;
    list = g_list_append (list, "en_US");
    list = g_list_append (list, "en_CA");
    list = g_list_append (list, "en_IN");
   
    // Get the current locale.
    const gchar * locale = g_getenv("LANG");
    LOGPRINTF("locale %s", locale);
    if (locale)
    {
        unsigned int i = 0;
        for (i = 0; i < g_list_length(list); i++)
        {
            GList * ptr = g_list_nth(list, i);
            if (g_strncasecmp(ptr->data, locale, strlen(ptr->data)) == 0)
            {
                widgets->twelve_clock = TRUE;
                break;
            }
        }
    }

    g_list_free(list);
}


// Widget Hierarchy
// |--vbox (frame)
//    |--label ("Timezone")
//    |--label (description)
//    |--alignment
//       |--hbox
//          |--widgets->timezone_button
//          |--widgets->dst_button
static void create_timezone_widget(DateTimeWidgets * widgets) 
{
    LOGPRINTF("entry");

    GtkVBox* frame = create_frame(GTK_VBOX(widgets->parent));

    // The label "Timezone".
    widgets->label_timezone = subject_create();
    gtk_box_pack_start(GTK_BOX(frame), widgets->label_timezone, FALSE, FALSE, 0);

    // The label "description".
    widgets->label_timezone_desc = description_create();
    gtk_box_pack_start(GTK_BOX(frame), widgets->label_timezone_desc, FALSE, FALSE, 0);

    // timezone
    widgets->timezone_button = NULL;
    GtkAdjustment* adj;
    adj = (GtkAdjustment *)gtk_adjustment_new(0, 0, TOTAL_TIMEZONES-1, 1.0, 5.0, 0.0);
    widgets->timezone_button = gtk_spin_button_new (adj, 4, 0);
    gtk_spin_button_set_wrap (GTK_SPIN_BUTTON(widgets->timezone_button), TRUE);
    gtk_entry_set_editable (GTK_ENTRY(widgets->timezone_button), FALSE);
    gtk_entry_set_width_chars(GTK_ENTRY(widgets->timezone_button), 40);
    gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(widgets->timezone_button), 
                                     GTK_UPDATE_ALWAYS);
    gtk_widget_modify_text(widgets->timezone_button, GTK_STATE_NORMAL, &grey); 
    gtk_widget_modify_font (widgets->timezone_button, 
            pango_font_description_from_string ("Normal italic 9"));
    g_signal_connect(widgets->timezone_button, "input", 
                    G_CALLBACK(on_timezone_input), NULL) ;
    g_signal_connect(widgets->timezone_button, "output", 
                    G_CALLBACK(on_timezone_output), NULL) ;
    gtk_box_pack_start(GTK_BOX(frame), widgets->timezone_button, FALSE, FALSE, 0);

    // separator
    GtkWidget* separator = create_separator_widgets();
    gtk_widget_set_name(separator, "irex-separator-invisible");
    gtk_box_pack_start(GTK_BOX(frame), separator, FALSE, FALSE, 0);
    
    // dst description
    widgets->label_dst_desc = description_create();
    gtk_box_pack_start(GTK_BOX(frame), widgets->label_dst_desc, TRUE, TRUE, 0);    
    
    // dst checkbox
    widgets->dst_button = gtk_check_button_new_with_label(_("Daylight Savings Time is in effect"));
    gtk_box_pack_start(GTK_BOX(frame), widgets->dst_button, FALSE, FALSE, 0);    
}


// Widget Hierarchy
// |--vbox (frame)
//    |--label ("Time")
//    |--label (description)
//    |--alignment
//       |--hbox
//          |--widgets->hour_button
//          |--widgets->minute_button
//          |--widgets->am_pm_button
static void create_time_widget(DateTimeWidgets * widgets) 
{
    LOGPRINTF("entry");

    GtkVBox* frame = create_frame(GTK_VBOX(widgets->parent));

    // The label "Time".
    widgets->label_time = subject_create();
    gtk_box_pack_start(GTK_BOX(frame), widgets->label_time, FALSE, FALSE, 0);

    // The label "description".
    widgets->label_time_desc = description_create();
    gtk_box_pack_start(GTK_BOX(frame), widgets->label_time_desc, FALSE, FALSE, 0);

    // alignment
    GtkWidget * alignment = gtk_alignment_new(0.0, 0.0, 0.0, 0.0);
    gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 
                              WINDOW_TOP_ALT_PADDING,
                              WINDOW_BOTTOM_PADDING,
                              0,
                              0);
    gtk_box_pack_start(GTK_BOX(frame), alignment, FALSE, FALSE, 0);

    // hbox
    GtkWidget * hbox = gtk_hbox_new(FALSE, SMALL_SPACING * 3);
    gtk_container_add(GTK_CONTAINER(alignment), hbox);

    // hour
    gdouble lower = 0.0;
    gdouble upper = 23.0;
    if (widgets->twelve_clock)
    {
        lower = 1.0;
        upper = 12.0;
    }
    GtkAdjustment* adj;
    adj = (GtkAdjustment *)gtk_adjustment_new(lower, lower, upper, 1.0, 5.0, 0.0);
    widgets->hour_button = gtk_spin_button_new(adj, 4, 0);
    gtk_spin_button_set_wrap (GTK_SPIN_BUTTON(widgets->hour_button), TRUE);
    gtk_entry_set_editable (GTK_ENTRY(widgets->hour_button), FALSE);
    gtk_widget_modify_text(widgets->hour_button, GTK_STATE_NORMAL, &grey); 
    gtk_widget_modify_font(widgets->hour_button, 
                            pango_font_description_from_string ("Normal italic 9"));
    gtk_box_pack_start(GTK_BOX(hbox), widgets->hour_button, FALSE, FALSE, 0);

    // minute
    adj = (GtkAdjustment *) gtk_adjustment_new (0.0, 0.0, 59.0, 1.0, 5.0, 0.0);
    widgets->minute_button = gtk_spin_button_new (adj, 4, 0);
    gtk_spin_button_set_wrap (GTK_SPIN_BUTTON(widgets->minute_button), TRUE);
    gtk_entry_set_editable(GTK_ENTRY(widgets->minute_button), FALSE);
    gtk_widget_modify_text(widgets->minute_button, GTK_STATE_NORMAL, &grey); 
    gtk_widget_modify_font(widgets->minute_button, 
                           pango_font_description_from_string ("Normal italic 9"));
                                
    g_signal_connect(widgets->minute_button, "output", G_CALLBACK(on_minutes_output), NULL);
    gtk_box_pack_start(GTK_BOX(hbox), widgets->minute_button, FALSE, FALSE, 0);

    // am_pm 
    widgets->am_pm_button = NULL;
    if (widgets->twelve_clock)
    {
        adj = (GtkAdjustment *) gtk_adjustment_new (0.0, 0.0, 1.0, 1.0, 1.0, 0.0);
        widgets->am_pm_button = gtk_spin_button_new (adj, 4, 0);
        gtk_spin_button_set_wrap (GTK_SPIN_BUTTON(widgets->am_pm_button), TRUE);
        gtk_entry_set_editable (GTK_ENTRY(widgets->am_pm_button), FALSE);
        gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(widgets->am_pm_button), 
                                         GTK_UPDATE_ALWAYS);
        gtk_widget_modify_text(widgets->am_pm_button, GTK_STATE_NORMAL, &grey); 
        gtk_widget_modify_font (widgets->am_pm_button, 
                pango_font_description_from_string ("Normal italic 9"));
        g_signal_connect(widgets->am_pm_button, "input", 
                        G_CALLBACK(on_am_pm_input), NULL) ;
        g_signal_connect(widgets->am_pm_button, "output", 
                        G_CALLBACK(on_am_pm_output), NULL) ;
        gtk_box_pack_start(GTK_BOX(hbox), widgets->am_pm_button, FALSE, FALSE, 0);
    }
}


// Widget Hierarchy
// |--vbox (frame)
//    |--label ("Date")
//    |--label (description)
//    |--alignment
//       |--hbox
//          |--widgets->day_button
//          |--widgets->month_button
//          |--widgets->year_button
static void create_date_widget(DateTimeWidgets * widgets)
{
    LOGPRINTF("entry");
    
    GtkVBox* frame = create_frame(GTK_VBOX(widgets->parent));

    // The label "Date".
    widgets->label_date = subject_create();
    gtk_box_pack_start(GTK_BOX(frame), widgets->label_date, FALSE, FALSE, 0);

    // The label "description".
    widgets->label_date_desc = description_create();
    gtk_box_pack_start(GTK_BOX(frame), widgets->label_date_desc, FALSE, FALSE, 0);

    // alignment
    GtkWidget * alignment = gtk_alignment_new(0.0, 0.0, 0.0, 0.0);
    gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 
                              WINDOW_TOP_ALT_PADDING,
                              WINDOW_BOTTOM_PADDING,
                              0,
                              0);
    gtk_box_pack_start(GTK_BOX(frame), alignment, FALSE, FALSE, 0);

    // hbox
    GtkWidget * hbox = gtk_hbox_new(FALSE, SMALL_SPACING * 3);
    gtk_container_add(GTK_CONTAINER(alignment), hbox);

    // day
    GtkAdjustment* adj = 
        (GtkAdjustment *) gtk_adjustment_new(0.0, 1.0, 31.0, 1.0, 5.0, 0.0);
    widgets->day_button = gtk_spin_button_new(adj, 4, 0);
    gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(widgets->day_button), TRUE);
    gtk_entry_set_editable(GTK_ENTRY(widgets->day_button), FALSE);
    gtk_widget_modify_text(widgets->day_button, GTK_STATE_NORMAL, &grey); 
    gtk_widget_modify_font (widgets->day_button, 
                            pango_font_description_from_string ("Normal italic 9"));
    gtk_box_pack_start(GTK_BOX(hbox), widgets->day_button, FALSE, FALSE, 0);

    // month
    adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 12.0, 1.0, 5.0, 0.0);
    widgets->month_button = gtk_spin_button_new (adj, 4, 0);
    gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON(widgets->month_button), 
                                       GTK_UPDATE_IF_VALID);
    gtk_spin_button_set_wrap (GTK_SPIN_BUTTON(widgets->month_button), TRUE);
    gtk_entry_set_editable (GTK_ENTRY(widgets->month_button), FALSE);
    gtk_widget_modify_text(widgets->month_button, GTK_STATE_NORMAL, &grey); 
    gtk_widget_modify_font (widgets->month_button, 
            pango_font_description_from_string ("Normal italic 9"));
                
    g_signal_connect(G_OBJECT(widgets->month_button), "input", 
                     G_CALLBACK(on_month_input), NULL);
    g_signal_connect(G_OBJECT(widgets->month_button), "output", 
                     G_CALLBACK(on_month_output), widgets);
    gtk_box_pack_start(GTK_BOX(hbox), widgets->month_button, FALSE, FALSE, 0);

    // year
    adj=(GtkAdjustment*)gtk_adjustment_new(0.0, 1900.0, 9999.0, 1.0, 5.0, 0.0);
    widgets->year_button = gtk_spin_button_new (adj, 4, 0);
    gtk_spin_button_set_wrap (GTK_SPIN_BUTTON(widgets->year_button), TRUE);
    gtk_entry_set_editable (GTK_ENTRY(widgets->year_button), FALSE);
    gtk_widget_modify_text(widgets->year_button, GTK_STATE_NORMAL, &grey); 
    gtk_widget_modify_font(widgets->year_button, 
                            pango_font_description_from_string ("Normal italic 9"));
    g_signal_connect(G_OBJECT(widgets->year_button), "changed", 
                     G_CALLBACK(on_date_change), widgets);
    gtk_box_pack_start(GTK_BOX(hbox), widgets->year_button, FALSE, FALSE, 0);


    // Add hidden button and signal handler.
    // 0003462: firstboot - Initial time & date setting page not full screen
    // This is a workaround for solving the problem of the cursor 
    // on year spinbutton doesn't update when focus out.
    widgets->hidden_button = gtk_button_new();
    gtk_widget_set_size_request(widgets->hidden_button, -1, -1);
    g_object_set(G_OBJECT(widgets->hidden_button), 
                 "focus-on-click", FALSE, NULL);
    gtk_widget_modify_fg(widgets->hidden_button, GTK_STATE_NORMAL, &white); //invisable
    gtk_widget_modify_fg(widgets->hidden_button, GTK_STATE_ACTIVE, &white); //invisable
    gtk_widget_modify_fg(widgets->hidden_button, GTK_STATE_SELECTED, &white); //invisable
    gtk_box_pack_start(GTK_BOX(hbox), widgets->hidden_button, FALSE, FALSE, 0);
}

static void init_widgets(DateTimeWidgets * widgets, DateTimeSettings * data)
{
    LOGPRINTF("entry");

    // Set current timezone and DST.
    gboolean is_dst = FALSE;
    gchar *tzname = get_timezone();
    gint tzindex = get_timezone_index(tzname, &is_dst);
    LOGPRINTF("tzname [%s] tzindex [%d] is_dst [%d]", tzname, tzindex, is_dst);
    g_free(tzname);
    
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->timezone_button), tzindex);
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->dst_button), is_dst);

    // Set current time.
    struct tm* local_time = localtime(&data->cur_datetime);
    if (widgets->twelve_clock)
    {
        if (local_time->tm_hour == 0)
        {
            gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->hour_button), 12);
        }
        else if (local_time->tm_hour <= 12)
        {
            gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->hour_button), 
                                      local_time->tm_hour);
        }
        else
        {
            gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->hour_button), 
                                      local_time->tm_hour - 12); 
        }

        gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->minute_button), 
                                  local_time->tm_min);

        if (local_time->tm_hour < 12)
        {
            gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->am_pm_button), 0);
        }
        else
        {
            gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->am_pm_button), 1);
        }
    }
    else
    {
        gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->hour_button), 
                                  local_time->tm_hour);
        gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->minute_button), 
                                  local_time->tm_min);
    }

    // Set current date.
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->day_button), 
                              local_time->tm_mday);
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->month_button), 
                              local_time->tm_mon + 1);
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->year_button), 
                              local_time->tm_year + 1900);

}

static void install_spinbutton_keypress_handler(DateTimeWidgets * widgets)
{
    LOGPRINTF("entry");

    // Translate the behaviour of 'enter' key as 'Tab'.
    GList * list = NULL;
    list = g_list_append(list, widgets->timezone_button);
    // DST button is added to the list for navigation but it does not connect to 
    // "activate" and "key-press-event" as these are handled by the checkbutton widget
    list = g_list_append(list, widgets->dst_button);
    list = g_list_append(list, widgets->hour_button);
    list = g_list_append(list, widgets->minute_button); 
    if (widgets->twelve_clock)
    {
       list = g_list_append(list, widgets->am_pm_button);
    }
    list = g_list_append(list, widgets->day_button);
    list = g_list_append(list, widgets->month_button); 
    list = g_list_append(list, widgets->year_button);
    
    int spinbuttons_number = g_list_length(list);
    int i = 0;
    for (i = 0; i < (spinbuttons_number - 1); i++)
    {
        GList * spin1 = g_list_nth(list, i);
        GList * spin2 = g_list_nth(list, i + 1);
        
        if (spin1->data != widgets->dst_button)
        {
            g_signal_connect_swapped(spin1->data, "activate",
                G_CALLBACK (gtk_widget_grab_focus), spin2->data);
        }
    }

    GList * spin = g_list_nth(list, spinbuttons_number - 1);
    g_signal_connect_swapped(spin->data, "activate",
                G_CALLBACK (gtk_widget_grab_focus), widgets->hidden_button);

    // Install 'key-press-event' handler.
    for ( i = 0 ; i < spinbuttons_number; i++ )
    {
        spin = g_list_nth(list, i);
        if (spin->data != widgets->dst_button)
        {
            g_signal_connect(spin->data, "key-press-event", 
                G_CALLBACK(on_key_pressed), (gpointer) &widgets->is_portrait); 
        }
    }

    g_list_free(list);
}

static gboolean on_key_pressed(GtkWidget * widget, 
                               GdkEventKey * event, 
                               gpointer user_data)
{
    LOGPRINTF("entry");

    g_assert ( NULL != user_data);

    int keyval = event->keyval ; 
    gboolean in_portrait_mode = *(gboolean*) user_data;

    if ( in_portrait_mode == TRUE)
    {
        switch (keyval)
        {
#if MACHINE_IS_DR1000S || MACHINE_IS_DR1000SW
            case GDK_Up:
                gtk_spin_button_spin((GtkSpinButton*) widget, 
                        GTK_SPIN_STEP_FORWARD, 1.0 );
                break;
            case GDK_Down:

                gtk_spin_button_spin((GtkSpinButton*) widget,
                        GTK_SPIN_STEP_BACKWARD, 1.0 );
                break;
            case GDK_Page_Up:
                gtk_spin_button_spin((GtkSpinButton*) widget, 
                        GTK_SPIN_STEP_FORWARD, 5.0 );
                break;
            case GDK_Page_Down:
                gtk_spin_button_spin((GtkSpinButton*) widget, 
                        GTK_SPIN_STEP_BACKWARD, 5.0 );
                break;
#elif MACHINE_IS_DR800S || MACHINE_IS_DR800SG || MACHINE_IS_DR800SW
            // NOTE the logic here is paradoxal:
            //      Up key is mapped to left flip; left flip is "back/previous/down"
            //      Down key is mapped right flip; right flip is "advance/next/up"
            case GDK_Up:
                gtk_spin_button_spin((GtkSpinButton*) widget,
                        GTK_SPIN_STEP_BACKWARD, 1.0 );
                break;
            case GDK_Down:
                gtk_spin_button_spin((GtkSpinButton*) widget, 
                        GTK_SPIN_STEP_FORWARD, 1.0 );
                break;
            case GDK_Page_Up:
                gtk_spin_button_spin((GtkSpinButton*) widget, 
                        GTK_SPIN_STEP_BACKWARD, 5.0 );
                break;
            case GDK_Page_Down:
                gtk_spin_button_spin((GtkSpinButton*) widget, 
                        GTK_SPIN_STEP_FORWARD, 5.0 );
#else
#error Unhandled machine type
#endif
            default:
                return FALSE;
        }
    }
    else  // landscape mode  -> normal operation
    {
        switch (keyval)
        {
            case GDK_Up:
                gtk_spin_button_spin((GtkSpinButton*) widget, 
                        GTK_SPIN_STEP_FORWARD, 1.0 );
                break;
            case GDK_Down:
                gtk_spin_button_spin((GtkSpinButton*) widget, 
                        GTK_SPIN_STEP_BACKWARD, 1.0 );
                break;
            case GDK_Page_Up:
                gtk_spin_button_spin((GtkSpinButton*) widget, 
                        GTK_SPIN_STEP_FORWARD, 5.0 );
                break;
            case GDK_Page_Down:
                gtk_spin_button_spin((GtkSpinButton*) widget, 
                        GTK_SPIN_STEP_BACKWARD, 5.0 );
                break;
            default:
                return FALSE;
        }
    }
    return TRUE;
}

static gint on_timezone_input(GtkSpinButton* spin, gdouble* new_val)
{
    LOGPRINTF("entry");
    const gchar*   text = gtk_entry_get_text(GTK_ENTRY(spin));
    gboolean found = FALSE;

    gint i;
    for (i = 0; i < TOTAL_TIMEZONES; i++)
    {
        if (g_strcasecmp(text, timezones[i].description) == 0)
        {
            found = TRUE;
            break;
        }
    }

    if (!found)
    {
        *new_val = 0.0;
        return GTK_INPUT_ERROR;
    }
    
    *new_val = (gdouble) i + 1;
    return TRUE;
}

static gint on_timezone_output(GtkSpinButton* spin)
{
    LOGPRINTF("entry");
    GtkAdjustment* adj = gtk_spin_button_get_adjustment (spin);
    int value = (int)gtk_adjustment_get_value (adj);
    gtk_entry_set_text(GTK_ENTRY(spin), timezones[value].description);
    
    return TRUE;
}

static gint on_minutes_output (GtkSpinButton *spin)
{
    GtkAdjustment *adj = gtk_spin_button_get_adjustment (spin);
    int value = (int)gtk_adjustment_get_value (adj);

    gchar* text = g_strdup_printf ("%02d", value);
    gtk_entry_set_text(GTK_ENTRY(spin), text);
    g_free(text);

    return TRUE;
}

static gint on_am_pm_input(GtkSpinButton* spin, gdouble* new_val)
{
   const gchar* text = gtk_entry_get_text(GTK_ENTRY(spin));
   if (g_strncasecmp(text, _("AM"), strlen(_("AM"))) == 0)
   {
       *new_val = 0.0;
   }
   else if (g_strncasecmp(text, _("PM"), strlen(_("PM"))) == 0)
   {
       *new_val = 1.0;
   }
   else
   {
       return GTK_INPUT_ERROR;
   }
   return TRUE;
}

static gint on_am_pm_output(GtkSpinButton* spin)
{
    GtkAdjustment* adj = gtk_spin_button_get_adjustment (spin);
    int value = (int)gtk_adjustment_get_value (adj);
    if (value == 0)
    {
        gtk_entry_set_text(GTK_ENTRY(spin), _("AM"));
    }
    else
    {
        gtk_entry_set_text(GTK_ENTRY(spin), _("PM"));
    }
    return TRUE;
}


static gint on_month_input(GtkSpinButton* spin, gdouble* new_val)
{
    gint     i;
    char     buf[BUF_LEN];
    struct   tm t;
    const gchar*   text = gtk_entry_get_text(GTK_ENTRY(spin));
    gboolean found = FALSE;

    for (i = 0; i < 12; i++)
    {
        t.tm_mon = i;
        strftime(buf, BUF_LEN, "%b", &t);
        if (g_strncasecmp(text, buf, strlen(buf)) == 0)
        {
            found = TRUE;
            break;
        }
    }

    if (!found)
    {
        *new_val = 0.0;
        return GTK_INPUT_ERROR;
    }

    *new_val = (gdouble) i + 1;

    return TRUE;
}

static gint on_month_output(GtkSpinButton* spin, DateTimeWidgets* widgets)
{
    char buf[BUF_LEN];
    struct tm t;

    GtkAdjustment* adj = gtk_spin_button_get_adjustment (spin);
    int value = (int)gtk_adjustment_get_value (adj);
 
    memset(&t, 0, sizeof(struct tm));
    t.tm_mon = value - 1;
    strftime(buf, BUF_LEN, "%b", &t);
    
    if (g_strncasecmp(gtk_entry_get_text(GTK_ENTRY(spin)), buf, strlen(buf)))
    {
        gtk_entry_set_text(GTK_ENTRY(spin), buf);
        gtk_entry_set_width_chars(GTK_ENTRY(spin), strlen(buf));
    } 

    // limit max day according to get_days_of_month
    (void) on_date_change(spin, widgets);
    
    return TRUE;
}

static gint on_date_change(GtkSpinButton* spin, DateTimeWidgets* widgets)
{
    LOGPRINTF("entry");

    // limit max day according to get_days_of_month
    int year = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widgets->year_button));
    int month = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widgets->month_button));
    int ndays = get_days_of_month(year, month);
    gtk_spin_button_set_range( GTK_SPIN_BUTTON(widgets->day_button), 1, (gdouble) ndays );
    
    return TRUE;
}

static time_t get_time_from_dialog(DateTimeWidgets * widgets)
{
    LOGPRINTF("entry");

    int year = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widgets->year_button)) - 1900;
    int month = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widgets->month_button)) - 1;
    int day = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widgets->day_button));
    int hour = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widgets->hour_button));
    if (widgets->twelve_clock)
    {
        if (hour == 12)
        {
            hour = 0;
        }
        int value = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widgets->am_pm_button));
        gboolean is_am = (value == 0);
        if (!is_am)
        {
            hour += 12;
        }
    }
    int minute = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widgets->minute_button));

    struct tm tm_sel;
    memset(&tm_sel, 0, sizeof(struct tm));
    tm_sel.tm_year = year;
    tm_sel.tm_mon  = month;
    tm_sel.tm_mday = day;
    tm_sel.tm_hour = hour;
    tm_sel.tm_min  = minute;

    time_t time = mktime(&tm_sel);
    
    return time;
}

static int get_days_of_month(int year, int month)
{
    LOGPRINTF("entry");
    int day = 0;

    switch (month)
    {
        case 1:
        case 3:
        case 5:
        case 7:
        case 8:
        case 10:
        case 12:
            day = 31; 
            break;
        case 4:
        case 6:
        case 9:
        case 11:
            day = 30;
            break;
        case 2:
            if ((year % 400 == 0) || ((year % 100 != 0) && (year % 4 ==0)))
            {
                day = 29;
            }
            else
            {
                day = 28;
            }
            break;
        default:
            break;
    }

    return day;
}