mh5dynamiclineart.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 "mh5debug.h"
#include "mh5dynamiclineart.h"
#include "mh5object.h"          /*for actions */
#include "mh5variable.h"        /*for actions */
#include "mh5display.h"         /*for actions */
#include "mh5memory.h"
#include "mh5action.h"
#include "tmcolor.h"
#include "mg_dla.h"

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


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

typedef struct sMHEG5DrawAction
{
   pMHEG5DrawAction next;
   E_ElementryAction action;
   MHEG5GList *params;
   int lWidth;
   OSDColor lineCol;
   OSDColor fillCol;
} MHEG5DrawAction;

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

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

static MHEG5ErrorCode DrawArc(void *graphic, MHEG5GList *params, int lwidth, OSDColor lcol)
{
   MHEG5ErrorCode error_val;
   MHEG5Int values[6];
   int count = 0;
   while ((count != 6) && params)
   {
      params = MHEG5resolveGenericInteger( params, &(values[count]));
      count++;
   }
   if (count != 6)
   {
      error_val = MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   /* Check elipseWidth and elipseHeight are within range specified by COR.1 18.2 */
   else if ((values[2] < 0) || (values[3] < 0))
   {
      error_val = MHEG5ERR_WRONGPARAM;
   }
   else
   {
      TRACE(TGRAPHICS,("gd=%p lcol=%x",graphic,lcol))
      OSDdrawArc( graphic,
         values[0], values[1],          /* x, y, */
         values[2], values[3],          /* elipseWidth, elipseHeight */
         values[4], values[5],          /* startAngle, arcAngle */
         lwidth, lcol );
      error_val = MHEG5ERR_NOERROR;
   }
   return error_val;
}

static MHEG5ErrorCode DrawSector(void *graphic, MHEG5GList *params, int lwidth, OSDColor lcol, OSDColor fcol)
{
   MHEG5ErrorCode error_val;
   MHEG5Int values[6];
   int count = 0;
   while ((count != 6) && params)
   {
      params = MHEG5resolveGenericInteger( params, &(values[count]));
      count++;
   }
   if (count != 6)
   {
      error_val = MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   /* Check elipseWidth and elipseHeight are within range specified by COR.1 18.2 */
   else if ((values[2] < 0) || (values[3] < 0))
   {
      error_val = MHEG5ERR_WRONGPARAM;
   }
   else
   {
      TRACE(TGRAPHICS,("gd=%p lcol=%x fcol=%x",graphic,lcol,fcol))
      OSDdrawSector( graphic,
         values[0], values[1],             /* x, y, */
         values[2], values[3],             /* elipseWidth, elipseHeight */
         values[4], values[5],             /* startAngle, arcAngle */
         lwidth, lcol, fcol);
      error_val = MHEG5ERR_NOERROR;
   }
   return error_val;
}

static MHEG5ErrorCode DrawLine(void *graphic, MHEG5GList *params, int lwidth, OSDColor lcol)
{
   MHEG5ErrorCode error_val;
   MHEG5Int values[6];
   int count = 0;
   while ((count != 4) && params)
   {
      params = MHEG5resolveGenericInteger( params, &(values[count]));
      count++;
   }
   if (count != 4)
   {
      error_val = MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   else
   {
      TRACE(TGRAPHICS,("gd=%p lcol=%x",graphic,lcol))
      OSDdrawDrawLine( graphic,
         values[0], values[1],                /* x1, y1, */
         values[2], values[3],                /* x2, y2, */
         lwidth, lcol );
      error_val = MHEG5ERR_NOERROR;
   }
   return error_val;
}

static MHEG5ErrorCode DrawOval(void *graphic, MHEG5GList *params, int lwidth, OSDColor lcol, OSDColor fcol)
{
   MHEG5ErrorCode error_val;
   MHEG5Int values[6];
   int count = 0;
   while ((count != 4) && params)
   {
      params = MHEG5resolveGenericInteger( params, &(values[count]));
      count++;
   }
   if (count != 4)
   {
      error_val = MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   /* Check elipseWidth and elipseHeight are within range specified by COR.1 18.2 */
   else if ((values[2] < 0) || (values[3] < 0))
   {
      error_val = MHEG5ERR_WRONGPARAM;
   }
   else
   {
      TRACE(TGRAPHICS,("gd=%p lcol=%x fcol=%x",graphic,lcol,fcol))
      OSDdrawEllipse(graphic,
         values[0], values[1],             /* x, y, */
         values[2], values[3],             /* elipseWidth, elipseHeight */
         lwidth, lcol, fcol);
      error_val = MHEG5ERR_NOERROR;
   }
   return error_val;
}

static MHEG5ErrorCode DrawPolygon(void *graphic, MHEG5GList *params, int lwidth, OSDColor lcol, OSDColor fcol)
{
   MHEG5Int x = 0, y = 0;
   OSDdrawPolygonStart( graphic );
   params = params->next;
   while (params)
   {
      params = params->next;
      if (!params)
      {
         break;;
      }
      params = MHEG5resolveGenericInteger(params, &x);
      if (!params)
      {
         return MHEG5ERR_WRONGNUMBEROFPARAMS;
      }
      params = MHEG5resolveGenericInteger(params, &y);
      params = params->next;
      OSDdrawPolygonAdd( graphic, x, y );
   }
   TRACE(TGRAPHICS,("gd=%p lcol=%x fcol=%x",graphic,lcol,fcol))
   OSDdrawPolygon( graphic, lwidth, lcol, fcol, MHEG5TRUE );
   return MHEG5ERR_NOERROR;
}

static MHEG5ErrorCode DrawPolyline(void *graphic, MHEG5GList *params, int lwidth, OSDColor lcol, OSDColor fcol)
{
   MHEG5Int x = 0, y = 0;
   OSDdrawPolygonStart( graphic );
   params = params->next;
   while (params)
   {
      params = params->next;
      if (!params)
      {
         break;
      }
      params = MHEG5resolveGenericInteger(params, &x);
      if (!params)
      {
         return MHEG5ERR_WRONGNUMBEROFPARAMS;
      }
      params = MHEG5resolveGenericInteger(params, &y);
      params = params->next;
      OSDdrawPolygonAdd( graphic, x, y );
   }
   TRACE(TGRAPHICS,("gd=%p lcol=%x",graphic,lcol))
   OSDdrawPolygon( graphic, lwidth, lcol, fcol, MHEG5FALSE );
   return MHEG5ERR_NOERROR;
}

static MHEG5ErrorCode DrawRectangle(void *graphic, MHEG5GList *params, int lwidth, OSDColor lcol, OSDColor fcol)
{
   MHEG5ErrorCode error_val;
   MHEG5Int values[6];
   int count = 0;
   while ((count != 4) && params)
   {
      params = MHEG5resolveGenericInteger(params, &(values[count]));
      count++;
   }
   if (count != 4)
   {
      error_val = MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   else
   {
      TRACE(TGRAPHICS,("gd=%p lcol=%x fcol=%x",graphic,lcol,fcol))
      OSDdrawRectangle( graphic,
         values[0], values[1],                /* x1, y1, */
         values[2], values[3],                /* x2, y2, */
         lwidth, lcol, fcol );
      error_val = MHEG5ERR_NOERROR;
   }
   return error_val;
}

static MHEG5ErrorCode DrawAction(void *gdata, pMHEG5DrawAction pda)
{
   switch (pda->action)
   {
      case MHEG5DRAWARC:
         return DrawArc(gdata,pda->params,pda->lWidth,pda->lineCol);
      case MHEG5DRAWLINE:
         return DrawLine(gdata,pda->params,pda->lWidth,pda->lineCol);
      case MHEG5DRAWOVAL:
         return DrawOval(gdata,pda->params,pda->lWidth,pda->lineCol,pda->fillCol);
      case MHEG5DRAWPOLYGON:
         return DrawPolygon(gdata,pda->params,pda->lWidth,pda->lineCol,pda->fillCol);
      case MHEG5DRAWPOLYLINE:
         return DrawPolyline(gdata,pda->params,pda->lWidth,pda->lineCol,pda->fillCol);
      case MHEG5DRAWRECTANGLE:
         return DrawRectangle(gdata,pda->params,pda->lWidth,pda->lineCol,pda->fillCol);
      case MHEG5DRAWSECTOR:
         return DrawSector(gdata,pda->params,pda->lWidth,pda->lineCol,pda->fillCol);
      default:;
   }
   TRACE(TERROR,("act=%d",pda->action))
   return MHEG5ERR_WRONGPARAM;
}

static MHEG5ErrorCode AddActionDraw(MHEG5DynamicLineart *dl, E_ElementryAction action, MHEG5GList *params)
{
   MHEG5ErrorCode err;
   pMHEG5DrawAction pda;
   pda = MHEG5getMem(sizeof(MHEG5DrawAction));
   if (pda == NULL)
   {
      err = MHEG5ERR_TARGETNOTAVAILABLE;
   }
   else
   {
      pda->next = NULL;
      pda->action = action;
      pda->params = params;
      pda->lWidth = dl->lineart.lineWidth;
      pda->lineCol = MHEG5displayColour( &dl->lineart.refLineColour );
      pda->fillCol = MHEG5displayColour( &dl->lineart.refFillColour );
      TRACE(TGRAPHICS, ("dl=%p posn=%ld,%ld", dl, dl->lineart.visible.position[0], dl->lineart.visible.position[1]))
      err = DrawAction(dl->lineart.visible.graphic_data,pda);
      if (err == MHEG5ERR_NOERROR)
      {
         pMHEG5DrawAction *ppda;
         ppda = &(dl->drawing);
         while (*ppda != NULL)
         {
            ppda = &((*ppda)->next);
         }
         *ppda = pda;
         MHEG5displayRedraw((MHEG5Visible*)dl);
      }
      else
      {
         TRACE(TERROR,("err=%d",err))
         MHEG5freeMem(pda);
      }
   }
   return err;
}

static void ClearActionDraws(MHEG5DynamicLineart *dynamicLineart)
{
   pMHEG5DrawAction pda,nxt;
   DBGTRACE(TGRAPHICS,"XXXXXXXXXX dl=%p",dynamicLineart)
   pda = dynamicLineart->drawing;
   if (pda != NULL && pda->action == MHEG5NONEACTION)
   {
      nxt = pda->next;
      pda->next = NULL;
      pda = nxt;
   }
   else
   {
      dynamicLineart->drawing = NULL;
   }
   while (pda != NULL)
   {
      nxt = pda->next;
      MHEG5freeMem(pda);
      pda = nxt;
   }
}

static void DrawAgain(MHEG5DynamicLineart *dl)
{
   pMHEG5DrawAction pda;
   DBGTRACE(TGRAPHICS,"*********** dl=%p",dl)
   pda = dl->drawing;
   if (pda != NULL && pda->action == MHEG5NONEACTION)
   {
      dl->lineart.visible.graphic_data =
         OSDinitDynamicLineart( dl->lineart.visible.position[0], dl->lineart.visible.position[1],
            dl->lineart.visible.boxSize[0], dl->lineart.visible.boxSize[1],
            pda->lWidth, dl->lineart.borderedBoundingBox, pda->lineCol, pda->fillCol );
      while (pda != NULL)
      {
         (void)DrawAction(dl->lineart.visible.graphic_data,pda);
         pda = pda->next;
      }
      MHEG5displayRedraw((MHEG5Visible *)dl);
   }
}

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

/*
   Debug
 */
#ifdef MH5PRINTOUT

void MHEG5dynamicLineartPrint(MHEG5DynamicLineart *dynamicLineart, char *out)
{
   MHEG5lineartPrint(&dynamicLineart->lineart, out);
}

#endif


void MHEG5dynamicLineartInit(MHEG5DynamicLineart *dynamicLineart)
{
   assert(dynamicLineart);

   MHEG5lineartInit(&dynamicLineart->lineart);
}

void MHEG5dynamicLineartFree(MHEG5DynamicLineart *dynamicLineart)
{
   assert(dynamicLineart);

   MHEG5lineartFree(&dynamicLineart->lineart);
}

void MHEG5initDynamicLineart( MHEG5DynamicLineart *dynamicLineart )
{
   pMHEG5DrawAction pda;
   assert(dynamicLineart);
   assert(dynamicLineart->lineart.visible.graphic_data == NULL);
   pda = dynamicLineart->drawing;
   if (pda == NULL)
   {
      pda = MHEG5getMem(sizeof(MHEG5DrawAction));
      if (pda == NULL)
      {
         TRACE(TERROR,("Mem fail"))
      }
      else
      {
         pda->next = NULL;
         pda->action = MHEG5NONEACTION;
         pda->params = NULL;
         pda->lWidth = dynamicLineart->lineart.originalLineWidth;
         pda->lineCol = MHEG5displayColour(&dynamicLineart->lineart.refLineColour);
         pda->fillCol = MHEG5displayColour(&dynamicLineart->lineart.refFillColour);
         dynamicLineart->drawing = pda;
      }
   }
   if (pda != NULL)
   {
      dynamicLineart->lineart.visible.graphic_data =
         OSDinitDynamicLineart( dynamicLineart->lineart.visible.position[0],
            dynamicLineart->lineart.visible.position[1],
            dynamicLineart->lineart.visible.boxSize[0],
            dynamicLineart->lineart.visible.boxSize[1],
            /* BUG FIX - use original line width, line colour and fill colour. */
            dynamicLineart->lineart.originalLineWidth,
            dynamicLineart->lineart.borderedBoundingBox,
            pda->lineCol, pda->fillCol );
   }
}

void MHEG5freeDynamicLineart( MHEG5DynamicLineart *dynamicLineart )
{
   if (dynamicLineart->lineart.visible.graphic_data)
   {
      /* Free canvas */
      OSDfreeDynamicLineart( dynamicLineart->lineart.visible.graphic_data );
      dynamicLineart->lineart.visible.graphic_data = NULL;
   }
}

void MHEG5dynamicLineartPrepare(MHEG5DynamicLineart *dynamicLineart)
{
   MHEG5lineartPrepare(&dynamicLineart->lineart);
   MHEG5initDynamicLineart( dynamicLineart );
}

void MHEG5dynamicLineartActivate(MHEG5DynamicLineart *dynamicLineart)
{
   if (!dynamicLineart->lineart.visible.ingredient.root.runningStatus)
   {
      if (!dynamicLineart->lineart.visible.ingredient.root.availabilityStatus)
      {
         MHEG5dynamicLineartPrepare( dynamicLineart );
      }
      else if (!dynamicLineart->lineart.visible.graphic_data)
      {
         /* Must have been stopped and now re-starting */
         DrawAgain( dynamicLineart );
      }
      MHEG5visibleActivate(&dynamicLineart->lineart.visible);
   }
}

void MHEG5dynamicLineartDeactivate(MHEG5DynamicLineart *dynamicLineart)
{
   if (dynamicLineart->lineart.visible.ingredient.root.runningStatus)
   {
      MHEG5freeDynamicLineart( dynamicLineart );
      MHEG5lineartDeactivate(&dynamicLineart->lineart);
   }
}

void MHEG5dynamicLineartDestruct(MHEG5DynamicLineart *dynamicLineart)
{
   MHEG5freeDynamicLineart( dynamicLineart );
   ClearActionDraws(dynamicLineart);
   if (dynamicLineart->drawing != NULL)
   {
      MHEG5freeMem(dynamicLineart->drawing);
      dynamicLineart->drawing = NULL;
   }
   MHEG5lineartDestruct(&dynamicLineart->lineart);
}

/*
    Actions
 */
MHEG5ErrorCode MHEG5getLineWidth(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5ErrorCode error_val;

   assert(target);

   if (target->clazz != MHEG5DYNAMICLINEART)
   {
      error_val = MHEG5ERR_WRONGTARGET;
   }
   else if (!params)
   {
      error_val = MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   else
   {
      MHEG5DynamicLineart *dl = (MHEG5DynamicLineart *)target;

      MHEG5resolveORef(params, &target);
      if (!target)
      {
         error_val = MHEG5ERR_WRONGNUMBEROFPARAMS;
      }
      else if (!target->runningStatus)
      {
         error_val = MHEG5ERR_PARAMNOTACTIVE;
      }
      else if (target->clazz == MHEG5INTEGERVARIABLE)
      {
         ((MHEG5IntegerVariable *) target)->value = dl->lineart.lineWidth;
         error_val = MHEG5ERR_NOERROR;
      }
      else
      {
         error_val = MHEG5ERR_WRONGPARAM;
      }
   }
   return error_val;
}

MHEG5ErrorCode MHEG5getLineStyle(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5ErrorCode error_val;

   assert(target);

   if (target->clazz != MHEG5DYNAMICLINEART)
   {
      error_val = MHEG5ERR_WRONGTARGET;
   }
   else if (!params)
   {
      error_val = MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   else
   {
      MHEG5DynamicLineart *dl = (MHEG5DynamicLineart *)target;

      MHEG5resolveORef(params, &target);
      if (!target)
      {
         error_val = MHEG5ERR_WRONGNUMBEROFPARAMS;
      }
      else if (!target->runningStatus)
      {
         error_val = MHEG5ERR_PARAMNOTACTIVE;
      }
      else if (target->clazz == MHEG5INTEGERVARIABLE)
      {
         ((MHEG5IntegerVariable *) target)->value = dl->lineart.lineStyle;
         error_val = MHEG5ERR_NOERROR;
      }
      else
      {
         error_val = MHEG5ERR_WRONGPARAM;
      }
   }
   return error_val;
}

MHEG5ErrorCode MHEG5getLineColour(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5ErrorCode error_val;

   assert(target);

   if (target->clazz != MHEG5DYNAMICLINEART)
   {
      error_val = MHEG5ERR_WRONGTARGET;
   }
   else if (!params)
   {
      error_val = MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   else
   {
      MHEG5DynamicLineart *dl = (MHEG5DynamicLineart *)target;

      MHEG5resolveORef(params, &target);
      if (!target)
      {
         error_val = MHEG5ERR_WRONGNUMBEROFPARAMS;
      }
      else if (!target->runningStatus)
      {
         error_val = MHEG5ERR_PARAMNOTACTIVE;
      }
      else if (target->clazz == MHEG5INTEGERVARIABLE)
      {
         if (dl->lineart.refLineColour.type == MHEG5INT)
         {
            ((MHEG5IntegerVariable *) target)->value = dl->lineart.refLineColour.value.i;
         }
         error_val = MHEG5ERR_NOERROR;
      }
      else if (target->clazz == MHEG5OCTETSTRINGVARIABLE)
      {
         if (dl->lineart.refLineColour.type == MHEG5INT)
         {
            /* This colour has been cached by MHEG5displayColour. Convert it back */
            MHEG5stringDestruct( &((MHEG5OctetStringVariable *) target)->value );
            ((MHEG5OctetStringVariable *) target)->value = OSDsetColour( dl->lineart.refLineColour.value.i );
         }
         else if (dl->lineart.refLineColour.type == MHEG5OCTETSTRING)
         {
            MHEG5stringDestruct( &((MHEG5OctetStringVariable *) target)->value);
            ((MHEG5OctetStringVariable *) target)->value = MHEG5stringCopy( dl->lineart.refLineColour.value.s );
         }
         error_val = MHEG5ERR_NOERROR;
      }
      else
      {
         error_val = MHEG5ERR_WRONGPARAM;
      }
   }
   return error_val;
}

MHEG5ErrorCode MHEG5getFillColour(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5ErrorCode error_val;

   assert(target);

   if (target->clazz != MHEG5DYNAMICLINEART)
   {
      error_val = MHEG5ERR_WRONGTARGET;
   }
   else if (!params)
   {
      error_val = MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   else
   {
      MHEG5DynamicLineart *dl = (MHEG5DynamicLineart *)target;

      MHEG5resolveORef(params, &target);
      if (!target)
      {
         error_val = MHEG5ERR_WRONGNUMBEROFPARAMS;
      }
      else if (!target->runningStatus)
      {
         error_val = MHEG5ERR_PARAMNOTACTIVE;
      }
      else if (target->clazz == MHEG5INTEGERVARIABLE)
      {
         if (dl->lineart.refLineColour.type == MHEG5INT)
         {
            ((MHEG5IntegerVariable *) target)->value = dl->lineart.refLineColour.value.i;
         }
         error_val = MHEG5ERR_NOERROR;
      }
      else if (target->clazz == MHEG5OCTETSTRINGVARIABLE)
      {
         if (dl->lineart.refLineColour.type == MHEG5INT)
         {
            /* This colour has been cached by MHEG5displayColour. Convert it back */
            MHEG5stringDestruct( &((MHEG5OctetStringVariable *) target)->value );
            ((MHEG5OctetStringVariable *) target)->value = OSDsetColour( dl->lineart.refFillColour.value.i );
         }
         else if (dl->lineart.refLineColour.type == MHEG5OCTETSTRING)
         {
            MHEG5stringDestruct( &((MHEG5OctetStringVariable *) target)->value);
            ((MHEG5OctetStringVariable *) target)->value = MHEG5stringCopy( dl->lineart.refFillColour.value.s );
         }
         error_val = MHEG5ERR_NOERROR;
      }
      else
      {
         error_val = MHEG5ERR_WRONGPARAM;
      }
   }
   return error_val;
}

MHEG5ErrorCode MHEG5drawArc(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5ErrorCode error_val;
   assert(target);
   if (target->clazz != MHEG5DYNAMICLINEART)
   {
      error_val = MHEG5ERR_WRONGTARGET;
   }
   else
   {
      error_val = AddActionDraw((MHEG5DynamicLineart *)target,MHEG5DRAWARC,params);
   }
   return error_val;
}

MHEG5ErrorCode MHEG5drawSector(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5ErrorCode error_val;
   if (target->clazz != MHEG5DYNAMICLINEART)
   {
      error_val = MHEG5ERR_WRONGTARGET;
   }
   else
   {
      error_val = AddActionDraw((MHEG5DynamicLineart *)target,MHEG5DRAWSECTOR,params);
   }
   return error_val;
}

MHEG5ErrorCode MHEG5drawLine(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5ErrorCode error_val;

   assert(target);
   if (target->clazz != MHEG5DYNAMICLINEART)
   {
      error_val = MHEG5ERR_WRONGTARGET;
   }
   else
   {
      error_val = AddActionDraw((MHEG5DynamicLineart *)target,MHEG5DRAWLINE,params);
   }
   return error_val;
}

MHEG5ErrorCode MHEG5drawOval(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5ErrorCode error_val;

   assert(target);

   if (target->clazz != MHEG5DYNAMICLINEART)
   {
      error_val = MHEG5ERR_WRONGTARGET;
   }
   else
   {
      error_val = AddActionDraw((MHEG5DynamicLineart *)target,MHEG5DRAWOVAL,params);
   }
   return error_val;
}

MHEG5ErrorCode MHEG5drawPolygon(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5ErrorCode error_val;

   assert(target);

   if (target->clazz != MHEG5DYNAMICLINEART)
   {
      error_val = MHEG5ERR_WRONGTARGET;
   }
   else
   {
      error_val = AddActionDraw((MHEG5DynamicLineart *)target,MHEG5DRAWPOLYGON,params);
   }
   return error_val;
}

MHEG5ErrorCode MHEG5drawPolyline(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5ErrorCode error_val;

   assert(target);

   if (target->clazz != MHEG5DYNAMICLINEART)
   {
      error_val = MHEG5ERR_WRONGTARGET;
   }
   else
   {
      error_val = AddActionDraw((MHEG5DynamicLineart *)target,MHEG5DRAWPOLYLINE,params);
   }
   return error_val;
}

MHEG5ErrorCode MHEG5drawRectangle(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5ErrorCode error_val;

   assert(target);

   if (target->clazz != MHEG5DYNAMICLINEART)
   {
      error_val = MHEG5ERR_WRONGTARGET;
   }
   else
   {
      error_val = AddActionDraw((MHEG5DynamicLineart *)target,MHEG5DRAWRECTANGLE,params);
   }
   return error_val;
}

MHEG5ErrorCode MHEG5clear(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5DynamicLineart *dl;

   assert(target);

   if (target->clazz != MHEG5DYNAMICLINEART)
   {
      return MHEG5ERR_WRONGTARGET;
   }

   dl = (MHEG5DynamicLineart *)target;

   ClearActionDraws(dl);

   OSDclearDynamicLineart( dl->lineart.visible.graphic_data );

   MHEG5displayRedraw((MHEG5Visible *) dl);

   return MHEG5ERR_NOERROR;
}