mh5entryfield.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2004 Ocean Blue Software Ltd
 * Copyright © 2000 Koninklijke Philips Electronics N.V
 *
 * This file is part of a DTVKit Software Component
 * You are permitted to copy, modify or distribute this file subject to the terms
 * of the DTVKit 1.0 Licence which can be found in licence.txt or at www.dtvkit.org
 * 
 * THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
 * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
 * 
 * If you or your organisation is not a member of DTVKit then you have access
 * to this source code outside of the terms of the licence agreement
 * and you are expected to delete this and any associated files immediately.
 * Further information on DTVKit, membership and terms can be found at www.dtvkit.org
 *******************************************************************************/
/*---includes for this file--------------------------------------------------*/
#include "mh5entryfield.h"
#include "mh5scene.h"
#include "mh5object.h"          /* for actions      */
#include "mh5variable.h"        /* for actions      */
#include "mh5display.h"         /* for actions      */
#include "mh5application.h"     /* Default Colour   */
#include "mh5queue.h"           /* Events           */
#include "glue_memory.h"          /*for constructor/destructor */
#include "glue_debug.h"
#include "mh5support.h"
#include "stb_os.h"
#include "glue_queue.h"
#include "glue_timers.h"
#include "mh5drawtext.h"
#include "mh5keypress.h"

#ifdef MH5PRINTOUT
#include <string.h>
#endif

/*---constant definitions for this file--------------------------------------*/
#define SMS_KEY_CYCLE_DELAY 1500

/*---local typedef structs for this file-------------------------------------*/

/*state information for SMS-style entry*/
typedef struct entry_state_s
{
   enum {choosing, chosen} state;
   E_MHEG5_KEY current_key;
   int key_map_index;
   U32BIT last_press_time;
   char previous_character;
   MHEG5Entryfield *entryfield;
} entry_state_t;

/*---local (static) variable declarations for this file----------------------*/

/*list of the numeric-key mappings for SMS style entry*/
static MHEG5String SMS_map[10] = {
   {4, (MHEG5Byte *)"&@_0"},
   {11, (MHEG5Byte *)" .,-?!':;/1"},
   {7, (MHEG5Byte *)"abcABC2"},
   {7, (MHEG5Byte *)"defDEF3"},
   {7, (MHEG5Byte *)"ghiGHI4"},
   {7, (MHEG5Byte *)"jklJKL5"},
   {7, (MHEG5Byte *)"mnoMNO6"},
   {9, (MHEG5Byte *)"pqrsPQRS7"},
   {7, (MHEG5Byte *)"tuvTUV8"},
   {9, (MHEG5Byte *)"wxyzWXYZ9"}
};


/*profile-determined permitted character lists*/
#ifdef INCLUDE_IC
static const MHEG5String char_list_any = {76, (MHEG5Byte *)"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ&@_0 .,-?!':;/0123456789"};

static const MHEG5String char_list_alpha = {52, (MHEG5Byte *)"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"};
#endif /*INCLUDE_IC*/
static const MHEG5String char_list_numeric = {10, (MHEG5Byte *)"0123456789"};

static entry_state_t entry_state;

static H_Timer SMSTimer;

/*---local function definitions----------------------------------------------*/

/*---global function definitions---------------------------------------------*/
static char SMS_GetNextEnabledChar(MHEG5Entryfield *entryfield, int key);
static int  SMS_CharsListedForKey(MHEG5Entryfield *entryfield, int key );
static void SMS_TimerCallback(BOOLEAN triggered, void *callerRef, H_Timer timerHandle);

#ifdef MH5PRINTOUT

