How to write a new application to maemo 3.x

Introduction

This document has been reviewed for maemo 3.x.

This document is a guide for making new applications for the maemo platform. When starting to write a new application, the first phase is to setup the development environment, which is explained in the Maemo Tutorial [1]. The actual coding process is described in this document.

As an example we use a simple plain text editor with only a few essential features. Good examples for this kind of plain text editors are gtk2edit and gpe-edit. From now on we call our application as an "MaemoPad".

MaemoPad will have some basic features, such as: "New", "Open", "Save", "Save As...", "Cut", "Copy", "Paste", "Font", "Full Screen" and "Close". For the simplicity there will be no features like "Undo", "Redo", different fonts in the same document, pictures, tables etc.

Figure 1. MaemoPad application

The Figure 1 is a screenshot from the MaemoPad. As you can see MaemoPad application has it's own toolbar at bottom of screen and a drop down menu in left upper corner. The left space is used to show the file.

Creating Application File Structure

First we have to create the file structure for Maemopad. The structure presented is quite genaral and can be used for different kind of applications on the maemo SDK platform.

The project directory has four subdirectories: src/, po/, debian/, and data/. Source files are located in the src/ directory, which contains ui/ subdirectory for UI related code. Localization files are located in the po/ directory.

Files to create Debian package are in the debian/ directory. Debian packaging is explained in details later. The data subdirectory has files to add MaemoPad to the maemo application menu, application icons, and help files.

The project directory includes only three script files to configure and compile the project: autogen.sh, configure.ac, and Makefile.am. The autogen.sh file is a tiny script file which uses GNU-toolchain to make other script files to build the project. Configure.ac includes definitions on how to produce the configure script for our project.

The Makefile.am file in the main project directory include the subdirectories src/, po/ and data/ and Makefiles in src/, po/, and data/ directories include the files and subdirectories under them needed to make the application. The GNU-toolchain is out of the scope of this document and you should study references [2] and [3] if you want to learn more.

In the src/ directory main.c is in the top of the hierarchy in the MaemoPad's code. The file appdata.h has the data needed by the application. Writing the code in main.c and appdata.h is explained in the next chapter. The file interface.c in the src/ui/ directory takes care of creating the graphical user interface. Callbacks.c contains the code that follows the messages between MaemoPad and maemo platform, read more in the functionality chapter.

The localization directory po/ has a file POTFILES.in, which lists the names of the files to be localized and a translation file en_GB.po containing British English strings for the application, see localization for more information.

The file structure of the MaemoPad application will look like this:

Makefile.am
autogen.sh
configure.ac
src/
	Makefile.am
	appdata.h
	main.c
	ui/
		callbacks.h
		callbacks.c
		interface.h
		interface.c
data/
	Makefile.am
	com.nokia.maemopad.service
	maemopad.desktop
        icons/
                26x26/
                        maemopad.png
                40x40/
                        maemopad.png
                scalable/
                        maemopad.png
        help/
                en_GB/
                        MaemoPad.xml
po/
	Makefile.in.in
	POTFILES.in
	en_GB.po
debian/
        changelog
	control
	copyright
	maemopad.install
	maemopad.links
	rules
	

Coding Application Main

This chapter explains how to make files main.c and appdata.h. Main.c has the code for initializing and setting up everything for the application, starting the applications, and freeing the used memory and exiting in the end. Appdata.h has the data needed by the application: pointers, state bits etc. We are making a Hildon based application and it is made by using HildonProgram [1]. Main.c uses functions interface_main_view_new() and interface_main_view_destroy() of interface.c to create a view for the application and to destroy the view when closing application.

int main( int argc, char* argv[] )
{
    AppData* data;
    HildonProgram* program;
    MainView* main_view;

    /* Initialise the locale stuff */
    setlocale ( LC_ALL, "" );
    bindtextdomain (  GETTEXT_PACKAGE, LOCALEDIR );
    bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
    textdomain ( GETTEXT_PACKAGE );

    /* Init the gtk - must be called before any hildon stuff */
    gtk_init( &argc, &argv );

    /* Create the hildon application and setup the title */
    program = HILDON_PROGRAM ( hildon_program_get_instance () );
    g_set_application_name ( _("MaemoPad") );

    /* Create the data and views for our application */
    data = create_data ();
    data->program = program;
    main_view = interface_main_view_new ( data );
    hildon_program_add_window( data->program, data->window );
        
    /* Begin the main app */
    gtk_widget_show ( GTK_WIDGET ( program ) );
    gtk_main();

    /* Clean up */
    interface_main_view_destroy ( main_view );
    destroy_data ( data );

    return 0;
}	  
		

