开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > MTK > 查看源码
EbookFramework.c
资源名称：mmi.rar　[点击查看]
上传用户：lqx1163
上传日期：2014-08-13
资源大小：9183k
文件大小：303k
源码类别：

MTK

开发平台：

C/C++

EbookFramework.c：源码内容
  1.  *  img_buff_p          [IN]        
  2.  *  str_img_mask        [IN]        
  3.  * RETURNS
  4.  *  void
  5.  *****************************************************************************/
  6. pBOOL ebr_get_book_mark_name_list(S32 item_index, UI_string_type str_buff, PU8 *img_buff_p, U8 str_img_mask)
  7. {
  8.     /*----------------------------------------------------------------*/
  9.     /* Local Variables                                                */
  10.     /*----------------------------------------------------------------*/
  12.     /*----------------------------------------------------------------*/
  13.     /* Code Body                                                      */
  14.     /*----------------------------------------------------------------*/
  15.     pfnUnicodeStrcpy(
  16.         (S8*) str_buff,
  17.         (S8*) g_curr_book_cntx_p->g_nfo_book_struct.book_marks[item_index].bookmark_name);
  18.     *img_buff_p = get_image(gIndexIconsImageList[item_index]);
  19.     return TRUE;
  20. }
  23. /*****************************************************************************
  24.  * FUNCTION
  25.  *  ebr_frm_get_count_of_book_marks
  26.  * DESCRIPTION
  27.  *  Count the number of book marks present
  28.  * PARAMETERS
  29.  *  void
  30.  * RETURNS
  31.  *  S16
  32.  *****************************************************************************/
  33. S16 ebr_frm_get_count_of_book_marks(void)
  34. {
  35.     /*----------------------------------------------------------------*/
  36.     /* Local Variables                                                */
  37.     /*----------------------------------------------------------------*/
  38.     S16 no_of_book_marks = 0;
  40.     /*----------------------------------------------------------------*/
  41.     /* Code Body                                                      */
  42.     /*----------------------------------------------------------------*/
  43.     while (g_curr_book_cntx_p->g_nfo_book_struct.book_marks[no_of_book_marks].bookmark_name[0] != 0 && (no_of_book_marks<EBR_FRM_MAX_NO_OF_BOOKMARKS))
  44.     {
  45.         no_of_book_marks++;
  46.     }
  47.     return no_of_book_marks;
  48. }
  51. /*****************************************************************************
  52.  * FUNCTION
  53.  *  ebr_frm_get_full_screen_flag_status
  54.  * DESCRIPTION
  55.  *  Get the status of full screen flag
  56.  * PARAMETERS
  57.  *  void
  58.  * RETURNS
  59.  *  S16
  60.  *****************************************************************************/
  61. S16 ebr_frm_get_full_screen_flag_status(void)
  62. {
  63.     /*----------------------------------------------------------------*/
  64.     /* Local Variables                                                */
  65.     /*----------------------------------------------------------------*/
  67.     /*----------------------------------------------------------------*/
  68.     /* Code Body                                                      */
  69.     /*----------------------------------------------------------------*/
  70.     if (g_curr_book_cntx_p->g_nfo_book_struct.settings.screen_mode == 0)
  71.     {
  72.         return 0;
  73.     }
  74.     else
  75.     {
  76.         return 1;
  77.     }
  78. }
  82. /*****************************************************************************
  83.  * FUNCTION
  84.  *  ebr_frm_get_auto_scroll_flag_status
  85.  * DESCRIPTION
  86.  *  Get the status of full screen flag
  87.  * PARAMETERS
  88.  *  void
  89.  * RETURNS
  90.  *  S16
  91.  *****************************************************************************/
  92. S16 ebr_frm_get_auto_scroll_flag_status(void)
  93. {
  94.     /*----------------------------------------------------------------*/
  95.     /* Local Variables                                                */
  96.     /*----------------------------------------------------------------*/
  98.     /*----------------------------------------------------------------*/
  99.     /* Code Body                                                      */
  100.     /*----------------------------------------------------------------*/
  101.     if (g_curr_book_cntx_p->g_nfo_book_struct.settings.auto_scroll_settings.scroll_flag == 0)
  102.     {
  103.         return 0;
  104.     }
  105.     else
  106.     {
  107.         return 1;
  108.     }
  109. }
  113. /*****************************************************************************
  114.  * FUNCTION
  115.  *  ebr_frm_create_new_file_path
  116.  * DESCRIPTION
  117.  *  
  118.  * PARAMETERS
  119.  *  void
  120.  * RETURNS
  121.  *  void
  122.  *****************************************************************************/
  123. void ebr_frm_create_new_file_path(void)
  124. {
  125.     /*----------------------------------------------------------------*/
  126.     /* Local Variables                                                */
  127.     /*----------------------------------------------------------------*/
  129.     /*----------------------------------------------------------------*/
  130.     /* Code Body                                                      */
  131.     /*----------------------------------------------------------------*/
  132.     memset(g_curr_book_cntx_p->fmgr_file_path, 0, sizeof(g_curr_book_cntx_p->fmgr_file_path));
  134.     pfnUnicodeStrcpy(
  135.             (S8*) g_curr_book_cntx_p->fmgr_file_path,
  136.             (S8*) ebr_frm_get_file_path(g_curr_book_cntx_p->memory_type_selected, EBR_FRM_SEARCH_DEFAULT));
  137. }
  140. /*****************************************************************************
  141.  * FUNCTION
  142.  *  ebr_fmgr_is_book_shelf_path
  143.  * DESCRIPTION
  144.  *  Check whetther the path is for bookshelf
  145.  * PARAMETERS
  146.  *  path        [IN]        
  147.  * RETURNS
  148.  *  S32
  149.  *****************************************************************************/
  150. S32 ebr_fmgr_is_book_shelf_path(PS8 path)
  151. {
  152.     /*----------------------------------------------------------------*/
  153.     /* Local Variables                                                */
  154.     /*----------------------------------------------------------------*/
  155.     U8 nfo_path[MAX_DWNL_EBK_PATH_LEN * ENCODING_LENGTH] = {0};
  157.     U32 driveCount = 0;
  158.     S8 driveLatter[FMGR_TOTAL_STORAGE];    
  159.     U8 driveNum;
  160.     /*----------------------------------------------------------------*/
  161.     /* Code Body                                                      */
  162.     /*----------------------------------------------------------------*/
  163.     
  164.     memset(driveLatter, 0, FMGR_TOTAL_STORAGE);
  165.     mmi_fmgr_get_exist_drive_letter(driveLatter, &driveNum);
  166.         
  167.     while (driveLatter[driveCount] != 0)
  168.     {
  169.         pfnUnicodeStrcpy((S8*) nfo_path, (S8*) ebr_frm_get_file_path(driveLatter[driveCount], EBR_FRM_SEARCH_DEFAULT));
  170.         ebr_frm_convert_to_upper((S16*) nfo_path);
  171.         ebr_frm_convert_to_upper((S16*) path);    
  172.         if (!pfnUnicodeStrcmp((S8*) nfo_path, (S8*) path))
  173.         {
  174.      g_curr_book_cntx_p->memory_type_selected = driveLatter[driveCount];
  175.             return driveLatter[driveCount];             
  176.         }
  177. driveCount++;
  178.     }
  179.     return -1;
  180.         
  181. }
  186. /*****************************************************************************
  187.  * FUNCTION
  188.  *  ebr_fmgr_get_file_name
  189.  * DESCRIPTION
  190.  *  
  191.  * PARAMETERS
  192.  *  void
  193.  * RETURNS
  194.  *  
  195.  *****************************************************************************/
  196. S8 *ebr_fmgr_get_file_name(void)
  197. {
  198.     /*----------------------------------------------------------------*/
  199.     /* Local Variables                                                */
  200.     /*----------------------------------------------------------------*/
  202.     /*----------------------------------------------------------------*/
  203.     /* Code Body                                                      */
  204.     /*----------------------------------------------------------------*/
  205.     return (S8*) g_curr_book_cntx_p->book_name_path;
  206. }
  209. /*****************************************************************************
  210.  * FUNCTION
  211.  *  ebr_fmgr_set_file_type
  212.  * DESCRIPTION
  213.  *  Set the file type
  214.  * PARAMETERS
  215.  *  file_name       [IN]        
  216.  *  type        [IN]        
  217.  * RETURNS
  218.  *  void
  219.  *****************************************************************************/
  220. void ebr_fmgr_set_file_type(S8 *file_name)
  221. {
  222.     /*----------------------------------------------------------------*/
  223.     /* Local Variables                                                */
  224.     /*----------------------------------------------------------------*/
  225.     S16 strlen_file_name = 0;
  227.     /*----------------------------------------------------------------*/
  228.     /* Code Body                                                      */
  229.     /*----------------------------------------------------------------*/
  230.     strlen_file_name = pfnUnicodeStrlen((const S8*)file_name);
  231.     if ((g_curr_book_cntx_p->nfo_name[strlen_file_name * 2 - 6] == 't') ||
  232.         (g_curr_book_cntx_p->nfo_name[strlen_file_name * 2 - 6] == 'T'))
  233.     {
  234.         g_curr_book_cntx_p->g_fmgr_book_type = EBR_FRM_FILE_TYPE_TXT;
  235.     }
  236.     else
  237.     {
  238.         g_curr_book_cntx_p->g_fmgr_book_type = EBR_FRM_FILE_TYPE_PDB;
  239.     }
  240. }
  243. /*****************************************************************************
  244.  * FUNCTION
  245.  *  ebr_fmgr_set_file_name
  246.  * DESCRIPTION
  247.  *  Sets the File name for File manager
  248.  * PARAMETERS
  249.  *  fmgr_file_name      [IN]        
  250.  * RETURNS
  251.  *  void
  252.  *****************************************************************************/
  253. void ebr_fmgr_set_file_name(PS8 fmgr_file_name)
  254. {
  255.     /*----------------------------------------------------------------*/
  256.     /* Local Variables                                                */
  257.     /*----------------------------------------------------------------*/
  259.     /*----------------------------------------------------------------*/
  260.     /* Code Body                                                      */
  261.     /*----------------------------------------------------------------*/
  262.     pfnUnicodeStrcpy((S8*) g_curr_book_cntx_p->book_name_path, (S8*) fmgr_file_name);
  263. }
  266. /*****************************************************************************
  267.  * FUNCTION
  268.  *  ebr_set_selected_file_name
  269.  * DESCRIPTION
  270.  *  Gets the name of the selected book
  271.  * PARAMETERS
  272.  *  file_info       [IN]        
  273.  * RETURNS
  274.  *  void
  275.  *****************************************************************************/
  276. void ebr_set_selected_file_name(FMGR_FILE_INFO_STRUCT *file_info)
  277. {
  278.     /*----------------------------------------------------------------*/
  279.     /* Local Variables                                                */
  280.     /*----------------------------------------------------------------*/
  281.     U8 tmp_path_buf[(FMGR_MAX_PATH_LEN + 1) * ENCODING_LENGTH];
  282.     
  283.     /*----------------------------------------------------------------*/
  284.     /* Code Body                                                      */
  285.     /*----------------------------------------------------------------*/
  286.     if (file_info->is_short)
  287.     {
  288.         memset(tmp_path_buf, 0, (FMGR_MAX_PATH_LEN + 1) * ENCODING_LENGTH);
  289.         mmi_chset_mixed_text_to_ucs2_str(
  290.                     (U8*) tmp_path_buf,
  291.                     (FMGR_MAX_PATH_LEN + 1) * ENCODING_LENGTH,
  292.                     (U8*) file_info->file_name,
  293.                     g_chset_text_encoding);
  294.         pfnUnicodeStrcpy((S8*) g_curr_book_cntx_p->nfo_name, (S8*) tmp_path_buf);
  295.     }
  296.     else
  297.     {
  298.         pfnUnicodeStrcpy((S8*) g_curr_book_cntx_p->nfo_name, (S8*) file_info->file_name);
  299.     }
  301. }
  304. /*****************************************************************************
  305.  * FUNCTION
  306.  *  ebr_get_selected_file_name
  307.  * DESCRIPTION
  308.  *  Gets the name of the selected book
  309.  * PARAMETERS
  310.  *  void
  311.  * RETURNS
  312.  *  S8*
  313.  *****************************************************************************/
  314. U8 *ebr_get_selected_file_name(void)
  315. {
  316.     /*----------------------------------------------------------------*/
  317.     /* Local Variables                                                */
  318.     /*----------------------------------------------------------------*/
  320.     /*----------------------------------------------------------------*/
  321.     /* Code Body                                                      */
  322.     /*----------------------------------------------------------------*/
  323.     return (U8*) g_curr_book_cntx_p->nfo_name;
  324. }
  327. /*****************************************************************************
  328.  * FUNCTION
  329.  *  ebr_frm_get_book_size
  330.  * DESCRIPTION
  331.  *  Gets the Size of the ebook
  332.  * PARAMETERS
  333.  *  void
  334.  * RETURNS
  335.  *  S8*
  336.  *****************************************************************************/
  337. S32 ebr_frm_get_book_size(void)
  338. {
  339.     /*----------------------------------------------------------------*/
  340.     /* Local Variables                                                */
  341.     /*----------------------------------------------------------------*/
  342.     FILE_HANDLE file_hnd;
  343.     U32 file_size;
  345.     /*----------------------------------------------------------------*/
  346.     /* Code Body                                                      */
  347.     /*----------------------------------------------------------------*/
  348.     ebr_frm_create_book_path();
  349.     file_hnd = FS_Open((const WCHAR*)g_curr_book_cntx_p->book_name_path, FS_READ_ONLY);
  350.     FS_GetFileSize(file_hnd, (U32*) & file_size);
  351.     FS_Close(file_hnd);
  352.     return file_size;
  353. }
  356. /*****************************************************************************
  357.  * FUNCTION
  358.  *  ebr_frm_create_book_path
  359.  * DESCRIPTION
  360.  *  
  361.  * PARAMETERS
  362.  *  void
  363.  * RETURNS
  364.  *  void
  365.  *****************************************************************************/
  366. void ebr_frm_create_book_path(void)
  367. {
  368.     /*----------------------------------------------------------------*/
  369.     /* Local Variables                                                */
  370.     /*----------------------------------------------------------------*/
  372.     /*----------------------------------------------------------------*/
  373.     /* Code Body                                                      */
  374.     /*----------------------------------------------------------------*/
  375.     pfnUnicodeStrcpy(
  376.         (S8*) g_curr_book_cntx_p->book_name_path,
  377.         (S8*) ebr_frm_get_file_path(g_curr_book_cntx_p->memory_type_selected, EBR_FRM_SEARCH_DEFAULT));
  378.     pfnUnicodeStrcat((PS8) g_curr_book_cntx_p->book_name_path, (PS8) g_curr_book_cntx_p->nfo_name);
  379. }
  382. /*****************************************************************************
  383.  * FUNCTION
  384.  *  ebr_frm_get_book_name
  385.  * DESCRIPTION
  386.  *  Gets the Name of the Ebook
  387.  * PARAMETERS
  388.  *  void
  389.  * RETURNS
  390.  *  S8*
  391.  *****************************************************************************/
  392. S8 *ebr_frm_get_book_name(void)
  393. {
  394.     /*----------------------------------------------------------------*/
  395.     /* Local Variables                                                */
  396.     /*----------------------------------------------------------------*/
  398.     /*----------------------------------------------------------------*/
  399.     /* Code Body                                                      */
  400.     /*----------------------------------------------------------------*/
  401.     return (S8*) g_curr_book_cntx_p->nfo_name;
  402. }
  405. /*****************************************************************************
  406.  * FUNCTION
  407.  *  ebr_frm_restore_default_book_shelf_settings
  408.  * DESCRIPTION
  409.  *  Restores the default settings for Book shelf
  410.  * PARAMETERS
  411.  *  void
  412.  * RETURNS
  413.  *  void
  414.  *****************************************************************************/
  415. S32 ebr_frm_restore_default_book_shelf_settings(void)
  416. {
  417.     /*----------------------------------------------------------------*/
  418.     /* Local Variables                                                */
  419.     /*----------------------------------------------------------------*/
  420.     S16 error;
  421.     ebr_frm_setting_struct g_setting;
  422.     ebr_frm_setting_struct *g_setting_list = &g_setting;
  424.     /*----------------------------------------------------------------*/
  425.     /* Code Body                                                      */
  426.     /*----------------------------------------------------------------*/
  427.     ReadRecord(NVRAM_EF_EBOOK_SETTINGS_LID, 1, (void*)(g_setting_list), NVRAM_EF_EBOOK_SETTING_SIZE, &error);
  428. #ifndef MMI_ON_HARDWARE_P
  429.     if (g_setting_list->common_settings.encoding_format == 0xff)
  430.     {
  431.         g_setting_list->common_settings.encoding_format = EBOOK_WESTERN_WINDOWS;
  432.         g_setting_list->common_settings.font_size = EBR_FONT_SIZE_MEDIUM;
  433.         g_setting_list->common_settings.font_style = EBR_FONT_STYLE_NORMAL;
  434.         g_setting_list->memory_type = (S8)MMI_PUBLIC_DRV;
  435.         g_setting_list->common_settings.screen_mode = EBR_FULL_SCREEN_OFF;
  436.         g_setting_list->common_settings.auto_scroll_settings.scroll_flag = EBR_SCROLL_OFF;
  437.         g_setting_list->common_settings.auto_scroll_settings.scroll_speed = EBR_AUTO_SCROLL_SPEED_1;
  438.         g_setting_list->common_settings.auto_scroll_settings.scroll_type = EBR_SCROLL_BY_PAGE;
  439.     }
  440.     WriteRecord(NVRAM_EF_EBOOK_SETTINGS_LID, 1, (void*)(g_setting_list), NVRAM_EF_EBOOK_SETTING_SIZE, &error);
  441. #endif /* MMI_ON_HARDWARE_P */ 
  442.     /* ebr_app_display_pop_up_default_settings_restored(); */
  443.     ebr_frm_restore_default_settings_for_each_book(g_setting_list);
  444.     return 1;
  445. }
  449. /*****************************************************************************
  450.  * FUNCTION
  451.  *  ebr_frm_restore_default_nvram
  452.  * DESCRIPTION
  453.  *  Restores Factory Default
  454.  * PARAMETERS
  455.  *  void
  456.  * RETURNS
  457.  *  void
  458.  *****************************************************************************/
  459. void ebr_frm_restore_default_nvram(void)
  460. {
  461.     /*----------------------------------------------------------------*/
  462.     /* Local Variables                                                */
  463.     /*----------------------------------------------------------------*/
  464.     S16 error;
  465.     ebr_frm_setting_struct g_setting;
  466.     ebr_frm_setting_struct *g_setting_list = &g_setting;
  468.     /*----------------------------------------------------------------*/
  469.     /* Code Body                                                      */
  470.     /*----------------------------------------------------------------*/
  471.     ReadRecord(NVRAM_EF_EBOOK_SETTINGS_LID, 1, (void*)(g_setting_list), NVRAM_EF_EBOOK_SETTING_SIZE, &error);
  472.     g_setting_list->common_settings.encoding_format = EBOOK_WESTERN_WINDOWS;
  473.     g_setting_list->common_settings.font_size = EBR_FONT_SIZE_MEDIUM;
  474.     g_setting_list->common_settings.font_style = EBR_FONT_STYLE_NORMAL;
  475.     g_setting_list->memory_type = (S8)MMI_PUBLIC_DRV;
  476.     g_setting_list->common_settings.screen_mode = EBR_FULL_SCREEN_OFF;
  477.     g_setting_list->common_settings.auto_scroll_settings.scroll_flag = EBR_SCROLL_OFF;
  478.     g_setting_list->common_settings.auto_scroll_settings.scroll_speed = EBR_AUTO_SCROLL_SPEED_1;
  479.     g_setting_list->common_settings.auto_scroll_settings.scroll_type = EBR_SCROLL_BY_PAGE;
  480.     WriteRecord(NVRAM_EF_EBOOK_SETTINGS_LID, 1, (void*)(g_setting_list), NVRAM_EF_EBOOK_SETTING_SIZE, &error);
  481. }
  485. /*****************************************************************************
  486.  * FUNCTION
  487.  *  ebr_frm_restore_default_settings_for_each_book
  488.  * DESCRIPTION
  489.  *  Restores the default settings for Book shelf
  490.  * PARAMETERS
  491.  *  g_setting_list      [IN]        
  492.  * RETURNS
  493.  *  void
  494.  *****************************************************************************/
  495. void ebr_frm_restore_default_settings_for_each_book(ebr_frm_setting_struct *g_setting_list)
  496. {
  497.     /*----------------------------------------------------------------*/
  498.     /* Local Variables                                                */
  499.     /*----------------------------------------------------------------*/
  501.     FS_HANDLE fh_cur;
  502.     FS_DOSDirEntry file_info;
  503.     S8 path[MAX_DWNL_EBK_PATH_LEN * ENCODING_LENGTH];
  504.     U8 filename[MAX_EBOOK_NAME_LENGTH * ENCODING_LENGTH];
  505.     U32 driveCount = 0;
  506.     S8 driveLatter[FMGR_TOTAL_STORAGE];
  507.     U8 driveNum;
  508.     
  510.     /*----------------------------------------------------------------*/
  511.     /* Code Body                                                      */
  512.     /*----------------------------------------------------------------*/
  513.     memset(driveLatter, 0, FMGR_TOTAL_STORAGE);
  514.     mmi_fmgr_get_exist_drive_letter(driveLatter, &driveNum);
  515.     
  516.     while (driveLatter[driveCount] != 0)
  517.     {
  518.         g_curr_book_cntx_p->memory_type_selected = driveLatter[driveCount];
  519.         pfnUnicodeStrcpy(
  520.             (S8*) path,
  521.             (S8*) ebr_frm_get_file_path(g_curr_book_cntx_p->memory_type_selected, EBR_FRM_SEARCH_NFO));
  523.         if ((fh_cur = FS_FindFirst(
  524.                         (const WCHAR*)path,
  525.                         0,
  526.                         0,
  527.                         &file_info,
  528.                         (U16*) filename,
  529.                         MAX_EBOOK_NAME_LENGTH * ENCODING_LENGTH)) >= 0)
  530.         {
  531.             do
  532.             {
  533.                 if (!(file_info.Attributes & FS_ATTR_DIR))
  534.                 {
  535.                     ebr_frm_open_nfo_file_and_restore_default(
  536.                         g_curr_book_cntx_p->memory_type_selected,
  537.                         filename,
  538.                         g_setting_list);
  539.                 }
  540.             } while ((FS_FindNext(fh_cur, &file_info, (U16*) filename, MAX_EBOOK_NAME_LENGTH * ENCODING_LENGTH) ==
  541.                       FS_NO_ERROR));
  542.             FS_FindClose(fh_cur);
  543.         }
  544.         driveCount++;
  545.     }
  546. }
  549. /*****************************************************************************
  550.  * FUNCTION
  551.  *  ebr_frm_open_nfo_file_and_restore_default
  552.  * DESCRIPTION
  553.  *  Restores the default settings for each book
  554.  * PARAMETERS
  555.  *  memory_type_selected        [IN]        
  556.  *  filename                    [IN]        
  557.  *  g_setting_list              [IN]        
  558.  * RETURNS
  559.  *  void
  560.  *****************************************************************************/
  561. void ebr_frm_open_nfo_file_and_restore_default(
  562.         S32 memory_type_selected,
  563.         U8 *filename,
  564.         ebr_frm_setting_struct *g_setting_list)
  565. {
  566.     /*----------------------------------------------------------------*/
  567.     /* Local Variables                                                */
  568.     /*----------------------------------------------------------------*/
  569.     FILE_HANDLE nfo_hnd;
  570.     S8 path[MAX_DWNL_EBK_PATH_LEN * ENCODING_LENGTH];
  571.     U32 size;
  572.     S32 retval;
  574.     /*----------------------------------------------------------------*/
  575.     /* Code Body                                                      */
  576.     /*----------------------------------------------------------------*/
  577.     pfnUnicodeStrcpy((S8*) path, (S8*) ebr_frm_get_file_path(memory_type_selected, EBR_FRM_SEARCH_DEFAULT));
  578.     pfnUnicodeStrcat((S8*) path, (S8*) filename);
  580.     nfo_hnd = FS_Open((const WCHAR*)path, FS_READ_WRITE);
  581.     if (nfo_hnd > 0)
  582.     {
  583.         FS_Read(nfo_hnd, &g_curr_book_cntx_p->g_nfo_book_struct, sizeof(g_curr_book_cntx_p->g_nfo_book_struct), &size);
  584.         g_curr_book_cntx_p->g_nfo_book_struct.settings.font_size = g_setting_list->common_settings.font_size;
  585.         g_curr_book_cntx_p->g_nfo_book_struct.settings.font_style = g_setting_list->common_settings.font_style;
  586.         g_curr_book_cntx_p->g_nfo_book_struct.settings.screen_mode = g_setting_list->common_settings.screen_mode;
  587.         g_curr_book_cntx_p->g_nfo_book_struct.settings.encoding_format =
  588.             g_setting_list->common_settings.encoding_format;
  589.         g_curr_book_cntx_p->g_nfo_book_struct.settings.auto_scroll_settings.scroll_flag =
  590.             g_setting_list->common_settings.auto_scroll_settings.scroll_flag;
  591.         g_curr_book_cntx_p->g_nfo_book_struct.settings.auto_scroll_settings.scroll_speed =
  592.             g_setting_list->common_settings.auto_scroll_settings.scroll_speed;
  593.         g_curr_book_cntx_p->g_nfo_book_struct.settings.auto_scroll_settings.scroll_type =
  594.             g_setting_list->common_settings.auto_scroll_settings.scroll_type;
  596.         FS_Seek(nfo_hnd, 0, FS_FILE_BEGIN);
  597.         retval = FS_Write(
  598.                     nfo_hnd,
  599.                     &g_curr_book_cntx_p->g_nfo_book_struct,
  600.                     sizeof(g_curr_book_cntx_p->g_nfo_book_struct),
  601.                     &size);
  602.         FS_Close(nfo_hnd);
  603.     }
  604. }
  607. /*****************************************************************************
  608.  * FUNCTION
  609.  *  ebr_frm_delete_all_from_book_shelf
  610.  * DESCRIPTION
  611.  *  Delete all books from Book Shelf
  612.  * PARAMETERS
  613.  *  void
  614.  * RETURNS
  615.  *  void
  616.  *****************************************************************************/
  617. void ebr_frm_delete_all_from_book_shelf(void)
  618. {
  619.     /*----------------------------------------------------------------*/
  620.     /* Local Variables                                                */
  621.     /*----------------------------------------------------------------*/
  622.     FS_HANDLE fh_cur;
  623.     FS_DOSDirEntry file_info;
  624.     S8 path[MAX_DWNL_EBK_PATH_LEN * ENCODING_LENGTH];
  625.     S8 ebook_path[MAX_DWNL_EBK_PATH_LEN * ENCODING_LENGTH];
  626.     WCHAR filename[MAX_EBOOK_NAME_LENGTH * ENCODING_LENGTH];
  627.     S16 retval;
  629.     /*----------------------------------------------------------------*/
  630.     /* Code Body                                                      */
  631.     /*----------------------------------------------------------------*/
  632.     pfnUnicodeStrcpy(
  633.         (S8*) path,
  634.         (S8*) ebr_frm_get_file_path(g_curr_book_cntx_p->memory_type_selected, EBR_FRM_SEARCH_NFO));
  635.     if ((fh_cur = FS_FindFirst(
  636.                     (const WCHAR*)path,
  637.                     0,
  638.                     0,
  639.                     &file_info,
  640.                     (U16*) filename,
  641.                     MAX_EBOOK_NAME_LENGTH * ENCODING_LENGTH)) >= 0)
  642.     {
  643.         do
  644.         {
  645.             if (!(file_info.Attributes & FS_ATTR_DIR))
  646.             {
  647.                 pfnUnicodeStrcpy(
  648.                     (S8*) ebook_path,
  649.                     (S8*) ebr_frm_get_file_path(g_curr_book_cntx_p->memory_type_selected, EBR_FRM_SEARCH_DEFAULT));
  650.                 pfnUnicodeStrcat((S8*) ebook_path, (S8*) filename);
  651.                 retval = FS_Delete((const WCHAR*)ebook_path);
  652.             }
  654.         } while ((FS_FindNext(fh_cur, &file_info, (U16*) filename, MAX_EBOOK_NAME_LENGTH * ENCODING_LENGTH) ==
  655.                   FS_NO_ERROR));
  656.         FS_FindClose(fh_cur);
  657.     }
  658.     pfnUnicodeStrcpy(
  659.         (S8*) path,
  660.         (S8*) ebr_frm_get_file_path(g_curr_book_cntx_p->memory_type_selected, EBR_FRM_SEARCH_PDB));
  661.     if ((fh_cur = FS_FindFirst(
  662.                     (const WCHAR*)path,
  663.                     0,
  664.                     0,
  665.                     &file_info,
  666.                     (U16*) filename,
  667.                     MAX_EBOOK_NAME_LENGTH * ENCODING_LENGTH)) >= 0)
  668.     {
  670.         do
  671.         {
  672.             if (!(file_info.Attributes & FS_ATTR_DIR))
  673.             {
  674.                 pfnUnicodeStrcpy(
  675.                     (S8*) ebook_path,
  676.                     (S8*) ebr_frm_get_file_path(g_curr_book_cntx_p->memory_type_selected, EBR_FRM_SEARCH_DEFAULT));
  677.                 pfnUnicodeStrcat((S8*) ebook_path, (S8*) filename);
  678.                 retval = FS_Delete((const WCHAR*)ebook_path);
  679.             }
  681.         } while ((FS_FindNext(fh_cur, &file_info, (U16*) filename, MAX_EBOOK_NAME_LENGTH * ENCODING_LENGTH) ==
  682.                   FS_NO_ERROR));
  683.         FS_FindClose(fh_cur);
  684.     }
  685.     pfnUnicodeStrcpy(
  686.         (S8*) path,
  687.         (S8*) ebr_frm_get_file_path(g_curr_book_cntx_p->memory_type_selected, EBR_FRM_SEARCH_TXT));
  688.     if ((fh_cur = FS_FindFirst(
  689.                     (const WCHAR*)path,
  690.                     0,
  691.                     0,
  692.                     &file_info,
  693.                     (U16*) filename,
  694.                     MAX_EBOOK_NAME_LENGTH * ENCODING_LENGTH)) >= 0)
  695.     {
  697.         do
  698.         {
  699.             if (!(file_info.Attributes & FS_ATTR_DIR))
  700.             {
  701.                 pfnUnicodeStrcpy(
  702.                     (S8*) ebook_path,
  703.                     (S8*) ebr_frm_get_file_path(g_curr_book_cntx_p->memory_type_selected, EBR_FRM_SEARCH_DEFAULT));
  704.                 pfnUnicodeStrcat((S8*) ebook_path, (S8*) filename);
  705.                 retval = FS_Delete((const WCHAR*)ebook_path);
  706.             }
  708.         } while ((FS_FindNext(fh_cur, &file_info, (U16*) filename, MAX_EBOOK_NAME_LENGTH * ENCODING_LENGTH) ==
  709.                   FS_NO_ERROR));
  710.         FS_FindClose(fh_cur);
  711.     }
  712. }
  715. /*****************************************************************************
  716.  * FUNCTION
  717.  *  ebr_frm_restore_default_book_settings
  718.  * DESCRIPTION
  719.  *  Restore default settings for Book
  720.  * PARAMETERS
  721.  *  void
  722.  * RETURNS
  723.  *  void
  724.  *****************************************************************************/
  725. S32 ebr_frm_restore_default_book_settings(void)
  726. {
  727.     /*----------------------------------------------------------------*/
  728.     /* Local Variables                                                */
  729.     /*----------------------------------------------------------------*/
  730.     S16 error;
  731.     S16 retval;
  732.     U32 size;
  733.     FILE_HANDLE nfo_hnd_local;
  734.     ebr_frm_setting_struct g_setting;
  735.     ebr_frm_setting_struct *g_setting_list = &g_setting;
  737.     /*----------------------------------------------------------------*/
  738.     /* Code Body                                                      */
  739.     /*----------------------------------------------------------------*/
  740.     nfo_hnd_local = ebr_frm_get_nfo_handle();
  741.     if (nfo_hnd_local <= 0)
  742.     {
  743.         FS_Close(nfo_hnd_local);
  744.         return 0;
  745.     }
  746.     ReadRecord(NVRAM_EF_EBOOK_SETTINGS_LID, 1, (void*)(g_setting_list), NVRAM_EF_EBOOK_SETTING_SIZE, &error);
  747.     g_curr_book_cntx_p->g_nfo_book_struct.settings = g_setting_list->common_settings;
  748.     FS_Seek(nfo_hnd_local, 0, FS_FILE_BEGIN);
  749.     retval = FS_Write(
  750.                 nfo_hnd_local,
  751.                 &g_curr_book_cntx_p->g_nfo_book_struct,
  752.                 sizeof(g_curr_book_cntx_p->g_nfo_book_struct),
  753.                 &size);
  754.     FS_Close(nfo_hnd_local);
  755.     return !retval;
  756. }
  759. /*****************************************************************************
  760.  * FUNCTION
  761.  *  ebr_frm_get_memory_type_selected
  762.  * DESCRIPTION
  763.  *  Get memory type selected
  764.  * PARAMETERS
  765.  *  void
  766.  * RETURNS
  767.  *  ebr_memory_type_enum
  768.  *****************************************************************************/
  769. ebr_memory_type_enum ebr_frm_get_memory_type_selected(void)
  770. {
  771.     /*----------------------------------------------------------------*/
  772.     /* Local Variables                                                */
  773.     /*----------------------------------------------------------------*/
  774.     ebr_frm_setting_struct g_setting;
  775.     ebr_frm_setting_struct *g_setting_list = &g_setting;
  776.     S16 error;
  777. MMI_BOOL status;
  778.         
  779.     /*----------------------------------------------------------------*/
  780.     /* Code Body                                                      */
  781.     /*----------------------------------------------------------------*/
  782. ReadRecord(NVRAM_EF_EBOOK_SETTINGS_LID, 1, (void*)(g_setting_list), NVRAM_EF_EBOOK_SETTING_SIZE, &error);
  783. g_curr_book_cntx_p->memory_type_selected = g_setting_list->memory_type;    
  784. status = mmi_fmgr_is_drive_letter_valid(g_curr_book_cntx_p->memory_type_selected);
  785. if (status && FS_GetDevStatus(g_curr_book_cntx_p->memory_type_selected, FS_MOUNT_STATE_ENUM) == FS_NO_ERROR)
  786. {
  787. return g_curr_book_cntx_p->memory_type_selected;
  788. }
  789. else
  790. {
  791. g_setting_list->memory_type = MMI_PUBLIC_DRV;
  792.         WriteRecord(NVRAM_EF_EBOOK_SETTINGS_LID, 1, (void*)(g_setting_list), NVRAM_EF_EBOOK_SETTING_SIZE, &error);
  793.     }        
  794.     g_curr_book_cntx_p->memory_type_selected = g_setting_list->memory_type;    
  795.     return g_curr_book_cntx_p->memory_type_selected;
  796.     
  797. }
  800. /*****************************************************************************
  801.  * FUNCTION
  802.  *  ebr_frm_fmgr_get_nfo_handle
  803.  * DESCRIPTION
  804.  *  Get nfo handle for File manager
  805.  * PARAMETERS
  806.  *  file_name       [IN]        
  807.  * RETURNS
  808.  *  FILE_HANDLE
  809.  *****************************************************************************/
  810. FILE_HANDLE ebr_frm_fmgr_get_nfo_handle(S8 *file_name)
  811. {
  812.     /*----------------------------------------------------------------*/
  813.     /* Local Variables                                                */
  814.     /*----------------------------------------------------------------*/
  815.     U8 nfo_path[MAX_DWNL_EBK_PATH_LEN * ENCODING_LENGTH] = {0};
  816.     FILE_HANDLE nfo_hnd;
  818.     /*----------------------------------------------------------------*/
  819.     /* Code Body                                                      */
  820.     /*----------------------------------------------------------------*/
  821.     pfnUnicodeStrcpy(
  822.         (S8*) nfo_path,
  823.         (S8*) ebr_frm_get_file_path(g_curr_book_cntx_p->memory_type_selected, EBR_FRM_SEARCH_DEFAULT));
  824.     pfnUnicodeStrcat((S8*) nfo_path, (S8*) file_name);
  825.     nfo_hnd = FS_Open((const WCHAR*)nfo_path, FS_READ_WRITE);
  826.     return nfo_hnd;
  827. }
  830. /*****************************************************************************
  831.  * FUNCTION
  832.  *  ebr_frm_write_default_value_for_nfo_id_in_nvram
  833.  * DESCRIPTION
  834.  *  Write default value for NFO in NVRAM
  835.  * PARAMETERS
  836.  *  void
  837.  * RETURNS
  838.  *  void
  839.  *****************************************************************************/
  840. void ebr_frm_write_default_value_for_nfo_id_in_nvram(void)
  841. {
  842.     /*----------------------------------------------------------------*/
  843.     /* Local Variables                                                */
  844.     /*----------------------------------------------------------------*/
  845.     S16 local_nfo_id = 0;
  846.     S16 error;
  848.     /*----------------------------------------------------------------*/
  849.     /* Code Body                                                      */
  850.     /*----------------------------------------------------------------*/
  851.     WriteValue(NVRAM_EBOOK_NFO_LID, (void*)&local_nfo_id, DS_SHORT, &error);
  852. }
  855. /*****************************************************************************
  856.  * FUNCTION
  857.  *  ebr_fmgr_get_file_name_call_back
  858.  * DESCRIPTION
  859.  *  Get the file name
  860.  * PARAMETERS
  861.  *  fmgr_file_name      [IN]        
  862.  *  file_name           [IN]        
  863.  * RETURNS
  864.  *  void
  865.  *****************************************************************************/
  866. void ebr_fmgr_get_file_name_call_back(S8 *fmgr_file_name, S8 *file_name)
  867. {
  868.     /*----------------------------------------------------------------*/
  869.     /* Local Variables                                                */
  870.     /*----------------------------------------------------------------*/
  871.     S8 nfo_path[MAX_DWNL_EBK_PATH_LEN * ENCODING_LENGTH];
  872.     ebr_frm_book_struct nfo_struct;
  873.     U32 size;
  874.     FILE_HANDLE nfo_hnd;
  876.     /*----------------------------------------------------------------*/
  877.     /* Code Body                                                      */
  878.     /*----------------------------------------------------------------*/
  879.     g_curr_book_cntx_p->memory_type_selected = ebr_get_drive_type();
  880.     pfnUnicodeStrcpy(
  881.         (S8*) nfo_path,
  882.         (S8*) ebr_frm_get_file_path(g_curr_book_cntx_p->memory_type_selected, EBR_FRM_SEARCH_DEFAULT));
  884.     pfnUnicodeStrcat((S8*) nfo_path, fmgr_file_name);
  885.     nfo_hnd = FS_Open((const WCHAR*)nfo_path, FS_READ_ONLY);
  886.     if (nfo_hnd > 0)
  887.     {
  888.         FS_Seek(nfo_hnd, 0, FS_FILE_BEGIN);
  889.         FS_Read(nfo_hnd, &nfo_struct, sizeof(ebr_frm_book_struct), &size);
  890.     }
  892.     FS_Close(nfo_hnd);
  893.     pfnUnicodeStrcpy((S8*) file_name, (S8*) nfo_struct.e_book_name);
  895. }
  898. /*****************************************************************************
  899.  * FUNCTION
  900.  *  ebr_fmgr_get_display_name_call_back
  901.  * DESCRIPTION
  902.  *  Get the display file name
  903.  * PARAMETERS
  904.  *  fmgr_file_name      [IN]        
  905.  *  book_type           [IN]        
  906.  *  file_name           [IN]        
  907.  * RETURNS
  908.  *  void
  909.  *****************************************************************************/
  910. void ebr_fmgr_get_display_name_call_back(S8 *fmgr_file_name, ebr_frm_filetype_enum book_type, S8 *file_name)
  911. {
  912.     /*----------------------------------------------------------------*/
  913.     /* Local Variables                                                */
  914.     /*----------------------------------------------------------------*/
  916.     S8 nfo_path[MAX_DWNL_EBK_PATH_LEN * ENCODING_LENGTH];
  917.     FILE_HANDLE file_hnd;
  919.     /*----------------------------------------------------------------*/
  920.     /* Code Body                                                      */
  921.     /*----------------------------------------------------------------*/
  922.     g_curr_book_cntx_p->memory_type_selected = ebr_get_drive_type();
  923.     pfnUnicodeStrcpy(
  924.         (S8*) nfo_path,
  925.         (S8*) ebr_frm_get_file_path(g_curr_book_cntx_p->memory_type_selected, EBR_FRM_SEARCH_DEFAULT));
  927.     pfnUnicodeStrcat((S8*) nfo_path, fmgr_file_name);
  928.     file_hnd = FS_Open((const WCHAR*)nfo_path, FS_READ_ONLY);
  930.     if (book_type == EBR_FRM_FILE_TYPE_PDB)
  931.     {
  932.         pfnUnicodeStrncpy((S8*) file_name, (S8*) fmgr_file_name, pfnUnicodeStrlen((const S8*)fmgr_file_name) - 4);
  933.     }
  934.     else
  935.     {
  936.         pfnUnicodeStrncpy((S8*) file_name, (S8*) fmgr_file_name, pfnUnicodeStrlen((const S8*)fmgr_file_name) - 4);
  937.     }
  939.     FS_Close(file_hnd);
  941. }
  944. /*****************************************************************************
  945.  * FUNCTION
  946.  *  ebr_fmgr_get_file_size_and_name
  947.  * DESCRIPTION
  948.  *  Get the file name and size
  949.  * PARAMETERS
  950.  *  fmgr_file_name      [IN]        
  951.  * RETURNS
  952.  *  FILE_HANDLE
  953.  *****************************************************************************/
  954. S8 *ebr_fmgr_get_file_size_and_name(S8 *fmgr_file_name)
  955. {
  956.     /*----------------------------------------------------------------*/
  957.     /* Local Variables                                                */
  958.     /*----------------------------------------------------------------*/
  959.     FILE_HANDLE nfo_hnd;
  960.     ebr_frm_book_struct book_struct;
  961.     U32 size;
  963.     /*----------------------------------------------------------------*/
  964.     /* Code Body                                                      */
  965.     /*----------------------------------------------------------------*/
  966.     nfo_hnd = ebr_frm_fmgr_get_nfo_handle(fmgr_file_name);
  967.     FS_Read(nfo_hnd, &book_struct, sizeof(ebr_frm_book_struct), &size);
  968.     FS_Close(nfo_hnd);
  969.     return (S8*) book_struct.e_book_name;
  970. }
  973. /*****************************************************************************
  974.  * FUNCTION
  975.  *  ebr_fmgr_get_file_size
  976.  * DESCRIPTION
  977.  *  Get the file size
  978.  * PARAMETERS
  979.  *  fmgr_file_name      [IN]        
  980.  * RETURNS
  981.  *  FILE_HANDLE
  982.  *****************************************************************************/
  983. U32 ebr_fmgr_get_file_size(S8 *fmgr_file_name)
  984. {
  985.     /*----------------------------------------------------------------*/
  986.     /* Local Variables                                                */
  987.     /*----------------------------------------------------------------*/
  988.     FILE_HANDLE file_hnd;
  989.     U8 file_path[MAX_DWNL_EBK_PATH_LEN * ENCODING_LENGTH];
  990.     U32 size;
  992.     /*----------------------------------------------------------------*/
  993.     /* Code Body                                                      */
  994.     /*----------------------------------------------------------------*/
  995.     pfnUnicodeStrcpy(
  996.         (S8*) file_path,
  997.         (S8*) (ebr_frm_get_file_path(ebr_frm_get_memory_type_selected(), EBR_FRM_SEARCH_DEFAULT)));
  998.     pfnUnicodeStrcat((S8*) file_path, (const S8*)fmgr_file_name);
  999.     file_hnd = FS_Open((const WCHAR*)file_path, FS_READ_ONLY);
  1000.     FS_GetFileSize(file_hnd, &size);
  1001.     FS_Close(file_hnd);
  1002.     return size;
  1003. }
  1006. /*****************************************************************************
  1007.  * FUNCTION
  1008.  *  ebr_frm_fmgr_pre_entry_open_book
  1009.  * DESCRIPTION
  1010.  *  Pre entry function for Open book
  1011.  * PARAMETERS
  1012.  *  file_name       [IN]        
  1013.  *  file_path       [IN]        
  1014.  *  file_ext        [IN]        
  1015.  * RETURNS
  1016.  *  FILE_HANDLE
  1017.  *****************************************************************************/
  1018. S32 ebr_frm_fmgr_pre_entry_open_book(S8 *file_name, S8 *file_path, S8 *file_ext)
  1019. {
  1020.     /*----------------------------------------------------------------*/
  1021.     /* Local Variables                                                */
  1022.     /*----------------------------------------------------------------*/
  1023.     S8 file_extension_name[FMGR_MAX_FILE_LEN * ENCODING_LENGTH];
  1024.     S8 file_extension_name_ansii[FMGR_MAX_FILE_LEN * ENCODING_LENGTH];
  1025.     S32 nfo_id;
  1027.     /*----------------------------------------------------------------*/
  1028.     /* Code Body                                                      */
  1029.     /*----------------------------------------------------------------*/
  1030.     pfnUnicodeStrcat((S8*) file_path, (S8*) file_name);
  1031.     pfnUnicodeStrcpy((S8*) file_extension_name, (S8*) file_ext);
  1032.     ebr_frm_convert_to_upper((S16*) file_extension_name);
  1033.     UnicodeToAnsii((S8*) file_extension_name_ansii, (S8*) file_extension_name);
  1035.     if (mmi_fmgr_is_drive_letter_valid(g_curr_book_cntx_p->memory_type_selected))
  1036.     {
  1037.         if (!strcmp(file_extension_name_ansii, EBR_FILE_TYPE_TXT))
  1038.         {
  1039.             g_curr_book_cntx_p->g_fmgr_book_type = EBR_FRM_FILE_TYPE_TXT;
  1040.             nfo_id = ebr_fmgr_get_nfo_id_for_txt_file(g_curr_book_cntx_p->memory_type_selected, file_name);
  1041.             return nfo_id;
  1042.         }
  1043.         else
  1044.         {
  1045.             g_curr_book_cntx_p->g_fmgr_book_type = EBR_FRM_FILE_TYPE_PDB;
  1046.             nfo_id = ebr_fmgr_get_nfo_id_for_pdb_file(g_curr_book_cntx_p->memory_type_selected, file_name);
  1047.             return nfo_id;
  1048.         }
  1049.     }
  1050.     else
  1051.     {
  1052.         if (!strcmp(file_extension_name_ansii, EBR_FILE_TYPE_TXT))
  1053.         {
  1054.             g_curr_book_cntx_p->g_fmgr_book_type = EBR_FRM_FILE_TYPE_TXT;
  1055.         }
  1056.         else
  1057.         {
  1058.             g_curr_book_cntx_p->g_fmgr_book_type = EBR_FRM_FILE_TYPE_PDB;
  1059.         }
  1060.         return -1;
  1061.     }
  1062. }
  1065. /*****************************************************************************
  1066.  * FUNCTION
  1067.  *  ebr_frm_check_is_ebook_folder_created
  1068.  * DESCRIPTION
  1069.  *  Is Ebook Folder created
  1070.  * PARAMETERS
  1071.  *  void
  1072.  * RETURNS
  1073.  *  void
  1074.  *****************************************************************************/
  1075. void ebr_frm_check_is_ebook_folder_created(void)
  1076. {
  1077.     /*----------------------------------------------------------------*/
  1078.     /* Local Variables                                                */
  1079.     /*----------------------------------------------------------------*/
  1080.     S8 tmp_str[MAX_DWNL_EBK_PATH_LEN];
  1081.     S8 ebook_folder_path[MAX_DWNL_EBK_PATH_LEN * ENCODING_LENGTH];
  1083.     /*----------------------------------------------------------------*/
  1084.     /* Code Body                                                      */
  1085.     /*----------------------------------------------------------------*/
  1086.     sprintf(tmp_str, "%c%s", MMI_CARD_DRV, EBR_DOWNLOADED_EBOOK_PATH);
  1087.     AnsiiToUnicodeString((S8*) ebook_folder_path, (S8*) tmp_str);
  1088.     FS_CreateDir((PU16) ebook_folder_path);
  1089.     sprintf(tmp_str, "%c%s", MMI_PUBLIC_DRV, EBR_DOWNLOADED_EBOOK_PATH);
  1090.     AnsiiToUnicodeString((S8*) ebook_folder_path, (S8*) tmp_str);
  1091.     FS_CreateDir((PU16) ebook_folder_path);
  1093. }
  1095. /*****************************************************************************
  1096.  * FUNCTION
  1097.  *  ebr_frm_init
  1098.  * DESCRIPTION
  1099.  *  
  1100.  * PARAMETERS
  1101.  *  void
  1102.  * RETURNS
  1103.  *  void
  1104.  *****************************************************************************/
  1105. void ebr_frm_init(void)
  1106. {
  1107.     /*----------------------------------------------------------------*/
  1108.     /* Local Variables                                                */
  1109.     /*----------------------------------------------------------------*/
  1111.     /*----------------------------------------------------------------*/
  1112.     /* Code Body                                                      */
  1113.     /*----------------------------------------------------------------*/
  1114.     g_curr_book_cntx_p->state_recursive_conversion = EBR_FRM_NO_CONVERSION;
  1115.     ebr_frm_check_is_ebook_folder_created();
  1116.     ebr_frm_get_memory_type_selected();
  1118. }
  1120. /*****************************************************************************
  1121.  * FUNCTION
  1122.  *  ebr_frm_get_drive_type
  1123.  * DESCRIPTION
  1124.  *  Get drive type
  1125.  * PARAMETERS
  1126.  *  void
  1127.  * RETURNS
  1128.  *  FILE_HANDLE
  1129.  *****************************************************************************/
  1130. ebr_memory_type_enum ebr_frm_get_drive_type(void)
  1131. {
  1132.     /*----------------------------------------------------------------*/
  1133.     /* Local Variables                                                */
  1134.     /*----------------------------------------------------------------*/
  1135.     S16 error;
  1136.     ebr_frm_setting_struct g_setting;
  1137.     ebr_frm_setting_struct *g_setting_list = &g_setting;
  1139.     /*----------------------------------------------------------------*/
  1140.     /* Code Body                                                      */
  1141.     /*----------------------------------------------------------------*/
  1142.     ReadRecord(NVRAM_EF_EBOOK_SETTINGS_LID, 1, (void*)(g_setting_list), NVRAM_EF_EBOOK_SETTING_SIZE, &error);
  1143.     return g_setting_list->memory_type;
  1144. }
  1147. /*****************************************************************************
  1148.  * FUNCTION
  1149.  *  ebr_frm_change_drive_type
  1150.  * DESCRIPTION
  1151.  *  Change the drive type and write in NVRAM
  1152.  * PARAMETERS
  1153.  *  void
  1154.  * RETURNS
  1155.  *  FILE_HANDLE
  1156.  *****************************************************************************/
  1157. S16 ebr_frm_change_drive_type(void)
  1158. {
  1159.     /*----------------------------------------------------------------*/
  1160.     /* Local Variables                                                */
  1161.     /*----------------------------------------------------------------*/
  1162.     S16 error;
  1163.     ebr_frm_setting_struct g_setting;
  1164.     ebr_frm_setting_struct *g_setting_list = &g_setting;
  1166.     /*----------------------------------------------------------------*/
  1167.     /* Code Body                                                      */
  1168.     /*----------------------------------------------------------------*/
  1169.     g_setting_list->memory_type = (U8) g_curr_book_cntx_p->memory_type_selected;
  1170.     WriteRecord(NVRAM_EF_EBOOK_SETTINGS_LID, 1, (void*)(g_setting_list), NVRAM_EF_EBOOK_SETTING_SIZE, &error);
  1171.     return error;
  1172. }
  1175. /*****************************************************************************
  1176.  * FUNCTION
  1177.  *  ebr_frm_get_drive_status
  1178.  * DESCRIPTION
  1179.  *  Get drive status
  1180.  * PARAMETERS
  1181.  *  void
  1182.  * RETURNS
  1183.  *  FILE_HANDLE
  1184.  *****************************************************************************/
  1185. int ebr_frm_get_drive_status(void)
  1186. {
  1187.     /*----------------------------------------------------------------*/
  1188.     /* Local Variables                                                */
  1189.     /*----------------------------------------------------------------*/
  1190.     int drive, status;
  1192.     /*----------------------------------------------------------------*/
  1193.     /* Code Body                                                      */
  1194.     /*----------------------------------------------------------------*/
  1195.     drive = FS_GetDrive(FS_DRIVE_V_REMOVABLE, 1, FS_NO_ALT_DRIVE);
  1196.     status = FS_GetDevStatus(drive, FS_MOUNT_STATE_ENUM);
  1197.     return status;
  1198. }
  1201. /*****************************************************************************
  1202.  * FUNCTION
  1203.  *  gui_paging_reset_auto_scroll
  1204.  * DESCRIPTION
  1205.  *  Reset auto scroll
  1206.  * PARAMETERS
  1207.  *  void
  1208.  * RETURNS
  1209.  *  void
  1210.  *****************************************************************************/
  1211. void gui_paging_reset_auto_scroll(void)
  1212. {
  1213.     /*----------------------------------------------------------------*/
  1214.     /* Local Variables                                                */
  1215.     /*----------------------------------------------------------------*/
  1216.     FILE_HANDLE nfo_hnd;
  1217.     U32 size;
  1218.     int retval;
  1220.     /*----------------------------------------------------------------*/
  1221.     /* Code Body                                                      */
  1222.     /*----------------------------------------------------------------*/
  1223.     nfo_hnd = FS_Open((const WCHAR*)g_curr_book_cntx_p->nfo_path, FS_READ_WRITE);
  1224.     g_curr_book_cntx_p->g_nfo_book_struct.settings.auto_scroll_settings.scroll_flag = 0;
  1225.     FS_Seek(nfo_hnd, 0, FS_FILE_BEGIN);
  1226.     retval = FS_Write(nfo_hnd, &g_curr_book_cntx_p->g_nfo_book_struct, sizeof(g_curr_book_cntx_p->g_nfo_book_struct), &size);
  1227.     retval = FS_Close(nfo_hnd);
  1228. }
  1231. /*****************************************************************************
  1232.  * FUNCTION
  1233.  *  ebr_frm_get_auto_scroll_status
  1234.  * DESCRIPTION
  1235.  *  Get auto scroll status
  1236.  * PARAMETERS
  1237.  *  void
  1238.  * RETURNS
  1239.  *  FILE_HANDLE
  1240.  *****************************************************************************/
  1241. pBOOL ebr_frm_get_auto_scroll_status(void)
  1242. {
  1243.     /*----------------------------------------------------------------*/
  1244.     /* Local Variables                                                */
  1245.     /*----------------------------------------------------------------*/
  1247.     /*----------------------------------------------------------------*/
  1248.     /* Code Body                                                      */
  1249.     /*----------------------------------------------------------------*/
  1250.     if (g_curr_book_cntx_p->g_nfo_book_struct.settings.auto_scroll_settings.scroll_flag == 1)
  1251.     {
  1252.         return FALSE;
  1253.     }
  1254.     else
  1255.     {
  1256.         return TRUE;
  1257.     }
  1258. }
  1261. /*****************************************************************************
  1262.  * FUNCTION
  1263.  *  get_highlight_id_from_nvram
  1264.  * DESCRIPTION
  1265.  *  Get auto scroll status
  1266.  * PARAMETERS
  1267.  *  void
  1268.  * RETURNS
  1269.  *  FILE_HANDLE
  1270.  *****************************************************************************/
  1271. S16 get_highlight_id_from_nvram(void)
  1272. {
  1273.     /*----------------------------------------------------------------*/
  1274.     /* Local Variables                                                */
  1275.     /*----------------------------------------------------------------*/
  1276.     S16 highlight_id = 0;
  1277.     S16 error;
  1279.     /*----------------------------------------------------------------*/
  1280.     /* Code Body                                                      */
  1281.     /*----------------------------------------------------------------*/
  1282.     ReadValue(NVRAM_EBOOK_LAST_HIGHLIGHT_ID, (void*)&highlight_id, DS_SHORT, &error);
  1283.     return highlight_id;
  1284. }
  1287. /*****************************************************************************
  1288.  * FUNCTION
  1289.  *  ebr_frm_set_current_highlight_id
  1290.  * DESCRIPTION
  1291.  *  Get highlight id
  1292.  * PARAMETERS
  1293.  *  index       [IN]        
  1294.  * RETURNS
  1295.  *  void
  1296.  *****************************************************************************/
  1297. void ebr_frm_set_current_highlight_id(S32 index)
  1298. {
  1299.     /*----------------------------------------------------------------*/
  1300.     /* Local Variables                                                */
  1301.     /*----------------------------------------------------------------*/
  1303.     /*----------------------------------------------------------------*/
  1304.     /* Code Body                                                      */
  1305.     /*----------------------------------------------------------------*/
  1306.     g_curr_book_cntx_p->current_highlight_book_id = index;
  1307. }
  1310. /*****************************************************************************
  1311.  * FUNCTION
  1312.  *  ebr_frm_get_book_size_from_nfo
  1313.  * DESCRIPTION
  1314.  *  
  1315.  * PARAMETERS
  1316.  *  void
  1317.  * RETURNS
  1318.  *  
  1319.  *****************************************************************************/
  1320. S32 ebr_frm_get_book_size_from_nfo(void)
  1321. {
  1322.     /*----------------------------------------------------------------*/
  1323.     /* Local Variables                                                */
  1324.     /*----------------------------------------------------------------*/
  1326.     /*----------------------------------------------------------------*/
  1327.     /* Code Body                                                      */
  1328.     /*----------------------------------------------------------------*/
  1329.     return g_curr_book_cntx_p->g_nfo_book_struct.book_size;
  1330. }
  1334. /*****************************************************************************
  1335.  * FUNCTION
  1336.  *  ebr_frm_get_book_temp_size_from_nfo
  1337.  * DESCRIPTION
  1338.  *  
  1339.  * PARAMETERS
  1340.  *  void
  1341.  * RETURNS
  1342.  *  
  1343.  *****************************************************************************/
  1344. S32 ebr_frm_get_book_temp_size_from_nfo(void)
  1345. {
  1346.     /*----------------------------------------------------------------*/
  1347.     /* Local Variables                                                */
  1348.     /*----------------------------------------------------------------*/
  1350.     /*----------------------------------------------------------------*/
  1351.     /* Code Body                                                      */
  1352.     /*----------------------------------------------------------------*/
  1353.     if (g_curr_book_cntx_p->book_is_in_other_encoding_format)
  1354.     {
  1355.         return g_curr_book_cntx_p->g_nfo_book_struct.temp_book_size;
  1356.     }
  1357.     else
  1358.     {
  1359.         return g_curr_book_cntx_p->g_nfo_book_struct.book_size;
  1360.     }
  1361. }
  1365. /*****************************************************************************
  1366.  * FUNCTION
  1367.  *  ebr_frm_get_page_size
  1368.  * DESCRIPTION
  1369.  *  
  1370.  * PARAMETERS
  1371.  *  void
  1372.  * RETURNS
  1373.  *  
  1374.  *****************************************************************************/
  1375. S32 ebr_frm_get_page_size(void)
  1376. {
  1377.     /*----------------------------------------------------------------*/
  1378.     /* Local Variables                                                */
  1379.     /*----------------------------------------------------------------*/
  1381.     /*----------------------------------------------------------------*/
  1382.     /* Code Body                                                      */
  1383.     /*----------------------------------------------------------------*/
  1384.     if (g_curr_book_cntx_p->is_book_in_unicode || g_curr_book_cntx_p->book_is_in_other_encoding_format)
  1385.     {
  1386.         return EBR_PAGE_SIZE * 2;
  1387.     }
  1388.     else
  1389.     {
  1390.         return EBR_PAGE_SIZE;
  1391.     }
  1392. }
  1395. /*****************************************************************************
  1396.  * FUNCTION
  1397.  *  ebr_frm_fmgr_get_nfo_id
  1398.  * DESCRIPTION
  1399.  *  Get nfo id
  1400.  * PARAMETERS
  1401.  *  void
  1402.  * RETURNS
  1403.  *  void
  1404.  *****************************************************************************/
  1405. S32 ebr_frm_fmgr_get_nfo_id(void)
  1406. {
  1407.     /*----------------------------------------------------------------*/
  1408.     /* Local Variables                                                */
  1409.     /*----------------------------------------------------------------*/
  1411.     /*----------------------------------------------------------------*/
  1412.     /* Code Body                                                      */
  1413.     /*----------------------------------------------------------------*/
  1414.     return g_curr_book_cntx_p->nfo_id;
  1415. }
  1418. /*****************************************************************************
  1419.  * FUNCTION
  1420.  *  ebr_frm_fmgr_set_nfo_id
  1421.  * DESCRIPTION
  1422.  *  Set nfo id
  1423.  * PARAMETERS
  1424.  *  local_nfo_id        [IN]        
  1425.  * RETURNS
  1426.  *  void
  1427.  *****************************************************************************/
  1428. void ebr_frm_fmgr_set_nfo_id(S32 local_nfo_id)
  1429. {
  1430.     /*----------------------------------------------------------------*/
  1431.     /* Local Variables                                                */
  1432.     /*----------------------------------------------------------------*/
  1434.     /*----------------------------------------------------------------*/
  1435.     /* Code Body                                                      */
  1436.     /*----------------------------------------------------------------*/
  1437.     g_curr_book_cntx_p->nfo_id = local_nfo_id;
  1438. }
  1441. /*****************************************************************************
  1442.  * FUNCTION
  1443.  *  ebr_fmgr_get_book_type
  1444.  * DESCRIPTION
  1445.  *  Get book type
  1446.  * PARAMETERS
  1447.  *  void
  1448.  * RETURNS
  1449.  *  void
  1450.  *****************************************************************************/
  1451. S16 ebr_fmgr_get_book_type(void)
  1452. {
  1453.     /*----------------------------------------------------------------*/
  1454.     /* Local Variables                                                */
  1455.     /*----------------------------------------------------------------*/
  1457.     /*----------------------------------------------------------------*/
  1458.     /* Code Body                                                      */
  1459.     /*----------------------------------------------------------------*/
  1460.     return g_curr_book_cntx_p->ebr_fmgr_book_type;
  1461. }
  1464. /*****************************************************************************
  1465.  * FUNCTION
  1466.  *  ebr_frm_fmgr_get_application_type
  1467.  * DESCRIPTION
  1468.  *  Get application type
  1469.  * PARAMETERS
  1470.  *  void
  1471.  * RETURNS
  1472.  *  void
  1473.  *****************************************************************************/
  1474. S16 ebr_frm_fmgr_get_application_type(void)
  1475. {
  1476.     /*----------------------------------------------------------------*/
  1477.     /* Local Variables                                                */
  1478.     /*----------------------------------------------------------------*/
  1480.     /*----------------------------------------------------------------*/
  1481.     /* Code Body                                                      */
  1482.     /*----------------------------------------------------------------*/
  1483.     return g_curr_book_cntx_p->src_application;
  1484. }
  1487. /*****************************************************************************
  1488.  * FUNCTION
  1489.  *  ebr_frm_fmgr_set_application_type
  1490.  * DESCRIPTION
  1491.  *  
  1492.  * PARAMETERS
  1493.  *  void
  1494.  * RETURNS
  1495.  *  void
  1496.  *****************************************************************************/
  1497. void ebr_frm_fmgr_set_application_type(void)
  1498. {
  1499.     /*----------------------------------------------------------------*/
  1500.     /* Local Variables                                                */
  1501.     /*----------------------------------------------------------------*/
  1503.     /*----------------------------------------------------------------*/
  1504.     /* Code Body                                                      */
  1505.     /*----------------------------------------------------------------*/
  1506.     g_curr_book_cntx_p->src_application = EBR_FRM_SRC_APP_FMGR;
  1507. }
  1510. /*****************************************************************************
  1511.  * FUNCTION
  1512.  *  ebr_frm_set_src_application_type
  1513.  * DESCRIPTION
  1514.  *  
  1515.  * PARAMETERS
  1516.  *  void
  1517.  * RETURNS
  1518.  *  void
  1519.  *****************************************************************************/
  1520. void ebr_frm_set_src_application_type(void)
  1521. {
  1522.     /*----------------------------------------------------------------*/
  1523.     /* Local Variables                                                */
  1524.     /*----------------------------------------------------------------*/
  1526.     /*----------------------------------------------------------------*/
  1527.     /* Code Body                                                      */
  1528.     /*----------------------------------------------------------------*/
  1529.     memset(g_curr_book_cntx_p->nfo_name, 0, sizeof(g_curr_book_cntx_p->nfo_name));
  1530.     g_curr_book_cntx_p->src_application = EBR_FRM_SRC_APP_EBOOK;
  1531. }
  1534. /*****************************************************************************
  1535.  * FUNCTION
  1536.  *  ebr_frm_check_nfo_file_present
  1537.  * DESCRIPTION
  1538.  *  
  1539.  * PARAMETERS
  1540.  *  nfo_id      [IN]        
  1541.  * RETURNS
  1542.  *  
  1543.  *****************************************************************************/
  1544. S32 ebr_frm_check_nfo_file_present(S32 nfo_id)
  1545. {
  1546.     /*----------------------------------------------------------------*/
  1547.     /* Local Variables                                                */
  1548.     /*----------------------------------------------------------------*/
  1549.     FILE_HANDLE nfo_handle;
  1550.     U32 size;
  1551.     S32 compare_type = 0;
  1553.     /*----------------------------------------------------------------*/
  1554.     /* Code Body                                                      */
  1555.     /*----------------------------------------------------------------*/
  1556.     nfo_handle = ebr_frm_get_nfo_handle();
  1558.     if (nfo_handle > 0)
  1559.     {
  1560.         FS_Read(
  1561.             nfo_handle,
  1562.             &g_curr_book_cntx_p->g_nfo_book_struct,
  1563.             sizeof(g_curr_book_cntx_p->g_nfo_book_struct),
  1564.             &size);
  1565.         FS_Close(nfo_handle);
  1566.         compare_type = pfnUnicodeStrcmp(
  1567.                         (const S8*)g_curr_book_cntx_p->g_nfo_book_struct.e_book_name,
  1568.                         (const S8*)g_curr_book_cntx_p->nfo_name);
  1569.         if (compare_type != 0)
  1570.         {
  1571.             return 0;
  1572.         }
  1573.         else
  1574.         {
  1575.             return nfo_id;
  1576.         }
  1578.     }
  1579.     else
  1580.     {
  1581.         FS_Close(nfo_handle);
  1582.         return 0;
  1583.     }
  1584. }
  1587. /*****************************************************************************
  1588.  * FUNCTION
  1589.  *  ebr_frm_fmgr_set_file_type
  1590.  * DESCRIPTION
  1591.  *  
  1592.  * PARAMETERS
  1593.  *  file_name       [IN]        
  1594.  * RETURNS
  1595.  *  void
  1596.  *****************************************************************************/
  1597. void ebr_frm_fmgr_set_file_type(S8 *file_name)
  1598. {
  1599.     /*----------------------------------------------------------------*/
  1600.     /* Local Variables                                                */
  1601.     /*----------------------------------------------------------------*/
  1602. U8 tmp_path_buf[(FMGR_MAX_PATH_LEN + 1) * ENCODING_LENGTH];
  1604.     /*----------------------------------------------------------------*/
  1605.     /* Code Body                                                      */
  1606.     /*----------------------------------------------------------------*/
  1607. if (g_curr_book_cntx_p->is_short)
  1608.     {
  1609.         memset(tmp_path_buf, 0, (FMGR_MAX_PATH_LEN + 1) * ENCODING_LENGTH);
  1610.         mmi_chset_mixed_text_to_ucs2_str(
  1611.                     (U8*) tmp_path_buf,
  1612.                     (FMGR_MAX_PATH_LEN + 1) * ENCODING_LENGTH,
  1613.                     (U8*) file_name,
  1614.                     g_chset_text_encoding);
  1615.         pfnUnicodeStrcpy((S8*) g_curr_book_cntx_p->nfo_name, (S8*) tmp_path_buf);
  1616.     }
  1617.     else
  1618.     {
  1619.         pfnUnicodeStrcpy((S8*) g_curr_book_cntx_p->nfo_name, (S8*) file_name);
  1620.     }
  1622.     ebr_frm_set_file_type();
  1623. }
  1626. /*****************************************************************************
  1627.  * FUNCTION
  1628.  *  ebr_frm_set_file_name
  1629.  * DESCRIPTION
  1630.  *  
  1631.  * PARAMETERS
  1632.  *  nfo_id      [IN]        
  1633.  * RETURNS
  1634.  *  void
  1635.  *****************************************************************************/
  1636. void ebr_frm_set_file_name(S32 nfo_id)
  1637. {
  1638.     /*----------------------------------------------------------------*/
  1639.     /* Local Variables                                                */
  1640.     /*----------------------------------------------------------------*/
  1641.     FILE_HANDLE nfo_hnd;
  1643.     /*----------------------------------------------------------------*/
  1644.     /* Code Body                                                      */
  1645.     /*----------------------------------------------------------------*/
  1646.     nfo_hnd = ebr_frm_get_nfo_handle();
  1647.     pfnUnicodeStrcpy((PS8) g_curr_book_cntx_p->nfo_name, (PS8) g_curr_book_cntx_p->g_nfo_book_struct.e_book_name);
  1648.     FS_Close(nfo_hnd);
  1649. }
  1652. /*****************************************************************************
  1653.  * FUNCTION
  1654.  *  ebr_frm_fmgr_move_ebook_file
  1655.  * DESCRIPTION
  1656.  *  
  1657.  * PARAMETERS
  1658.  *  void
  1659.  * RETURNS
  1660.  *  void
  1661.  *****************************************************************************/
  1662. void ebr_frm_fmgr_move_ebook_file(void)
  1663. {
  1664.     /*----------------------------------------------------------------*/
  1665.     /* Local Variables                                                */
  1666.     /*----------------------------------------------------------------*/
  1667.     S32 create_result;
  1668.     FS_HANDLE file_handle;
  1669. U8 name[FMGR_MAX_FILE_LEN*ENCODING_LENGTH];
  1670.     U8 tmp_path_buf[(FMGR_MAX_PATH_LEN + 1) * ENCODING_LENGTH];
  1672.     /*----------------------------------------------------------------*/
  1673.     /* Code Body                                                      */
  1674.     /*----------------------------------------------------------------*/
  1675.     pfnUnicodeStrcat((S8*) g_curr_book_cntx_p->fmgr_file_path, (S8*) g_curr_book_cntx_p->fmgr_file_name);
  1676. #ifndef __MMI_SHOW_FILE_EXT__
  1677.     pfnUnicodeStrcat((PS8) g_curr_book_cntx_p->fmgr_file_path, (PS8) g_curr_book_cntx_p->fmgr_file_extension);
  1678. #endif 
  1679.     pfnUnicodeStrcpy((PS8) g_curr_book_cntx_p->old_file_path, (PS8) g_curr_book_cntx_p->fmgr_file_path);
  1681.     /* short file name src file should be renamed to long file name */
  1682. #ifdef MMI_ON_HARDWARE_P
  1683.     if (g_curr_book_cntx_p->is_short == TRUE)
  1684.     {
  1685.         PS8 temp, temp1;
  1687.         temp = mmi_fmgr_extract_file_name((PS8) g_curr_book_cntx_p->fmgr_file_path);
  1688.         temp1 = mmi_fmgr_extract_file_name((PS8) g_curr_book_cntx_p->old_file_path);
  1689.         mmi_chset_mixed_text_to_ucs2_str(
  1690.             (U8*) temp1,
  1691.             (MAX_SUBMENU_CHARACTERS - 1) * ENCODING_LENGTH,
  1692.             (U8*) temp,
  1693.             PhnsetGetDefEncodingType());
  1694.         FS_Rename((PU16) g_curr_book_cntx_p->fmgr_file_path, (PU16) g_curr_book_cntx_p->old_file_path);
  1695.     }
  1696. #endif /* MMI_ON_HARDWARE_P */ 
  1697.     mmi_fmgr_remove_last_dir((PS8) g_curr_book_cntx_p->fmgr_file_path);
  1698. pfnUnicodeStrcpy((PS8) name, (PS8) FMGR_DEFAULT_FOLDER_EBOOKS);
  1699. mmi_fmgr_append_file_name((PS8) g_curr_book_cntx_p->fmgr_file_path, (PS8) name);
  1700. ebr_fmgr_is_book_shelf_path(g_curr_book_cntx_p->fmgr_file_path);
  1701. mmi_fmgr_remove_last_dir((PS8) g_curr_book_cntx_p->fmgr_file_path);
  1702.         ebr_frm_create_new_file_path();
  1703.     file_handle = FS_Open((U16*) g_curr_book_cntx_p->fmgr_file_path, FS_OPEN_DIR | FS_READ_ONLY);
  1705.     /* path already exist */
  1706.     if (file_handle >= 0)
  1707.     {
  1708.         FS_Close(file_handle);
  1709.         create_result = 0;
  1710.     }
  1711.     else
  1712.     {
  1713.         create_result = FS_CreateDir((PU16) g_curr_book_cntx_p->fmgr_file_path);
  1714.         pfnUnicodeStrcpy((PS8) g_curr_book_cntx_p->gebook_folder_path, (PS8) g_curr_book_cntx_p->fmgr_file_path);
  1715.         g_curr_book_cntx_p->g_isEbook_folder_created = TRUE;
  1716.     }
  1718.     if (mmi_fmgr_append_file_name((PS8) g_curr_book_cntx_p->fmgr_file_path, (PS8) g_curr_book_cntx_p->fmgr_file_name) ==
  1719.         TRUE)
  1720.     {
  1721.         if (g_curr_book_cntx_p->is_short)
  1722.         {
  1723.             memset(tmp_path_buf, 0, (FMGR_MAX_PATH_LEN + 1) * ENCODING_LENGTH);
  1724.             mmi_chset_mixed_text_to_ucs2_str(
  1725.                         (U8*) tmp_path_buf,
  1726.                         (FMGR_MAX_PATH_LEN + 1) * ENCODING_LENGTH,
  1727.                         (U8*) g_curr_book_cntx_p->fmgr_file_path,
  1728.                         g_chset_text_encoding);
  1729.             pfnUnicodeStrcpy((S8*) g_curr_book_cntx_p->fmgr_file_path, (S8*) tmp_path_buf);
  1730.         }
  1732.         ebr_frm_delete_unused_nfo_file();
  1733.         mmi_fmgr_send_copy_req(
  1734.                 FMGR_ACTION_MOVE,
  1735.                 (PU8) g_curr_book_cntx_p->old_file_path,
  1736.                 (PU8) g_curr_book_cntx_p->fmgr_file_path,
  1737.                 (PsFuncPtr) fmgr_ebook_move_rsp);
  1738. ebr_please_wait_actual_screen();        
  1739.     }
  1740. }
  1743. /*****************************************************************************
  1744.  * FUNCTION
  1745.  *  fmgr_ebook_move_rsp
  1746.  * DESCRIPTION
  1747.  *  Move response handler
  1748.  * PARAMETERS
  1749.  *  info        [IN]        
  1750.  * RETURNS
  1751.  *  void
  1752.  *****************************************************************************/
  1753. void fmgr_ebook_move_rsp(void *info)
  1754. {
  1755.     /*----------------------------------------------------------------*/
  1756.     /* Local Variables                                                */
  1757.     /*----------------------------------------------------------------*/
  1759.     mmi_fmt_copy_rsp_strcut *msgPtr;
  1761.     /*----------------------------------------------------------------*/
  1762.     /* Code Body                                                      */
  1763.     /*----------------------------------------------------------------*/
  1764.     msgPtr = (mmi_fmt_copy_rsp_strcut*) info;
  1765.     if (msgPtr->result >= 0)
  1766.     {
  1767.         ebr_fmgr_set_file_type((S8*) g_curr_book_cntx_p->fmgr_file_name);
  1768.         mmi_fmgr_remove_last_dir((PS8) g_curr_book_cntx_p->old_file_path);
  1769.         ebr_fmgr_copy_new_file_path_after_move(g_curr_book_cntx_p->old_file_path);
  1770.         DeleteScreenIfPresent(SCR_FMGR_FILE_OPTION);
  1771.         ebr_app_add_to_book_shelf();
  1772.     }
  1773.     else
  1774.     {
  1775.    ebr_display_error_pop_up(msgPtr->result);
  1776.     }
  1777. }
  1780. /*****************************************************************************
  1781.  * FUNCTION
  1782.  *  ebr_app_change_drive_type
  1783.  * DESCRIPTION
  1784.  *  Change drive type
  1785.  * PARAMETERS
  1786.  *  void
  1787.  * RETURNS
  1788.  *  void
  1789.  *****************************************************************************/
  1790. void ebr_app_change_drive_type(void)
  1791. {
  1792.     /*----------------------------------------------------------------*/
  1793.     /* Local Variables                                                */
  1794.     /*----------------------------------------------------------------*/
  1795.     S16 error;
  1797.     /*----------------------------------------------------------------*/
  1798.     /* Code Body                                                      */
  1799.     /*----------------------------------------------------------------*/
  1800.     error = ebr_frm_change_drive_type();
  1801.     ebr_app_get_nfo_id_from_fmgr(
  1802.         g_curr_book_cntx_p->fmgr_file_name,
  1803.         g_curr_book_cntx_p->fmgr_file_path,
  1804.         g_curr_book_cntx_p->fmgr_file_extension,
  1805.         g_curr_book_cntx_p->is_short);
  1806. }
  1809. /*****************************************************************************
  1810.  * FUNCTION
  1811.  *  ebr_fmgr_entry_open
  1812.  * DESCRIPTION
  1813.  *  Entry open book
  1814.  * PARAMETERS
  1815.  *  void
  1816.  * RETURNS
  1817.  *  void
  1818.  *****************************************************************************/
  1819. void ebr_fmgr_entry_open(void)
  1820. {
  1821.     /*----------------------------------------------------------------*/
  1822.     /* Local Variables                                                */
  1823.     /*----------------------------------------------------------------*/
  1825.     /*----------------------------------------------------------------*/
  1826.     /* Code Body                                                      */
  1827.     /*----------------------------------------------------------------*/
  1828.     ebr_app_get_nfo_id_from_fmgr(
  1829.         g_curr_book_cntx_p->fmgr_file_name,
  1830.         g_curr_book_cntx_p->fmgr_file_path,
  1831.         g_curr_book_cntx_p->fmgr_file_extension,
  1832.         g_curr_book_cntx_p->is_short);
  1833. }
  1836. /*****************************************************************************
  1837.  * FUNCTION
  1838.  *  ebr_fmgr_move_to_ebook_folder
  1839.  * DESCRIPTION
  1840.  *  Move to ebook folder
  1841.  * PARAMETERS
  1842.  *  void
  1843.  * RETURNS
  1844.  *  void
  1845.  *****************************************************************************/
  1846. void ebr_fmgr_move_to_ebook_folder(void)
  1847. {
  1848.     /*----------------------------------------------------------------*/
  1849.     /* Local Variables                                                */
  1850.     /*----------------------------------------------------------------*/
  1852.     /*----------------------------------------------------------------*/
  1853.     /* Code Body                                                      */
  1854.     /*----------------------------------------------------------------*/
  1855.     ebr_app_clear_all_key_handlers();
  1856.     ebr_frm_fmgr_move_ebook_file();
  1857. }
  1860. /*****************************************************************************
  1861.  * FUNCTION
  1862.  *  ebr_frm_check_file_validity
  1863.  * DESCRIPTION
  1864.  *  Move to ebook folder
  1865.  * PARAMETERS
  1866.  *  file_path       [?]     
  1867.  *  file_name       [?]    
  1868.  * RETURNS
  1869.  *  void
  1870.  *****************************************************************************/
  1871. pBOOL ebr_frm_check_file_validity(S8 *file_path, S8 *file_name)
  1872. {
  1873.     /*----------------------------------------------------------------*/
  1874.     /* Local Variables                                                */
  1875.     /*----------------------------------------------------------------*/
  1876.     FILE_HANDLE file_hnd;
  1877.     U32 size;
  1878.     ebr_frm_database_hdr_type file_header;
  1880.     /*----------------------------------------------------------------*/
  1881.     /* Code Body                                                      */
  1882.     /*----------------------------------------------------------------*/
  1883.     if (g_curr_book_cntx_p->gbook_type == EBR_FRM_FILE_TYPE_TXT)
  1884.     {
  1885.         return TRUE;
  1886.     }
  1887.     pfnUnicodeStrcat((S8*) file_path, (S8*) file_name);
  1888.     file_hnd = FS_Open((const WCHAR*)file_path, FS_READ_ONLY);
  1889.     if (file_hnd > 0)
  1890.     {
  1891.         if (FS_Read(file_hnd, &file_header, EBR_FRM_DATABASE_HEADER_SIZE, &size) == FS_NO_ERROR)
  1892.         {
  1893.             if (memcmp(file_header.type, DOC_TYPE, strlen((PS8) DOC_TYPE)) == 0)
  1894.             {
  1895.                 FS_Close(file_hnd);
  1896.                 return TRUE;
  1897.             }
  1898.             else
  1899.             {
  1900.                 FS_Close(file_hnd);
  1901.                 return FALSE;
  1902.             }
  1903.         }
  1904.         else
  1905.         {
  1906.             return FALSE;
  1907.         }
  1908.     }
  1909.     else
  1910.     {
  1911.         return FALSE;
  1912.     }
  1913. }
  1916. /*****************************************************************************
  1917.  * FUNCTION
  1918.  *  ebr_frm_set_file_info_from_fmgr
  1919.  * DESCRIPTION
  1920.  *  Move to ebook folder
  1921.  * PARAMETERS
  1922.  *  file_name       [IN]        
  1923.  *  file_path       [IN]        
  1924.  *  file_ext        [IN]        
  1925.  *  is_short        [IN]        
  1926.  * RETURNS
  1927.  *  void
  1928.  *****************************************************************************/
  1929. void ebr_frm_set_file_info_from_fmgr(S8 *file_name, S8 *file_path, S8 *file_ext, BOOL is_short)
  1930. {
  1931.     /*----------------------------------------------------------------*/
  1932.     /* Local Variables                                                */
  1933.     /*----------------------------------------------------------------*/
  1935.     /*----------------------------------------------------------------*/
  1936.     /* Code Body                                                      */
  1937.     /*----------------------------------------------------------------*/
  1938.     pfnUnicodeStrcpy((PS8) g_curr_book_cntx_p->fmgr_file_name, (PS8) file_name);
  1939.     pfnUnicodeStrcpy((PS8) g_curr_book_cntx_p->fmgr_file_path, (PS8) file_path);
  1940.     pfnUnicodeStrcpy((PS8) g_curr_book_cntx_p->fmgr_file_extension, (PS8) file_ext);
  1941.     g_curr_book_cntx_p->is_short = is_short;
  1942. }
  1945. /*****************************************************************************
  1946.  * FUNCTION
  1947.  *  ebr_frm_delete_all_unused_nfo_file
  1948.  * DESCRIPTION
  1949.  *  Move to ebook folder
  1950.  * PARAMETERS
  1951.  *  void
  1952.  * RETURNS
  1953.  *  void
  1954.  *****************************************************************************/
  1955. void ebr_frm_delete_all_unused_nfo_file(void)
  1956. {
  1957.     /*----------------------------------------------------------------*/
  1958.     /* Local Variables                                                */
  1959.     /*----------------------------------------------------------------*/
  1960.     FS_HANDLE fh_cur;
  1961.     FS_DOSDirEntry file_info;
  1962.     S8 path[MAX_DWNL_EBK_PATH_LEN * ENCODING_LENGTH];
  1963.     U8 filename[MAX_EBOOK_NAME_LENGTH * ENCODING_LENGTH];
  1964.     U32 driveCount = 0;
  1965.     S8 driveLatter[FMGR_TOTAL_STORAGE];
  1966.     U8 driveNum;
  1968.     /*----------------------------------------------------------------*/
  1969.     /* Code Body                                                      */
  1970.     /*----------------------------------------------------------------*/
  1971.     memset(driveLatter, 0, FMGR_TOTAL_STORAGE);
  1972.     mmi_fmgr_get_exist_drive_letter(driveLatter, &driveNum);
  1973.             
  1974.     while (driveLatter[driveCount] != 0)
  1975.     {
  1976.         memset((char*)path, 0, MAX_DWNL_EBK_PATH_LEN * ENCODING_LENGTH);
  1977.         
  1978.         pfnUnicodeStrcpy((S8*) path, (S8*) ebr_frm_get_file_path(driveLatter[driveCount], EBR_FRM_SEARCH_NFO));
  1979.             if ((fh_cur = FS_FindFirst(
  1980.                             (const WCHAR*)path,
  1981.                             0,
  1982.                             0,
  1983.                             &file_info,
  1984.                             (U16*) filename,
  1985.                             MAX_EBOOK_NAME_LENGTH * ENCODING_LENGTH)) >= 0)
  1986.             {
  1987.                 do
  1988.                 {
  1989.                     if (!(file_info.Attributes & FS_ATTR_DIR))
  1990.                     {
  1991.                         ebr_frm_open_nfo_file_and_delete_all_unused_nfo(driveLatter[driveCount], filename);
  1992.                     }
  1993.                 } while ((FS_FindNext(fh_cur, &file_info, (U16*) filename, MAX_EBOOK_NAME_LENGTH * ENCODING_LENGTH) ==
  1994.                           FS_NO_ERROR));
  1995.                 FS_FindClose(fh_cur);
  1996.             }
  1997.         driveCount++;
  1998.     }
  1999.     
  2000. }
  2003. /*****************************************************************************
  2004.  * FUNCTION
  2005.  *  ebr_frm_open_nfo_file_and_delete_all_unused_nfo
  2006.  * DESCRIPTION
  2007.  *  Move to ebook folder
  2008.  * PARAMETERS
  2009.  *  memory_type     [IN]        
  2010.  *  filename        [IN]        
  2011.  * RETURNS
  2012.  *  void
  2013.  *****************************************************************************/
  2014. void ebr_frm_open_nfo_file_and_delete_all_unused_nfo(S8 memory_type, U8 *filename)
  2015. {
  2016.     /*----------------------------------------------------------------*/
  2017.     /* Local Variables                                                */
  2018.     /*----------------------------------------------------------------*/
  2019.     S8 nfo_path[MAX_DWNL_EBK_PATH_LEN * ENCODING_LENGTH];
  2020.     S8 file_path[MAX_DWNL_EBK_PATH_LEN * ENCODING_LENGTH];
  2021.     FILE_HANDLE nfo_hnd, file_hnd;
  2022.     U32 size;
  2023.     S32 nfo_id, strlen_file_name;
  2024.     ebr_frm_book_struct book_struct;
  2025.     ebr_frm_filetype_enum book_type;
  2027.     /*----------------------------------------------------------------*/
  2028.     /* Code Body                                                      */
  2029.     /*----------------------------------------------------------------*/
  2030.     pfnUnicodeStrcpy((S8*) nfo_path, (S8*) ebr_frm_get_file_path(memory_type, EBR_FRM_SEARCH_DEFAULT));
  2031.     pfnUnicodeStrcat((S8*) nfo_path, (S8*) filename);
  2032.     nfo_hnd = FS_Open((const WCHAR*)nfo_path, FS_READ_ONLY);
  2033.     FS_Read(nfo_hnd, &book_struct, sizeof(book_struct), &size);
  2034.     FS_Close(nfo_hnd);
  2036.     strlen_file_name = pfnUnicodeStrlen((const S8*)book_struct.e_book_name);
  2038.     if (book_struct.e_book_name[strlen_file_name * 2 - 6] == 'p')
  2039.     {
  2040.         book_type = EBR_FRM_FILE_TYPE_PDB;
  2041.     }
  2042.     else
  2043.     {
  2044.         book_type = EBR_FRM_FILE_TYPE_TXT;
  2045.     }
  2047.     pfnUnicodeStrcpy((S8*) file_path, (S8*) ebr_frm_get_file_path(memory_type, EBR_FRM_SEARCH_DEFAULT));
  2048.     pfnUnicodeStrcat((S8*) file_path, (S8*) book_struct.e_book_name);
  2049.     file_hnd = FS_Open((const WCHAR*)file_path, FS_READ_ONLY);
  2050.     if (file_hnd <= 0)
  2051.     {
  2052.         FS_Delete((const WCHAR*)nfo_path);
  2053.     }
  2054.     else
  2055.     {
  2056.         FS_Close(file_hnd);
  2057.         if (book_type == EBR_FRM_FILE_TYPE_TXT)
  2058.         {
  2059.             nfo_id = ebr_fmgr_get_nfo_id_for_txt_file(memory_type, (S8*) g_curr_book_cntx_p->g_nfo_book_struct.e_book_name);
  2060.         }
  2061.         else
  2062.         {
  2063.             nfo_id = ebr_fmgr_get_nfo_id_for_pdb_file(memory_type, (S8*) g_curr_book_cntx_p->g_nfo_book_struct.e_book_name);
  2064.         }
  2065.         if (nfo_id <= 0)
  2066.         {
  2067.             FS_Delete((const WCHAR*)nfo_path);
  2068.         }
  2069.     }
  2070. }
  2072. #if defined(MMI_ON_HARDWARE_P) && (defined(__MMI_CHSET_BIG5__) || defined(__MMI_CHSET_GB2312__))
  2073. extern const key_index_t *g_chset_encode_to_ucs2_key_LSB_index[NO_OF_TEXT_ENCODING];
  2074. extern const kal_uint8 *g_chset_encode_to_ucs2_key_MSB[NO_OF_TEXT_ENCODING];
  2075. extern const kal_uint16 *g_chset_encode_to_ucs2_table[NO_OF_TEXT_ENCODING];
  2077. extern const kal_uint16 *g_chset_unknown_encode_char;
  2080. /*****************************************************************************
  2081.  * FUNCTION
  2082.  *  ebr_frm_mmi_chset_text_to_ucs2_str
  2083.  * DESCRIPTION
  2084.  *  
  2085.  * PARAMETERS
  2086.  *  file_hnd                    [IN]        
  2087.  *  dest                        [IN]        
  2088.  *  dest_size                   [IN]        
  2089.  *  src                         [IN]        
  2090.  *  src_size                    [IN]        
  2091.  *  encoding                    [IN]        
  2092.  *  over_the_record_border      [?]         
  2093.  * RETURNS
  2094.  *  
  2095.  *****************************************************************************/
  2096. U16 ebr_frm_mmi_chset_text_to_ucs2_str(
  2097.         FILE_HANDLE file_hnd,
  2098.         U8 *dest,
  2099.         S16 dest_size,
  2100.         U8 *src,
  2101.         S16 src_size,
  2102.         TextEncodingEnum encoding,
  2103.         U32 *over_the_record_border)
  2104. {
  2105.     /*----------------------------------------------------------------*/
  2106.     /* Local Variables                                                */
  2107.     /*----------------------------------------------------------------*/
  2109.     const key_index_t *key_LSB_index_table = g_chset_encode_to_ucs2_key_LSB_index[encoding];
  2110.     const kal_uint8 *key_MSB_table = g_chset_encode_to_ucs2_key_MSB[encoding];
  2111.     const kal_uint16 *ucs2_table = g_chset_encode_to_ucs2_table[encoding];
  2112.     U8 key_LSB;
  2113.     U8 key_MSB;
  2114.     S16 start;
  2115.     S16 end;
  2116.     S16 pos = 0;
  2117.     S16 index;
  2118.     S16 count = 0;
  2120.     /*----------------------------------------------------------------*/
  2121.     /* Code Body                                                      */
  2122.     /*----------------------------------------------------------------*/
  2123.     *over_the_record_border = 0;
  2124.     while (*(src) != 0) /* I do not know how we assume that this is end of data.. Currently we are taking only chinese encodings for
  2125.                            the optimized algo so we can take it as 2 bytes */
  2126.     {
  2127.         if (*(src) <= 0x7f)
  2128.         {
  2129.             *(dest + pos) = *src;
  2130.             pos++;
  2131.             *(dest + pos) = 0;
  2132.             pos++;
  2133.             src += 1;
  2134.             count += 1;
  2135.         }
  2136.         else
  2137.         {
  2138.             key_LSB = (U8) (*(src));
  2139.             count += 1;
  2140.             start = key_LSB_index_table[key_LSB].start;
  2141.             if (start < 0)
  2142.             {
  2143.                 dest[pos] = (U8) g_chset_unknown_encode_char[encoding];
  2144.                 dest[pos + 1] = (U8) (g_chset_unknown_encode_char[encoding] >> 8);
  2145.                 src += 1;
  2146.             }
  2147.             else
  2148.             {
  2149.                 if (count >= src_size)
  2150.                 {
  2151.                     U32 temp_size;
  2153.                     FS_Read(file_hnd, &key_MSB, 1, &temp_size);
  2154.                     if (temp_size != 1)
  2155.                     {
  2156.                         key_MSB = 0;
  2157.                     }
  2158.                     else
  2159.                     {
  2160.                         *over_the_record_border = 1;
  2161.                     }
  2162.                 }
  2163.                 else
  2164.                 {
  2165.                     key_MSB = (U8) (*(src + 1));
  2166.                 }
  2167.                 count += 1;
  2168.                 end = key_LSB_index_table[key_LSB].end;
  2169.                 if ((index = ebr_frm_mmi_chset_binary_search(key_MSB, key_MSB_table, start, end)) < 0)  /* key MSB not found */
  2170.                 {
  2171.                     dest[pos] = (U8) g_chset_unknown_encode_char[encoding];
  2172.                     dest[pos + 1] = (U8) (g_chset_unknown_encode_char[encoding] >> 8);
  2173.                 }
  2174.                 else
  2175.                 {
  2176.                     dest[pos] = (U8) ucs2_table[index];
  2177.                     dest[pos + 1] = (U8) (ucs2_table[index] >> 8);
  2179.                 }
  2180.                 src += 2;
  2181.             }
  2182.             
  2183.             pos += 2;
  2184.         }
  2185.         if (pos >= dest_size - 2)
  2186.         {
  2187.             break;
  2188.         }
  2189.     }
  2190.     dest[pos] = 0;
  2191.     dest[pos + 1] = 0;
  2192.     return pos + 2;
  2193. }
  2195. /* dest_size must be >= 4 */
  2198. /*****************************************************************************
  2199.  * FUNCTION
  2200.  *  ebr_frm_mmi_chset_binary_search
  2201.  * DESCRIPTION
  2202.  *  
  2203.  * PARAMETERS
  2204.  *  key                 [IN]        
  2205.  *  lookup_table        [IN]        
  2206.  *  start               [IN]        
  2207.  *  end                 [IN]        
  2208.  * RETURNS
  2209.  *  
  2210.  *****************************************************************************/
  2211. S16 ebr_frm_mmi_chset_binary_search(const kal_uint8 key, const kal_uint8 *lookup_table, kal_int16 start, kal_int16 end)
  2212. {
  2213.     /*----------------------------------------------------------------*/
  2214.     /* Local Variables                                                */
  2215.     /*----------------------------------------------------------------*/
  2217.     /*----------------------------------------------------------------*/
  2218.     /* Code Body                                                      */
  2219.     /*----------------------------------------------------------------*/
  2220.     while (start <= end)
  2221.     {
  2222.         kal_int16 mid = (start + end) / 2;
  2224.         if (key > lookup_table[mid])
  2225.         {
  2226.             start = mid + 1;
  2227.         }
  2228.         else if (key < lookup_table[mid])
  2229.         {
  2230.             end = mid - 1;
  2231.         }
  2232.         else    /* key == target */
  2233.         {
  2234.             return mid;
  2235.         }
  2236.     }
  2238.     return -1;
  2239. }
  2241. #endif /* defined(MMI_ON_HARDWARE_P) && (defined(__MMI_CHSET_BIG5__) || defined(__MMI_CHSET_GB2312__)) */ /* defined(MMI_ON_HARDWARE_P) && defined(__MMI_CHSET_IDEOGRAM_SUPPORT__) */
  2243. #if defined(MMI_ON_HARDWARE_P)
  2244. const kal_uint8 g_ebr_frm_cheset_utf8_bytes_per_char[16] = 
  2245. {
  2246.     1, 1, 1, 1, 1, 1, 1, 1,
  2247.     0, 0, 0, 0, 2, 2, 3, 4  /* we don't support UCS4 */
  2248. };
  2249. extern kal_int32 mmi_chset_utf8_to_ucs2(kal_uint8 *dest, kal_uint8 *utf8);
  2253. /*****************************************************************************
  2254.  * FUNCTION
  2255.  *  ebr_frm_mmi_chset_utf8_to_ucs2_string
  2256.  * DESCRIPTION
  2257.  *  
  2258.  * PARAMETERS
  2259.  *  file_hnd                    [IN]        
  2260.  *  dest                        [IN]        
  2261.  *  dest_size                   [IN]        
  2262.  *  src                         [IN]        
  2263.  *  src_size                    [IN]        
  2264.  *  over_the_record_border      [IN]         
  2265.  * RETURNS
  2266.  *  
  2267.  *****************************************************************************/
  2268. S32 ebr_frm_mmi_chset_utf8_to_ucs2_string(
  2269.         FILE_HANDLE file_hnd,
  2270.         U8 *dest,
  2271.         S16 dest_size,
  2272.         U8 *src,
  2273.         S16 src_size,
  2274.         U32 *over_the_record_border)
  2275. {
  2276.     /*----------------------------------------------------------------*/
  2277.     /* Local Variables                                                */
  2278.     /*----------------------------------------------------------------*/
  2279.     S32 pos = 0;
  2280.     S32 cnt;
  2281.     S32 src_count = 0;
  2283.     /*----------------------------------------------------------------*/
  2284.     /* Code Body                                                      */
  2285.     /*----------------------------------------------------------------*/
  2286.     *over_the_record_border = 0;
  2287.     while (*src && pos < dest_size - 2)
  2288.     {
  2289.         cnt = g_ebr_frm_cheset_utf8_bytes_per_char[(*src) >> 4];
  2290.         if (src_count + cnt > src_size)
  2291.         {
  2292.             S32 i = 0;
  2293.             U8 utf8_char[4];
  2294.             U8 bytes_in_buffer;
  2295.             U32 size;
  2297.             *over_the_record_border = (src_count + cnt) - src_size;
  2298.             bytes_in_buffer = cnt - *over_the_record_border;
  2299.             
  2300.             for (i = 0; i < bytes_in_buffer; i++)
  2301.             {
  2302.                 utf8_char[i] = *src;
  2303.                 src += 1;
  2304.             }
  2305.             FS_Read(file_hnd, &utf8_char[bytes_in_buffer], *over_the_record_border, &size);
  2306.             if (size != *over_the_record_border)
  2307.             {
  2308.                 break;
  2309.             }
  2310.             else
  2311.             {
  2312.                 cnt = mmi_chset_utf8_to_ucs2(dest + pos, utf8_char);
  2313.             }
  2314.         }
  2315.         else
  2316.         {
  2317.             cnt = mmi_chset_utf8_to_ucs2(dest + pos, src);
  2318.         }
  2319.         if (cnt == 0)   /* abnormal case */
  2320.         {
  2321.             break;
  2322.         }
  2323.         else if (cnt == 4)
  2324.         {
  2325.             src += cnt;
  2326.         }
  2327.         else    /* normal case */
  2328.         {
  2329.             src += cnt;
  2330.             pos += 2;
  2331.         }
  2332.         src_count += cnt;
  2333.     }
  2334.     dest[pos] = 0;
  2335.     dest[pos + 1] = 0;
  2336.     return pos + 2;
  2337. }
  2339. #endif /* defined(MMI_ON_HARDWARE_P) */ 
  2342. /*****************************************************************************
  2343.  * FUNCTION
  2344.  *  ebr_frm_reset_find_next_data
  2345.  * DESCRIPTION
  2346.  *  Clears flags for find next on shortcut keys
  2347.  * PARAMETERS
  2348.  *  void
  2349.  * RETURNS
  2350.  *  void
  2351.  *****************************************************************************/
  2352. void ebr_frm_reset_find_next_data(void)
  2353. {
  2354.     /*----------------------------------------------------------------*/
  2355.     /* Local Variables                                                */
  2356.     /*----------------------------------------------------------------*/
  2358.     /*----------------------------------------------------------------*/
  2359.     /* Code Body                                                      */
  2360.     /*----------------------------------------------------------------*/
  2361.     g_curr_book_cntx_p->ebr_last_offset_string = -1;
  2362.     g_curr_book_cntx_p->search_found_flag = FALSE;
  2363.     g_curr_book_cntx_p->search_string_count = 0;
  2364.     g_curr_book_cntx_p->find_next_first_flag = 0;
  2365.     g_curr_book_cntx_p->last_record_flag = 0;
  2366.     g_curr_book_cntx_p->ebr_last_text_offset = 0;
  2367.     g_curr_book_cntx_p->ebr_last_page_id = 0;
  2368. }
  2371. /*****************************************************************************
  2372.  * FUNCTION
  2373.  *  ebr_frm_get_and_set_current_page_values
  2374.  * DESCRIPTION
  2375.  *  Sets current page values in case of Exit category
  2376.  * PARAMETERS
  2377.  *  void
  2378.  * RETURNS
  2379.  *  void
  2380.  *****************************************************************************/
  2381. void ebr_frm_get_and_set_current_page_values(void)
  2382. {
  2383.     /*----------------------------------------------------------------*/
  2384.     /* Local Variables                                                */
  2385.     /*----------------------------------------------------------------*/
  2386.     U32 page_id;
  2387.     S32 text_offset;
  2388.     U8 shared_bytes;
  2389.     U8 last_showed_percentage;
  2391.     S32 last_text_offset_y;
  2394.     /*----------------------------------------------------------------*/
  2395.     /* Code Body                                                      */
  2396.     /*----------------------------------------------------------------*/
  2397.     wgui_paging_multiline_get_current_page(
  2398.         &page_id,
  2399.         &text_offset,
  2400.         &shared_bytes,
  2401.         &last_showed_percentage,
  2402.         &last_text_offset_y);
  2403.     g_curr_book_cntx_p->ebr_last_text_offset = text_offset;
  2404.     g_curr_book_cntx_p->ebr_last_page_id = page_id;
  2405. }
  2407. #ifdef __MMI_LANG_HINDI__
  2410. /*****************************************************************************
  2411.  * FUNCTION
  2412.  *  ebr_frm_check_for_full_characters
  2413.  * DESCRIPTION
  2414.  *  
  2415.  * PARAMETERS
  2416.  *  pattern     [IN]        
  2417.  * RETURNS
  2418.  *  
  2419.  *****************************************************************************/
  2420. pBOOL ebr_frm_check_for_full_characters(S16 *pattern)
  2421. {
  2422.     /*----------------------------------------------------------------*/
  2423.     /* Local Variables                                                */
  2424.     /*----------------------------------------------------------------*/
  2426.     /*----------------------------------------------------------------*/
  2427.     /* Code Body                                                      */
  2428.     /*----------------------------------------------------------------*/
  2429.     if (pattern[pfnUnicodeStrlen((const S8*)pattern) - 1] == 2381)
  2430.     {
  2431.         return FALSE;
  2432.     }
  2433.     else
  2434.     {
  2435.         return TRUE;
  2436.     }
  2437. }
  2439. #endif /* __MMI_LANG_HINDI__ */ 
  2442. /*****************************************************************************
  2443.  * FUNCTION
  2444.  *  ebr_frm_check_drive_space
  2445.  * DESCRIPTION
  2446.  *  
  2447.  * PARAMETERS
  2448.  *  void
  2449.  * RETURNS
  2450.  *  
  2451.  *****************************************************************************/
  2452. pBOOL ebr_frm_check_drive_space(void)
  2453. {
  2454.     /*----------------------------------------------------------------*/
  2455.     /* Local Variables                                                */
  2456.     /*----------------------------------------------------------------*/
  2457.     S8 file_path_in_ascii[5];
  2458.     S8 file_path[10];
  2459.     U64 disk_free_space;
  2460.     U64 disk_total_space;
  2461.     S32 fs_ret;
  2462.     FS_DiskInfo disk_info;
  2464.     /*----------------------------------------------------------------*/
  2465.     /* Code Body                                                      */
  2466.     /*----------------------------------------------------------------*/
  2467.     sprintf((char*)file_path_in_ascii, "%c", g_curr_book_cntx_p->memory_type_selected);
  2468.     strcat((char*)file_path_in_ascii, ":\");
  2469.     AnsiiToUnicodeString((PS8) file_path, file_path_in_ascii);
  2470.     fs_ret = FS_GetDiskInfo((PU16) file_path, &disk_info, FS_DI_BASIC_INFO | FS_DI_FREE_SPACE);
  2472.     disk_free_space = 0;
  2473.     disk_total_space = 0;
  2474.     if (fs_ret >= 0)
  2475.     {
  2476.         disk_free_space = disk_info.FreeClusters * disk_info.SectorsPerCluster * disk_info.BytesPerSector;
  2477.         disk_total_space = disk_info.TotalClusters * disk_info.SectorsPerCluster * disk_info.BytesPerSector;
  2478.         if (disk_free_space <= g_curr_book_cntx_p->g_nfo_book_struct.book_size)
  2479.         {
  2480.             return FALSE;
  2481.         }
  2482.         else
  2483.         {
  2484.             return TRUE;
  2485.         }
  2486.     }
  2487.     return FALSE;
  2488. }
  2492. /*****************************************************************************
  2493.  * FUNCTION
  2494.  *  ebr_frm_check_nfo_file_size
  2495.  * DESCRIPTION
  2496.  *  
  2497.  * PARAMETERS
  2498.  *  void
  2499.  * RETURNS
  2500.  *  
  2501.  *****************************************************************************/
  2502. pBOOL ebr_frm_check_nfo_file_size(void)
  2503. {
  2504.     /*----------------------------------------------------------------*/
  2505.     /* Local Variables                                                */
  2506.     /*----------------------------------------------------------------*/
  2507.     S8 file_path_in_ascii[5];
  2508.     S8 file_path[10];
  2509.     U64 disk_free_space;
  2510.     U64 disk_total_space;
  2511.     S32 fs_ret;
  2512.     FS_DiskInfo disk_info;
  2514.     /*----------------------------------------------------------------*/
  2515.     /* Code Body                                                      */
  2516.     /*----------------------------------------------------------------*/
  2517.     sprintf((char*)file_path_in_ascii, "%c", g_curr_book_cntx_p->memory_type_selected);
  2518.     strcat((char*)file_path_in_ascii, ":\");
  2519.     AnsiiToUnicodeString((PS8) file_path, file_path_in_ascii);
  2520.     fs_ret = FS_GetDiskInfo((PU16) file_path, &disk_info, FS_DI_BASIC_INFO | FS_DI_FREE_SPACE);
  2522.     disk_free_space = 0;
  2523.     disk_total_space = 0;
  2524.     if (fs_ret >= 0)
  2525.     {
  2526.         disk_free_space = disk_info.FreeClusters * disk_info.SectorsPerCluster * disk_info.BytesPerSector;
  2527.         disk_total_space = disk_info.TotalClusters * disk_info.SectorsPerCluster * disk_info.BytesPerSector;
  2528.         if (disk_free_space <= sizeof(g_curr_book_cntx_p->g_nfo_book_struct))
  2529.         {
  2530.             return TRUE;
  2531.         }
  2532.         else
  2533.         {
  2534.             return FALSE;
  2535.         }
  2536.     }
  2537.     return FALSE;
  2538. }
  2542. /*****************************************************************************
  2543.  * FUNCTION
  2544.  *  ebr_fmgr_kernel_hide_ext_name
  2545.  * DESCRIPTION
  2546.  *  
  2547.  * PARAMETERS
  2548.  *  str_buf_ptr     [?]     
  2549.  *  info_ptr        [?]     
  2550.  * RETURNS
  2551.  *  void
  2552.  *****************************************************************************/
  2553. void ebr_fmgr_kernel_hide_ext_name(S8 *str_buf_ptr, FMGR_FILE_INFO_STRUCT *info_ptr)
  2554. {
  2555.     /*----------------------------------------------------------------*/
  2556.     /* Local Variables                                                */
  2557.     /*----------------------------------------------------------------*/
  2558.     S32 str_len;
  2559.     S32 ext_str_len;
  2561.     /*----------------------------------------------------------------*/
  2562.     /* Code Body                                                      */
  2563.     /*----------------------------------------------------------------*/
  2564.     str_len = pfnUnicodeStrlen((PS8) str_buf_ptr);
  2565.     ext_str_len = pfnUnicodeStrlen((PS8) info_ptr->file_ext);
  2566.     if (ext_str_len > 0)
  2567.     {
  2568.         ext_str_len += 1;
  2569.     }
  2571.     if (!(info_ptr->attribute & FS_ATTR_DIR))   /* not folder */
  2572.     {
  2573.         memset(&str_buf_ptr[(str_len - ext_str_len) * ENCODING_LENGTH], 0, ext_str_len * ENCODING_LENGTH);
  2574.     }
  2576. }
  2579. /*****************************************************************************
  2580.  * FUNCTION
  2581.  *  ebr_frm_remove_last_directory
  2582.  * DESCRIPTION
  2583.  *  
  2584.  * PARAMETERS
  2585.  *  void
  2586.  * RETURNS
  2587.  *  void
  2588.  *****************************************************************************/
  2589. void ebr_frm_remove_last_directory(void)
  2590. {
  2591.     /*----------------------------------------------------------------*/
  2592.     /* Local Variables                                                */
  2593.     /*----------------------------------------------------------------*/
  2595.     /*----------------------------------------------------------------*/
  2596.     /* Code Body                                                      */
  2597.     /*----------------------------------------------------------------*/
  2598.     mmi_fmgr_remove_last_dir((PS8) g_curr_book_cntx_p->book_name_path);
  2599.     ebr_fmgr_copy_new_file_path_after_move((S8*) g_curr_book_cntx_p->book_name_path);
  2600. }
  2603. /*****************************************************************************
  2604.  * FUNCTION
  2605.  *  ebr_frm_check_is_nfo_file_exist
  2606.  * DESCRIPTION
  2607.  *  
  2608.  * PARAMETERS
  2609.  *  nfo_id      [IN]        
  2610.  * RETURNS
  2611.  *  void
  2612.  *****************************************************************************/
  2613. void ebr_frm_check_is_nfo_file_exist(S16 nfo_id)
  2614. {
  2615.     /*----------------------------------------------------------------*/
  2616.     /* Local Variables                                                */
  2617.     /*----------------------------------------------------------------*/
  2618.     FILE_HANDLE nfo_hnd;
  2619.     S16 error;
  2621.     /*----------------------------------------------------------------*/
  2622.     /* Code Body                                                      */
  2623.     /*----------------------------------------------------------------*/
  2624.     nfo_hnd = FS_Open((const WCHAR*)ebr_frm_get_nfo_file_name((S32) nfo_id), FS_READ_ONLY);
  2625.     if (nfo_hnd <= 0)
  2626.     {
  2627.         nfo_id = 0;
  2628.         WriteValue(NVRAM_EBOOK_NFO_LID, (void*)&nfo_id, DS_SHORT, &error);
  2629.     }
  2630.     FS_Close(nfo_hnd);
  2632. }
  2634. /*****************************************************************************
  2635.  * FUNCTION
  2636.  *  ebr_frm_check_file_exist
  2637.  * DESCRIPTION
  2638.  *  
  2639.  * PARAMETERS
  2640.  *  void
  2641.  * RETURNS
  2642.  *  pBOOL
  2643.  *****************************************************************************/
  2644. pBOOL ebr_frm_check_file_exist(void)
  2645. {
  2646. FILE_HANDLE file_hnd;
  2648.     /*----------------------------------------------------------------*/
  2649.     /* Code Body                                                      */
  2650.     /*----------------------------------------------------------------*/
  2651. if (g_curr_book_cntx_p->book_is_in_other_encoding_format)
  2652.     {
  2653.         file_hnd = FS_Open((const WCHAR*)g_curr_book_cntx_p->temp_book_name_path, FS_READ_ONLY);
  2654.     }
  2655.     else
  2656.     {
  2657.         file_hnd = FS_Open((const WCHAR*)g_curr_book_cntx_p->book_name_path, FS_READ_ONLY);
  2658.     }
  2659. if(file_hnd<=0)
  2660. return FALSE;
  2661. else
  2662. {
  2663. FS_Close(file_hnd);
  2664. return TRUE;
  2665. }
  2667. }
  2669. MMI_BOOL mmi_ebr_is_memory_type_changed(S8 memoryType)
  2670. {
  2671.     if (g_curr_book_cntx_p->g_nfo_book_struct.memory_type == memoryType)
  2672.     {
  2673.         return MMI_FALSE;
  2674.     }
  2675.     else
  2676.     {
  2677.         return MMI_TRUE;
  2678.     }
  2679. }
  2680. #endif /* __MMI_EBOOK_READER__ */