contentLister/src/main.c File Reference

#include <config.h>
#include <gtk/gtk.h>
#include <libermanifest/ermanifest.h>
#include <liberregxml/erregapi.h>
#include <liberdm/display.h>
#include "contentListerLog.h"
#include "erConnect.h"
#include "system.h"
#include "gtkPincodeScreen.h"
#include "control.h"
#include "erbusy.h"
#include "languages.h"
#include "click.h"

Go to the source code of this file.

Functions
static void	load_registry (void)
static void	release_registry (void)
void	reload_registry (void)
void	prepare_registry_write (void)
static void	usage (const char *argv_0)
static void	parse_arguments (int argc, char **argv)
startup_behaviour_t	main_get_startup_behaviour (void)
void	do_registry_write (void)
static void	on_destroy (GtkWidget *widget, gpointer data)
int	main (int argc, char *argv[])
Variables
static startup_behaviour_t	g_startup_behaviour = behaviourUndefined_t
struct {
const char *   argv
const startup_behaviour_t   behaviour
}	g_startup_locations []

---

Function Documentation

void do_registry_write

(

void

)

Definition at line 279 of file main.c.

{
    gboolean       b;
    
    // verify write lock
    g_assert(lock_write == erRegGetLockState());
    
    // save registry
    b = erRegStore();
    if (b == FALSE)
    {
        CL_ERRORPRINTF("erRegStore fails with return code [%d]", b);
    }

    // release lock
    erRegUnlock();
}

Here is the call graph for this function:

static void load_registry

(

void

)

[static]

Definition at line 77 of file main.c.

{
    static gboolean firsttime = TRUE;

    gboolean       b;
    regLoad_t      regLoad;
    
    // init registry locking
    b = erRegRWLockInit();
    if (b == FALSE)
    {
        CL_ERRORPRINTF("erRegRWLockInit fails with return code [%d]", b);
        g_assert_not_reached();
    }

    if (firsttime)
    {
        // acquire write lock to force recovery, if needed
        b = erRegWriteLock();
        if (b == FALSE)
        {
            CL_ERRORPRINTF("erRegWriteLock fails with return code [%d]", b);
            g_assert_not_reached();
        }

        // load network profiles, so these will be recovered if needed
        regLoad = erRegLoad(regNWProfiles_t);
        if (regLoad != loadOk_t)
        {
            CL_WARNPRINTF("erRegLoad(regNWProfiles_t) returns [%d]", regLoad);
            if (regLoad == loadError_t)
            {
                CL_ERRORPRINTF("erRegLoad(regNWProfiles_t) fails with return code [%d]", regLoad);
                g_assert_not_reached();
            }
        }
        // release network profiles, contentLister does not use them
        erRegUnload(regNWProfiles_t);
    }
    else
    {
        // acquire read-only lock
        b = erRegReadLock();
        if (b == FALSE)
        {
            CL_ERRORPRINTF("erRegReadLock fails with return code [%d]", b);
            g_assert_not_reached();
        }
    }
    
    // load registry sections used
    regLoad = erRegLoad(regBasis_t);
    if (regLoad == loadError_t)
    {
        CL_ERRORPRINTF("erRegLoad(regBasis_t) fails with return code [%d]", regLoad);
        g_assert_not_reached();
    }
    
    // release lock, all data now in memory
    erRegUnlock();

    firsttime = FALSE;
}

Here is the call graph for this function:

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 312 of file main.c.

{
    GtkWidget *window;
    ContentLister *theContentLister;

    parse_arguments(argc, argv);

    /* init threads */
    g_thread_init(NULL);
    gdk_threads_init();
    gdk_threads_enter();

    // open the RC file associate with this program
    gtk_rc_parse(DATA_DIR "/contentLister.rc");
    CL_LOGPRINTF("rc file %s", DATA_DIR "/contentLister.rc");

    gtk_init(&argc, &argv);

    gchar** files = gtk_rc_get_default_files();
    while( *files )
    {
        CL_WARNPRINTF("gtk_rc_get_default_files [%s]", *files);
        files++;
    }

    
#ifdef ENABLE_LOGGING
    erlog_write_start();
    erlog_event_system(power_on);
#endif /* ENABLE_LOGGING */

//#ifdef COMMAND_LINE_INPUT
//    erRegInitSystemAccess();
//#endif /* COMMAND_LINE_INPUT */

    load_registry();

    languagesInit();
    click_init();

    // create the main, top level, window 
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(window), PACKAGE " " VERSION);
    gtk_window_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
    gtk_container_set_border_width(GTK_CONTAINER(window), 0);
    gtk_widget_set_size_request(GTK_WIDGET(window), SCREEN_WIDTH, SCREEN_HEIGHT - TOOLBAR_HEIGHT - PAGEBAR_HEIGHT);
    gtk_window_set_modal(GTK_WINDOW(window), TRUE);
    gtk_window_set_resizable(GTK_WINDOW(window), FALSE);

    theContentLister = ctrlInit(window);

    if (theContentLister)
    {
        CL_LOGPRINTF("Inside if (theContentLister)");

        // Connect the destroy event of the window with our on_destroy function
        // When the window is about to be destroyed we get a notificaton and
        // stop the main GTK loop
        g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(on_destroy), theContentLister);

        // make sure that everything, window and label, are visible 
        gtk_widget_show(window);
    }

    // start the main loop //
    CL_LOGPRINTF("Before gtk_main");

    gtk_main();
    gdk_threads_leave();

    release_registry();

    return 0;
}