void MHEG5entryfieldPrint(MHEG5Entryfield *entryfield, char *out)
{
   MHEG5textPrint(&entryfield->text, out);
   MHEG5interactiblePrint(&entryfield->interactible, out);
   MHEG5indent(out);
   MHEG5indent(out);
   MHEG_PRINT(out, ":InputType ");
   switch (entryfield->inputType)
   {
      case mh5alpha:
         MHEG_PRINT(out, "Alpha");
         break;
      case mh5numeric:
         MHEG_PRINT(out, "Numeric");
         break;
      case mh5any:
         MHEG_PRINT(out, "Any");
         break;
      case mh5listed:
         MHEG_PRINT(out, "Listed");
         break;
      default:
         MHEG_PRINT(out, "Internal Error");
         break;
   }
   MHEG5newLine(out);
   MHEG5indent(out);
   MHEG_PRINT(out, ":Charlist ");
   MHEG5stringPrint(entryfield->charList, out);
   MHEG5newLine(out);
   MHEG5indent(out);
   MHEG_PRINT(out, ":ObscuredInput ");
   MHEG5boolPrint(entryfield->obscuredInput, out);
   MHEG5newLine(out);
   MHEG5indent(out);
   MHEG_PRINT(out, ":Maxlength ");
   MHEG5intPrint(entryfield->maxlength, out);
   MHEG5newLine(out);
   MHEG5indent(out);
   MHEG_PRINT(out, ":OverwriteMode ");
   MHEG5boolPrint(entryfield->overwriteMode, out);
   MHEG5newLine(out);
   MHEG5indent(out);
   MHEG_PRINT(out, "// EntryPoint:\t");
   MHEG5intPrint(entryfield->entryPoint, out);
   MHEG5newLine(out);
}

#endif

static void MHEG5entryfieldAppend(MHEG5Entryfield *entryfield)
{
   unsigned char *save;

   /* Keep the old data */
   save = entryfield->text.visible.ingredient.data;

   /* Allocate memory for the new data (one char longer than previous) */
   entryfield->text.visible.ingredient.data =
      MHEG5getMem((entryfield->text.visible.ingredient.dataLen + 1) * sizeof(unsigned short));

   if (entryfield->text.visible.ingredient.data)
   {
      /* Memory allocate suceeded */

      /* Copy the old data into the new memory */
      memcpy(entryfield->text.visible.ingredient.data,
         save, entryfield->text.visible.ingredient.dataLen * sizeof(unsigned short));

      /* Indicate the new data length */
      entryfield->text.visible.ingredient.dataLen++;

      if (entryfield->text.visible.ingredient.dataLen > 1)
      {
         /* Free off the old saved data */
         MHEG5freeMem(save);
      }
   }
   else
   {
      /* Memory allocate failed */

      /* Reuse the old (saved) data. Length of the entryfield is not increased
       */
      entryfield->text.visible.ingredient.data = save;
   }
}

void MHEG5entryfieldInsert(MHEG5Entryfield *entryfield, unsigned short c)
{
   int i;
   unsigned short *data;

   if ((entryfield->maxlength > 0) && (entryfield->entryPoint >= entryfield->maxlength))
   {
      return;
   }

   if (entryfield->entryPoint < 0)
   {
      entryfield->entryPoint = 0;
   }

   if (entryfield->entryPoint >= entryfield->text.visible.ingredient.dataLen)
   {
      entryfield->entryPoint = entryfield->text.visible.ingredient.dataLen;
   }
   else if (entryfield->overwriteMode)
   {
      data = (unsigned short *)entryfield->text.visible.ingredient.data;
      data[entryfield->entryPoint] = c;
      entryfield->entryPoint++;
      return;
   }

   if ((entryfield->maxlength > 0) && (entryfield->text.visible.ingredient.dataLen >= entryfield->maxlength))
   {
      /* No room to insert further characters into this entryfield */
      return;
   }

   /* Grow the length of the entryfield data by 1 character */
   MHEG5entryfieldAppend(entryfield);

   /* Set pointer to the character data */
   data = (unsigned short *)entryfield->text.visible.ingredient.data;

   /* Shuffle up all characters after the entry point (if any) */
   for (i = entryfield->text.visible.ingredient.dataLen - 1; i > entryfield->entryPoint; i--)
   {
      data[i] = data[i - 1];
   }

   /* Add the new character at the entry point */
   data[entryfield->entryPoint] = c;
   entryfield->entryPoint++;
}

void MHEG5entryfieldInit(MHEG5Entryfield *entryfield)
{
   assert(entryfield);

   MHEG5textInit(&entryfield->text);
   MHEG5interactibleInit(&entryfield->interactible);
}

void MHEG5entryfieldFree(MHEG5Entryfield *entryfield)
{
   assert(entryfield);

   if (SMSTimer != NULL)
   {
      mhegTimerDestroy(SMSTimer);
      SMSTimer = NULL;
   }
   MHEG5textFree(&entryfield->text);
   MHEG5interactibleFree(&entryfield->interactible);
#ifdef INCLUDE_IC
   switch (entryfield->inputType)
   {
      case mh5alpha:
      case mh5any:
      case mh5numeric:
         break;
      case mh5listed:
         MHEG5stringDestruct(&entryfield->charList);
         break;
      default:
         assert(0);
   }
#endif /*INCLUDE_IC*/
}

