#ifdef ENABLE_ID3
  if ((_bFlMnItemType == FTYPE_AUDIO) && fgFlMnIsCurrPlayItem(bItemIdx))
  {
    _wStartX = (WORD) FLMN_PREVIEW_X - FSMENU_BASIC_WB_LEFT;
    _wStartY = (WORD) FLMN_PREVIEW_Y - FSMENU_BASIC_WB_TOP + 15;
    vOsdClearPos(FL_MENU_WB, 200, 180);
  }
#endif

  vMoveSlider(wFlGetItemIdx(bItemIdx), _wFlMnListLen, FALSE);

#ifdef FSMENU_WITH_FILE_INFO
    // Set to indicate the content is dirty
    vSetSharedInfo(SI_DDISC_FILE_INFO_MODE, SV_FI_DIRTY);
#endif

  // - terminate the JPEG preview timing
  _bPreview = PREVIEW_STATE_IDLE;

  return TRUE;
}

/**
 * Perform the operation to the given item when the hover cursor enter it.
 */
static BOOL fgFlMnEntItem(BYTE bItemIdx) large
{
  WORD  wNum;

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

  wNum = wFlGetItemIdx(bItemIdx);
  vFlMnHiliItem(bItemIdx, TRUE);
  vMoveSlider(wNum, _wFlMnListLen, TRUE);
  _bFlMnItemType = bFlGetItemType(bItemIdx);

  vFlIpShowInfo(IP_INFO_FILE_INDEX, 0, wNum);

  // - restart the JPEG preview timing if we enter a JPEG file
  if (_bFlMnItemType == FTYPE_STILL)
  {
    _bPreview = PREVIEW_STATE_START;
  }
#ifdef FSMENU_WITH_FILE_INFO
  else if (_bFlMnItemType == FTYPE_AV)
  {
    if (bSharedInfo(SI_MP3_STT) != MP3STT_PB_STRT)
    {
      vSetSharedInfo(SI_DDISC_FILE_INFO_MODE, SV_FI_GET_START);
      vFlCmdQueryItem(_bFlMnListId, wFlGetItemIdx(bItemIdx));
    }
  }
#endif

  // - move current item to the given one
  _bFlMnCurItemIdx = bItemIdx;

#ifdef ENABLE_ID3
  if ((_bFlMnItemType == FTYPE_AUDIO) && fgFlMnIsCurrPlayItem(_bFlMnCurItemIdx))
  {
    vFlGetId3Info();
  }
#endif

  vFlUpdateVfd(FALSE);

#ifdef MT8302_MANUFACTURE_TEST
  vTstPostEvt(TST_EVT_ENTER_ITEM, 0, 0, 0);
#endif

  return TRUE;
}

/**
 * Read in the list info from proper shared info group.
 */
void vFlMnRdListInfo(BYTE bId) large
{
  BYTE bIncItemType;
  WORD wBsDir, wPos;

  if (bId >= FL_MAX_LIST_NS)
    return;

  wPos = FL_LIST_FIELD(bId);
  _bFlMnListType =  bSharedInfo(wPos);//061208 xinzhen modify for CQ(PL00103667)
  bIncItemType = bSharedInfo(wPos + 1);
  bLoByte(wBsDir) = bSharedInfo(wPos + 2);
  bHiByte(wBsDir) = bSharedInfo(wPos + 3);

  bLoByte(_wFlMnListLen) = bSharedInfo(wPos + 4);
  bHiByte(_wFlMnListLen) = bSharedInfo(wPos + 5);

  return;
}

/**
 * Leave the current dir to its parent.
 */
