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

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

编辑器/阅读器

开发平台：

C/C++

reader_option.c：源码内容
  1. #include <reader_core.h>
  3. enum {
  4.   MAX_INTERVAL = 100,
  5.   MIN_INTERVAL = 10,
  6.   INTERVAL = 5,
  7.   FILENAME_BUF_SIZE = 1024,
  8.   MAX_FILES = 32,
  9.   BMP_ID = 0x4d42 //'BM'
  10. };
  12. typedef enum _tag_cursor_pos_t {
  13.   BRIGHTNESS_DR = 0,
  14.   ENABLE_BG_PIC,
  15.   BG_PIC_SETTING,
  16.   ENABLE_TIMER,
  17.   TIMER_SETTING,
  18.   LOCK_L
  19. } cursor_pos_t;
  21. reader_option_saver_t reader_option, reader_option_bak;
  23. reader_option_saver_t reader_option_def;
  25. static cursor_pos_t cursor;
  26. static void draw_cursor(screen_t screen);
  28. /***************************************************************
  29. The number N of displayed file names is limited by
  30. the MAX_FILES(N <= MAX_FILES) and 
  31. the FILENAME_BUF_SIZE (the total length of N files <= FILENAME_BUF_SIZE)
  32. ****************************************************************/
  33. static int collect_bitmap_filenames(unsigned short *buf, unsigned short **pointers, int max_size);
  34. static unsigned short *ptr_bitmap_filesnames[MAX_FILES];
  35. static unsigned short bitmap_filenames[FILENAME_BUF_SIZE];
  37. static int bg_pic_index;
  38. static void dec_bg_pic_index(void);
  39. static void inc_bg_pic_index(void);
  41. static int bg_pic_num;
  43. static int dec_brightness(void);
  44. static int inc_brightness(void);
  46. static int has_bg() {
  47.   return (bg_pic_num > 0);
  48. };
  50. void reader_option_draw_menu(screen_t screen) {
  51.   int text_pos_y[] = {30, 60, 110, 160, 230};
  52.   unsigned char *strs[] = {lcd_brightness_str, enable_bg_pic_str, timer_turn, lock_l_str, ab_prompt};
  53.   int i, ti;
  54.   unsigned short *p, *p2;
  55.   color_t time_color = READER_COLOR_WHITE, tc;
  56.   unsigned short buf[4] = {0};
  58.   reader_mmi_fill_screen(screen, READER_COLOR_BLACK);
  60.   reader_caption(screen, READER_STR(option_str));
  62.   //static text
  63.   for (i = 0; i < _dim(text_pos_y); i++) {
  64.     p = READER_STR(strs[i]);
  65.     tc = READER_COLOR_WHITE;
  66.     if ((unsigned char *)p == lcd_brightness_str) {
  67.       //show brightness value
  68.       ti = reader_option.brightness;
  69.       assert(ti <= 3);
  70.       reader_itoa(ti+1, buf);
  71.       reader_textout_ex(screen, 164, text_pos_y[i], buf, 1, DEFAULT_FONT_SIZE, READER_COLOR_WHITE, 0);
  72.     } else if ((unsigned char *)p == lock_l_str) {
  73.       if (reader_option.lock_l) {
  74.         p2 = READER_STR(yes_str);
  75.       } else {
  76.         p2 = READER_STR(no_str);
  77.       }
  78.       reader_textout_ex(screen, 160, text_pos_y[i], p2, reader_wcslen(p2), DEFAULT_FONT_SIZE, READER_COLOR_WHITE, 0);
  79.     } else if ((unsigned char *)p == timer_turn) {
  80.       if (reader_option.enable_timer) {
  81.         p2 = READER_STR(yes_str);
  82.       } else {
  83.         p2 = READER_STR(no_str);
  84.         time_color = READER_COLOR_GREY;
  85.       }
  86.       reader_textout_ex(screen, 160, text_pos_y[i], p2, reader_wcslen(p2), DEFAULT_FONT_SIZE, READER_COLOR_WHITE, 0);
  87.     } else if ((unsigned char *)p == enable_bg_pic_str) {
  88.       if (! has_bg()) {
  89.         reader_option.enable_bg_pic = 0;
  90.         tc = READER_COLOR_GREY;
  91.       }
  92.       if (reader_option.enable_bg_pic) {
  93.         p2 = READER_STR(yes_str);
  94.       } else {
  95.         p2 = READER_STR(no_str);
  96.       }
  97.       reader_textout_ex(screen, 160, text_pos_y[i], p2, reader_wcslen(p2), DEFAULT_FONT_SIZE, 
  98.         tc, 0);
  99.     }
  100.     reader_textout_ex(screen, 0, text_pos_y[i], p, reader_wcslen(p), DEFAULT_FONT_SIZE, tc, 0);
  101.   }
  103.   //show time option in grey if timer is disabled
  104.   //else in white
  105.   p = READER_STR(time_str);
  106.   reader_textout_ex(screen, 0, 130, p, reader_wcslen(p), DEFAULT_FONT_SIZE, time_color, 0);
  107.   p = READER_STR(second_str);
  108.   reader_textout_ex(screen, 160, 130, p, reader_wcslen(p), DEFAULT_FONT_SIZE, time_color, 0);
  109.   ti = reader_option.timer_interval;
  110.   assert(ti >= MIN_INTERVAL && ti <= MAX_INTERVAL);
  111.   i = reader_itoa(ti, buf);
  112.   reader_textout_ex(screen, 140, 130, buf, i, DEFAULT_FONT_SIZE, time_color, TEXT_OUT_ALIGN_RIGHT);
  114.   //show pic name or no_pic message
  115.   if (! has_bg()) {
  116.     p = READER_STR(no_bg_pic_msg);
  117.     reader_textout_ex(screen, 0, 80, p, reader_wcslen(p), DEFAULT_FONT_SIZE, READER_COLOR_GREY, 0);
  118.   } else {
  119.     p = READER_STR(bg_pic_str);
  120.     reader_textout_ex(screen, 0, 80, p, reader_wcslen(p), DEFAULT_FONT_SIZE, READER_COLOR_WHITE, 0);
  121.     //use the first file if the bg pic is not set yet
  122.     p = (*(reader_option.pic_name) ? reader_option.pic_name : ptr_bitmap_filesnames[bg_pic_index]);
  123.     reader_textout_ex(screen, 60, 80, p, reader_wcslen(p), DEFAULT_FONT_SIZE, 
  124.       (color_t)(reader_option.enable_bg_pic ? READER_COLOR_WHITE : READER_COLOR_GREY), 0);
  125.   }
  127.   draw_cursor(screen);
  129.   reader_mmi_trigger_screen_update(screen);
  130. }
  132. void reader_option_init(void) {
  133.   memset(&reader_option_def, 0, sizeof(reader_option_def));
  134.   reader_option_def.timer_interval = 20;
  135.   bg_pic_num = collect_bitmap_filenames(bitmap_filenames, ptr_bitmap_filesnames, MAX_FILES);
  136.   if (bg_pic_num > 0) {
  137.     reader_option_def.enable_bg_pic = 1;
  138.     reader_wcscpy(reader_option_def.pic_name, ptr_bitmap_filesnames[0]);
  139.   }
  140. }
  142. static void draw_cursor(screen_t screen) {
  143.   point_t cursor_pos[] = {
  144.     {150, 40}, {186, 40},
  145.     {150, 70}, {186, 70},
  146.     {50, 90}, {186, 90},
  147.     {150, 120}, {186, 120},
  148.     {110, 140}, {150, 140},
  149.     {150, 170}, {186, 170},
  150.   };
  151.   point_t *p = cursor_pos + cursor*2;
  153.   reader_arrow(screen, p[0].x, p[0].y, 5, LEFT_POINTER, READER_COLOR_YELLOW);
  154.   reader_arrow(screen, p[1].x, p[1].y, 5, RIGHT_POINTER, READER_COLOR_YELLOW);
  155. }
  157. int reader_option_cursor_up(void) {
  158.   switch (cursor) {
  159.   case BRIGHTNESS_DR:
  160.     return 1;
  161.   case LOCK_L:
  162.     if (reader_option.enable_timer) {
  163.       cursor = TIMER_SETTING;
  164.     } else {
  165.       cursor = ENABLE_TIMER;
  166.     }
  167.     return 0;
  168.   case ENABLE_TIMER:
  169.     if (! has_bg()) {
  170.       cursor = BRIGHTNESS_DR;
  171.       return 0;
  172.     }
  173.     if (reader_option.enable_bg_pic) {
  174.       cursor = BG_PIC_SETTING;
  175.     } else {
  176.       cursor = ENABLE_BG_PIC;
  177.     }
  178.     return 0;
  179.   case TIMER_SETTING:
  180.   case BG_PIC_SETTING:
  181.   case ENABLE_BG_PIC:
  182.     cursor --;
  183.     return 0;
  184.   default:
  185.     assert(0);
  186.   }
  187.   return 0;
  188. }
  190. int reader_option_cursor_down(void) {
  191.   switch (cursor) {
  192.   case BRIGHTNESS_DR:
  193.     if (has_bg()) {
  194.       cursor = ENABLE_BG_PIC;
  195.     } else {
  196.       cursor = ENABLE_TIMER;
  197.     }
  198.     return 0;
  199.   case BG_PIC_SETTING:
  200.   case TIMER_SETTING:
  201.     cursor ++;
  202.     return 0;
  203.   case ENABLE_TIMER:
  204.     if (reader_option.enable_timer) {
  205.       cursor = TIMER_SETTING;
  206.     }
  207.     else {
  208.       cursor = LOCK_L;
  209.     }
  210.     return 0;
  211.   case ENABLE_BG_PIC:
  212.     if (reader_option.enable_bg_pic) {
  213.       cursor = BG_PIC_SETTING;
  214.     } else {
  215.       cursor = ENABLE_TIMER;
  216.     }
  217.     return 0;
  218.   case LOCK_L:
  219.     return 1;
  220.   default:
  221.     assert(0);
  222.   }
  223.   return 0;
  224. }
  226. int reader_option_cursor_left(void) {
  227.   switch (cursor) {
  228.   case BRIGHTNESS_DR:
  229.     return dec_brightness();
  230.   case LOCK_L:
  231.     if (reader_option.lock_l) {
  232.       reader_option.lock_l = 0;
  233.     } else {
  234.       reader_option.lock_l = 1;
  235.     }
  236.     return 0;
  237.   case ENABLE_TIMER:
  238.     if (reader_option.enable_timer) {
  239.       reader_option.enable_timer = 0;
  240.     } else {
  241.       reader_option.enable_timer = 1;
  242.     }
  243.     return 0;
  244.   case TIMER_SETTING: {
  245.     int t = reader_option.timer_interval;
  246.     assert(t >= MIN_INTERVAL);
  247.     if (t == MIN_INTERVAL) {
  248.       return 1;
  249.     }
  250.     t -= INTERVAL;
  251.     reader_option.timer_interval = t;
  252.     return 0;
  253.           }
  254.   case ENABLE_BG_PIC:
  255.     if (reader_option.enable_bg_pic) {
  256.       reader_option.enable_bg_pic = 0;
  257.     } else {
  258.       reader_option.enable_bg_pic = 1;
  259.       if (reader_option.pic_name[0] == 0) { //not initialized
  260.         reader_wcscpy(reader_option.pic_name, ptr_bitmap_filesnames[bg_pic_index]);
  261.       }
  262.     }
  263.     return 0;
  264.   case BG_PIC_SETTING:
  265.     dec_bg_pic_index();
  266.     return 0;
  267.   default:
  268.     assert(0);
  269.     break;
  270.   }
  272.   return 1;
  273. }
  275. int reader_option_cursor_right(void) {
  276.   switch (cursor) {
  277.   case BRIGHTNESS_DR:
  278.     return inc_brightness();
  279.   case LOCK_L:
  280.   case ENABLE_TIMER:
  281.   case ENABLE_BG_PIC:
  282.     //the inverse logic is the same with cursor_left()
  283.     return reader_option_cursor_left();
  284.   case TIMER_SETTING: {
  285.     int t = reader_option.timer_interval;
  286.     assert(t <= MAX_INTERVAL);
  287.     if (t == MAX_INTERVAL) {
  288.       return 1;
  289.     }
  290.     t += INTERVAL;
  291.     reader_option.timer_interval = t;
  292.     return 0;
  293.           }
  294.   case BG_PIC_SETTING:
  295.     inc_bg_pic_index();
  296.     return 0;
  297.   default:
  298.     assert(0);
  299.     break;
  300.   }
  302.   return 1;
  303. }
  305. static void check_cursor(void) {
  306.   if (cursor == TIMER_SETTING && (! reader_option.enable_timer)) {
  307.     cursor = ENABLE_TIMER;
  308.   }
  310.   if (cursor == BG_PIC_SETTING && (! reader_option.enable_bg_pic)) {
  311.     cursor = ENABLE_BG_PIC;
  312.   }
  314. }
  316. void reader_option_select_ready(void) {
  317.   check_cursor();
  318.   memcpy(&reader_option_bak, &reader_option, sizeof(reader_option));
  319. }
  321. void reader_option_select_cancel(void) {
  322.   memcpy(&reader_option, &reader_option_bak, sizeof(reader_option));
  323.   //restore brightness
  324.   reader_dev_dsl_set_brightness(reader_option.brightness);
  325. }
  327. int reader_option_lkey_locked(void) {
  328.   return reader_option.lock_l;
  329. }
  331. int reader_option_timer_enabled(void) {
  332.   return reader_option.enable_timer;
  333. }
  335. int reader_option_timer_interval(void) {
  336.   return reader_option.timer_interval;
  337. }
  339. int reader_option_bg_pic_enabled(void) {
  340.   return reader_option.enable_bg_pic;
  341. }
  343. void reader_option_disable_bg_pic(void) {
  344.   reader_option.enable_bg_pic = 0;
  345. }
  347. unsigned short *reader_option_bg_pic(void) {
  348.   return reader_option.pic_name;
  349. }
  351. //-- turn timer control
  352. static unsigned int turn_timer_v;
  353. int reader_option_turn_timer_check(unsigned int e) {
  354.   if (turn_timer_v < e) {
  355.     return 1;
  356.   }
  357.   turn_timer_v -= e;
  358.   return 0;
  359. }
  361. void reader_option_turn_timer_reset(void) {
  362.   turn_timer_v = reader_option_timer_interval() * 1000; //in ms
  363. }
  365. //-- fs access helper
  366. //return 0 means OK, 1 means invalid
  367. static int check_pic_content(unsigned short *bmpfile) {
  368.   fsal_file_handle_t fd = fsal_open(bmpfile, "rb");
  369.   char buf[sizeof(BMPHeader0)+sizeof(BMP_Headers)];
  370.   int nr;
  371.   BMPHeader0 *pheader0;
  372.   BMP_Headers *pheader;
  374.   if (fd == 0) {
  375.     goto err;
  376.   }
  377.   nr = fsal_read(buf, sizeof(buf), 1, fd);
  378.   if (nr != 1) {
  379.     goto err;
  380.   }
  381.   fsal_close(fd);
  382.   pheader0 = (BMPHeader0 *)buf;
  383.   READER_TRACEW((L"bmpfile=%s ", bmpfile));
  384.   READER_TRACE(("id=%xn", pheader0->Id));
  385.   if (pheader0->Id != BMP_ID) {
  386.     goto err;
  387.   }
  388.   pheader = (BMP_Headers *)(buf+sizeof(BMPHeader0));
  389.   READER_TRACE(("colors=%dn", pheader->NColors));
  390.   if ((pheader->Width != READER_SCREEN_HEIGHT)
  391.     ||(pheader->Height != READER_SCREEN_WIDTH)
  392.     ||(pheader->Compression != 0 )) {
  393.     goto err;
  394.   }
  396.   return 0;
  398. err:
  399.   if (fd != 0) {
  400.     fsal_close(fd);
  401.   }
  402.   return 1;
  403. }
  405. //return 1 means the input file should be filtered
  406. //return 0 means the input file is qualified
  407. static int bg_pic_filter(unsigned short *filename, struct stat *st) {
  408.   unsigned short ext1[5] = {'.', 'b', 'm', 'p', 0};
  409.   unsigned short ext2[5] = {'.', 'B', 'M', 'P', 0};
  410.   unsigned short *p;
  411.   static unsigned short pic_name[READER_FILENAME_MAX];
  413.   if (st->st_mode & S_IFDIR) {
  414.     return 1;
  415.   }
  416.   p = reader_wcsrchr(filename, '.');
  417.   if (p == NULL) {
  418.     return 1;
  419.   }
  420.   if ((memcmp(p, ext1, 10) != 0)
  421.     && (memcmp(p, ext2, 10) != 0)) {
  422.     return 1;
  423.   }
  424.   reader_full_pic_name(pic_name, filename);
  425.   return check_pic_content(pic_name);
  426. }
  428. static int collect_bitmap_filenames(unsigned short *buf, unsigned short **pointers, int max_size) {
  429.   fsal_dir_handle_t dir_handle;
  430.   int i, len;
  431.   struct stat st;
  432.   int cursor = 0;
  433.   unsigned short *p;
  434.   static unsigned short filename[READER_PATH_MAX]; //no stack overhead
  436.   dir_handle = fsal_diropen(reader_path_bg);
  437.   if (0 == dir_handle) {
  438.     return 0;
  439.   }
  440.   i = 0;
  441.   while ((i < MAX_FILES)
  442.     && (fsal_dirnext(dir_handle, filename, &st) == 0)) {
  443.     if (*filename == 0) {
  444.       //no lfn is found
  445.       continue;
  446.     }
  447.     if (0 == bg_pic_filter(filename, &st)) {
  448.       len = reader_wcslen(filename);
  449.       if (cursor+len+1 > FILENAME_BUF_SIZE) {
  450.         break;
  451.       }
  452.       p = buf+cursor;
  453.       reader_wcsncpy(p, filename, len);
  454.       p[len] = 0;
  455.       cursor += len+1; //move over last ''
  456.       pointers[i ++] = p;
  457.     }
  458.   }
  460.   return i;
  461. }
  463. //-- bg pic index operators
  464. static void dec_bg_pic_index(void) {
  465.   bg_pic_index --;
  466.   if (bg_pic_index < 0) {
  467.     bg_pic_index = bg_pic_num - 1;
  468.   }
  469.   reader_wcscpy(reader_option.pic_name, ptr_bitmap_filesnames[bg_pic_index]);
  470. }
  472. static void inc_bg_pic_index(void) {
  473.   bg_pic_index ++;
  474.   if (bg_pic_index >= bg_pic_num) {
  475.     bg_pic_index = 0;
  476.   }
  477.   reader_wcscpy(reader_option.pic_name, ptr_bitmap_filesnames[bg_pic_index]);
  478. }
  480. //-- dsl brightness operators
  481. static int dec_brightness(void) {
  482.   if (reader_option.brightness > 0) {
  483.     reader_option.brightness --;
  484.     reader_dev_dsl_set_brightness(reader_option.brightness);
  485.     return 0;
  486.   }
  487.   return 1;
  488. }
  490. static int inc_brightness(void) {
  491.   if (reader_option.brightness < 3) {
  492.     reader_option.brightness ++;
  493.     reader_dev_dsl_set_brightness(reader_option.brightness);
  494.     return 0;
  495.   }
  496.   return 1;
  497. }