#else
    vDrawStrAddr(FL_MENU_WB, bStrLen, 0xffff, dwAddr, 0, 0);
  #endif
  }

  if (fgFlMnIsCurrPlayItem(bItemIdx))
  {
    vFlMnHiliOn(bItemIdx, FLMN_HILI_PLAY, FLMN_CLR_BG, FLMN_CLR_PLAY);
  }

  return;
}

/**
 * Preprocess the given name string. The namae string is given by
 *  pointer to it and its length. We adjust the pointer and the len to
 *  indicate the new string.
 *
 * The current preprocess includes:
 *  1. Cut out the extension name
 *  2. Etc ...
 */
void vFlMnPProcName(DWRD *pdwAddr, BYTE *pbLen) large
{
  BYTE bChar, bIdx, bLen;
  DWRD dwAddr;

  if (!pdwAddr || !pbLen)
    return;

  dwAddr = (DWRD)(*pdwAddr);
  bLen = (*pbLen);

  // - move the pointer to the end of the string
  dwAddr += (DWRD)bLen;

  // - check each char
  for (bIdx = 1; bIdx < bLen; bIdx ++)
  {
    dwAddr --;
    bChar = bReadDRAMTbl(bLoByte(wHiWord(dwAddr)), wLoWord(dwAddr));
    if (bChar == '.')
      break;
  }

  // - cut out the ext
  if (bIdx < bLen)
    bLen -= bIdx;

//#ifdef FLMN_DONT_SHOW_NONPRINTABLE_CHAR
#if 0
  dwAddr = (DWRD)(*pdwAddr);
  for (bIdx = 0; bIdx < bLen; bIdx++, dwAddr++)
  {
    bChar = bReadDRAMTbl(bLoByte(wHiWord(dwAddr)), wLoWord(dwAddr));
    if ((bChar < 0x20) || (bChar > 0x7E))
    {
      WriteDRAMTbl(bLoByte(wHiWord(dwAddr)), wLoWord(dwAddr), '_');
    }
  }
#endif

  if (bLen > FLMN_FILENANE_LEN)
    bLen = FLMN_FILENANE_LEN;

  (*pbLen) = bLen;
}

static void vShowJpegInfo(void) large
{
  BYTE  pbStr[9], i;
  WORD  wTmp;

  pbStr[0] = 8;
  wTmp = (WORD) bSharedInfo(SI_JPG_ORG_WIDTH_HI) * 256 + (WORD) bSharedInfo(SI_JPG_ORG_WIDTH_LO);
  wTmp = wWRDToBCD(wTmp);
  pbStr[1] = BCD_HI(bHiByte(wTmp)) + '0';
  pbStr[2] = BCD_LO(bHiByte(wTmp)) + '0';
  pbStr[3] = BCD_HI(bLoByte(wTmp)) + '0';
  pbStr[4] = BCD_LO(bLoByte(wTmp)) + '0';
  for (i=1; i<=4; i++)
  {
    if (pbStr[i] == '0')
      pbStr[i] = ' ';
    else
      break;
  }
  wTmp = (WORD) bSharedInfo(SI_JPG_ORG_HEIGHT_HI) * 256 + (WORD) bSharedInfo(SI_JPG_ORG_HEIGHT_LO);
  wTmp = wWRDToBCD(wTmp);
  pbStr[5] = BCD_HI(bHiByte(wTmp)) + '0';
  pbStr[6] = BCD_LO(bHiByte(wTmp)) + '0';
  pbStr[7] = BCD_HI(bLoByte(wTmp)) + '0';
  pbStr[8] = BCD_LO(bLoByte(wTmp)) + '0';
  for (i=5; i<=8; i++)
  {
    if (pbStr[i] == '0')
      pbStr[i] = ' ';
    else
      break;
  }

  vOsdPosShowArg(OSD_POS_FS_INFO_BAR, OSD_MSG_FL_RESOLUTION, OSD_TIMEOUT, pbStr);
}


