From 928c33c255e47c39c5f549b3e1aa40fbb3aaa09a Mon Sep 17 00:00:00 2001 From: Antoine Cellerier Date: Wed, 19 Jul 2006 20:11:02 +0000 Subject: rockpaint.c: Paint plugin for color LCD targets. Features include: different tools (brush, bucket, cut/copy/paste, line, bezier curve, text, rectangles, ovals, linear and radial gradients), 18 color palette, RGBHSV color picker, BMP file loading and saving. This still needs some work (and maybe some, if not a lot, of cleaning up of the source code) but it works fine (tested on h3x0 and ipod5g sims and ipod5g real target). viewers.config: add rockpaint to the list of available viewers for .bmp files git-svn-id: svn://svn.rockbox.org/rockbox/trunk@10258 a1c6a512-1295-4272-9138-f99709370657 --- apps/plugins/SOURCES | 4 + apps/plugins/rockpaint.c | 2799 +++++++++++++++++++++++++++++++++++++++++++ apps/plugins/viewers.config | 1 + 3 files changed, 2804 insertions(+) create mode 100644 apps/plugins/rockpaint.c diff --git a/apps/plugins/SOURCES b/apps/plugins/SOURCES index 526a127c7a..0e0a78bc9d 100644 --- a/apps/plugins/SOURCES +++ b/apps/plugins/SOURCES @@ -85,6 +85,10 @@ xobox.c spacerocks.c +#if LCD_DEPTH >= 16 +rockpaint.c +#endif + #endif /* HAVE_LCD_BITMAP */ #ifdef HAVE_LCD_CHARCELLS /* Player model only */ diff --git a/apps/plugins/rockpaint.c b/apps/plugins/rockpaint.c new file mode 100644 index 0000000000..7ca4cb50f8 --- /dev/null +++ b/apps/plugins/rockpaint.c @@ -0,0 +1,2799 @@ +/*************************************************************************** + * __________ __ ___. + * Open \______ \ ____ ____ | | _\_ |__ _______ ___ + * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / + * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ + * \/ \/ \/ \/ \/ + * $Id$ + * + * Copyright (C) 2006 Antoine Cellerier + * Based on parts of rockpaint 0.45, Copyright (C) 2005 Eli Sherer + * + * All files in this archive are subject to the GNU General Public License. + * See the file COPYING in the source tree root for full license agreement. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ****************************************************************************/ + +/** + * TODO: + * - implement 2 layers with alpha colors + * - take brush width into account when drawing shapes + * - handle bigger than screen bitmaps + * - cache fonts when building the font preview (else it only works well on simulators because they have "fast" disk read) + */ + +#include "plugin.h" +#include "errno.h" +#include "lib/bmp.h" +#include "lib/rgb_hsv.h" + +PLUGIN_HEADER + +/*********************************************************************** + * Buttons + ***********************************************************************/ + +#if CONFIG_KEYPAD == IRIVER_H300_PAD +#define ROCKPAINT_QUIT BUTTON_OFF +#define ROCKPAINT_DRAW BUTTON_SELECT +#define ROCKPAINT_MENU BUTTON_ON +#define ROCKPAINT_TOOLBAR BUTTON_REC +#define ROCKPAINT_TOOLBAR2 BUTTON_MODE +#define ROCKPAINT_UP BUTTON_UP +#define ROCKPAINT_DOWN BUTTON_DOWN +#define ROCKPAINT_LEFT BUTTON_LEFT +#define ROCKPAINT_RIGHT BUTTON_RIGHT + +#elif ( CONFIG_KEYPAD == IPOD_4G_PAD ) || ( CONFIG_KEYPAD == IPOD_3G_PAD ) +#define ROCKPAINT_QUIT ( ~BUTTON_MAIN ) +#define ROCKPAINT_DRAW BUTTON_SELECT +#define ROCKPAINT_MENU ( BUTTON_SELECT | BUTTON_MENU ) +#define ROCKPAINT_TOOLBAR ( BUTTON_MENU | BUTTON_LEFT ) +#define ROCKPAINT_TOOLBAR2 ( BUTTON_MENU | BUTTON_RIGHT ) +#define ROCKPAINT_UP BUTTON_MENU +#define ROCKPAINT_DOWN BUTTON_PLAY +#define ROCKPAINT_LEFT BUTTON_LEFT +#define ROCKPAINT_RIGHT BUTTON_RIGHT + +#elif ( CONFIG_KEYPAD == IAUDIO_X5_PAD ) +#define ROCKPAINT_QUIT BUTTON_POWER +#define ROCKPAINT_DRAW BUTTON_SELECT +#define ROCKPAINT_MENU BUTTON_PLAY +#define ROCKPAINT_TOOLBAR BUTTON_REC +#define ROCKPAINT_TOOLBAR2 ( BUTTON_REC | BUTTON_LEFT ) +#define ROCKPAINT_UP BUTTON_UP +#define ROCKPAINT_DOWN BUTTON_DOWN +#define ROCKPAINT_LEFT BUTTON_LEFT +#define ROCKPAINT_RIGHT BUTTON_RIGHT + +#else +#error "Please define keys for this keypad" +#endif + +/*********************************************************************** + * Palette Default Colors + ***********************************************************************/ +#define COLOR_BLACK LCD_RGBPACK(0,0,0) +#define COLOR_WHITE LCD_RGBPACK(255,255,255) +#define COLOR_DARKGRAY LCD_RGBPACK(128,128,128) +#define COLOR_LIGHTGRAY LCD_RGBPACK(192,192,192) +#define COLOR_RED LCD_RGBPACK(128,0,0) +#define COLOR_LIGHTRED LCD_RGBPACK(255,0,0) +#define COLOR_DARKYELLOW LCD_RGBPACK(128,128,0) +#define COLOR_YELLOW LCD_RGBPACK(255,255,0) +#define COLOR_GREEN LCD_RGBPACK(0,128,0) +#define COLOR_LIGHTGREN LCD_RGBPACK(0,255,0) +#define COLOR_CYAN LCD_RGBPACK(0,128,128) +#define COLOR_LIGHTCYAN LCD_RGBPACK(0,255,255) +#define COLOR_BLUE LCD_RGBPACK(0,0,128) +#define COLOR_LIGHTBLUE LCD_RGBPACK(0,0,255) +#define COLOR_PURPLE LCD_RGBPACK(128,0,128) +#define COLOR_PINK LCD_RGBPACK(255,0,255) +#define COLOR_BROWN LCD_RGBPACK(128,64,0) +#define COLOR_LIGHTBROWN LCD_RGBPACK(255,128,64) + +#define SPLASH_SCREEN PLUGIN_DIR "/rockpaint/splash.bmp" +#define ROCKPAINT_TITLE_FONT 2 + +/*********************************************************************** + * Program Colors + ***********************************************************************/ +#define ROCKPAINT_PALETTE LCD_RGBPACK(0,64,128) +#define ROCKPAINT_SELECTED LCD_RGBPACK(128,192,255) + +#define ROWS LCD_HEIGHT +#define COLS LCD_WIDTH + +/** + * Toolbar positioning stuff ... don't read this unless you really need to + * + * TB Toolbar + * SP Separator + * SC Selected Color + * PL Palette + * TL Tools + */ + +/* Separator sizes */ +#define TB_SP_MARGIN 3 +#define TB_SP_WIDTH (2+2*TB_SP_MARGIN) + +/* Selected color sizes */ +#define TB_SC_SIZE 12 + +/* Palette sizes */ +#define TB_PL_COLOR_SIZE 7 +#define TB_PL_COLOR_SPACING 2 +#define TB_PL_WIDTH ( 9 * TB_PL_COLOR_SIZE + 8 * TB_PL_COLOR_SPACING ) +#define TB_PL_HEIGHT ( TB_PL_COLOR_SIZE * 2 + TB_PL_COLOR_SPACING ) + +/* Tools sizes */ +#define TB_TL_SIZE 8 +#define TB_TL_SPACING 2 +#define TB_TL_WIDTH ( 7 * ( TB_TL_SIZE + TB_TL_SPACING ) - TB_TL_SPACING ) +#define TB_TL_HEIGHT ( 2 * TB_TL_SIZE + TB_TL_SPACING ) + +/* Menu button size ... gruik */ +#define TB_MENU_MIN_WIDTH 30 + +/* Selected colors position */ +#define TB_SC_FG_TOP 2 +#define TB_SC_FG_LEFT 2 +#define TB_SC_BG_TOP (TB_SC_FG_TOP+TB_PL_COLOR_SIZE*2+TB_PL_COLOR_SPACING-TB_SC_SIZE) +#define TB_SC_BG_LEFT (TB_SC_FG_LEFT+TB_PL_COLOR_SIZE*2+TB_PL_COLOR_SPACING-TB_SC_SIZE) + +/* Palette position */ +#define TB_PL_TOP TB_SC_FG_TOP +#define TB_PL_LEFT (TB_SC_BG_LEFT + TB_SC_SIZE + TB_PL_COLOR_SPACING) + +/* Tools position */ +#define TB_TL_TOP TB_SC_FG_TOP +#define TB_TL_LEFT ( TB_PL_LEFT + TB_PL_WIDTH-1 + TB_SP_WIDTH ) + +#if TB_TL_LEFT + TB_TL_WIDTH + TB_MENU_MIN_WIDTH >= LCD_WIDTH +#undef TB_TL_TOP +#undef TB_TL_LEFT +#define TB_TL_TOP ( TB_PL_TOP + TB_PL_HEIGHT + 4 ) +#define TB_TL_LEFT TB_SC_FG_LEFT +#endif + +/* Menu button position */ +#define TB_MENU_TOP ( TB_TL_TOP + (TB_TL_HEIGHT-8)/2 ) +#define TB_MENU_LEFT ( TB_TL_LEFT + TB_TL_WIDTH-1 + TB_SP_WIDTH ) + +#define TB_HEIGHT ( TB_TL_TOP + TB_TL_HEIGHT + 1 ) + + +static void draw_pixel(int x,int y); +static void draw_line( int x1, int y1, int x2, int y2 ); +static void draw_rect( int x1, int y1, int x2, int y2 ); +static void draw_toolbars(bool update); +static void inv_cursor(bool update); +static void restore_screen(void); +static void clear_drawing(void); +static void goto_menu(void); +static int load_bitmap( char *filename ); +static int save_bitmap( char *filename ); +static void draw_rect_full( int x1, int y1, int x2, int y2 ); +extern int errno; + +/*********************************************************************** + * Global variables + ***********************************************************************/ + +#if !defined(SIMULATOR) || defined(__MINGW32__) || defined(__CYGWIN__) +int errno; +#endif + +static struct plugin_api* rb; + +static int drawcolor=0; /* Current color (in palette) */ +static int bgdrawcolor=9; /* Current background color (in palette) */ +bool isbg = false; /* gruik ugly hack alert */ + +static int preview=false; /* Is preview mode on ? */ + +/* TODO: clean this up */ +static int x=0, y=0; /* cursor position */ +static int prev_x=-1, prev_y=-1; /* previous saved cursor position */ +static int prev_x2=-1, prev_y2=-1; +static int prev_x3=-1, prev_y3=-1; +static int tool_mode=-1; + + +static int bsize=1; /* brush size */ +static int bspeed=1; /* brush speed */ + +enum Tools { Brush = 0, /* Regular brush */ + Fill = 1, /* Fill a shape with current color */ + SelectRectangle = 2, + ColorPicker = 3, /* Pick a color */ + Line = 4, /* Draw a line between two points */ + Unused = 5, /* THIS IS UNUSED ... */ + Curve = 6, + Text = 7, + Rectangle = 8, /* Draw a rectangle */ + RectangleFull = 9, + Oval = 10, /* Draw an oval */ + OvalFull = 11, + LinearGradient = 12, + RadialGradient = 13 + }; + +enum Tools tool = Brush; + +static bool quit=false; +static int gridsize=0; + +static fb_data rp_colors[18] = +{ + COLOR_BLACK, COLOR_DARKGRAY, COLOR_RED, COLOR_DARKYELLOW, + COLOR_GREEN, COLOR_CYAN, COLOR_BLUE, COLOR_PURPLE, COLOR_BROWN, + COLOR_WHITE, COLOR_LIGHTGRAY, COLOR_LIGHTRED, COLOR_YELLOW, + COLOR_LIGHTGREN, COLOR_LIGHTCYAN, COLOR_LIGHTBLUE, COLOR_PINK, + COLOR_LIGHTBROWN +}; + +static fb_data save_buffer[ ROWS*COLS ]; + +extern fb_data rockpaint[]; +extern fb_data rockpaint_hsvrgb[]; + +/* Maximum string size allowed for the text tool */ +#define MAX_TEXT 255 + +static union +{ + /* Used by fill and gradient algorithms */ + struct + { + short x; + short y; + } coord[ ROWS*COLS ]; + + /* Used by bezier curve algorithms */ + struct + { + short x1, y1; + short x2, y2; + short x3, y3; + short x4, y4; + short depth; + } bezier[ (ROWS*COLS)/5 ]; /* We have 4.5 times more data per struct + * than coord ... so we divide to take + * less memory. */ + + /* Used to cut/copy/paste data */ + fb_data clipboard[ ROWS*COLS ]; + + /* Used for text mode */ + struct + { + char text[MAX_TEXT+1]; + char font[MAX_PATH+1]; + char old_font[MAX_PATH+1]; + } text; +} buffer; + +/* Current filename */ +static char filename[MAX_PATH+1]; + +/* Font preview buffer */ +//#define FONT_PREVIEW_WIDTH ((LCD_WIDTH-30)/8) +//#define FONT_PREVIEW_HEIGHT 1000 +//static unsigned char fontpreview[FONT_PREVIEW_WIDTH*FONT_PREVIEW_HEIGHT]; + +/*********************************************************************** + * Offscreen buffer/Text/Fonts handling + * + * Parts of code taken from firmware/drivers/lcd-16bit.c + ***********************************************************************/ +static void buffer_mono_bitmap_part( + fb_data *buf, int buf_width, int buf_height, + const unsigned char *src, int src_x, int src_y, + int stride, int x, int y, int width, int height ) +/* this function only draws the foreground part of the bitmap */ +{ + const unsigned char *src_end; + fb_data *dst, *dst_end; + unsigned fgcolor = rb->lcd_get_foreground(); + + /* nothing to draw? */ + if( ( width <= 0 ) || ( height <= 0 ) || ( x >= buf_width ) + || ( y >= buf_height ) || ( x + width <= 0 ) || ( y + height <= 0 ) ) + return; + + /* clipping */ + if( x < 0 ) + { + width += x; + src_x -= x; + x = 0; + } + if( y < 0 ) + { + height += y; + src_y -= y; + y = 0; + } + if( x + width > buf_width ) + width = buf_width - x; + if( y + height > buf_height ) + height = buf_height - y; + + src += stride * (src_y >> 3) + src_x; /* move starting point */ + src_y &= 7; + src_end = src + width; + + dst = buf + y*buf_width + x; + + do + { + const unsigned char *src_col = src++; + unsigned data = *src_col >> src_y; + fb_data *dst_col = dst++; + int numbits = 8 - src_y; + + dst_end = dst_col + height * buf_width; + do + { + if( data & 0x01 ) + *dst_col = fgcolor; /* FIXME ? */ + + dst_col += buf_width; + + data >>= 1; + if( --numbits == 0 ) + { + src_col += stride; + data = *src_col; + numbits = 8; + } + } while( dst_col < dst_end ); + } while( src < src_end ); +} + +static void buffer_putsxyofs( fb_data *buf, int buf_width, int buf_height, + int x, int y, int ofs, const unsigned char *str ) +{ + unsigned short ch; + unsigned short *ucs; + + struct font *pf = rb->font_get( FONT_UI ); + if( !pf ) pf = rb->font_get( FONT_SYSFIXED ); + + ucs = rb->bidi_l2v( str, 1 ); + + while( (ch = *ucs++) != 0 && x < buf_width ) + { + int width; + const unsigned char *bits; + + /* get proportional width and glyph bits */ + width = rb->font_get_width( pf, ch ); + + if( ofs > width ) + { + ofs -= width; + continue; + } + + bits = rb->font_get_bits( pf, ch ); + + buffer_mono_bitmap_part( buf, buf_width, buf_height, bits, ofs, 0, width, x, y, width - ofs, pf->height); + + x += width - ofs; + ofs = 0; + } +} + +/*********************************************************************** + * Menu handling + ***********************************************************************/ +struct menu_items +{ + int value; + char label[13]; /* GRUIK ? */ +}; + +#define MENU_ESC -1242 +enum { + /* Generic menu items */ + MENU_END = -42, MENU_TITLE = -12, + /* Main menu */ + MAIN_MENU_RESUME, + MAIN_MENU_NEW, MAIN_MENU_LOAD, MAIN_MENU_SAVE, + MAIN_MENU_BRUSH_SIZE, MAIN_MENU_BRUSH_SPEED, MAIN_MENU_COLOR, + MAIN_MENU_GRID_SIZE, + MAIN_MENU_EXIT, + /* Select action menu */ + SELECT_MENU_CUT, SELECT_MENU_COPY, SELECT_MENU_INVERT, + SELECT_MENU_CANCEL, + /* Text menu */ + TEXT_MENU_TEXT, TEXT_MENU_FONT, + TEXT_MENU_PREVIEW, TEXT_MENU_APPLY, TEXT_MENU_CANCEL, + }; + +static struct menu_items main_menu[]= + { { MENU_TITLE, "RockPaint" }, + { MAIN_MENU_RESUME, "Resume" }, + { MAIN_MENU_NEW, "New" }, + { MAIN_MENU_LOAD, "Load" }, + { MAIN_MENU_SAVE, "Save" }, + { MAIN_MENU_BRUSH_SIZE, "Brush Size" }, + { MAIN_MENU_BRUSH_SPEED, "Brush Speed" }, + { MAIN_MENU_COLOR, "Choose Color" }, + { MAIN_MENU_GRID_SIZE, "Grid Size" }, + { MAIN_MENU_EXIT, "Exit" }, + { MENU_END, "" } }; + +static struct menu_items size_menu[] = + { { MENU_TITLE, "Choose Size" }, + { 1, "1x" }, + { 2, "2x" }, + { 4, "4x" }, + { 8, "8x" }, + { MENU_END, "" } }; + +static struct menu_items speed_menu[] = + { { MENU_TITLE, "Choose Speed" }, + { 1, "1x" }, + { 2, "2x" }, + { 4, "4x" }, + { MENU_END, "" } }; + +static struct menu_items gridsize_menu[] = + { { MENU_TITLE, "Grid Size" }, + { 0, "No grid" }, + { 5, "5px" }, + { 10, "10px" }, + { 20, "20px" }, + { MENU_END, "" } }; + +static struct menu_items select_menu[] = + { { MENU_TITLE, "Select..." }, + { SELECT_MENU_CUT, "Cut" }, + { SELECT_MENU_COPY, "Copy" }, + { SELECT_MENU_INVERT, "Invert" }, + { SELECT_MENU_CANCEL, "Cancel" }, + { MENU_END, "" } }; + +static struct menu_items text_menu[] = + { { MENU_TITLE, "Text" }, + { TEXT_MENU_TEXT, "Set text" }, + { TEXT_MENU_FONT, "Change font" }, + { TEXT_MENU_PREVIEW, "Preview" }, + { TEXT_MENU_APPLY, "Apply" }, + { TEXT_MENU_CANCEL, "Cancel" }, + { MENU_END, "" } }; + +static int draw_window( int height, int width, + int *top, int *left, + const char *title ) +{ + int fh; + rb->lcd_getstringsize( title, NULL, &fh ); + fh++; + + const int _top = ( LCD_HEIGHT - height ) / 2; + const int _left = ( LCD_WIDTH - width ) / 2; + if( top ) *top = _top; + if( left ) *left = _left; + rb->lcd_set_background(COLOR_BLUE); + rb->lcd_set_foreground(COLOR_LIGHTGRAY); + rb->lcd_fillrect( _left, _top, width, height ); + rb->lcd_set_foreground(COLOR_BLUE); + rb->lcd_fillrect( _left, _top, width, fh+4 ); + rb->lcd_set_foreground(COLOR_WHITE); + rb->lcd_putsxy( _left+2, _top+2, title ); + rb->lcd_set_foreground(COLOR_BLACK); + rb->lcd_drawrect( _left, _top, width, height ); + return _top+fh+4; +} + +static int menu_display( struct menu_items menu[], int prev_value ) +{ + int i, + fh, /* font height */ + width, height, + a, b, + selection=1, + menu_length, + top, left; + int scroll = 0, onscreen = 0; + + rb->lcd_getstringsize( menu[0].label, &width, &fh ); + for( i=1; menu[i].value != MENU_END; i++ ) + { + if( prev_value == menu[i].value ) + { + selection = i; + } + rb->lcd_getstringsize( menu[i].label, &a, &b ); + if( a > width ) width = a; + if( b > fh ) fh = b; + } + menu_length = i; + fh++; + width += 10; + + height = menu_length * fh + 4 + 2 + 2; + if( height >= LCD_HEIGHT ) + { + scroll = 1; + onscreen = ( LCD_HEIGHT - 4 - 2 - 2 )/fh; + height = onscreen * fh + 4 + 2 + 2; + width += 5; + } + else + { + onscreen = menu_length; + } + + draw_window( height, width, &top, &left, menu[0].label ); + + while( 1 ) + { + for( i = (scroll == 0 ? 1 : scroll); + i < (scroll ? scroll + onscreen - 1:onscreen); + i++ ) + { + if( i == selection ) + { + rb->lcd_set_foreground( COLOR_WHITE ); + rb->lcd_set_background( COLOR_BLUE ); + } + else + { + rb->lcd_set_foreground( COLOR_BLACK ); + rb->lcd_set_background( COLOR_LIGHTGRAY ); + } + rb->lcd_putsxy( left+2, + top+6+fh*(i-(scroll == 0 ? 0 : scroll-1 )), + menu[i].label ); + } + if( scroll ) + { + int scroll_height = ((height-fh-4-2)*onscreen)/menu_length; + rb->lcd_set_foreground( COLOR_BLACK ); + rb->lcd_vline( left+width-5, top+fh+4, top+height-2 ); + rb->lcd_fillrect( left+width-4, + top+fh+4+((height-4-2-fh-scroll_height)*(scroll-1))/(menu_length-onscreen), + 3, scroll_height ); + } + rb->lcd_update(); + + switch( rb->button_get(true) ) + { + case ROCKPAINT_UP: + case ROCKPAINT_UP|BUTTON_REPEAT: + selection = (selection + menu_length-1)%menu_length; + if( !selection ) selection = menu_length-1; + break; + + case ROCKPAINT_DOWN: + case ROCKPAINT_DOWN|BUTTON_REPEAT: + selection = (selection + 1)%menu_length; + if( !selection ) selection++; + break; + + case ROCKPAINT_LEFT: + restore_screen(); + return MENU_ESC; + + case ROCKPAINT_RIGHT: + case ROCKPAINT_DRAW: + restore_screen(); + return menu[selection].value; + } + if( scroll ) + { + if( selection < scroll ) + { + scroll = selection; + draw_window( height, width, NULL, NULL, menu[0].label ); + } + if( selection >= scroll + onscreen - 1 ) + { + scroll++; + draw_window( height, width, NULL, NULL, menu[0].label ); + } + } + } +} + +/*********************************************************************** + * File browser + ***********************************************************************/ + +char bbuf[MAX_PATH+1]; /* used by file and font browsers */ +char bbuf_s[MAX_PATH+1]; /* used by file and font browsers */ + +static bool browse( char *dst, int dst_size, const char *start ) +{ +#define WIDTH ( LCD_WIDTH - 20 ) +#define HEIGHT ( LCD_HEIGHT - 20 ) +#define LINE_SPACE 2 + int top, top_inside, left; + + DIR *d; + struct dirent *de; + int fvi = 0; /* first visible item */ + int lvi = 0; /* last visible item */ + int si = 0; /* selected item */ + int li = 0; /* last item */ + int i; + + int fh; + char *a; + + rb->lcd_getstringsize( "Ap", NULL, &fh ); + + rb->strcpy( bbuf, start ); + a = bbuf+rb->strlen(bbuf)-1; + if( *a != '/' ) + { + a[1] = '/'; + a[2] = '\0'; + } + + while( 1 ) + { + d = rb->PREFIX(opendir)( bbuf ); + if( !d ) + { + if( errno == ENOTDIR ) + { + /* this is a file */ + bbuf[rb->strlen(bbuf)-1] = '\0'; + rb->strncpy( dst, bbuf, dst_size ); + return true; + } + else if( errno == EACCES || errno == ENOENT ) + { + bbuf[0] = '/'; bbuf[1] = '\0'; + d = rb->PREFIX(opendir)( "/" ); + } + else + { + return false; + } + } + top_inside = draw_window( HEIGHT, WIDTH, &top, &left, bbuf ); + i = 0; + li = -1; + while( i < fvi ) + { + rb->PREFIX(readdir)( d ); + i++; + } + while( top_inside+(i-fvi)*(fh+LINE_SPACE) < HEIGHT ) + { + de = rb->PREFIX(readdir)( d ); + if( !de ) + { + li = i-1; + break; + } + rb->lcd_set_foreground((si==i?COLOR_WHITE:COLOR_BLACK)); + rb->lcd_set_background((si==i?COLOR_BLUE:COLOR_LIGHTGRAY)); + rb->lcd_putsxy( left+10, + top_inside+(i-fvi)*(fh+LINE_SPACE), + de->d_name ); + if( si == i ) + rb->strcpy( bbuf_s, de->d_name ); + i++; + } + lvi = i-1; + if( li == -1 ) + { + if( !rb->PREFIX(readdir)( d ) ) + { + li = lvi; + } + } + rb->PREFIX(closedir)( d ); + + rb->lcd_update(); + + switch( rb->button_get(true) ) + { + case ROCKPAINT_UP: + case ROCKPAINT_UP|BUTTON_REPEAT: + if( si > 0 ) + { + si--; + if( silvi ) + { + fvi++; + } + } + break; + + case ROCKPAINT_LEFT: + if( bbuf[0] == '/' && !bbuf[1] ) return false; + bbuf_s[0] = '.'; + bbuf_s[1] = '.'; + bbuf_s[2] = '\0'; + case ROCKPAINT_RIGHT: + case ROCKPAINT_DRAW: + if( *bbuf_s == '.' && !bbuf_s[1] ) break; + a = bbuf; + while( *a ) a++; + if( *bbuf_s == '.' && bbuf_s[1] == '.' && !bbuf_s[2] ) + { + a--; + if( a == bbuf ) break; + if( *a == '/' ) a--; + while( *a != '/' ) a--; + *++a = '\0'; + break; + } + rb->strcpy( a, bbuf_s ); + while( *a ) a++; + *a++ = '/'; + *a = '\0'; + fvi = si = 0; + break; + } + } + +#undef WIDTH +#undef HEIGHT +#undef LINE_SPACE +} + +/*********************************************************************** + * Font browser + * + * FIXME: This still needs some work ... it currently only works fine + * on the simulators, disk spins too much on real targets -> rendered + * font buffer needed. + ***********************************************************************/ +static bool browse_fonts( char *dst, int dst_size ) +{ + char old_font[MAX_PATH]; +#define WIDTH ( LCD_WIDTH - 20 ) +#define HEIGHT ( LCD_HEIGHT - 20 ) +#define LINE_SPACE 2 + int top, top_inside, left; + + DIR *d; + struct dirent *de; + int fvi = 0; /* first visible item */ + int lvi = 0; /* last visible item */ + int si = 0; /* selected item */ + int li = 0; /* last item */ + int nvih = 0; /* next visible item height */ + int i; + + int cp = 0; /* current position */ + int fh; /* font height */ + + rb->snprintf( old_font, MAX_PATH, + ROCKBOX_DIR FONT_DIR "/%s.fnt", + rb->global_settings->font_file ); + + while( 1 ) + { + d = rb->PREFIX(opendir)( ROCKBOX_DIR FONT_DIR "/" ); + if( !d ) + { + return false; + } + top_inside = draw_window( HEIGHT, WIDTH, &top, &left, "Fonts" ); + i = 0; + li = -1; + while( i < fvi ) + { + rb->PREFIX(readdir)( d ); + i++; + } + cp = top_inside+LINE_SPACE; + while( cp < top+HEIGHT ) + { + de = rb->PREFIX(readdir)( d ); + if( !de ) + { + li = i-1; + break; + } + if( rb->strlen( de->d_name ) < 4 + || rb->strcmp( de->d_name + rb->strlen( de->d_name ) - 4, + ".fnt" ) ) + continue; + rb->snprintf( bbuf, MAX_PATH, ROCKBOX_DIR FONT_DIR "/%s", + de->d_name ); + rb->font_load( bbuf ); + rb->font_getstringsize( de->d_name, NULL, &fh, FONT_UI ); + if( nvih > 0 ) + { + nvih -= fh; + fvi++; + if( nvih < 0 ) nvih = 0; + i++; + continue; + } + if( cp + fh >= top+HEIGHT ) + { + nvih = fh; + break; + } + rb->lcd_set_foreground((si==i?COLOR_WHITE:COLOR_BLACK)); + rb->lcd_set_background((si==i?COLOR_BLUE:COLOR_LIGHTGRAY)); + rb->lcd_putsxy( left+10, cp, de->d_name ); + cp += fh + LINE_SPACE; + if( si == i ) + rb->strcpy( bbuf_s, bbuf ); + i++; + } + lvi = i-1; + if( li == -1 ) + { + if( !(de = rb->PREFIX(readdir)( d ) ) ) + { + li = lvi; + } + else if( !nvih && !rb->strlen( de->d_name ) < 4 + && !rb->strcmp( de->d_name + rb->strlen( de->d_name ) - 4, + ".fnt" ) ) + { + rb->snprintf( bbuf, MAX_PATH, ROCKBOX_DIR FONT_DIR "/%s", + de->d_name ); + rb->font_load( bbuf ); + rb->font_getstringsize( de->d_name, NULL, &fh, FONT_UI ); + nvih = fh; + } + } + rb->font_load( old_font ); + rb->PREFIX(closedir)( d ); + + rb->lcd_update_rect( left, top, WIDTH, HEIGHT ); + + switch( rb->button_get(true) ) + { + case ROCKPAINT_UP: + case ROCKPAINT_UP|BUTTON_REPEAT: + if( si > 0 ) + { + si--; + if( sisnprintf( dst, dst_size, "%s", bbuf_s ); + return true; + } + if( si<=lvi ) + { + nvih = 0; + } + } +#undef WIDTH +#undef HEIGHT +#undef LINE_SPACE +} + +/*********************************************************************** + * HSVRGB Color chooser + ***********************************************************************/ +static unsigned int color_chooser( unsigned int color ) +{ + int red = RGB_UNPACK_RED( color ); + int green = RGB_UNPACK_GREEN( color ); + int blue = RGB_UNPACK_BLUE( color ); + int hue, saturation, value; + int r, g, b; /* temp variables */ + int i, top, left; + + enum BaseColor { Hue = 0, Saturation = 1, Value = 2, + Red = 3, Green = 4, Blue = 5 }; + enum BaseColor current = Red; + bool has_changed; + + char str[6] = ""; + + restore_screen(); + + rgb2hsv( red, green, blue, &hue, &saturation, &value ); + + while( 1 ) + { + has_changed = false; + color = LCD_RGBPACK( red, green, blue ); + +#define HEIGHT ( 100 ) +#define WIDTH ( 150 ) + + top = draw_window( HEIGHT, WIDTH, NULL, &left, "Color chooser" ); + top -= 15; + + for( i=0; i<100; i++ ) + { + hsv2rgb( i*36, saturation, value, &r, &g, &b ); + rb->lcd_set_foreground( LCD_RGBPACK( r, g, b ) ); + rb->lcd_vline( left+15+i, top+20, top+27 ); + hsv2rgb( hue, i*255/100, value, &r, &g, &b ); + rb->lcd_set_foreground( LCD_RGBPACK( r, g, b ) ); + rb->lcd_vline( left+15+i, top+30, top+37 ); + hsv2rgb( hue, saturation, i*255/100, &r, &g, &b ); + rb->lcd_set_foreground( LCD_RGBPACK( r, g, b ) ); + rb->lcd_vline( left+15+i, top+40, top+47 ); + rb->lcd_set_foreground( LCD_RGBPACK( i*255/100, green, blue ) ); + rb->lcd_vline( left+15+i, top+50, top+57 ); + rb->lcd_set_foreground( LCD_RGBPACK( red, i*255/100, blue ) ); + rb->lcd_vline( left+15+i, top+60, top+67 ); + rb->lcd_set_foreground( LCD_RGBPACK( red, green, i*255/100 ) ); + rb->lcd_vline( left+15+i, top+70, top+77 ); + } + + rb->lcd_set_foreground(COLOR_BLACK); +#define POSITION( a, i ) \ + rb->lcd_drawpixel( left+14+i, top + 19 + a ); \ + rb->lcd_drawpixel( left+16+i, top + 19 + a ); \ + rb->lcd_drawpixel( left+14+i, top + 28 + a ); \ + rb->lcd_drawpixel( left+16+i, top + 28 + a ); + POSITION( 0, hue/36 ); + POSITION( 10, saturation*99/255 ); + POSITION( 20, value*99/255 ); + POSITION( 30, red*99/255 ); + POSITION( 40, green*99/255 ); + POSITION( 50, blue*99/255 ); +#undef POSITION + rb->lcd_set_background(COLOR_LIGHTGRAY); + rb->lcd_setfont( FONT_SYSFIXED ); + rb->snprintf( str, 6, "%d", hue/10 ); + rb->lcd_putsxy( left + 117, top + 20, str ); + rb->snprintf( str, 6, "%d.%d", saturation/255, ((saturation*100)/255)%100 ); + rb->lcd_putsxy( left + 117, top + 30, str ); + rb->snprintf( str, 6, "%d.%d", value/255, ((value*100)/255)%100 ); + rb->lcd_putsxy( left + 117, top + 40, str ); + rb->snprintf( str, 6, "%d", red ); + rb->lcd_putsxy( left + 117, top + 50, str ); + rb->snprintf( str, 6, "%d", green ); + rb->lcd_putsxy( left + 117, top + 60, str ); + rb->snprintf( str, 6, "%d", blue ); + rb->lcd_putsxy( left + 117, top + 70, str ); + rb->lcd_setfont( FONT_UI ); + +#define CURSOR( l ) \ + rb->lcd_bitmap_transparent_part( rockpaint_hsvrgb, 1, 1, 16, left+l+1, top+20, 6, 58 ); \ + rb->lcd_bitmap_transparent_part( rockpaint_hsvrgb, 8, 10*current, 16, left+l, top+19+10*current, 8, 10 ); + CURSOR( 5 ); +#undef CURSOR + + rb->lcd_set_foreground( color ); + rb->lcd_fillrect( left+15, top+85, 100, 8 ); + + rb->lcd_update(); + + switch( rb->button_get(true) ) + { + case ROCKPAINT_UP: + current = ( current + 5 )%6; + break; + + case ROCKPAINT_DOWN: + current = (current + 1 )%6; + break; + + case ROCKPAINT_LEFT: + has_changed = true; + switch( current ) + { + case Hue: + hue = ( hue + 3600 - 10 )%3600; + break; + case Saturation: + if( saturation ) saturation--; + break; + case Value: + if( value ) value--; + break; + case Red: + if( red ) red--; + break; + case Green: + if( green ) green--; + break; + case Blue: + if( blue ) blue--; + break; + } + break; + + case ROCKPAINT_LEFT|BUTTON_REPEAT: + has_changed = true; + switch( current ) + { + case Hue: + hue = ( hue + 3600 - 100 )%3600; + break; + case Saturation: + if( saturation >= 8 ) saturation-=8; + else saturation = 0; + break; + case Value: + if( value >= 8 ) value-=8; + else value = 0; + break; + case Red: + if( red >= 8 ) red-=8; + else red = 0; + break; + case Green: + if( green >= 8 ) green-=8; + else green = 0; + break; + case Blue: + if( blue >= 8 ) blue-=8; + else blue = 0; + break; + } + break; + + case ROCKPAINT_RIGHT: + has_changed = true; + switch( current ) + { + case Hue: + hue = ( hue + 10 )%3600; + break; + case Saturation: + if( saturation < 0xff ) saturation++; + break; + case Value: + if( value < 0xff ) value++; + break; + case Red: + if( red < 0xff ) red++; + break; + case Green: + if( green < 0xff ) green++; + break; + case Blue: + if( blue < 0xff ) blue++; + break; + } + break; + + case ROCKPAINT_RIGHT|BUTTON_REPEAT: + has_changed = true; + switch( current ) + { + case Hue: + hue = ( hue + 100 )%3600; + break; + case Saturation: + if( saturation < 0xff - 8 ) saturation+=8; + else saturation = 0xff; + break; + case Value: + if( value < 0xff - 8 ) value+=8; + else value = 0xff; + break; + case Red: + if( red < 0xff - 8 ) red+=8; + else red = 0xff; + break; + case Green: + if( green < 0xff - 8 ) green+=8; + else green = 0xff; + break; + case Blue: + if( blue < 0xff - 8 ) blue+=8; + else blue = 0xff; + break; + } + break; + + case ROCKPAINT_DRAW: + return color; + } + if( has_changed ) + { + switch( current ) + { + case Hue: + case Saturation: + case Value: + hsv2rgb( hue, saturation, value, &red, &green, &blue ); + break; + + case Red: + case Green: + case Blue: + rgb2hsv( red, green, blue, &hue, &saturation, &value ); + break; + } + } +#undef HEIGHT +#undef WIDTH + } +} + +/*********************************************************************** + * Misc routines + ***********************************************************************/ +static void init_buffer(void) +{ + int i; + fb_data color = rp_colors[ bgdrawcolor ]; + for( i = 0; i < ROWS*COLS; i++ ) + { + save_buffer[i] = color; + } +} + +static void draw_pixel(int x,int y) +{ + if( !preview ) + { + if( x < 0 || x >= COLS || y < 0 || y >= ROWS ) return; + if( isbg ) + { + save_buffer[ x+y*COLS ] = rp_colors[bgdrawcolor]; + } + else + { + save_buffer[ x+y*COLS ] = rp_colors[drawcolor]; + } + } + rb->lcd_drawpixel(x,y); +} + +static void color_picker( int x, int y ) +{ + if( preview ) + { + rb->lcd_set_foreground( save_buffer[ x+y*COLS ] ); +#define PSIZE 12 + rb->lcd_set_drawmode(DRMODE_COMPLEMENT); + rb->lcd_drawrect( xlcd_set_drawmode(DRMODE_SOLID); + rb->lcd_fillrect( xlcd_set_foreground( rp_colors[ drawcolor ] ); + } + else + { + rp_colors[ drawcolor ] = save_buffer[ x+y*COLS ]; + } +} + +static void draw_select_rectangle( int x1, int y1, int x2, int y2 ) +/* This is a preview mode only function */ +{ + int i,a; + if( x1 > x2 ) + { + i = x1; + x1 = x2; + x2 = i; + } + if( y1 > y2 ) + { + i = y1; + y1 = y2; + y2 = i; + } + rb->lcd_set_drawmode(DRMODE_COMPLEMENT); + i = 0; + for( a = x1; a < x2; a++, i++ ) + if( i%2 ) + rb->lcd_drawpixel( a, y1 ); + for( a = y1; a < y2; a++, i++ ) + if( i%2 ) + rb->lcd_drawpixel( x2, a ); + if( y2 != y1 ) + for( a = x2; a > x1; a--, i++ ) + if( i%2 ) + rb->lcd_drawpixel( a, y2 ); + if( x2 != x1 ) + for( a = y2; a > y1; a--, i++ ) + if( i%2 ) + rb->lcd_drawpixel( x1, a ); + rb->lcd_set_drawmode(DRMODE_SOLID); +} + +static void copy_to_clipboard( void ) +{ + /* This needs to be optimised ... but i'm lazy ATM */ + rb->memcpy( buffer.clipboard, save_buffer, COLS*ROWS*sizeof( fb_data ) ); +} + +/* no preview mode handling atm ... do we need it ? (one if) */ +static void draw_invert( int x1, int y1, int x2, int y2 ) +{ + int i; + if( x1 > x2 ) + { + i = x1; + x1 = x2; + x2 = i; + } + if( y1 > y2 ) + { + i = y1; + y1 = y2; + y2 = i; + } + + rb->lcd_set_drawmode(DRMODE_COMPLEMENT); + rb->lcd_fillrect( x1, y1, x2-x1+1, y2-y1+1 ); + rb->lcd_set_drawmode(DRMODE_SOLID); + + for( ; y1<=y2; y1++ ) + { + for( i = x1; i<=x2; i++ ) + { + save_buffer[ y1*COLS + i ] = ~save_buffer[ y1*COLS + i ]; + } + } + /*if( update )*/ rb->lcd_update(); +} + +static void draw_paste_rectangle( int src_x1, int src_y1, int src_x2, + int src_y2, int x1, int y1, int mode ) +{ + int i; + if( mode == SELECT_MENU_CUT ) + { + i = drawcolor; + drawcolor = bgdrawcolor; + draw_rect_full( src_x1, src_y1, src_x2, src_y2 ); + drawcolor = i; + } + if( src_x1 > src_x2 ) + { + i = src_x1; + src_x1 = src_x2; + src_x2 = i; + } + if( src_y1 > src_y2 ) + { + i = src_y1; + src_y1 = src_y2; + src_y2 = i; + } + rb->lcd_bitmap_part( buffer.clipboard, src_x1, src_y1, COLS, + x1, y1, src_x2-src_x1+1, src_y2-src_y1+1 ); + if( !preview ) + { + for( i = 0; i <= src_y2 - src_y1; i++ ) + { + rb->memcpy( save_buffer+(y1+i)*COLS+x1, + buffer.clipboard+(src_y1+i)*COLS+src_x1, + (src_x2 - src_x1 + 1)*sizeof( fb_data ) ); + } + } +} + +static void show_grid( bool update ) +{ + int i; + if( gridsize > 0 ) + { + rb->lcd_set_drawmode(DRMODE_COMPLEMENT); + for( i = gridsize; i < COLS; i+= gridsize ) + { + rb->lcd_vline( i, 0, ROWS-1 ); + } + for( i = gridsize; i < ROWS; i+= gridsize ) + { + rb->lcd_hline( 0, COLS-1, i ); + } + rb->lcd_set_drawmode(DRMODE_SOLID); + if( update ) rb->lcd_update(); + } +} + +static void draw_text( int x, int y ) +{ + buffer.text.text[0] = '\0'; + rb->snprintf( buffer.text.old_font, MAX_PATH, + ROCKBOX_DIR FONT_DIR "/%s.fnt", + rb->global_settings->font_file ); + DEBUGF( "old font: %s\n", buffer.text.old_font ); + while( 1 ) + { + int m = TEXT_MENU_TEXT; + switch( m = menu_display( text_menu, m ) ) + { + case TEXT_MENU_TEXT: + rb->kbd_input( buffer.text.text, MAX_TEXT ); + restore_screen(); + break; + + case TEXT_MENU_FONT: + if( browse_fonts( buffer.text.font, MAX_PATH ) ) + { + rb->font_load( buffer.text.font ); + } + break; + + case TEXT_MENU_PREVIEW: + while( 1 ) + { + unsigned int button; + restore_screen(); + rb->lcd_putsxy( x, y, buffer.text.text ); + rb->lcd_update(); + switch( button = rb->button_get( true ) ) + { + case ROCKPAINT_LEFT: + case ROCKPAINT_LEFT | BUTTON_REPEAT: + x-=bspeed * ( button & BUTTON_REPEAT ? 4 : 1 ); + if (x<0) x=COLS-1; + break; + + case ROCKPAINT_RIGHT: + case ROCKPAINT_RIGHT | BUTTON_REPEAT: + x+=bspeed * ( button & BUTTON_REPEAT ? 4 : 1 ); + if (x>=COLS) x=0; + break; + + case ROCKPAINT_UP: + case ROCKPAINT_UP | BUTTON_REPEAT: + y-=bspeed * ( button & BUTTON_REPEAT ? 4 : 1 ); + if (y<0) y=ROWS-1; + break; + + case ROCKPAINT_DOWN: + case ROCKPAINT_DOWN | BUTTON_REPEAT: + y+=bspeed * ( button & BUTTON_REPEAT ? 4 : 1 ); + if (y>=ROWS-1) y=0; + break; + + case ROCKPAINT_DRAW: + button = 1242; + break; + } + if( button == 1242 ) break; + } + break; + + case TEXT_MENU_APPLY: + buffer_putsxyofs( save_buffer, COLS, ROWS, x, y, 0, + buffer.text.text ); + case TEXT_MENU_CANCEL: + restore_screen(); + rb->font_load( buffer.text.old_font ); + return; + } + } +} + +static void draw_brush( int x, int y ) +{ + int i,j; + for( i=-bsize/2+(bsize+1)%2; i<=bsize/2; i++ ) + { + for( j=-bsize/2+(bsize+1)%2; j<=bsize/2; j++ ) + { + draw_pixel( x+i, y+j ); + } + } +} + +static void draw_line( int x1, int y1, int x2, int y2 ) +{ + x1 = x1<<1; + y1 = y1<<1; + x2 = x2<<1; + y2 = y2<<1; + int w = x1 - x2; + int h = y1 - y2; + + int x, y; + + if( w == 0 && h == 0 ) + { + draw_pixel( x1>>1, y1>>1 ); + return; + } + + if( w < 0 ) w *= -1; + if( h < 0 ) h *= -1; + + if( w > h ) + { + if( x1 > x2 ) + { + x = x2; + y = y2; + x2 = x1; + y2 = y1; + x1 = x; + y1 = y; + } + w = x1 - x2; + h = y1 - y2; + while( x1 <= x2 ) + { + draw_pixel( (x1+1)>>1, (y1+1)>>1 ); + x1+=2; + y1 = y2 - ( x2 - x1 ) * h / w; + } + } + else /* h > w */ + { + if( y1 > y2 ) + { + x = x2; + y = y2; + x2 = x1; + y2 = y1; + x1 = x; + y1 = y; + } + w = x1 - x2; + h = y1 - y2; + while( y1 <= y2 ) + { + draw_pixel( (x1+1)>>1, (y1+1)>>1 ); + y1+=2; + x1 = x2 - ( y2 - y1 ) * w / h; + } + } +} + +static void draw_curve( int x1, int y1, int x2, int y2, + int xa, int ya, int xb, int yb ) +{ + int i = 0; + short xl1, yl1; + short xl2, yl2; + short xl3, yl3; + short xl4, yl4; + short xr1, yr1; + short xr2, yr2; + short xr3, yr3; + short xr4, yr4; + short depth; + short xh, yh; + + if( x1 == x2 && y1 == y2 ) + { + draw_pixel( x1, y1 ); + return; + } + +// if( preview ) + { + rb->lcd_set_drawmode(DRMODE_COMPLEMENT); + if( xa == -1 || ya == -1 ) + { + rb->lcd_drawline( x1, y1, xb, yb ); + rb->lcd_drawline( x2, y2, xb, yb ); + } + else + { + rb->lcd_drawline( x1, y1, xa, ya ); + rb->lcd_drawline( x2, y2, xb, yb ); + } + rb->lcd_set_drawmode(DRMODE_SOLID); + } + + if( xa == -1 || ya == -1 ) + /* We only have 3 of the points + * This will currently only be used in preview mode */ + { +#define PUSH( a1, b1, a2, b2, a3, b3, d ) \ + buffer.bezier[i].x1 = a1; \ + buffer.bezier[i].y1 = b1; \ + buffer.bezier[i].x2 = a2; \ + buffer.bezier[i].y2 = b2; \ + buffer.bezier[i].x3 = a3; \ + buffer.bezier[i].y3 = b3; \ + buffer.bezier[i].depth = d; \ + i++; +#define POP( a1, b1, a2, b2, a3, b3, d ) \ + i--; \ + a1 = buffer.bezier[i].x1; \ + b1 = buffer.bezier[i].y1; \ + a2 = buffer.bezier[i].x2; \ + b2 = buffer.bezier[i].y2; \ + a3 = buffer.bezier[i].x3; \ + b3 = buffer.bezier[i].y3; \ + d = buffer.bezier[i].depth; + PUSH( x1<<4, y1<<4, xb<<4, yb<<4, x2<<4, y2<<4, 0 ); + while( i ) + { + /* de Casteljau's algorithm (see wikipedia) */ + POP( xl1, yl1, xb, yb, xr3, yr3, depth ); + if( depth < 10 ) /* check that the stack's 'i' doesn't overflow */ + { + xl2 = ( xl1 + xb )>>1; + yl2 = ( yl1 + yb )>>1; + xr2 = ( xb + xr3 )>>1; + yr2 = ( yb + yr3 )>>1; + xr1 = ( xl2 + xr2 )>>1; + yr1 = ( yl2 + yr2 )>>1; + xl3 = xr1; + yl3 = yr1; + PUSH( xl1, yl1, xl2, yl2, xl3, yl3, depth+1 ); + PUSH( xr1, yr1, xr2, yr2, xr3, yr3, depth+1 ); + } + else + { + draw_line( ((xl1>>3)+1)>>1, ((yl1>>3)+1)>>1, + ((xr3>>3)+1)>>1, ((yr3>>3)+1)>>1 ); + } + } +#undef PUSH +#undef POP + } + else /* We have the 4 points */ + { +#define PUSH( a1, b1, a2, b2, a3, b3, a4, b4, d ) \ + buffer.bezier[i].x1 = a1; \ + buffer.bezier[i].y1 = b1; \ + buffer.bezier[i].x2 = a2; \ + buffer.bezier[i].y2 = b2; \ + buffer.bezier[i].x3 = a3; \ + buffer.bezier[i].y3 = b3; \ + buffer.bezier[i].x4 = a4; \ + buffer.bezier[i].y4 = b4; \ + buffer.bezier[i].depth = d; \ + i++; +#define POP( a1, b1, a2, b2, a3, b3, a4, b4, d ) \ + i--; \ + a1 = buffer.bezier[i].x1; \ + b1 = buffer.bezier[i].y1; \ + a2 = buffer.bezier[i].x2; \ + b2 = buffer.bezier[i].y2; \ + a3 = buffer.bezier[i].x3; \ + b3 = buffer.bezier[i].y3; \ + a4 = buffer.bezier[i].x4; \ + b4 = buffer.bezier[i].y4; \ + d = buffer.bezier[i].depth; + + PUSH( x1<<4, y1<<4, xa<<4, ya<<4, xb<<4, yb<<4, x2<<4, y2<<4, 0 ); + while( i ) + { + /* de Casteljau's algorithm (see wikipedia) */ + POP( xl1, yl1, xa, ya, xb, yb, xr4, yr4, depth ); + if( depth < 10 ) /* check that the stack's 'i' doesn't overflow */ + { + xl2 = ( xl1 + xa )>>1; + yl2 = ( yl1 + ya )>>1; + xh = ( xa + xb )>>1; + yh = ( ya + yb )>>1; + xr3 = ( xb + xr4 )>>1; + yr3 = ( yb + yr4 )>>1; + xl3 = ( xl2 + xh )>>1; + yl3 = ( yl2 + yh )>>1; + xr2 = ( xr3 + xh )>>1; + yr2 = ( yr3 + yh )>>1; + xl4 = ( xl3 + xr2 )>>1; + yl4 = ( yl3 + yr2 )>>1; + xr1 = xl4; + yr1 = yl4; + PUSH( xl1, yl1, xl2, yl2, xl3, yl3, xl4, yl4, depth+1 ); + PUSH( xr1, yr1, xr2, yr2, xr3, yr3, xr4, yr4, depth+1 ); + } + else + { + draw_line( ((xl1>>3)+1)>>1, ((yl1>>3)+1)>>1, + ((xr4>>3)+1)>>1, ((yr4>>3)+1)>>1 ); + } + } +#undef PUSH +#undef POP + } +} + +static void draw_rect( int x1, int y1, int x2, int y2 ) +{ + draw_line( x1, y1, x1, y2 ); + draw_line( x1, y1, x2, y1 ); + draw_line( x1, y2, x2, y2 ); + draw_line( x2, y1, x2, y2 ); +} + +static void togglebg( void ) +{ + if( isbg ) + { + rb->lcd_set_foreground( rp_colors[ drawcolor ] ); + } + else + { + rb->lcd_set_foreground( rp_colors[ bgdrawcolor ] ); + } + isbg = !isbg; +} + +static void draw_rect_full( int x1, int y1, int x2, int y2 ) +{ + /* GRUIK */ + int x = x1; + togglebg(); + if( x < x2 ) + { + do { + draw_line( x, y1, x, y2 ); + } while( ++x <= x2 ); + } + else + { + do { + draw_line( x, y1, x, y2 ); + } while( --x >= x2 ); + } + togglebg(); + draw_rect( x1, y1, x2, y2 ); +} + +static void draw_oval( int x1, int y1, int x2, int y2, bool full ) +{ + /* TODO: simplify :) */ + int cx = (x1+x2)>>1; + int cy = (y1+y2)>>1; + + int rx = (x1-x2)>>1; + int ry = (y1-y2)>>1; + if( rx < 0 ) rx *= -1; + if( ry < 0 ) ry *= -1; + + if( rx == 0 || ry == 0 ) + { + draw_line( x1, y1, x2, y2 ); + return; + } + + int x,y; + int dst, old_dst; + + for( x = 0; x < rx; x++ ) + { + y = 0; + dst = -0xfff; + do { + old_dst = dst; + dst = ry * ry * x * x + rx * rx * y * y - rx * rx * ry * ry; + y++; + } while( dst < 0 ); + if( -old_dst < dst ) y--; + if( full ) + { + draw_line( cx+x, cy, cx+x, cy+y ); + draw_line( cx+x, cy, cx+x, cy-y ); + draw_line( cx-x, cy, cx-x, cy+y ); + draw_line( cx-x, cy, cx-x, cy-y ); + } + else + { + draw_pixel( cx+x, cy+y ); + draw_pixel( cx+x, cy-y ); + draw_pixel( cx-x, cy+y ); + draw_pixel( cx-x, cy-y ); + } + } + for( y = 0; y < ry; y++ ) + { + x = 0; + dst = -0xfff; + do { + old_dst = dst; + dst = ry * ry * x * x + rx * rx * y * y - rx * rx * ry * ry; + x++; + } while( dst < 0 ); + if( -old_dst < dst ) x--; + if( full ) + { + draw_line( cx+x, cy, cx+x, cy+y ); + draw_line( cx+x, cy, cx+x, cy-y ); + draw_line( cx-x, cy, cx-x, cy+y ); + draw_line( cx-x, cy, cx-x, cy-y ); + } + else + { + draw_pixel( cx+x, cy+y ); + draw_pixel( cx+x, cy-y ); + draw_pixel( cx-x, cy+y ); + draw_pixel( cx-x, cy-y ); + } + } +} + +static void draw_oval_empty( int x1, int y1, int x2, int y2 ) +{ + draw_oval( x1, y1, x2, y2, false ); +} + +static void draw_oval_full( int x1, int y1, int x2, int y2 ) +{ + togglebg(); + draw_oval( x1, y1, x2, y2, true ); + togglebg(); + draw_oval( x1, y1, x2, y2, false ); +} + +static void draw_fill( int x0, int y0 ) +{ +#define PUSH( a, b ) \ + draw_pixel( (int)a, (int)b ); \ + buffer.coord[i].x = a; \ + buffer.coord[i].y = b; \ + i++; +#define POP( a, b ) \ + i--; \ + a = buffer.coord[i].x; \ + b = buffer.coord[i].y; + + unsigned int i=0; + short x = x0; + short y = y0; + unsigned int prev_color = save_buffer[ x0+y0*COLS ]; + + if( prev_color == rp_colors[ drawcolor ] ) return; + + PUSH( x, y ); + + while( i != 0 ) + { + POP( x, y ); + if( x > 0 && save_buffer[x-1+y*COLS] == prev_color ) + { + PUSH( x-1, y ); + } + if( x < COLS-1 && save_buffer[x+1+y*COLS] == prev_color ) + { + PUSH( x+1, y ); + } + if( y > 0 && save_buffer[x+(y-1)*COLS] == prev_color ) + { + PUSH( x, y-1 ); + } + if( y < ROWS - 1 && save_buffer[x+(y+1)*COLS] == prev_color ) + { + PUSH( x, y+1 ); + } + } +#undef PUSH +#undef POP + +} + +/* For preview purposes only */ +static void line_gradient( int x1, int y1, int x2, int y2 ) +{ + int r1, g1, b1; + int r2, g2, b2; + int h1, s1, v1, h2, s2, v2, r, g, b; + int w, h, x, y; + + bool a = false; + + x1 <<= 1; + y1 <<= 1; + x2 <<= 1; + y2 <<= 1; + + w = x1 - x2; + h = y1 - y2; + + if( w == 0 && h == 0 ) + { + draw_pixel( x1>>1, y1>>1 ); + return; + } + + r1 = RGB_UNPACK_RED( rp_colors[ bgdrawcolor ] ); + g1 = RGB_UNPACK_GREEN( rp_colors[ bgdrawcolor ] ); + b1 = RGB_UNPACK_BLUE( rp_colors[ bgdrawcolor ] ); + r2 = RGB_UNPACK_RED( rp_colors[ drawcolor ] ); + g2 = RGB_UNPACK_GREEN( rp_colors[ drawcolor ] ); + b2 = RGB_UNPACK_BLUE( rp_colors[ drawcolor ] ); + + if( w < 0 ) + { + w *= -1; + a = true; + } + if( h < 0 ) + { + h *= -1; + a = !a; + } + if( a ) + { + r = r1; + r1 = r2; + r2 = r; + g = g1; + g1 = g2; + g2 = g; + b = b1; + b1 = b2; + b2 = b; + } + + rgb2hsv( r1, g1, b1, &h1, &s1, &v1 ); + rgb2hsv( r2, g2, b2, &h2, &s2, &v2 ); + + if( w > h ) + { + if( x1 > x2 ) + { + x = x2; + y = y2; + x2 = x1; + y2 = y1; + x1 = x; + y1 = y; + } + w = x1 - x2; + h = y1 - y2; + while( x1 <= x2 ) + { + hsv2rgb( h1+((h2-h1)*(x1-x2))/w, + s1+((s2-s1)*(x1-x2))/w, + v1+((v2-v1)*(x1-x2))/w, + &r, &g, &b ); + rp_colors[ drawcolor ] = LCD_RGBPACK( r, g, b ); + rb->lcd_set_foreground( rp_colors[ drawcolor ] ); + draw_pixel( (x1+1)>>1, (y1+1)>>1 ); + x1+=2; + y1 = y2 - ( x2 - x1 ) * h / w; + } + } + else /* h > w */ + { + if( y1 > y2 ) + { + x = x2; + y = y2; + x2 = x1; + y2 = y1; + x1 = x; + y1 = y; + } + w = x1 - x2; + h = y1 - y2; + while( y1 <= y2 ) + { + hsv2rgb( h1+((h2-h1)*(y1-y2))/h, + s1+((s2-s1)*(y1-y2))/h, + v1+((v2-v1)*(y1-y2))/h, + &r, &g, &b ); + rp_colors[ drawcolor ] = LCD_RGBPACK( r, g, b ); + rb->lcd_set_foreground( rp_colors[ drawcolor ] ); + draw_pixel( (x1+1)>>1, (y1+1)>>1 ); + y1+=2; + x1 = x2 - ( y2 - y1 ) * w / h; + } + } + if( a ) + { + rp_colors[ drawcolor ] = LCD_RGBPACK( r1, g1, b1 ); + } + else + { + rp_colors[ drawcolor ] = LCD_RGBPACK( r2, g2, b2 ); + } +} + +static void linear_gradient( int x1, int y1, int x2, int y2 ) +{ + int r1 = RGB_UNPACK_RED( rp_colors[ bgdrawcolor ] ); + int g1 = RGB_UNPACK_GREEN( rp_colors[ bgdrawcolor ] ); + int b1 = RGB_UNPACK_BLUE( rp_colors[ bgdrawcolor ] ); + int r2 = RGB_UNPACK_RED( rp_colors[ drawcolor ] ); + int g2 = RGB_UNPACK_GREEN( rp_colors[ drawcolor ] ); + int b2 = RGB_UNPACK_BLUE( rp_colors[ drawcolor ] ); + + int h1, s1, v1, h2, s2, v2, r, g, b; + + /* radius^2 */ + int radius2 = ( x1 - x2 ) * ( x1 - x2 ) + ( y1 - y2 ) * ( y1 - y2 ); + int dist2, i=0; + + /* We only propagate the gradient to neighboring pixels with the same + * color as ( x1, y1 ) */ + unsigned int prev_color = save_buffer[ x1+y1*COLS ]; + + int x = x1; + int y = y1; + + if( radius2 == 0 ) return; + if( preview ) + { + line_gradient( x1, y1, x2, y2 ); + } + + rgb2hsv( r1, g1, b1, &h1, &s1, &v1 ); + rgb2hsv( r2, g2, b2, &h2, &s2, &v2 ); + +#define PUSH( x0, y0 ) \ + buffer.coord[i].x = (short)(x0); \ + buffer.coord[i].y = (short)(y0); \ + i++; +#define POP( a, b ) \ + i--; \ + a = (int)buffer.coord[i].x; \ + b = (int)buffer.coord[i].y; + + PUSH( x, y ); + + while( i != 0 ) + { + POP( x, y ); + + dist2 = ( x2 - x1 ) * ( x - x1 ) + ( y2 - y1 ) * ( y - y1 ); + if( dist2 <= 0 ) + { + rp_colors[ drawcolor ] = rp_colors[ bgdrawcolor ]; + } + else if( dist2 < radius2 ) + { + hsv2rgb( h1+((h2-h1)*dist2)/radius2, + s1+((s2-s1)*dist2)/radius2, + v1+((v2-v1)*dist2)/radius2, + &r, &g, &b ); + rp_colors[ drawcolor ] = LCD_RGBPACK( r, g, b ); + } + else + { + rp_colors[ drawcolor ] = LCD_RGBPACK( r2, g2, b2 ); + } + if( rp_colors[ drawcolor ] == prev_color ) + { + if( rp_colors[ drawcolor ]) + rp_colors[ drawcolor ]--; /* GRUIK */ + else + rp_colors[ drawcolor ]++; /* GRUIK */ + } + rb->lcd_set_foreground( rp_colors[ drawcolor ] ); + draw_pixel( x, y ); + + if( x > 0 && save_buffer[x-1+y*COLS] == prev_color ) + { + PUSH( x-1, y ); + } + if( x < COLS-1 && save_buffer[x+1+y*COLS] == prev_color ) + { + PUSH( x+1, y ); + } + if( y > 0 && save_buffer[x+(y-1)*COLS] == prev_color ) + { + PUSH( x, y-1 ); + } + if( y < ROWS - 1 && save_buffer[x+(y+1)*COLS] == prev_color ) + { + PUSH( x, y+1 ); + } + } +#undef PUSH +#undef POP + + rp_colors[ drawcolor ] = LCD_RGBPACK( r2, g2, b2 ); +} + +static void radial_gradient( int x1, int y1, int x2, int y2 ) +{ + int r1 = RGB_UNPACK_RED( rp_colors[ bgdrawcolor ] ); + int g1 = RGB_UNPACK_GREEN( rp_colors[ bgdrawcolor ] ); + int b1 = RGB_UNPACK_BLUE( rp_colors[ bgdrawcolor ] ); + int r2 = RGB_UNPACK_RED( rp_colors[ drawcolor ] ); + int g2 = RGB_UNPACK_GREEN( rp_colors[ drawcolor ] ); + int b2 = RGB_UNPACK_BLUE( rp_colors[ drawcolor ] ); + + int h1, s1, v1, h2, s2, v2, r, g, b; + + /* radius^2 */ + int radius2 = ( x1 - x2 ) * ( x1 - x2 ) + ( y1 - y2 ) * ( y1 - y2 ); + int dist2, i=0; + + /* We only propagate the gradient to neighboring pixels with the same + * color as ( x1, y1 ) */ + unsigned int prev_color = save_buffer[ x1+y1*COLS ]; + + int x = x1; + int y = y1; + + if( radius2 == 0 ) return; + if( preview ) + { + line_gradient( x1, y1, x2, y2 ); + } + + rgb2hsv( r1, g1, b1, &h1, &s1, &v1 ); + rgb2hsv( r2, g2, b2, &h2, &s2, &v2 ); + +#define PUSH( x0, y0 ) \ + buffer.coord[i].x = (short)(x0); \ + buffer.coord[i].y = (short)(y0); \ + i++; +#define POP( a, b ) \ + i--; \ + a = (int)buffer.coord[i].x; \ + b = (int)buffer.coord[i].y; + + PUSH( x, y ); + + while( i != 0 ) + { + POP( x, y ); + + if( ( dist2 = (x1-(x))*(x1-(x))+(y1-(y))*(y1-(y)) ) < radius2 ) + { + hsv2rgb( h1+((h2-h1)*dist2)/radius2, + s1+((s2-s1)*dist2)/radius2, + v1+((v2-v1)*dist2)/radius2, + &r, &g, &b ); + rp_colors[ drawcolor ] = LCD_RGBPACK( r, g, b ); + } + else + { + rp_colors[ drawcolor ] = LCD_RGBPACK( r2, g2, b2 ); + } + if( rp_colors[ drawcolor ] == prev_color ) + { + if( rp_colors[ drawcolor ]) + rp_colors[ drawcolor ]--; /* GRUIK */ + else + rp_colors[ drawcolor ]++; /* GRUIK */ + } + rb->lcd_set_foreground( rp_colors[ drawcolor ] ); + draw_pixel( x, y ); + + if( x > 0 && save_buffer[x-1+y*COLS] == prev_color ) + { + PUSH( x-1, y ); + } + if( x < COLS-1 && save_buffer[x+1+y*COLS] == prev_color ) + { + PUSH( x+1, y ); + } + if( y > 0 && save_buffer[x+(y-1)*COLS] == prev_color ) + { + PUSH( x, y-1 ); + } + if( y < ROWS - 1 && save_buffer[x+(y+1)*COLS] == prev_color ) + { + PUSH( x, y+1 ); + } + } +#undef PUSH +#undef POP + + rp_colors[ drawcolor ] = LCD_RGBPACK( r2, g2, b2 ); +} + +static void draw_toolbars(bool update) +{ + int i; +#define TOP (LCD_HEIGHT-TB_HEIGHT) + rb->lcd_set_background( COLOR_LIGHTGRAY ); + rb->lcd_set_foreground( COLOR_LIGHTGRAY ); + rb->lcd_fillrect( 0, TOP, LCD_WIDTH, TB_HEIGHT ); + rb->lcd_set_foreground( COLOR_BLACK ); + rb->lcd_drawrect( 0, TOP, LCD_WIDTH, TB_HEIGHT ); + + rb->lcd_set_foreground( rp_colors[ bgdrawcolor ] ); + rb->lcd_fillrect( TB_SC_BG_LEFT, TOP+TB_SC_BG_TOP, + TB_SC_SIZE, TB_SC_SIZE ); + rb->lcd_set_foreground(ROCKPAINT_PALETTE); + rb->lcd_drawrect( TB_SC_BG_LEFT, TOP+TB_SC_BG_TOP, + TB_SC_SIZE, TB_SC_SIZE ); + rb->lcd_set_foreground( rp_colors[ drawcolor ] ); + rb->lcd_fillrect( TB_SC_FG_LEFT, TOP+TB_SC_FG_TOP, + TB_SC_SIZE, TB_SC_SIZE ); + rb->lcd_set_foreground(ROCKPAINT_PALETTE); + rb->lcd_drawrect( TB_SC_FG_LEFT, TOP+TB_SC_FG_TOP, + TB_SC_SIZE, TB_SC_SIZE ); + + for( i=0; i<18; i++ ) + { + rb->lcd_set_foreground( rp_colors[i] ); + rb->lcd_fillrect( + TB_PL_LEFT+(i%9)*( TB_PL_COLOR_SIZE+TB_PL_COLOR_SPACING ), + TOP+TB_PL_TOP+(i/9)*( TB_PL_COLOR_SIZE+TB_PL_COLOR_SPACING), + TB_PL_COLOR_SIZE, TB_PL_COLOR_SIZE ); + rb->lcd_set_foreground( ROCKPAINT_PALETTE ); + rb->lcd_drawrect( + TB_PL_LEFT+(i%9)*( TB_PL_COLOR_SIZE+TB_PL_COLOR_SPACING ), + TOP+TB_PL_TOP+(i/9)*( TB_PL_COLOR_SIZE+TB_PL_COLOR_SPACING), + TB_PL_COLOR_SIZE, TB_PL_COLOR_SIZE ); + } + +#define SEPARATOR( x, y ) \ + rb->lcd_set_foreground( COLOR_WHITE ); \ + rb->lcd_vline( x, TOP+y, TOP+y+TB_PL_HEIGHT-1 ); \ + rb->lcd_set_foreground( COLOR_DARKGRAY ); \ + rb->lcd_vline( x+1, TOP+y, TOP+y+TB_PL_HEIGHT-1 ); + SEPARATOR( TB_PL_LEFT + TB_PL_WIDTH - 1 + TB_SP_MARGIN, TB_PL_TOP ); + + rb->lcd_bitmap_transparent( rockpaint, TB_TL_LEFT, TOP+TB_TL_TOP, + TB_TL_WIDTH, TB_TL_HEIGHT ); + rb->lcd_set_foreground(ROCKPAINT_PALETTE); + rb->lcd_drawrect( TB_TL_LEFT+(TB_TL_SIZE+TB_TL_SPACING)*(tool/2), + TOP+TB_TL_TOP+(TB_TL_SIZE+TB_TL_SPACING)*(tool%2), + TB_TL_SIZE, TB_TL_SIZE ); + + SEPARATOR( TB_TL_LEFT + TB_TL_WIDTH - 1 + TB_SP_MARGIN, TB_TL_TOP ); + + rb->lcd_setfont( FONT_SYSFIXED ); + rb->lcd_putsxy( TB_MENU_LEFT, TOP+TB_MENU_TOP, "Menu" ); + rb->lcd_setfont( FONT_UI ); +#undef TOP + + if( update ) rb->lcd_update(); +} + +static void toolbar( void ) +{ + unsigned int button, i, j; + restore_screen(); + draw_toolbars( false ); + y = LCD_HEIGHT-TB_HEIGHT/2; + inv_cursor( true ); + while( 1 ) + { + switch( button = rb->button_get( true ) ) + { + case ROCKPAINT_DRAW: +#define TOP ( LCD_HEIGHT - TB_HEIGHT ) + if( y >= TOP + TB_SC_FG_TOP + && y < TOP + TB_SC_FG_TOP + TB_SC_SIZE + && x >= TB_SC_FG_LEFT + && x < TB_SC_FG_LEFT + TB_SC_SIZE ) + { + /* click on the foreground color */ + rp_colors[drawcolor] = color_chooser( rp_colors[drawcolor] ); + } + else if( y >= TOP + TB_SC_BG_TOP + && y < TOP + TB_SC_BG_TOP + TB_SC_SIZE + && x >= TB_SC_BG_LEFT + && x < TB_SC_BG_LEFT + TB_SC_SIZE ) + { + /* click on the background color */ + i = drawcolor; + drawcolor = bgdrawcolor; + bgdrawcolor = i; + } + else if( y >= TOP + TB_PL_TOP + && y < TOP + TB_PL_TOP + TB_PL_HEIGHT + && x >= TB_PL_LEFT + && x < TB_PL_LEFT + TB_PL_WIDTH ) + { + /* click on the palette */ + i = (x - TB_PL_LEFT)%(TB_PL_COLOR_SIZE+TB_PL_COLOR_SPACING); + j = (y - (TOP+TB_PL_TOP) )%(TB_PL_COLOR_SIZE+TB_PL_COLOR_SPACING); + if( i >= TB_PL_COLOR_SIZE || j >= TB_PL_COLOR_SIZE ) + break; + i = ( x - TB_PL_LEFT )/(TB_PL_COLOR_SIZE+TB_PL_COLOR_SPACING); + j = ( y - (TOP+TB_PL_TOP) )/(TB_PL_COLOR_SIZE+TB_PL_COLOR_SPACING); + drawcolor = j*(TB_PL_COLOR_SIZE+TB_PL_COLOR_SPACING)+i; + } + else if( y >= TOP+TB_TL_TOP + && y < TOP + TB_TL_TOP + TB_TL_HEIGHT + && x >= TB_TL_LEFT + && x <= TB_TL_LEFT + TB_TL_WIDTH ) + { + /* click on the tools */ + i = (x - TB_TL_LEFT ) % (TB_TL_SIZE+TB_TL_SPACING); + j = (y - (TOP+TB_TL_TOP) ) %(TB_TL_SIZE+TB_TL_SPACING); + if( i >= TB_TL_SIZE || j >= TB_TL_SIZE ) break; + i = ( x - TB_TL_LEFT )/(TB_TL_SIZE+TB_TL_SPACING); + j = ( y - (TOP+TB_TL_TOP) )/(TB_TL_SIZE+TB_TL_SPACING); + tool = i*2+j; + prev_x = -1; + prev_y = -1; + prev_x2 = -1; + prev_y2 = -1; + prev_x3 = -1; + prev_y3 = -1; + preview = false; + } + else if( x >= TB_MENU_LEFT && y >= TOP+TB_MENU_TOP-2) + { + /* menu button */ + goto_menu(); + } +#undef TOP + restore_screen(); + draw_toolbars( false ); + inv_cursor( true ); + break; + + case ROCKPAINT_LEFT: + case ROCKPAINT_LEFT | BUTTON_REPEAT: + inv_cursor(false); + x-=bspeed * ( button & BUTTON_REPEAT ? 4 : 1 ); + if (x<0) x=COLS-1; + inv_cursor(true); + break; + + case ROCKPAINT_RIGHT: + case ROCKPAINT_RIGHT | BUTTON_REPEAT: + inv_cursor(false); + x+=bspeed * ( button & BUTTON_REPEAT ? 4 : 1 ); + if (x>=COLS) x=0; + inv_cursor(true); + break; + + case ROCKPAINT_UP: + case ROCKPAINT_UP | BUTTON_REPEAT: + inv_cursor(false); + y-=bspeed * ( button & BUTTON_REPEAT ? 4 : 1 ); + if (y=LCD_HEIGHT) + { + y = 0; + return; + } + inv_cursor(true); + break; + + case ROCKPAINT_TOOLBAR: + case ROCKPAINT_TOOLBAR2: + return; + } + if( quit ) return; + } +} + +static void inv_cursor(bool update) +{ + rb->lcd_set_foreground(COLOR_BLACK); + rb->lcd_set_drawmode(DRMODE_COMPLEMENT); + /* cross painting */ + rb->lcd_drawline(x-4,y,x-1,y); + rb->lcd_drawline(x+1,y,x+4,y); + rb->lcd_drawline(x,y-4,x,y-1); + rb->lcd_drawline(x,y+1,x,y+4); + rb->lcd_set_foreground(rp_colors[drawcolor]); + rb->lcd_set_drawmode(DRMODE_SOLID); + + if( update ) rb->lcd_update(); +} + +static void restore_screen(void) +{ + rb->lcd_bitmap( save_buffer, 0, 0, COLS, ROWS ); +} + +static void clear_drawing(void) +{ + init_buffer(); + rb->lcd_set_foreground( rp_colors[ bgdrawcolor ] ); + rb->lcd_fillrect( 0, 0, COLS, ROWS ); + rb->lcd_update(); +} + +static void goto_menu(void) +{ + int multi; + + while( 1 ) + { + switch( menu_display( main_menu, 1 ) ) + { + case MAIN_MENU_NEW: + clear_drawing(); + return; + + case MAIN_MENU_LOAD: + if( browse( filename, MAX_PATH, "/" ) ) + { + if( load_bitmap( filename ) <= 0 ) + { + rb->splash( 1*HZ, true, "Error while loading %s", + filename ); + } + else + { + rb->splash( 1*HZ, true, "Image loaded (%s)", filename ); + restore_screen(); + inv_cursor(true); + return; + } + } + break; + + case MAIN_MENU_SAVE: + if( !rb->kbd_input( filename, MAX_PATH ) ) + { + save_bitmap( filename ); + rb->splash( 1*HZ, true, "File saved (%s)", filename ); + } + break; + + case MAIN_MENU_BRUSH_SIZE: + multi = menu_display( size_menu, bsize ); + if( multi != - 1 ) + bsize = multi; + break; + + case MAIN_MENU_BRUSH_SPEED: + multi = menu_display( speed_menu, bspeed ); + if( multi != -1 ) + bspeed = multi; + break; + + case MAIN_MENU_COLOR: + rp_colors[drawcolor] = color_chooser( rp_colors[drawcolor] ); + break; + + case MAIN_MENU_GRID_SIZE: + multi = menu_display( gridsize_menu, gridsize ); + if( multi != - 1 ) + gridsize = multi; + break; + + case MAIN_MENU_EXIT: + quit=true; + return; + + case MAIN_MENU_RESUME: + case MENU_ESC: + return; + }/* end switch */ + }/* end while */ +} + +static void reset_tool( void ) +{ + prev_x = -1; + prev_y = -1; + prev_x2 = -1; + prev_y2 = -1; + prev_x3 = -1; + prev_y3 = -1; + tool_mode = -1; + preview = false; +} + +static bool rockpaint_loop( void ) +{ + int button=0,i,j; + int accelaration; + + while (!quit) { + button = rb->button_get(true); + + if( tool == Brush && prev_x != -1 ) + { + accelaration = 1; + } + else if( button & BUTTON_REPEAT ) + { + accelaration = 4; + } + else + { + accelaration = 1; + } + + switch(button) + { + case ROCKPAINT_QUIT: + rb->lcd_set_drawmode(DRMODE_SOLID); + return PLUGIN_OK; + + case ROCKPAINT_MENU: + inv_cursor(false); + goto_menu(); + inv_cursor(true); + break; + + case ROCKPAINT_DRAW: + inv_cursor(false); + switch( tool ) + { + case Brush: + if( prev_x == -1 ) prev_x = 1; + else prev_x = -1; + break; + + case SelectRectangle: + case Line: + case Curve: + case Rectangle: + case RectangleFull: + case Oval: + case OvalFull: + case LinearGradient: + case RadialGradient: + /* Curve uses 4 points, others use 2 */ + if( prev_x == -1 || prev_y == -1 ) + { + prev_x = x; + prev_y = y; + preview = true; + } + else if( tool == Curve + && ( prev_x2 == -1 || prev_y2 == -1 ) ) + { + prev_x2 = x; + prev_y2 = y; + } + else if( tool == SelectRectangle + && ( prev_x2 == -1 || prev_y2 == -1 ) ) + { + tool_mode = menu_display( select_menu, + SELECT_MENU_CUT ); + switch( tool_mode ) + { + case SELECT_MENU_CUT: + case SELECT_MENU_COPY: + prev_x2 = x; + prev_y2 = y; + copy_to_clipboard(); + break; + + case SELECT_MENU_INVERT: + draw_invert( prev_x, prev_y, x, y ); + reset_tool(); + break; + + case SELECT_MENU_CANCEL: + reset_tool(); + break; + + case MENU_ESC: + break; + } + } + else if( tool == Curve + && ( prev_x3 == -1 || prev_y3 == -1 ) ) + { + prev_x3 = x; + prev_y3 = y; + } + else + { + preview = false; + switch( tool ) + { + case SelectRectangle: + draw_paste_rectangle( prev_x, prev_y, + prev_x2, prev_y2, + x, y, tool_mode ); + break; + case Line: + draw_line( prev_x, prev_y, x, y ); + break; + case Curve: + draw_curve( prev_x, prev_y, + prev_x2, prev_y2, + prev_x3, prev_y3, + x, y ); + break; + case Rectangle: + draw_rect( prev_x, prev_y, x, y ); + break; + case RectangleFull: + draw_rect_full( prev_x, prev_y, x, y ); + break; + case Oval: + draw_oval_empty( prev_x, prev_y, x, y ); + break; + case OvalFull: + draw_oval_full( prev_x, prev_y, x, y ); + break; + case LinearGradient: + linear_gradient( prev_x, prev_y, x, y ); + break; + case RadialGradient: + radial_gradient( prev_x, prev_y, x, y ); + break; + default: + break; + } + reset_tool(); + } + break; + + case Fill: + draw_fill( x, y ); + break; + + case ColorPicker: + color_picker( x, y ); + break; + + case Text: + draw_text( x, y ); + break; + + default: + break; + } + inv_cursor(true); + break; + + case ROCKPAINT_DRAW|BUTTON_REPEAT: + if( tool == Curve ) + { + /* 3 point bezier curve */ + preview = false; + draw_curve( prev_x, prev_y, + prev_x2, prev_y2, + -1, -1, + x, y ); + reset_tool(); + restore_screen(); + inv_cursor( true ); + } + break; + + case ROCKPAINT_TOOLBAR: + i = x; j = y; + x = 10; + toolbar(); + x = i; y = j; + restore_screen(); + inv_cursor(true); + break; + + case ROCKPAINT_TOOLBAR2: + i = x; j = y; + x = 110; + toolbar(); + x = i; y = j; + restore_screen(); + inv_cursor(true); + break; + + case ROCKPAINT_LEFT: + case ROCKPAINT_LEFT | BUTTON_REPEAT: + inv_cursor(false); + x-=bspeed * accelaration; + if (x<0) x=COLS-1; + inv_cursor(true); + break; + + case ROCKPAINT_RIGHT: + case ROCKPAINT_RIGHT | BUTTON_REPEAT: + inv_cursor(false); + x+=bspeed * accelaration; + if (x>=COLS) x=0; + inv_cursor(true); + break; + + case ROCKPAINT_UP: + case ROCKPAINT_UP | BUTTON_REPEAT: + inv_cursor(false); + y-=bspeed * accelaration; + if (y<0) y=ROWS-1; + inv_cursor(true); + break; + + case ROCKPAINT_DOWN: + case ROCKPAINT_DOWN | BUTTON_REPEAT: + inv_cursor(false); + y+=bspeed * accelaration; + if (y>=ROWS) + { + toolbar(); + restore_screen(); + } + inv_cursor(true); + break; + + default: + if (rb->default_event_handler(button) == SYS_USB_CONNECTED) + return PLUGIN_USB_CONNECTED; + break; + } + if( tool == Brush && prev_x == 1 ) + { + inv_cursor(false); + draw_brush( x, y ); + inv_cursor(true); + } + if( preview || tool == ColorPicker ) + /* always preview color picker */ + { + restore_screen(); + switch( tool ) + { + case SelectRectangle: + if( prev_x2 == -1 || prev_y2 == -1 ) + { + /* we are defining the selection */ + draw_select_rectangle( prev_x, prev_y, x, y ); + } + else + { + /* we are pasting the selected data */ + draw_paste_rectangle( prev_x, prev_y, prev_x2, + prev_y2, x, y, tool_mode ); + prev_x3 = prev_x2-prev_x; + if( prev_x3 < 0 ) prev_x3 *= -1; + prev_y3 = prev_y2-prev_y; + if( prev_y3 < 0 ) prev_y3 *= -1; + draw_select_rectangle( x, y, x+prev_x3, y+prev_y3 ); + prev_x3 = -1; + prev_y3 = -1; + } + break; + + case Brush: + break; + + case Line: + draw_line( prev_x, prev_y, x, y ); + break; + + case Curve: + if( prev_x2 == -1 || prev_y2 == -1 ) + { + draw_line( prev_x, prev_y, x, y ); + } + else + { + draw_curve( prev_x, prev_y, + prev_x2, prev_y2, + prev_x3, prev_y3, + x, y ); + } + break; + + case Rectangle: + draw_rect( prev_x, prev_y, x, y ); + break; + + case RectangleFull: + draw_rect_full( prev_x, prev_y, x, y ); + break; + + case Oval: + draw_oval_empty( prev_x, prev_y, x, y ); + break; + + case OvalFull: + draw_oval_full( prev_x, prev_y, x, y ); + break; + + case Fill: + break; + + case ColorPicker: + preview = true; + color_picker( x, y ); + preview = false; + break; + + case LinearGradient: + line_gradient( prev_x, prev_y, x, y ); + break; + + case RadialGradient: + line_gradient( prev_x, prev_y, x, y ); + break; + + case Text: + default: + break; + } + inv_cursor( true ); + } + if( gridsize > 0 ) + { + show_grid( true ); + show_grid( false ); + } + } + + return PLUGIN_OK; +} + +static int load_bitmap( char *file ) +{ + struct bitmap bm; + bool ret; + bm.data = (char*)save_buffer; + ret = rb->read_bmp_file( file, &bm, ROWS*COLS*sizeof( fb_data ), + FORMAT_NATIVE ); + if( bm.width < COLS ) + { + int l; + for( l = bm.height-1; l > 0; l-- ) + { + rb->memmove( save_buffer+l*COLS, save_buffer+l*bm.width, + sizeof( fb_data )*bm.width ); + } + for( l = 0; l < bm.height; l++ ) + { + rb->memset( save_buffer+l*COLS+bm.width, rp_colors[ bgdrawcolor ], + sizeof( fb_data )*(COLS-bm.width) ); + } + rb->memset( save_buffer+COLS*bm.height, rp_colors[ bgdrawcolor ], + sizeof( fb_data )*COLS*(ROWS-bm.height) ); + } + return ret; +} + +static int save_bitmap( char *file ) +{ + struct bitmap bm; + bm.data = (char*)save_buffer; + bm.height = ROWS; + bm.width = COLS; + bm.format = FORMAT_NATIVE; + return save_bmp_file( file, &bm, rb ); +} + +enum plugin_status plugin_start(struct plugin_api* api, void* parameter) +{ + /** must have stuff **/ + rb = api; + + rb->lcd_set_foreground(COLOR_WHITE); + rb->lcd_fillrect(0,0,LCD_WIDTH,LCD_HEIGHT); + rb->splash( HZ/2, true, "Rock Paint"); + + rb->lcd_clear_display(); + + filename[0] = '\0'; + + if( parameter ) + { + if( load_bitmap( parameter ) <= 0 ) + { + rb->splash( 1*HZ, true, "Error"); + clear_drawing(); + } + else + { + rb->splash( 1*HZ, true, "Image loaded (%s)", parameter ); + restore_screen(); + rb->strcpy( filename, parameter ); + } + } + else + { + clear_drawing(); + } + inv_cursor(true); + + return rockpaint_loop(); +} diff --git a/apps/plugins/viewers.config b/apps/plugins/viewers.config index ea95ed184b..7b937a90a9 100644 --- a/apps/plugins/viewers.config +++ b/apps/plugins/viewers.config @@ -20,4 +20,5 @@ ss,rocks/sudoku, 55 55 55 55 55 55 wav,viewers/wav2wv, 00 00 00 00 00 00 wav,viewers/mp3_encoder, 00 00 00 00 00 00 wav,viewers/wavplay,60 7F 05 35 3F 00 +bmp,rocks/rockpaint, 01 10 01 10 01 10 -- cgit v1.2.3