static BOOL fgFlMnLeavDir(void) large
{
  BYTE bICfg;
  WORD wPos, wBsDir;

  // - check current dir
  wPos = FL_LIST_FIELD(_bFlMnListId);
  bICfg = bSharedInfo(wPos + 1);
  bLoByte(wBsDir) = bSharedInfo(wPos + 2);
  bHiByte(wBsDir) = bSharedInfo(wPos + 3);

  if (!wBsDir || !(bICfg & FLPARM_INC_PARENT))
    return FALSE;

  if (fgFlCmdIsOOC()) // Prevent doing fgFlMnEntDir() before other command returns.
    return FALSE;

  // - get in parent dir
  fgFlMnLeavItem(_bFlMnCurItemIdx); // - leave current item
  if ((wFlGetItemIdx(0) == 0) && (bFlGetItemType(0) == FTYPE_FOLDER))
  {
    if (fgFlClLock(FL_CMDPATH_DIR_UP_1))
    {
      fgFlMnEntDir(0, TRUE);
    }
  }
  else
  {
    //_bFlMnCurItemIdx = 0;  // this should be ".."
    //fgFlCmdGetItems(_bFlMnListId, 0x0, FLCMD_RET_OP_ENTDIR);
    if (fgFlClLock(FL_CMDPATH_DIR_UP_0))
      fgFlCmdGetItems(_bFlMnListId, 0x0);
  }

  return TRUE;
}

/**
 * Enter the dir given by item index.
 */
static BOOL fgFlMnEntDir(BYTE bItemIdx, BOOL fgMoveUp) large
{
  WORD wPos, wBsDir, wIdx;
  BYTE bFType;

  if (bItemIdx >= FL_MIN(_bFlMnItemNs, FLMN_PAGE_SZ))
  {
    return FALSE;
  }

  // - check the type of the given item
  wPos = FL_ITEM_FIELD(bItemIdx);

  // - parse the full path
  _bFlMnMemLock = TRUE;
  vParseFolderName(bItemIdx, fgMoveUp);

  // - get the base dir index and set the list to it
  bLoByte(wBsDir) = bSharedInfo(wPos + 12);
  bHiByte(wBsDir) = bSharedInfo(wPos + 13);
  wPos = FL_LIST_FIELD(_bFlMnListId);

  vFlCmdClickItem(_bFlMnListId, wFlGetItemIdx(bItemIdx));

  return TRUE;
}

/**
 * Handle the notification of MP3 playback status change.
 *
 * NOTE: In order to avoid the racing condition, check the parameters
 *  of notification instead of shared info slot.
 */
static void vFlMnChgMp3State(BYTE bStt) large
{
  BYTE  bIdx;
  WORD  wItemIdx, wIdx;

  // - the current item of MP3 module
  bLoByte(wItemIdx) = bSharedInfo(SI_MP3_ITEM_IDX_LO);
  bHiByte(wItemIdx) = bSharedInfo(SI_MP3_ITEM_IDX_HI);

  bStt = bSharedInfo(SI_MP3_STT);

  switch (bStt)
  {
    case MP3STT_PB_ENB:
      // - playback enabled
      break;
    case MP3STT_PB_STRT:
      // - playback starts

      // - temp solution
#ifdef SPTM_SUPPORT
      if (_bFlIpState == IP_STATE_PANEL_1)
        vFlIpShowInfo(IP_INFO_EQ, 0, 0);
      else
        vHideEqBar();
#endif

      if (_wFlCurAdoDir == wFlGetListBaseDir(_bFlMnListId))
      {
        vFlMnHiliOff(FLMN_HILI_PLAY);
        _wFlCurAdoIdx = wItemIdx;
        wIdx = wFlGetItemIdx(0);
        if ((_wFlCurAdoIdx != wFlGetItemIdx(_bFlMnCurItemIdx)) &&
            (wItemIdx >= wIdx) && (wItemIdx < wIdx + FLMN_ITEM_N))
        {
          bIdx = _wFlCurAdoIdx % FLMN_ITEM_N;
          vFlMnHiliOn(bIdx, FLMN_HILI_PLAY, FLMN_CLR_BG, FLMN_CLR_PLAY);
        }
      }

      vFlIpShowInfo(IP_INFO_FILE_INDEX, 0, wItemIdx);
      vFlIpShowInfo(IP_INFO_TOTALTIME, bSharedInfo(SI_MP3_TOTAL_TIME_MM),
                                         bSharedInfo(SI_MP3_TOTAL_TIME_SS));
      vFlIpShowInfo(IP_INFO_PBC, 0, 0);

#ifdef ENABLE_ID3
      vFlGetId3Info();
#endif
      break;
    case MP3STT_PB_FSH:
      // - playback finishes
      // break;
    case MP3STT_PB_ABT:
      // - playback is aborted
      // break;
    case MP3STT_PB_ERR:
      // - temp solution
#ifdef SPTM_SUPPORT
      vHideEqBar();
#endif

      // - some playback erro occurs
#ifdef SUPPORT_SACD
      if (!IS_SACD_TYPE() || bSharedInfo(SI_SACD_INFO_STYLE) != SACD_INFO_STYLE_CDDA)
#endif
      {
        vFlIpShowInfo(IP_INFO_PLAYTIME, 0, 0);
        vFlIpShowInfo(IP_INFO_TOTALTIME, 0, 0);
      }

      if (_wFlCurAdoDir == wFlGetListBaseDir(_bFlMnListId))
      {
        vFlMnHiliOff(FLMN_HILI_PLAY);
        _wFlCurAdoIdx = 0xFFFF;
      }
      if (_bFlIpState == IP_STATE_PANEL_1)
      {
        _wStartX = FS_EQ_X;
        _wStartY = 32;
        vOsdClearPos(FL_INFO_WB, 200, 32);
      }

      vFlIpShowInfo(IP_INFO_BITRATE, 0, 0xFFFF);

#ifdef MT8302_MANUFACTURE_TEST
      vTstPostEvt(TST_EVT_PLAY_ITEM_DONE, 0, 0, 0);
#endif

#ifdef ISO_AUTO_PLAY
      fgFlAutoPlayNext();
#endif
      break;
    default:
      // - error occurs
      break;
  }

  return;
}


