mh5drawtext.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2008 Ocean Blue Software Ltd
 *
 * 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 <string.h>

#include "mg_drawtext.h"
#include "mh5drawtext.h"
#include "mh5application.h"
#include "mh5object.h"
#include "mh5font.h"
#include "mh5queue.h"
#include "mh5display.h"
#include "mh5debug.h"
#include "mg_api.h"
#include "mh5support.h"

#include "tmcolor.h" /* for RGBT() */

/* Default font attribute values */
#define FONT_ATTRIBUTES_DEFAULT_SIZE            (24)
#define FONT_ATTRIBUTES_DEFAULT_LINESPACE       (28)
#define FONT_ATTRIBUTES_DEFAULT_LETTERSPACE     (0)

/* 8 pixels - why would anyone have a text box with width or height of 8 pixels or less */
#define MINIMUM_BOX_DIMENSION   8

/* Default hypertext link colours */
#define DEFAULT_LINK_COLOUR             (RGBT(0x00, 0x00, 0xff, 0x00))
#define DEFAULT_ACTIVE_LINK_COLOUR      (RGBT(0xff, 0x00, 0x00, 0x00))
#define DEFAULT_VISITED_LINK_COLOUR     (RGBT(0x3f, 0x1f, 0x7f, 0x00))

/* Characters used for Entryfield */
#define OBSCURED_INPUT_CHAR   ('*')

#ifdef HK_PROFILE
static MHEG5String hk_font_name = {(U32BIT)14, (U8BIT *)"rec://font/hk1"};
#endif

static int parseInt(MHEG5String *string, int *offset)
{
   int sgn;
   int value;
   int localOffset;

   /* Keep a local copy of offset */
   localOffset = *offset;

   /* Check for a leading minus sign. sgn is set to 1 if the number is positive
    * or -1 if it is negative.
    */
   sgn = 1;
   if (string->data[localOffset] == '-')
   {
      /* Number is negative */
      sgn = -1;

      /* Skip the minus sign */
      localOffset++;
   }
   else if (string->data[localOffset] == '+')
   {
      /* Skip the plus sign */
      localOffset++;
   }

   /* Extract an integer value */
   value = 0;
   while ((localOffset < string->len) && (string->data[localOffset] <= '9') &&
          (string->data[localOffset] >= '0'))
   {
      /* Multiply previous value by 10 and add the next digit */
      value = value * 10 + (int) (string->data[localOffset]) - (int) '0';

      /* Increment the offset */
      localOffset++;
   }

   /* Copy the offset back to the return value */
   *offset = localOffset;

   return value * sgn;
}

