// Return    :
// *********************************************************************
static void vSelMenuBarActive(BYTE bState) large
{ 
  BYTE bType = bSharedInfo(SI_USR_PROGRAM_TYPE);
  BYTE bRepeatType = bSharedInfo(SI_REPEAT_MODE);

  switch (bState)
  {
    case PROG_STATE_EXIT:
      if (_rSelMenu.fgExitValid)
      {
        vSetExitInputState();
      }
      break;
    
    case PROG_STATE_PREV:
      if (_rSelMenu.fgPrevValid)
      {
        if (bType == SV_PROGRAM_NONE_ITEM)
        {
          _rSelMenu.bPage--;
          vSelMenuShowPage(_rSelMenu.bPage, OSD_PROG_ITEM_HEADER);
          vSelMenuGotoBar(PROG_STATE_NEXT);
        }
        else
        {
          vSelMenuGotoItem(bSelMenuHiliItemNo(_rSelMenu.bPage - 1, SELMENU_PAGE_SIZE - 1));
        }
      }
      break;

    case PROG_STATE_NEXT:
      if (_rSelMenu.fgNextValid)
      {
        if (bType == SV_PROGRAM_NONE_ITEM)
        {
          _rSelMenu.bPage++;
          vSelMenuShowPage(_rSelMenu.bPage, OSD_PROG_ITEM_HEADER);
          vSelMenuGotoBar(PROG_STATE_PREV);
        }
        else
        {
          vSelMenuGotoItem(bSelMenuHiliItemNo(_rSelMenu.bPage + 1, 0));
        }
      }
      break;

    case PROG_STATE_START_STOP:
      if (_rSelMenu.fgStartStopValid)
      {
        // FIXME: race condition
        // risc state isn't equal to state in shared memory
        // Wait UOP_PROGRAM notify to confirm state consistency
        if (bSharedInfo(SI_USR_PBC_CTRL) == SV_PROGRAM)
        {
          _rSelMenu.fgWaitProgStop = TRUE;
          vSendUopCmd(UOP_PROGRAM, SV_PROGRAM_STOP, 0, 0);
          
          _rSelMenu.fgListValid = TRUE;
        }
        else
        {
          _rSelMenu.fgWaitProgStop = FALSE;

#ifdef USR_CTRL_CANCEL_REPEAT
          if ((bRepeatType != SV_REPEAT_NONE) && 
              (bRepeatType != SV_REPEAT_ABNONE))
          {
            vSendUopCmd(UOP_REPEAT, SV_REPEAT_NONE, 0, 0);
          }
#endif /* USR_CTRL_CANCEL_REPEAT */
          
          if (bSharedInfo(SI_PBC_SWITCH) == SV_PBC_ON)
          {
            /* switch to PBC off first */
            vSendUopCmd(UOP_PBC_SWITCH, 0, 0, 0);
          }

          vSendUopCmd(UOP_PROGRAM, SV_PROGRAM_START, 0, 0);
          
          _rSelMenu.fgListValid = TRUE;
          
          /* escape program menu immediately */
          vSetExitInputState();
        }
        _rSelMenu.fgStartStopValid = FALSE; /* this is turned on by shared info update */
        vSelMenuGotoBar(PROG_STATE_EXIT);
#ifdef HILI_USE_OSD
		_bSelMenuFromStop = 0x77;
#endif /* HILI_USE_OSD */
      }
      break;
          
    case PROG_STATE_SELECT:
    case PROG_STATE_INPUT:
    case PROG_STATE_INPUT_1:
    default:
      break;
  }
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vSelMenuTimeInputStart(void) large
{
  BYTE bItem = bSelMenuHiliItemNo(_rSelMenu.bPage, _rSelMenu.bHili);

  if ((bItem > bSharedInfo(SI_USR_PROGRAM_NS)) ||  /* include add new one */
      (_rSelMenu.bState != PROG_STATE_SELECT) ||
      (bSharedInfo(SI_USR_PBC_CTRL) == SV_PROGRAM))
  {
    return;
  }

#ifdef NO_ADD10_KEY
  vNumInInitState(NUM_IN_SEQ_WAIT, 2);
#else
  vNumInInitState(NUM_IN_TYPE_1, 1);
#endif

  _rSelMenu.bState = PROG_STATE_INPUT;
  vOsdPosHili(OSD_POS_HILI_CLEAR, 0, 0);

  vOsdShowProgItemTime(bItem, OSD_PROG_ITEM_HILI_TIME | 0, 0, 0);
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vSelMenuTimeInputEnd(BYTE bSelNo1) large
{
  BYTE bItem = bSelMenuHiliItemNo(_rSelMenu.bPage, _rSelMenu.bHili);
  BYTE bNs = bSharedInfo(SI_USR_PROGRAM_NS);
  BYTE pbTime[3];
  BOOL fgItemValid = FALSE;

  if (bSelNo1 != bSelMenuReadItem(bItem, 0))
  {
    vSelMenuSetItem(bItem, bSelNo1, 0);
  }

  if ((bSelNo1 > 0) && (bItem == bNs))
  {
    vSetSharedInfo(SI_USR_PROGRAM_NS, bItem + 1);
    if (bNs == 0)
    {
      /* to show START */
      vSelMenuShowBar();
    }
    fgItemValid = TRUE;
  }

  bSelMenuReadItem(bItem, pbTime);
  if ((pbTime[0] <= 9) && (bBCDToHEX(pbTime[1]) <= 59) && (bBCDToHEX(pbTime[2]) <= 59) && (bSelNo1 > 0))
  {
    vOsdShowProgItemTime(bItem, OSD_PROG_ITEM_NORMAL, bSelNo1, pbTime);
  }
  else
  {
    vOsdShowProgItemTime(bItem, OSD_PROG_ITEM_NORMAL, bSelNo1, 0);
  }

  _rSelMenu.bState = PROG_STATE_SELECT;

  if (((bItem + 1) % SELMENU_PAGE_SIZE) && (fgItemValid))
  {
    vSelMenuGotoItem(bItem + 1);
  }
  else
  {
#ifndef HILI_USE_OSD
    vShowHL(HL_1);
#else
	/*
		For VCD/CDDA:
		1. When user inputed incorrectly, redraw the hili without defects.
		2. Do a correct focus on correct item.
		by Alfonso, 2005/11/10.
	*/
	vOsdPosHili(OSD_POS_HILI_SHOW, OSD_POS_PROG_ITEM_1 + (bItem%SELMENU_PAGE_SIZE), 0);
#endif /* not HILI_USE_OSD */
  }
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
BOOL fgSelMenuTimeInputState(void) large
{
  BOOL fgRetValue = TRUE;
  BYTE bItem = bSelMenuHiliItemNo(_rSelMenu.bPage, _rSelMenu.bHili);
  
  if (_bIRKey <= IR_ADD10 || _bIRKey == IR_ADD5)  // megaa ADD5
  {
    fgNumInState();

    if (_rNumInStateCtx.rState.fgComplete)
    {
      if ((_rNumInStateCtx.wNum > 0) &&
          (_rNumInStateCtx.wNum <= _rSelMenu.bSelNoMax) &&
          (_rNumInStateCtx.rState.fgCancel == FALSE))
      {
        vSelMenuTimeInputEnd(_rNumInStateCtx.wNum);
      }
      else
      {
        vSelMenuTimeInputEnd(bSelMenuReadItem(bItem, 0));
      }
    }
    else /* _rNumInStateCtx.rState.fgComplete */
    {
      /* update OSD only */
      vOsdShowProgItemTime(bItem, OSD_PROG_ITEM_HILI_TIME | _rNumInStateCtx.rState.bDigNum,
                           _rNumInStateCtx.wNum, 0);
    }
  }
  else /* > IR_ADD10 and not IR_ADD5 */
  {
    vSelMenuTimeInputEnd(bSelMenuReadItem(bItem, 0));
    fgRetValue = FALSE;
  }

  return (fgRetValue);
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vSelMenuTtChInputStart(void) large
{
  BYTE bItem = bSelMenuHiliItemNo(_rSelMenu.bPage, _rSelMenu.bHili);

  if ((bItem > bSharedInfo(SI_USR_PROGRAM_NS)) ||  /* include add new one */
      (_rSelMenu.bState != PROG_STATE_SELECT) ||
      (bSharedInfo(SI_USR_PBC_CTRL) == SV_PROGRAM))
  {
    return;
  }

#ifdef NO_ADD10_KEY
  vNumInInitState(NUM_IN_SEQ_WAIT, 2);
#else
  vNumInInitState(NUM_IN_TYPE_1, 1);
#endif

  _rSelMenu.bState = PROG_STATE_INPUT;

// for clear residue wb in selecting mode. by Alfonso, 2005/0705
#ifndef HILI_USE_OSD
  vOsdPosHili(OSD_POS_HILI_CLEAR, 0, 0);
#else
  vOsdPosHili(OSD_POS_HILI_CLEAR, OSD_POS_PROG_ITEM_1, 0);
#endif /* HILI_USE_OSD */

  vOsdShowProgItemTtCh(bItem, OSD_PROG_ITEM_HILI_TT | 0, 0, 0);
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vSelMenuTtChInputEnd(BYTE bSelNo1, BYTE bSelNo2) large
{
  BYTE bItem = bSelMenuHiliItemNo(_rSelMenu.bPage, _rSelMenu.bHili);
  BYTE bNs = bSharedInfo(SI_USR_PROGRAM_NS);
  BYTE pbTime[3];
  BOOL fgItemValid = FALSE;

  if (bSelNo1 != bSelMenuReadItem(bItem, pbTime))
  {
    pbTime[0] = bSelNo2;
    vSelMenuSetItem(bItem, bSelNo1, pbTime);
  }
  else if (pbTime[0] != bSelNo2)
  {
    pbTime[0] = bSelNo2;
    vSelMenuSetItem(bItem, bSelNo1, pbTime);
  }

  if ((bSelNo1 > 0) && (bSelNo2 > 0) && (bItem == bNs))
  {
    vSetSharedInfo(SI_USR_PROGRAM_NS, bItem + 1);
    if (bNs == 0)
    {
      /* to show START */
      vSelMenuShowBar();
    }
    fgItemValid = TRUE;
  }

  bSelMenuReadItem(bItem, pbTime);
  if (pbTime[0] <= bSharedInfo(SI_DVD_TT_CH + bSelNo1 - 1))
  {
    vOsdShowProgItemTtCh(bItem, OSD_PROG_ITEM_NORMAL, bSelNo1, pbTime[0]);
  }
  else
  {
    vOsdShowProgItemTtCh(bItem, OSD_PROG_ITEM_NORMAL, 0, 0);
  }

  _rSelMenu.bState = PROG_STATE_SELECT;

  /* update chapter input range */
  vOsdShowProgType(SV_PROGRAM_TT_CH_ITEM, _rSelMenu.bSelNoMax, 0);

  if (((bItem + 1) % SELMENU_PAGE_SIZE) && (fgItemValid))
  {
    vSelMenuGotoItem(bItem + 1);
  }
  else
  {
#ifndef HILI_USE_OSD
    vShowHL(HL_1);
#else
	/*
		Once the item were incorrectly inputed, we gonna hili the field again.
		By Alfonso, refined on 2005/11/10
	*/
	vOsdPosHili(OSD_POS_HILI_SHOW, OSD_POS_PROG_ITEM_1 + (bItem%SELMENU_PAGE_SIZE), 0);
#endif /* not HILI_USE_OSD */
  }
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
BOOL fgSelMenuTtChInputState(void) large
{
  BOOL fgRetValue;
  BYTE bItem = bSelMenuHiliItemNo(_rSelMenu.bPage, _rSelMenu.bHili);
  BYTE pbTmp[3];
  
  fgRetValue = fgNumInState();
  
  if (fgRetValue == TRUE)
  {
    if (_rSelMenu.bState == PROG_STATE_INPUT) /* title input state */
    {
      if (_rNumInStateCtx.rState.fgComplete)
      {
        if ((_rNumInStateCtx.wNum > 0) &&
            (_rNumInStateCtx.wNum <= _rSelMenu.bSelNoMax) &&
            (_rNumInStateCtx.rState.fgCancel == FALSE))
        {
          pbTmp[0] = _rNumInStateCtx.wNum;
  
          /* reset number input state */
#ifdef NO_ADD10_KEY
          vNumInInitState(NUM_IN_SEQ_WAIT, 2);
#else
          vNumInInitState(NUM_IN_TYPE_1, 1);
#endif
          
          /* save title number, note here is some trick, assume bDig[5] is not used */
          _rNumInStateCtx.bDig[5] = pbTmp[0];
          
          /* update OSD only */
          vOsdShowProgItemTtCh(bItem, OSD_PROG_ITEM_HILI_CH | _rNumInStateCtx.rState.bDigNum,
                               _rNumInStateCtx.bDig[5], 0);

          /* update chapter input range */
          vOsdShowProgType(SV_PROGRAM_TT_CH_ITEM, _rNumInStateCtx.bDig[5],
                           bSharedInfo(SI_DVD_TT_CH + _rNumInStateCtx.bDig[5] - 1));

          /* switch to chapter input state */
          _rSelMenu.bState = PROG_STATE_INPUT_1;
        }
        else
        {
          /* reset to default value */
          _rNumInStateCtx.wNum = bSelMenuReadItem(bItem, pbTmp);
          vSelMenuTtChInputEnd(_rNumInStateCtx.wNum, pbTmp[0]);
        }
      }
      else /* not complete */
      {
        if (_rNumInStateCtx.rState.fgCancel == FALSE)
        {
          /* update OSD only */
          vOsdShowProgItemTtCh(bItem, OSD_PROG_ITEM_HILI_TT | _rNumInStateCtx.rState.bDigNum,
                               _rNumInStateCtx.wNum, 0);
        }
        else
        {
          /* reset to default value */
          _rNumInStateCtx.wNum = bSelMenuReadItem(bItem, pbTmp);
          vSelMenuTtChInputEnd(_rNumInStateCtx.wNum, pbTmp[0]);
        }
      }
    }
    else if (_rSelMenu.bState == PROG_STATE_INPUT_1) /* chapter input state */
    {
      if (_rNumInStateCtx.rState.fgComplete)
      {
        if ((_rNumInStateCtx.wNum > 0) &&
            (_rNumInStateCtx.wNum <= bSharedInfo(SI_DVD_TT_CH + _rNumInStateCtx.bDig[5] - 1)) &&
            (_rNumInStateCtx.rState.fgCancel == FALSE))
        {
          vSelMenuTtChInputEnd(_rNumInStateCtx.bDig[5], _rNumInStateCtx.wNum);
        }
        else
        {
          /* reset to default value */
          _rNumInStateCtx.wNum = bSelMenuReadItem(bItem, pbTmp);
          vSelMenuTtChInputEnd(_rNumInStateCtx.wNum, pbTmp[0]);
        }
      }
      else /* not complete */
      {
        /* check title number when chapter not inputed yet */
        if (_rNumInStateCtx.rState.fgCancel == FALSE)
        {
          /* update OSD only */
          vOsdShowProgItemTtCh(bItem, OSD_PROG_ITEM_HILI_CH | _rNumInStateCtx.rState.bDigNum,
                               _rNumInStateCtx.bDig[5], _rNumInStateCtx.wNum);
        }
        else
        {
          /* reset to default value */
          _rNumInStateCtx.wNum = bSelMenuReadItem(bItem, pbTmp);
          vSelMenuTtChInputEnd(_rNumInStateCtx.wNum, pbTmp[0]);
        }
      }
    } /* chapter input state */
  }
  else /* if (fgRetValue == FALSE) */
  {
    _rNumInStateCtx.wNum = bSelMenuReadItem(bItem, pbTmp);
    vSelMenuTtChInputEnd(_rNumInStateCtx.wNum, pbTmp[0]);
    return (FALSE);
  }

  return (TRUE);
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
static BOOL fgSelMenuSelectState(void) large
{
  BYTE bItem = bSelMenuHiliItemNo(_rSelMenu.bPage, _rSelMenu.bHili);
  BYTE bTmp;
  BYTE bIdx;
  BYTE pbTime[3];
#ifdef HILI_USE_OSD
  BYTE bCurItem = bItem;
#endif /* HILI_USE_OSD */

  switch (_bIRKey)
  {
    case IR_UP:
      if (bItem > 0)
      {
        bItem--;
      }
      break;

    case IR_LEFT:
      if (bItem - SELMENU_COL_SIZE >= 0)
      {
        bItem -= SELMENU_COL_SIZE;
      }
      break;

    case IR_RIGHT:
      if (bItem + SELMENU_COL_SIZE < (SELMENU_PAGE_SIZE * SELMENU_PAGE_NS))
      {
        bItem += SELMENU_COL_SIZE;
      }
      break;

    case IR_DOWN:
      if (((bItem + 1) % SELMENU_COL_SIZE) == 0)
      {
        _rSelMenu.bState = bSelMenuGetBarNextValid(_rSelMenu.bState);
        if (_rSelMenu.bState == PROG_STATE_SELECT)
        {
          if (bItem < (SELMENU_PAGE_SIZE * SELMENU_PAGE_NS - 1))
          {
            bItem++;
          }
        }
        else
        {
          vSelMenuGotoBar(_rSelMenu.bState);
        }
      }
      else if (bItem < (SELMENU_PAGE_SIZE * SELMENU_PAGE_NS))
      {
        bItem++;
      }
      break;

    case IR_CLEAR:
      if (bSharedInfo(SI_USR_PBC_CTRL) == SV_PROGRAM)
      {
        break;
      }

      bTmp = bSharedInfo(SI_USR_PROGRAM_NS);
      if ((bItem < bTmp) && (bTmp > 0))