/**
 * Clear the working area barrowed from DRAM.
 */
static void vWorkAreaClear(void) large
{
  BYTE bLen, i;
  DWRD dwAddr;

  bLen = bSharedInfo(SI_FS_WA_SZ);

  dwAddr = dwMakeDWord(SI_FS_WA_SA_B1);

  WriteDRAMTbl(bLoByte(wHiWord(dwAddr)), wLoWord(dwAddr), 0);
  dwAddr++;
  WriteDRAMTbl(bLoByte(wHiWord(dwAddr)), wLoWord(dwAddr), 0);
  dwAddr++;
  WriteDRAMTbl(bLoByte(wHiWord(dwAddr)), wLoWord(dwAddr), 1);
  dwAddr++;
  WriteDRAMTbl(bLoByte(wHiWord(dwAddr)), wLoWord(dwAddr), '\\');
  dwAddr++;

  for (i=4; i < bLen-4; i++)
  {
    WriteDRAMTbl(bLoByte(wHiWord(dwAddr)), wLoWord(dwAddr), 0);
  }

  return;
}

#ifdef FLMN_RET_PLAY_DIR
static void vWorkAreaMove(BOOL fgToFront) large
{
  BYTE  bLen, bChar, i;
  DWRD  dwAddr, dwSrcAddr, dwDesAddr;


  dwAddr = dwMakeDWord(SI_FS_WA_SA_B1);

  if (fgToFront)
  {
    dwDesAddr = dwAddr;
    dwSrcAddr = dwAddr + FLMN_MAX_WA_SIZE;
  }
  else
  {
    dwSrcAddr = dwAddr;
    dwDesAddr = dwAddr + FLMN_MAX_WA_SIZE;
  }

  bChar = bReadDRAMTbl(bLoByte(wHiWord(dwSrcAddr)), wLoWord(dwSrcAddr));
  WriteDRAMTbl(bLoByte(wHiWord(dwDesAddr)), wLoWord(dwDesAddr), bChar);
  dwSrcAddr ++;
  dwDesAddr ++;

  bChar = bReadDRAMTbl(bLoByte(wHiWord(dwSrcAddr)), wLoWord(dwSrcAddr));
  WriteDRAMTbl(bLoByte(wHiWord(dwDesAddr)), wLoWord(dwDesAddr), bChar);
  dwSrcAddr ++;
  dwDesAddr ++;

  bLen = bReadDRAMTbl(bLoByte(wHiWord(dwSrcAddr)), wLoWord(dwSrcAddr));
  WriteDRAMTbl(bLoByte(wHiWord(dwDesAddr)), wLoWord(dwDesAddr), bLen);
  dwSrcAddr ++;
  dwDesAddr ++;

  while (bLen)
  {
    bChar = bReadDRAMTbl(bLoByte(wHiWord(dwSrcAddr)), wLoWord(dwSrcAddr));
    WriteDRAMTbl(bLoByte(wHiWord(dwDesAddr)), wLoWord(dwDesAddr), bChar);
    dwSrcAddr ++;
    dwDesAddr ++;
    bLen--;
  }
}
#endif

