mh5listgroup.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 "mh5profile.h"
#include "mh5listgroup.h"
#include "mh5object.h"          /* for actions */
#include "mh5gate.h"
#include "mh5variable.h"        /* for actions */
#include "mh5memory.h"          /* for constructor/destructor */
#include "mh5queue.h"           /* Events           */
#include "mh5debug.h"
#include "mh5final.h"
#include "mh5bitmap.h"
#include "mh5video.h"
#include "mh5rectangle.h"
#include "mh5hypertext.h"
#include "mh5entryfield.h"
#include "mh5slider.h"
#include "mh5dynamiclineart.h"
#ifndef MHEG5PROFILE_UK1_06
#include "mh5button.h"
#include "mh5hotspot.h"
#include "mh5pushbutton.h"
#include "mh5switchbutton.h"
#include "mh5rtgraphics.h"
#endif

#include "mh5application.h"
#include "mh5scene.h"

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

/*---constant definitions for this file--------------------------------------*/


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

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

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

/*---global function definitions---------------------------------------------*/

static void MHEG5listGroupDeselect(MHEG5ListGroup *listGroup, MHEG5Int itemIndex);
static void MHEG5listGroupUpdate(MHEG5ListGroup *listGroup);


/*
   Debug
 */
#ifdef MH5PRINTOUT
#include <string.h>
#include "mh5group.h"


static void MHEG5listGroupItemsPrint(MHEG5ListGroup *grp, MHEG5ItemList *item, char *out)
{
   MHEG5indent(out);
   MHEG_PRINT(out, "(");
   MHEG5stringPrint(grp->tokenGroup.ingredient.root.grp->groupName, out);
   MHEG_PRINT(out, " ");
   MHEG5intPrint(item->id, out);
   MHEG_PRINT(out, ") ");
   MHEG5boolPrint(item->itemSelectionStatus, out);
   MHEG5newLine(out);
   if (item->next)
   {
      MHEG5listGroupItemsPrint(grp, item->next, out);
   }
}

static void MHEG5listGroupPositionsPrint(MHEG5PosList *pos, char *out)
{
   MHEG5indent(out);
   MHEG_PRINT(out, "(");
   MHEG5intPrint(pos->position.x, out);
   MHEG_PRINT(out, " ");
   MHEG5intPrint(pos->position.y, out);
   MHEG_PRINT(out, ")");
   MHEG5newLine(out);
   if (pos->next)
      MHEG5listGroupPositionsPrint(pos->next, out);
}

void MHEG5listGroupPrint(MHEG5ListGroup *listGroup, char *out)
{
   MHEG5tokenGroupPrint(&listGroup->tokenGroup, out);

   if (listGroup->originalPositions)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":OriginalPositions");
      MHEG5newLine(out);
      MHEG5incIndent();
      MHEG5listGroupPositionsPrint(listGroup->originalPositions, out);
      MHEG5decIndent();
   }
   if (listGroup->wrapAround)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":WrapAround TRUE");
      MHEG5newLine(out);
   }
   if (listGroup->multipleSelection)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":MultipleSelection TRUE");
      MHEG5newLine(out);
   }
   if (listGroup->positions)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, "// :Positions");
      MHEG5newLine(out);
      MHEG5incIndent();
      MHEG5listGroupPositionsPrint(listGroup->positions, out);
      MHEG5decIndent();
   }
   if (listGroup->firstItem != 1)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, "// FirstItem:\t");
      MHEG5intPrint(listGroup->firstItem, out);
      MHEG5newLine(out);
   }
   if (listGroup->positionCount)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, "// PositionCount:\t");
      MHEG5intPrint(listGroup->positionCount, out);
      MHEG5newLine(out);
   }
   if (listGroup->itemCount)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, "// ItemCount:\t");
      MHEG5intPrint(listGroup->itemCount, out);
      MHEG5newLine(out);
   }
   if (listGroup->itemList)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, "// :Items");
      MHEG5newLine(out);
      MHEG5incIndent();
      MHEG5listGroupItemsPrint(listGroup, listGroup->itemList, out);
      MHEG5decIndent();
   }
}

#endif



static void MHEG5listGroupInitInternal(MHEG5ListGroup *listGroup)
{
   MHEG5PosList **copy, *position, *newItem;

   assert(listGroup);

   assert(listGroup->itemList == 0);
   listGroup->firstItem = 1;

   listGroup->positions = 0;
   position = listGroup->originalPositions;
   copy = &listGroup->positions;
   while (position)
   {
      newItem = MHEG5getMem(sizeof(MHEG5PosList));    /* FreeMem in Destruct */
      if (!newItem)
      {
         /* Out of memory */
         return;
      }
      newItem->position.x = position->position.x;
      newItem->position.y = position->position.y;
      newItem->next = 0;
      *copy = newItem;
      copy = &newItem->next;
      position = position->next;
   }

   listGroup->firstItemVisible = MHEG5FALSE;
   listGroup->lastItemVisible = MHEG5FALSE;
}

void MHEG5listGroupFree(MHEG5ListGroup *listGroup)
{
   MHEG5PosList *lastPos;

   assert(listGroup);

   MHEG5tokenGroupFree(&listGroup->tokenGroup);

   while (listGroup->originalPositions)
   {
      lastPos = listGroup->originalPositions;
      listGroup->originalPositions = listGroup->originalPositions->next;
      MHEG5freeMem(lastPos);
   }
   while (listGroup->positions)
   {
      lastPos = listGroup->positions;
      listGroup->positions = listGroup->positions->next;
      MHEG5freeMem(lastPos);
   }
}

void MHEG5listGroupAddPosition(MHEG5ListGroup *listGroup, MHEG5Int x, MHEG5Int y)
{
   MHEG5PosList *position, *newItem;

   INFO_PRINT(("Adding position (%d, %d) to ListGroup id=%d\n", x, y, ((MHEG5Root *)listGroup)->id));

   assert(listGroup);
   newItem = MHEG5getMem(sizeof(MHEG5PosList));   /* FreeMem in Destruct */
   if (!newItem)
   {
      /* Out of memory */
      return;
   }
   newItem->position.x = x;
   newItem->position.y = y;
   newItem->next = 0;
   position = listGroup->originalPositions;
   listGroup->positionCount++;
   if (!position)
   {
      listGroup->originalPositions = newItem;
   }
   else
   {
      while (position->next)
      {
         position = position->next;
      }
      position->next = newItem;
   }
}

