erkeybd.c

Go to the documentation of this file.

/*
 * File Name: erkeybd.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 include files, between < >
#include <glib.h>
#include <gtk/gtk.h>
/* local include files */
#include "ergtk-keyb.h"

/* logging */
#include "logging.h"

#include <errno.h>
#include <string.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <strings.h>
#include <errno.h>
#include <signal.h>

//----------------------------------------------------------------------------
//  MACRO definitions
//----------------------------------------------------------------------------

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

typedef struct _KeybUI KeybUI;

struct _KeybUI {
    gboolean is_visible;
    GtkWidget* window;
    GtkWidget* alignment;
    GtkWidget* keyb;
    GIOChannel* sock_io_chan;
};


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

static KeybUI g_keybui;

//----------------------------------------------------------------------------
// Function Prototypes
//----------------------------------------------------------------------------
static void on_sigterm (int signo);
static gboolean my_io_callback(GIOChannel* source, GIOCondition condition, gpointer data );

static gint realize_keyboard(KeybUI* ui );
static gint keyboard_show(KeybUI* ui );
static gint keyboard_hide(KeybUI* ui );
static gint destroy_keyboard(KeybUI* ui);

static gboolean finish_app_cb(GtkWidget* widget, gpointer data );

//----------------------------------------------------------------------------
// Function Implementations
//----------------------------------------------------------------------------

static void on_sigterm (int signo)
{
    DBG_ENTRY;

    DBG("erkeybd: Caught SIGNAL (%d), exiting...  my pid [%d]", getpid(), signo);

    gtk_main_quit();

    DBG_EXIT;
}

static gboolean my_io_callback(GIOChannel* source, GIOCondition condition, gpointer data )
{
    DBG_ENTRY;

    char* tmp = NULL ; 

    GString* buf = g_string_new(NULL);

    g_io_channel_read_line_string( source, buf, NULL, NULL);
    tmp = (char*) buf->str; 

    DBG(" Received -- %s", tmp );

    if (strcasecmp(tmp, "Keyboard-Show\n") == 0)
    {
        DBG("Showing Keyboard!\n");
        keyboard_show(&g_keybui);
    }
    else if (strcasecmp(tmp, "Keyboard-Hide\n") == 0)
    {
        DBG("Hiding Keyboard!\n");
        keyboard_hide(&g_keybui);
    }
    else if (strcasecmp(tmp, "Keyboard-Destroy\n") == 0)
    {
        DBG("Destroying Keyboard!\n");
        destroy_keyboard(&g_keybui);
    }


    tmp = NULL ;
    tmp = (char*) g_string_free(buf, TRUE);
    DBG_ASSERT( tmp == NULL );

    DBG_EXIT;

    return TRUE;
}


int main ( int argc, char** argv )
{
    DBG_ENTRY;

    struct sigaction on_term;
    int        sockfd = -1;
    int        error = 0;
    struct     sockaddr_in server_addr;

    gchar      buffer[512];
    memset(buffer, 0x0, sizeof(buffer));

    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

    sockfd = socket(PF_INET, SOCK_DGRAM, 0);
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(60666);
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    memset(server_addr.sin_zero, '\0', sizeof(server_addr.sin_zero));

    error = bind(sockfd, (struct sockaddr*) &server_addr, sizeof(server_addr));

    if (error)
    {
        perror("Error invoking bind");
        return 0;
    }

    gtk_init(&argc, &argv);

    g_keybui.sock_io_chan = NULL ; 
    g_keybui.sock_io_chan = g_io_channel_unix_new(sockfd) ;
    DBG_ASSERT( g_keybui.sock_io_chan != NULL  ) ;

    realize_keyboard(&g_keybui);

    g_io_channel_set_encoding(g_keybui.sock_io_chan, NULL, NULL  );
    g_io_add_watch( g_keybui.sock_io_chan, G_IO_IN, my_io_callback, NULL );

    gtk_main();

    close(sockfd);

    DBG_EXIT;
    return 0;
}


