sysd/src/display.c

Go to the documentation of this file.

/*
 * File Name: display.c
 */

/*
 * This file is part of sysd.
 *
 * sysd 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.
 *
 * sysd 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) 2008 iRex Technologies B.V.
 * All rights reserved.
 */

//----------------------------------------------------------------------------
// Include Files
//----------------------------------------------------------------------------

#include "config.h"

// system include files, between < >
#include <glib.h>
#include <gtk/gtk.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <arpa/inet.h>
#include <string.h>
#include <pthread.h>

// ereader include files, between < >
#include <liberipc/eripc.h>
#include <liberipc/eripc_support.h>
#include <liberutils/display_utils.h>

// local include files, between " "
#include "log.h"
#include "delta.h"
#include "system.h"
#include "tasks.h"
#include "xwindow.h"
#include "ipc.h"

#define UNUSED(x) (void)(x)


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

// TCP port for incoming GTK messages
#define DMPORT          50555
#define LOCALHOST       0x7f000001L // "127.0.0.1"

#define DM_MAXCHARONLINE 1024
#define DM_CMD_NAME       128
#define DM_ARGLENGTH      256
#define DM_N_ARG           16

// TCP port for incoming WM messages
#define WMPORT          50556
#define WM_NAME            64

#define WAVEFORM_QUICK          6 // WAVEFORM_1BPP_IMAGE
#define WAVEFORM_PARTIAL        9 // WAVEFORM_2BPP_IMAGE
#define WAVEFORM_FULL           1 // WAVEFORM_4BPP_IMAGE

// Times [ms] needed for the waveform playback during which delta is unavailable 
#define DELTA_TIME_FULL         900*1000 
// NOTE: not actual delay but this makes the soft keyboard act better
#define DELTA_TIME_QUICK        50*1000                 

typedef enum
{
    DM_INFO,      // automically by GTK
    DM_FORCE,     // forced by application
    DM_UNDEFINED
} DMCommandCode;

typedef struct
{
    int  pid;
    int  x, y;
    int  w, h;
    int  shouldIgnore;
    int  isWindow;
    int  windowType;
    char widgetType[64];
    int  isFocus;
} DMCommandInfo;

typedef struct
{
    int  pid;
    int  takeControl;
    int  hint;
} DMCommandForce;

typedef struct
{
    DMCommandCode cmd;
    DMCommandInfo info;
    DMCommandForce force;
} DMCommand;

typedef struct
{
    char    name[DM_CMD_NAME]; // Command Name
    int     cc;             // Command Code
    char    arg[DM_N_ARG][DM_ARGLENGTH];
    int     nArg;
} erDmCmd_t;

typedef struct
{
    char    name[WM_NAME];
    int     window;
    int     type;
    long    flags;
    int     pid;
} WMInfo;


typedef struct display_update_info DisplayUpdateInfo;
typedef struct wave_info WaveInfo;
typedef struct busy_info BusyInfo;

// Client Struct State flags, taken from structs.h of Matchbox WM 1.2
#define CLIENT_IS_SPLASH_WIN      (1<<0)
#define CLIENT_FULLSCREEN_FLAG    (1<<1)
#define CLIENT_TITLE_HIDDEN_FLAG  (1<<2)
#define CLIENT_SHRUNK_FOR_TB_FLAG (1<<3)
#define CLIENT_HELP_BUTTON_FLAG   (1<<4)
#define CLIENT_ACCEPT_BUTTON_FLAG (1<<5)
#define CLIENT_DOCK_NORTH         (1<<6)
#define CLIENT_DOCK_SOUTH         (1<<7)
#define CLIENT_DOCK_EAST          (1<<8)
#define CLIENT_DOCK_WEST          (1<<9)
#define CLIENT_WANTS_MASK_FLAG    (1<<10)
#define CLIENT_IS_MODAL_FLAG      (1<<11)
#define CLIENT_BORDERS_ONLY_FLAG  (1<<12)
#define CLIENT_IS_MESSAGE_DIALOG  (1<<14)
#define CLIENT_IS_DESKTOP_FLAG    (1<<15)
#define CLIENT_NEW_FOR_DESKTOP    (1<<16)
#define CLIENT_DOCK_TITLEBAR      (1<<17)
#define CLIENT_CUSTOM_BUTTON_FLAG (1<<18)
#define CLIENT_IS_MOVING          (1<<19)
#define CLIENT_DOCK_TITLEBAR_SHOW_ON_DESKTOP (1<<20)
#define CLIENT_NO_FOCUS_ON_MAP    (1<<21)
#define CLIENT_IS_MINIMIZED       (1<<23)
#define CLIENT_TOOLBARS_MOVED_FOR_FULLSCREEN (1<<24)
#define CLIENT_IS_TRANSIENT_FOR_ROOT (1<<25)
#define CLIENT_HAS_URGENCY_FLAG   (1<<26)
#define CLIENT_HAS_ABOVE_STATE    (1<<27)
#define CLIENT_IS_MENU_DIALOG     (1<<30)
#define CLIENT_DELAY_MAPPING      (1<<31)

