dm.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>

// 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 display_update_info DisplayUpdateInfo;
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_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_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 guint     g_timeout              = 0;
static DMCommand DisplayCommand;
static uint64_t  deltaAvailableAgain    = 0;
static GSList    *g_ignorelist          = NULL;

static gboolean g_display_locked        = FALSE;


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; }


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 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

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

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);
    }
}

static gint parse_message(char *szCommand, erDmCmd_t * pCmd)
{
    LOGPRINTF("entry");
    
    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 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 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 gboolean on_message_timeout(gpointer data)
{
    LOGPRINTF("entry");
    
    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);
    
    // stop timeout
    return FALSE;
}


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 schedule_update(gint delay, const char *rule)
{
    // check if sending screen updates too fast
    uint64_t now = getCurrentTime();
#if DMLOGGING_ON
    guint prev_delay = delay;
#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 + delay*1000) < deltaAvailableAgain))
        && ((deltaAvailableAgain - DELTA_TIME_FULL) < now))
    {
        delay = (deltaAvailableAgain - now) / 1000;
    }

    // set new timeout
    if (g_timeout > 0) {  
        DMPPRINTF("cancel t/o [%d]", g_timeout);
        g_source_remove(g_timeout);
        g_timeout= 0;
    }
    g_timeout = g_timeout_add(delay, on_message_timeout, NULL);
    
    DMPPRINTF("set delay %d [was %d] (rule: %s) t/o [%d]", delay, prev_delay, rule, g_timeout);
}



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 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 void parse_gtk_messages(char* buffer)
{    
#if DMLOGGING_ON
    GTimeVal   oldtime = {0};
#endif    
    DMCommand  command;
    erDmCmd_t  cmd;

    LOGPRINTF("entry");

    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())
                {
                    DMPPRINTF("cancel pending update");
                    // cancel pending update
                    bzero(&DisplayCommand, sizeof(DMCommand));
                    if (g_timeout > 0) 
                    { 
                        g_source_remove(g_timeout);
                        g_timeout = 0;
                    }
                }
            }
            else
            {
                DMPPRINTF("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
                ignore_pid_remove(force.pid);
            }
            
            if (force.hint != DM_HINT_NONE)
            {
                gint update_delay = 50;
                switch (force.hint)
                {
                    case DM_HINT_LOCK:
                        lock_display();
                        break;
                    case DM_HINT_UNLOCK:
                        unlock_display();
                        break;
                    case DM_HINT_FULL:
                        useSpecialWaveform = WAVEFORM_FULL;
                        break;
                    case DM_HINT_SPLASH:
                        update_delay = UPDATE_TIMEOUT_NORMAL_PORTRAIT;
                        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 = 200;
                            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_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   = TRUE;
//                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                
    }
}



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

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


int main(int argc, char *argv[])
{
    GMainLoop* gloop;
    g_type_init();
    gloop = g_main_loop_new(NULL, FALSE);

    // open framebuffer device
    fbDev = open("/dev/fb0", O_RDWR);
    if (fbDev == -1)
    {
        ERRORPRINTF("Cannot open framebufferdevice. # mknod /dev/fb0 c 29 0");
        return 0;
    }

    // add GIOChannel for WM socket
    int sockfd = socket(PF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) {
        perror("Error invoking socket");
        return 0;
    }
    struct sockaddr_in server_addr;
    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(INADDR_ANY);
    memset(server_addr.sin_zero, 0, sizeof(server_addr.sin_zero));

    int error = bind(sockfd, (struct sockaddr *) &server_addr, sizeof(server_addr));
    if (error) {
        perror("Error invoking bind");
        return 0;
    }
    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_gtk_socket, NULL);
    
    // init VCOM for delta driver
    delta_vcom_set(-2.7);

    // run the main loop
    LOGPRINTF("before g_main_loop_run");
    g_main_loop_run(gloop);
    LOGPRINTF("after g_main_loop_run");
    
    return 0;
}