static gint realize_keyboard(KeybUI* ui)
{
    DBG_ENTRY;

    DBG_ASSERT( ui != NULL ) ;

    ui->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    
    gtk_signal_connect(
            GTK_OBJECT(ui->window),
            "destroy", 
            GTK_SIGNAL_FUNC(gtk_widget_destroyed), 
            (gpointer)&ui->window
            );
    

    ui->alignment = gtk_alignment_new(0.5, 0.0, 0.0, 0.0);
    gtk_signal_connect(
            GTK_OBJECT(ui->alignment),
            "destroy", 
            GTK_SIGNAL_FUNC(gtk_widget_destroyed), 
            (gpointer)&ui->alignment
            );

    // ui->vbox = gtk_vbox_new(3,FALSE);
    ui->keyb = ergtk_keyb_new();
    gtk_signal_connect(
            GTK_OBJECT(ui->keyb),
            "destroy", 
            GTK_SIGNAL_FUNC(gtk_widget_destroyed), 
            (gpointer)&ui->keyb
            );
    g_signal_connect(
            G_OBJECT(ui->keyb), 
            "destroy", 
            G_CALLBACK(finish_app_cb), 
            (gpointer) &g_keybui 
            );

    gtk_container_add(GTK_CONTAINER(ui->alignment), ui->keyb);
    gtk_widget_show(ui->keyb);

    gtk_container_add(GTK_CONTAINER(ui->window), ui->alignment);
    gtk_widget_show(ui->alignment);

    gtk_window_set_title(GTK_WINDOW(ui->window), "erkeyb");
    gtk_container_set_border_width(GTK_CONTAINER(ui->window), 10);
    gtk_window_set_resizable(GTK_WINDOW(ui->window),FALSE);

    // use hint DOCK so it is hidden for fullscreen windows
    gtk_window_set_type_hint(GTK_WINDOW(ui->window), GDK_WINDOW_TYPE_HINT_DOCK);
    gtk_window_set_decorated(GTK_WINDOW(ui->window), FALSE);
    gtk_window_set_accept_focus(GTK_WINDOW(ui->window), FALSE);

    // resize and move to dock at the botton of the screen
    gtk_window_move(GTK_WINDOW(ui->window), 0, gdk_screen_height());
    gtk_window_set_resizable(GTK_WINDOW(ui->window), FALSE);

    ui->is_visible = FALSE;

    DBG_EXIT;
    return 0;
}

static gint keyboard_show(KeybUI* ui)
{
    DBG_ENTRY;
    DBG_ASSERT( ui != NULL ) ;
    DBG_ASSERT( ui->window != NULL ) ;

    ergtk_keyb_reset_keymap(ERGTK_KEYB(ui->keyb));

    if ( ui->is_visible == FALSE  )
    {
        gtk_widget_show_all(ui->window);
        ui->is_visible = TRUE;
    }
    else {
        DBG("Keyboard is already visible!\n");
    }

    DBG_EXIT;
    return 0;
}

static gint keyboard_hide(KeybUI* ui)
{
    DBG_ENTRY;
    DBG_ASSERT( ui != NULL ) ;
    DBG_ASSERT( ui->window != NULL ) ;

    if ( ui->is_visible == TRUE  )
    {
        gtk_widget_hide_all(ui->window);
        ui->is_visible = FALSE;
    }
    else {
        DBG("Keyboard is already hidden!\n");
    }

    DBG_EXIT;
    return 0;
}

static gint destroy_keyboard(KeybUI* ui)
{
    DBG_ENTRY;
    DBG_ASSERT( ui != NULL ) ;
    DBG_ASSERT(ui->window != NULL ) ;
    
    gtk_widget_hide_all(ui->window);
    ui->is_visible = FALSE;
    gtk_widget_destroy(ui->window);

    DBG_EXIT;
    return 0;
}

static gboolean finish_app_cb(GtkWidget* widget, gpointer data )
{
    DBG_ENTRY;
    KeybUI* k = (KeybUI*) data;

    DBG_ASSERT( k->window     == NULL ) ;
    DBG_ASSERT( k->keyb       == NULL ) ;
    DBG_ASSERT( k->alignment  == NULL ) ;
    DBG_ASSERT( k->is_visible == FALSE ) ;

    /* remove the watch from the main event loop and close the GIOChannel */
    g_io_channel_shutdown(k->sock_io_chan, FALSE, NULL);
    g_io_channel_unref(k->sock_io_chan);
    k->sock_io_chan = NULL ; 

    gtk_main_quit();
    DBG_EXIT;
    return FALSE;
}