/**
 * Display a page with the prepared items. Mark the hovered item by hili if
 *  necessary.
 *
 * DES:
 *  1. clear the previous display
 *  2. redraw the slider
 *  3. draw the full path
 *  4. draw each items
 *
 * NOTE: demo how to get the item info when the command "FLCMD_GET_ITEMS"
 *  suceeds.
 */
static void vFlMnDrawPage(void) large
{
  BYTE  bItemIdx;

  // - clear the page first
  vFlMnClrPage();

  // - redraw the slider
  _wStartX = FS_SLIDER_X;
  _wEndX = FS_SLIDER_X + FS_SLIDER_W;
  _wStartY = FS_SLIDER_Y;
  _wEndY = FS_SLIDER_Y + FS_SLIDER_H;
  vRectangle(FL_MENU_WB, 0, 0, 1, 0);
  vDrawSlider(wFlGetItemIdx(_bFlMnCurItemIdx), _wFlMnListLen);

  // - draw the full path name
  if (!_fgFlIsAutoPlay)
  {
    if (bSharedInfo(FL_LIST_FIELD(_bFlMnListId)) == FLPARM_LIST_FOLDER)
      vDrawFolderName(TRUE);
    else
      vDrawFolderName(FALSE);
  }

  _bFlMnMemLock = FALSE;
  //vFlClRls();

  // - draw items
  vSetMsgCol4(FL_MENU_WB, 0, 0, 2, 3);
  for (bItemIdx = 0;
       (bItemIdx < _bFlMnItemNs) && (bItemIdx < FLMN_PAGE_SZ);
       bItemIdx ++)
  {
    vFlMnDrawItem(bItemIdx);
  }
  vSetMsgCol4(FL_MENU_WB, 0, 0, 3, 2);

  return;
}

#ifdef SUPPORT_SACD
/**
 * get the sacd base dir depend on setting ( MCH or 2CH )
 * it fails when return zero
 */
WORD wGetSacdBaseDir(BYTE bSacdPrio) large
{
  if (!IS_SACD_TYPE())
    return 0;

  // if get from SI_SACD_CHANNEL, need to check its Cdda disc or not.
  if (bSacdPrio == SV_SACD_CD && _fgHybridSACD)
    return 0xffff;

  if (bSacdPrio != SV_SACD_MCH &&
      bSacdPrio != SV_SACD_2CH &&
      bSacdPrio != SV_SACD_CD)
    return 0;

  switch(bSharedInfo(SI_SACD_SUPPORT) & 0x03)
  {
    case SV_SACD_2CH_SUPPORT: // only has one dir
      return 1;
    case SV_SACD_MCH_SUPPORT: // only has one dir
      return 1;
    case (SV_SACD_2CH_SUPPORT | SV_SACD_MCH_SUPPORT): // only has two dirs
      return ((bSacdPrio == SV_SACD_MCH) ? 2 : 1);
    default:
      return 0;
  }
}

/**
 * if SACD_PRIO option is changed ...
 * we must change the sacd base dir or pesudo open/close
 */