struct _AppData
{
    HildonProgram *program; /* handle to application */
    HildonWindow *window; /* handle to app's window */
    osso_context_t *osso; /* handle to osso */
};	
		

User Interface

The source file interface.c includes all code which make the the graphical user interface (GUI) work. GTK and Hildon API are used to create the GUI. At first our application interface needs a view, which is implemented using HildonWindow [1]. There is drop down menu, toolbar, and scrollable text area in the application view. All of these are made using standard GTK components. Hildon adds some features to GTK, for example theming and differently formed dialogs, though.

Hildon applications have a predefined place for drop down menu and toolbar so we attach our application menu to Hildon application menu and our toolbar to Hildon application toolbar. Rest of the view is dedicated for the scrollable text area. The figure 2 shows how the components will be placed.

Illustration 2. HildonWindow's components

Our interface.c has two public functions: main_view_new and main_view_destroy. Main_view_new creates a view for the application given by parameter and returns a handle to that view. Main_view_destroy destroys the view given as a parameter. Main_view_new uses private functions create_menu to create a drop down menu, create_toolbar to create a tool bar and create_textarea to create a scrollable text view. We use struct MainView to store view data.

To get more information about Hildon study the Maemo Tutorial [1]. If you are not familiar with GTK, a good reference is http://developer.gnome.org/doc/API/2.0/gtk/index.html [4].

#include <gtk/gtk.h>
#include <hildon-widgets/hildon-program.h>
#include <appdata.h>

#define _(String) gettext(String)

/* confirmation responses */
#define CONFRESP_YES 1
#define CONFRESP_NO 2
#define CONFRESP_OK 3
#define CONFRESP_CANCEL 4
#define CONFRESP_ERROR 5

#define MAIN_VIEW_NAME "MainView"

typedef enum {
    MAEMOPAD_NO_ERROR = 0,
    MAEMOPAD_ERROR_INVALID_URI,
    MAEMOPAD_ERROR_SAVE_FAILED,
    MAEMOPAD_ERROR_OPEN_FAILED
} MaemopadError;

/* Struct to include view's information */
typedef struct _MainView MainView;
struct _MainView
{
    /* Handle to app's data */
    AppData *data;

    /* Fullscreen mode is on (TRUE) or off (FALSE) */
    gboolean fullscreen;

    /* Items for menu */
    GtkWidget *file_item;
    GtkWidget *new_item;
	. . .

    /* Toolbar */
    GtkWidget* toolbar;
    GtkWidget* iconw;
    GtkToolItem* new_tb;
    GtkToolItem* open_tb;
   	. . .

    /* Textview related */
    GtkWidget* scrolledwindow;   /* textview is under this widget */
    GtkWidget* textview;         /* widget that shows the text */
    GtkTextBuffer* buffer;       /* buffer that contains the text */
    GtkClipboard* clipboard;     /* clipboard for copy/paste */
   
    PangoFontDescription* font_desc;    /* font used in textview */

    gboolean file_edited;     /* tells is our file on view edited */
    gchar* file_name;         /* directory/file under editing */

};

/* Publics: */
MainView* interface_main_view_new( AppData* data );
void interface_main_view_destroy( MainView* main );
char* interface_file_chooser( MainView* main, GtkFileChooserAction action );
PangoFontDescription* interface_font_chooser( MainView * main );
gint interface_save_changes_note( MainView* main );
void interface_error( MaemopadError me, MainView *main );

		

