hello-world/settings/main.c

Go to the documentation of this file.

/*
 * File Name: main.c
 */

/*
 * This file is part of hello-world-settings.
 *
 * hello-world 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.
 *
 * hello-world 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"

// system include files, between < >
#include <glib.h>
#include <gtk/gtk.h>
#include <signal.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

// ereader include files, between < >
#include <libergtk/ergtk.h>
#include <liberutils/gconf_utils.h>

// local include files, between " "
#include "log.h"
#include "i18n.h"
#include "ipc.h"
#include "main.h"
#include "menu.h"
#include "screen_utils.h"


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

typedef enum
        {
            RADIO_FIRST,
            RADIO_SECOND,
            RADIO_THIRD,
            N_RADIO
        } TODO_radioButton_e;

//----------------------------------------------------------------------------
// Constants
//----------------------------------------------------------------------------

static const char  *rc_filename = DATADIR "/" PACKAGE_NAME ".rc";

// registry access
#define GCONF_ROOT              "/apps/er/" PACKAGE
#define GCONF_TODO_ENTRY        GCONF_ROOT "/todo_entry"
#define GCONF_TODO_RADIOBUTTON  GCONF_ROOT "/todo_radiobutton"

// screen layout
static const int        WINDOW_TOP_PADDING      =  40;
static const int        WINDOW_BOTTOM_PADDING   =  20;
static const int        WINDOW_H_PADDING        =  20;
static const int        SCREENITEMS_V_SPACING   =  20;
static const int        SCREENITEMS_H_SPACING   =  20;
static const int        BUTTONS_H_SPACING       =  20;
static const int        ENTRY_LABEL_WIDTH       = 200;

#define WINDOW_MIN_WIDTH  700
#define WINDOW_MIN_HEIGHT 625

#if (WINDOW_MIN_WIDTH * WINDOW_MIN_HEIGHT) < (1024 * 1280 / 3)
#error  Window size must be at least 1/3rd of screen size
#error  this forces display mgr to use a 16 colour (flashing) waveform when the window appears
#endif

// TODO radio-button text
static  struct
        {
            GtkWidget   *widget;                        // screen widget (button)
            const gchar *TODO_radio_button_text;        // text on radio button
            const gchar *TODO_registry_value;           // value stored in registry
        }               g_radio_buttons[N_RADIO]
        =
        {   //widget    button_text       registry_value
            { NULL, N_("<Radio one>"  ), "first-radio-selection"  },
            { NULL, N_("<Radio two>"  ), "second-radio-selection" },
            { NULL, N_("<Radio three>"), "third-radio-selection"  }
        };

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

static GtkWidget        *g_title         = NULL;  // screen title
static GtkWidget        *g_label_TODO    = NULL;  // TODO user input field
static GtkWidget        *g_entry_TODO    = NULL;  // 
static GtkWidget        *g_button_cancel = NULL;  // button "Cancel"
static GtkWidget        *g_button_save   = NULL;  // button "Save"

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

static void     load_settings           ( void );
static void     main_set_text           ( void );
static void     save_settings           ( void );

// signal handlers
static void     on_cancel_clicked       ( GtkButton *button, gpointer user_data );
static gboolean on_focus_out            ( GtkWidget *widget, GdkEventFocus *event, gpointer user_data );
static void     on_save_clicked         ( GtkButton *button, gpointer user_data );
static gboolean on_startup_complete     ( gpointer data );

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

// print usage text and quit
static void usage (const char *argv_0)
{
    static const char *usage_text = 
                        "\n"
                        "usage: %s [options]\n"
                        "\n"
                        "options:\n"
                        "    --help\n"
                        "        Print help text and quit\n";

    printf(usage_text, argv_0);

    exit(1);
}

// get command-line options
static void parse_arguments (int argc, char **argv)
{
    int  i;

    // parse options
    for (i = 1 ; i < argc ; i++)
    {
        if (strcmp(argv[i], "--help") == 0)
        {
            usage(argv[0]);
        }
        else
        {
            ERRORPRINTF("ignore unknown option [%s]", argv[i]);
            usage(argv[0]);
        }
    }
}


// set locale (language)
void main_set_locale (const char *locale)
{
    LOGPRINTF("entry: locale [%s]", locale);

    g_setenv("LANG", locale, TRUE);
    setlocale(LC_ALL, "");

    main_set_text();
    menu_set_text();
}


// create main screen layout
static GtkWidget *create_screen_layout (void)
{
    GtkWidget   *background = NULL;  // return value
    GtkWidget   *widget;
    GtkWidget   *previous;
    GtkWidget   **p_widget;
    GtkBox      *vbox;
    GtkBox      *vbox2;
    GtkBox      *hbox;
    GtkLabel    *label;
    int         i;

    LOGPRINTF("entry");

    // object hierarchy:
    //     background (alignment)
    //       |
    widget = gtk_alignment_new(0.0, 0.0, 1.0, 1.0);
    gtk_alignment_set_padding( GTK_ALIGNMENT(widget),
                               WINDOW_TOP_PADDING,
                               WINDOW_BOTTOM_PADDING,
                               WINDOW_H_PADDING,
                               WINDOW_H_PADDING  );
    gtk_widget_show(widget);
    background = widget;
    //       |
    //       |-- vbox
    //             |
    widget = gtk_vbox_new(FALSE, SCREENITEMS_V_SPACING);
    gtk_container_add(GTK_CONTAINER(background), widget);
    gtk_widget_show(widget);
    vbox = GTK_BOX(widget);
    //             |
    //             |-- g_title
    //             |
    widget = create_screen_title( &g_title );
    gtk_box_pack_start(vbox, widget, FALSE, FALSE, 0);
    //             |
    //             |-- hbox
    //             |     |-- g_label_TODO
    //             |     |-- g_entry_TODO
    //             |
    widget = gtk_hbox_new(FALSE, SCREENITEMS_H_SPACING);
    gtk_box_pack_start(vbox, widget, FALSE, FALSE, 0);
    gtk_widget_show(widget);
    hbox = GTK_BOX(widget);
    //             |
    p_widget = &g_label_TODO;
    widget = gtk_label_new(NULL);
    gtk_widget_set_name(widget, "irex-hello-instruction");
    gtk_widget_set_size_request(widget, ENTRY_LABEL_WIDTH, -1 );
    gtk_box_pack_start(hbox, widget, FALSE, FALSE, 0);
    label = GTK_LABEL(widget);
    gtk_label_set_line_wrap(label, TRUE);
    gtk_label_set_ellipsize(label, PANGO_ELLIPSIZE_NONE);
    gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
    g_signal_connect(widget, "destroy", G_CALLBACK(gtk_widget_destroyed), p_widget);
    gtk_widget_show(widget);
    g_assert(*p_widget == NULL);
    *p_widget = widget;
    //             |
    p_widget = &g_entry_TODO;
    widget = ergtk_entry_new();
    gtk_widget_set_name(widget, "irex-hello-entry");
    gtk_box_pack_end(hbox, widget, TRUE, TRUE, 0);
    g_signal_connect(widget, "destroy", G_CALLBACK(gtk_widget_destroyed), p_widget);
    gtk_widget_show(widget);
    g_assert(*p_widget == NULL);
    *p_widget = widget;
    //             |
    //             |-- separator
    //             |
    widget = create_separator();
    gtk_box_pack_start(vbox, widget, FALSE, FALSE, 0);
    gtk_widget_show(widget);
    //             |
    //             |-- vbox2
    //             |     |-- g_radiobutton_TODO[..].widget
    //             |
    widget = gtk_vbox_new(FALSE, 0);
    gtk_box_pack_start(vbox, widget, FALSE, FALSE, 0);
    gtk_widget_show(widget);
    vbox2 = GTK_BOX(widget);
    //             |
    previous = NULL;
    for (i = 0 ; i < N_RADIO ; i++)
    {
        p_widget = &(g_radio_buttons[i].widget);
        widget = gtk_radio_button_new_with_label_from_widget(
                                                previous ? GTK_RADIO_BUTTON(previous) : NULL,
                                                NULL );
        gtk_box_pack_start(vbox2, widget, FALSE, FALSE, 0);
        g_signal_connect(widget, "destroy", G_CALLBACK(gtk_widget_destroyed), p_widget);
        gtk_widget_show(widget);
        g_assert(*p_widget == NULL);
        *p_widget = widget;

        previous = widget;
    }
    //             |
    //             |-- separator
    //             |
    widget = create_separator();
    gtk_box_pack_start(vbox, widget, FALSE, FALSE, 0);
    gtk_widget_show(widget);
    //             |
    //             |-- filler (event box)
    //             |     Note: filler takes no space itself, but puts buttons at double V spacing
    //             |
    widget = gtk_event_box_new();
    gtk_widget_set_size_request(widget, -1, -1);
    gtk_box_pack_start(vbox, widget, FALSE, FALSE, 0);
    gtk_widget_show(widget);
    //             |
    //             |-- hbox
    //                   |-- g_button_cancel
    //                   |-- g_button_save
    //
    widget = gtk_hbox_new(FALSE, BUTTONS_H_SPACING);
    gtk_box_pack_end(vbox, widget, FALSE, FALSE, 0);
    gtk_widget_show(widget);
    hbox = GTK_BOX(widget);
    //
    p_widget = &g_button_cancel;
    widget = gtk_button_new_with_label(NULL);
    gtk_box_pack_end(hbox, widget, FALSE, FALSE, 0);
    g_signal_connect(widget, "clicked", G_CALLBACK(on_cancel_clicked),    NULL);
    g_signal_connect(widget, "destroy", G_CALLBACK(gtk_widget_destroyed), p_widget);
    gtk_widget_show(widget);
    g_assert(*p_widget == NULL);
    *p_widget = widget;
    //
    p_widget = &g_button_save;
    widget = gtk_button_new_with_label(NULL);
    gtk_box_pack_end(hbox, widget, FALSE, FALSE, 0);
    g_signal_connect(widget, "clicked", G_CALLBACK(on_save_clicked),      NULL);
    g_signal_connect(widget, "destroy", G_CALLBACK(gtk_widget_destroyed), p_widget);
    gtk_widget_show(widget);
    g_assert(*p_widget == NULL);
    *p_widget = widget;

    main_set_text();
    load_settings();
    gtk_widget_grab_focus(g_button_cancel);
    
    return background;
}


// set screen texts
static void main_set_text (void)
{
    int         i;
    GtkWidget   *widget;

    LOGPRINTF("entry");

    if (g_title)
    {
        gtk_label_set_text(GTK_LABEL(g_title), _("Hello world - Settings"));
    }

    if (g_label_TODO)
    {
        gtk_label_set_text(GTK_LABEL(g_label_TODO), _("<your text here>"));
    }

    for (i = 0 ; i < N_RADIO ; i++)
    {
        widget = g_radio_buttons[i].widget;
        if (widget)
        {
            gtk_button_set_label( GTK_BUTTON(widget), _(g_radio_buttons[i].TODO_radio_button_text)  );
        }
    }

    if (g_button_cancel)
    {
        gtk_button_set_label(GTK_BUTTON(g_button_cancel), _("Cancel"));
    }

    if (g_button_save)
    {
        gtk_button_set_label(GTK_BUTTON(g_button_save), _("Save & Close"));
    }
}


// terminate application
void main_quit (void)
{
    WARNPRINTF("entry");
    
    // clean up modules
    menu_destroy();
    ergconf_finalize();

    // clean up widgets
    if (g_main_window)
    {
        gtk_widget_destroy(g_main_window);
        g_main_window = NULL;
    }    
    
    // clean up gtk
    if (gtk_main_level() > 0)
    {
        WARNPRINTF("quit main loop");
        gtk_main_quit();
    }
    else
    {
        WARNPRINTF("no main loop to quit, exit directly");
        _exit(0);
    }
}


// terminate signal
static void on_sigterm (int signo)
{
    WARNPRINTF("    -- entry " PACKAGE_NAME "-settings, my pid [%d]", getpid());

    // stop main process, prepare to quit application
    main_quit();

    WARNPRINTF("    -- leave " PACKAGE_NAME "-settings");
}


// report startup completed
static gboolean on_startup_complete (gpointer data)
{
    LOGPRINTF("entry");

    ipc_sys_startup_complete();

    return FALSE;  // don't call me again
}


// button "cancel" clicked
static void on_cancel_clicked (GtkButton *button, gpointer user_data)
{
    LOGPRINTF("entry");

    main_quit();
}


// button "save" clicked
static void on_save_clicked (GtkButton *button, gpointer user_data)
{
    LOGPRINTF("entry");

    save_settings();
    main_quit();
}


// main window looses focus
static gboolean on_focus_out (GtkWidget *widget, GdkEventFocus *event, gpointer user_data)
{
    LOGPRINTF("entry");

    main_quit();

    return FALSE;
}


// main function
int main (int argc, char *argv[])
{
    GtkWidget        *widget;
    GtkWindow        *window;
    struct sigaction on_term;

    // parse command-line arguments
    parse_arguments(argc, argv);

    // catch the SIGTERM signal
    memset(&on_term, 0x00, sizeof(on_term));
    on_term.sa_handler = on_sigterm;
    sigaction(SIGTERM, &on_term, NULL);
#if LOGGING_ON
    sigaction(SIGINT,  &on_term, NULL);
#endif

    // init domain for translations
    textdomain(GETTEXT_PACKAGE);
    
    // init gtk, list the default rc files
    gtk_init(&argc, &argv);
    gchar** files = gtk_rc_get_default_files();
    while( *files )
    {
        WARNPRINTF("gtk_rc_get_default_files [%s]", *files);
        files++;
    }

    // init GConf library
    ergconf_initialize();

    // init modules
    ipc_set_services();
    menu_init();

    // open the RC file associated with this program
    WARNPRINTF("gtk_rc_parse [%s]", rc_filename);
    gtk_rc_parse(rc_filename);

    // create the top level window 
    widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_widget_set_size_request(widget, WINDOW_MIN_WIDTH, WINDOW_MIN_HEIGHT);
    window = GTK_WINDOW(widget);
    gtk_window_set_type_hint( window, GDK_WINDOW_TYPE_HINT_DIALOG);
    gtk_window_set_title(     window, "");
    gtk_window_set_keep_above(window, TRUE);
    gtk_widget_realize(widget);
    gdk_window_set_decorations(widget->window, GDK_DECOR_BORDER);
    g_signal_connect(window, "focus-out-event", G_CALLBACK (on_focus_out), NULL);
    g_main_window = widget;

    // add screen details
    widget = create_screen_layout();
    gtk_container_add(GTK_CONTAINER(window), widget);

    // make sure everything is visible 
    gtk_widget_show(GTK_WIDGET(window));

    // tell system daemon we are ready to go
    g_idle_add(on_startup_complete, NULL);
    
    // run the main loop
    LOGPRINTF("before gtk_main");
    gtk_main();
    LOGPRINTF("after gtk_main");

    // clean up modules

    return 0;
}


// run error dialog
void run_error_dialog (const gchar *msg)
{
    GtkWidget   *dialog = NULL;

    ERRORPRINTF("entry: msg [%s]", msg);

    dialog = gtk_message_dialog_new( GTK_WINDOW(g_main_window),
                                     GTK_DIALOG_DESTROY_WITH_PARENT,
                                     GTK_MESSAGE_ERROR,
                                     GTK_BUTTONS_OK,
                                     msg );

    gtk_dialog_run( GTK_DIALOG(dialog) );
    gtk_widget_destroy( dialog );
}


// load settings from registry
void load_settings (void)
{
    gchar       *cp;
    gint        i;
    gboolean    b;
    GtkWidget   *widget;

    LOGPRINTF("entry");

    //TODO start
    ERRORPRINTF("Missing implementation: load values from registry");

    // entry field
    if (g_entry_TODO)
    {
        cp = ergconf_get_string( GCONF_TODO_ENTRY );
        LOGPRINTF("GCONF_TODO_ENTRY [%s]", cp);
        gtk_entry_set_text(GTK_ENTRY(g_entry_TODO), cp ? cp : "");
        g_free(cp);
    }

    // radio button
    cp = ergconf_get_string( GCONF_TODO_RADIOBUTTON );
    LOGPRINTF("GCONF_TODO_RADIOBUTTON [%s]", cp);
    for ( i = 0 ; i < N_RADIO ; i++ )
    {
        b = FALSE;
        if ( cp  &&  strcmp(cp, g_radio_buttons[i].TODO_registry_value) == 0 )
        {
            b = TRUE;
        }

        widget = g_radio_buttons[i].widget;
        if (widget)
        {
            gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(widget), b );
        }
    }
    g_free(cp);

    //TODO end
}


// save settings to registry
// Note: no need to compare with old values, just write to registry,
//       GConf compares with current registry values and writes only when needed
void save_settings (void)
{
    const gchar *cp;
    gint        i;
    gboolean    b;
    GtkWidget   *widget;

    LOGPRINTF("entry");

    //TODO start
    ERRORPRINTF("Missing implementation: save values to registry");

    // entry field
    if (g_entry_TODO)
    {
        cp = gtk_entry_get_text( GTK_ENTRY(g_entry_TODO) );
        ergconf_set_string( GCONF_TODO_ENTRY, cp );
    }

    // radio button
    cp = NULL;
    for ( i = 0 ; cp == NULL && i < N_RADIO ; i++ )
    {
        widget = g_radio_buttons[i].widget;
        if (widget)
        {
            b = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(widget) );
            if ( b )
            {
                cp = g_radio_buttons[i].TODO_registry_value;
            }
        }
    }
    if (cp == NULL)
    {
        ERRORPRINTF("none of the g_radio_buttons selected");
        cp = "";
    }
    ergconf_set_string( GCONF_TODO_RADIOBUTTON, cp );

    //TODO end
}