void MHEG5listGroupPrepare(MHEG5ListGroup *listGroup)
{
   MHEG5TokenSlot *token_ptr;
   U32BIT token_num;
   MHEG5ItemList *item;
   MHEG5ItemList *newItem;
   MHEG5ItemList *lastItem;
   MHEG5Bool alreadyPresent;

   assert(listGroup);

   INFO_PRINT(("Prepare ListGroup id=%d\n", ((MHEG5Root *) listGroup)->id));

   /* Execute the following sequence of actions: */
   if (listGroup->tokenGroup.ingredient.root.availabilityStatus)
   {
      return;
   }

   assert(listGroup->itemList == 0);

   MHEG5listGroupInitInternal(listGroup);

   /* 1. Apply the Preparation behaviour as inherited from the base class. */
   MHEG5tokenGroupPrepare(&listGroup->tokenGroup);

   /* 2. Add each reference listed in the token_ptr attribute to the
    *    ItemList in the order they are listed in the token_ptr
    *    attribute. If a Visible is referenced more than once in the
    *    token_ptr, it is added only at its first occurrence in the
    *    ItemList. Null ObjectReferences are not added to ItemList.
    */
   token_ptr = listGroup->tokenGroup.tokens_ptr + 1;
   token_num = listGroup->tokenGroup.tokens_num - 1;
   lastItem = 0;
   while (token_num)
   {
      item = listGroup->itemList;
      alreadyPresent = MHEG5FALSE;

      /* Check for NULL reference */
      if ((token_ptr->groupid.ptr.name == NULL) || (token_ptr->id == 0))
      {
         alreadyPresent = MHEG5TRUE;
      }

      /* Check whether item is already in the list */
      while (item)
      {
         if ((item->id == token_ptr->id) &&
             ((item->groupRef.ptr.group == token_ptr->groupid.ptr.group) ||
              MHEG5sameGroups(item->groupRef, token_ptr->groupid)))
         {
            alreadyPresent = MHEG5TRUE;
            break;
         }
         item = item->next;
      }

      if (!alreadyPresent)
      {
         /* Add item to the list */
         newItem = MHEG5getMem(sizeof(MHEG5ItemList));    /* FreeMem in Destruct */
         if (!newItem)
         {
            /* Out of memory */
            break;
         }
         newItem->groupRef = token_ptr->groupid;
         newItem->id = token_ptr->id;
         newItem->itemSelectionStatus = MHEG5FALSE;
         newItem->next = 0;
         if (lastItem)
         {
            /* Add to the tail of the list */
            lastItem->next = newItem;
         }
         else
         {
            /* List is empty - add to the head */
            listGroup->itemList = newItem;
         }
         lastItem = newItem;
         listGroup->itemCount++;
      }
      token_ptr++;
      token_num--;
   }

   if (listGroup->itemCount > 0)
   {
      MHEG5sendSync((MHEG5Root *)listGroup, MHEG5TAILITEMS, listGroup->itemCount - listGroup->firstItem + 1 );
   }
}

void MHEG5listGroupDestruct(MHEG5ListGroup *listGroup)
{
   MHEG5ItemList *lastItem;

   while (listGroup->itemList)
   {
      lastItem = listGroup->itemList;
      listGroup->itemList = listGroup->itemList->next;
      MHEG5freeMem(lastItem);
   }

   MHEG5tokenGroupDestruct(&listGroup->tokenGroup);
}

void MHEG5listGroupActivate(MHEG5ListGroup *listGroup)
{
   assert(listGroup);

   /* Execute the following sequence of actions: */
   if (!listGroup->tokenGroup.ingredient.root.runningStatus)
   {
      /* 1. Apply the Activation behaviour as inherited from the Presentable
       * class.
       */

      if (!listGroup->tokenGroup.ingredient.root.availabilityStatus)
      {
         MHEG5listGroupPrepare( listGroup );
      }
      /* Could call the base class activation behaviour, but */
      MHEG5ingredientActivate(&listGroup->tokenGroup.ingredient);   /*<- does nothing, so don't bother */

      /* 2. Generate a TokenMovedTo event with the value of the TokenPosition
       * attribute as associated data.
       */
      MHEG5sendSync((MHEG5Root *)listGroup, MHEG5TOKENMOVEDTO, listGroup->tokenGroup.tokenManager.tokenPosition );

      /* 3. Set the RunningStatus to True. */
      listGroup->tokenGroup.ingredient.root.runningStatus = MHEG5TRUE;

      /* 4. Apply the Updatebehaviour. */
      MHEG5listGroupUpdate(listGroup);

      /* 5. Generate an IsRunningevent. */
      MHEG5sendSync((MHEG5Root *)listGroup, MHEG5ISRUNNING, 0);
   }
}

void MHEG5listGroupDeactivate(MHEG5ListGroup *listGroup)
{
   MHEG5ItemList *item;
   MHEG5Root *visible;

   /* NOTE: This class is different that all others. Step 1 occurs before
    * checking that the RunningStatus is True.
    */

   /* Execute the following sequence of actions: */
   /* 1. Apply the Deactivation behaviour to all Visibles referenced in the
    * ItemList.
    */
   item = listGroup->itemList;
   while (item)
   {
      visible = MHEG5findObject(item->groupRef, item->id);
      if (visible)
      {
         MHEG5finalDeactivate(visible);
         MHEG5visibleResetPosition((MHEG5Visible *)visible);
      }
      item = item->next;
   }

   /* 2. Apply the Deactivation behaviour as defined in the base class. */
   MHEG5tokenGroupDeactivate(&listGroup->tokenGroup);
}

