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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编辑器/阅读器 > 查看源码
reader_file.c.svn-base
资源名称：lread.rar　[点击查看]
上传用户：holyzs
上传日期：2022-06-29
资源大小：2335k
文件大小：17k
源码类别：

编辑器/阅读器

开发平台：

C/C++

reader_file.c.svn-base：源码内容
  1. #include <stdlib.h>
  2. #include <string.h>
  3. #include <reader_core.h>
  5. enum {
  6.   ITEMS_PER_PAGE = 12,
  7.   MAX_ITEMS = 256, //max entries in a single directory
  8.   MAX_NAME_LEN = 32, //32 in unicode
  9.   FILENAME_BORDER = 128,
  10.   FILENAME_TAB_SIZE = 8*1024
  11. };
  13. static unsigned short reader_current_file[READER_FILENAME_MAX];
  14. unsigned short reader_current_dir[READER_PATH_MAX];
  15. int reader_file_menu_cursor;
  17. //file names table in unicode for sort, display and handle
  18. static unsigned short uni_names_tab[FILENAME_TAB_SIZE];
  20. #if TRACE_FILENAME || ENABLE_CONSOLE
  21. //buffer for trace out
  22. static unsigned short trace_buf[4*1024];
  23. #endif
  24. #if TRACE_FILENAME
  25. static int trace_ip;
  26. #define TRACE_FN_LEN 128
  27. #endif
  29. /*The file list is limited by 3 elements:
  30. 1. <MAX_ITEMS>, only <MAX_ITEMS> entries will be listed in a single directory
  31. 2. sizeof(uni_names_tab), if the size of lfn of files reached this size,
  32.    no more entries will be listed
  33. */
  35. reader_file_item_t file_menu_items[MAX_ITEMS + 1];
  36. static int n_item, n_pages;
  38. static int roll_name_display;
  39. static int name_cursor;
  41. static int compare_name(const void *f1, const void *f2);
  43. //calculate how many chars can be displayed within 'lim' pixels
  44. static int calc_chars(unsigned short *p, int lim);
  45. static int calc_width(unsigned short *p, int n);
  47. unsigned short *reader_file_get_dir(void) {
  48.   return reader_current_dir;
  49. }
  51. static int is_root_dir(unsigned short *path) {
  52.   return (0 == reader_wcscmp(path, reader_path_root));
  53. }
  55. static int is_upper_dir(unsigned short *path) {
  56.   if (0 == reader_wcscmp(path, reader_path_upper)) {
  57.     return 1;
  58.   }
  59.   return 0;
  60. }
  62. //0 means the file will not be listed
  63. //1 means a file ends with the wanted extension name
  64. //2 means will be listed because is a directory which is not '.'
  65. static int is_file_to_be_listed(unsigned short *filename, struct stat *st) {
  66.   unsigned short *p;
  67.   unsigned short ext1[4] = {'.', 'd', 'r', 0};
  68.   unsigned short ext2[4] = {'.', 'D', 'R', 0};
  69.   unsigned short ext3[5] = {'.', 'd', 'r', 'b', 0};
  70.   unsigned short ext4[5] = {'.', 'D', 'R', 'B', 0};
  72.   //do not list 'this' dir
  73.   if (filename[0] == '.' && filename[1] == 0) {
  74.     return 0;
  75.   }
  76.   //only list files ends with ".dr" or ".DR"
  77.   if (! (st->st_mode & S_IFDIR)) {
  78.     p = reader_wcsrchr(filename, '.');
  79.     if ((p == NULL)) {
  80.       return 0;
  81.     }
  82.     if ((memcmp(p, ext1, 8) != 0)
  83.       && (memcmp(p, ext2, 8) != 0)
  84.       && (memcmp(p, ext3, 10) != 0)
  85.       && (memcmp(p, ext4, 10) != 0)) {
  86.       return 0;
  87.     } else {
  88.       return 1;
  89.     }
  90.   }
  91.   return 2;
  92. }
  94. //This function looks a little weird
  95. //because of the weird activity of chdir() in libfat
  96. //take a look at test_dir() in libfat unit test
  97. //you can find it in test/fat/src/main.c
  98. static int mychdir(unsigned short *path) {
  99.   int ret = 0;
  100.   unsigned short root[] = {'/', '.', 0};
  102. #if ENABLE_CONSOLE
  103.   char *p = "path in mydir:";
  104.   char *p2;
  105.   char *buf = (char *)trace_buf;
  106.   int len = reader_wcslen(path), i;
  107.   strcpy(buf, p);
  108.   p2 = buf + strlen(buf);
  109.   sprintf(p2, "%d", path[0]);
  110.   for (i = 1; i < len; i++) {
  111.     p2 = buf + strlen(buf);
  112.     sprintf(p2, ",%d", path[i]);
  113.   }
  114.   console_log(buf);
  115. #endif
  117.   if (*path == '/') {
  118.     ret = fsal_chdir(root);
  119.     path ++;
  120.   }
  121.   if (*path) {
  122.     ret = fsal_chdir(path);
  123.     if (ret != 0) {
  124.       //restore the working path
  125.       if (reader_current_dir[0] != '') { //has been intialized
  126.         mychdir(reader_current_dir);
  127.       }
  128.     }
  129.   }
  130.   return ret;
  131. }
  133. int reader_file_set_dir(unsigned short *path) {
  134.   int i, len, attr;
  135.   struct stat st;
  136.   unsigned short filename[READER_PATH_MAX];
  137.   int uni_tab_cursor = 0;
  138.   unsigned short *puni = NULL;
  139.   fsal_dir_handle_t dir_handle;
  141.   if (0 != mychdir(path)) {
  142.     return ERR_CHDIR;
  143.   }
  145.   if (path != reader_current_dir) {
  146.     reader_wcsncpy(reader_current_dir, path, READER_PATH_MAX);
  147.   }
  149.   dir_handle = fsal_diropen(reader_path_this);
  151. #if TRACE_FILENAME
  152.   memset(trace_buf, 0, sizeof(trace_buf));
  153.   trace_ip = 0;
  154. #endif
  156.   //calc menu item number and page number
  157.   i = 0;
  158.   while ((i < MAX_ITEMS)
  159.     && (fsal_dirnext(dir_handle, filename, &st) == 0)) {
  160.     if (*filename == 0) {
  161.       //no lfn is found
  162.       continue;
  163.     }
  165. #if TRACE_FILENAME
  166.     if (trace_ip < sizeof(trace_buf)/sizeof(unsigned short) - TRACE_FN_LEN) {
  167.       reader_wcsncpy(&trace_buf[trace_ip], filename, TRACE_FN_LEN);
  168.       trace_ip += (reader_wcslen(filename)+1);
  169.     }
  170. #endif
  172.     attr = is_file_to_be_listed(filename, &st);
  173.     if (attr == 0) {
  174.       continue;
  175.     }
  176.     len = reader_wcslen(filename);
  177.     if (uni_tab_cursor+len+1 > FILENAME_TAB_SIZE) {
  178.       break;
  179.     }
  180.     puni = uni_names_tab+uni_tab_cursor;
  181.     reader_wcsncpy(puni, filename, len);
  182.     puni[len] = 0;
  183.     uni_tab_cursor += len+1; //move over last ''
  185.     READER_TRACEWM((L"uniname=%sn", puni));
  186.     file_menu_items[i].lfn = puni;
  187.     file_menu_items[i].is_folder = (st.st_mode & S_IFDIR);
  188.     file_menu_items[i].size = st.st_size;
  189.     i ++;
  190.   }
  191.   fsal_dirclose(dir_handle);
  192.   n_item = i;
  194.   n_pages = n_item / ITEMS_PER_PAGE + 1;
  195.   if (n_item % ITEMS_PER_PAGE == 0) {
  196.     n_pages --;
  197.   }
  199.   //sort the file items
  200.   qsort(file_menu_items, n_item, sizeof(reader_file_item_t), compare_name);
  202. #if TRACE_FILENAME
  203.   {
  204.     FILE *fd = NULL;
  205.     fd = fopen("console.txt", "a+");
  206.     fprintf(fd, "trace_ip=%dn", trace_ip);
  207.     fclose(fd);
  209.     fd = fopen("fnames", "wb");
  210.     fwrite(trace_buf, 2, trace_ip, fd);
  211.     fclose(fd);
  212.   }
  213. #endif
  215.   return 0;
  216. }
  218. //return if number is found in the given string
  219. //if found any number, output the number to num arg and the substring index that the number begins to prefix arg and return 1
  220. //else return 0
  221. static int look_for_numbers(unsigned short *str, int *prefix, int *num) {
  222.   unsigned short *p, *num_pos;
  223.   int i;
  224.   unsigned short num_buf[MAX_NAME_LEN + 1] = {0};
  226.   p = str;
  227.   i = 0;
  228.   num_pos = NULL;
  229.   while (*p) {
  230.     if (*p >= '0' && *p <= '9') {
  231.       if (num_pos == NULL) {
  232.         num_pos = p;
  233.       }
  234.       if (i < MAX_NAME_LEN) {
  235.         num_buf[i ++] = *p;
  236.       }
  237.     } else if (num_pos != NULL) { //cut the number
  238.       break;
  239.     }
  240.     p ++;
  241.   }
  242.   if (num_pos == NULL) {
  243.     return 0;
  244.   }
  246.   *prefix = num_pos - str;
  247.   *num = reader_atoi(num_buf);
  249.   return 1;
  250. }
  252. static int is_parent_folder(const reader_file_item_t *f) {
  253.   if (! (f->is_folder)) {
  254.     return 0;
  255.   }
  257.   if (0 == reader_wcscmp(f->lfn, reader_path_upper)) {
  258.     return 1;
  259.   }
  261.   return 0;
  262. }
  264. static int compare_name(const void *f1, const void *f2) {
  265.   const reader_file_item_t *p1 = (const reader_file_item_t *)f1;
  266.   const reader_file_item_t *p2 = (const reader_file_item_t *)f2;
  267.   unsigned short *n1, *n2;
  268.   int prefix1 = 0, prefix2 = 0;
  269.   int ret, num1, num2;
  271.   //folders are listed prior to the files
  272.   if (p1->is_folder != p2->is_folder) {
  273.     if (p1->is_folder) {
  274.       return -1;
  275.     }
  276.     return 1;
  277.   }
  279.   //parent folder is listed at the beginning
  280.   if (is_parent_folder(p1)) {
  281.     return -1;
  282.   }
  283.   if (is_parent_folder(p2)) {
  284.     return 1;
  285.   }
  287.   assert (p1->is_folder == p2->is_folder);
  288.   n1 = p1->lfn;
  289.   n2 = p2->lfn;
  291.   //look for numbers in names
  292.   if (0 == look_for_numbers(n1, &prefix1, &num1)) {
  293.     return reader_wcscmp(n1, n2);
  294.   }
  296.   if (0 == look_for_numbers(n2, &prefix2, &num2)) {
  297.     return reader_wcscmp(n1, n2);
  298.   }
  300.   ret = reader_wcscmp_n(n1, prefix1, n2, prefix2);
  301.   if (0 == ret) {
  302.     //same prefix, compare numbers
  303.     if (num1 == num2) {
  304.       //same number, the shorter the bigger because of the prefix 0s
  305.       return reader_wcslen(n2) - reader_wcslen(n1);
  306.     }
  307.     return num1 - num2;
  308.   }
  310.   return ret;
  311. }
  313. int reader_file_into_dir(unsigned short *path) {
  314.   reader_file_item_t *pitem = NULL;
  315.   unsigned short abspath[READER_PATH_MAX];
  316.   int len;
  318.   if (path != NULL) {
  319.     if (is_upper_dir(path)) {
  320.       return reader_file_upper_dir();
  321.     }
  322.     pitem = &file_menu_items[reader_file_menu_cursor];
  323.     reader_wcsncpy(abspath, reader_current_dir, READER_PATH_MAX);
  324.     len = reader_wcslen(abspath);
  325.     //append sub-dir name
  326.     if (abspath[len-1] != '/') {
  327.       //add '/' at the end
  328.       abspath[len++] = '/';
  329.     }
  330.     reader_wcscpy(&abspath[len], pitem->lfn);
  331.     reader_file_set_dir(abspath);
  332.   } else {
  333.     reader_file_set_dir(reader_current_dir);
  334.   }
  335.   reader_file_menu_cursor = 0;
  336.   return 0;
  337. }
  339. void reader_file_init(void) {
  340.   reader_file_set_dir(reader_path_root);
  341.   reader_file_menu_cursor = 0;
  342. }
  344. //return 0 means cursor changed, 1 means remained unchange.
  345. int reader_file_menu_up(void) {
  346.   if (reader_file_menu_cursor > 0) {
  347.     reader_file_menu_cursor --;
  348.     return 0;
  349.   }
  350.   return 1;
  351. }
  353. int reader_file_menu_down(void) {
  354.   if (reader_file_menu_cursor + 1 < n_item) {
  355.     reader_file_menu_cursor ++;
  356.     return 0;
  357.   }
  358.   return 1;
  359. }
  361. int reader_file_menu_prev_page(void) {
  362.   int t = reader_file_menu_cursor;
  364.   reader_file_menu_cursor -= ITEMS_PER_PAGE;
  365.   if (reader_file_menu_cursor < 0) {
  366.     reader_file_menu_cursor = 0;
  367.   }
  369.   return (t == reader_file_menu_cursor);
  370. }
  372. int reader_file_menu_next_page(void) {
  373.   int t = reader_file_menu_cursor;
  375.   reader_file_menu_cursor += ITEMS_PER_PAGE;
  376.   if (reader_file_menu_cursor >= n_item) {
  377.     reader_file_menu_cursor = n_item - 1;
  378.   }
  380.   return (t == reader_file_menu_cursor);
  381. }
  383. int reader_file_current_item(unsigned short *filename) {
  384.   reader_file_item_t *pitem = &file_menu_items[reader_file_menu_cursor];
  385.   int ret = pitem->is_folder;
  387.   if (filename == NULL) {
  388.     return ret;
  389.   }
  391.   reader_wcsncpy(filename, pitem->lfn, READER_FILENAME_MAX);
  392.   return ret;
  393. }
  395. int reader_file_menu_get_cursor_pos(void) {
  396.   return reader_file_menu_cursor % ITEMS_PER_PAGE;
  397. }
  399. int reader_file_menu_get_cursor(void) {
  400.   return reader_file_menu_cursor;
  401. }
  403. int reader_file_menu_set_cursor(int cursor) {
  404.   assert(cursor >= 0);
  405.   if (cursor >= 0 && cursor < n_item) {
  406.     reader_file_menu_cursor = cursor;
  407.     return 0;
  408.   }
  409.   return 1;
  410. }
  412. int reader_file_menu_map_cursor(int y) {
  413.   int y_begin = DEFAULT_FONT_SIZE + LINE_INTERVAL;
  414.   int y_end = READER_SCREEN_HEIGHT - (DEFAULT_FONT_SIZE + LINE_INTERVAL);
  415.   int ret;
  417.   if (y < y_begin || y > y_end) {
  418.     return -1;
  419.   }
  421.   ret = (y - y_begin) / (DEFAULT_FONT_SIZE + LINE_INTERVAL);
  422.   if (ret >= ITEMS_PER_PAGE) {
  423.     ret = ITEMS_PER_PAGE - 1;
  424.   }
  426.   return (reader_file_menu_cursor/ITEMS_PER_PAGE)*ITEMS_PER_PAGE + ret;
  427. }
  429. int reader_file_menu_set_cursor_pos(int pos) {
  430.   int current_page, current_item, new_cursor;
  432.   assert(pos >= 0 && pos < ITEMS_PER_PAGE);
  433.   current_page = reader_file_menu_cursor / ITEMS_PER_PAGE;
  434.   current_item = reader_file_menu_cursor % ITEMS_PER_PAGE;
  435.   if (current_item == pos) {
  436.     return 1;
  437.   }
  438.   new_cursor = current_page * ITEMS_PER_PAGE + pos;
  439.   if (new_cursor < n_item) {
  440.     reader_file_menu_cursor = new_cursor;
  441.     return 0;
  442.   }
  444.   return 1;
  445. }
  447. void reader_file_draw_menu(screen_t screen) {
  448.   int i, j, ibegin, iend, y, nc, n;
  449.   unsigned short tmp_str[16];
  450.   int current_page, current_item;
  451.   unsigned short *p;
  453.   reader_mmi_fill_screen(screen, READER_COLOR_BLACK);
  455.   reader_caption(screen, READER_STR(file_menu_prompt));
  457.   assert(n_item > 0);
  459.   //page number
  460.   current_page = reader_file_menu_cursor / ITEMS_PER_PAGE;
  461.   current_item = reader_file_menu_cursor % ITEMS_PER_PAGE;
  462.   i = reader_itoa(current_page + 1, tmp_str);
  463.   tmp_str[i ++] = '/';
  464.   j = reader_itoa(n_pages, tmp_str + i);
  465.   reader_textout_ex(screen, READER_SCREEN_WIDTH - 1, DEFAULT_HEADER_BLANK, tmp_str, i + j, DEFAULT_FONT_SIZE, READER_COLOR_YELLOW, TEXT_OUT_ALIGN_RIGHT);
  467.   //show cursor
  468.   y = (current_item + 1) * (DEFAULT_FONT_SIZE + LINE_INTERVAL) + DEFAULT_HEADER_BLANK;
  469.   reader_rectangle(screen, 0, y, READER_SCREEN_WIDTH - 1,
  470.                    y + DEFAULT_FONT_SIZE, READER_COLOR_WHITE, 1);
  472.   //show menu items
  473.   ibegin = current_page * ITEMS_PER_PAGE;
  474.   if (current_page == n_pages - 1) { //last page
  475.     iend = n_item;
  476.   } else {
  477.     iend = ibegin + ITEMS_PER_PAGE;
  478.   }
  480. #if TRACE_FILENAME
  481.   memset(trace_buf, 0, sizeof(trace_buf));
  482.   trace_ip = 0;
  483. #endif
  485.   roll_name_display = 0;
  486.   for (i = ibegin, j = 0; i < iend; i ++, j ++) {
  487.     color_t text_color = (j == current_item) ? READER_COLOR_BLACK : READER_COLOR_WHITE;
  488.     int name_begin = (j == current_item) ? name_cursor : 0;
  489.     y = (j + 1) * (DEFAULT_FONT_SIZE + LINE_INTERVAL) + DEFAULT_HEADER_BLANK;
  490.     p = file_menu_items[i].lfn;
  491. #if TRACE_FILENAME
  492.     if (trace_ip < sizeof(trace_buf)-TRACE_FN_LEN) {
  493.       reader_wcscpy(&trace_buf[trace_ip], p);
  494.       trace_ip += (reader_wcslen(p)+1);
  495.     }
  496. #endif
  497.     //show name
  498.     p += name_begin;
  499.     nc = calc_chars(p, FILENAME_BORDER);
  500.     reader_textout_ex(screen, 0, y, p, nc, DEFAULT_FONT_SIZE, text_color, 0);
  501.     if (nc < (int)reader_wcslen(p)) {
  502.       unsigned short append_mark[3];
  503.       append_mark[0] = '.';
  504.       append_mark[1] = '.';
  505.       append_mark[2] = 0;
  506.       if (j == current_item) {
  507.         roll_name_display = 1;
  508.       }
  509.       //append ".."
  510.       reader_textout_ex(screen, calc_width(p, nc), y, append_mark, 2, DEFAULT_FONT_SIZE, text_color, 0);
  511.     }
  513.     //show additional info, file size or <dir>
  514.     if (file_menu_items[i].is_folder) {
  515.       reader_textout_ex(screen, READER_SCREEN_WIDTH - 1, y, READER_STR(dir_mark), reader_wcslen(READER_STR(dir_mark)), DEFAULT_FONT_SIZE, text_color, TEXT_OUT_ALIGN_RIGHT);
  516.     } else {
  517.       int k;
  518.       int len, len_kb;
  520.       //only show length as 0K when the file is empty, or else at least 1K
  521.       len = file_menu_items[i].size;
  522.       if (len == 0) {
  523.         len_kb = 0;
  524.       } else {
  525.         len_kb = len / 1024;
  526.         if (len_kb == 0) {
  527.           len_kb = 1;
  528.         }
  529.       }
  530.       k = reader_itoa(len_kb, tmp_str);
  531.       tmp_str[k ++] = 'K';
  532.       reader_textout_ex(screen, READER_SCREEN_WIDTH - 1, y, tmp_str, k, DEFAULT_FONT_SIZE, text_color, TEXT_OUT_ALIGN_RIGHT);
  533.     }
  534.   }
  536.   //show current path
  537.   //draw path status bg
  538.   y = (ITEMS_PER_PAGE + 1) * (DEFAULT_FONT_SIZE + LINE_INTERVAL) + DEFAULT_HEADER_BLANK - 1;
  539.   reader_rectangle(screen, 0, y, READER_SCREEN_WIDTH - 1,
  540.                    y + DEFAULT_FONT_SIZE + 1, READER_COLOR_BLUE, 1);
  541.   //show dir name
  542.   n = calc_chars(reader_current_dir, READER_SCREEN_WIDTH-DEFAULT_FONT_SIZE);
  543.   reader_textout_ex(screen, 0, y + 1, reader_current_dir, n, DEFAULT_FONT_SIZE, READER_COLOR_YELLOW, 0);
  545.   reader_mmi_trigger_screen_update(screen);
  546.   READER_TRACEM(("roll=%dn", roll_name_display));
  548. #if TRACE_FILENAME
  549.   {
  550.     FILE *fd = NULL;
  551.     fd = fopen("dispname", "wb");
  552.     fwrite(trace_buf, 2, trace_ip, fd);
  553.     fclose(fd);
  554.   }
  555. #endif
  556. }
  558. void reader_file_reset_name_cursor(void) {
  559.   name_cursor = 0;
  560. }
  562. int reader_file_rolling_name(void) {
  563.   return roll_name_display;
  564. }
  566. void reader_file_move_name(int movement) {
  567.   name_cursor += movement;
  568. }
  570. static int calc_chars(unsigned short *p, int lim) {
  571.   int i = 0, len = 0;
  572.   unsigned short c;
  574.   while ((c = p[i]) != 0 && (len < lim)) {
  575.     len += get_chr_width(c, DEFAULT_FONT_SIZE);
  576.     i ++;
  577.   }
  579.   return i;
  580. }
  582. static int calc_width(unsigned short *p, int n) {
  583.   int i;
  584.   int width = 0;
  586.   for (i = 0; i < n; i++) {
  587.     width += get_chr_width(p[i], DEFAULT_FONT_SIZE);
  588.   }
  590.   return width;
  591. }
  593. unsigned short *reader_get_current_file() {
  594.   return reader_current_file;
  595. }
  597. int reader_set_current_file(unsigned short *filename) {
  598.   reader_wcsncpy(reader_current_file, filename, READER_FILENAME_MAX);
  599.   return 0;
  600. }
  602. int reader_file_set_cursor_by_name(unsigned short *filename) {
  603.   int i = 0;
  605.   while (file_menu_items[i].is_folder) {
  606.     i ++;
  607.   }
  609.   while (i < n_item) {
  610.     if (0 == reader_wcscmp(file_menu_items[i].lfn, filename)) {
  611.       reader_file_menu_cursor = i;
  612.       return i;
  613.     }
  614.     i++;
  615.   }
  617.   return -1;
  618. }
  620. int reader_dir_set_cursor_by_name(unsigned short *dirname) {
  621.   int i;
  623.   for (i = 0; (i < n_item) && file_menu_items[i].is_folder; i++) {
  624.     if (0 == reader_wcscmp(file_menu_items[i].lfn, dirname)) {
  625.       reader_file_menu_cursor = i;
  626.       return i;
  627.     }
  628.   }
  630.   return -1;
  631. }
  633. int reader_file_upper_dir(void) {
  634.   unsigned short abspath[READER_PATH_MAX];
  635.   unsigned short prevpath[READER_PATH_MAX];
  636.   int i, len, ret;
  637.   unsigned short *p;
  639.   if (is_root_dir(reader_current_dir)) {
  640.     return 1;
  641.   }
  643.   reader_wcsncpy(abspath, reader_current_dir, READER_PATH_MAX);
  644.   len = reader_wcslen(abspath);
  646.   //remove the pervious directory string
  647.   if (abspath[len-1] == '/') {
  648.     abspath[len-1] = ''; 
  649.   }
  650.   p = reader_wcsrchr(abspath, '/');
  651.   assert(p != NULL);
  652.   reader_wcsncpy(prevpath, &p[1], READER_PATH_MAX);
  653.   if (p == abspath) {
  654.     //keep '/' for root dir
  655.     p[1] = '';
  656.   } else {
  657.     *p = '';
  658.   }
  659.   if (0 != (ret = reader_file_set_dir(abspath))) {
  660.     console_log("upper dir failed.");
  661.     return ret;
  662.   }
  663.   //back to upper dir, locate cursor to the previous dir
  664.   i = reader_dir_set_cursor_by_name(prevpath);
  665.   if (i >= 0) {
  666.     reader_file_menu_cursor = i;
  667.   } else {
  668.     reader_file_menu_cursor = 0;
  669.   }
  671.   return 0;
  672. }