ergtk-keyb.c

Go to the documentation of this file.

/*
 * File Name: ergtk-keyb.c 
 */

/*
 * This file is part of erkeyb.
 *
 * erkeyb 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.
 *
 * erkeyb 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
//----------------------------------------------------------------------------

// system includes
#include <stdio.h>
#include <string.h>

/* includes for fakekey */
#include <X11/Xlib.h>
#include <fakekey/fakekey.h>

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

// local include files, between " "
#include "config.h"
#include "ergtk-keyb.h"

#include "erkeyb-display-sched.h"

// logging
#include "logging.h"

//----------------------------------------------------------------------------
// MACROS and definitions
//----------------------------------------------------------------------------

// table definitionss
#define NUM_COLUMNS             20
#define NUM_ROWS                 4

#define NUM_KEYS                32
#define NUM_KEYS_FIRST_ROW      10
#define NUM_KEYS_SECOND_ROW      9
#define NUM_KEYS_THIRD_ROW       9
#define NUM_KEYS_FOURTH_ROW      4

#define FIRST_ROW_START          0
#define FIRST_ROW_END            ( FIRST_ROW_START + NUM_KEYS_FIRST_ROW -1 )
#define SECOND_ROW_START         ( FIRST_ROW_END + 1 )
#define SECOND_ROW_END           ( SECOND_ROW_START + NUM_KEYS_SECOND_ROW -1 ) 
#define THIRD_ROW_START          ( SECOND_ROW_END + 1 )
#define THIRD_ROW_END            ( THIRD_ROW_START + NUM_KEYS_THIRD_ROW - 1 )
#define FOURTH_ROW_START         ( THIRD_ROW_END + 1 )
#define FOURTH_ROW_END           ( FOURTH_ROW_START + NUM_KEYS_FOURTH_ROW - 1 )

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

#define ERGTK_KEYB_GET_PRIVATE(o)  \
           (G_TYPE_INSTANCE_GET_PRIVATE ((o), ERGTK_TYPE_KEYB, ErGtkKeybPrivate))


G_DEFINE_TYPE (ErGtkKeyb, ergtk_keyb, GTK_TYPE_VBOX) ;

/* we support at most 6 alternatives */
typedef enum _key_alt key_alt;

enum _key_alt {
    KEY_ALT0 = 0,
    KEY_ALT0_SHIFTED = 1,
    KEY_ALT1 = 2,
    KEY_ALT1_SHIFTED = 3,
    KEY_ALT2 = 4,
    KEY_ALT2_SHIFTED = 5,
    KEY_ALT_MAX = 6
};

typedef struct _rangetype rangetype;

struct _rangetype { 
    int row;
    int column;
    int nrows;
    int ncolumns;
} ;


/* this is a temp solutions until we have dynamic keymaps that are loeaded from an
 * XML file
 */
typedef struct _c_keyboardmap c_keyboardmap; /* keyboard map using c strings */

struct _c_keyboardmap {
    int    key_num;    /* the keynumber on the keyboard layout */
    gchar*  alt[6];    /* the list of c strings that are the char alternatives for a key */ 
};

typedef struct _charmap charmap;

struct _charmap {
    gint    key_num;    /* the keynumber on the keyboard layout */
    GList*  alt;        /* the list of GStrings that are the characters (1 per GString) assigned to this key */
};

typedef enum _ergtk_keyfacetype ergtk_keyfacetype;

enum _ergtk_keyfacetype  {
    ergtk_keyfacetype_label = 0,
    ergtk_keyfacetype_image,
    ergtk_keyfacetype_unknown = 255,
};

typedef struct _ErGtkKey ErGtkKey;

struct _ErGtkKey {
            ErGtkKeyb*          parent;
            gint                key_num;
            GtkWidget*          button;
            ergtk_keyfacetype   key_facetype;
    union {
        GtkWidget* label;
        GtkWidget* image;
    }                           u;
};

struct _ErGtkKeybPrivate
{
    GString*    xmlfile;                /* xml file containing the keyboard keymap */
    charmap     keymap[32];             /* keynumber to keychar map */
    ErGtkKey    keyboard[32];           /* keyboard widget/layout */
    gint        current_alt_keyb_num;   /* the current alternative keymap */
    gint        num_alternatives;       /* total number of keyboard alternatives */
    gboolean    finalizing;             /* true when object is finalizing */
    guint       highlight_id;

    /* fakekeylib */
    Display*    Xdpy;                   /* X display reference */
    FakeKey*    fk;                     /* fakekey reference */
    GdkDisplay* Gdpy;                   /* Gdk Display reference */
};

enum {
    PROP_0,
    PROP_NUM_ALTERNATIVES,
};

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