static BOOLEAN getBoxAndAttribs( MHEG5Text *txt, VRect *pBox, pDrawTextAttrib pAttrib, pTextString pStr)
{
   MHEG5String fa = txt->fontAttributes;
   MHEG5Application *application = MHEG5getCurrentApplication();
   S16BIT font_index;
   U8BIT font_size, font_style;

   /* Set the default values */
   int retSize = FONT_ATTRIBUTES_DEFAULT_SIZE;
   int retLinespace = FONT_ATTRIBUTES_DEFAULT_LINESPACE;
   int retLetterspace = FONT_ATTRIBUTES_DEFAULT_LETTERSPACE;

   if (txt->visible.graphic_data)
   {
      MG_FreeData( txt->visible.graphic_data );
      txt->visible.graphic_data = NULL;
   }
   if ((txt->visible.boxSize[0] < MINIMUM_BOX_DIMENSION) ||
       (txt->visible.boxSize[1] < MINIMUM_BOX_DIMENSION)
       )
   {
      TRACE(TTEXT, ("TxtBox is too small (%ld,%ld)", txt->visible.boxSize[0], txt->visible.boxSize[1]));
      return FALSE;
   }
   pBox->width = (U16BIT)txt->visible.boxSize[0];
   pBox->height = (U16BIT)txt->visible.boxSize[1];
   pBox->left = (S16BIT)txt->visible.position[0];
   pBox->top = (S16BIT)txt->visible.position[1];
   pStr->len = (U16BIT)txt->visible.ingredient.dataLen;
   pStr->data = (U16BIT *)txt->visible.ingredient.data;  /* conversion to unicode was done in MHEG5textContentAdapt */

   // hardware may not be able to cope with large surface sizes,
   // so restrict to visible screen
   txt->visible.restricted = FALSE;
   if (pBox->width > 720)
   {
      pBox->width = txt->visible.rect.right - pBox->left;
      txt->visible.restricted = TRUE;
   }
   if (pBox->height > 576)
   {
      pBox->height = txt->visible.rect.bottom - pBox->top;
      txt->visible.restricted = TRUE;
   }

   pAttrib->justify = (U8BIT)(txt->verticalJustification << 4) | (U8BIT)(txt->horizontalJustification);
   if ((pAttrib->justify & JFY_HZ_MASK) == JUSTIFY_H_JUSTIFIED)
   {
      pAttrib->justify &= ~JUSTIFY_H_JUSTIFIED; /*treat "JUSTIFIED" just as "START" */
   }
   if (txt->textWrapping)
   {
      pAttrib->justify |= WRAP_WORDS;
   }

   if (txt->textColour.type == MHEG5NONE)
   {
      /* Use application default text colour */
      pAttrib->fore_colour = MHEG5displayColour( &application->textColour);
   }
   else
   {
      /* Retreive the text colour from the text object */
      pAttrib->fore_colour = MHEG5displayColour( &txt->textColour );
   }

   if (txt->backgroundColour.type == MHEG5NONE)
   {
      /* Use application default background colour */
      pAttrib->back_colour = MHEG5displayColour( &application->backgroundColour );
   }
   else
   {
      /* Retreive the background colour from the text object */
      pAttrib->back_colour = MHEG5displayColour( &txt->backgroundColour );
   }

   /* use normal UK profile font as default */
   font_index = 0;
   font_style = FONT_STYLE_PLAIN;

   if (txt->font.referenced)
   {
      MHEG5Root *f_obj = MHEG5findObject( txt->font.ref.referenced.grp,
            txt->font.ref.referenced.id );
      /* use font object */
      if (f_obj != NULL && f_obj->clazz == MHEG5FONT)
      {
         if (((MHEG5Font *)f_obj)->mg_fnt_index == INVALID_MG_FNT_INDEX)
         {
            /* need to display empty box, coz the font is still being loaded */
            return FALSE;
         }
         font_index = ((MHEG5Font *)f_obj)->mg_fnt_index;
      }
   }
   else if (!txt->font.ref.included.len)   /* len > 0, then ref is in-built font */
   {
      /* check whether application default is pointing at font object */
      if (application->fontBody.referenced)
      {
         MHEG5Root *f_obj = MHEG5findObject( application->fontBody.ref.referenced.grp,
               application->fontBody.ref.referenced.id );
         /* use font object */
         if (f_obj != NULL && f_obj->clazz == MHEG5FONT)
         {
            if (((MHEG5Font *)f_obj)->mg_fnt_index == INVALID_MG_FNT_INDEX)
            {
               /* need to display empty box, coz the font is still being loaded */
               return FALSE;
            }
            font_index = ((MHEG5Font *)f_obj)->mg_fnt_index;
         }
      }
   }

   if (!txt->font.referenced && txt->font.ref.included.len > 0)
   {
      pAttrib->font_name.zptr = txt->font.ref.included.data;
      pAttrib->font_name.zlen = txt->font.ref.included.len;
   }
   else if (!application->fontBody.referenced && application->fontBody.ref.included.len)
   {
      pAttrib->font_name.zptr = application->fontBody.ref.included.data;
      pAttrib->font_name.zlen = application->fontBody.ref.included.len;
   }
   else
   {
      pAttrib->font_name.zlen = 0;
      pAttrib->font_name.zptr = NULL;
   }

   if (!txt->characterSetEncoded)
   {
      pAttrib->character_set = application->characterSet;
   }
   else
   {
      pAttrib->character_set = txt->characterSet;
   }

   /* Parse the font attributes */
   if (fa.len == 0)
   {
      /* This object does not have font attributes encoded - use the application defaults */
      fa = application->fontAttributes;
   }
   if (fa.len != 0)
   {
      /* check for short Form */
      if (fa.len == 5)
      {
         TRACE(TTEXT, ("Short FA=(0x%x,0x%x,0x%x,0x%x,0x%x)",
                       fa.data[0], fa.data[1], fa.data[2], fa.data[3], fa.data[4], fa.data[5]))
         /* Parse the short form */
         if (fa.data[0] & 0x10)
         {
            /* if not support HDGRAPHICS then ignore the style, fa.data[0], since we can only support plain
               (see UK1.05 section 5.3.1.1) */
            if (MH5_SupportHDGraphics())
            {
               font_style = FONT_STYLE_SQUARE;
            }
         }

         /* Extract the size, linespace and letterspace.
          * Note: letterspace is a signed value, others are not
          */
         retSize = fa.data[1];
         retLinespace = fa.data[2];
         retLetterspace = fa.data[3] * 256 + fa.data[4];
         if (retLetterspace > 0x7FFF)
         {
            /* Do sign conversion to negative letterspace */
            retLetterspace -= 0x10000;
         }
      }
      else
      {
         /* DAVIC-like long form */
         int i = 0;
         TRACE(TTEXT, ("Long FA=(%s)", fa.data))
         if (MH5_SupportHDGraphics())
         {
            if (MHEG5strncmp((char *)fa.data, (char *)"square", 5) == 0)
            {
               font_style = FONT_STYLE_SQUARE;
            }
         }

         while ((i < fa.len) && (fa.data[i] != '.'))
         {
            i++;
         }
         if (i >= fa.len)
         {
            TRACE(TERROR, ("Unexpected end of font attributes %.*s", (int)fa.len, fa.data))
         }
         else
         {
            /* Skip the separating dot */
            i++;

            retSize = parseInt(&fa, &i);
            if ((i >= fa.len) || (fa.data[i] != '.'))
            {
               TRACE(TERROR, ("Unexpected end of font attributes or missing dot %.*s", (int)fa.len, fa.data))
               retSize = FONT_ATTRIBUTES_DEFAULT_SIZE;
            }
            else
            {
               /* Skip the separating dot */
               i++;

               retLinespace = parseInt(&fa, &i);
               if ((i >= fa.len) || (fa.data[i] != '.'))
               {
                  TRACE(TERROR, ("Unexpected end of font attributes or missing dot %.*s", (int)fa.len, fa.data))
                  retSize = FONT_ATTRIBUTES_DEFAULT_SIZE;
                  retLinespace = FONT_ATTRIBUTES_DEFAULT_LINESPACE;
               }
               else
               {
                  /* Skip the separating dot */
                  i++;

                  retLetterspace = parseInt(&fa, &i);
                  if (i != fa.len)
                  {
                     TRACE(TERROR, ("Expected end of font attributes %.*s", (int)fa.len, fa.data))
                     retSize = FONT_ATTRIBUTES_DEFAULT_SIZE;
                     retLinespace = FONT_ATTRIBUTES_DEFAULT_LINESPACE;
                     retLetterspace = FONT_ATTRIBUTES_DEFAULT_LETTERSPACE;
                  }
               }
            }
         }
      }
   }

   if (font_index != 0)
   {
      font_size = retSize; /* no restriction on size! */
   }
   else
   {
      /* When not doing CI+'s downloaded font ...
       * If the font size does not match one of those of the in-built font the
       * receiver shall substitute the next smaller size provided by the in-built
       * font. If the required font is smaller than the smallest available, then
       * the smallest available in-built size shall be used.
       */
      if (retSize < 26)
      {
         if ((retSize < 24) && (MH5_SupportHDGraphics()))
         {
            if (retSize < 22)
            {
               font_size = 20;
            }
            else
            {
               font_size = 22;
            }
         }
         else
         {
            font_size = 24;
         }
      }
      else if (retSize < 31)
      {
         font_size = 26;
      }
      else if (retSize < 36)
      {
         font_size = 31;
      }
      else
      {
         font_size = 36;
      }
   }
#ifdef HK_PROFILE
   if (MHEG5stringEqual((MHEG5String *)&pAttrib->font_name, &hk_font_name))
   {
      pAttrib->font.fp.index = HK_FNT_MAGIC;
      pAttrib->font.fp.size = font_size;
      pAttrib->font.fp.style = font_style;
   }
   else
#endif
   {
      pAttrib->font.hdl = MG_AllocateFont( font_index, font_size, font_style );
   }

   /* Check letterspace is in range [-32767, 32767] */
   if (retLetterspace >= 32767)
   {
      pAttrib->letter_space = 32767;
   }
   else if (retLetterspace <= -32767)
   {
      pAttrib->letter_space = -32767;
   }
   else
   {
      pAttrib->letter_space = (S16BIT)retLetterspace;
   }

   /* Check linespace is in range [0, 255] */
   if (retLinespace >= 255)
   {
      pAttrib->line_space = 255;
   }
   else if (retLinespace <= 0)
   {
      pAttrib->line_space = 0;
   }
   else
   {
      pAttrib->line_space = (U8BIT)retLinespace;
   }
   return TRUE;
}