static void create_menu( MainView *main )
{
    /* Create needed handles */
    GtkMenu *main_menu;
    GtkWidget *file_menu, *edit_menu;
    GtkWidget *separator = NULL;
    GtkWidget *close = NULL;

    /* Create main menu and new menus for submenus in our drop down menu */
    main_menu = GTK_MENU( gtk_menu_new () );
    file_menu = gtk_menu_new ();
    edit_menu = gtk_menu_new ();

    /* Create the menu items */
    main->file_item = gtk_menu_item_new_with_label ("File");
    main->new_item = gtk_menu_item_new_with_label ("New");
	. . .

    /* Add menu items to right menus */
    gtk_menu_append( main_menu, main->file_item );
    gtk_menu_append( file_menu, main->new_item );
	. . .

    /* Add submenus to the right items */
    gtk_menu_item_set_submenu( GTK_MENU_ITEM (main->file_item), file_menu );
    gtk_menu_item_set_submenu( GTK_MENU_ITEM (main->edit_item), edit_menu );

    /* Attach the callback functions to the activate signal */
    g_signal_connect( G_OBJECT( main->new_item ), "activate", 
		      G_CALLBACK ( callback_file_new), main );
    g_signal_connect( G_OBJECT( main->open_item ), "activate", 
		      G_CALLBACK ( callback_file_open), main );
	. . . 

    /* We need to show menu items */
    gtk_widget_show_all( GTK_WIDGET( main_menu ) );
}		
			

static void create_toolbar ( MainView *main ) 
{
    /* Create new GTK toolbar */
    main->toolbar = gtk_toolbar_new ();

    /* Set toolbar properties */
    gtk_toolbar_set_orientation( GTK_TOOLBAR(main->toolbar), GTK_ORIENTATION_HORIZONTAL);
    gtk_toolbar_set_style( GTK_TOOLBAR(main->toolbar), GTK_TOOLBAR_BOTH_HORIZ);

    /* Make menus and buttons to toolbar: */
    /* Create toolitems using defined items from stock */
    main->new_tb = gtk_tool_button_new_from_stock(GTK_STOCK_NEW);
    main->open_tb = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN);
  	. . .

    /* Insert items to toolbar */
    gtk_toolbar_insert
	( GTK_TOOLBAR(main->toolbar), main->new_tb, -1);
    gtk_toolbar_insert
	( GTK_TOOLBAR(main->toolbar), main->open_tb, -1);
	. . .

    /* Connect signals to buttons */
    g_signal_connect(G_OBJECT(main->new_tb), "clicked",
                     G_CALLBACK(callback_file_new), main);
    g_signal_connect(G_OBJECT(main->open_tb), "clicked",
                     G_CALLBACK(callback_file_open), main);
	. . .
	
    /* Add toolbar to the HildonWindow */
    hildon_window_add_toolbar(main->data->window, GTK_TOOLBAR(main->toolbar));

    /* Show toolbar */
    gtk_widget_show_all (GTK_WIDGET(main->toolbar));
    gtk_widget_show_all (GTK_WIDGET(main->data->window) );
}					
			

void create_textarea( MainView *main )
{
    /* Create scrolled window */
    main->scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
    gtk_widget_show(main->scrolledwindow);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(
        main->scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);

    /* Text view */
    main->textview = gtk_text_view_new ();

    /* Some text view settings */
    gtk_text_view_set_editable (GTK_TEXT_VIEW (main->textview), TRUE);
    gtk_text_view_set_left_margin (GTK_TEXT_VIEW (main->textview), 10);
    gtk_text_view_set_right_margin (GTK_TEXT_VIEW (main->textview), 10);

    /* Get handle to buffer */
    main->buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW
	(main->textview));

    /* Enable Rich Text Support */
    gtk_text_buffer_set_can_paste_rich_text ( main->buffer, TRUE );
    gtk_text_buffer_set_rich_text_format ( main->buffer, "RTF" );

    /* Put textview under scrolledwindow and show it*/
    gtk_container_add(GTK_CONTAINER(main->scrolledwindow), main->textview);
    gtk_widget_show(main->textview);

    /* Change default font throughout the widget */
    main->font_desc = pango_font_description_from_string (DEFAULT_FONT);
    gtk_widget_modify_font (main->textview, main->font_desc);

    /* Connect signals to detect changes in text */
    g_signal_connect (G_OBJECT (main->buffer), "modified-changed",
                      G_CALLBACK(callback_buffer_modified), main);
    g_signal_connect (G_OBJECT (main->buffer), "changed",
                      G_CALLBACK(callback_buffer_modified), main);
}					
			

