mh5text.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 "mh5text.h"
#include "mh5entryfield.h"
#include "mh5object.h"          /* for actions */
#include "mh5variable.h"        /* for actions */
#include "mh5display.h"         /* for actions */
#include "mh5memory.h"          /* for constructor/destructor */
#include "mh5application.h"     /* Default Colour   */
#include "mh5profile.h"
#include "mh5debug.h"
#include <stdlib.h>
#include <string.h>
#include "mh5drawtext.h"
#include "mg_api.h"

#define UNICODE_BOM_LITTLE_ENDIAN   0xFFFE
#define UNICODE_BOM_BIG_ENDIAN      0xFEFF

/*
   Debug
 */
#ifdef MH5PRINTOUT

void MHEG5textPrint(MHEG5Text *text, char *out)
{
   /* Base Class */
   MHEG5visiblePrint(&text->visible, out);

   /* Exchanged Attributes */
   if (text->originalFont.referenced || text->originalFont.ref.included.len)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":OrigFont ");
      MHEG5fontBodyPrint(text->originalFont, out);
      MHEG5newLine(out);
   }

   if (text->originalFontAttributes.len)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":FontAttributes ");
      MHEG5stringPrint(text->originalFontAttributes, out);
      MHEG5newLine(out);
   }

/*
   if (text->originalTextColour.direct)
   {
      MHEG5indent(out);
      MHEG_PRINT(out,":OriginalTextColour ");
      MHEG5colourPrint(text->originalTextColour,out);
      MHEG5newLine(out);
   }

   if (text->originalBackgroundColour.direct)
   {
      MHEG5indent(out);
      MHEG_PRINT(out,":OriginalBackgroundColour ");
      MHEG5colourPrint(text->originalBackgroundColour,out);
      MHEG5newLine(out);
   }
 */
   if (text->characterSet)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":CharacterSet ");
      MHEG5intPrint(text->characterSet, out);
      MHEG5newLine(out);
   }

   if (text->horizontalJustification != HJUSTIFICATION_START)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":HJustification ");
      switch (text->horizontalJustification)
      {
         case HJUSTIFICATION_END:       MHEG_PRINT(out, "end"); break;
         case HJUSTIFICATION_CENTRE:    MHEG_PRINT(out, "centre");  break;
         case HJUSTIFICATION_JUSTIFIED: MHEG_PRINT(out, "justified"); break;
         default:;
      }
      MHEG5newLine(out);
   }

   if (text->verticalJustification != VJUSTIFICATION_START)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":VJustification ");
      switch (text->verticalJustification)
      {
         case VJUSTIFICATION_END:       MHEG_PRINT(out, "end"); break;
         case VJUSTIFICATION_CENTRE:    MHEG_PRINT(out, "centre");  break;
         case VJUSTIFICATION_JUSTIFIED: MHEG_PRINT(out, "justified"); break;
         default:;
      }
      MHEG5newLine(out);
   }

   if (text->verticalLineOrientation)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":LineOrientation vertical");
      MHEG5newLine(out);
   }

   if (text->startCorner != 0)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":StartCorner ");
      switch (text->startCorner)
      {
         case 1: MHEG_PRINT(out, "upper-right"); break;
         case 2: MHEG_PRINT(out, "lower-left");  break;
         case 3: MHEG_PRINT(out, "lower-right"); break;
         default:;
      }
      MHEG5newLine(out);
   }

   if (!text->originalTextColour.indirect && text->originalTextColour.type)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":TextColour ");
      MHEG5colourPrint(text->originalTextColour, out);
      MHEG5newLine(out);
   }

   if (!text->originalBackgroundColour.indirect && text->originalBackgroundColour.type)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":BackgroundColour ");
      MHEG5colourPrint(text->originalBackgroundColour, out);
      MHEG5newLine(out);
   }

   if (text->textWrapping)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":TextWrapping TRUE");
      MHEG5newLine(out);
   }
}

#endif

/*
     Constructor
 */
void MHEG5textInit(MHEG5Text *text)
{
   assert(text);

   MHEG5visibleInit(&text->visible);
}