Here is the call graph for this function:

startup_behaviour_t main_get_startup_behaviour

(

void

)

Definition at line 273 of file main.c.

{
    return g_startup_behaviour;
}

static void on_destroy	(	GtkWidget *	widget,
		gpointer	data
	)			[static]

Definition at line 301 of file main.c.

{
    ContentLister *theContentLister = (ContentLister *) data;

    CL_WARNPRINTF("entry");

    ctrlDestroy(theContentLister);

    gtk_main_quit();
}

Here is the call graph for this function:

static void parse_arguments	(	int	argc,
		char **	argv
	)			[static]

Definition at line 231 of file main.c.

{
    int  i;
    int  j;
    gboolean found = FALSE;

    // parse contentLister options
    for (i = 1 ; i < argc ; i++)
    {
        if (strcmp(argv[i], "--help") == 0)
        {
            usage(argv[0]);
        }
        else if(strcmp(argv[i], "--location") == 0)
        {
            i++;
            if (i >= argc)
            {
                usage(argv[0]);
            }
            else
            {
                // get startup location (behaviour)
                for (j = 0 ; g_startup_locations[j].argv ; j++)
                {
                    if (strcmp(argv[i],  g_startup_locations[j].argv) == 0)
                    {
                        g_startup_behaviour = g_startup_locations[j].behaviour;
                        found = TRUE;
                    }
                }
                if (!found)
                {
                    // invalid location specified
                    usage(argv[0]);
                }
            }
        }
    }
}

Here is the call graph for this function:

void prepare_registry_write

(

void

)

Definition at line 179 of file main.c.

{
    gboolean       b;
    regLoad_t      regLoad;
    
    // acquire write lock
    b = erRegWriteLock();
    if (b == FALSE)
    {
        CL_ERRORPRINTF("erRegWriteLock fails with return code [%d]", b);
        g_assert_not_reached();
    }
    
    // reload section(s) that may be written
    erRegUnload(regBasis_t);
    regLoad = erRegLoad(regBasis_t);
    if (regLoad == loadError_t)
    {
        CL_ERRORPRINTF("erRegLoad(regBasis_t) fails with return code [%d]", regLoad);
        g_assert_not_reached();
    }
}

Here is the call graph for this function:

static void release_registry

(

void

)

[static]

Definition at line 142 of file main.c.

{
    // unload registry sections
    erRegUnload(regBasis_t);

    // discard registry locking
    erRegRWLockDestroy();
}

Here is the call graph for this function:

void reload_registry

(

void

)

Definition at line 152 of file main.c.

{
    gboolean       b;
    regLoad_t      regLoad;
    
    // acquire read lock
    b = erRegReadLock();
    if (b == FALSE)
    {
        CL_ERRORPRINTF("erRegReadLock fails with return code [%d]", b);
        g_assert_not_reached();
    }
    
    // reload registry sections used
    erRegUnload(regBasis_t);
    regLoad = erRegLoad(regBasis_t);
    if (regLoad == loadError_t)
    {
        CL_ERRORPRINTF("erRegLoad(regBasis_t) fails with return code [%d]", regLoad);
        g_assert_not_reached();
    }

    // release lock, all data now in memory
    erRegUnlock();
}

Here is the call graph for this function:

static void usage

(

const char *

argv_0

)

[static]

Definition at line 203 of file main.c.

{
    int i;

    static const char *usage_text = 
                        "\n"
                        "usage: %s [options]\n"
                        "\n"
                        "options:\n"
                        "    --help\n"
                        "        Print help text and quit\n"
                        "    --location <location>\n"
                        "        Start contentLister in <location>\n"
                        "\n"
                        "<location>:\n";

    printf(usage_text, argv_0);

    for (i = 0 ; g_startup_locations[i].argv ; i++)
    {
        printf("    %s\n", g_startup_locations[i].argv);
    }
    printf("\n");

    exit(1);
}

---

Variable Documentation

const char* argv

Definition at line 60 of file main.c.

const startup_behaviour_t behaviour

Definition at line 61 of file main.c.

startup_behaviour_t g_startup_behaviour = behaviourUndefined_t [static]

Definition at line 56 of file main.c.

struct { ... } g_startup_locations[] [static]