// Client window types, taken from structs.h of Matchbox WM 1.2
typedef enum 
{ 
  MBCLIENT_TYPE_DIALOG    = (1<<1),
  MBCLIENT_TYPE_TOOLBAR   = (1<<2),
  MBCLIENT_TYPE_PANEL     = (1<<3),
  MBCLIENT_TYPE_TASK_MENU = (1<<4),
  MBCLIENT_TYPE_APP       = (1<<5),
  MBCLIENT_TYPE_DESKTOP   = (1<<6),
  MBCLIENT_TYPE_OVERRIDE  = (1<<7),
  MBCLIENT_TYPE_ANY       = (1<<8)
} MBClientTypeEnum;


//----------------------------------------------------------------------------
// Constants
//----------------------------------------------------------------------------

#define N_FILENAME              1024
#define BUFFERSIZE              1024
#define BUSY_ANIMATION_SPEED    50

#if MACHINE_IS_DR800SG || MACHINE_IS_DR800S || MACHINE_IS_DR800SW
#define UPDATE_TIMEOUT_FORCED              50
#define UPDATE_TIMEOUT_NORMAL_PORTRAIT    300 /* can be quicker but increases double updates */
#define UPDATE_TIMEOUT_NORMAL_LANDSCAPE   600
#define UPDATE_TIMEOUT_KEY                 24
#define UPDATE_TIMEOUT_CURSOR              60 /* can be quicker but makes successive updates slower */
#define UPDATE_TIMEOUT_TYPE                60 /* can be quicker but makes successive updates slower */
#define UPDATE_TIMEOUT_SCRIBBLE           150 /* can be quicker but makes successive updates slower */
#define UPDATE_AREA_CONTENT               744*806
#define UPDATE_AREA_FULL                  768*1024
#elif MACHINE_IS_DR1000S || MACHINE_IS_DR1000SW
#define UPDATE_TIMEOUT_FORCED              80
#define UPDATE_TIMEOUT_NORMAL_PORTRAIT    450 /* can be quicker but increases double updates */
#define UPDATE_TIMEOUT_NORMAL_LANDSCAPE   900
#define UPDATE_TIMEOUT_KEY                 40
#define UPDATE_TIMEOUT_CURSOR             100 /* can be quicker but makes successive updates slower */
#define UPDATE_TIMEOUT_TYPE               100 /* can be quicker but makes successive updates slower */
#define UPDATE_TIMEOUT_SCRIBBLE           250 /* can be quicker but makes successive updates slower */
#define UPDATE_AREA_CONTENT               1000*1010
#define UPDATE_AREA_FULL                  1024*1280
#else
#error Unhandled machine type
#endif


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

static int       fbDev                  = 0;
static int       useSpecialWaveform     = 0;
static DMCommand DisplayCommand;
static WMInfo    WindowInfo;
static uint64_t  deltaAvailableAgain    = 0;
static GSList    *g_ignorelist          = NULL;

static int      g_ctb_window            = 0;
static int      g_prev_window           = 0;
static gboolean g_display_locked        = FALSE;
static gboolean g_vcom_is_set           = FALSE;

static pthread_t dm_thread;
static struct timeval g_timeout;


//============================================================================
// Local Function Definitions
//============================================================================

static gboolean handle_gtk_socket   (GIOChannel* source, GIOCondition condition, gpointer data);
static gint parse_message           (char *szCommand, erDmCmd_t *pCmd);
static gint parse_command           (erDmCmd_t *pCmd, DMCommand *command);
static void get_arguments           (char *pChar, erDmCmd_t * pCmd, int nReqArgs);
static void on_message_timeout      (void);
static void* gtk_messages           (void *arg);
static void display_update          (gint waveform);
static void schedule_update         (gint delay, const char *rule);

static gint delta_vcom_set          (gfloat vcom);
static int  delta_uploadwave        (char *filename, glong offset);
static gint delta_erase             (gint color);
static gint delta_update_display    (DisplayUpdateInfo *displayUpdateInfo);
static gint delta_busy              (gint xpos, gint ypos, gint speed);
static void delta_init              (void);

static gboolean ignore_pid          (gint pid);
static void ignore_pid_add          (gint pid);
static void ignore_pid_remove       (gint pid);

static gboolean locked_display      (void) { return g_display_locked; }
static void lock_display            (void) { g_display_locked = TRUE; }
static void unlock_display          (void) { g_display_locked = FALSE; }


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