// temp solution until we have XML based dynamic keymaps
static c_keyboardmap g_mykeymap[NUM_KEYS] = 
{
    { .key_num =  0, .alt = { "q", "Q", "1", "`", NULL, NULL, }, },
    { .key_num =  1, .alt = { "w", "W", "2", "'", NULL, NULL, }, },
    { .key_num =  2, .alt = { "e", "E", "3", "%", NULL, NULL, }, },
    { .key_num =  3, .alt = { "r", "R", "4", "^", NULL, NULL, }, },
    { .key_num =  4, .alt = { "t", "T", "5", "_", NULL, NULL, }, },
    { .key_num =  5, .alt = { "y", "Y", "6", "<", NULL, NULL, }, },
    { .key_num =  6, .alt = { "u", "U", "7", ">", NULL, NULL, }, },
    { .key_num =  7, .alt = { "i", "I", "8", "-", NULL, NULL, }, },
    { .key_num =  8, .alt = { "o", "O", "9", "+", NULL, NULL, }, },
    { .key_num =  9, .alt = { "p", "P", "0", "{", NULL, NULL, }, },
    { .key_num = 10, .alt = { "a", "A", "£", "}", NULL, NULL, }, },
    { .key_num = 11, .alt = { "s", "S", "=", "|", NULL, NULL, }, },
    { .key_num = 12, .alt = { "d", "D", "(", ";", NULL, NULL, }, },
    { .key_num = 13, .alt = { "f", "F", ")", "\"", NULL, NULL, }, },
    { .key_num = 14, .alt = { "g", "G", "\\", "\\", NULL, NULL, }, },
    { .key_num = 15, .alt = { "h", "H", "*", "*", NULL, NULL, }, },
    { .key_num = 16, .alt = { "j", "J", ":", ":", NULL, NULL, }, },
    { .key_num = 17, .alt = { "k", "K", ",", ",", NULL, NULL, }, },
    { .key_num = 18, .alt = { "l", "L", "/", "/", NULL, NULL, }, },
    { .key_num = 19, .alt = { "Shift", "Shift", "Shift", "Shift", "Shift", "Shift", }, },
    { .key_num = 20, .alt = { "z", "Z", "~", "~", NULL, NULL, }, },
    { .key_num = 21, .alt = { "x", "X", "@", "@", NULL, NULL, }, },
    { .key_num = 22, .alt = { "c", "C", "$", "€", NULL, NULL, }, },
    { .key_num = 23, .alt = { "v", "V", "&", "&", NULL, NULL, }, },
    { .key_num = 24, .alt = { "b", "B", "#", "#", NULL, NULL, }, },
    { .key_num = 25, .alt = { "n", "N", "!", "!", NULL, NULL, }, },
    { .key_num = 26, .alt = { "m", "M", "?", "?", NULL, NULL, }, },
    { .key_num = 27, .alt = { "Backspace", "Backspace", "Backspace", "Backspace", "Backspace", "Backspace", }, },
    { .key_num = 28, .alt = { "@123", "@123", "abc", "abc", "@123", "@123", }, },
    { .key_num = 29, .alt = { " ", " ", " ", " ", " ", " ", }, },
    { .key_num = 30, .alt = { ".", ".", ".", ".", ".", ".", }, },
    { .key_num = 31, .alt = { "Enter", "Enter", "Enter", "Enter", "Enter", "Enter", }, },
};


//----------------------------------------------------------------------------
// Functions Prototypes 
//----------------------------------------------------------------------------

static void ergtk_keyb_class_init (ErGtkKeybClass* klass);
static void ergtk_keyb_init (ErGtkKeyb* keyb);
static void ergtk_keyb_finalize(GObject* object);

static void ergtk_keyb_set_property(GObject* object, guint prop_id, const GValue* value, GParamSpec* pspec );
static void ergtk_keyb_get_property(GObject* object, guint prop_id, GValue* value, GParamSpec* pspec );

static void ergtk_keyb_populate (ErGtkKeyb* keyb );
static void  ergtk_keyb_populate_real(ErGtkKeyb* keyb );
static void ergtk_keyb_create_key_in_table(ErGtkKeyb* keyb, GtkWidget* table, char* keyname, int keyindex, rangetype range);

static gboolean ergtk_keyb_button_clicked_event_cb(GtkWidget* button,  gpointer data);
static gboolean on_highlight_expired( gpointer data );

static gint ergtk_keyb_send_key(ErGtkKeyb* keyb, char* keychar);
static gint ergtk_keyb_send_keysym(ErGtkKeyb* keyb, KeySym keysym );
static gint ergtk_keyb_redraw_keyboard(ErGtkKeyb* keyb);
static int ergtk_keyb_init_fakekey(ErGtkKeyb* keyb);
static void ergtk_keyb_string_free(gpointer data, gpointer user_data );


static gboolean label_log_destroy ( GtkWidget* , gpointer );
static gboolean image_log_destroy ( GtkWidget* , gpointer );
static gboolean button_log_destroy ( GtkWidget* button, gpointer data );

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