void MHEG5textFree(MHEG5Text *text)
{
   assert(text);

   MHEG5visibleFree(&text->visible);

   if (text->originalFont.referenced)
   {
      if (text->originalFont.ref.referenced.grp.len != 0)
      {
         MHEG5stringDestruct((MHEG5String *)&text->originalFont.ref.referenced.grp);
      }
   }
   else
   {
      MHEG5stringDestruct(&text->originalFont.ref.included);
   }
   MHEG5stringDestruct(&text->originalFontAttributes);
   MHEG5colourDestruct(&text->originalTextColour);
   MHEG5colourDestruct(&text->originalBackgroundColour);

   MHEG5stringDestruct(&text->textDataRaw);
}

MHEG5Text* MHEG5textClone(MHEG5Text *source)
{
   MHEG5Text *destination;

   assert(source);
   destination = (MHEG5Text *)MHEG5getMem( sizeof(MHEG5Text));
   if (destination != NULL)
   {
      memset( destination, 0, sizeof(MHEG5Text));
      destination->visible.ingredient.root.clazz = MHEG5TEXT;

      MHEG5visibleClone(&destination->visible, &source->visible);

      destination->originalFont.referenced = source->originalFont.referenced;
      if (source->originalFont.referenced)
      {
         if (source->originalFont.ref.referenced.grp.len != 0)
         {
            MHEG5String name;
            name.len = source->originalFont.ref.referenced.grp.len;
            name.data = source->originalFont.ref.referenced.grp.ptr.name;
            name = MHEG5stringCopy(name);
            destination->originalFont.ref.referenced.grp.len = name.len;
            destination->originalFont.ref.referenced.grp.ptr.name = name.data;
         }
         else
         {
            destination->originalFont.ref.referenced.grp.len = 0;
            destination->originalFont.ref.referenced.grp.ptr.group = source->originalFont.ref.referenced.grp.ptr.group;
         }
         destination->originalFont.ref.referenced.id = source->originalFont.ref.referenced.id;
      }
      else
      {
         destination->originalFont.ref.included = MHEG5stringCopy(source->originalFont.ref.included);
      }
      destination->originalFontAttributes = MHEG5stringCopy(source->originalFontAttributes);
      MHEG5genericCopy(&destination->originalTextColour, &source->originalTextColour);
      MHEG5genericCopy(&destination->originalBackgroundColour, &source->originalBackgroundColour);
      destination->characterSet = source->characterSet;
      destination->horizontalJustification = source->horizontalJustification;
      destination->verticalJustification = source->verticalJustification;
      destination->verticalLineOrientation = source->verticalLineOrientation;
      destination->startCorner = source->startCorner;
      destination->textWrapping = source->textWrapping;
   }
   return destination;
}

/*
     Internal behaviours
 */
void MHEG5textPrepare(MHEG5Text *text)
{
   assert(text);
   text->font.referenced = text->originalFont.referenced;
   if (text->font.referenced)
   {
      if (text->originalFont.ref.referenced.grp.len != 0)
      {
         text->font.ref.referenced.grp = text->originalFont.ref.referenced.grp;
      }
      else
      {
         text->font.ref.referenced.grp.len = 0;
         text->font.ref.referenced.grp.ptr.group = text->originalFont.ref.referenced.grp.ptr.group;
      }
      text->font.ref.referenced.id = text->originalFont.ref.referenced.id;
   }
   else
   {
      text->font.ref.included = MHEG5stringCopy(text->originalFont.ref.included);
   }

   text->fontAttributes = MHEG5stringCopy(text->originalFontAttributes);
   MHEG5genericCopy(&text->textColour, &text->originalTextColour);
   MHEG5genericCopy(&text->backgroundColour, &text->originalBackgroundColour);

   MHEG5visiblePrepare(&text->visible);
}

void MHEG5textActivate(MHEG5Text *text)
{
   assert(text);
   if (!text->visible.ingredient.root.availabilityStatus)
   {
      MHEG5textPrepare( text );
   }
   MHEG5visibleActivate(&text->visible);
}

void MHEG5textDeactivate(MHEG5Text *text)
{
   assert(text);
   if (text->visible.graphic_data != NULL)
   {
      MG_FreeData( text->visible.graphic_data );
      text->visible.graphic_data = NULL;
   }
   MHEG5visibleDeactivate(&text->visible);
}

void MHEG5textDestruct(MHEG5Text *text)
{
   assert(text);
   MHEG5visibleDestruct(&text->visible);
   if (text->font.referenced)
   {
      if (text->font.ref.referenced.grp.len != 0)
      {
         MHEG5stringDestruct((MHEG5String *)&text->font.ref.referenced.grp);
      }
   }
   else
   {
      MHEG5stringDestruct(&text->font.ref.included);
   }

   MHEG5stringDestruct(&text->fontAttributes);
   MHEG5colourDestruct(&text->textColour);
   MHEG5colourDestruct(&text->backgroundColour);
}