/**
 * Draw the name string of the current folder.
 */
static void vDrawFolderName(BOOL fgDraw) large
{
  BYTE bLen, i;
  DWRD dwAddr;


  if (fgDraw)
  {
    dwAddr = dwMakeDWord(SI_FS_WA_SA_B1);

    dwAddr += 2;
    bLen = bReadDRAMTbl(bLoByte(wHiWord(dwAddr)), wLoWord(dwAddr));

    _wStartX = FLMN_BTN_1_X + FLMN_MENU_BORDER + 20;
    _wStartY = FLMN_BTN_1_Y + FLMN_MENU_BORDER + 2;
    vPasteBmp(FL_MENU_WB, BMP_FOLDER);

    _wStartY = FLMN_BTN_1_Y + FLMN_MENU_BORDER;
    _wStartX += 50;

    _wEndY = _wStartY + 30;
    _wEndX = FLMN_BTN_1_X + FLMN_BTN_2_W - FLMN_MENU_BORDER * 2;
    vRectangle(FL_MENU_WB, 0, 0, 1, 0);

    vSetFsCodePage(0);
    vSetMsgCol4(FL_MENU_WB, 0, 0, 3, 2);
    if (bLen > FLMN_FOLDER_LEN)
    {
      dwAddr += (bLen - FLMN_FOLDER_LEN);
      bLen = FLMN_FOLDER_LEN;
    }
  #ifdef FLMN_DONT_SHOW_NONPRINTABLE_CHAR
    vDrawStrAddrXY(_wStartX, _wStartY, 0xffff, FL_MENU_WB, bLen, dwAddr+1, '_', 0);
  #else
    vDrawStrAddrXY(_wStartX, _wStartY, 0xffff, FL_MENU_WB, bLen, dwAddr+1, 0, 0);
  #endif
    vSetFsCodePage(CODE_PAGE_MENU);
  }
  else
  {
    _wStartX = FLMN_BTN_1_X + FLMN_MENU_BORDER + 20;
    _wStartY = FLMN_BTN_1_Y + FLMN_MENU_BORDER + 2;
//    _wEndY = _wStartY + 30;
//    _wEndX = FLMN_BTN_1_X + FLMN_BTN_2_W - FLMN_MENU_BORDER * 2;
    vOsdClearPos(FL_MENU_WB, FSMENU_BASIC_WB_WIDTH, 30);
  }

  return;
}

/**
 * Calculate the name string of the folder.
 */
