erbrowser/src/browser.cpp File Reference

browser - eReader "GtkMozEmbed" widget creation, signal hanlders initialistation and browser related API's More...

#include <liberdm/display.h>
#include "browserTypes.h"
#include "pagebar.h"
#include "indexFileHandler.h"
#include "main.h"
#include "browser.h"
#include "toolbar.h"
#include "displayUpdate.h"
#include "browserLog.h"
#include <libermanifest/ermanifest.h>
#include "mozilla_api.h"
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "prenv.h"
#include "mozEmbedCallbacks.h"

Go to the source code of this file.

Classes
class	CPersist
Functions
gboolean	delete_cb (GtkWidget *widget, GdkEventAny *event, Ereader *reader)
gboolean	browser_main_window_expose_event (GtkWidget *widget, GdkEventExpose *event, Ereader *reader)
static void	browser_create (Ereader *browser, gchar *URL_input)
static GtkWidget *	create_window (char *title)
static void	maximize_window (GtkWidget *src)
Ereader *	new_gtk_ereader (char *manifest, char *input_URL)
void	browser_quit ()
void	destroy_ereader (Ereader *theEreader)
void	set_browser_visibility (Ereader *browser, gboolean visibility)
Variables
static CPersist	s_recorder

---

Detailed Description

browser - eReader "GtkMozEmbed" widget creation, signal hanlders initialistation and browser related API's

<File description>="">

Definition in file browser.cpp.

---

Function Documentation

static void browser_create	(	Ereader *	browser,
		gchar *	URL_input
	)			[static]

create a "GtkMozEmbed" widget, specify the callbacks of the GtkMozEmbed specific signals and load the first XHTML file

Parameters:

URL

location of the first file that needs to be displayed

Returns:

void

Definition at line 403 of file browser.cpp.

{
    browser->mozEmbed = gtk_moz_embed_new();


    
    // add this to the browser window
    gtk_container_add(GTK_CONTAINER(browser->eventBox), browser->mozEmbed);

    BR_LOGPRINTF("browser 0x%x - created mozEmbed 0x%x", browser, browser->mozEmbed);

    g_signal_connect(GTK_OBJECT(browser->mozEmbed), "location", G_CALLBACK(location_changed_cb), browser);
    g_signal_connect(GTK_OBJECT(browser->mozEmbed), "visibility", G_CALLBACK(visibility_cb), browser);
    g_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_stop", G_CALLBACK(load_finished_cb), browser);
    //g_signal_connect(GTK_OBJECT(browser->mozEmbed), "progress", G_CALLBACK(progress_change_cb), browser);
    //g_signal_connect(GTK_OBJECT(browser->mozEmbed), "progress_all", G_CALLBACK(progress_all), browser);
    //g_signal_connect(GTK_OBJECT(browser->mozEmbed), "status_change", G_CALLBACK(status_change_cb), browser);
    //g_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_state", G_CALLBACK(net_state_change_cb), browser);
    g_signal_connect(GTK_OBJECT(browser->mozEmbed), "open_uri", G_CALLBACK(open_uri_cb), browser);

#ifndef PC_ENVIRONMENT
    // set the chrome type so it's stored in the object
    // commented for scrollbars fixing
    gtk_moz_embed_set_chrome_mask(GTK_MOZ_EMBED(browser->mozEmbed), GTK_MOZ_EMBED_FLAG_DEFAULTCHROME);
#endif
    // set our minimum size 
    gtk_widget_set_size_request(browser->mozEmbed, SCREEN_WIDTH, CLIENT_AREA);

    if (URL_input)
    {
        BR_LOGPRINTF("loading URL %s", URL_input);

        // => only request a refresh when the page is loaded
        display_update_increase_level(MOZEMBED_UPDATE_LEVEL);

        gtk_moz_embed_load_url(GTK_MOZ_EMBED(browser->mozEmbed), URL_input);
    }
    else
    {
        BR_ERRORPRINTF("No default URL available");
    }

    BR_LOGPRINTF("show mozEmbed 0x%x", browser->mozEmbed);
    set_browser_visibility(browser, TRUE);
}