static void ergtk_keyb_class_init (ErGtkKeybClass* klass)
{
    DBG_ENTRY;

    GObjectClass* object_class = G_OBJECT_CLASS(klass);

    object_class->set_property = ergtk_keyb_set_property;
    object_class->get_property = ergtk_keyb_get_property;

    object_class->finalize = ergtk_keyb_finalize;

    g_object_class_install_property( object_class, 
            PROP_NUM_ALTERNATIVES, 
            g_param_spec_int (
                "num-alternatives",
                "Number of keyboard alternatives",
                "Specify the number of keyboard layout alternatives",
                0,
                6,
                4,
                G_PARAM_READWRITE ));


    g_type_class_add_private (klass, sizeof(ErGtkKeybPrivate));

    DBG_EXIT;
}

static void ergtk_keyb_init (ErGtkKeyb* keyb)
{
    DBG_ENTRY;

    ErGtkKeybPrivate* priv = keyb->priv;
    priv = keyb->priv =  ERGTK_KEYB_GET_PRIVATE( keyb);
    priv->finalizing = FALSE; /* we are not finalizing */
    priv->highlight_id = 0;
    priv->xmlfile = NULL ; /* for now we do not have any XML keymap support */

    memset(priv->keymap,  0x0, sizeof(priv->keymap));

    int i = 0 ;
    for ( i = 0; i< NUM_KEYS; i++ )
    {
        int j = 0;

        priv->keymap[i].key_num = g_mykeymap[i].key_num;

        for ( j = 0; j<6; j++ )
        {
            if ( g_mykeymap[i].alt[j] != NULL )
            {
                GString* tmp = g_string_new( g_mykeymap[i].alt[j] );
                priv->keymap[i].alt = g_list_prepend(priv->keymap[i].alt, (gpointer) tmp);
            }
        }
        priv->keymap[i].alt = g_list_reverse(priv->keymap[i].alt);
    }
   
    memset(priv->keyboard, 0x0, NUM_KEYS * sizeof(ErGtkKey));
    priv->current_alt_keyb_num = 0;
    priv->num_alternatives = 4; /* hard coded to match static keymap def */
    priv->Xdpy = NULL;
    priv->fk = NULL; 
    priv->Gdpy = NULL; 

    ergtk_keyb_populate (keyb);
    ergtk_keyb_init_fakekey(keyb);

    priv->Gdpy = gdk_display_get_default(); // init gdk display reference

    DBG_EXIT;
}

GtkWidget* ergtk_keyb_new (void )
{
    DBG_ENTRY;

    ErGtkKeyb* result = NULL ; 

    result = g_object_new(ergtk_keyb_get_type(), "num-alternatives", 4, NULL ) ;

    DBG_EXIT;
    return GTK_WIDGET( result );
}

void ergtk_keyb_reset_keymap(ErGtkKeyb* thiz)
{
    DBG_ENTRY;

    ErGtkKeybPrivate* priv = thiz->priv;

    DBG("Resetting alternate keymap 0.\n");
    priv->current_alt_keyb_num = 0 ;
    ergtk_keyb_redraw_keyboard(thiz);

    DBG_EXIT;
}

static void ergtk_keyb_set_property(GObject* object, guint prop_id, const GValue* value, GParamSpec* pspec )
{
    ErGtkKeyb*          keyb;
    ErGtkKeybPrivate*   priv;
    gint                num_alternatives;

    keyb = ERGTK_KEYB(object);
    priv = keyb->priv;

    switch (prop_id)
    {
        case PROP_NUM_ALTERNATIVES:
            num_alternatives = g_value_get_int(value);
            if ( priv->num_alternatives != num_alternatives )
            {
                priv->num_alternatives = num_alternatives;
            }
            break;

        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
            break;
    }
}

static void ergtk_keyb_get_property(GObject* object, guint prop_id, GValue* value, GParamSpec* pspec )
{
    ErGtkKeyb* keyb;
    ErGtkKeybPrivate* priv;

    keyb = ERGTK_KEYB(object);
    priv = keyb->priv;

    switch (prop_id)
    {
        case PROP_NUM_ALTERNATIVES:
            g_value_set_int(value, priv->num_alternatives);
            break;

        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
            break;
    }

}

static void ergtk_keyb_string_free(gpointer data, gpointer user_data )
{
    gboolean free_orig = *(gboolean*) user_data ;
    GString* to_delete = (GString*) data;
    gchar* orig = NULL ;

    orig = g_string_free(to_delete, free_orig);

    if ( free_orig == TRUE )
    {
        DBG_ASSERT( orig == NULL );
    }
}