static void MHEG5listGroupUpdateItemVisibleIndices(MHEG5ListGroup *listGroup)
{
   MHEG5ItemList *item;
   MHEG5Int itemPos, firstItem;

   assert(listGroup);

   firstItem = listGroup->firstItem - 1;      /* Index from 0 */
   if (listGroup->wrapAround)
   {
      firstItem %= listGroup->itemCount;
   }

   /* Find out which items are visible and set the visibleIndex for them */
   itemPos = 0;
   item = listGroup->itemList;
   while (item)
   {
      if ((itemPos >= firstItem) &&
          (itemPos < firstItem + listGroup->positionCount))
      {
         /* This item is visible in the normal view */
         item->visibleIndex = itemPos - firstItem;
      }
      else if (((listGroup->wrapAround) &&
                (listGroup->positionCount >= listGroup->itemCount)) ||
               ((listGroup->wrapAround) &&
                (itemPos < firstItem) &&
                (firstItem + listGroup->positionCount > listGroup->itemCount) &&
                (itemPos < (firstItem + listGroup->positionCount) % listGroup->itemCount)))
      {
         /* Wrapped items are visible */
         item->visibleIndex = itemPos - firstItem + listGroup->itemCount;
      }
      else
      {
         /* Item is not visible */
         item->visibleIndex = -1;
      }
      itemPos++;
      item = item->next;
   }
}

static void MHEG5listGroupDeactivateNotPresentedVisibles(MHEG5ListGroup *listGroup)
{
   MHEG5ItemList *item;
   MHEG5Root *visible;

   assert(listGroup);

   item = listGroup->itemList;
   while (item)
   {
      if (item->visibleIndex < 0)     /* Will not be presented */
      {
         visible = MHEG5findObject(item->groupRef, item->id);
         if (visible)
         {
            INFO_PRINT(("   Item id=%d not visible\n", ((MHEG5Root *)visible)->id));
            MHEG5finalDeactivate(visible);
            MHEG5visibleResetPosition((MHEG5Visible *)visible);
         }
      }
      item = item->next;
   }
}

static void MHEG5listGroupPreparePresentedVisibles(MHEG5ListGroup *listGroup)
{
   MHEG5ItemList *item;
   MHEG5Root *visible;
   MHEG5PosList *pos;

   assert(listGroup);

   item = listGroup->itemList;
   while (item)
   {
      if (item->visibleIndex >= 0)
      {
         /* Will be presented */
         visible = MHEG5findObject(item->groupRef, item->id);
         if (visible)
         {
            MHEG5Int i;

            INFO_PRINT(("   Item id=%d visible\n", ((MHEG5Root *)visible)->id));
            if (!visible->availabilityStatus)
            {
               switch (visible->clazz)
               {
                  case MHEG5BITMAP:
                     MHEG5bitmapPrepare((MHEG5Bitmap *) visible);
                     break;
                  case MHEG5TEXT:
                     MHEG5textPrepare((MHEG5Text *) visible);
                     break;
                  case MHEG5LINEART:
                     MHEG5lineartPrepare((MHEG5Lineart *) visible);
                     break;
                  case MHEG5DYNAMICLINEART:
                     MHEG5dynamicLineartPrepare((MHEG5DynamicLineart *) visible);
                     break;
                  case MHEG5RECTANGLE:
                     MHEG5rectanglePrepare((MHEG5Rectangle *) visible);
                     break;
                  case MHEG5VIDEO:
                     MHEG5videoPrepare((MHEG5Video *) visible);
                     break;
                  case MHEG5ENTRYFIELD:
                     MHEG5entryfieldPrepare((MHEG5Entryfield *)visible);
                     break;
                  case MHEG5HYPERTEXT:
                     MHEG5hypertextPrepare((MHEG5Hypertext *)visible);
                     break;
                  case MHEG5SLIDER:
                     MHEG5sliderPrepare((MHEG5Slider *)visible);
                     break;

               #ifndef MHEG5PROFILE_UK1_06
                  case MHEG5HOTSPOT:
                     MHEG5hotspotPrepare((MHEG5Hotspot *)visible);
                     break;
                  case MHEG5PUSHBUTTON:
                     MHEG5pushbuttonPrepare((MHEG5Pushbutton *)visible);
                     break;
                  case MHEG5SWITCHBUTTON:
                     MHEG5switchbuttonPrepare((MHEG5Switchbutton *)visible);
                     break;
                  case MHEG5RTGRAPHICS:
                     MHEG5rtgraphicsPrepare((MHEG5RTGraphics *) visible);
                     break;
                  case MHEG5PALETTE:
                     MHEG5palettePrepare((MHEG5Palette *)visible);
                     break;
                  case MHEG5CURSORSHAPE:
                     MHEG5cursorShapePrepare((MHEG5CursorShape *)visible);
                     break;
               #endif 
                  case MHEG5SCENE:
                  case MHEG5APPLICATION:
                  case MHEG5LINK:
                  case MHEG5RESIDENTPROGRAM:
                  case MHEG5REMOTEPROGRAM:
                  case MHEG5INTERCHANGEDPROGRAM:
                  case MHEG5BOOLEANVARIABLE:
                  case MHEG5INTEGERVARIABLE:
                  case MHEG5OCTETSTRINGVARIABLE:
                  case MHEG5OBJECTREFVARIABLE:
                  case MHEG5CONTENTREFVARIABLE:
                  case MHEG5STREAM:
                  case MHEG5AUDIO:
                  case MHEG5FONT:
                  case MHEG5TOKENGROUP:
                  case MHEG5LISTGROUP:
                  default:
                     ERROR_PRINT(("ListGroup: item not visible %d\n", visible->clazz));
                     return;
               }
            }
            pos = listGroup->positions;

            for (i = 0; i < item->visibleIndex && pos; i++)
            {
               pos = pos->next;
               assert(pos);
            }

            if (pos)
            {
               INFO_PRINT(("Setting position of item id=%d to (%d, %d)\n", visible->id, pos->position.x, pos->position.y));
               MHEG5visibleSetPosition((MHEG5Visible *)visible, pos->position.x, pos->position.y);
            }
         }
      }
      item = item->next;
   }
}