Here is the call graph for this function:

gboolean browser_main_window_expose_event	(	GtkWidget *	widget,
		GdkEventExpose *	event,
		Ereader *	reader
	)

Definition at line 504 of file browser.cpp.

{
    BR_DISPLAYPRINTF("entry");
    display_update_request_screen_refresh(MAIN_WINDOW_EXPOSE_LEVEL, NULL);
    return FALSE;
}

Here is the call graph for this function:

void browser_quit

(

)

Definition at line 343 of file browser.cpp.

{
    s_recorder.UninstallTermHandler();
    destroy_ereader(s_recorder.GetBrowser());
}

Here is the call graph for this function:

static GtkWidget * create_window

(

char *

title

)

[static]

Definition at line 489 of file browser.cpp.

{
    GtkWidget *window;

    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(window), (title));
    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_HEIGTH - PAGEBAR_HEIGHT);
    gtk_window_set_modal(GTK_WINDOW(window), FALSE);
    gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
    gtk_signal_connect(GTK_OBJECT(window), "realize", GTK_SIGNAL_FUNC(maximize_window), NULL);
    return window;
}

Here is the call graph for this function:

gboolean delete_cb	(	GtkWidget *	widget,
		GdkEventAny *	event,
		Ereader *	reader
	)

Definition at line 386 of file browser.cpp.

{
    BR_LOGPRINTF("entry");
    destroy_ereader(reader);
    gtk_widget_destroy(widget);
    return TRUE;
}

Here is the call graph for this function:

void destroy_ereader

(

Ereader *

theEreader

)

clear resources used by the Ereader data structure

Parameters:

theEreader

reference to the eReader struct

Returns:

void

Definition at line 349 of file browser.cpp.

{
    // store url lastest visited
    gchar  *    type = NULL;
    gboolean    page_type_known = FALSE;
    int         page = -1;
                
        // current url 
    gchar  *url = gtk_moz_embed_get_location(GTK_MOZ_EMBED(theEreader->mozEmbed));
       
    // get type so that we can get page number
    if (page_type_known = mozilla_get_page_type(GTK_MOZ_EMBED(theEreader->mozEmbed), &type))
    {
        page = index_file_get_page_number(&theEreader->pageStatus->index, type, url);
    }
    BR_LOGPRINTF("url last visited %s %d page\n", url, page);
    s_recorder.StorePageLastRead(url);
    if (url) 
    {
        free(url);
    }
    
    if (theEreader)
    {
        BR_LOGPRINTF("cleaning up browser allocations");

        if (theEreader->pageStatus)
        {
            browser_destroy_page_status(theEreader->pageStatus);
        }

        g_free(theEreader);
        theEreader = NULL;
    }
}

Here is the call graph for this function:

static void maximize_window

(

GtkWidget *

src

)

[static]

Definition at line 464 of file browser.cpp.

{
#ifndef PC_ENVIRONMENT
#ifndef LOCAL_DISPLAY
//      GdkBitmap       *empty_bitmap;
//      GdkCursor *cursor;
//      GdkColor useless;
//      char invisible_cursor_bits[] = {0x0};

    /* set transparent cursor */
//      useless.red = 0;
//      useless.green = 0;
//      useless.blue = 0;
//      useless.pixel = 0;
//      empty_bitmap = gdk_bitmap_create_from_data(src->window,invisible_cursor_bits,1,1);
//      cursor = gdk_cursor_new_from_pixmap(empty_bitmap,empty_bitmap,&useless,&useless,0,0);
//      gdk_window_set_cursor(src->window,cursor);

    /* no borders, buttons, ... */
//      gdk_window_set_decorations(src->window,GdkWMDecoration(0));
#endif //LOCAL_DISPLAY
#endif //PC_ENVIRONMENT
}

Ereader* new_gtk_ereader	(	char *	manifest,
		char *	input_URL
	)

