mh5slider.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 "mh5slider.h"
#include "mh5scene.h"
#include "mh5object.h"          /* for actions      */
#include "mh5variable.h"        /* for actions      */
#include "mh5display.h"         /* for actions      */
#include "mh5application.h"     /* Default Colour   */
#include "mh5queue.h"           /* Events           */
#include "mh5memory.h"          /* Constructor      */
#include "mh5debug.h"

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

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


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

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

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

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

/*
   Debug
 */
#ifdef MH5PRINTOUT

void MHEG5sliderPrint(MHEG5Slider *slider, char *out)
{
   MHEG5visiblePrint(&slider->visible, out);
   MHEG5interactiblePrint(&slider->interactible, out);

   /* exchanged attributes */
   MHEG5indent(out);
   MHEG_PRINT(out, ":Orientation: ");
   switch (slider->orientation)
   {
      case MHEG5LEFT:
         MHEG_PRINT(out, "LEFT");
         break;
      case MHEG5RIGHT:
         MHEG_PRINT(out, "RIGHT");
         break;
      case MHEG5UP:
         MHEG_PRINT(out, "UP");
         break;
      case MHEG5DOWN:
         MHEG_PRINT(out, "DOWN");
         break;
      default:
         MHEG_PRINT(out, "<Internal Error>");
         break;
   }
   MHEG5newLine(out);

   MHEG5indent(out);
   MHEG_PRINT(out, ":InitialValue ");
   MHEG5intPrint(slider->initialValue, out);
   MHEG5newLine(out);

   MHEG5indent(out);
   MHEG_PRINT(out, ":OriginalMinValue: ");
   MHEG5intPrint(slider->originalMinValue, out);
   MHEG5newLine(out);

   MHEG5indent(out);
   MHEG_PRINT(out, ":OriginalMaxValue: ");
   MHEG5intPrint(slider->originalMaxValue, out);
   MHEG5newLine(out);

   MHEG5indent(out);
   MHEG_PRINT(out, ":InitialPortion: ");
   MHEG5intPrint(slider->initialPortion, out);
   MHEG5newLine(out);

   MHEG5indent(out);
   MHEG_PRINT(out, ":OriginalStepSize: ");
   MHEG5intPrint(slider->originalStepSize, out);
   MHEG5newLine(out);

   MHEG5indent(out);
   MHEG_PRINT(out, ":SliderStyle: ");
   switch (slider->sliderStyle)
   {
      case MHEG5NORMAL:
         MHEG_PRINT(out, "NORMAL");
         break;
      case MHEG5THERMOMETER:
         MHEG_PRINT(out, "THERMOMETER");
         break;
      case MHEG5PROPORTIONAL:
         MHEG_PRINT(out, "PROPORTIONAL");
         break;
      default:
         MHEG_PRINT(out, "<Internal Error>");
         break;
   }
   MHEG5newLine(out);

   MHEG5indent(out);
   MHEG_PRINT(out, "SliderRefColour: ");
   MHEG5colourPrint(slider->sliderRefColour, out);
   MHEG5newLine(out);

   /* local attributes */
   MHEG5indent(out);
   MHEG_PRINT(out, "// Value:\t");
   MHEG5intPrint(slider->sliderValue, out);
   MHEG5newLine(out);

   MHEG5indent(out);
   MHEG_PRINT(out, "// Portion:\t");
   MHEG5intPrint(slider->portion, out);
   MHEG5newLine(out);

   MHEG5indent(out);
   MHEG_PRINT(out, "// MinValue:\t");
   MHEG5intPrint(slider->minValue, out);
   MHEG5newLine(out);

   MHEG5indent(out);
   MHEG_PRINT(out, "// MaxValue:\t");
   MHEG5intPrint(slider->maxValue, out);
   MHEG5newLine(out);

   MHEG5indent(out);
   MHEG_PRINT(out, "// StepSize:\t");
   MHEG5intPrint(slider->stepSize, out);
   MHEG5newLine(out);
}

#endif


/*
     Constructor
 */

void MHEG5sliderInit(MHEG5Slider *slider)
{
   assert(slider);

   MHEG5visibleInit(&slider->visible);
   MHEG5interactibleInit(&slider->interactible);

   /* Default value of InitialValue is specified to be MinValue. We cannot know
    * MinValue yet, so set it to the default value of MinValue.
    */
   slider->initialValue = 1;
   slider->originalMinValue = 1;
   slider->originalStepSize = 1;
}

void MHEG5sliderFree(MHEG5Slider *slider)
{
   assert(slider);

   MHEG5visibleFree(&slider->visible);
   MHEG5interactibleFree(&slider->interactible);

   MHEG5colourDestruct(&slider->sliderRefColour);
}

/*
     Internal behaviours
 */

void MHEG5sliderPrepare(MHEG5Slider *slider)
{
   assert(slider);

   slider->sliderValue = slider->initialValue;
   slider->portion = slider->initialPortion;
   slider->minValue = slider->originalMinValue;
   slider->maxValue = slider->originalMaxValue;
   slider->stepSize = slider->originalStepSize;

   MHEG5interactiblePrepare(&slider->interactible);
   MHEG5visiblePrepare(&slider->visible);
}