/*
     Internal behaviours
 */

void MHEG5entryfieldPrepare(MHEG5Entryfield *entryfield)
{
   assert(entryfield);
   MHEG5interactiblePrepare(&entryfield->interactible);

   entryfield->entryPoint = 0;
   entryfield->overwriteMode = MHEG5FALSE;

#ifdef INCLUDE_IC
   if (MH5_SupportInteractionChannel())
   {
      switch (entryfield->inputType)
      {
         case mh5alpha:
            MHEG5stringDestruct(&entryfield->charList);
            entryfield->charList = char_list_alpha;
            break;
         case mh5any:
            MHEG5stringDestruct(&entryfield->charList);
            entryfield->charList = char_list_any;
            break;
         case mh5listed:
            break;
         case mh5numeric:
            MHEG5stringDestruct(&entryfield->charList);
            entryfield->charList = char_list_numeric;
            break;
         default:
            assert(0);
      }
   }
   else
#endif /*INCLUDE_IC*/
   { /* IC is not supported then just use numeric*/
      MHEG5stringDestruct(&entryfield->charList);
      entryfield->charList = char_list_numeric;
   }
   MHEG5textPrepare(&entryfield->text);
}

void MHEG5entryfieldActivate(MHEG5Entryfield *entryfield)
{
   assert(entryfield);
   if (!entryfield->text.visible.ingredient.root.availabilityStatus)
   {
      MHEG5entryfieldPrepare(entryfield);
      entryfield->entryPoint = 0;
      entryfield->overwriteMode = MHEG5FALSE;
   }
   MHEG5textActivate(&entryfield->text);
}

void MHEG5entryfieldDeactivate(MHEG5Entryfield *entryfield)
{
   assert(entryfield);

   MHEG5textDeactivate(&entryfield->text);

   /* Apply deactivation behaviour inherrited from Interactible class */
   MHEG5interactibleDeactivate(&entryfield->interactible);
}

void MHEG5entryfieldDestruct(MHEG5Entryfield *entryfield)
{
   assert(entryfield);

   MHEG5textDestruct(&entryfield->text);
   MHEG5interactibleDestruct(&entryfield->interactible);
}

/*
   Actions
 */