static void ergtk_keyb_finalize(GObject* object)
{
    DBG_ENTRY;
    ErGtkKeyb* keyb = ERGTK_KEYB(object);
    ErGtkKeybPrivate* priv = keyb->priv;
    priv->finalizing = TRUE;
    if ( priv->highlight_id != 0 )
    {
        g_source_remove(priv->highlight_id);
    }
    priv->highlight_id = 0;

    gchar* tmp = NULL;
    int i = 0 ;

    if ( priv->xmlfile != NULL )
    {
        tmp = g_string_free(priv->xmlfile, TRUE);
        DBG_ASSERT(tmp == NULL ) ;
    }

    for ( i = 0; i < NUM_KEYS; i++ )
    {
        if ( priv->keymap[i].alt != NULL )
        {
            gboolean weed_out = TRUE ; 
            g_list_foreach( priv->keymap[i].alt, ergtk_keyb_string_free, (gpointer) &weed_out);
            g_list_free( priv->keymap[i].alt );
            priv->keymap[i].alt = NULL ; 
        }
    }

    for (i = 0; i < NUM_KEYS; i++ )
    {
        if ( priv->keyboard[i].parent != NULL )
        {
            priv->keyboard[i].parent = NULL ; 
        }
        priv->keyboard[i].key_num = 0;

        DBG_ASSERT( priv->keyboard[i].button == NULL ) ;
        
        if ( priv->keyboard[i].key_facetype == ergtk_keyfacetype_label)
        {
            DBG_ASSERT( priv->keyboard[i].u.label == NULL ) ;
            ;
        }
        else if ( priv->keyboard[i].key_facetype == ergtk_keyfacetype_image)
        {
            DBG_ASSERT( priv->keyboard[i].u.image == NULL ) ;
            ;
        }
    }
    priv->current_alt_keyb_num = 0 ;
    priv->num_alternatives = 0 ;
    priv->fk = NULL ; 
    XCloseDisplay( priv->Xdpy);
    priv->Xdpy = NULL ; 

    G_OBJECT_CLASS (ergtk_keyb_parent_class)->finalize(object);

    // When the keyboard is destroyed, do a full screen update
    erkeyb_on_idle_display_yield(DM_HINT_FULL);

    DBG_EXIT;
}


static void ergtk_keyb_populate (ErGtkKeyb* keyb )
{
    DBG_ENTRY; 

    ErGtkKeybPrivate* priv = keyb->priv;

    int i = 0;
    GList* ptr = NULL ;
    gchar* tmp = NULL ;

    for ( i = 0; i < NUM_KEYS; i++ )  
    {
        /* needed for reference from the button clicked callback */
        priv->keyboard[i].parent = keyb;

        priv->keyboard[i].key_num = i;

        ptr = g_list_nth(priv->keymap[i].alt, 1);
        DBG_ASSERT(ptr != NULL ) ;
        tmp = ((GString*)(ptr->data))->str;

        if (strcasecmp(tmp, "Shift") == 0)
        {
            // Shift has an image instead of a label
            priv->keyboard[i].key_facetype = ergtk_keyfacetype_image ; 
        }
        else if (strcasecmp(tmp, "Backspace") == 0)
        {
            // Backspace has an image instead of a label
            priv->keyboard[i].key_facetype = ergtk_keyfacetype_image ; 
        }
        else 
        {
            priv->keyboard[i].key_facetype = ergtk_keyfacetype_label ; 
        }
    }

    /* continue populating the keyboard widget */
    ergtk_keyb_populate_real(keyb);

    DBG_EXIT;
}