static void parse_wm_messages(char* buffer)
{
    // handle single message
    gchar **args = g_strsplit_set(buffer, ",", 4);

    gint window = atoi(args[0]);
    gint type   = atoi(args[1]);
    glong flags  = atol(args[2]);
    gchar *endp   = strchr(args[3], ' ');
    if (endp) {
        *endp = '\0';
    }
    gchar *name   = args[3];

    proc_t *proc = process_get_by_name(name);

    if ( ((type & MBCLIENT_TYPE_DIALOG) == MBCLIENT_TYPE_DIALOG) &&
         ((flags & CLIENT_IS_MENU_DIALOG) != CLIENT_IS_MENU_DIALOG) )
    {
        DMPPRINTF("ignored dialog, window [%d] name [%s] pid [%d]", WindowInfo.window, name, proc ? proc->pid : -1);
    }
    else
    {
        if ( (g_prev_window != window) &&
             ((flags & CLIENT_IS_MENU_DIALOG) != CLIENT_IS_MENU_DIALOG) )
        {
            LOGPRINTF("changed window and not menu, deactivate previous: %d", g_prev_window);

            // new window set as foreground, send deactivated to window
            if (g_prev_window > 0)
            {
                const gchar *service = task_service_by_window(g_prev_window);
                if (service)
                {
                    ipc_send_window_deactivated(service,  g_prev_window);
                }
                else if (g_ctb_window != 0 && g_prev_window == g_ctb_window)
                {
                    ipc_send_window_deactivated("com.irexnet.ctb", g_ctb_window);
                }
            }

            if (window > 0)
            {
                // send activatedWindow to window's application
                const gchar *service = task_service_by_window(window);
                if (service)
                {
                    ipc_send_window_activated(service, window);
                }
                else if (g_ctb_window != 0 && window == g_ctb_window)
                {
                    ipc_send_window_activated("com.irexnet.ctb", g_ctb_window);
                }
            }
            g_prev_window = window;
        }

        // set current window info
        strncpy(WindowInfo.name, name, WM_NAME);
        WindowInfo.name[WM_NAME-1] = '\0';
        WindowInfo.window = window;
        WindowInfo.type   = type;
        WindowInfo.flags  = flags;
        WindowInfo.pid    = proc ? proc->pid : -1;

        DMPPRINTF("set window info [%d] type [%d] flags [%ld] name [%s] pid [%d]",
                  WindowInfo.window, WindowInfo.type, WindowInfo.flags, WindowInfo.name,
                  WindowInfo.pid);
    }

    // force next update to be full screen
    useSpecialWaveform = WAVEFORM_FULL;

    g_strfreev(args);
}


gboolean handle_wm_socket(GIOChannel* source, GIOCondition condition, gpointer data)
{
    UNUSED(data);
    
    if (condition != G_IO_IN) {
        WARNPRINTF("%s() UNKNOWN CONDITION (%d)", __func__, condition);
        return FALSE;
    }

    gchar* buffer = NULL;
    gsize bytes_read = 0;
    gsize last_byte = 0;
    GError *error = NULL;
    g_io_channel_read_line(source, &buffer, &bytes_read, &last_byte, &error);
    buffer[last_byte] = 0;
    if (error) {
        WARNPRINTF("WM socket read failed: %s", error->message);
        g_error_free(error);
    } else {
        parse_wm_messages(buffer);
    }
    g_free(buffer);
    return TRUE;    // keep listening
}


void display_set_services()
{
    LOGPRINTF("entry");
    
    if (pthread_create(&dm_thread, NULL, gtk_messages, NULL) != 0)
    {
        ERRORPRINTF("Could not create thread");
        return;
    }

    // add GIOChannel for WM socket
    //
    int sockfd = socket(PF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) {
        perror("Error invoking socket");
        return;
    }
    bzero(&WindowInfo, sizeof(WMInfo));
    struct sockaddr_in server_addr;
    bzero(&server_addr, sizeof(struct sockaddr_in));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(WMPORT);
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    memset(server_addr.sin_zero, 0, sizeof(server_addr.sin_zero));

    int error = bind(sockfd, &server_addr, sizeof(server_addr));
    if (error) {
        perror("Error invoking bind");
        return;
    }
    GIOChannel* channel = g_io_channel_unix_new(sockfd);
    g_io_channel_set_encoding(channel, NULL, NULL);
    g_io_add_watch(channel, G_IO_IN|G_IO_PRI|G_IO_ERR, handle_wm_socket, NULL);
}


void display_blank(void)
{
    LOGPRINTF("entry");

    // cancel scheduled dislay update 
    if (g_timeout.tv_sec > 0 || g_timeout.tv_usec > 0) 
    { 
        bzero(&DisplayCommand, sizeof(DMCommand));
        g_timeout.tv_sec = -1;
        g_timeout.tv_usec = -1;
    }

    // clear display
    delta_erase(15);   
}


void display_busy_animation(gint xpos, gint ypos)
{
    LOGPRINTF("entry: x %d, y %d", xpos, ypos);
    delta_busy(xpos, ypos, BUSY_ANIMATION_SPEED);
}


gchar *display_get_active_window(void)
{
    LOGPRINTF("entry");
    return WindowInfo.name;
}


void display_cleanup_pid(gint pid)
{
    LOGPRINTF("entry");
    ignore_pid_remove(pid);    
}


void display_set_vcom(gfloat vcom)
{
    LOGPRINTF("entry [%f]", vcom);
    delta_vcom_set(vcom);
}