void vSwitchSacdDir() large
{
  BYTE bSacdPrio = bSharedInfo(SI_SACD_PRIO);

  if (fgIsCddaPlay())
  {
    switch(bSacdPrio)
    {
      // switch from CD ..
      case SV_SACD_2CH:
      case SV_SACD_MCH:
        if (fgIsDiscPlay(bSharedInfo(SI_PBC_STATE)))
        {
          vSendUopCmd(UOP_STOP, 0, 0, SV_STOP_FORCE);
        }
        vPlayerReset();
        vSendUopCmd(UOP_OPEN_CLOSE, SV_PSEUDO_OPEN, 0, 0);
        break;
      case SV_SACD_CD:
      defailt:
        break; // do nothing..
    }
  }else
  {
    WORD wNewSacdBaseDir = wGetSacdBaseDir(bSacdPrio);
    WORD wNowSacdBaseDir = wGetSacdBaseDir(bSharedInfo(SI_SACD_CHANNEL));

    if (wNewSacdBaseDir != wNowSacdBaseDir &&
        wNewSacdBaseDir != 0 && wNowSacdBaseDir != 0)
    {
      // switch to CD ..
      if (wNewSacdBaseDir == 0xffff || wNowSacdBaseDir == 0xffff)
      {
        vPlayerReset();
        vEnableWB(WB_NORMAL_HEAD2);
        vEnableWB(WB_NORMAL_PBC1);
        vEnableWB(WB_NORMAL_PBC2);
        vEnableWB(WB_NORMAL_VOL);
        vSendUopCmd(UOP_OPEN_CLOSE, SV_PSEUDO_OPEN, 0, 0);
        // in vUITimer ... SV_PSEUDO_CLOSE will be executed.
      }else
      {
        // reset all player status ..
        BYTE bUsrCtrl = bSharedInfo(SI_USR_PBC_CTRL);
        BYTE bRepeatType = bSharedInfo(SI_REPEAT_MODE);

        if (fgIsDiscPlay(bSharedInfo(SI_PBC_STATE)))
        {
          vSendUopCmd(UOP_STOP, 0, 0, SV_STOP_FORCE);
        }

        if ((bRepeatType != SV_REPEAT_NONE) &&
            (bRepeatType != SV_REPEAT_ABNONE))
        {
          vSendUopCmd(UOP_REPEAT, SV_REPEAT_NONE, 0, 0);
        }

        switch (bUsrCtrl)
        {
          case SV_SHUFFLE:
            vSendUopCmd(UOP_SHUFFLE, SV_OFF, 0, 0);
            break;

          case SV_RANDOM:
            vSendUopCmd(UOP_RANDOM, SV_OFF, 0, 0);
            break;

          case SV_REPEAT_SET_A:
          case SV_REPEAT_AB:
            vSendUopCmd(UOP_A_TO_B, SV_AB_OFF, 0, 0);
            break;
        }

        _bFlPbMode = SV_REPEAT_NONE;
        vSetSharedInfo(SI_DDISC_DEF_PMODE, _bFlPbMode);

        // if risc find the channel change ,it will auto clean program list
        vFlCmdSet(_bFlMnListId, FLPARM_LIST_FOLDER, 0x0,
                  wNewSacdBaseDir, FLMN_DEF_FFAC, FLPARM_SO_GDIR);
      }
    }
  }
}
#endif

/**
 * Redraw the display of the object "file list menu".
 */
#ifdef WB_ALLOC_MIN
void vFlMnRecover(void) large
{
  if (_wFlMnListLen)
  {
    // - enable the white boards used by this object
    vCreateWBEx(FL_MENU_WB);
    vFlMnDrawInfoPanel(_bFlIpState);
    vFlMnDrawPage();
    vFlMnHiliItem(_bFlMnCurItemIdx, TRUE);

    vFlIpShowInfo(IP_INFO_FILE_INDEX, 0, wFlGetItemIdx(_bFlMnCurItemIdx));

    vOsdPosClear(OSD_POS_FS_INFO_BAR);

    if (_bFlMnItemType == FTYPE_STILL)
    {
      _bPreview = PREVIEW_STATE_START;
    }

    vFlUpdateVfd(TRUE);
  }
  else
  {
#ifdef SUPPORT_EMD
    vFlMnShowPage();
    vFlMnDrawInfoPanel(_bFlIpState);
    vFlIpShowInfo(IP_INFO_FILE_INDEX, 0, 0);
    _wStartX = FLMN_BTN_1_X + FLMN_MENU_BORDER + 60;
    _wStartY = FLMN_BTN_1_Y + FLMN_MENU_BORDER + 2;
    vOsdMsgPaste(FL_MENU_WB, OSD_MSG_EMPTY_CARD);
#endif
  }

  return;
}
#else
void vFlMnRecover(void) large
{
  // - disable all white board used outside
  //vHideHL(FSMENU_HOVER_HILIT);
  //vOsdShowWb(OSD_WB_FULL_SCR);

  vEnableWB(FL_INFO_WB);
  vEnableWB(FL_MENU_WB);
  vOsdPosClear(OSD_POS_FS_INFO_BAR);

  if (_bFlMnItemType == FTYPE_STILL)
  {
    _bPreview = PREVIEW_STATE_START;
  }

  vFlUpdateVfd(TRUE);

  return;
}
#endif