static void  ergtk_keyb_populate_real(ErGtkKeyb* keyb )
{
    DBG_ENTRY;

    ErGtkKeybPrivate* priv = keyb->priv;

    GtkWidget* table = gtk_table_new( NUM_ROWS, NUM_COLUMNS, TRUE ); // 4 rows, 20 columns, homogeneous
    gtk_table_set_row_spacings(GTK_TABLE(table), 3 );
    gtk_table_set_col_spacings(GTK_TABLE(table), 3 );

    {
        int i ; // i is the row
        
        for ( i = 0; i < NUM_ROWS; i++ ) // for each row
        {
            switch (i)
            {
                case 0: 
                    {
                        int j; // for each two columns
                        int c;

                        for (j = 0, c = FIRST_ROW_START; c < SECOND_ROW_START ; j+=2, c++ )
                        {
                            rangetype range = { 
                                .row = i,
                                .column = j,
                                .nrows = 1,
                                .ncolumns = 2 
                            };
                            GList* ptr = g_list_nth(priv->keymap[c].alt, 0);
                            DBG_ASSERT( ptr != NULL  ) ;
                            gchar* keyname = ((GString*)(ptr->data))->str;
                            ergtk_keyb_create_key_in_table(keyb, table, (char*) keyname, c, range);
                        }
                        break;
                    }
                case 1:
                    {
                        int j=0; // for each two columns
                        int c;

                        for (j = 1, c = SECOND_ROW_START; c < THIRD_ROW_START ; j+=2, c++ )
                        {
                            rangetype range = { 
                                .row = i,
                                .column = j,
                                .nrows = 1,
                                .ncolumns = 2 
                            };
                            GList* ptr = g_list_nth(priv->keymap[c].alt, 0);
                            DBG_ASSERT( ptr != NULL  ) ;
                            gchar* keyname = ((GString*)(ptr->data))->str;
                            ergtk_keyb_create_key_in_table(keyb, table, (char*) keyname, c, range);
                        }
                        break;
                    }
                case 2:
                    {
                        int j; // for each two columns
                        int c;

                        for (j = 0, c = THIRD_ROW_START; c < FOURTH_ROW_START ; j+=2, c++ )
                        {
                            if  ( c == THIRD_ROW_START ) // shift 
                            {
                                rangetype range = { 
                                    .row = i,
                                    .column = j,
                                    .nrows = 1,
                                    .ncolumns = 3 
                                };
                                GList* ptr = g_list_nth(priv->keymap[c].alt, 0);
                                DBG_ASSERT( ptr != NULL  ) ;
                                gchar* keyname = ((GString*)(ptr->data))->str;
                                ergtk_keyb_create_key_in_table(keyb, table, (char*) keyname, c, range);
                                j++; // this key needs three columns -> compensate
                            } 
                            else if ( c == THIRD_ROW_END ) // BS
                            {
                                rangetype range = { 
                                    .row = i,
                                    .column = j,
                                    .nrows = 1,
                                    .ncolumns = 3 
                                };
                                GList* ptr = g_list_nth(priv->keymap[c].alt, 0);
                                DBG_ASSERT( ptr != NULL  ) ;
                                gchar* keyname = ((GString*)(ptr->data))->str;
                                ergtk_keyb_create_key_in_table(keyb, table, (char*) keyname, c, range);
                            }
                            else { // normal key
                                rangetype range = { 
                                    .row = i,
                                    .column = j,
                                    .nrows = 1,
                                    .ncolumns = 2 
                                };
                                GList* ptr = g_list_nth(priv->keymap[c].alt, 0);
                                DBG_ASSERT( ptr != NULL  ) ;
                                gchar* keyname = ((GString*)(ptr->data))->str;
                                ergtk_keyb_create_key_in_table(keyb, table, (char*) keyname, c, range);
                            }
                        }
                        break;
                    }
                case 3:
                    {
                        int j=0;
                        int c;

                        for (c = FOURTH_ROW_START; c <= FOURTH_ROW_END ; c++ )
                        {
                            if ( j == 0 )
                            {
                                rangetype range = { 
                                    .row = i,
                                    .column = j,
                                    .nrows = 1,
                                    .ncolumns = 4 
                                };
                                GList* ptr = g_list_nth(priv->keymap[c].alt, 0);
                                DBG_ASSERT( ptr != NULL  ) ;
                                gchar* keyname = ((GString*)(ptr->data))->str;
                                ergtk_keyb_create_key_in_table(keyb, table, (char*) keyname, c, range);
                                j+=4;  //  this key needs 4 columns
                                continue;
                            }
                            if ( j == 4 )
                            {
                                rangetype range = { 
                                    .row = i,
                                    .column = j,
                                    .nrows = 1,
                                    .ncolumns = 10 
                                };
                                GList* ptr = g_list_nth(priv->keymap[c].alt, 0);
                                DBG_ASSERT( ptr != NULL  ) ;
                                gchar* keyname = ((GString*)(ptr->data))->str;
                                ergtk_keyb_create_key_in_table(keyb, table, (char*) keyname, c, range);
                                j+=10; // tihs key needs 10 columns
                                continue;
                            }
                            if ( j == 14 )
                            {
                                rangetype range = { 
                                    .row = i,
                                    .column = j,
                                    .nrows = 1,
                                    .ncolumns = 2
                                };
                                GList* ptr = g_list_nth(priv->keymap[c].alt, 0);
                                DBG_ASSERT( ptr != NULL  ) ;
                                gchar* keyname = ((GString*)(ptr->data))->str;
                                ergtk_keyb_create_key_in_table(keyb, table, (char*) keyname, c, range);
                                j+=2;
                                continue;
                            }
                            if ( j== 16 )
                            {
                                rangetype range = { 
                                    .row = i,
                                    .column = j,
                                    .nrows = 1,
                                    .ncolumns = 4
                                };
                                GList* ptr = g_list_nth(priv->keymap[c].alt, 0);
                                DBG_ASSERT( ptr != NULL  ) ;
                                gchar* keyname = ((GString*)(ptr->data))->str;
                                ergtk_keyb_create_key_in_table(keyb, table, (char*) keyname, c, range);
                                j+=4;
                                continue;
                            }
                            DBG_ASSERT( 0 );
                            break; // if we get here something is wrong.
                        }
                        break;
                    }
                default:
                    {
                        DBG_ASSERT( 0 ) ;
                        break; // does not happen
                    }
            }
        }
    }
    gtk_container_add(GTK_CONTAINER(keyb), table);
    gtk_widget_show(table);

    DBG_EXIT;
}

