viewer.c

编译后直接运行的ＭＰ３播放器全部Ｃ语言源代码 一个包含FAT文件系统、系统引导 Boot、FLASH Driver等内容的

                line_end = find_next_line(line_begin);
                if (line_end == NULL)  /* Should not really happen */
                    break;
            }
        }
        line_len = line_end - line_begin;

        if (line_mode == JOIN) {
            if (line_begin[0] == 0) {
                line_begin++;
                if (word_mode == CHOP)
                    line_end++;
            }
            for (j=k=spaces=0; j < line_len; j++) {
                if (k == MAX_COLUMNS)
                    break;

                c = line_begin[j];
                switch (c) {
                    case ' ':
                        spaces++;
                        break;
                    case 0:
                        spaces = 0;
                        scratch_buffer[k++] = ' ';
                        break;
                    default:
                        while (spaces) {
                            spaces--;
                            scratch_buffer[k++] = ' ';
                            if (k == MAX_COLUMNS - 1)
                                break;
                        }
                        scratch_buffer[k++] = c;
                        break;
                }
            }
            if (col != -1)
                if (k > col) {
                    scratch_buffer[k] = 0;
                    rb->lcd_puts(left_col, i, scratch_buffer + col);
                }
        }
        else {
            if (col != -1)
                if (line_len > col) {
                    c = line_end[0];
                    line_end[0] = 0;
                    rb->lcd_puts(left_col, i, line_begin + col);
                    line_end[0] = c;
                }
        }
        if (line_len > max_line_len)
            max_line_len = line_len;

        if (i == 0)
            next_line_ptr = line_end;
    }
    next_screen_ptr = line_end;
    if (BUFFER_OOB(next_screen_ptr))
        next_screen_ptr = NULL;

#ifdef HAVE_LCD_BITMAP
    next_screen_to_draw_ptr = page_mode==OVERLAP? line_begin: next_screen_ptr;

    if (need_scrollbar)
        viewer_scrollbar();

    if (col != -1)
        rb->lcd_update();
#else
    next_screen_to_draw_ptr = next_screen_ptr;
#endif
}

static void viewer_top(void)
{
    /* Read top of file into buffer
      and point screen pointer to top */
    file_pos = 0;
    buffer_end = BUFFER_END();  /* Update whenever file_pos changes */
    screen_top_ptr = buffer;
    fill_buffer(0, buffer, BUFFER_SIZE);
}

static void viewer_bottom(void)
{
    /* Read bottom of file into buffer
      and point screen pointer to bottom */
    long last_sectors;

    if (file_size > BUFFER_SIZE) {
        /* Find last buffer in file, round up to next sector boundary */
        last_sectors = file_size - BUFFER_SIZE + SMALL_BLOCK_SIZE;
        last_sectors /= SMALL_BLOCK_SIZE;
        last_sectors *= SMALL_BLOCK_SIZE;
    }
    else {
        last_sectors = 0;
    }
    file_pos = last_sectors;
    buffer_end = BUFFER_END();  /* Update whenever file_pos changes */
    screen_top_ptr = buffer_end-1;
    fill_buffer(last_sectors, buffer, BUFFER_SIZE);
}

#ifdef HAVE_LCD_BITMAP
static void init_need_scrollbar(void) {
    /* Call viewer_draw in quiet mode to initialize next_screen_ptr,
     and thus ONE_SCREEN_FITS_ALL(), and thus NEED_SCROLLBAR() */
    viewer_draw(-1);
    need_scrollbar = NEED_SCROLLBAR();
}
#endif

static bool viewer_init(char* file)
{
#ifdef HAVE_LCD_BITMAP
    int w,h;

    rb->lcd_getstringsize("o", &w, &h);
    display_lines = LCD_HEIGHT / h;
    display_columns = LCD_WIDTH / w;
#else
    display_lines = 2;
    display_columns = 11;
#endif
    /*********************
    * (Could re-initialize settings here, if you
    *   wanted viewer to start the same way every time)
    word_mode = WRAP;
    line_mode = NORMAL;
    view_mode = NARROW;
#ifdef HAVE_LCD_BITMAP
    page_mode = NO_OVERLAP;
    scrollbar_mode[NARROW] = SB_OFF;
    scrollbar_mode[WIDE] = SB_ON;
#endif
    **********************/

    fd = rb->open(file, O_RDONLY);
    if (fd==-1)
        return false;

    file_size = rb->filesize(fd);
    if (file_size==-1)
        return false;

    /* Init mac_text value used in processing buffer */
    mac_text = false;

    /* Read top of file into buffer;
      init file_pos, buffer_end, screen_top_ptr */
    viewer_top();

#ifdef HAVE_LCD_BITMAP
    /* Init need_scrollbar value */
    init_need_scrollbar();
#endif

    return true;
}