static void vParseFolderName(BYTE bItem, BOOL fgMoveUp) large
{
  BYTE bSrcLen, bDesLen, bTmp, i;
  WORD wPos, wBsDir;
  DWRD dwSrcAddr, dwDesAddr, dwAddr;
  BYTE bDepth, bDirLvl;


  if (fgMoveUp == TRUE)
  {
    dwSrcAddr = dwMakeDWord(SI_FS_WA_SA_B1);

    bDepth = bReadDRAMTbl(bLoByte(wHiWord(dwSrcAddr)), wLoWord(dwSrcAddr));
    bDepth--;
    WriteDRAMTbl(bLoByte(wHiWord(dwSrcAddr)), wLoWord(dwSrcAddr), bDepth);
    dwSrcAddr++;

    bDirLvl = bReadDRAMTbl(bLoByte(wHiWord(dwSrcAddr)), wLoWord(dwSrcAddr));
    if (bDirLvl == bDepth + 1)
    {
      bDirLvl--;
      WriteDRAMTbl(bLoByte(wHiWord(dwSrcAddr)), wLoWord(dwSrcAddr), bDirLvl);
    }
    dwSrcAddr++;

    dwDesAddr = dwSrcAddr;

    bSrcLen = bReadDRAMTbl(bLoByte(wHiWord(dwSrcAddr)), wLoWord(dwSrcAddr));
    dwSrcAddr += bSrcLen;

    dwSrcAddr--;
    bSrcLen--;
    while ((bReadDRAMTbl(bLoByte(wHiWord(dwSrcAddr)), wLoWord(dwSrcAddr)) != '\\') && (bSrcLen > 1))
    {
      bSrcLen--;
      dwSrcAddr--;
    }
    WriteDRAMTbl(bLoByte(wHiWord(dwDesAddr)), wLoWord(dwDesAddr), bSrcLen);
  }
  else
  {
    wPos = FL_ITEM_FIELD(bItem);

    dwDesAddr = dwMakeDWord(SI_FS_WA_SA_B1);
    dwSrcAddr = dwMakeDWord(wPos);

    bDepth = bReadDRAMTbl(bLoByte(wHiWord(dwDesAddr)), wLoWord(dwDesAddr));
    bDepth++;
    WriteDRAMTbl(bLoByte(wHiWord(dwDesAddr)), wLoWord(dwDesAddr), bDepth);
    dwDesAddr++;

    bDirLvl = bReadDRAMTbl(bLoByte(wHiWord(dwDesAddr)), wLoWord(dwDesAddr));
    dwAddr = dwDesAddr;
    dwDesAddr++;

    bSrcLen = bSharedInfo(FL_ITEM_FIELD(bItem) + 4);
    bDesLen = bReadDRAMTbl(bLoByte(wHiWord(dwDesAddr)), wLoWord(dwDesAddr));

    if (bSrcLen + 1 + bDesLen < FLMN_MAX_WA_SIZE - 2)
    {
      bDirLvl++;
      WriteDRAMTbl(bLoByte(wHiWord(dwAddr)), wLoWord(dwAddr), bDirLvl);

      WriteDRAMTbl(bLoByte(wHiWord(dwDesAddr)), wLoWord(dwDesAddr), bSrcLen + 1 + bDesLen);

      dwDesAddr += (bDesLen + 1);

      i=0;
      while (i < bSrcLen)
      {
        bTmp = bReadDRAMTbl(bLoByte(wHiWord(dwSrcAddr)), wLoWord(dwSrcAddr));
  //#ifdef FLMN_DONT_SHOW_NONPRINTABLE_CHAR
  #if 0
        if ((bTmp < 0x20) || (bTmp > 0x7E))
        {
          bTmp = '_';
        }
  #endif
        WriteDRAMTbl(bLoByte(wHiWord(dwDesAddr)), wLoWord(dwDesAddr), bTmp);
        dwSrcAddr++;
        dwDesAddr++;
        i++;
      }
      WriteDRAMTbl(bLoByte(wHiWord(dwDesAddr)), wLoWord(dwDesAddr), '\\');
    }
  }

  return;
}

////////////////////////////////////////////////////////////////////////////////
//
// Info Panel
//

static void vFlMnDrawInfoPanel(BYTE bPanel) large
{
  switch(bPanel)
  {
    case IP_STATE_PANEL_1:
      vFlIpShowInfo(IP_INFO_EQ, 0, 0);
      vFlIpClearInfoArea(IP_INFO_PANEL_2);
      vFlIpShowInfo(IP_INFO_VOLUME, bAdspCurrVol(),
                    (fgIsMute() ? FLIP_VOLUME_MUTE_ON : FLIP_VOLUME_REDRAW));
      vFlIpShowInfo(IP_INFO_PBC, 0, 0);
              vFlIpShowInfo(IP_INFO_USR_AUX_CTRL, bSharedInfo(SI_USR_AUX_CTRL), 0);
      if (bS