/**
 * Clear all item on the page.
 */
void vFlMnClrPage(void) large
{
  BYTE bItemIdx;

  _wStartX = FS_SLIDER_X;
  _wEndX = FS_SLIDER_X + FS_SLIDER_W + 4;
  _wStartY = FS_SLIDER_Y;
  _wEndY = FS_SLIDER_Y + (WORD) FS_SLIDER_H;
  vRectangle(FL_MENU_WB, 0, 0, 1, 0);

  // - clear OSD message
  for (bItemIdx = 0; bItemIdx < FLMN_PAGE_SZ; bItemIdx ++)
  {
    vOsdClearPosXY(_prFlMnItemTbl[bItemIdx].wLeft,
                   _prFlMnItemTbl[bItemIdx].wTop,
                   FL_MENU_WB,
                   FLMN_ITEM_W, FLMN_ITEM_H);
  }

  return;
}


////////////////////////////////////////////////////////////////////////////////
//
// Utility Function
//

/**
 * Return the icon index of the given type.
 */
BYTE bFlMnGetIconIdx(BYTE bFType) large
{
  if ((bFType == FTYPE_UNKNOWN) || (bFType > sizeof(_pbIconIndex) / sizeof(_pbIconIndex[0])))
  {
    return BMP_INVALID;
  }

  return _pbIconIndex[bFType];
}

static BOOL fgFlMnIsCurrPlayItem(BYTE bIdx) large
{
  if ((_wFlCurAdoDir == wFlGetListBaseDir(_bFlMnListId)) &&
      (_wFlCurAdoIdx == wFlGetItemIdx(bIdx))&& 
    //  (_bFlCurAdoFileType == bSharedInfo(FL_LIST_FIELD(_bFlMnListId)))&&
      (_bFlMnListType == _bFlCurAdoListType))//061208 xinzhen add for CQ(PL00103667)  
    return TRUE;

  return FALSE;
}

static void vFlMnHiliOn(BYTE bItemIdx, BYTE bHiliIdx, BYTE bColor1, BYTE bColor2) large
{
  _wStartX = _prFlMnItemTbl[bItemIdx].wLeft + FL_ICON_W;
  _wEndX = _prFlMnItemTbl[bItemIdx].wRight;
  _wStartY = _prFlMnItemTbl[bItemIdx].wTop;
  _wEndY = _prFlMnItemTbl[bItemIdx].wBottom;

  switch (bHiliIdx)
  {
    case FLMN_HILI_SEL:
//      if (_bFlMnHiliPos1 != 0x0F)
//        return;
      _bFlMnHiliClrSrc1 = bColor1;
      _bFlMnHiliClrDes1 = bColor2;
      _bFlMnHiliPos1 = bItemIdx;
      break;
    case FLMN_HILI_PLAY:
//      if (_bFlMnHiliPos2 != 0x0F)
//        return;
      _bFlMnHiliClrSrc2 = bColor1;
      _bFlMnHiliClrDes2 = bColor2;
      _bFlMnHiliPos2 = bItemIdx;
      break;
  }
  vChgColRep(FL_MENU_WB, bColor1, bColor2);
}