gchar* interface_file_chooser
(MainView * mainview, GtkFileChooserAction action)
{
    GtkWidget *dialog;
    gchar* filename = NULL;

    dialog = hildon_file_chooser_dialog_new(
	GTK_WINDOW(mainview->data->program), action);
    gtk_widget_show_all (GTK_WIDGET(dialog));
    if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
    {
        filename = gtk_file_chooser_get_filename
	(GTK_FILE_CHOOSER (dialog));
    }
    gtk_widget_destroy (dialog);
    return filename;
}			
			

PangoFontDescription* interface_font_chooser( MainView * main )
{
    HildonFontSelectionDialog *dialog = NULL;

    PangoFontDescription *font = NULL;
    gint size;
    gboolean bold, italic;
    gchar *family = NULL;

    font = pango_font_description_new();

    /* create dialog */
    dialog = HILDON_FONT_SELECTION_DIALOG ( hildon_font_selection_dialog_new( NULL, NULL ) );

    gtk_widget_show_all (GTK_WIDGET(dialog));
    if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
    {
        g_object_get(G_OBJECT(dialog),
                    "family", &family,
                    "size", &size,
                    "bold", &bold,
                    "italic", &italic,
                    NULL);
        pango_font_description_set_family(font, family);
        pango_font_description_set_size(font, size * PANGO_SCALE);
        if (bold) {
            pango_font_description_set_weight(font, PANGO_WEIGHT_BOLD);
        } else {
            pango_font_description_set_weight(font, PANGO_WEIGHT_NORMAL);
        }
        if (italic) {
            pango_font_description_set_style(font, PANGO_STYLE_ITALIC);
        } else {
            pango_font_description_set_style(font, PANGO_STYLE_NORMAL);
        }
    }
    gtk_widget_destroy(GTK_WIDGET(dialog));

    return font;
}           
			

gint interface_save_changes_note(MainView * main)
{
    HildonNote *hn = NULL;
    gint response = FALSE;

    g_assert(main != NULL && main->data->program != NULL);

    hn = HILDON_NOTE(hildon_note_new_confirmation_add_buttons
                     (GTK_WINDOW(main->data->window),
                      _("maemopad_save_changes_made"),
                      _("maemopad_yes"), CONFRESP_YES,
                      _("maemopad_no"), CONFRESP_NO,
                      NULL, NULL));
    response = gtk_dialog_run(GTK_DIALOG(hn));
    gtk_widget_destroy(GTK_WIDGET(hn));
    return response;
}			
			