void MHEG5textRedraw(MHEG5Text *text)
{
   if (((MHEG5Root *)text)->clazz == MHEG5ENTRYFIELD)
   {
      MHEG5drawEntry((MHEG5Entryfield *)text, CURSOR_INSERT);
   }
   else if (((MHEG5Root *)text)->clazz == MHEG5HYPERTEXT)
   {
      MHEG5drawHypertext((MHEG5Hypertext *)text );
   }
   else
   {
      MHEG5drawText( text );
   }
   MHEG5displayRedraw((MHEG5Visible *) text);
}

/*
    Actions
 */

MHEG5ErrorCode MHEG5getTextContent(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Root *tVar = 0;

   assert(target);

   if ((target->clazz != MHEG5TEXT) &&
       (target->clazz != MHEG5HYPERTEXT) &&
       (target->clazz != MHEG5ENTRYFIELD))
      return MHEG5ERR_WRONGTARGET;

   if (!params)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   MHEG5resolveORef(params, &tVar);
   if (!tVar)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   if (!tVar->runningStatus)
      return MHEG5ERR_PARAMNOTACTIVE;

   /* What should happen if content is included, but TextContentVar is a
    * ContentRefVariable or content is referenced but TextContentVar is an
    * OctetStringVariable? Current implementation returns MHEG5ERR_WRONGPARAM.
    */
   if (((MHEG5Ingredient *) target)->content.referenced)
   {
      if (tVar->clazz != MHEG5CONTENTREFVARIABLE)
         return MHEG5ERR_WRONGPARAM;
      MHEG5stringDestruct(&((MHEG5ContentVariable *) tVar)->contentData);
      ((MHEG5ContentVariable *) tVar)->contentData = MHEG5stringCopy(((MHEG5Ingredient *) target)->content.ref.referenced.reference);
   }
   else
   {
      if (tVar->clazz != MHEG5OCTETSTRINGVARIABLE)
         return MHEG5ERR_WRONGPARAM;
      MHEG5stringDestruct(&((MHEG5OctetStringVariable *) tVar)->value);
      ((MHEG5OctetStringVariable *) tVar)->value = MHEG5stringCopy(((MHEG5Ingredient *) target)->content.ref.included);
   }
   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5getTextData(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Root *tVar = 0;

   assert(target);

   if ((target->clazz != MHEG5TEXT) && (target->clazz != MHEG5HYPERTEXT) && (target->clazz != MHEG5ENTRYFIELD))
   {
      return MHEG5ERR_WRONGTARGET;
   }

   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   MHEG5resolveORef(params, &tVar);

   if (!tVar)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if (!tVar->runningStatus)
   {
      return MHEG5ERR_PARAMNOTACTIVE;
   }

   if (tVar->clazz != MHEG5OCTETSTRINGVARIABLE)
   {
      return MHEG5ERR_WRONGPARAM;
   }

   MHEG5stringDestruct(&((MHEG5OctetStringVariable *) tVar)->value);

   if ((target->clazz == MHEG5TEXT) || (target->clazz == MHEG5HYPERTEXT))
   {
     #ifdef TRACING
      if (mheg_trace_debug & TACTIONS)
      {
         char buff[256];
         strcpy(buff, T_NL "MHEG5getTextData ");
         MHEG5stringTrace(((MHEG5Text *) target)->textDataRaw, buff, 0, 120 );
         DBG_PRINTF(buff);
         DBG_PRINTF(" )");
      }
     #endif
      /* For non-interactible Text classes, the raw text data is kept. This
       * allows non-UTF-8 complient content to be returned.
       */
      ((MHEG5OctetStringVariable *) tVar)->value = MHEG5stringCopy(((MHEG5Text *) target)->textDataRaw);
   }
   else
   {
      if (((MHEG5Ingredient *)target)->contentHook == 11)
      {
         MHEG5textContentUnadaptUTF16((MHEG5Text *)target, &((MHEG5OctetStringVariable *) tVar)->value.data, &((MHEG5OctetStringVariable *) tVar)->value.len);
      }
      else
      {
         /* For entryfield class, we must unadapt the existing content */
         MHEG5textContentUnadapt((MHEG5Text *)target, &((MHEG5OctetStringVariable *) tVar)->value.data, &((MHEG5OctetStringVariable *) tVar)->value.len);
      }
   }

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5setFontAttributes(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5String newFontAttributes;
   MHEG5Bool invalidString;
   MHEG5Text *text;

   assert(target);

   if ((target->clazz != MHEG5TEXT) && (target->clazz != MHEG5HYPERTEXT) && (target->clazz != MHEG5ENTRYFIELD))
   {
      return MHEG5ERR_WRONGTARGET;
   }
   text = (MHEG5Text *) target;

   if (!params)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   MHEG5resolveGenericOctetString(params, &newFontAttributes, &invalidString);
   if (invalidString == MHEG5TRUE)
      return MHEG5ERR_NOERROR;

   text->fontAttributes = MHEG5stringCopy(newFontAttributes);

   MHEG5textRedraw((MHEG5Text *) target);

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5setTextColour(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Colour newTextColour;
   MHEG5Text *text;

   assert(target);

   if ((target->clazz != MHEG5TEXT) && (target->clazz != MHEG5HYPERTEXT) && (target->clazz != MHEG5ENTRYFIELD))
   {
      return MHEG5ERR_WRONGTARGET;
   }
   text = (MHEG5Text *) target;

   if (!params)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   MHEG5resolveGenericGeneric(params, &newTextColour);

   MHEG5colourDestruct(&text->textColour);
   MHEG5genericCopy(&text->textColour, &newTextColour);

   MHEG5textRedraw((MHEG5Text *) target);

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5setBackgroundColour(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Colour newBackgroundColour;
   MHEG5Text *text;

   assert(target);

   if ((target->clazz != MHEG5TEXT) && (target->clazz != MHEG5HYPERTEXT) && (target->clazz != MHEG5ENTRYFIELD))
   {
      return MHEG5ERR_WRONGTARGET;
   }
   text = (MHEG5Text *) target;

   if (!params)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   MHEG5resolveGenericGeneric(params, &newBackgroundColour);

   MHEG5genericCopy(&text->backgroundColour, &newBackgroundColour);

   MHEG5textRedraw((MHEG5Text *) target);

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5setFontRef(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Text *text;
   MHEG5Generic g;

   assert(target);

   if ((target->clazz != MHEG5TEXT) && (target->clazz != MHEG5HYPERTEXT) && (target->clazz != MHEG5ENTRYFIELD))
   {
      return MHEG5ERR_WRONGTARGET;
   }
   text = (MHEG5Text *) target;

   if (!params)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   MHEG5resolveGenericGeneric(params, &g);
   if (g.type == MHEG5OBJECTREF)
   {
      if (text->font.referenced)
      {
         MHEG5stringDestruct((MHEG5String *)&text->font.ref.referenced.grp);
      }
      else
      {
         MHEG5stringDestruct(&text->font.ref.included);
      }
      text->font.referenced = MHEG5TRUE;
      if (g.value.o.gref.len != 0)
      {
         MHEG5String name;
         name.len = g.value.o.gref.len;
         name.data = g.value.o.gref.ptr.name;
         name = MHEG5stringCopy(name);
         text->font.ref.referenced.grp.len = name.len;
         text->font.ref.referenced.grp.ptr.name = name.data;
      }
      else
      {
         text->font.ref.referenced.grp = g.value.o.gref;
      }
      text->font.ref.referenced.id = g.value.o.id;
   }
   else if (g.type == MHEG5OCTETSTRING)
   {
      if (text->font.referenced)
      {
         MHEG5stringDestruct((MHEG5String *)&text->font.ref.referenced.grp);
      }
      else
      {
         MHEG5stringDestruct(&text->font.ref.included);
      }
      text->font.referenced = MHEG5FALSE;
      text->font.ref.included = MHEG5stringCopy(g.value.s);
   }

   MHEG5textRedraw((MHEG5Text *) target);

   return MHEG5ERR_NOERROR;
}

static MHEG5Int getMarkupLength(unsigned char *data, MHEG5Int len)
{
   if (len > 0)
   {
      if (*data >= 0x40 && *data <= 0x5e)
      {
         /* Start of markup */
         MHEG5Int paramLength;

         if (len > 1)
         {
            paramLength = data[1];
         }
         else
         {
            paramLength = -1;
         }

         /* Return the length of markup_start_identifier,
          * parameters_length and parameter_bytes
          */
         return paramLength + 2;
      }

      if (*data >= 0x60 && *data <= 0x7e)
      {
         /* End of markup */
         /* Return the length of end_of_markup and markup_end_identifier bytes
          */
         return 1;
      }
   }
   /* Unknown markup identifier */
   return 0;
}

void MHEG5textUtf8Content(MHEG5Text *text, unsigned char *data, int len)
{
   int pos;
   int adaptedDataLen;
   unsigned short *adaptedData;

   /* Set default adapted data to be empty */
   text->visible.ingredient.data = 0;
   text->visible.ingredient.dataLen = 0;

   /* Create a temporary buffer the maximum possible adapted size */
   adaptedData = MHEG5getMem(len * sizeof(unsigned short));

   if (adaptedData == NULL)
   {
      ERROR_PRINT(("ERROR : MHEG5textContentAdapt out of memory\n"));
      return;
   }

   pos = 0;
   adaptedDataLen = 0;
   while (pos < len)
   {
      if (data[pos] == 0x1b)
      {
         /* Skip all markup - copy it unchanged */
         unsigned int markupLength;

         adaptedData[adaptedDataLen] = data[pos];
         pos++;
         adaptedDataLen++;

         markupLength = getMarkupLength(&data[pos], len - pos);

         while (markupLength > 0)
         {
            adaptedData[adaptedDataLen] = data[pos];
            pos++;
            adaptedDataLen++;
            markupLength--;
         }
      }
      else
      {
         /* Convert UTF8 chars to unicode character:
          *
          *      0x00000000 - 0x0000007F:
          *          0xxxxxxx
          *
          *      0x00000080 - 0x000007FF:
          *          110xxxxx 10xxxxxx
          *
          *      0x00000800 - 0x0000FFFF:
          *          1110xxxx 10xxxxxx 10xxxxxx
          *
          *      0x00010000 - 0x001FFFFF:
          *          11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
          *
          * The  xxx  bit  positions  are  filled with the bits of the
          * character code number in binary representation.  Only  the
          * shortest  possible  multibyte sequence which can represent
          * the code number of the character can be used.
          */
         if ((data[pos] & 0x80) == 0x00)
         {
            /* 1 Byte code */
            adaptedData[adaptedDataLen] = data[pos];
         }
         else if ((data[pos] & 0xe0) == 0xc0)
         {
            /* 2 Byte code */
            if (pos + 1 == len)
            {
               /* This char exceeds the end of data - break out of while loop */
               /* assert(0); */
               break;
            }
            adaptedData[adaptedDataLen] = (data[pos] & 0x1F) << 6;
            pos++;
            adaptedData[adaptedDataLen] |= (data[pos] & 0x3F);
         }
         else if ((data[pos] & 0xf0) == 0xe0)
         {
            /* 3 Byte code */
            if (pos + 2 >= len)
            {
               /* This char exceeds the end of data - break out of while loop */
               /* assert(0); DTG X.1 test gets here */
               break;
            }
            adaptedData[adaptedDataLen] = (data[pos] & 0x0F) << 12;
            pos++;
            adaptedData[adaptedDataLen] |= (data[pos] & 0x3F) << 6;
            pos++;
            adaptedData[adaptedDataLen] |= (data[pos] & 0x3F);
         }
         else if ((data[pos] & 0xf8) == 0xf0)
         {
            /* 4 Byte code - not used by UK1.05 profile */
            if (pos + 3 >= len)
            {
               /* This char exceeds the end of data - break out of while loop */
               /* assert(0); */
               break;
            }
            adaptedData[adaptedDataLen] = 0;
            pos += 3;
         }
         else
         {
            /* Unrecognised code - ignore it. */
            adaptedData[adaptedDataLen] = 0;
         }
         pos++;
         adaptedDataLen++;
      }
   }

   if (((MHEG5Root *)text)->clazz == MHEG5ENTRYFIELD)
   {
      if ((((MHEG5Entryfield *)text)->maxlength > 0) &&
          (adaptedDataLen > ((MHEG5Entryfield *)text)->maxlength))
      {
         adaptedDataLen = ((MHEG5Entryfield *)text)->maxlength;
      }
   }

   if (adaptedDataLen == len)
   {
      /* The temporary buffer was already the correct size. Just store a
       * pointer to it - there's no need to copy the data again.
       */
      text->visible.ingredient.data = (unsigned char *)adaptedData;
      text->visible.ingredient.dataLen = adaptedDataLen;
   }
   else
   {
      /* We now know the size of the adapted content, so allocate a buffer for
       * it and copy the adapted data into it from the temporary buffer.
       */
      text->visible.ingredient.data = MHEG5getMem(adaptedDataLen * sizeof(unsigned short));
      if (text->visible.ingredient.data != 0)
      {
         memcpy(text->visible.ingredient.data, adaptedData,
            adaptedDataLen * sizeof(unsigned short));
         text->visible.ingredient.dataLen = adaptedDataLen;
      }

      /* Free off the temporay buffer */
      MHEG5freeMem(adaptedData);
   }

   if (((MHEG5Root *)text)->clazz != MHEG5ENTRYFIELD)
   {
      /* Make a copy of the raw content for Text and HyperText classes. Note that
       * this is not done for EntryField classes, which can alter the TextData
       * internal attribute through interaction.
       */
      /* Destruct the old copy */
      MHEG5stringDestruct(&text->textDataRaw);

      /* Allocate memory for new raw text data */
      text->textDataRaw.data = STR_DataAlloc( len );
      if (text->textDataRaw.data == NULL)
      {
         ERROR_PRINT(("ERROR : MHEG5textContentAdapt out of memory\n"));
         return;
      }

      /* Copy the raw text data */
      memcpy(text->textDataRaw.data, data, len);
      text->textDataRaw.len = len;
#ifdef DRAW_IN_ADVANCE
      if (((MHEG5Root *)text)->clazz == MHEG5HYPERTEXT)
      {
         MHEG5drawHypertext((MHEG5Hypertext *)text );
      }
      else
      {
         MHEG5drawText((MHEG5Text *)text );
      }
   }
   else
   {
      MHEG5drawEntry((MHEG5Entryfield *)text, CURSOR_INSERT);
#endif /*DRAW_IN_ADVANCE*/
   }
}

void MHEG5textUtf16Content(MHEG5Text *text, unsigned char *data, int len)
{
   unsigned char *p_data, *p_end;
   int is_little_endian;
   int adpt_len, m_len;
   unsigned short *p_adpt, tmp_adpt;

   tmp_adpt = (data[0] << 8) | data[1];
   text->byteOrderMark = BOM_NONE;
   switch (tmp_adpt)
   {
      case UNICODE_BOM_LITTLE_ENDIAN:
         is_little_endian = 1;
         data += 2; /* skip BOM */
         len -= 2;
         text->byteOrderMark = BOM_LITTLE_ENDIAN;
         break;

      case UNICODE_BOM_BIG_ENDIAN:
         data += 2; /* skip BOM */
         len -= 2;
         text->byteOrderMark = BOM_BIG_ENDIAN;
      /* fallthrough */

      default: /* assumes big endian */
         is_little_endian = 0;
   }

   adpt_len = 0;
   p_data = data;
   p_end = data + len;
   if (is_little_endian)
   {
      while (p_data < p_end)
      {
         tmp_adpt = *p_data;
         p_data++;
         tmp_adpt |= *p_data << 8;
         p_data++;
         adpt_len++;
         if (tmp_adpt == 0x001B)
         {
            m_len = getMarkupLength(p_data, p_end - p_data);
            adpt_len += m_len;
            p_data += m_len;
         }
      }
   }
   else
   {
      while (p_data < p_end)
      {
         tmp_adpt = *p_data << 8;
         p_data++;
         tmp_adpt |= *p_data;
         p_data++;
         adpt_len++;
         if (tmp_adpt == 0x001B)
         {
            m_len = getMarkupLength(p_data, p_end - p_data);
            adpt_len += m_len;
            p_data += m_len;
         }
      }
   }

   /* Create a buffer the right adapted size */
   p_adpt = MHEG5getMem(adpt_len * sizeof(unsigned short));

   if (p_adpt == NULL)
   {
      ERROR_PRINT(("ERROR : MHEG5textContentAdapt out of memory\n"));
   }
   else
   {
      text->visible.ingredient.data = (unsigned char *)p_adpt;
      text->visible.ingredient.dataLen = adpt_len;

      p_data = data;
      if (is_little_endian)
      {
         while (p_data < p_end)
         {
            *p_adpt = *p_data;
            p_data++;
            *p_adpt |= *p_data << 8;
            p_data++;
            if (*p_adpt == 0x001B)
            {
               p_adpt++;
               m_len = getMarkupLength(p_data, p_end - p_data);
               while (m_len--)
               {
                  *p_adpt++ = *p_data++;
               }
            }
            else
            {
               p_adpt++;
            }
         }
      }
      else
      {
         while (p_data < p_end)
         {
            *p_adpt = *p_data << 8;
            p_data++;
            *p_adpt |= *p_data;
            p_data++;
            if (*p_adpt == 0x001B)
            {
               p_adpt++;
               m_len = getMarkupLength(p_data, p_end - p_data);
               /* copy mark up */
               while (m_len--)
               {
                  *p_adpt++ = *p_data++;
               }
            }
            else
            {
               p_adpt++;
            }
         }
      }
   }

   if (((MHEG5Root *)text)->clazz == MHEG5ENTRYFIELD)
   {
      if ((((MHEG5Entryfield *)text)->maxlength > 0) &&
          (adpt_len > ((MHEG5Entryfield *)text)->maxlength))
      {
         adpt_len = ((MHEG5Entryfield *)text)->maxlength;
      }
   }

   if (((MHEG5Root *)text)->clazz != MHEG5ENTRYFIELD)
   {
      /* Make a copy of the raw content for Text and HyperText classes. Note that
       * this is not done for EntryField classes, which can alter the TextData
       * internal attribute through interaction.
       */
      /* Destruct the old copy */
      MHEG5stringDestruct(&text->textDataRaw);

      /* Allocate memory for new raw text data */
      text->textDataRaw.data = STR_DataAlloc( len );
      if (text->textDataRaw.data == NULL)
      {
         ERROR_PRINT(("ERROR : MHEG5textContentAdapt out of memory\n"));
         return;
      }

      /* Copy the raw text data */
      memcpy(text->textDataRaw.data, data, len);
      text->textDataRaw.len = len;
#ifdef DRAW_IN_ADVANCE
      if (((MHEG5Root *)text)->clazz == MHEG5HYPERTEXT)
      {
         MHEG5drawHypertext((MHEG5Hypertext *)text );
      }
      else
      {
         MHEG5drawText((MHEG5Text *)text );
      }
   }
   else
   {
      MHEG5drawEntry((MHEG5Entryfield *)text, CURSOR_INSERT);
#endif /*DRAW_IN_ADVANCE*/
   }
}

void MHEG5textContentUnadapt(MHEG5Text *text, MHEG5Byte **utf8Data, MHEG5Int *utf8Len)
{
   int pos;
   int unadaptedLen;
   unsigned char *unadaptedData;
   unsigned short *data;
   int dataLen;

   *utf8Data = 0;
   *utf8Len = 0;

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

   if ((data == 0) || (dataLen == 0))
   {
      /* No data to unadapt */
      return;
   }

   /* Allocate some memory for storing the unadapted content. Since we don't
    * know the size, allocate the largest possible required (3 times the number
    * of characters in the text content) as a temporary buffer.
    */
   unadaptedData = MHEG5getMem( text->visible.ingredient.dataLen * 3 );

   if (unadaptedData == NULL)
   {
      /* Unable to allocate memory for unadapted data */
      ERROR_PRINT(("ERROR: MHEG5textContentUnadapt out of memory\n"));
      return;
   }

   pos = 0;
   unadaptedLen = 0;
   while (pos < dataLen)
   {
      if (data[pos] == 0x1b)
      {
         /* Skip all markup - copy it unchanged */
         unsigned int markupLength;

         if ((data[pos + 1] >= 0x40) && (data[pos + 1] <= 0x5e))
         {
            markupLength = data[pos + 2] + 3;
         }
         else if ((data[pos + 1] >= 0x60) && (data[pos + 1] <= 0x7e))
         {
            markupLength = 2;
         }
         else
         {
            markupLength = 1;
         }

         while (markupLength > 0)
         {
            assert(data[pos] <= 0xff);
            unadaptedData[unadaptedLen] = (unsigned char)data[pos];
            pos++;
            unadaptedLen++;
            markupLength--;
         }
      }
      else
      {
         /* Convert from Unicode to UTF8 encoding */
         if (data[pos] <= 0x7f)
         {
            /*      0x00000000 - 0x0000007F:
             *          0xxxxxxx
             */
            unadaptedData[unadaptedLen++] = (unsigned char)data[pos];
         }
         else if (data[pos] <= 0x7ff)
         {
            /*      0x00000080 - 0x000007FF:
             *          110xxxxx 10xxxxxx
             */
            unadaptedData[unadaptedLen++] = (unsigned char)((data[pos] & 0x07c0) >> 6) | 0xc0;
            unadaptedData[unadaptedLen++] = (unsigned char)(data[pos] & 0x003f) | 0x80;
         }
         else
         {
            /*      0x00000800 - 0x0000FFFF:
             *          1110xxxx 10xxxxxx 10xxxxxx
             */
            unadaptedData[unadaptedLen++] = ((data[pos] & 0xf000) >> 12) | 0xe0;
            unadaptedData[unadaptedLen++] = ((data[pos] & 0x0fc0) >> 6) | 0x80;
            unadaptedData[unadaptedLen++] = (data[pos] & 0x003f) | 0x80;
         }

         pos++;
      }
   }

   /* We now know the size of the unadapted content, so allocate a buffer for
    * it and copy the unadapted data into it from the temporary buffer.
    */
   *utf8Data = STR_DataAlloc( unadaptedLen );
   if (*utf8Data != 0)
   {
      memcpy(*utf8Data, unadaptedData, unadaptedLen);
      *utf8Len = unadaptedLen;
   }

   /* Free off out temporary buffer */
   MHEG5freeMem(unadaptedData);
}

void MHEG5textContentUnadaptUTF16(MHEG5Text *text, MHEG5Byte **utf16Data, MHEG5Int *utf16Len)
{
   int pos;
   int unadaptedLen;
   unsigned char *unadaptedData;
   unsigned short *data;
   int dataLen;

   *utf16Data = 0;
   *utf16Len = 0;

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

   if ((data == 0) || (dataLen == 0))
   {
      /* No data to unadapt */
      return;
   }

   /* Allocate some memory for storing the unadapted content. Since we don't
    * know the size, allocate the largest possible required (3 times the number
    * of characters in the text content) as a temporary buffer.
    */
   unadaptedData = MHEG5getMem( text->visible.ingredient.dataLen * 3 );

   if (unadaptedData == NULL)
   {
      /* Unable to allocate memory for unadapted data */
      ERROR_PRINT(("ERROR: MHEG5textContentUnadapt out of memory\n"));
      return;
   }

   pos = 0;

   if (text->byteOrderMark == BOM_LITTLE_ENDIAN)
   {
      unadaptedData[0] = 0xFF;
      unadaptedData[1] = 0xFE;
      unadaptedLen = 2;
   }
   else if (text->byteOrderMark == BOM_BIG_ENDIAN)
   {
      unadaptedData[0] = 0xFE;
      unadaptedData[1] = 0xFF;
      unadaptedLen = 2;
   }
   else
   {
      unadaptedLen = 0;
   }

   while (pos < dataLen)
   {
      if (data[pos] == 0x1b)
      {
         /* Skip all markup - copy it unchanged */
         unsigned int markupLength;

         if ((data[pos + 1] >= 0x40) && (data[pos + 1] <= 0x5e))
         {
            markupLength = data[pos + 2] + 3;
         }
         else if ((data[pos + 1] >= 0x60) && (data[pos + 1] <= 0x7e))
         {
            markupLength = 2;
         }
         else
         {
            markupLength = 1;
         }

         while (markupLength > 0)
         {
            assert(data[pos] <= 0xff);
            unadaptedData[unadaptedLen] = (unsigned char)data[pos];
            pos++;
            unadaptedLen++;
            markupLength--;
         }
      }
      else
      {
         /* Convert from Unicode to UTF16 encoding */
         if (text->byteOrderMark == BOM_LITTLE_ENDIAN)
         {
            unadaptedData[unadaptedLen++] = data[pos] & 0xff;
            unadaptedData[unadaptedLen++] = (data[pos] >> 8) & 0xff;
         }
         else
         {
            unadaptedData[unadaptedLen++] = (data[pos] >> 8) & 0xff;
            unadaptedData[unadaptedLen++] = data[pos] & 0xff;
         }
         pos++;
      }
   }
   /* We now know the size of the unadapted content, so allocate a buffer for
    * it and copy the unadapted data into it from the temporary buffer.
    */
   *utf16Data = STR_DataAlloc( unadaptedLen );
   if (*utf16Data != 0)
   {
      memcpy(*utf16Data, unadaptedData, unadaptedLen);
      *utf16Len = unadaptedLen;
   }

   /* Free off out temporary buffer */
   MHEG5freeMem(unadaptedData);
}

void MHEG5textClearTextData(MHEG5Text *text)
{
   MHEG5stringDestruct(&text->textDataRaw);
}