void MHEG5drawText(MHEG5Text *txt)
{
   VRect box;
   DrawTextAttrib attrib;
   TextString str;

   if (getBoxAndAttribs( txt, &box, &attrib, &str ))
   {
      if ((str.len > 0) && (str.data))
      {
         attrib.p_ha = NULL;
         attrib.entry_point = -1;
         txt->visible.graphic_data = MG_DrawText( str, &attrib, box );
      }
   }
}

void MHEG5drawEntry(MHEG5Entryfield *entry, entryfieldCursor_t cursor)
{
   VRect box;
   DrawTextAttrib attrib;
   TextString str;

   if (getBoxAndAttribs((MHEG5Text *)entry, &box, &attrib, &str ))
   {
      if (entry->interactible.interactionStatus)
      {
         attrib.entry_point = (S16BIT)entry->entryPoint;
      }
      else
      {
         attrib.entry_point = -1;
      }

   #ifdef INCLUDE_IC
      if (cursor == CURSOR_REPLACE)
         attrib.caret = ENTRY_OVERWRITE_CHAR;
      else
   #endif
      attrib.caret = ENTRY_INSERT_CHAR;

      if ((str.len > 0) || (attrib.entry_point != -1))
      {
         /* For entryfields - No wrapping is allowed by UK profile 1.06 (sec 5.7.2)*/
      #ifdef INCLUDE_IC
         if (MH5_SupportInteractionChannel() && entry->text.textWrapping == MHEG5TRUE)
         {
            attrib.justify |= WRAP_WORDS;
         }
         else
      #endif
         {
            attrib.justify &= ~(WRAP_WORDS | WRAP_VERTICAL);
         }
         /* Entryfields have a 4 pixel border for "manufacturer defined decoration".
          * We use this to indicate highlight and interaction status.
          */
         box.top += 4;
         box.height -= 8;
         box.width -= 8;
         box.left += 4;

         attrib.p_ha = NULL;

         if (entry->obscuredInput)
         {
            int i;
            U16BIT o_str[256];
            assert( str.len <= 255 );
            if (str.len > 255)
               str.len = 255;
            for (i = 0; i != str.len; i++)
            {
               if (cursor == CURSOR_INSERT || i != attrib.entry_point - 1)
               {
                  o_str[i] = OBSCURED_INPUT_CHAR;
               }
               else
               {
                  o_str[i] = str.data[i];
               }
            }
            str.data = o_str;
            entry->text.visible.graphic_data = MG_DrawText( str, &attrib, box );
         }
         else
         {
            entry->text.visible.graphic_data = MG_DrawText( str, &attrib, box );
         }
      }
   }
}