static void viewer_exit(void)
{
    rb->close(fd);
}

static int col_limit(int col)
{
    if (col < 0)
        col = 0;
    else
        if (col > max_line_len - 2)
            col = max_line_len - 2;

    return col;
}

#ifdef HAVE_LCD_BITMAP
static int viewer_recorder_on_button(int col)
{
    bool exit = false;

    while (!exit) {
        switch (rb->button_get(true)) {
            case BUTTON_ON | BUTTON_F1:
                /* Page-overlap mode */
                if (++page_mode == PAGE_MODES)
                    page_mode = 0;

                rb->splash(HZ, true, "%s %s",
                           page_mode_str[page_mode],
                           page_mode_str[PAGE_MODES]);

                viewer_draw(col);
                break;

            case BUTTON_ON | BUTTON_F3:
                /* Show-scrollbar mode for current view-width mode */
                if (!(ONE_SCREEN_FITS_ALL())) {
                    if (++scrollbar_mode[view_mode] == SCROLLBAR_MODES)
                        scrollbar_mode[view_mode] = 0;

                    init_need_scrollbar();
                    viewer_draw(col);

                    rb->splash(HZ, true, "%s %s (%s %s)",
                               scrollbar_mode_str[SCROLLBAR_MODES],
                               scrollbar_mode_str[scrollbar_mode[view_mode]],
                               view_mode_str[view_mode],
                               view_mode_str[VIEW_MODES]);
                }
                viewer_draw(col);
                break;

            case BUTTON_ON | BUTTON_UP:
            case BUTTON_ON | BUTTON_UP | BUTTON_REPEAT:
                /* Scroll up one line */
                viewer_scroll_up();
                viewer_draw(col);
                break;

            case BUTTON_ON | BUTTON_DOWN:
            case BUTTON_ON | BUTTON_DOWN | BUTTON_REPEAT:
                /* Scroll down one line */
                if (next_screen_ptr != NULL)
                    screen_top_ptr = next_line_ptr;

                viewer_draw(col);
                break;

            case BUTTON_ON | BUTTON_LEFT:
            case BUTTON_ON | BUTTON_LEFT | BUTTON_REPEAT:
                /* Scroll left one column */
                col--;
                col = col_limit(col);
                viewer_draw(col);
                break;

            case BUTTON_ON | BUTTON_RIGHT:
            case BUTTON_ON | BUTTON_RIGHT | BUTTON_REPEAT:
                /* Scroll right one column */
                col++;
                col = col_limit(col);
                viewer_draw(col);
                break;

            case BUTTON_ON | BUTTON_REL:
            case BUTTON_ON | BUTTON_DOWN | BUTTON_REL:
            case BUTTON_ON | BUTTON_UP | BUTTON_REL:
                /* Drop out of this loop (when ON btn released) */
                exit = true;
                break;
        }
    }
    return col;
}
#endif

enum plugin_status plugin_start(struct plugin_api* api, void* file)
{
    bool exit=false;
    int col = 0;
    int i;
    int ok;

    TEST_PLUGIN_API(api);
    rb = api;

    if (!file)
        return PLUGIN_ERROR;

    ok = viewer_init(file);
    if (!ok) {
        rb->splash(HZ, false, "Error");
        viewer_exit();
        return PLUGIN_OK;
    }

    viewer_draw(col);