void MHEG5sliderActivate(MHEG5Slider *slider)
{
   assert(slider);

   if (!slider->visible.ingredient.root.availabilityStatus)
   {
      MHEG5sliderPrepare( slider );
   }
   MHEG5visibleActivate(&slider->visible);
}

void MHEG5sliderDeactivate(MHEG5Slider *slider)
{
   assert(slider);

   MHEG5visibleDeactivate(&slider->visible);

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

void MHEG5sliderDestruct(MHEG5Slider *slider)
{
   assert(slider);

   MHEG5visibleDestruct(&slider->visible);
   MHEG5interactibleDestruct(&slider->interactible);
}

/*
     Actions
 */

MHEG5ErrorCode MHEG5step(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Int nSteps, newValue;
   MHEG5Slider *slider;

   assert(target);

   if (target->clazz != MHEG5SLIDER)
      return MHEG5ERR_WRONGTARGET;
   slider = (MHEG5Slider *) target;

   if (!params)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   MHEG5resolveGenericInteger(params, &nSteps);

   newValue = slider->stepSize * nSteps + slider->sliderValue;
   if (newValue < slider->minValue)
      newValue = slider->minValue;
   if ((newValue + slider->portion) > slider->maxValue)
      return MHEG5ERR_NOERROR;
   slider->sliderValue = newValue;

   MHEG5displayRedraw((MHEG5Visible *) target);

   /* Send the slider value changed event with new slider value as parameter */
   MHEG5sendEvent((MHEG5Root *)slider, MHEG5SLIDERVALUECHANGED, slider->sliderValue );

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5setSliderValue(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Int newValue;
   MHEG5Slider *slider;

   assert(target);

   if (target->clazz != MHEG5SLIDER)
      return MHEG5ERR_WRONGTARGET;
   slider = (MHEG5Slider *) target;

   if (!params)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   MHEG5resolveGenericInteger(params, &newValue);
   if (newValue < slider->minValue)
      return MHEG5ERR_NOERROR;
   if ((newValue + slider->portion) > slider->maxValue)
      return MHEG5ERR_NOERROR;

   slider->sliderValue = newValue;

   MHEG5displayRedraw((MHEG5Visible *) target);

   /* Send the slider value changed event with new slider value as parameter */
   MHEG5sendEvent((MHEG5Root *)slider, MHEG5SLIDERVALUECHANGED, slider->sliderValue );

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5getSliderValue(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Root *intVar = 0;
   MHEG5IntegerVariable *rc = 0;
   MHEG5Slider *slider;

   if (target->clazz != MHEG5SLIDER)
      return MHEG5ERR_WRONGTARGET;
   slider = (MHEG5Slider *) target;

   if (!params)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   MHEG5resolveORef(params, &intVar);
   if (!intVar)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   if (intVar->clazz != MHEG5INTEGERVARIABLE)
      return MHEG5ERR_WRONGPARAM;
   if (!intVar->runningStatus)
      return MHEG5ERR_PARAMNOTACTIVE;

   rc = (MHEG5IntegerVariable *)intVar;
   rc->value = slider->sliderValue;

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5setPortion(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Int newPortion;
   MHEG5Slider *slider;

   if (target->clazz != MHEG5SLIDER)
      return MHEG5ERR_WRONGTARGET;
   slider = (MHEG5Slider *) target;

   if (!params)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   MHEG5resolveGenericInteger(params, &newPortion);

   if (newPortion > (slider->maxValue - slider->sliderValue))
      return MHEG5ERR_NOERROR;

   slider->portion = newPortion;

   MHEG5displayRedraw((MHEG5Visible *) target);

   /* Send the slider value changed event with new slider value as parameter */
   MHEG5sendEvent((MHEG5Root *)slider, MHEG5SLIDERVALUECHANGED, slider->sliderValue );

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5getPortion(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Root *intVar = 0;
   MHEG5IntegerVariable *rc = 0;
   MHEG5Slider *slider;

   assert(target);

   if (target->clazz != MHEG5SLIDER)
      return MHEG5ERR_WRONGTARGET;
   slider = (MHEG5Slider *) target;

   if (!params)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   MHEG5resolveORef(params, &intVar);
   if (!intVar)
      return MHEG5ERR_WRONGPARAM;
   if (intVar->clazz != MHEG5INTEGERVARIABLE)
      return MHEG5ERR_WRONGPARAM;
   if (!intVar->runningStatus)
      return MHEG5ERR_PARAMNOTACTIVE;

   rc = (MHEG5IntegerVariable *)intVar;
   rc->value = slider->portion;

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5setSliderParameters(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5GList *thirdParam, *fourthParam;
   MHEG5Int newMinValue;
   MHEG5Int newMaxValue;
   MHEG5Int newStepSize;
   MHEG5Slider *slider;

   assert(target);

   if (target->clazz != MHEG5SLIDER)
      return MHEG5ERR_WRONGTARGET;
   slider = (MHEG5Slider *) target;

   if (!params)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   thirdParam = MHEG5resolveGenericInteger(params, &newMinValue);

   if (!thirdParam)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   fourthParam = MHEG5resolveGenericInteger(thirdParam, &newMaxValue);

   if (!fourthParam)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   MHEG5resolveGenericInteger(fourthParam, &newStepSize);

   if (newMinValue >= newMaxValue)
      return MHEG5ERR_NOERROR;
   if (((newMaxValue - newMinValue) % newStepSize) != 0)
      return MHEG5ERR_NOERROR;
   if ((newMaxValue - newMinValue) < slider->portion)
      return MHEG5ERR_NOERROR;

   slider->sliderValue = newMinValue;
   slider->minValue = newMinValue;
   slider->maxValue = newMaxValue;
   slider->stepSize = newStepSize;

   MHEG5displayRedraw((MHEG5Visible *) target);

   /* Send the slider value changed event with new slider value as parameter */
   MHEG5sendEvent((MHEG5Root *)slider, MHEG5SLIDERVALUECHANGED, slider->sliderValue );

   return MHEG5ERR_NOERROR;
}

void MHEG5sliderLEFT(MHEG5Slider *slider)
{
   MHEG5Int newValue;
   switch (slider->orientation)
   {
      case MHEG5LEFT:
         newValue = slider->sliderValue + slider->stepSize;
         break;
      case MHEG5RIGHT:
         newValue = slider->sliderValue - slider->stepSize;
         break;
      default:
         return;
   }

   if (newValue < slider->minValue)
   {
      newValue = slider->minValue;
   }
   if ((newValue + slider->portion) > slider->maxValue)
   {
      return;
   }
   slider->sliderValue = newValue;

   MHEG5displayRedraw((MHEG5Visible *) slider);

   /* Send the slider value changed event with new slider value as parameter */
   MHEG5sendEvent((MHEG5Root *)slider, MHEG5SLIDERVALUECHANGED, slider->sliderValue);
}

void MHEG5sliderUP(MHEG5Slider *slider)
{
   MHEG5Int newValue;
   switch (slider->orientation)
   {
      case MHEG5UP:
         newValue = slider->sliderValue + slider->stepSize;
         break;
      case MHEG5DOWN:
         newValue = slider->sliderValue - slider->stepSize;
         break;
      default:
         return;
   }

   if (newValue < slider->minValue)
   {
      newValue = slider->minValue;
   }
   if ((newValue + slider->portion) > slider->maxValue)
   {
      return;
   }
   slider->sliderValue = newValue;

   MHEG5displayRedraw((MHEG5Visible *) slider);

   /* Send the slider value changed event with new slider value as parameter */
   MHEG5sendEvent((MHEG5Root *)slider, MHEG5SLIDERVALUECHANGED, slider->sliderValue );
}

void MHEG5sliderRIGHT(MHEG5Slider *slider)
{
   MHEG5Int newValue;
   switch (slider->orientation)
   {
      case MHEG5RIGHT:
         newValue = slider->sliderValue + slider->stepSize;
         break;
      case MHEG5LEFT:
         newValue = slider->sliderValue - slider->stepSize;
         break;
      default:
         return;
   }

   if (newValue < slider->minValue)
   {
      newValue = slider->minValue;
   }
   if ((newValue + slider->portion) > slider->maxValue)
   {
      return;
   }
   slider->sliderValue = newValue;

   MHEG5displayRedraw((MHEG5Visible *) slider);

   /* Send the slider value changed event with new slider value as parameter */
   MHEG5sendEvent((MHEG5Root *)slider, MHEG5SLIDERVALUECHANGED, slider->sliderValue);
}

void MHEG5sliderDOWN(MHEG5Slider *slider)
{
   MHEG5Int newValue;
   switch (slider->orientation)
   {
      case MHEG5DOWN:
         newValue = slider->sliderValue + slider->stepSize;
         break;
      case MHEG5UP:
         newValue = slider->sliderValue - slider->stepSize;
         break;
      default:
         return;
   }

   if (newValue < slider->minValue)
   {
      newValue = slider->minValue;
   }
   if ((newValue + slider->portion) > slider->maxValue)
   {
      return;
   }
   slider->sliderValue = newValue;

   MHEG5displayRedraw((MHEG5Visible *) slider);

   /* Send the slider value changed event with new slider value as parameter */
   MHEG5sendEvent((MHEG5Root *)slider, MHEG5SLIDERVALUECHANGED, slider->sliderValue );
}

void MHEG5sliderSELECT(MHEG5Slider *slider)
{
   MHEG5Scene *scene;

   scene = MHEG5getCurrentScene();

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

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

void MHEG5sliderEXIT(MHEG5Slider *slider)
{
   MHEG5Scene *scene;

   scene = MHEG5getCurrentScene();

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

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