void MHEG5drawHypertext(MHEG5Hypertext *hypertxt)
{
   VRect box;
   DrawTextAttrib attrib;
   HyperAttribs hyp_atb;
   TextString str;

   if (getBoxAndAttribs((MHEG5Text *)hypertxt, &box, &attrib, &str ))
   {
      if ((str.len > 0) && (str.data))
      {
         attrib.entry_point = -1;
         attrib.p_ha = &hyp_atb;
         hyp_atb.link_colour = DEFAULT_LINK_COLOUR;
         hyp_atb.active_colour = DEFAULT_ACTIVE_LINK_COLOUR;
         hyp_atb.visit_colour = DEFAULT_VISITED_LINK_COLOUR;
         hyp_atb.markup_state = 0;    /*initialise*/
         hyp_atb.anchor_wrap = FALSE;
         if (hypertxt->interactible.interactionStatus)
         {
            /* hyp_atb.interacting = TRUE; */
            if (hypertxt->focusPosition == 0)
            {
               /* position is not yet initialised,
                * so for the drawing the text, if there is a position, it's 1
                */
               hyp_atb.focus_position = 1;
            }
            else
            {
               hyp_atb.focus_position = (S16BIT)hypertxt->focusPosition;
            }
         }
         else
         {
            /* hyp_atb.interacting = FALSE; */
            hyp_atb.focus_position = 0;
         }
         hyp_atb.number_of_links = 0;

         hypertxt->text.visible.graphic_data = MG_DrawText( str, &attrib, box );

         /* Remember the anchor wrap state - from 'body' attributes */
         if (hyp_atb.anchor_wrap)
         {
            hypertxt->anchorWrappingFlag = MHEG5TRUE;
         }

         /* Remember the number of links in this hypertext object */
         if (hypertxt->numberOfLinks == -1)
         {
            hypertxt->numberOfLinks = hyp_atb.number_of_links;
         }
         if (hypertxt->focusPosition == 0 && hypertxt->numberOfLinks > 0)
         {
            hypertxt->focusPosition = 1;
         }

         /* Number of links changed - fire FocusMoved event */
         if (hypertxt->focusPosition != hypertxt->lastFocusPosition)
         {
            MHEG5sendEvent((MHEG5Root *)hypertxt, MHEG5FOCUSMOVED, hypertxt->focusPosition );
            hypertxt->lastFocusPosition = hypertxt->focusPosition;
         }
      }
   }
}