    while (!exit) {
        switch (rb->button_get(true)) {
#ifdef HAVE_RECORDER_KEYPAD
            case BUTTON_OFF:
#else
            case BUTTON_STOP:
#endif
                viewer_exit();
                exit = true;
                break;

#ifdef HAVE_RECORDER_KEYPAD
            case BUTTON_F1:
#else
            case BUTTON_ON | BUTTON_LEFT:
#endif
                /* Word-wrap mode: WRAP or CHOP */
                if (++word_mode == WORD_MODES)
                    word_mode = 0;

#ifdef HAVE_LCD_BITMAP
                init_need_scrollbar();
#endif
                viewer_draw(col);

                rb->splash(HZ, true, "%s %s",
                           word_mode_str[word_mode],
                           word_mode_str[WORD_MODES]);

                viewer_draw(col);
                break;

#ifdef HAVE_RECORDER_KEYPAD
            case BUTTON_F2:
#else
            case BUTTON_ON | BUTTON_MENU | BUTTON_RIGHT:
#endif
                /* Line-paragraph mode: NORMAL, JOIN or EXPAND */
                if (++line_mode == LINE_MODES)
                    line_mode = 0;

                if (view_mode == WIDE)
                    if (line_mode == JOIN)
                        if (++line_mode == LINE_MODES)
                            line_mode = 0;

#ifdef HAVE_LCD_BITMAP
                init_need_scrollbar();
#endif
                viewer_draw(col);

                rb->splash(HZ, true, "%s %s",
                           line_mode_str[line_mode],
                           line_mode_str[LINE_MODES]);

                viewer_draw(col);
                break;

#ifdef HAVE_RECORDER_KEYPAD
            case BUTTON_F3:
#else
            case BUTTON_ON | BUTTON_RIGHT:
#endif
                /* View-width mode: NARROW or WIDE */
                if (line_mode == JOIN)
                    rb->splash(HZ, true, "(no %s %s)",
                               view_mode_str[WIDE],
                               line_mode_str[JOIN]);
                else
                    if (++view_mode == VIEW_MODES)
                        view_mode = 0;

                col = 0;

                /***** Could do this after change of word-wrap mode
                * and after change of view-width mode, to normalize
                * view:
                if (screen_top_ptr > buffer + BUFFER_SIZE/2) {
                    screen_top_ptr = find_prev_line(screen_top_ptr);
                    screen_top_ptr = find_next_line(screen_top_ptr);
                }
                else {
                    screen_top_ptr = find_next_line(screen_top_ptr);
                    screen_top_ptr = find_prev_line(screen_top_ptr);
                }
                ***********/

#ifdef HAVE_LCD_BITMAP
                init_need_scrollbar();
#endif
                viewer_draw(col);

                rb->splash(HZ, true, "%s %s",
                           view_mode_str[view_mode],
                           view_mode_str[VIEW_MODES]);

                viewer_draw(col);
                break;

#ifdef HAVE_RECORDER_KEYPAD
            case BUTTON_UP:
            case BUTTON_UP | BUTTON_REPEAT:
#else
            case BUTTON_LEFT:
            case BUTTON_LEFT | BUTTON_REPEAT:
#endif
                /* Page up */
#ifdef HAVE_LCD_BITMAP
                for (i = page_mode==OVERLAP? 1:0; i < display_lines; i++)
#else
                for (i = 0; i < display_lines; i++)
#endif
                    viewer_scroll_up();

                viewer_draw(col);
                break;

#ifdef HAVE_RECORDER_KEYPAD
            case BUTTON_DOWN:
            case BUTTON_DOWN | BUTTON_REPEAT:
#else
            case BUTTON_RIGHT:
            case BUTTON_RIGHT | BUTTON_REPEAT:
#endif
                /* Page down */
                if (next_screen_ptr != NULL)
                    screen_top_ptr = next_screen_to_draw_ptr;

                viewer_draw(col);
                break;

#ifdef HAVE_RECORDER_KEYPAD
            case BUTTON_LEFT:
            case BUTTON_LEFT | BUTTON_REPEAT:
#else
            case BUTTON_MENU | BUTTON_LEFT:
            case BUTTON_MENU | BUTTON_LEFT | BUTTON_REPEAT:
#endif
                if (view_mode == WIDE) {
                    /* Screen left */
                    col -= display_columns;
                    col = col_limit(col);
                }
                else {   /* view_mode == NARROW */
                    /* Top of file */
                    viewer_top();
                }

                viewer_draw(col);
                break;

#ifdef HAVE_RECORDER_KEYPAD
            case BUTTON_RIGHT:
            case BUTTON_RIGHT | BUTTON_REPEAT:
#else
            case BUTTON_MENU | BUTTON_RIGHT:
            case BUTTON_MENU | BUTTON_RIGHT | BUTTON_REPEAT:
#endif
                if (view_mode == WIDE) {
                    /* Screen right */
                    col += display_columns;
                    col = col_limit(col);
                }
                else {   /* view_mode == NARROW */
                    /* Bottom of file */
                    viewer_bottom();
                }

                viewer_draw(col);
                break;

#ifdef HAVE_RECORDER_KEYPAD
            case BUTTON_ON:
                /*Go to On-btn combinations */
                col = viewer_recorder_on_button(col);
                break;
#endif

            case SYS_USB_CONNECTED:
                /* Release control to USB functions */
                rb->usb_screen();
                viewer_exit();
                return PLUGIN_USB_CONNECTED;
        }
    }
    return PLUGIN_OK;
}