MHEG5ErrorCode MHEG5setOverwriteMode(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Bool newMode;
   MHEG5Entryfield *item;

   assert(target);

   if (target->clazz != MHEG5ENTRYFIELD)
   {
      return MHEG5ERR_WRONGTARGET;
   }
   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   item = (MHEG5Entryfield *) target;
   MHEG5resolveGenericBoolean(params, &newMode);

   item->overwriteMode = newMode;

   MHEG5displayRedraw((MHEG5Visible *) target);

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5getOverwriteMode(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Root *boolVar = 0;
   MHEG5BooleanVariable *rc = 0;
   MHEG5Entryfield *item;

   assert(target);

   if (target->clazz != MHEG5ENTRYFIELD)
   {
      return MHEG5ERR_WRONGTARGET;
   }
   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   item = (MHEG5Entryfield *) target;
   MHEG5resolveORef(params, &boolVar);
   if (!boolVar)
   {
      return MHEG5ERR_WRONGPARAM;
   }
   if (boolVar->clazz != MHEG5BOOLEANVARIABLE)
   {
      return MHEG5ERR_WRONGPARAM;
   }
   if (!boolVar->runningStatus)
   {
      return MHEG5ERR_PARAMNOTACTIVE;
   }
   rc = (MHEG5BooleanVariable *)boolVar;
   rc->value = item->overwriteMode;

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5setEntryPoint(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Int newPoint;
   MHEG5Entryfield *item;

   assert(target);

   if (target->clazz != MHEG5ENTRYFIELD)
   {
      return MHEG5ERR_WRONGTARGET;
   }
   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   item = (MHEG5Entryfield *) target;
   MHEG5resolveGenericInteger(params, &newPoint);

   if (newPoint > item->text.visible.ingredient.dataLen)
   {
      newPoint = item->text.visible.ingredient.dataLen;
   }
   if (newPoint < 0)
   {
      newPoint = 0;
   }
   if (item->entryPoint != newPoint)
   {
      item->entryPoint = newPoint;

      MHEG5drawEntry((MHEG5Entryfield *)target, CURSOR_INSERT);

      MHEG5displayRedraw((MHEG5Visible *) target);
   }
   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5getEntryPoint(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Root *intVar = 0;
   MHEG5IntegerVariable *rc = 0;
   MHEG5Entryfield *item;

   assert(target);

   if (target->clazz != MHEG5ENTRYFIELD)
   {
      return MHEG5ERR_WRONGTARGET;
   }
   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   item = (MHEG5Entryfield *) target;
   MHEG5resolveORef(params, &intVar);
   if (!intVar)
   {
      return MHEG5ERR_WRONGPARAM;
   }
   if (intVar->clazz != MHEG5INTEGERVARIABLE)
   {
      return MHEG5ERR_WRONGPARAM;
   }
   if (!intVar->runningStatus)
   {
      return MHEG5ERR_PARAMNOTACTIVE;
   }
   rc = (MHEG5IntegerVariable *)intVar;
   rc->value = item->entryPoint;

   return MHEG5ERR_NOERROR;
}

void MHEG5entryfieldBACKSPACE(MHEG5Entryfield *entryfield)
{
   if (entryfield->entryPoint > entryfield->text.visible.ingredient.dataLen)
   {
      entryfield->entryPoint = entryfield->text.visible.ingredient.dataLen;
   }

   if (entryfield->entryPoint > 0)
   {
      int i;
      unsigned short *data;

      data = (unsigned short *)entryfield->text.visible.ingredient.data;

      for (i = entryfield->entryPoint; i < entryfield->text.visible.ingredient.dataLen; i++)
      {
         data[i - 1] = data[i];
      }
      entryfield->entryPoint--;
      entryfield->text.visible.ingredient.dataLen--;

      if (entryfield->text.visible.ingredient.dataLen == 0)
      {
         /* Entry field is empty - free off the data */
         MHEG5freeMem(entryfield->text.visible.ingredient.data);
         entryfield->text.visible.ingredient.data = 0;
      }
   }
}

void MHEG5entryfieldLEFT(MHEG5Entryfield *entryfield)
{
   if (entryfield->entryPoint > 0)
   {
      entryfield->entryPoint--;
   }
}

void MHEG5entryfieldRIGHT(MHEG5Entryfield *entryfield)
{
   if (entryfield->entryPoint < entryfield->text.visible.ingredient.dataLen)
   {
      entryfield->entryPoint++;
   }
}

void MHEG5entryfieldSELECT(MHEG5Entryfield *entryfield)
{
   MHEG5Scene *scene;

   scene = MHEG5getCurrentScene();

   entryfield->interactible.interactionStatus = MHEG5FALSE;
   scene->currentInteractible = 0;

   MHEG5interactibleInteractionCompleted(&entryfield->interactible, (MHEG5Root *)entryfield);
}

void MHEG5entryfieldEXIT(MHEG5Entryfield *entryfield)
{
   if (entryfield->text.visible.ingredient.dataLen)
   {
      entryfield->text.visible.ingredient.dataLen = 0;
      MHEG5freeMem(entryfield->text.visible.ingredient.data);
   }
   entryfield->text.visible.ingredient.data = 0;
   entryfield->entryPoint = 0;
}

static void MHEG5entryfieldSMSEntry(MHEG5Entryfield *entryfield,
   E_MHEG5_KEY ui, int key_number)
{
   U32BIT current_time;
   char next_char;
   MHEG5Int current_position;

   assert( ui >= MHEG5_KEY_0 && ui <= MHEG5_KEY_9 );

   /*reset state if we have moved to another field*/
   if (entry_state.entryfield != entryfield)
   {
      entry_state.entryfield = entryfield;
      entry_state.state = chosen;
      entry_state.current_key = (E_MHEG5_KEY)-1;
   }
   current_position = entryfield->text.visible.ingredient.dataLen;
   /*stop the timer if it is running*/
   if (SMSTimer != NULL)
   {
      mhegTimerDestroy(SMSTimer);
      SMSTimer = NULL;
   }
   current_time = STB_OSGetClockMilliseconds();

   /*if the key pressed is the same as the last one, and it hasn't timed out*/
   if (entry_state.current_key == ui &&
       entry_state.state == choosing &&
       entry_state.last_press_time + SMS_KEY_CYCLE_DELAY > current_time)
   {
      /*find the next listed character for the key*/
      next_char = SMS_GetNextEnabledChar(entryfield, key_number);

      /*replace the previous character with the new one*/
      if (!entryfield->overwriteMode)
      {
         MHEG5entryfieldBACKSPACE(entryfield);
      }
      else
      {
         MHEG5entryfieldLEFT(entryfield);
      }
      MHEG5entryfieldInsert(entryfield, next_char);
      entry_state.previous_character = next_char;
   }
   else  /*different key pressed or timed out*/
   {
      char backup_char = entry_state.previous_character;

      entry_state.current_key = ui;
      entry_state.key_map_index = -1;  /*reset the map index*/

      /*if there is space for new characters, go back to choosing*/
      if (entryfield->overwriteMode ||
          entryfield->maxlength == 0 ||
          entryfield->maxlength > entryfield->text.visible.ingredient.dataLen)
      {
         entry_state.state = choosing;

         next_char = SMS_GetNextEnabledChar(entryfield, key_number);
         if (next_char)
         {
            int char_count;
            MHEG5entryfieldInsert(entryfield, next_char);
            entry_state.previous_character = next_char;

            char_count = SMS_CharsListedForKey(entryfield, key_number);
            if (char_count == 1) /*If the key has only one character listed*/
            {
               entry_state.state = chosen;
               if (current_position < entryfield->maxlength &&
                   entryfield->maxlength > 0 &&
                   entryfield->text.visible.ingredient.dataLen >= entryfield->maxlength)
               {
                  /* Entry point reached the end of the field - generate an
                   * EntryFieldFull event
                   */
                  MHEG5sendEvent((MHEG5Root *)entryfield, MHEG5ENTRYFIELDFULL, 0);
               }
            }
         }
         else
         {
            /*ignore keypress if no allowed characters associated with it*/
            next_char = backup_char;
            entry_state.state = chosen;
         }
      }
      else
      {
         entry_state.previous_character = backup_char;
         if (current_position < entryfield->maxlength &&
             entryfield->maxlength > 0 &&
             entryfield->text.visible.ingredient.dataLen >= entryfield->maxlength)
         {
            /* Entry point reached the end of the field - generate an
             * EntryFieldFull event
             */
            MHEG5sendEvent((MHEG5Root *)entryfield, MHEG5ENTRYFIELDFULL, 0);
         }
      }
   }


   entry_state.last_press_time = current_time;

   if (entry_state.state == choosing)
   {
      /*start timer*/
      mhegTimerCreate(SMS_KEY_CYCLE_DELAY, (F_TimerCallback)SMS_TimerCallback, (void *)entryfield, &SMSTimer);
   }
}

void MHEG5entryfieldUserInput(MHEG5Entryfield *entryfield, E_MHEG5_KEY ui)
{
   switch (ui)
   {
      /*numeric keys enter text into the field*/
      case MHEG5_KEY_0:
      case MHEG5_KEY_1:
      case MHEG5_KEY_2:
      case MHEG5_KEY_3:
      case MHEG5_KEY_4:
      case MHEG5_KEY_5:
      case MHEG5_KEY_6:
      case MHEG5_KEY_7:
      case MHEG5_KEY_8:
      case MHEG5_KEY_9:
         MHEG5entryfieldSMSEntry(entryfield, ui, (int)ui - (int)MHEG5_KEY_0);
         break;
      /*control keys reset the SMS-entry state and do their action*/
      case MHEG5_KEY_LEFT:
         entry_state.state = chosen;
         MHEG5entryfieldBACKSPACE(entryfield);
         break;
      case MHEG5_KEY_UP:
         entry_state.state = chosen;
         MHEG5entryfieldLEFT(entryfield);
         break;
      case MHEG5_KEY_DOWN:
      case MHEG5_KEY_RIGHT:
         entry_state.state = chosen;
         MHEG5entryfieldRIGHT(entryfield);
         break;
      case MHEG5_KEY_CANCEL:
         MHEG5entryfieldEXIT(entryfield);
      /*drop through to perform SELECT action as well*/
      case MHEG5_KEY_SELECT:
         entry_state.state = chosen;
         MHEG5entryfieldSELECT(entryfield);
         break;
      default:
         /*other keys just reset the SMS-entry state*/
         entry_state.state = chosen;
         break;
   }

   /*redraw*/
   if (entry_state.state == chosen)
   {
      MHEG5drawEntry( entryfield, CURSOR_INSERT);
   }
   else
   {
      MHEG5drawEntry( entryfield, CURSOR_REPLACE);
   }
   MHEG5displayRedraw((MHEG5Visible *)entryfield );
}

static char SMS_GetNextEnabledChar(MHEG5Entryfield *entryfield, int key)
{
   MHEG5String *map_string;
   MHEG5String *permitted_list;
   char next_char = 0;
   int idx;
   int i, j;
   MHEG5Bool found;

   map_string = &(SMS_map[key]);
   permitted_list = &(entryfield->charList);

   /*start from the previous position in the map*/
   idx = entry_state.key_map_index;

   /*loop through the key map*/
   for (i = 0; i < map_string->len; i++)
   {
      idx++;
      /*wrap around if we get to the end of the string*/
      if (idx >= map_string->len)
      {
         idx = 0;
      }

      /*search the permitted char list*/
      found = FALSE;
      for (j = 0; j < permitted_list->len; j++)
      {
         if (permitted_list->data[j] == map_string->data[idx])
         {
            found = TRUE;
            break;
         }
      }

      if (found == TRUE)
      {
         next_char = map_string->data[idx];
         entry_state.key_map_index = idx;
         break;
      }
   }
   return next_char;
}

static int SMS_CharsListedForKey(MHEG5Entryfield *entryfield, int key )
{
   MHEG5String *map_string;
   MHEG5String *permitted_list;
   int i, j;
   int count = 0;

   map_string = &(SMS_map[key]);
   permitted_list = &(entryfield->charList);


   /*loop through the key map*/
   for (i = 0; i < map_string->len; i++)
   {
      /*search the permitted char list*/
      for (j = 0; j < permitted_list->len; j++)
      {
         if (permitted_list->data[j] == map_string->data[i])
         {
            count++;
            break;
         }
      }
   }
   return count;
}

void entryfieldSMSTimeout( void *data )
{
   MHEG5TimerEventParams_t *param = (MHEG5TimerEventParams_t *)data;
   MHEG5Entryfield *field_ref = (MHEG5Entryfield *)param->callerRef;
   U32BIT current_time;
   int time;

   if (param->triggered)
   {
      current_time = STB_OSGetClockMilliseconds();
      /*check the time to ensure the timeout is correct*/
      if (entry_state.last_press_time + SMS_KEY_CYCLE_DELAY <= current_time)
      {
         entry_state.state = chosen;
         mhegTimerDestroy(SMSTimer);

         /*redraw*/
         MHEG5drawEntry( field_ref, CURSOR_INSERT);
         MHEG5displayRedraw((MHEG5Visible *) field_ref);

         if ((field_ref->maxlength > 0) && (field_ref->text.visible.ingredient.dataLen >= field_ref->maxlength))
         {
            /* Entry point reached the end of the field - generate an
             * EntryFieldFull event
             */
            MHEG5sendEvent((MHEG5Root *)field_ref, MHEG5ENTRYFIELDFULL, 0);
         }
      }
      else
      {
         /*if the timer fired too soon, start it again with the remaining time*/
         time = (entry_state.last_press_time + SMS_KEY_CYCLE_DELAY) - current_time;
         mhegTimerCreate(time, (F_TimerCallback) SMS_TimerCallback, (void *)field_ref, &SMSTimer);
      }
   }
}

static void SMS_TimerCallback(BOOLEAN triggered, void *callerRef,
   H_Timer timerHandle)
{
   MHEG5eventMessage_t event;
   E_MhegErr err;

   /* Send event to component task */
   event.proc_msg_func = entryfieldSMSTimeout;
   event.data_type = DT_VALUE;
   event.data.timer.triggered = triggered;
   event.data.timer.callerRef = callerRef;
   event.data.timer.timerHandle = (void *)timerHandle;
   err = VQ_PutMsg(&event, PRTY_NORMAL);
   if (err != MHERR_OK)
   {
      TRACE(TERROR, ("VQ_PutMsg returned Error %d", err))
   }
}