static void ergtk_keyb_create_key_in_table(ErGtkKeyb* keyb, GtkWidget* table, char* keyname, int keyindex, rangetype range)
{
    GtkWidget* thekey   = NULL;
    GtkWidget* thelabel = NULL;
    GtkWidget* theimage = NULL;

    ErGtkKeybPrivate* priv = keyb->priv;

    GList* ptr = g_list_nth(priv->keymap[keyindex].alt, 1);
    gchar* tmp = ((GString*)(ptr->data))->str;

    priv->keyboard[keyindex].button = gtk_button_new();

    g_signal_connect(
            GTK_OBJECT(priv->keyboard[keyindex].button), 
            "destroy", 
            GTK_SIGNAL_FUNC(gtk_widget_destroyed), 
            (gpointer) &priv->keyboard[keyindex].button
            );
    g_signal_connect(
            GTK_OBJECT(priv->keyboard[keyindex].button), 
            "destroy", 
            GTK_SIGNAL_FUNC(button_log_destroy), 
            (gpointer) NULL
            );

    thekey = priv->keyboard[keyindex].button   ;
    GTK_WIDGET_UNSET_FLAGS(thekey, GTK_CAN_FOCUS); // buttons can never steal the focus

    // TODO: the image files should be defined in the XML (XML not supported yet) -- open
    if (priv->keyboard[keyindex].key_facetype == ergtk_keyfacetype_image ) 
    {
        if (strcasecmp(tmp, "Shift") == 0)
        {
            char path[512];
            snprintf(path, 512, "%s/%s", PKGDATADIR, "key-shift.png");
            priv->keyboard[keyindex].u.image = gtk_image_new_from_file((gchar*) path ); 
        }
        else if (strcasecmp(tmp, "Backspace") == 0)
        {
            char path[512];
            snprintf(path, 512, "%s/%s", PKGDATADIR, "key-backspace.png");
            priv->keyboard[keyindex].u.image = gtk_image_new_from_file((gchar*) path ); 
        }
        g_signal_connect(
                GTK_OBJECT(priv->keyboard[keyindex].u.image), 
                "destroy", 
                GTK_SIGNAL_FUNC(gtk_widget_destroyed), 
                (gpointer) &priv->keyboard[keyindex].u.image
                );
        g_signal_connect(
                GTK_OBJECT(priv->keyboard[keyindex].u.image), 
                "destroy", 
                GTK_SIGNAL_FUNC(image_log_destroy),
                (gpointer) NULL
                );

        theimage = priv->keyboard[keyindex].u.image;
        gtk_container_add(GTK_CONTAINER(thekey), theimage);
        gtk_widget_show(theimage);
    }
    else 
    {
        if ( keyname != NULL )
        {
            priv->keyboard[keyindex].u.label = gtk_label_new(keyname); 
            gtk_widget_set_sensitive(priv->keyboard[keyindex].button, TRUE);
        }
        else
        {
            priv->keyboard[keyindex].u.label = gtk_label_new(" "); 
            //gtk_widget_set_sensitive(priv->keyboard[keyindex].button, FALSE);
            /* leave at true for the moment, looks ugly otherwise */
            gtk_widget_set_sensitive(priv->keyboard[keyindex].button, TRUE); 
        }
        g_signal_connect(
                GTK_OBJECT(priv->keyboard[keyindex].u.label), 
                "destroy", 
                GTK_SIGNAL_FUNC(gtk_widget_destroyed), 
                (gpointer) &priv->keyboard[keyindex].u.label
                );
        g_signal_connect(
                GTK_OBJECT(priv->keyboard[keyindex].u.label), 
                "destroy", 
                GTK_SIGNAL_FUNC(label_log_destroy),
                (gpointer) NULL
                );

        thelabel = priv->keyboard[keyindex].u.label ;
        gtk_container_add(GTK_CONTAINER(thekey), thelabel);
        gtk_widget_show(thelabel);
    }

    g_signal_connect(GTK_OBJECT(thekey), "clicked", G_CALLBACK(ergtk_keyb_button_clicked_event_cb), (gpointer) &priv->keyboard[keyindex]);
 
    gtk_widget_set_size_request(thekey, 35, 35) ;
    gtk_table_attach(GTK_TABLE(table), thekey, range.column, (range.column+range.ncolumns), 
            range.row, (range.row+range.nrows), GTK_EXPAND|GTK_FILL, GTK_SHRINK|GTK_FILL, 0, 0);

    gtk_widget_show(thekey);

    return;
}


static gboolean on_highlight_expired( gpointer data )
{
    DBG_ENTRY;

    GtkWidget* button = (GtkWidget*) data ;
    GtkWidget* label = gtk_bin_get_child(GTK_BIN(button));

    GdkColor black;
    gdk_color_parse("black", &black);
    gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black);
    gtk_widget_modify_fg(label, GTK_STATE_ACTIVE, &black);
    GdkColor white;
    gdk_color_parse("white", &white);
    gtk_widget_modify_bg(button, GTK_STATE_NORMAL, &white);
    gtk_widget_modify_bg(button, GTK_STATE_ACTIVE, &white);
    gtk_widget_queue_draw(button);

    erkeyb_on_idle_display_yield(DM_HINT_KEY);

    DBG_EXIT;
    return FALSE;
}