Allocate an Ereader data structure, creates the ereader browser specific GTK widgets and initializes the embedded browser window

Parameters:

	Manifest	File location
	URL	location of the first file that needs to be displayed

Returns:

reference to Ereader structure indicates success

Definition at line 266 of file browser.cpp.

{
    Ereader *theEreader;

    BR_LOGPRINTF("entry");

    // create one Ereader ereader struct and fill it with zeros
    theEreader = g_new0(Ereader, 1);

    if (theEreader)
    {
        theEreader->pageStatus = browser_create_page_status();
        browser_set_page_status_indexfile(theEreader->pageStatus, manifest);

        BR_LOGPRINTF("theEreader 0x%x - theEreader->pageStatus 0x%x", theEreader, theEreader->pageStatus);

        theEreader->topLevelWindow = create_window("E-reader");

        // new vbox - homogenous - zero spacing
        theEreader->topLevelVBox = gtk_vbox_new(FALSE, 0);
        gtk_widget_show(theEreader->topLevelVBox);
        gtk_container_add(GTK_CONTAINER(theEreader->topLevelWindow), theEreader->topLevelVBox);

        // event box addded to have an actual X-window     
        theEreader->eventBox = gtk_event_box_new();
        gtk_box_pack_start(GTK_BOX(theEreader->topLevelVBox), theEreader->eventBox, TRUE, TRUE, 0);
        gtk_widget_show(theEreader->eventBox);

        g_signal_connect(G_OBJECT(theEreader->topLevelVBox), "expose-event", G_CALLBACK(browser_main_window_expose_event), theEreader);


#ifdef LOCAL_DISPLAY
        // create toolbar empty area 
        BR_WARNPRINTF("LOCAL_DISPLAY is defined => toolbar");

        theEreader->toolbar = gtk_toolbar_new();
        gtk_widget_set_usize(GTK_WIDGET(theEreader->toolbar), (-1), TOOLBAR_HEIGTH);
        gtk_widget_show(theEreader->toolbar);

        gtk_box_pack_start(GTK_BOX(theEreader->topLevelVBox), GTK_WIDGET(theEreader->toolbar), FALSE, // expand
                           FALSE, // fill
                           0);  // padding
#endif //LOCAL_DISPLAY

        gtk_widget_show(theEreader->topLevelWindow);

        // check manifest file
        s_recorder.SetManifestPathName(manifest);
        
        char *url = s_recorder.GetPageLastRead(input_URL);
        if (url)
        {
            input_URL = url;
            // input_URL = "file:///./pagl01.html";
        }
                
        // create the embedded browser
        browser_create(theEreader, input_URL);

        // catch the destruction of the toplevel window
        g_signal_connect(GTK_OBJECT(theEreader->topLevelWindow), "delete_event", G_CALLBACK(delete_cb), theEreader);

        // catch the key-events in the toplevel window
        gtk_signal_connect(GTK_OBJECT(theEreader->topLevelWindow), "key_press_event", G_CALLBACK(on_mainWindow_keypress), theEreader);
        
        // init 
        s_recorder.InstallTermHandler();
        s_recorder.SetBrowser(theEreader);
    }
    else
    {
        BR_ERRORPRINTF("unable to allocate gEreader");
    }

    return theEreader;
}

Here is the call graph for this function:

void set_browser_visibility	(	Ereader *	browser,
		gboolean	visibility
	)

show/hide the Mozembed widget

Parameters:

	theEreader	reference to the eReader struct
	visibility

Returns:

void

Definition at line 449 of file browser.cpp.

{
    BR_LOGPRINTF("%s", (visibility == TRUE) ? "TRUE" : "FALSE");

    if (!visibility)
    {
        gtk_widget_hide(browser->mozEmbed);
    }
    else
    {
        gtk_widget_show(browser->mozEmbed);
        gtk_widget_grab_focus(browser->mozEmbed);
    }
}

---

Variable Documentation

CPersist s_recorder [static]

Definition at line 254 of file browser.cpp.