static void MHEG5listGroupActivatePresentedVisibles(MHEG5ListGroup *listGroup)
{
   MHEG5ItemList *item;
   MHEG5Root *visible;

   assert(listGroup);

   item = listGroup->itemList;
   while (item)
   {
      if (item->visibleIndex >= 0)     /* Will be presented */
      {
         visible = MHEG5findObject(item->groupRef, item->id);
         if (visible)
         {
            MHEG5finalActivate(visible);
         }
         if (item == listGroup->itemList && !listGroup->firstItemVisible)
         {
            listGroup->firstItemVisible = MHEG5TRUE;
            MHEG5sendSync((MHEG5Root *)listGroup, MHEG5FIRSTITEMPRESENTED, MHEG5TRUE );
         }
         if (!item->next && !listGroup->lastItemVisible)
         {
            listGroup->lastItemVisible = MHEG5TRUE;
            MHEG5sendSync((MHEG5Root *)listGroup, MHEG5LASTITEMPRESENTED, MHEG5TRUE );
         }
      }
      else
      {
         if (item == listGroup->itemList && listGroup->firstItemVisible)
         {
            listGroup->firstItemVisible = MHEG5FALSE;
            MHEG5sendSync((MHEG5Root *)listGroup, MHEG5FIRSTITEMPRESENTED, MHEG5FALSE);
         }
         if (!item->next && listGroup->lastItemVisible)
         {
            listGroup->lastItemVisible = MHEG5FALSE;
            MHEG5sendSync((MHEG5Root *)listGroup, MHEG5LASTITEMPRESENTED, MHEG5FALSE );
         }
      }

      item = item->next;
   }
}

static void MHEG5listGroupUpdate(MHEG5ListGroup *listGroup)
{
   INFO_PRINT(("INFO: ListGroup update id=%d\n", ((MHEG5Root *)listGroup)->id));

   assert(listGroup);

   if (!listGroup)
   {
      return;
   }

   /* If the RunningStatus of the ListGroup is True then execute the following
    * sequence of actions:
    */
   if (!((MHEG5Root *)listGroup)->runningStatus)
   {
      DEBUG_PRINT(("WARNING: MHEG5listGroupUpdate - listgroup id=%d not running\n", ((MHEG5Root *)listGroup)->id));
      return;
   }

   /* Update the display index that each visible in the list holds */
   MHEG5listGroupUpdateItemVisibleIndices(listGroup);

   /* 1. For each item that will not be presented in a cell, if the item is
    *    active then apply the Deactivation behaviour to it and set its
    *    position to its OriginalPosition attribute.
    */
   MHEG5listGroupDeactivateNotPresentedVisibles(listGroup);

   /* 2. For each item, if it is to be presented at a cell, apply the
    *    Preparation behaviour to it and then set its
    *    Position(internal attribute) to the position defined for that cell.
    */
   MHEG5listGroupPreparePresentedVisibles(listGroup);

   /* 3. For each item that will be presented in a cell, if the item is
    *    inactive, apply the Activation behaviour to it.
    */
   MHEG5listGroupActivatePresentedVisibles(listGroup);
}

static void MHEG5listGroupAddItem(MHEG5ListGroup *listGroup, MHEG5Int idx, MH5GroupRef grpRef, MHEG5Int id)
{
   MHEG5ItemList *item, *newItem;
   MHEG5Int i;
   MH5GroupPtr gptr;
   INFO_PRINT(("Adding item ( %d, %d ) to ListGroup id=%d\n", grpRef.len, id, ((MHEG5Root *)listGroup)->id));

   /* Execute the following sequence of actions: */

   /* 1. If the Visible referenced by the Item parameter is already in the ItemList, ignore this behaviour. */
   item = listGroup->itemList;
   while (item)
   {
      if ((item->id == id) &&
          ((item->groupRef.ptr.group == grpRef.ptr.group) ||
           MHEG5sameGroups(item->groupRef, grpRef)))
      {
         DEBUG_PRINT(("MHEG5listGroupAddItem: Item already in ListGroup\n"));
         return;
      }
      item = item->next;
   }

   /* 2. If Index is less than 1 or greater than the current length of
    * ItemList + 1, ignore this behaviour.
    */
   if ((idx < 1) || (idx > listGroup->itemCount + 1))
   {
      DEBUG_PRINT(("MHEG5listGroupAddItem: Index out of range\n"));
      return;
   }

   i = 0;
   gptr = listGroup->tokenGroup.ingredient.root.grp;
   if ( !MHEG5sameGroup(gptr,grpRef) )
   {
      if (gptr->root.clazz == MHEG5SCENE)
      {
         gptr = (MH5GroupPtr)MHEG5getCurrentApplication();
      }
      else
      {
         gptr = (MH5GroupPtr)MHEG5getCurrentScene();
      }
      if ( !MHEG5sameGroup(gptr,grpRef) )
      {
         i = grpRef.len;
      }
   }

   /* 3. Add the Item reference at position Index in the ItemList. (The item
    * previously at position Index in the ItemList -if any- will now have index
    * Index+1 and, similarly, every item of index greater than Index will now
    * have an index incremented by one.)
    */
   newItem = MHEG5getMem(sizeof(MHEG5ItemList) + i);   /* FreeMem in Destruct */
   if (!newItem)
   {
      TRACE(TERROR,("Out of memory"))
   }
   else
   {
      if (i == 0)
      {
         newItem->groupRef.len = 0;
         newItem->groupRef.ptr.group = gptr;
      }
      else
      {
         newItem->groupRef.len = i;
         newItem->groupRef.ptr.name = (MHEG5Byte*)(newItem + 1);
         memcpy(newItem->groupRef.ptr.name,grpRef.ptr.name,i);
      }
      newItem->id = id;
      newItem->itemSelectionStatus = MHEG5FALSE;
      newItem->next = 0;

      listGroup->itemCount++;

      if (idx==1)
      {
         newItem->next=listGroup->itemList;
         listGroup->itemList=newItem;
      }
      else
      {
         item=listGroup->itemList;
         i=2;
         while (item && (i<idx))
         {
            item=item->next;
            i++;
         }

         /* Really can assert that item != NULL, because 'idx' <= listGroup->itemCount+1,
          * however no harm in checking anyway */
         assert( item != NULL );
         if (!item)
         {
            return;
         }

         newItem->next=item->next;
         item->next=newItem;
      }

      /* Increment the index of first item if necessary */
      if ((idx <= listGroup->firstItem) && (listGroup->firstItem < listGroup->itemCount))
      {
         listGroup->firstItem++;

         /* FirstItem has been incremented. */
         MHEG5sendSync((MHEG5Root *)listGroup, MHEG5HEADITEMS, listGroup->firstItem - 1 );
      }
      else
      {
         /* FirstItem remains the same, but itemCount has incremented */
         MHEG5sendSync((MHEG5Root *)listGroup, MHEG5TAILITEMS, listGroup->itemCount - listGroup->firstItem + 1 );
      }

      /* 4. Apply the Update behaviour. */
      MHEG5listGroupUpdate(listGroup);
   }
}