static gboolean ergtk_keyb_button_clicked_event_cb(GtkWidget* button,  gpointer data)
{   
    DBG_ENTRY;

    DBG_ASSERT ( data != NULL ) ;
    DBG_ASSERT ( button != NULL );

    ErGtkKey* key = (ErGtkKey*) data;
    ErGtkKeyb* keyb = key->parent;
    ErGtkKeybPrivate* priv = keyb->priv;
    GtkWidget* label = gtk_bin_get_child(GTK_BIN(button));

    GList*  ptr = NULL ;
    gchar*  keychar = NULL ; 

    gint display_update_hint = DM_HINT_KEY;

    erkeyb_stop_display_update();

    GdkColor white;
    gdk_color_parse("white", &white);
    gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
    gtk_widget_modify_fg(label, GTK_STATE_ACTIVE, &white);
    GdkColor black;
    gdk_color_parse("black", &black);
    gtk_widget_modify_bg(button, GTK_STATE_NORMAL, &black);
    gtk_widget_modify_bg(button, GTK_STATE_ACTIVE, &black);
    gtk_widget_queue_draw(button);
    
    ptr = g_list_nth(priv->keymap[key->key_num].alt, priv->current_alt_keyb_num);

    if ( ptr == NULL )
    {
        DBG("Key has no value!\n");
        goto cb_exit;
    }

    /* ptr != NULL */

    keychar = ((GString*)(ptr->data))->str;
    DBG_ASSERT(keychar != NULL );
    DBG_ASSERT(priv->current_alt_keyb_num < KEY_ALT_MAX ) ;

    if ( priv->current_alt_keyb_num % 2 == 1 ) /* shift pressed -> odd keymap */
    {
        if (strcasecmp (keychar, "Shift") == 0)
        {
            DBG("Shift key pressed\n");
            priv->current_alt_keyb_num -- ; 
            DBG_ASSERT(priv->current_alt_keyb_num >= KEY_ALT0 ) ;
            ergtk_keyb_redraw_keyboard(keyb);
            display_update_hint = DM_HINT_PARTIAL;
            goto cb_exit;
        }
        if ((strcasecmp (keychar, "@123") == 0) || (strcasecmp (keychar, "abc") == 0))
        {
            DBG("Switch to alternate keyboard layout key pressed \n");
            priv->current_alt_keyb_num += 1;
            DBG_ASSERT( priv->current_alt_keyb_num % 2 == 0); /* always a master layout -> even keymap */
            DBG_ASSERT( priv->num_alternatives < KEY_ALT_MAX ); /* always less than KEY_ALT_MAX */
            priv->current_alt_keyb_num %= priv->num_alternatives; /* wrap around */
            ergtk_keyb_redraw_keyboard(keyb);
            display_update_hint = DM_HINT_PARTIAL;
            goto cb_exit;
        }
        if (strcasecmp(keychar, "Enter") == 0 )
        {
            DBG("Return key pressed\n");
            ergtk_keyb_send_keysym(keyb, XK_Return);
            priv->current_alt_keyb_num --;
            DBG_ASSERT(priv->current_alt_keyb_num >= KEY_ALT0 ) ;
            ergtk_keyb_redraw_keyboard(keyb);
            display_update_hint = DM_HINT_PARTIAL;
            goto cb_exit;
        }
        if (strcasecmp (keychar, "Backspace") == 0)
        {
            DBG("Backspace pressed\n");
            ergtk_keyb_send_keysym(keyb, XK_BackSpace);
            priv->current_alt_keyb_num --;
            DBG_ASSERT(priv->current_alt_keyb_num >= KEY_ALT0 ) ;
            ergtk_keyb_redraw_keyboard(keyb);
            display_update_hint = DM_HINT_PARTIAL;
            goto cb_exit;
        }

        DBG("(Normal) Pressed key %s\n", (char*) keychar );
        ergtk_keyb_send_key(keyb, keychar);
        priv->current_alt_keyb_num -- ; 
        DBG_ASSERT(priv->current_alt_keyb_num >= KEY_ALT0 ) ;
        ergtk_keyb_redraw_keyboard(keyb);
        display_update_hint = DM_HINT_PARTIAL;
        goto cb_exit;
    }

    /* we are not in shifted mode -> normal operation */
    if (strcasecmp (keychar, "Shift") == 0)
    {
        DBG("Shift key pressed\n");
        DBG_ASSERT(priv->current_alt_keyb_num % 2 == 0 ) ;
        priv->current_alt_keyb_num ++ ; 
        ergtk_keyb_redraw_keyboard(keyb);
        display_update_hint = DM_HINT_PARTIAL;
        goto cb_exit;
    }
    if ((strcasecmp (keychar, "@123") == 0) || (strcasecmp (keychar, "abc") == 0))
    {
        DBG("Switch to alternate keyboard layout key pressed \n");
        DBG_ASSERT( priv->current_alt_keyb_num % 2 == 0); /* always a master layout -> even keymap */
        DBG_ASSERT( priv->num_alternatives < KEY_ALT_MAX ); /* always less than KEY_ALT_MAX */
        priv->current_alt_keyb_num += 2 ; 
        priv->current_alt_keyb_num %= priv->num_alternatives;
        ergtk_keyb_redraw_keyboard(keyb);
        display_update_hint = DM_HINT_PARTIAL;
        goto cb_exit;
    }
    if (strcasecmp (keychar, "Backspace") == 0)
    {
        DBG("Backspace pressed\n");
        ergtk_keyb_send_keysym(keyb, XK_BackSpace);
        display_update_hint = DM_HINT_KEY;
        goto cb_exit;
    }
    if (strcasecmp(keychar, "Enter") == 0 )
    {
        DBG("Return key pressed\n");
        ergtk_keyb_send_keysym(keyb, XK_Return);
        display_update_hint = DM_HINT_KEY;
        goto cb_exit;
    }

    DBG("(Normal) Pressed key %s\n", (char*) keychar );
    ergtk_keyb_send_key(keyb, keychar);
    display_update_hint = DM_HINT_KEY;

cb_exit:
    gtk_widget_queue_draw(button);
    gdk_display_flush(priv->Gdpy);
    gdk_display_sync(priv->Gdpy);  /* this may be some serious overkill */

    erkeyb_on_timeout_display_update(50, display_update_hint);

    // schedule an unhighlight action for the same button 
    priv->highlight_id = g_timeout_add(200, on_highlight_expired, (gpointer) button );

    DBG_EXIT;
    return FALSE;
}

