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

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

编辑器/阅读器

开发平台：

C/C++

reader_mmi.c：源码内容
  1. #include <reader_core.h>
  3. void reader_mmi_trigger_screen_update(screen_t screen) {
  4. #ifdef USE_DOUBLE_FRAME_BUFFER
  5.   trigger_screen_update(screen);
  6. #endif
  7. }
  9. void reader_mmi_fill_screen(screen_t screen, color_t color) {
  10.   fill_screen(screen, color);
  11. }
  13. void reader_mmi_fill_screen_trigger(screen_t screen, color_t color) {
  14.   fill_screen(screen, color);
  15.   trigger_screen_update(screen);
  16. }
  18. static int info_visible;
  20. int reader_info_visible(void) {
  21.   return info_visible;
  22. }
  24. void reader_set_info_visible(int v) {
  25.   info_visible = (v != 0);
  26. }
  28. int get_header_blank(int fs) {
  29.   switch (fs) {
  30.   case DEFAULT_FONT_SIZE:
  31.     return 3;
  32.   case 14:
  33.     return 2;
  34.   default:
  35.     assert(0);
  36.   }
  37.   //never reach here
  38.   return -1;
  39. }
  41. int reader_get_start_x(int fs) {
  42.   switch (fs) {
  43.   case DEFAULT_FONT_SIZE:
  44.     return 0;
  45.   case 14:
  46.     return 4;
  47.   default:
  48.     assert(0);
  49.   }
  50.   //never reach here
  51.   return -1;
  52. }
  54. unsigned short *reader_load_bmp(unsigned short *bmpfile) {
  55.   static unsigned short bmp_buf[READER_SCREEN_WIDTH*READER_SCREEN_HEIGHT];
  56.   static unsigned short last_access_file[READER_FILENAME_MAX];
  57.   fsal_file_handle_t fd = 0;
  58.   int len, nr;
  59.   void *p = NULL;
  61.   //try the last access cache
  62.   if (reader_wcscmp(bmpfile, last_access_file) == 0) {
  63.     return bmp_buf;
  64.   }
  65.   reader_wcscpy(last_access_file, bmpfile);
  66.   fd = fsal_open(bmpfile, "rb");
  67.   if (fd == 0) {
  68.     goto err;
  69.   }
  70.   fsal_seek(fd, 0, SEEK_END);
  71.   len = fsal_tell(fd);
  72.   fsal_rewind(fd);
  73.   p = malloc(len);
  74.   if (p == NULL) {
  75.     goto err;
  76.   }
  77.   nr = fsal_read(p, len, 1, fd);
  78.   if (nr != 1) {
  79.     goto err;
  80.   }
  81.   fsal_close(fd);
  82.   PA_LoadBmpToBuffer(bmp_buf, 0, 0, p, READER_SCREEN_HEIGHT);
  83.   free(p);
  84.   return bmp_buf;
  85. err:
  86.   if (fd != 0) {
  87.     fsal_close(fd);
  88.   }
  89.   if (p != NULL) {
  90.     free(p);
  91.   }
  92.   return NULL;
  93. }
  95. void reader_mmi_update_screen(screen_t screen, unsigned short *content, int page_number) {
  96.   page_t *page = reader_pages + page_number;
  97.   int i, j;
  98.   int lines;
  99.   int last_line_chars;
  100.   unsigned short page_number_str[16];
  101.   int fs = reader_get_font_size();
  102.   int header = get_header_blank(fs);
  103.   int max_line = reader_get_max_line(fs);
  104.   int start_x = reader_get_start_x(fs);
  105.   unsigned short *bmpbuf;
  106.   unsigned short pic_name[READER_FILENAME_MAX];
  108.   if (reader_option_bg_pic_enabled()) {
  109.     reader_full_pic_name(pic_name, reader_option_bg_pic());
  110.     if ((bmpbuf = reader_load_bmp(pic_name)) != NULL) {
  111.       fill_screen_bitmap(screen, bmpbuf);
  112.     } else {
  113.       //can not load bg pic
  114.       reader_option_disable_bg_pic();
  115.       fill_screen(screen, reader_bg_color);
  116.     }
  117.   } else {
  118.     fill_screen(screen, reader_bg_color);
  119.   }
  121.   if (page_number >= reader_total_pages) {
  122.     //erase screen anyway
  123. #ifdef USE_DOUBLE_FRAME_BUFFER
  124.     trigger_screen_update(screen);
  125. #endif
  126.     return;
  127.   }
  129.   content += page->page_offset;
  131.   if (page_number == reader_total_pages - 1) { //last page
  132.     lines = reader_last_page_lines;
  133.   } else {
  134.     lines = max_line;
  135.   }
  137.   if (! info_visible) {
  138.     header += 6;
  139.   }
  141.   for (i = 0; i < lines - 1; i++) {
  142.     reader_textout(screen, start_x, i * (fs + LINE_INTERVAL) + header, content + page->line_offest[i], page->line_offest[i + 1] - page->line_offest[i], fs);
  143.   }
  144.   if (page_number == reader_total_pages - 1) {
  145.     last_line_chars = reader_last_line_chars;
  146.   } else {
  147.     last_line_chars = reader_pages[page_number + 1].page_offset - (reader_pages[page_number].page_offset + page->line_offest[i]);
  148.   }
  149.   reader_textout(screen, start_x, i * (fs + LINE_INTERVAL) + header, content + page->line_offest[i], last_line_chars, fs);
  151.   if (info_visible) {
  152.     //show page number at the bottom line
  153.     page_number ++; //start from index 0, show from 1
  154.     if (page_number & 1) {
  155.       //show page number in left screen
  156.       if (page_number > reader_total_pages) {
  157.         page_number = reader_total_pages;
  158.       }
  159.       i = reader_itoa(page_number, page_number_str);
  160.       page_number_str[i ++] = '/';
  161.       j = reader_itoa(reader_total_pages, page_number_str + i);
  162.       assert(i + j < 12);
  163.       if (reader_get_layout()) {
  164.         //append compact layout flag
  165.         reader_wcsncpy(&page_number_str[i+j], READER_STR(compact_layout_flag), 3);
  166.         page_number_str[i + j + 3] = 0;
  167.       } else {
  168.         page_number_str[i + j] = 0;
  169.       }
  170.       reader_textout_ex(screen, 0, max_line * (fs + LINE_INTERVAL) + header, page_number_str, 16, fs, READER_COLOR_BLUE, 0);
  171.       i = reader_itoa(page_number * 100 / reader_total_pages, page_number_str);
  172.       page_number_str[i ++] = '%';
  173.       reader_textout_ex(screen, READER_SCREEN_WIDTH - 1, max_line * (fs + LINE_INTERVAL) + header, page_number_str, i, fs, READER_COLOR_BLUE, TEXT_OUT_ALIGN_RIGHT);
  174.     } else {
  175.       //show progress bar in right screen
  176.       int y1 = max_line * (fs + LINE_INTERVAL) + header + 6;
  177.       int x_cur = page_number * (READER_SCREEN_WIDTH - 5) / reader_total_pages;
  178.       reader_rectangle(screen, 0, y1, READER_SCREEN_WIDTH - 1, y1 + 3, READER_COLOR_BLUE, 1);
  179.       reader_rectangle(screen, x_cur, y1, x_cur + 3, y1 + 3, READER_COLOR_YELLOW, 1);
  180.     }
  181.   }
  183. #ifdef USE_DOUBLE_FRAME_BUFFER
  184.   trigger_screen_update(screen);
  185. #endif
  186. }
  188. int reader_current_page;
  190. int reader_turn_next_page() {
  191.   if (reader_current_page + 2 < reader_total_pages) {
  192.     reader_current_page += 2;
  193.     return 0;
  194.   }
  195.   return 1;
  196. }
  198. int reader_turn_prev_page() {
  199.   if (reader_current_page >= 2) {
  200.     reader_current_page -= 2;
  201.     return 0;
  202.   }
  203.   return 1;
  204. }
  206. int reader_turn_next_page10() {
  207.   int pg = reader_current_page;
  208.   pg += 10;
  209.   if (pg > reader_total_pages - 1) {
  210.     pg = (reader_total_pages - 1) / 2 * 2;
  211.   }
  212.   if (pg != reader_current_page) {
  213.     reader_current_page = pg;
  214.     return 0;
  215.   }
  216.   return 1;
  217. }
  219. int reader_turn_prev_page10() {
  220.   int pg = reader_current_page;
  221.   pg -= 10;
  222.   if (pg < 0) {
  223.     pg = 0;
  224.   }
  225.   if (pg != reader_current_page) {
  226.     reader_current_page = pg;
  227.     return 0;
  228.   }
  229.   return 1;
  230. }
  232. int reader_get_current_page() {
  233.   return reader_current_page;
  234. }
  236. int reader_set_current_page(int pg) {
  237.   unsigned int old = reader_current_page;
  238.   //page number must be even for dual screen
  239.   if (pg & 1) {
  240.     pg --;
  241.   }
  242.   reader_current_page = pg;
  243.   return old;
  244. }