static void MHEG5listGroupDelItem(MHEG5ListGroup *listGroup, MH5GroupRef grpRef, MHEG5Int id)
{
   MHEG5ItemList *item, *prevItem = 0;
   MHEG5Int idx = 0;
   MHEG5Root *visible;

   INFO_PRINT(("Deleting item ( %ld ) from ListGroup %d\n", id, ((MHEG5Root *)listGroup)->id));

   /* Execute the following sequence of actions: */
   item = listGroup->itemList;
   while (item)
   {
      idx++;

      /* 1. If the Visible referenced by the Item parameter is not in the
       * ItemList, ignore this action.
       */
      if ((item->id == id) &&
          ((item->groupRef.ptr.group == grpRef.ptr.group) ||
           MHEG5sameGroups(item->groupRef, grpRef)))
      {
         INFO_PRINT(("   Found it!\n"));

         /* 2. Remove the reference indicated by the Item parameter from the
          * ItemList. (The item index of the following items in ItemList will
          * decrement by one.)
          */
         if (!prevItem)
         {
            listGroup->itemList = listGroup->itemList->next;
         }
         else
         {
            prevItem->next = item->next;
         }

         /* Find the visible referenced by this item */
         visible = MHEG5findObject(item->groupRef, item->id);

         /* Destruct the reference to the visible */
         MHEG5freeMem(item);

         listGroup->itemCount--;

         /* 3. Set the position of the referenced Visible to its
          * OriginalPosition.
          */
         if (visible)
         {
            MHEG5visibleResetPosition((MHEG5Visible *)visible);
         }

         /* 4. If the index of the deleted Item was less than or equal to
          * FirstItem and FirstItem is strictly greater than one, then
          * decrease FirstItem internal attribute by one.
          */
         if ((idx <= listGroup->firstItem) && (listGroup->firstItem > 1))
         {
            listGroup->firstItem--;

            /* FirstItem has been decremented */
            MHEG5sendSync((MHEG5Root *)listGroup, MHEG5HEADITEMS, listGroup->firstItem - 1 );
         }
         else
         {
            /* FirstItem remains the same, ItemCount has been decremented */
            MHEG5sendSync((MHEG5Root *)listGroup, MHEG5TAILITEMS, listGroup->itemCount - listGroup->firstItem + 1 );
         }

         /* 5. Apply the Update behaviour. */
         MHEG5listGroupUpdate(listGroup);
         return;
      }
      prevItem = item;
      item = item->next;
   }
}

static void MHEG5listGroupSelect(MHEG5ListGroup *listGroup, MHEG5Int itemIndex)
{
   MHEG5ItemList *item;
   MHEG5Int i;

   item = listGroup->itemList;
   for (i = 1; (i < itemIndex) && (item != NULL); i++)
   {
      item = item->next;
   }

   if (item == NULL)
   {
      return;
   }

   /* Execute the following sequence of actions: */

   /* 1. If ItemSelectionStatus of item with index ItemIndex is True, ignore this behaviour. */
   if (item->itemSelectionStatus)
   {
      return;
   }

   /* 2. If MultipleSelection is False, apply Deselect(Index) internal
    * behaviour for any item with index Index, for which the
    * ItemSelectionStatus is True.
    */
   if (!listGroup->multipleSelection)
   {
      MHEG5ItemList *item2;
      MHEG5Int idx;

      item2 = listGroup->itemList;
      idx = 0;
      while (item2)
      {
         idx++;
         if (item2->itemSelectionStatus)
         {
            MHEG5listGroupDeselect(listGroup, idx);
         }
         item2 = item2->next;
      }
   }

   /* 3. Set the ItemSelectionStatus of the item with index ItemIndex to True. */
   item->itemSelectionStatus = MHEG5TRUE;

   /* 4. Generate an ItemSelected event with ItemIndex as associated data. */
   MHEG5sendSync((MHEG5Root *)listGroup, MHEG5ITEMSELECTED, itemIndex );
}

static void MHEG5listGroupDeselect(MHEG5ListGroup *listGroup, MHEG5Int itemIndex)
{
   MHEG5ItemList *item;
   MHEG5Int i;

   item = listGroup->itemList;
   for (i = 1; (i < itemIndex) && (item != NULL); i++)
   {
      item = item->next;
   }

   if (item == NULL)
   {
      return;
   }

   /* Execute the following sequence of actions: */

   /* 1. If ItemSelectionStatus of item with index ItemIndex is False, ignore this behaviour. */
   if (!item->itemSelectionStatus)
   {
      return;
   }

   /* 2. Set the ItemSelectionStatus of the item with the index ItemIndex to False. */
   item->itemSelectionStatus = MHEG5FALSE;

   /* 3. Generate an ItemDeselected event with ItemIndex as associated data. */
   MHEG5sendSync((MHEG5Root *)listGroup, MHEG5ITEMDESELECTED, itemIndex );
}

static MHEG5Int MHEG5listGroupAdjustindex(MHEG5ListGroup *listGroup, MHEG5Int idx)
{
   assert(listGroup);
   if (!listGroup)
   {
      return 0;
   }

   /* Set the Adjusted parameter to the value of the Index parameter normalised
    * to the length of the ItemList, by applying the following logic:
    */
   /* If the length of ItemListis zero then set Adjustedto 1. */
   if (!listGroup->itemCount)
   {
      return 1;
   }

   /* Otherwise, if Index is greater than the length of ItemList, set Adjusted
    * to:
    *      (( Index-1) MODULO Length of ItemList) + 1
    */
   if (idx > listGroup->itemCount)
   {
      return ((idx - 1) % listGroup->itemCount) + 1;
   }

   /* Otherwise, if Index is less than 1, set Adjusted to:
    *      Length of ItemList - ((- Index) MODULO Length of ItemList)
    */
   if (idx < 1)
   {
      return listGroup->itemCount - ((-idx) % listGroup->itemCount);
   }

   /* Otherwise, set Adjustedto Index, unmodified. */
   return idx;
}

/*
     Actions
 */