static gint ergtk_keyb_redraw_keyboard(ErGtkKeyb* keyb)
{
    DBG_ENTRY;

    GList* ptr = NULL ; 
    gchar* tmp = NULL ; 

    ErGtkKeybPrivate* priv = keyb->priv;

    int i = 0;

    for (i=0; i < NUM_KEYS; i++ ) /* hard coded -> use define or so here */
    {

        ptr = g_list_nth( priv->keymap[i].alt, priv->current_alt_keyb_num);

        if ( NULL != ptr )
        {
            tmp = ((GString*)(ptr->data))->str;
        }
        else 
        {
            tmp = NULL ; 
        }
        
        switch (i)
        {
            case 19:
            case 27: 
            //case 31: // Enter key has label instead of image now
                break;
            default:
                if ( tmp  != NULL ) { 
                    gtk_label_set_label(GTK_LABEL(priv->keyboard[i].u.label), (const gchar*) tmp);
                    gtk_widget_set_sensitive(priv->keyboard[i].button, TRUE);
                }
                else {
                    gtk_label_set_label(GTK_LABEL(priv->keyboard[i].u.label), (const gchar*) " ");
                    // gtk_widget_set_sensitive(priv->keyboard[i].button, FALSE);
                    /* leave at true for the moment, looks ugly otherwise */
                    gtk_widget_set_sensitive(priv->keyboard[i].button, TRUE);
                }
                break;
        }
    }

    DBG_EXIT;
    return FALSE ;
}

static gint ergtk_keyb_send_key(ErGtkKeyb* keyb, char* keychar)
{
    DBG_ENTRY;
    
    ErGtkKeybPrivate* priv = keyb->priv;

    DBG_ASSERT( priv->fk != NULL );

    fakekey_press(priv->fk, (const unsigned char*) keychar, -1 , 0);
    fakekey_release(priv->fk);

    DBG_EXIT;
    return 1;
}

static gint ergtk_keyb_send_keysym(ErGtkKeyb* keyb, KeySym keysym )
{
    DBG_ENTRY;

    ErGtkKeybPrivate* priv = keyb->priv;

    DBG_ASSERT( priv->fk != NULL );

    fakekey_press_keysym(priv->fk, keysym, 0 );
    fakekey_release(priv->fk);

    DBG_EXIT;
    return 1;
}

static int ergtk_keyb_init_fakekey(ErGtkKeyb* keyb)
{
    ErGtkKeybPrivate* priv = keyb->priv;

    priv->Xdpy = XOpenDisplay(getenv("DISPLAY"));

    if (priv->Xdpy  == NULL)
    {
            ERR("Could not open X display\n");
            DBG_EXIT;
            return 0;
    }

    priv->fk = fakekey_init(priv->Xdpy);

    if ( priv->fk == NULL)
    {
            ERR("Could not initialize fakekey\n");
            DBG_EXIT;
            return 0;
    }

    DBG("fakekey initialized\n");
    return 1;

}

static gboolean label_log_destroy ( GtkWidget* label, gpointer data )
{
    DBG("-- LABEL  destroyed.\n");
    return FALSE;
}

static gboolean image_log_destroy ( GtkWidget* image, gpointer data )
{
    DBG("-- IMAGE  destroyed.\n");
    return FALSE;
}

static gboolean button_log_destroy ( GtkWidget* button, gpointer data )
{
    DBG("-- BUTTON  destroyed.\n");
    return FALSE;
}