void display_set_waveforms(void)
{
    LOGPRINTF("entry");
    delta_uploadwave("/var/tmp/waves", 0);
}


void display_init(void)
{
    LOGPRINTF("entry");
    delta_init();
}


//============================================================================
// Local Function Implementation
//============================================================================

static uint64_t getCurrentTime() 
{
    struct timespec now;

    clock_gettime(CLOCK_MONOTONIC, &now);
    u_int64_t now64 = now.tv_sec;
    now64 *= 1000000;
    now64 += (now.tv_nsec/1000);
    return now64;
}


static gboolean ignore_pid(gint pid)
{
    // just test if ANY pid ignored
    return (g_slist_length(g_ignorelist) > 0);
}


static void ignore_pid_add(gint pid)
{
    LOGPRINTF("entry [%d]", pid);

    GSList *found = g_slist_find(g_ignorelist, (gconstpointer) pid);
    if (found == NULL) 
    {
        LOGPRINTF("added [%d]", pid);
        g_ignorelist = g_slist_prepend(g_ignorelist, (gpointer) pid);
    }
}


static void ignore_pid_remove(gint pid)
{
    LOGPRINTF("entry [%d]", pid);
    g_ignorelist = g_slist_remove(g_ignorelist, (gpointer) pid);
}


static void promote_waveform(gint waveform)
{
    if (useSpecialWaveform == waveform)
        return;
    
    switch (waveform)
    {
    case WAVEFORM_QUICK: 
        if (useSpecialWaveform == 0)
        {
            useSpecialWaveform = waveform;
        }
        break;
                
    case WAVEFORM_PARTIAL: 
        if ((useSpecialWaveform == 0) || (useSpecialWaveform  == WAVEFORM_QUICK))
        {
            useSpecialWaveform = waveform;
        }
        break;
                
    case WAVEFORM_FULL: 
    default: 
        useSpecialWaveform = waveform;
        break;
    }
}