void MH5_DisplayText( MHEG5Text *txt, S_REGION *overlap )
{
   OSDColor bg_col;
   if (txt->backgroundColour.type == MHEG5NONE)
   {
      /* Use application default background colour */
      bg_col = MHEG5displayColour( &MHEG5getCurrentApplication()->backgroundColour );
   }
   else
   {
      /* Retreive the background colour from the text object */
      bg_col = MHEG5displayColour( &txt->backgroundColour );
   }
   MG_OSDdisplayRectangle( overlap, txt->visible.position[0], txt->visible.position[1],
      txt->visible.boxSize[0], txt->visible.boxSize[1],
      0, /*MHEG_LINE_STYLE_SOLID,*/ 0,                      /* <- no line, so all zero */
      bg_col );

   if (txt->visible.graphic_data)
   {
      MG_OSDdisplayImage( txt->visible.graphic_data, overlap,
         txt->visible.position[0], txt->visible.position[1] );
   }
}

void MH5_DisplayEntry( MHEG5Entryfield *entry, S_REGION *overlap )
{
   OSDColor borderColour;
   OSDColor backgroundColour;
   S16BIT left = (S16BIT)entry->text.visible.position[0];
   S16BIT top = (S16BIT)entry->text.visible.position[1];
   U16BIT width = (U16BIT)entry->text.visible.boxSize[0];
   U16BIT height = (U16BIT)entry->text.visible.boxSize[1];

   /* Entryfields have a 4 pixel border for "manufacturer defined decoration".
    * We use this to indicate highlight and interaction status.
    */

   if (entry->interactible.highlightStatus && entry->interactible.engineResp)
   {
      if (entry->interactible.highlightRefColour.type == MHEG5NONE)
      {
         borderColour = MHEG5displayColour( &MHEG5getCurrentApplication()->highlightRefColour );
      }
      else
      {
         borderColour = MHEG5displayColour( &entry->interactible.highlightRefColour );
      }
   }
   else
   {
      if (entry->text.backgroundColour.type == MHEG5NONE)
      {
         /* Use application default background colour */
         borderColour = MHEG5displayColour( &MHEG5getCurrentApplication()->backgroundColour );
      }
      else
      {
         /* Retreive the background colour from the text object */
         borderColour = MHEG5displayColour( &entry->text.backgroundColour );
      }
   }

   if (entry->text.backgroundColour.type == MHEG5NONE)
   {
      /* Use application default background colour */
      backgroundColour = MHEG5displayColour( &MHEG5getCurrentApplication()->backgroundColour );
   }
   else
   {
      /* Retreive the background colour from the text object */
      backgroundColour = MHEG5displayColour( &entry->text.backgroundColour );
   }
   MG_OSDdisplayRectangle( overlap, left, top, width, height, 4, /*MHEG_LINE_STYLE_SOLID,*/ borderColour, backgroundColour );
   if (entry->text.visible.graphic_data)
   {
      MG_OSDdisplayImage( entry->text.visible.graphic_data, overlap, left, top );
   }
}