MHEG5ErrorCode MHEG5addItem(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5GList *thirdParam = 0;
   MHEG5Int itemIndex;
   MH5GroupRef gref;
   MHEG5Int id;

   assert(target);

   if (target->clazz != MHEG5LISTGROUP)
   {
      return MHEG5ERR_WRONGTARGET;
   }
   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   thirdParam = MHEG5resolveGenericInteger(params, &itemIndex);
   if (!thirdParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveGenericORefProper(thirdParam, &gref, &id);
   if ((id == 0) || (gref.ptr.group == 0))
   {
      return MHEG5ERR_REFERENCEDPARAMNOTAVAILABLE;
   }

   /* Apply the Additem(ItemIndex, VisibleReference) internal behaviour to add
    * the reference to the visible, as indicated by the VisibleReference
    * parameter at the position indicated by the ItemIndex parameter.
    */
   MHEG5listGroupAddItem((MHEG5ListGroup *)target, itemIndex, gref, id);

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5delItem(MHEG5Root *target, MHEG5GList *params)
{
   MH5GroupRef gref;
   MHEG5Int id;

   assert(target);

   if (target->clazz != MHEG5LISTGROUP)
   {
      return MHEG5ERR_WRONGTARGET;
   }
   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   MHEG5resolveGenericORefProper(params, &gref, &id);
   if ((id == 0) || (gref.ptr.group == 0))
   {
      return MHEG5ERR_REFERENCEDPARAMNOTAVAILABLE;
   }

   /* Apply the Delitem(VisibleReference) internal behaviour to delete the
    * reference to the visible, as indicated by the VisibleReference parameter
    * from the ItemList attribute, if it occurs in it.
    */
   MHEG5listGroupDelItem((MHEG5ListGroup *)target, gref, id);

   return MHEG5ERR_NOERROR;
}

/* mh5variable.h is included at the top of this file and yet the ST compiler still does not
 * know about the function MHEG5objRefValueDestruct unless its definition is placed here
 * ??? - beats me!
 */
extern void MHEG5objRefValueDestruct(MHEG5ObjectRefVariable *objRef);

MHEG5ErrorCode MHEG5getListItem(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5GList *thirdParam = 0;
   MHEG5Root *visible;
   MHEG5Int itemIndex;
   MHEG5Int idx;
   MHEG5ItemList *item;
   MHEG5ListGroup *listGroup;
   MHEG5ObjectRefVariable *oRef;
   MHEG5Int i;

   assert(target);

   if (target->clazz != MHEG5LISTGROUP)
   {
      return MHEG5ERR_WRONGTARGET;
   }
   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   thirdParam = MHEG5resolveGenericInteger(params, &itemIndex);
   if (!thirdParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(thirdParam, &visible);
   if (!visible)
   {
      return MHEG5ERR_REFERENCEDPARAMNOTAVAILABLE;
   }
   if (visible->clazz != MHEG5OBJECTREFVARIABLE)
   {
      return MHEG5ERR_WRONGPARAM;
   }
   listGroup = (MHEG5ListGroup *)target;

   /* Using a local variable Index: */
   if (!listGroup->wrapAround)
   {
      /* If WrapAround is False, if ItemIndex is in the range
       * [1, length of ItemList] then set Index to ItemIndex, otherwise
       * ignore this action.
       */
      if ((itemIndex >= 1) && (itemIndex <= listGroup->itemCount))
      {
         idx = itemIndex;
      }
      else
      {
         return MHEG5ERR_NOERROR;
      }
   }
   else
   {
      /* If WrapAround is True, apply the AdjustIndex(ItemIndex,Index)
       * behaviour.
       */
      idx = MHEG5listGroupAdjustindex(listGroup, itemIndex);
   }

   /* Find the item in the item list */
   item = listGroup->itemList;
   for (i = 1; (i < idx) && (item != NULL); i++)
   {
      item = item->next;
   }

   /* Return the reference included in the ItemList attribute with the index
    * specified by the Index parameter in the ObjectRefVariable referenced by
    * ItemRefVar.
    */
   oRef = (MHEG5ObjectRefVariable *)visible;
   if (item)
   {
      MHEG5objRefStoreValue( oRef, item->groupRef, item->id );
   }
   else
   {
      /* this could only get here if internal error with the linked list of items */
      TRACE(TERROR, ("itemIndex=%d wr=%d", itemIndex, listGroup->wrapAround))
      assert(0);
   }
   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5getCellItem(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5GList *thirdParam = 0;
   MHEG5Root *visible;
   MHEG5Int idx, first;
   MHEG5ItemList *item;
   MHEG5ListGroup *listGroup;
   MHEG5ObjectRefVariable *oRef;

   if (target->clazz != MHEG5LISTGROUP)
   {
      return MHEG5ERR_WRONGTARGET;
   }
   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   thirdParam = MHEG5resolveGenericInteger(params, &idx);
   if (!thirdParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(thirdParam, &visible);
   if (!visible)
   {
      return MHEG5ERR_REFERENCEDPARAMNOTAVAILABLE;
   }
   if (visible->clazz != MHEG5OBJECTREFVARIABLE)
   {
      return MHEG5ERR_WRONGPARAM;
   }
   listGroup = (MHEG5ListGroup *)target;

   /* Return the reference of the visible presented at the cell indicated by
    * the CellIndex parameter in the ObjectRefVariable referenced by
    * ItemRefVar. If the CellIndex specifies an index smaller than or equal to
    * 1 return the reference of the visible presented at the first cell. If the
    * CellIndex specifies an index greater than or equal to the number of
    * cells, return the reference of the visible presented in the last cell. If
    * no visible is presented at the indicated cell, return NULL.
    */
   if (idx < 1)
   {
      idx = 1;
   }
   if (idx > listGroup->positionCount)
   {
      idx = listGroup->positionCount;
   }

   if (listGroup->wrapAround)
   {
      if (idx > listGroup->itemCount)
      {
         /* Cell index is greater than the number of items in this list.
          * Nothing will be displayed in this cell.
          */
         first = 0;
      }
      else
      {
         first = MHEG5listGroupAdjustindex(listGroup, listGroup->firstItem + idx - 1);
      }
   }
   else
   {
      first = listGroup->firstItem + idx - 1;
      if (first > listGroup->itemCount)
      {
         first = 0;
      }
   }

   if (first > 0)
   {
      first--;
      item = listGroup->itemList;
      while ((first) && (item))
      {
         item = item->next;
         first--;
      }
   }
   else
   {
      item = NULL;
   }
   oRef = (MHEG5ObjectRefVariable *)visible;
   if (item)
   {
      MHEG5objRefStoreValue( oRef, item->groupRef, item->id );
   }
   else
   {
      MH5GroupRef gref;
      gref.len = 0;
      gref.ptr.group = NULL;
      MHEG5objRefStoreValue( oRef, gref, 0 );
   }
   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5getItemStatus(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5GList *thirdParam = 0;
   MHEG5Root *visible;
   MHEG5Int itemIndex;
   MHEG5Int idx;
   MHEG5ItemList *item;
   MHEG5ListGroup *listGroup;
   MHEG5BooleanVariable *oRef;
   int i;

   assert(target);

   if (target->clazz != MHEG5LISTGROUP)
   {
      return MHEG5ERR_WRONGTARGET;
   }
   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   thirdParam = MHEG5resolveGenericInteger(params, &itemIndex);
   if (!thirdParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(thirdParam, &visible);
   if (!visible)
   {
      return MHEG5ERR_REFERENCEDPARAMNOTAVAILABLE;
   }
   if (visible->clazz != MHEG5BOOLEANVARIABLE)
   {
      return MHEG5ERR_WRONGPARAM;
   }
   listGroup = (MHEG5ListGroup *)target;

   /* Using a local variable Index: */
   if (!listGroup->wrapAround)
   {
      /* If WrapAround is False, if ItemIndex is in the range
       * [1, length of ItemList] then set Index to ItemIndex, otherwise
       * ignore this action.
       */
      if ((itemIndex >= 1) && (itemIndex <= listGroup->itemCount))
      {
         idx = itemIndex;
      }
      else
      {
         return MHEG5ERR_NOERROR;
      }
   }
   else
   {
      /* If WrapAround is True, apply the AdjustIndex(ItemIndex,Index)
       * behaviour.
       */
      idx = MHEG5listGroupAdjustindex(listGroup, itemIndex);
   }

   /* Find the item in the item list */
   item = listGroup->itemList;
   for (i = 1; (i < idx) && (item != NULL); i++)
   {
      item = item->next;
   }

   oRef = (MHEG5BooleanVariable *)visible;
   if (item)
   {
      /* Return the value of the ItemSelectionStatus attribute of the item in
       * the ItemList with index Index in the BooleanVariable referenced by
       * ItemStatusVar
       */
      oRef->value = item->itemSelectionStatus;
   }
   else
   {
      oRef->value = MHEG5FALSE;
   }

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5selectItem(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Int itemIndex;
   MHEG5Int idx;
   MHEG5ListGroup *listGroup;

   assert(target);

   if (target->clazz != MHEG5LISTGROUP)
   {
      return MHEG5ERR_WRONGTARGET;
   }
   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveGenericInteger(params, &itemIndex);
   listGroup = (MHEG5ListGroup *)target;

   /* Using a local variable Index: */
   if (!listGroup->wrapAround)
   {
      /* If WrapAround is False, if ItemIndex is in the range
       * [1, length of ItemList] then set Index to ItemIndex, otherwise ignore
       * this action.
       */
      if ((itemIndex >= 1) && (itemIndex <= listGroup->itemCount))
      {
         idx = itemIndex;
      }
      else
      {
         return MHEG5ERR_NOERROR;
      }
   }
   else
   {
      /* If WrapAround is True, apply the AdjustIndex(ItemIndex,Index)
       * behaviour.
       */
      idx = MHEG5listGroupAdjustindex(listGroup, itemIndex);
   }

   /* Apply the Select(Index) internal behaviour. */
   MHEG5listGroupSelect(listGroup, idx);

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5deselectItem(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Int itemIndex;
   MHEG5Int idx;
   MHEG5ListGroup *listGroup;

   assert(target);

   if (target->clazz != MHEG5LISTGROUP)
   {
      return MHEG5ERR_WRONGTARGET;
   }
   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveGenericInteger(params, &itemIndex);
   listGroup = (MHEG5ListGroup *)target;

   /* Using a local variable Index: */
   if (!listGroup->wrapAround)
   {
      /* If WrapAround is False, if ItemIndex is in the range
       * [1, length of ItemList] then set Index to ItemIndex, otherwise ignore
       * this action.
       */
      if ((itemIndex >= 1) && (itemIndex <= listGroup->itemCount))
      {
         idx = itemIndex;
      }
      else
      {
         return MHEG5ERR_NOERROR;
      }
   }
   else
   {
      /* If WrapAround is True, apply the AdjustIndex(ItemIndex,Index)
       * behaviour.
       */
      idx = MHEG5listGroupAdjustindex(listGroup, itemIndex);
   }

   /* Apply the Deselect(Index) internal behaviour. */
   MHEG5listGroupDeselect(listGroup, idx);

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5toggleItem(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Int itemIndex;
   MHEG5Int idx;
   MHEG5Int i;
   MHEG5ItemList *item;
   MHEG5ListGroup *listGroup;

   assert(target);

   if (target->clazz != MHEG5LISTGROUP)
   {
      return MHEG5ERR_WRONGTARGET;
   }
   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveGenericInteger(params, &itemIndex);
   listGroup = (MHEG5ListGroup *)target;

   /* Using a local variable Index: */
   if (!listGroup->wrapAround)
   {
      /* If WrapAround is False, if ItemIndex is in the range
       * [1, length of ItemList] then set Index to ItemIndex, otherwise ignore
       * this action.
       */
      if ((itemIndex >= 1) && (itemIndex <= listGroup->itemCount))
      {
         idx = itemIndex;
      }
      else
      {
         return MHEG5ERR_NOERROR;
      }
   }
   else
   {
      /* If WrapAround is True, apply the AdjustIndex(ItemIndex,Index)
       * behaviour.
       */
      idx = MHEG5listGroupAdjustindex(listGroup, itemIndex);
   }

   /* Find the item in the item list */
   item = listGroup->itemList;
   if (item == 0)
   {
      return MHEG5ERR_NOERROR;
   }
   for (i = 1; i < idx; i++)
   {
      item = item->next;
      if (item == 0)
      {
         return MHEG5ERR_NOERROR;
      }
   }

   /* If the ItemSelectionStatus of the item indicated by Index is True, apply
    * the Deselect(Index) internal behaviour, otherwise apply the Select(Index)
    * internal behaviour.
    */
   if (item->itemSelectionStatus)
   {
      MHEG5listGroupDeselect(listGroup, idx);
   }
   else
   {
      MHEG5listGroupSelect(listGroup, idx);
   }

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5scrollItems(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Int itemsToScroll = 0, newIndex;
   MHEG5ListGroup *listGroup;
   MHEG5Int oldFirstItem;

   assert(target);

   if (target->clazz != MHEG5LISTGROUP)
   {
      return MHEG5ERR_WRONGTARGET;
   }
   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveGenericInteger(params, &itemsToScroll);

   listGroup = (MHEG5ListGroup *)target;
   newIndex = listGroup->firstItem + itemsToScroll;
   oldFirstItem = listGroup->firstItem;

   if (!listGroup->wrapAround)
   {
      /* If WrapAround is False, if FirstItem+ItemsToScroll is in the range
       * [1, length of ItemList] then set FirstItem to
       * FirstItem+ItemsToScroll, otherwise ignore this action.
       */
      if ((newIndex >= 1) && (newIndex <= listGroup->itemCount))
      {
         listGroup->firstItem = newIndex;
      }
      else
      {
         return MHEG5ERR_NOERROR;
      }
   }
   else
   {
      /* If WrapAround is True, apply the
       * AdjustIndex(FirstItem+ItemsToScroll,FirstItem) behaviour.
       */
      listGroup->firstItem = MHEG5listGroupAdjustindex(listGroup, newIndex);
   }

   if (oldFirstItem != listGroup->firstItem)
   {
      /* FirstItem has changed */
      MHEG5sendSync((MHEG5Root *)listGroup, MHEG5HEADITEMS, listGroup->firstItem - 1 );
      MHEG5sendSync((MHEG5Root *)listGroup, MHEG5TAILITEMS, listGroup->itemCount - listGroup->firstItem + 1 );
   }

   /* Apply the Update behaviour. */
   MHEG5listGroupUpdate(listGroup);

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5setFirstItem(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Int newFirstItem;
   MHEG5ListGroup *listGroup;
   MHEG5Int oldFirstItem;

   assert(target);

   if (target->clazz != MHEG5LISTGROUP)
   {
      return MHEG5ERR_WRONGTARGET;
   }
   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveGenericInteger(params, &newFirstItem);

   listGroup = (MHEG5ListGroup *)target;
   oldFirstItem = listGroup->firstItem;

   if (!listGroup->wrapAround)
   {
      /* If WrapAround is False, if NewFirstItem is in the range
       * [1, length of ItemList] then set FirstItem to NewFirstItem, otherwise
       * ignore this action.
       */
      if ((newFirstItem >= 1) && (newFirstItem <= listGroup->itemCount))
      {
         listGroup->firstItem = newFirstItem;
      }
      else
      {
         return MHEG5ERR_NOERROR;
      }
   }
   else
   {
      /* If WrapAround is True, apply the AdjustIndex(NewFirstItem,FirstItem)
       * behaviour.
       */
      listGroup->firstItem = MHEG5listGroupAdjustindex(listGroup, newFirstItem);
   }

   if (oldFirstItem != listGroup->firstItem)
   {
      /* FirstItem has changed */
      MHEG5sendSync((MHEG5Root *)listGroup, MHEG5HEADITEMS, listGroup->firstItem - 1);
      MHEG5sendSync((MHEG5Root *)listGroup, MHEG5TAILITEMS, listGroup->itemCount - listGroup->firstItem + 1);
   }

   /* Apply the Update behaviour. */
   MHEG5listGroupUpdate(listGroup);

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5getFirstItem(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Root *object = 0;
   MHEG5ListGroup *listGroup;
   MHEG5IntegerVariable *oRef;

   assert(target);

   if (target->clazz != MHEG5LISTGROUP)
   {
      return MHEG5ERR_WRONGTARGET;
   }
   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(params, &object);
   if (!object)
   {
      return MHEG5ERR_REFERENCEDPARAMNOTAVAILABLE;
   }
   if (object->clazz != MHEG5INTEGERVARIABLE)
   {
      return MHEG5ERR_WRONGPARAM;
   }

   listGroup = (MHEG5ListGroup *)target;

   /* Return the current value of the FirstItem attribute in the
    * IntegerVariable referenced by FirstItemVar.
    */
   oRef = (MHEG5IntegerVariable *)object;
   oRef->value = listGroup->firstItem;

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5getListSize(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Root *object = 0;
   MHEG5ListGroup *listGroup;
   MHEG5IntegerVariable *oRef;

   assert(target);

   if (target->clazz != MHEG5LISTGROUP)
   {
      return MHEG5ERR_WRONGTARGET;
   }
   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(params, &object);
   if (!object)
   {
      return MHEG5ERR_REFERENCEDPARAMNOTAVAILABLE;
   }
   if (object->clazz != MHEG5INTEGERVARIABLE)
   {
      return MHEG5ERR_WRONGPARAM;
   }

   listGroup = (MHEG5ListGroup *)target;

   /* Return the number of items in the ItemList in the IntegerVariable
    * referenced by SizeVar.
    */
   oRef = (MHEG5IntegerVariable *)object;
   oRef->value = listGroup->itemCount;

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5setCellPosition(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5GList *thirdParam = 0;
   MHEG5GList *fourthParam = 0;
   MHEG5ListGroup *listGroup;
   MHEG5Int idx, newXPosition, newYPosition;
   MHEG5Int counter;
   MHEG5PosList *position;

   assert(target);

   if (target->clazz != MHEG5LISTGROUP)
   {
      return MHEG5ERR_WRONGTARGET;
   }
   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   thirdParam = MHEG5resolveGenericInteger(params, &idx);
   if (!thirdParam)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   fourthParam = MHEG5resolveGenericInteger(thirdParam, &newXPosition);
   if (!fourthParam)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   MHEG5resolveGenericInteger(fourthParam, &newYPosition);

   listGroup = (MHEG5ListGroup *)target;

   position = listGroup->positions;
   for (counter = 1; counter < idx; ++counter)
   {
      if (position->next)
      {
         position = position->next;
      }
   }
   position->position.x = newXPosition;
   position->position.y = newYPosition;

   /* Apply the Update behaviour. */
   MHEG5listGroupUpdate(listGroup);

   return MHEG5ERR_NOERROR;
}