static void parse_gtk_message(char* buffer)
{    
//    LOGPRINTF("entry");

#if DMLOGGING_ON
    static GTimeVal   oldtime = {0};
#endif    
    erDmCmd_t  cmd;
    DMCommand  command;
    bzero(&command, sizeof(command));

    if ((parse_message(buffer, &cmd)==0) && (parse_command(&cmd, &command) == 0))
    {
#if DMLOGGING_ON
        GTimeVal curtime;
        g_get_current_time(&curtime);
        
        guint timediff = ((curtime.tv_sec - oldtime.tv_sec) * 1000) + 
            ((curtime.tv_usec / 1000 ) - (oldtime.tv_usec / 1000));
#endif

        if (command.cmd == DM_FORCE)
        {
            DMCommandForce force = command.force;
            
            DMPPRINTF("%ld:%3ld [%4d] checking msg: %d, %d, %d", 
                curtime.tv_sec, curtime.tv_usec / 1000, timediff, 
                force.pid, force.takeControl, force.hint); 

            if (force.takeControl > 0)
            {
                DMPPRINTF(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
                ignore_pid_add(force.pid);
                if (!locked_display() && (g_timeout.tv_sec > 0 || g_timeout.tv_usec > 0))
                {
                    // cancel pending update
                    DMPPRINTF("cancel pending update");
                    bzero(&DisplayCommand, sizeof(DMCommand));
                    g_timeout.tv_sec = -1;
                    g_timeout.tv_usec = -1;
                }
            }
            else
            {
                DMPPRINTF("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
                ignore_pid_remove(force.pid);
            }
            
            if (force.hint != DM_HINT_NONE)
            {
                gint update_delay = UPDATE_TIMEOUT_FORCED;
                switch (force.hint)
                {
                    case DM_HINT_LOCK:
                        lock_display();
                        break;
                    case DM_HINT_UNLOCK:
                        unlock_display();
                        break;
                    case DM_HINT_FULL:
                    case DM_HINT_SPLASH:
                        useSpecialWaveform = WAVEFORM_FULL;
                        break;
                    case DM_HINT_CURSOR:
                        useSpecialWaveform = WAVEFORM_QUICK;
                        break;
                    case DM_HINT_PARTIAL:
                        useSpecialWaveform = WAVEFORM_PARTIAL;
                        break;
                    case DM_HINT_KEY:
                        update_delay = 20;
                        useSpecialWaveform = WAVEFORM_QUICK;
                        break;
                    default:
                        WARNPRINTF("unsupported display manager hint [%d]", force.hint);
                        useSpecialWaveform = WAVEFORM_FULL;
                        break;
                }

                if (sys_get_orientation() != ORIENTATION_PORTRAIT)
                {
                    // account for slower updates when display is rotated
                    switch (force.hint)
                    {
                        case DM_HINT_FULL:
                            update_delay = UPDATE_TIMEOUT_NORMAL_LANDSCAPE;
                            break;
                        case DM_HINT_SPLASH:
                            // splash screens are shown in portrait mode
                            update_delay = UPDATE_TIMEOUT_NORMAL_PORTRAIT; 
                            break;
                        case DM_HINT_PARTIAL:
                            update_delay = UPDATE_TIMEOUT_NORMAL_LANDSCAPE;
                            break;
                        case DM_HINT_CURSOR:
                        case DM_HINT_KEY:
                            update_delay = 150;
                            break;
                        case DM_HINT_LOCK:
                        case DM_HINT_UNLOCK:
                            break;
                        default:
                            WARNPRINTF("unsupported display manager hint [%d]", force.hint);
                            break;
                    }
                }

                if ( (!locked_display() && !(force.hint == DM_HINT_UNLOCK)) || (force.hint == DM_HINT_SPLASH)  )
                {
                    schedule_update(update_delay, "forced by application");
                }
            }
        }
        else if (command.cmd == DM_INFO) 
        {
            DMCommandInfo  info  = command.info;
            const gchar   *rule        = NULL;
            gboolean      save         = FALSE;
            gboolean      trigger      = FALSE;
            gboolean      skip         = FALSE;
            guint         area_pending = DisplayCommand.info.w * DisplayCommand.info.h;
            gboolean      is_portait   = (sys_get_orientation() == ORIENTATION_PORTRAIT) ? TRUE : FALSE;
            gboolean      is_pending   = (area_pending > 0) ? TRUE : FALSE;
            guint      delay        = is_portait ? UPDATE_TIMEOUT_NORMAL_PORTRAIT : UPDATE_TIMEOUT_NORMAL_LANDSCAPE;
            guint         area         = info.w * info.h;
            
            if ((info.pid != -1) && ignore_pid(info.pid) && 
                (strcmp(info.widgetType,"erGtkBusyDialog") != 0) && (strcmp(info.widgetType,"GtkMessageDialog") != 0))
            {
                // skip updates when busy or loading dialog is shown
                skip = TRUE;
            }

            DMPPRINTF("%ld:%3ld [%4d] %s pid [%d] %4dx%4d flags: i[%d] w[%d] t[%d] f[%d] %s",
                curtime.tv_sec, curtime.tv_usec / 1000, timediff, skip ? "SKIPPED" : "checking", 
                info.pid, info.w, info.h, info.shouldIgnore,
                info.isWindow, info.windowType, info.isFocus,
                info.widgetType);
            
            //
            // SPECIAL RULES - pre
            //
           
            if (!is_pending && info.h == 32 &&
                strcmp(info.widgetType, "GtkEventBox") == 0)
            {
                rule = "statusbar";
                promote_waveform(WAVEFORM_PARTIAL);
                save  = TRUE;
            }

            if (!is_pending && strcmp(info.widgetType,"GtkEntry")==0)
            {
                rule = "keyboard entry";
                promote_waveform( WAVEFORM_QUICK);
                delay = UPDATE_TIMEOUT_TYPE;
                save  = TRUE;
            }
            
            //
            // GENERAL RULES
            //

            if (!info.shouldIgnore ||
                (strcmp(info.widgetType,"HtmlView")         == 0) || /* for libgtkhtml */
                (strcmp(info.widgetType,"GtkDrawingArea")   == 0) ||
                (strcmp(info.widgetType,"GtkCalendar")      == 0) ||
                (strcmp(info.widgetType,"GtkTreeView")      == 0) ||
                (strcmp(info.widgetType,"GtkIconView")      == 0) ||
                (strcmp(info.widgetType,"erGtkIconView")    == 0) ||
                (strcmp(info.widgetType,"erGtkListView")    == 0) ||
                (strcmp(info.widgetType,"erGtkNetworkList") == 0) ||
                (strcmp(info.widgetType,"WebKitWebView")    == 0) ||
                (strcmp(info.widgetType,"GtkMenu")          == 0) ||
                (strcmp(info.widgetType,"GtkProgressBar")   == 0) )
            {
                if (!is_pending &&
                    info.isFocus && 
                    (area<UPDATE_AREA_CONTENT) &&
                    ((strcmp(info.widgetType, "erGtkIconView") == 0) ||
                     (strcmp(info.widgetType, "erGtkNetworkList") == 0) ||
                     (strcmp(info.widgetType, "erGtkListView") == 0)) ) 
                {
                    rule = "cursor";
                    promote_waveform(WAVEFORM_QUICK);
                    delay = is_portait ? UPDATE_TIMEOUT_CURSOR : 3*UPDATE_TIMEOUT_CURSOR;
                    save  = TRUE;
                }
                else if (strcmp(WindowInfo.name, "erbrowser") == 0)
                {
                    if ( !((strcmp(info.widgetType, "GtkWindow") == 0) && is_pending)
                        && ((area * 3) < UPDATE_AREA_FULL) )
                    {
                        rule = "paint, partial (browser)";
                        promote_waveform(WAVEFORM_PARTIAL);
                    }
                    else
                    {
                        rule = "paint, full (browser)";
                        promote_waveform(WAVEFORM_FULL);
                        delay = 1000;
                    }
                    save = TRUE;
                }
                else if (area > area_pending)
                {
                    if ((area * 3) < UPDATE_AREA_FULL)
                    {
                        promote_waveform(WAVEFORM_PARTIAL);
                        rule = "paint, partial";
                    }
                    else
                    {
                        promote_waveform(WAVEFORM_FULL);
                        rule = "paint, full";
                        
                        if (is_portait && strcmp(info.widgetType,"GtkDrawingArea") == 0)
                        {
                            rule = "paint, full (UDS)";
                            delay /= 2;
                        }
                    }
                    save = TRUE;
                }
                else if (is_pending)
                {
                    if (is_portait && strcmp(info.widgetType,"erGtkIconView")  == 0)
                    {
                        delay /= 2;
                    }
                    rule    = "delay";
                    trigger = TRUE;
                }
            }
            
            //
            // SPECIAL RULES - post - override general rules
            //
           
            if (!is_pending && info.h == 29 && 
                ((strcmp(info.widgetType,"GtkMessageDialog")==0) ||
                 (strcmp(info.widgetType,"GtkDialog")==0)))
            {
                rule = "button cursor";
                useSpecialWaveform = WAVEFORM_QUICK;
                delay = is_portait ? UPDATE_TIMEOUT_CURSOR : 2*UPDATE_TIMEOUT_CURSOR;
                save  = TRUE;
            }
            
            if (!is_pending && strcmp(info.widgetType,"erscribble")==0)
            {
                rule = "scribble";
                useSpecialWaveform = WAVEFORM_PARTIAL;
                delay = UPDATE_TIMEOUT_SCRIBBLE;
                save  = TRUE;
            }
            
            // NOTE: check is_pending
            if (is_pending && 
                (useSpecialWaveform != WAVEFORM_FULL) &&
                ( (strcmp(info.widgetType, "WebKitWebView")==0) ||
                  (strcmp(info.widgetType, "GtkEntry")==0) ) )
            {
                rule = "entry speedup";
                save = FALSE;
                delay /= 2;
                trigger = FALSE;
            }
            
            //
            // Save command and (re)set timeout
            //
            
            if (save)
            {
                DMPPRINTF("%ld:%3ld save area %d (rule: %s)", curtime.tv_sec, curtime.tv_usec / 1000, area, rule);
                
                memcpy(&DisplayCommand, &command, sizeof(DMCommand));
                trigger = TRUE;
            }
                
            if (trigger && !skip)
            {
                schedule_update(delay, rule);
            }
        }
#if DMLOGGING_ON
        memcpy(&oldtime, &curtime, sizeof(GTimeVal));
#endif                
    }
}


static void schedule_update(gint mdelay, const char *rule)
{
    gulong udelay;
    
    // check if sending screen updates too fast
    uint64_t now = getCurrentTime();
#if DMLOGGING_ON
    guint prev_delay = mdelay;
#endif                
    // adjust delay to after delta is available again
    // except when time was set back as deltaAvailableAgain can't be trusted then
    if (((deltaAvailableAgain != 0) && ((now + mdelay*1000) < deltaAvailableAgain))
        && ((deltaAvailableAgain - DELTA_TIME_FULL) < now))
    {
        udelay = (deltaAvailableAgain - now);
    }
    else
    {
        udelay = mdelay * 1000;
    }

    // set new timeout
    g_timeout.tv_sec  = udelay / G_USEC_PER_SEC;
    g_timeout.tv_usec = udelay % G_USEC_PER_SEC;
    
    DMPPRINTF("set delay %ld.%03d [was 0.%03d] (rule: %s)", g_timeout.tv_sec, g_timeout.tv_usec/1000, prev_delay, rule);
}


static void display_update(gint waveform)
{
    DisplayUpdateInfo displayUpdateInfo;
    
    displayUpdateInfo.color = 0;
    displayUpdateInfo.waveform = waveform;
    
#if DMLOGGING_ON 
    GTimeVal curtime;
    g_get_current_time(&curtime);
    
    DMPPRINTF("\n\n%ld:%3ld update waveform %d\n",
           curtime.tv_sec, curtime.tv_usec / 1000, 
           displayUpdateInfo.waveform);
#endif

    // init VCOM for delta driver
    if (!g_vcom_is_set)
    {
        display_set_vcom(sys_get_display_vcom());
        g_vcom_is_set = TRUE;
    }

    // perform display update
    delta_update_display(&displayUpdateInfo);
    
    // reset idle timer
    sys_reset_idle_time();
}


static void on_message_timeout(void)
{
    gint waveform = WAVEFORM_FULL;
    
    if (useSpecialWaveform != 0)
    {
        waveform = useSpecialWaveform;
    }

    // set time when delta is available again
    deltaAvailableAgain = getCurrentTime();
    if ((waveform == WAVEFORM_FULL) || (waveform == WAVEFORM_PARTIAL)) 
    {
        deltaAvailableAgain += DELTA_TIME_FULL;
    } 
    else if (waveform == WAVEFORM_QUICK) 
    {
        deltaAvailableAgain += DELTA_TIME_QUICK;
    }
    
    // reset display command
    bzero(&DisplayCommand, sizeof(DMCommand));
    useSpecialWaveform = 0;
    
    // perform display update
    display_update(waveform);

    g_timeout.tv_sec = -1;
    g_timeout.tv_usec = -1;
}


static int delta_uploadwave(char *filename, glong offset)
{
    LOGPRINTF("entry");

    int ret = 0;
    FILE *file = NULL;
    WaveInfo info;
    
    // open the wave file
    file = fopen(filename, "rb");
    if (file == NULL)
    {
        ERRORPRINTF("Error opening file %s", filename);
        return -1;
    }
    
    if (offset > 0)
    {
        if (fseek(file, offset, SEEK_SET) != 0)
        {
            ERRORPRINTF("Error seeking file in %s [%d]", filename, errno);
            return -1;
        }
    }
    
    info.wave = malloc(WAVEFORM_SIZE);
    if (info.wave == NULL)
    {
        ERRORPRINTF("Not enough memory\n");
        return -1;
    }
    
    info.size = fread(info.wave, 1, WAVEFORM_SIZE, file);

    // close the image
    fclose(file);

    ret = ioctl(fbDev, FBIO_DELTA_UPLOADWAVES, &info);
    if (ret != 0)
    {
        ERRORPRINTF("Error sending FBIO_DELTA_UPLOADWAVES: %x", ret);
    }
    
    free(info.wave);

    return ret;
}


static void delta_init()
{
    LOGPRINTF("entry");
    
    gint ret = 0;
    
    if ((ret = ioctl(fbDev, FBIO_DELTA_INIT, NULL)))
    {
        ERRORPRINTF("Error sending FBIO_DELTA_INIT: %x\n", ret);
    }
}


static gint delta_vcom_set(gfloat vcom)
{
    LOGPRINTF("entry");

    glong vcom_int = 0;
    gint ret = 0;
    
    if(vcom < -5) 
    {
        vcom = -5;
    }
    else if(vcom > 5) 
    {
        vcom = 5;
    }
    
    vcom_int = (signed long)(1000 * vcom);
    
    if ((ret=ioctl(fbDev, FBIO_DETA_VCOM_SET, &vcom_int)))
    { 
        ERRORPRINTF("Error sending FBIO_DETA_VCOM_SET: %x",ret); 
    }
    
    return ret;    
}


static gint delta_erase(gint color)
{
    LOGPRINTF("entry");

    DisplayUpdateInfo updateinfo;
    
    updateinfo.waveform = 0; // full
    updateinfo.color = color;
    
    color = ((color & 0xf) << 4) + color;
    
    int ret =  ioctl(fbDev, FBIO_DELTA_ERASE, &updateinfo);
    if (ret != 0)
    { 
        ERRORPRINTF("Error sending FBIO_DELTA_ERASE: %x",ret); 
    }
    return ret;
}


static gint delta_busy(gint xpos, gint ypos, gint speed)
{
    LOGPRINTF("entry");
    
    BusyInfo info;

    info.x     = (unsigned short) xpos;
    info.y     = (unsigned short) ypos;
    info.delay = (unsigned short) speed;

    int ret = ioctl(fbDev, FBIO_DELTA_BUSY, &info);
    if (ret != 0)
    { 
        ERRORPRINTF("Error sending FBIO_DELTA_BUSY: %x",ret);
    }
    return ret;
}


static gint delta_update_display(DisplayUpdateInfo *displayUpdateInfo) 
{
//    LOGPRINTF("entry");

    int ret = ioctl(fbDev, FBIO_DELTA_UPDATE_DISPLAY, displayUpdateInfo);
    if (ret != 0)
    {
        ERRORPRINTF("Error sending FBIO_DELTA_UPDATE_DISPLAY: %x", ret);
    }
    return ret;
}


static gint parse_message(char *szCommand, erDmCmd_t * pCmd)
{
    int     i;
    char   *pChar;
    char    szToken[DM_MAXCHARONLINE];

    pCmd->cc = (int) DM_UNDEFINED;
    for (i = 0; i < DM_N_ARG; i++)
    {
        strcpy(pCmd->arg[i], "");
    }

    // parse command, form of a command is: !n1,n2,n3...
    if (szCommand[0] != '!')
    {
        ERRORPRINTF("Command should start with \'!\'. (%s)", szCommand);
        return -1;
    }

    // move beyond initial '!'
    pChar = szCommand + 1;
    i = 0;
    while (*pChar != '\0')
    {
        szToken[i] = '\0';
        if (*pChar == ',')
        {
            pChar++;
            break;
        }
        szToken[i] = *pChar++;
        i++;
        szToken[i] = '\0';
    }

    // we have found the command token, figure out what the command is
    if (!strcmp(szToken, "I"))
    {
        strcpy(pCmd->name, szToken);
        pCmd->cc = DM_INFO;
        pCmd->nArg = 10;
    }
    else if (!strcmp(szToken, "F"))
    {
        strcpy(pCmd->name, szToken);
        pCmd->cc = DM_FORCE;
        pCmd->nArg = 3;
    }
    else
    {
        return -1;
    }

    if (pCmd->nArg > 0)
    {
        get_arguments(pChar, pCmd, pCmd->nArg);
    }
    return 0;
}


static gint parse_command(erDmCmd_t *pCmd, DMCommand *command)
{
    switch (pCmd->cc)
    {
    case DM_INFO:
        command->cmd                = DM_INFO;
        command->info.pid           = atoi(pCmd->arg[0]);
        command->info.x             = atoi(pCmd->arg[1]);
        command->info.y             = atoi(pCmd->arg[2]);
        command->info.w             = atoi(pCmd->arg[3]);
        command->info.h             = atoi(pCmd->arg[4]);
        command->info.shouldIgnore  = atoi(pCmd->arg[5]);
        command->info.isWindow      = atoi(pCmd->arg[6]);
        command->info.windowType    = atoi(pCmd->arg[7]);
        strcpy(command->info.widgetType,pCmd->arg[8]);   
        command->info.isFocus       = atoi(pCmd->arg[9]);
        break;

    case DM_FORCE:
        command->cmd                = DM_FORCE;
        command->force.pid          = atoi(pCmd->arg[0]);
        command->force.takeControl  = atoi(pCmd->arg[1]);
        command->force.hint         = atoi(pCmd->arg[2]);
        break;

    default:
        ERRORPRINTF("Undefined command");
        return -1;
        break;
    }
    return 0;
}


static void get_arguments(char *pChar, erDmCmd_t * pCmd, int nReqArgs)
{
    int     nArg;
    int     i;
    char    szToken[DM_MAXCHARONLINE];

    for (nArg = 0; nArg < nReqArgs; nArg++)
    {
        i = 0;
        while (*pChar != '\0')
        {
            szToken[i] = '\0';
            if (*pChar == ',')
            {
                pChar++;
                break;
            }
            szToken[i] = *pChar++;
            i++;
            szToken[i] = '\0';
        }
        strcpy(pCmd->arg[nArg], szToken);
    }
}


void display_set_ctb_window(gint wid)
{
    g_ctb_window = wid;
}


static void *gtk_messages(void *arg)
{
    int        sockfd = -1;
    int        error = 0;
    struct     sockaddr_in server_addr;
    DMCommand  command;
    erDmCmd_t  cmd;
    gchar      buffer[BUFFERSIZE];
    gsize      n;
    
    // open framebuffer device
    fbDev = open("/dev/fb0", O_RDWR);
    if (fbDev == -1)
    {
        ERRORPRINTF("Cannot open framebufferdevice. # mknod /dev/fb0 c 29 0");
        return NULL;
    }

    // create and bind socket
    //
    sockfd = socket(PF_INET, SOCK_DGRAM, 0);
    bzero(&server_addr, sizeof(struct sockaddr_in));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(DMPORT);
    server_addr.sin_addr.s_addr = htonl(LOCALHOST);
    memset(server_addr.sin_zero, '\0', sizeof(server_addr.sin_zero));
    
    bzero(&DisplayCommand, sizeof(DMCommand));
    
    error = bind(sockfd, &server_addr, sizeof(server_addr));
    if (error)
    {
        perror("Error invoking bind");
        return NULL;
    }
    
    int retval;
    fd_set rfds;
    
    // process incoming messages
    //
    for (;;)
    {
        FD_ZERO(&rfds);
        FD_SET(sockfd, &rfds);
        
        if (g_timeout.tv_sec > 0 || g_timeout.tv_usec > 0) 
        {
//            WARNPRINTF("wait for data or timeout");
            retval = select(sockfd+1, &rfds, NULL, NULL, &g_timeout);
        }
        else
        {
//            WARNPRINTF("wait for data indefinately");
            retval = select(sockfd+1, &rfds, NULL, NULL, NULL);
        }
        
        if (retval == -1 && errno == EINTR)
        {
            continue;        
        }
        if (retval < 0)
        {
            ERRORPRINTF("error in select");
            return arg;
        }
        if (retval > 0)
        {
            if (FD_ISSET(sockfd, &rfds))
            {
//                WARNPRINTF("data available");
                recv(sockfd, buffer, BUFFERSIZE, MSG_PEEK);
                gint state  = sys_get_power_state();
                if ((state == STATE_POWER_IDLE) || (state == STATE_POWER_STANDBY))
                {
                    // device is not ready, check again after a little while
                    g_usleep(10*1000);
                    continue;
                }
                
                n = recv(sockfd, buffer, BUFFERSIZE, 0);
                buffer[n] = '\0';
                parse_gtk_message(buffer);
            }
            else
            {
                WARNPRINTF("huh? data for other channel");
            }
        }
        else
        {
            if (g_timeout.tv_sec >= 0 || g_timeout.tv_usec >= 0) 
            {
//                WARNPRINTF("timeout, update");
                on_message_timeout();
            }
            else
            {
//                WARNPRINTF("timeout was reset");
            }
        }
    }
    return arg;
}