void interface_error( MaemopadError me, MainView *main )
{
    GtkWidget *dialog = NULL;
    gchar *msg = NULL;

    switch (me) {

    case MAEMOPAD_ERROR_INVALID_URI:
        msg = g_strdup(_("maemopad_ms_invalid_uri"));
        break;
        . . .
    default:
        g_assert_not_reached();
    }

    dialog = hildon_note_new_information
	( GTK_WINDOW( main->data->program ), msg );

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

Functionality

void callback_edit_cut( GtkAction * action, gpointer data )
{
        . . .
    /* do cut */
    gtk_text_buffer_cut_clipboard( GTK_TEXT_BUFFER(mainview->buffer),
	mainview->clipboard, TRUE);
}					
			

void callback_edit_copy( GtkAction * action, gpointer data )
{
        . . .
    /* do copy */
    gtk_text_buffer_copy_clipboard( GTK_TEXT_BUFFER(mainview->buffer),
	mainview->clipboard);
}
			

void callback_edit_paste( GtkAction * action, gpointer data )
{
	. . .
    gtk_text_buffer_paste_clipboard( GTK_TEXT_BUFFER( mainview->buffer ),
	mainview->clipboard, NULL, TRUE );
}
			

void callback_file_new(GtkAction * action, gpointer data)
{
        . . .
    /* save changes note if file is edited */
    if( mainview->file_edited ) {
        answer = interface_save_changes_note( mainview );
        if( answer == CONFRESP_YES ) {
            if( mainview->file_name == NULL ) {
                mainview->file_name = interface_file_chooser ( mainview, GTK_FILE_CHOOSER_ACTION_SAVE );
            }
            write_buffer_to_file ( mainview );
        }
    }
    /* clear buffer, filename and free buffer text */
    gtk_text_buffer_set_text ( GTK_TEXT_BUFFER (mainview->buffer), "", -1 );
    mainview->file_name = NULL;
    mainview->file_edited = FALSE;
	  

void callback_file_open(GtkAction * action, gpointer data)
{
	. . .
    /* save changes note if file is edited */
    if( mainview->file_edited ) {
        answer = interface_save_changes_note( mainview );
        if( answer == CONFRESP_YES ) {
            /* check if we had a new file */
            if( mainview->file_name == NULL ) {
                mainview->file_name = interface_file_chooser ( mainview, GTK_FILE_CHOOSER_ACTION_SAVE );
            }
            write_buffer_to_file ( mainview );
        }
    }

    /* open new file */
    filename = interface_file_chooser ( mainview, GTK_FILE_CHOOSER_ACTION_OPEN );

    /* if we got a file name from chooser -> open file */
    if( filename != NULL ) {
        mainview->file_name = filename;
        read_file_to_buffer ( mainview );
        mainview->file_edited = FALSE;
    }
}
			

void callback_file_save(GtkAction * action, gpointer data)
{
	. . .
    /* check if we had a new file */
    if( mainview->file_name != NULL ) {
        write_buffer_to_file ( mainview );
    } else { 
        filename = interface_file_chooser
	( mainview, GTK_FILE_CHOOSER_ACTION_SAVE );
        /* if we got a file name from chooser -> save file */
        if( filename != NULL ) {
            mainview->file_name = filename;
            write_buffer_to_file ( mainview );
            mainview->file_edited = FALSE;
        }
    }
}		
			

void callback_file_saveas(GtkAction * action, gpointer data)
{
	. . .

    filename = interface_file_chooser
	( mainview, GTK_FILE_CHOOSER_ACTION_SAVE );

    /* if we got a file name from chooser -> save file */
    if( filename != NULL ) {
        mainview->file_name = filename;
        write_buffer_to_file ( mainview );
        mainview->file_edited = FALSE;
    }
}
			

void callback_font( GtkAction * action, gpointer data )
{
	. . .
    new_font = interface_font_chooser( mainview );

    /* if we got a new font from chooser -> change font */
    if( new_font != NULL ) {
        mainview->font_desc = new_font;
        gtk_widget_modify_font( mainview->textview, mainview->font_desc );
    }    
}	  
			

void callback_fullscreen( GtkAction * action, gpointer data )
{
	. . .
    /* toggle fullscreen on<->off */
    mainview->fullscreen = !mainview->fullscreen;
    if (mainview->fullscreen) {
        gtk_window_fullscreen(GTK_WINDOW(mainview->data->window));
    } else {
        gtk_window_unfullscreen(GTK_WINDOW(mainview->data->window));
    }
}
			

void callback_buffer_modified ( GtkAction * action, gpointer data )
{
	. . .
    /* change state */
    mainview->file_edited = TRUE;
}
			

void read_file_to_buffer ( MainView* mainview )
{
	. . .
    /* try to get file info */
    vfs_result = gnome_vfs_get_file_info
	(mainview->file_name, &finfo, GNOME_VFS_FILE_INFO_DEFAULT);
    if ( vfs_result != GNOME_VFS_OK ) {
        interface_error( MAEMOPAD_ERROR_OPEN_FAILED, mainview );
        return;
    }
    /* try to create handle to file */
    vfs_result = gnome_vfs_open
	(&handle, mainview->file_name, GNOME_VFS_OPEN_READ);
    if ( vfs_result != GNOME_VFS_OK ) {
        interface_error( MAEMOPAD_ERROR_OPEN_FAILED, mainview );
        return;
    }

    /* allocate memory for temp_buffer */
    temp_buffer = g_malloc(finfo.size + 1);
    memset(temp_buffer, 0, finfo.size + 1);
    
    /* read from file to buffer */
    gnome_vfs_read(handle, temp_buffer, finfo.size, &in_bytes);

    /* set text to screen */
    gtk_text_buffer_set_text
	( GTK_TEXT_BUFFER (mainview->buffer), temp_buffer, -1);

    /* free temp, close file and return */
    g_free(temp_buffer);
    gnome_vfs_close(handle);
}		
			

void write_buffer_to_file ( MainView* mainview )
{
	. . .
    /* try to create handle to file */
    vfs_result = gnome_vfs_create
	(&handle, mainview->file_name, GNOME_VFS_OPEN_WRITE, 0, 0600);
    if ( vfs_result != GNOME_VFS_OK ) {
        interface_error( MAEMOPAD_ERROR_SAVE_FAILED, mainview );
        return;
    }

    /* find start and end of text */
    gtk_text_buffer_get_bounds
	( GTK_TEXT_BUFFER (mainview->buffer), &start, &end);

    /* copy all text from screen to temp_buffer */
    temp_buffer = gtk_text_buffer_get_slice
	( GTK_TEXT_BUFFER (mainview->buffer), &start, &end, TRUE);

    /* write text to file */
    gnome_vfs_write(handle, temp_buffer, strlen(temp_buffer), &out_bytes);

    /* free temp, close file and return */
    g_free(temp_buffer);
    gnome_vfs_close(handle);
}
			

Localization

Localization means translating the application to different languages. Localization needs couple of files which are stored in the po/ directory. The following files will be used for localization:

Makefile.am	
POTFILES.in
en_GB.po
			

POTFILES.in contains the list of source code files which will be localized. File en_GB.po includes translated text.

#: src/document.c:727 src/document.c:733
msgid "note_ib_autosave_recover_failed"
msgstr "Recovering autosaved file failed"
			

Adding Application To Menu

To add application icon into the maemo Task Navigator menu, a couple of files are needed. These are .desktop and .service files.

[Desktop Entry]
Encoding=UTF-8
Version=0.1
Type=Application
Name=MaemoPad
Exec=/usr/bin/maemopad
Icon=maemopad
X-Window-Icon=maemopad
X-Window-Icon-Dimmed=maemopad
X-Osso-Service=maemopad
X-Osso-Type=application/x-executable	  
			

# Service description file
[D-BUS Service]
Name=com.nokia.maemopad
Exec=/usr/bin/maemopad
			

Adding Help

Applications can have their own help files. Help files are XML files that are located under /usr/share/osso-help directory. Each language is in its own subdirectory, like /usr/share/osso-help/en_GB for British English help files. In Maemopad there's data/help/en_GB/MaemoPad.xml, which contains very simple help content. It is mandatory that the middle part of the contextUID middle is the same as the help file name (without suffix):

<?xml version="1.0" encoding="UTF-8"?>
<ossohelpsource>
  <folder>
    <h2>Help MaemoPad Example</h2>

    <topic>
      <topich2>Main Topic</topich2>
      <context contextUID="Example_MaemoPad_Content" />
      <para>This is a help file with example content.</para>

    </topic>
  </folder>
</ossohelpsource>
      

By using ossohelp_show() function (see osso-helplib.h) you can show this help content in your application. You can create a "Help" menu item and connect this kind of callback function to it:

void callback_help( GtkAction * action, gpointer data )
{
    osso_return_t retval;

    /* connect pointer to our MainView struct */
    MainView *mainview = NULL;
    mainview = ( MainView * ) data;
    g_assert(mainview != NULL && mainview->data != NULL );

    retval = ossohelp_show(
      mainview->data->osso, /* osso_context */
      HELP_TOPIC_ID,        /* topic id */
      OSSO_HELP_SHOW_DIALOG);
}
      

To get more information check the maemo help framework HOWTO.

Packaging Application

A Debian package is an application packed in one file to make installing easy in the Debian based operating systems like maemo platform. More information about creating a Debian packages can be found in the official Maintainers' quide (http://www.debian.org/doc/maint-guide/) [9]. Our goal in this chapter is to create a Debian package of MaemoPad, which can be installed in the maemo platform.

If you want to create a package, that can be installed using the the Application Manager, see Making a package for the Application Manager.

The next two sections briefly discuss debian package creation. For a more detailed guide see the Creating a Debian package page.

changelog
control
copyright
maemopad.install
maemopad.links
rules
			

# Add here commands to install the package into debian/tmp/<installation directory>

$(MAKE) install DESTDIR=$(CURDIR)/debian/tmp/<installation directory>
			

Code examples

Full source code for for MaemoPad can be downloaded from Downloads section

References

[1] Maemo 3.X Tutorial

[2] http://www.gnu.org/software/autoconf

[3] http://www.gnu.org/software/automake

[4] http://developer.gnome.org/doc/API/2.0/gtk/index.html

[5] http://library.gnome.org/devel/gnome-vfs-2.0/stable/

[6] http://www.debian.org/

[7] http://pangopdf.sourceforge.net/docs/index.html

[8] http://www.gnu.org/software/gettext/

[9] http://www.debian.org/doc/maint-guide/