static void vFlMnHiliOff(BYTE bHiliIdx) large
{
  switch (bHiliIdx)
  {
    case FLMN_HILI_SEL:
      if (_bFlMnHiliPos1 == 0x0F)
        return;

      _wStartX = _prFlMnItemTbl[_bFlMnHiliPos1].wLeft + FL_ICON_W;
      _wEndX = _prFlMnItemTbl[_bFlMnHiliPos1].wRight;
      _wStartY = _prFlMnItemTbl[_bFlMnHiliPos1].wTop;
      _wEndY = _prFlMnItemTbl[_bFlMnHiliPos1].wBottom;
      //vChgColRep(FL_MENU_WB, _bFlMnHiliClrDes1, _bFlMnHiliClrSrc1);
      vChgColRep(FL_MENU_WB, _bFlMnHiliClrDes1, FLMN_CLR_BG);

      _bFlMnHiliClrSrc1 = 0x0F;
      _bFlMnHiliClrDes1 = 0x0F;
      _bFlMnHiliPos1 = 0x0F;
      break;
    case FLMN_HILI_PLAY:
      if (_bFlMnHiliPos2 == 0x0F)
        return;

      _wStartX = _prFlMnItemTbl[_bFlMnHiliPos2].wLeft + FL_ICON_W;
      _wEndX = _prFlMnItemTbl[_bFlMnHiliPos2].wRight;
      _wStartY = _prFlMnItemTbl[_bFlMnHiliPos2].wTop;
      _wEndY = _prFlMnItemTbl[_bFlMnHiliPos2].wBottom;
      //vChgColRep(FL_MENU_WB, _bFlMnHiliClrDes2, _bFlMnHiliClrSrc2);
      vChgColRep(FL_MENU_WB, _bFlMnHiliClrDes2, FLMN_CLR_BG);

      _bFlMnHiliClrSrc2 = 0x0F;
      _bFlMnHiliClrDes2 = 0x0F;
      _bFlMnHiliPos2 = 0x0F;
      break;
  }
}

/**
 * The turn on/off the given item.
 *
 * DES: Use change color to implement this function.
 */
static void vFlMnHiliItem(BYTE bItemIdx, BOOL fgOn) large
{
  WORD wYOfst, wXOfst;
  BOOL fgIsCurrPlay;

  if ((bItemIdx >= _bFlMnItemNs) || (bItemIdx >= FLMN_PAGE_SZ))
    return;

  _wStartX = _prFlMnItemTbl[bItemIdx].wLeft + FL_ICON_W;
  _wEndX = _prFlMnItemTbl[bItemIdx].wRight;
  _wStartY = _prFlMnItemTbl[bItemIdx].wTop;
  _wEndY = _prFlMnItemTbl[bItemIdx].wBottom;

  fgIsCurrPlay = fgFlMnIsCurrPlayItem(bItemIdx);

  if (fgOn)
  {
    if (fgIsCurrPlay)
    {
      //vFlMnHiliOff(FLMN_HILI_PLAY);
      vFlMnHiliOff(FLMN_HILI_PLAY);
      vFlMnHiliOn(bItemIdx, FLMN_HILI_SEL, FLMN_CLR_BG, FLMN_CLR_SEL);
      //vFlMnHiliOn(bItemIdx, FLMN_HILI_PLAY, FLMN_CLR_BG, FLMN_CLR_PLAY);
    }
    else
    {
      vFlMnHiliOn(bItemIdx, FLMN_HILI_SEL, FLMN_CLR_BG, FLMN_CLR_SEL);
    }
  }
  else
  {
    if (fgIsCurrPlay)
    {
      vFlMnHiliOn(bItemIdx, FLMN_HILI_PLAY, FLMN_CLR_SEL, FLMN_CLR_PLAY);
    }
    else
    {
      vFlMnHiliOff(FLMN_HILI_SEL);
    }
  }

  return;
}

/**
 * Perform the operation to the given item when the hover cursor leave it.
 */
static BOOL fgFlMnLeavItem(BYTE bItemIdx) large
{
  if ((bItemIdx >= _bFlMnItemNs) || (bItemIdx >= FLMN_PAGE_SZ))
    return FALSE;

  vFlMnHiliItem(bItemIdx, FALSE);