From 37b8c5d83da69a13ce155c040a90cc6a850dc456 Mon Sep 17 00:00:00 2001 From: Ole Loots Date: Fri, 13 Jul 2012 22:19:04 +0200 Subject: Plotter refactor: removed one plotter abraction layer. --- atari/Makefile.target | 7 +- atari/bitmap.c | 36 +- atari/bitmap.h | 34 + atari/browser.c | 43 +- atari/browser_win.c | 20 +- atari/ctxmenu.c | 56 +- atari/font.c | 7 +- atari/gui.c | 5 +- atari/options.h | 3 - atari/plot/font_freetype.c | 20 +- atari/plot/font_internal.c | 20 +- atari/plot/font_internal.h | 4 +- atari/plot/font_vdi.c | 2 +- atari/plot/fontplot.c | 88 ++ atari/plot/fontplot.h | 79 ++ atari/plot/plot.c | 2068 ++++++++++++++++++++++++++++++++++++++++++++ atari/plot/plot.h | 187 ++++ atari/statusbar.c | 49 +- atari/toolbar.c | 75 +- atari/treeview.c | 24 +- atari/verify_ssl.c | 30 +- 21 files changed, 2671 insertions(+), 186 deletions(-) create mode 100644 atari/plot/fontplot.c create mode 100644 atari/plot/fontplot.h create mode 100755 atari/plot/plot.c create mode 100755 atari/plot/plot.h diff --git a/atari/Makefile.target b/atari/Makefile.target index 5776a8d1f..2589a4208 100644 --- a/atari/Makefile.target +++ b/atari/Makefile.target @@ -48,11 +48,8 @@ LDFLAGS += -lxml2 -lz -liconv -lcares -lHermes -lwindom -lgem -lm S_ATARI := gui.c findfile.c filetype.c misc.c bitmap.c schedule.c \ download.c thumbnail.c login.c verify_ssl.c treeview.c hotlist.c history.c\ search.c font.c \ - plot.c plot/plotter.c \ - plot/plotter_vdi.c \ - plot/plotter_gd.c \ - plot/font_vdi.c plot/font_freetype.c plot/font_internal.c \ - plot/eddi.s \ + plot/plot.c plot/fontplot.c plot/eddi.s \ + plot/font_freetype.c plot/font_internal.c \ redrawslots.c encoding.c \ browser_win.c toolbar.c statusbar.c browser.c \ global_evnt.c osspec.c dragdrop.c system_colour.c \ diff --git a/atari/bitmap.c b/atari/bitmap.c index 97fa37484..9cfebcaf6 100755 --- a/atari/bitmap.c +++ b/atari/bitmap.c @@ -23,11 +23,43 @@ #include "assert.h" +#include "desktop/options.h" #include "image/bitmap.h" #include "atari/bitmap.h" -#include "atari/plot.h" +#include "atari/plot/plot.h" #include "utils/log.h" + +/* + bpp: bits per pixel, + +*/ +int init_mfdb(int bpp, int w, int h, uint32_t flags, MFDB * out ) +{ + int dststride; + dststride = MFDB_STRIDE( w ); + int size = MFDB_SIZE( bpp, dststride, h ); + if( bpp > 0 ) { + if( (flags & MFDB_FLAG_NOALLOC) == 0 ) { + out->fd_addr = malloc( size ); + if( out->fd_addr == NULL ){ + return( 0 ); + } + if( (flags & MFDB_FLAG_ZEROMEM) ){ + memset( out->fd_addr, 0, size ); + } + } + out->fd_stand = (flags & MFDB_FLAG_STAND) ? 1 : 0; + out->fd_nplanes = (short)bpp; + out->fd_r1 = out->fd_r2 = out->fd_r3 = 0; + } else { + memset( out, 0, sizeof(MFDB) ); + } + out->fd_w = dststride; + out->fd_h = h; + out->fd_wdwidth = dststride >> 4; + return( size ); +} /** @@ -327,7 +359,7 @@ bool bitmap_test_opaque(void *bitmap) LOG(("NULL bitmap!")); return false; } - + if( nsoption_int(atari_transparency) == 0 ){ return( true ); } diff --git a/atari/bitmap.h b/atari/bitmap.h index f917f5560..7002a14ee 100755 --- a/atari/bitmap.h +++ b/atari/bitmap.h @@ -19,10 +19,35 @@ #ifndef NS_ATARI_BITMAP_H #define NS_ATARI_BITMAP_H +#include + +/* Flags for init_mfdb function: */ +#define MFDB_FLAG_STAND 0x01 +#define MFDB_FLAG_ZEROMEM 0x02 +#define MFDB_FLAG_NOALLOC 0x04 + #define BITMAP_SHRINK 0 #define BITMAP_GROW 1024 /* Don't realloc when bitmap size shrinks */ #define BITMAP_CLEAR 2048 /* Zero bitmap memory */ + +/* + calculates MFDB compatible rowstride (in number of bits) +*/ +#define MFDB_STRIDE( w ) (((w & 15) != 0) ? (w | 15)+1 : w) + + +/* +Calculate size of an mfdb, + + params: + + bpp: Bits per pixel, + stride: Word aligned rowstride (width) as returned by MFDB_STRIDE, + h: Height in pixels +*/ +#define MFDB_SIZE( bpp, stride, h ) ( ((stride >> 3) * h) * bpp ) + struct bitmap { int width; int height; @@ -41,5 +66,14 @@ void * bitmap_create_ex( int w, int h, short bpp, int rowstride, unsigned int st void bitmap_to_mfdb(void * bitmap, MFDB * out); void * bitmap_realloc( int w, int h, short bpp, int rowstride, unsigned int state, void * bmp ); size_t bitmap_buffer_size( void * bitmap ) ; +/* + setup an MFDB struct and allocate memory for it when it is needed. + If bpp == 0, this function assumes that the MFDB shall point to the screen + and will not allocate any memory (mfdb.fd_addr == 0). + The function will return 0 when the memory allocation fails + ( out of memory), otherwise it returns the size of the mfdb.fd_addr + as number of bytes. +*/ +int init_mfdb(int bpp, int w, int h, uint32_t flags, MFDB * out ); #endif diff --git a/atari/browser.c b/atari/browser.c index 3d05dbd39..373cd73c7 100755 --- a/atari/browser.c +++ b/atari/browser.c @@ -52,14 +52,16 @@ #include "atari/res/netsurf.rsh" #include "atari/redrawslots.h" #include "atari/browser.h" -#include "atari/plot/plotter.h" -#include "atari/plot.h" +#include "atari/plot/plot.h" +#include "atari/plot/plot.h" #include "atari/encoding.h" #include "atari/ctxmenu.h" #include "cflib.h" -extern GEM_PLOTTER plotter; -extern struct gui_window *input_window; +extern struct gui_window *input_window; + +extern long atari_plot_flags; +extern int atari_plot_vdi_handle; static void browser_process_scroll( struct gui_window * gw, LGRECT bwrect ); static void browser_redraw_content( struct gui_window * gw, int xoff, int yoff, @@ -431,7 +433,7 @@ static void browser_process_scroll( struct gui_window * gw, LGRECT bwrect ) dst.g_y = h; dst.g_w = src.g_w; dst.g_h = src.g_h; - plotter->copy_rect( plotter, src, dst ); + plot_copy_rect(src, dst); b->scroll.current.y += b->scroll.requested.y; browser_schedule_redraw( gw, 0, 0, bwrect.g_w, h ); } @@ -446,7 +448,7 @@ static void browser_process_scroll( struct gui_window * gw, LGRECT bwrect ) dst.g_y = 0; dst.g_w = bwrect.g_w; dst.g_h = bwrect.g_h - h; - plotter->copy_rect( plotter, src, dst ); + plot_copy_rect(src, dst ); b->scroll.current.y += b->scroll.requested.y; browser_schedule_redraw( gw, 0, bwrect.g_h - h, bwrect.g_w, bwrect.g_h ); } @@ -461,7 +463,7 @@ static void browser_process_scroll( struct gui_window * gw, LGRECT bwrect ) dst.g_y = 0; dst.g_w = bwrect.g_w - w; dst.g_h = bwrect.g_h; - plotter->copy_rect( plotter, src, dst ); + plot_copy_rect(src, dst ); b->scroll.current.x += b->scroll.requested.x; browser_schedule_redraw( gw, 0, 0, w, bwrect.g_h ); } @@ -476,7 +478,7 @@ static void browser_process_scroll( struct gui_window * gw, LGRECT bwrect ) dst.g_y = 0; dst.g_w = bwrect.g_w - w; dst.g_h = bwrect.g_h; - plotter->copy_rect( plotter, src, dst ); + plot_copy_rect(src, dst ); b->scroll.current.x += b->scroll.requested.x; browser_schedule_redraw( gw, bwrect.g_w - w, 0, bwrect.g_w, bwrect.g_h ); } @@ -746,15 +748,14 @@ void browser_redraw( struct gui_window * gw ) } browser_get_rect(gw, BR_CONTENT, &bwrect); - - plotter->resize(plotter, bwrect.g_w, bwrect.g_h); - plotter->move(plotter, bwrect.g_x, bwrect.g_y ); + + plot_set_dimensions(bwrect.g_x, bwrect.g_y, bwrect.g_w, bwrect.g_h); clip.x0 = 0; clip.y0 = 0; clip.x1 = bwrect.g_w; clip.y1 = bwrect.g_h; - plotter->set_clip( plotter, &clip ); - if( plotter->lock(plotter) == 0 ) + plot_clip(&clip); + if (plot_lock() == false) return; if( b->scroll.required == true && b->bw->current_content != NULL) { @@ -763,7 +764,7 @@ void browser_redraw( struct gui_window * gw ) } if ((b->redraw.areas_used > 0) && b->bw->current_content != NULL ) { - if( (plotter->flags & PLOT_FLAG_OFFSCREEN) == 0 ) { + if( (atari_plot_flags & PLOT_FLAG_OFFSCREEN) == 0 ) { int i; GRECT area; @@ -773,7 +774,7 @@ void browser_redraw( struct gui_window * gw ) todo[1] = bwrect.g_y; todo[2] = todo[0] + bwrect.g_w-1; todo[3] = todo[1] + bwrect.g_h-1; - vs_clip(plotter->vdi_handle, 1, (short*)&todo[0]); + vs_clip(atari_plot_vdi_handle, 1, (short*)&todo[0]); wind_get( 0, WF_TOP, &wf_top[0], &wf_top[1], &wf_top[2], &wf_top[3] ); @@ -859,9 +860,7 @@ void browser_redraw( struct gui_window * gw ) } } } - - - vs_clip(plotter->vdi_handle, 0, (short*)&todo); + vs_clip(atari_plot_vdi_handle, 0, (short*)&todo); } else { /* its save to do a complete redraw without knowledge about GEM windows :) */ @@ -881,7 +880,7 @@ void browser_redraw( struct gui_window * gw ) area.g_y = bwrect.g_y; area.g_w = bwrect.g_w; area.g_h = bwrect.g_h; - //plotter->blit( plotter, &area ); + //plot_blit( plotter, &area ); } b->redraw.areas_used = 0; } @@ -895,12 +894,12 @@ void browser_redraw( struct gui_window * gw ) area.g_y = bwrect.g_y; area.g_w = bwrect.g_w; area.g_h = bwrect.g_h; - vs_clip(plotter->vdi_handle, 1, (short*)&todo[0]); + vs_clip(atari_plot_vdi_handle, 1, (short*)&todo[0]); browser_redraw_caret( gw, &area ); - vs_clip(plotter->vdi_handle, 0, (short*)&todo[0]); + vs_clip(atari_plot_vdi_handle, 0, (short*)&todo[0]); b->caret.redraw = false; } - plotter->unlock(plotter); + plot_unlock(); /* TODO: if we use offscreen bitmap, trigger content redraw here */ } diff --git a/atari/browser_win.c b/atari/browser_win.c index e9a0c499a..273ef48eb 100755 --- a/atari/browser_win.c +++ b/atari/browser_win.c @@ -47,13 +47,12 @@ #include "atari/browser_win.h" #include "atari/browser.h" #include "atari/misc.h" -#include "atari/plot.h" +#include "atari/plot/plot.h" #include "atari/global_evnt.h" #include "atari/res/netsurf.rsh" #include "atari/browser.h" #include "atari/toolbar.h" #include "atari/statusbar.h" -#include "atari/plot/plotter.h" #include "atari/dragdrop.h" #include "atari/search.h" #include "atari/osspec.h" @@ -62,7 +61,6 @@ extern void * h_gem_rsrc; extern struct gui_window *input_window; -extern GEM_PLOTTER plotter; void __CDECL std_szd( WINDOW * win, short buff[8], void * ); void __CDECL std_mvd( WINDOW * win, short buff[8], void * ); @@ -229,9 +227,8 @@ void window_open( struct gui_window * gw, GRECT pos ) /* recompute the nested component sizes and positions: */ browser_update_rects( gw ); mt_WindGetGrect( &app, gw->root->handle, WF_CURRXYWH, (GRECT*)&gw->root->loc); - browser_get_rect( gw, BR_CONTENT, &br ); - plotter->move( plotter, br.g_x, br.g_y ); - plotter->resize( plotter, br.g_w, br.g_h ); + browser_get_rect( gw, BR_CONTENT, &br ); + plot_set_dimensions(br.g_x, br.g_y, br.g_w, br.g_h); gw->browser->attached = true; if( gw->root->statusbar != NULL ){ gw->root->statusbar->attached = true; @@ -504,13 +501,10 @@ static void __CDECL evnt_window_icondraw( WINDOW *win, short buff[8], void * dat } else { struct rect clip = { 0,0,w,h }; plot_set_dimensions( x,y,w,h ); - plotter->set_clip(plotter, &clip ); - plotter->bitmap_resize( plotter, gw->icon, w, h ); - plotter->bitmap( - plotter, - ( gw->icon->resized ) ? gw->icon->resized : gw->icon, - 0, 0, 0xffffff, BITMAPF_NONE - ); + plot_clip(&clip); + plot_resize_bitmap(gw->icon, w, h); + plot_blit_bitmap(( gw->icon->resized ) ? gw->icon->resized : gw->icon, + 0, 0, 0xffffff, BITMAPF_NONE); } } diff --git a/atari/ctxmenu.c b/atari/ctxmenu.c index 2acf61ca4..d5c39d341 100644 --- a/atari/ctxmenu.c +++ b/atari/ctxmenu.c @@ -149,8 +149,8 @@ void context_popup( struct gui_window * gw, short x, short y ) char * data; FILE * fp_tmpfile; char * tempfile; - int err = 0; - char * editor; + int err = 0; + char * editor; char cmdline[128]; pop = get_tree( POP_CTX ); @@ -177,7 +177,7 @@ void context_popup( struct gui_window * gw, short x, short y ) if( ctx->flags & CNT_HREF ){ SET_BIT(pop[ POP_CTX_COPY_LINK ].ob_state, DISABLED, 0); - SET_BIT(pop[ POP_CTX_OPEN_NEW ].ob_state, DISABLED, 0); + SET_BIT(pop[ POP_CTX_OPEN_NEW ].ob_state, DISABLED, 0); SET_BIT(pop[ POP_CTX_SAVE_LINK_AS ].ob_state, DISABLED, 0); } @@ -210,24 +210,24 @@ void context_popup( struct gui_window * gw, short x, short y ) browser_window_key_press( gw->browser->bw, KEY_SELECT_ALL ); break; - case POP_CTX_SAVE_AS: - if( ctx->ccdata.object != NULL ) { + case POP_CTX_SAVE_AS: + if( ctx->ccdata.object != NULL ) { if( hlcache_handle_get_url(ctx->ccdata.object) != NULL ) { browser_window_download( gw->browser->bw, nsurl_access(hlcache_handle_get_url(ctx->ccdata.object)), nsurl_access(hlcache_handle_get_url(gw->browser->bw->current_content)) ); - } - } - - case POP_CTX_SAVE_LINK_AS: - if( ctx->ccdata.link_url != NULL ) { + } + } + + case POP_CTX_SAVE_LINK_AS: + if( ctx->ccdata.link_url != NULL ) { browser_window_download( gw->browser->bw, - nsurl_access((const char*)ctx->ccdata.link_url), + nsurl_access(/*(const char*)*/ctx->ccdata.link_url), nsurl_access(hlcache_handle_get_url(gw->browser->bw->current_content)) - ); + ); } break; @@ -257,7 +257,7 @@ void context_popup( struct gui_window * gw, short x, short y ) } break; - case POP_CTX_VIEW_SOURCE: + case POP_CTX_VIEW_SOURCE: editor = nsoption_charp(atari_editor); if( editor != NULL && strlen(editor)>0 ) { data = content_get_source_data( gw->browser->bw->current_content, &size ); @@ -266,24 +266,24 @@ void context_popup( struct gui_window * gw, short x, short y ) fp_tmpfile = fopen( tempfile, "w" ); if( fp_tmpfile ){ fwrite( data, size, 1, fp_tmpfile ); - fclose( fp_tmpfile ); - - // TODO: check if app is runnin, if not, use pexec or such. - /* - sprintf((char*)&cmdline, "%s \"%s\"", nsoption_charp(atari_editor), tempfile ); - system( (char*)&cmdline ); - */ - err = ShelWrite( editor, tempfile , editor, 1, 0); + fclose( fp_tmpfile ); + + // TODO: check if app is runnin, if not, use pexec or such. + /* + sprintf((char*)&cmdline, "%s \"%s\"", nsoption_charp(atari_editor), tempfile ); + system( (char*)&cmdline ); + */ + err = ShelWrite( editor, tempfile , editor, 1, 0); LOG(("Launched: %s %s (%d)\n", editor, tempfile, err )); - } else { - printf("Could not open temp file: %s!\n", tempfile ); - } + } else { + printf("Could not open temp file: %s!\n", tempfile ); + } - } else { - LOG(("Invalid content!")); + } else { + LOG(("Invalid content!")); } - } else { - form_alert(0, "[1][Set option \"option_atari_editor\".][OK]"); + } else { + form_alert(0, "[1][Set option \"option_atari_editor\".][OK]"); } break; diff --git a/atari/font.c b/atari/font.c index cb47c8ef3..713765818 100755 --- a/atari/font.c +++ b/atari/font.c @@ -31,13 +31,12 @@ #include "atari/gui.h" #include "atari/font.h" -#include "atari/plot.h" +#include "atari/plot/plot.h" #include "atari/findfile.h" #include "atari/gui.h" -#include "atari/plot.h" -#include "atari/plot/plotter.h" +#include "atari/plot/plot.h" -extern GEM_FONT_PLOTTER fplotter; +extern FONT_PLOTTER fplotter; static bool atari_font_position_in_string(const plot_font_style_t * fstyle,const char *string, size_t length,int x, size_t *char_offset, int *actual_x ) diff --git a/atari/gui.c b/atari/gui.c index fef8fcb62..12e516f73 100755 --- a/atari/gui.c +++ b/atari/gui.c @@ -71,7 +71,7 @@ #include "atari/global_evnt.h" #include "atari/encoding.h" #include "atari/res/netsurf.rsh" -#include "atari/plot.h" +#include "atari/plot/plot.h" #include "atari/clipboard.h" #include "atari/osspec.h" #include "atari/search.h" @@ -85,7 +85,6 @@ struct gui_window *window_list = NULL; void * h_gem_rsrc; OBJECT * h_gem_menu; OBJECT **rsc_trindex; -short vdih; short rsc_ntree; long next_poll; bool rendering = false; @@ -972,7 +971,7 @@ static void gui_init(int argc, char** argv) die("unable to process command line.\n"); nkc_init(); - atari_plotter_init( nsoption_charp(atari_screen_driver), nsoption_charp(atari_font_driver) ); + atari_plotter_init(nsoption_charp(atari_font_driver)); } static char *theapp = (char*)"NetSurf"; diff --git a/atari/options.h b/atari/options.h index 9b6257d9c..005271f62 100755 --- a/atari/options.h +++ b/atari/options.h @@ -25,7 +25,6 @@ #define NSOPTION_EXTRA_DEFINE \ - char *atari_screen_driver; \ char *atari_font_driver; \ int atari_font_monochrom; \ int atari_dither; \ @@ -50,7 +49,6 @@ char *tree_icons_path #define NSOPTION_EXTRA_DEFAULTS \ - .atari_screen_driver = (char*)"vdi", \ .atari_font_driver = (char*)"vdi", \ .atari_font_monochrom = 0, \ .atari_dither = 1, \ @@ -75,7 +73,6 @@ .tree_icons_path = (char*)"./res/icons" #define NSOPTION_EXTRA_TABLE \ - { "atari_screen_driver", OPTION_STRING, &nsoptions.atari_screen_driver },\ { "atari_font_driver", OPTION_STRING, &nsoptions.atari_font_driver },\ { "atari_font_monochrom", OPTION_INTEGER, &nsoptions.atari_font_monochrom },\ { "atari_image_toolbar", OPTION_INTEGER, &nsoptions.atari_image_toolbar },\ diff --git a/atari/plot/font_freetype.c b/atari/plot/font_freetype.c index 355809346..4717fdee9 100755 --- a/atari/plot/font_freetype.c +++ b/atari/plot/font_freetype.c @@ -20,12 +20,16 @@ #ifdef WITH_FREETYPE_FONT_DRIVER #include #include FT_CACHE_H - -#include "atari/plot/plotter.h" + +#include "desktop/options.h" +#include "atari/plot/plot.h" #include "atari/plot/font_freetype.h" #define DEJAVU_PATH "/usr/share/fonts/truetype/ttf-dejavu/" + +extern unsigned long atari_plot_flags; +extern int atari_plot_vdi_handle; static FT_Library library; static FTC_Manager ft_cmanager; @@ -395,7 +399,7 @@ static void draw_glyph8(FONT_PLOTTER self, GRECT * clip, GRECT * loc, uint8_t * h = loc->g_h; w = loc->g_w; - + assert( h <= fontbmp_allocated_height ); assert( w <= fontbmp_allocated_width ); @@ -408,7 +412,7 @@ static void draw_glyph8(FONT_PLOTTER self, GRECT * clip, GRECT * loc, uint8_t * linebuf[xloop] = (uint32_t)(colour | fontpix); } } - self->plotter->bitmap( self->plotter, fontbmp, loc->g_x, loc->g_y, 0, BITMAPF_MONOGLYPH); + plot_blit_bitmap(fontbmp, loc->g_x, loc->g_y, 0, BITMAPF_MONOGLYPH); } static void draw_glyph1(FONT_PLOTTER self, GRECT * clip, GRECT * loc, uint8_t * pixdata, int pitch, uint32_t colour) @@ -464,10 +468,10 @@ static void draw_glyph1(FONT_PLOTTER self, GRECT * clip, GRECT * loc, uint8_t * #ifdef WITH_8BPP_SUPPORT if( app.nplanes > 8 ){ #endif - self->plotter->plot_mfdb( self->plotter, loc, &tmp, OFFSET_CUSTOM_COLOR, PLOT_FLAG_TRANS ); + plot_blit_mfdb(loc, &tmp, OFFSET_CUSTOM_COLOR, PLOT_FLAG_TRANS ); #ifdef WITH_8BPP_SUPPORT } else { - self->plotter->plot_mfdb( self->plotter, loc, &tmp, colour, PLOT_FLAG_TRANS ); + plot_blit_mfdb(loc, &tmp, colour, PLOT_FLAG_TRANS ); } #endif @@ -493,7 +497,7 @@ static int text( FONT_PLOTTER self, int x, int y, const char *text, size_t leng #endif unsigned short out[4]; rgb_to_vdi1000( (unsigned char*)&c, (unsigned short*)&out ); - vs_color( self->plotter->vdi_handle, OFFSET_CUSTOM_COLOR, (unsigned short*)&out[0] ); + vs_color(atari_plot_vdi_handle, OFFSET_CUSTOM_COLOR, (unsigned short*)&out[0]); #ifdef WITH_8BPP_SUPPORT } else { c = RGB_TO_VDI(c); @@ -501,7 +505,7 @@ static int text( FONT_PLOTTER self, int x, int y, const char *text, size_t leng #endif } - self->plotter->get_clip( self->plotter, &clipping ); + plot_get_clip(&clipping); clip.g_x = clipping.x0; clip.g_y = clipping.y0; clip.g_w = (clipping.x1 - clipping.x0)+1; diff --git a/atari/plot/font_internal.c b/atari/plot/font_internal.c index e8ddc5ae1..4edec4565 100644 --- a/atari/plot/font_internal.c +++ b/atari/plot/font_internal.c @@ -17,15 +17,19 @@ * along with this program. If not, see . */ -#ifdef WITH_INTERNAL_FONT_DRIVER -#include "atari/plot/plotter.h" +#ifdef WITH_INTERNAL_FONT_DRIVER + +#include "atari/plot/plot.h" +#include "atari/plot/fontplot.h" #include "atari/plot/font_internal.h" #include "utils/utf8.h" #include "utils/log.h" #include - + +extern unsigned long atari_plot_flags; +extern int atari_plot_vdi_handle; static int dtor( FONT_PLOTTER self ); static int str_width( FONT_PLOTTER self,const plot_font_style_t *fstyle, const char * str, size_t length, int * width ); @@ -162,7 +166,7 @@ static void draw_glyph1(FONT_PLOTTER self, GRECT *inloc, uint8_t *chrp, int pitc pixmask = (pixmask << 1); } } - self->plotter->bitmap( self->plotter, fontbmp, loc.g_x, loc.g_y, 0, BITMAPF_MONOGLYPH ); + plot_blit_bitmap(fontbmp, loc.g_x, loc.g_y, 0, BITMAPF_MONOGLYPH ); } static int text( FONT_PLOTTER self, int x, int y, const char *text, size_t length, @@ -192,7 +196,7 @@ static int text( FONT_PLOTTER self, int x, int y, const char *text, size_t leng return( 1 ); } - if( self->plotter->flags & PLOT_FLAG_OFFSCREEN ){ + if(atari_plot_flags & PLOT_FLAG_OFFSCREEN ){ /* when the plotter is an offscreen plotter the call to bitmap() isn't that expensive. Draw an 8 bit bitmap into the offscreen buffer. @@ -245,12 +249,12 @@ static int text( FONT_PLOTTER self, int x, int y, const char *text, size_t leng #endif unsigned short out[4]; rgb_to_vdi1000( (unsigned char*)&fstyle->foreground, (unsigned short*)&out ); - vs_color( self->plotter->vdi_handle, OFFSET_CUSTOM_COLOR, (unsigned short*)&out[0] ); - self->plotter->plot_mfdb( self->plotter, &loc, &tmp, OFFSET_CUSTOM_COLOR, PLOT_FLAG_TRANS ); + vs_color(atari_plot_vdi_handle, OFFSET_CUSTOM_COLOR, (unsigned short*)&out[0] ); + plot_blit_mfdb(&loc, &tmp, OFFSET_CUSTOM_COLOR, PLOT_FLAG_TRANS ); #ifdef WITH_8BPP_SUPPORT } else { unsigned char c = RGB_TO_VDI(fstyle->foreground); - self->plotter->plot_mfdb( self->plotter, &loc, &tmp, c, PLOT_FLAG_TRANS ); + plot_blit_mfdb(&loc, &tmp, c, PLOT_FLAG_TRANS ); } #endif } diff --git a/atari/plot/font_internal.h b/atari/plot/font_internal.h index b5de3c2cc..628a63cdc 100644 --- a/atari/plot/font_internal.h +++ b/atari/plot/font_internal.h @@ -18,7 +18,9 @@ */ #ifdef WITH_INTERNAL_FONT_DRIVER #ifndef FONT_PLOTTER_INTERNAL -#define FONT_PLOTTER_INTERNAL +#define FONT_PLOTTER_INTERNAL + +#include "atari/plot/plot.h" int ctor_font_plotter_internal( FONT_PLOTTER self ); diff --git a/atari/plot/font_vdi.c b/atari/plot/font_vdi.c index 56afab569..89596b38a 100755 --- a/atari/plot/font_vdi.c +++ b/atari/plot/font_vdi.c @@ -17,7 +17,7 @@ */ #ifdef WITH_VDI_FONT_DRIVER -#include "atari/plot/plotter.h" +#include "atari/plot/plot.h" #include "atari/plot/font_vdi.h" #include "utils/utf8.h" diff --git a/atari/plot/fontplot.c b/atari/plot/fontplot.c new file mode 100644 index 000000000..ba4e26776 --- /dev/null +++ b/atari/plot/fontplot.c @@ -0,0 +1,88 @@ +#include "atari/plot/fontplot.h" + +const struct s_font_driver_table_entry font_driver_table[] = +{ +#ifdef WITH_VDI_FONT_DRIVER + {"vdi", ctor_font_plotter_vdi, 0}, +#endif +#ifdef WITH_FREETYPE_FONT_DRIVER + {"freetype", ctor_font_plotter_freetype, 0}, +#endif +#ifdef WITH_INTERNAL_FONT_DRIVER + {"internal", ctor_font_plotter_internal, 0}, +#endif + {(char*)NULL, NULL, 0} +}; + +void dump_font_drivers(void) +{ + int i = 0; + while( font_driver_table[i].name != NULL ) { + printf("%s -> flags: %d\n", + font_driver_table[i].name, + font_driver_table[i].flags + ); + i++; + } +} + + +/* + Create an new text plotter object +*/ +FONT_PLOTTER new_font_plotter( int vdihandle, char * name, unsigned long flags, + int * error) +{ + int i=0; + int res = 0-ERR_PLOTTER_NOT_AVAILABLE; + FONT_PLOTTER fplotter = (FONT_PLOTTER)malloc( sizeof(struct s_font_plotter) ); + if( fplotter == NULL ) { + *error = 0-ERR_NO_MEM; + return( NULL ); + } + memset( fplotter, 0, sizeof(FONT_PLOTTER)); + fplotter->vdi_handle = vdihandle; + fplotter->name = name; + fplotter->flags = 0; + fplotter->flags |= flags; + for( i = 0; ; i++) { + if( font_driver_table[i].name == NULL ) { + res = 0-ERR_PLOTTER_NOT_AVAILABLE; + break; + } else { + if( strcmp(name, font_driver_table[i].name) == 0 ) { + if( font_driver_table[i].ctor ) { + res = font_driver_table[i].ctor( fplotter ); + *error = 0; + } else { + res = 0-ERR_PLOTTER_NOT_AVAILABLE; + *error = res; + return (NULL); + } + break; + } + } + } + if( res < 0 ) { + free( fplotter ); + *error = res; + return( NULL ); + } + return( fplotter ); +} + +/* + Free an font plotter +*/ +int delete_font_plotter(FONT_PLOTTER p) +{ + if( p ) { + p->dtor(p); + free( p ); + p = NULL; + } + else + return( -1 ); + return( 0 ); +} + diff --git a/atari/plot/fontplot.h b/atari/plot/fontplot.h new file mode 100644 index 000000000..e4286a961 --- /dev/null +++ b/atari/plot/fontplot.h @@ -0,0 +1,79 @@ +#ifndef FONT_PLOT_H +#define FONT_PLOT_H + +#include +#include +#include +#include +#include +#include + +#include "desktop/plot_style.h" +#include "image/bitmap.h" +#include "utils/log.h" +#include "atari/bitmap.h" +#include "atari/plot/eddi.h" +#include "atari/gui.h" +#include "atari/misc.h" +#include "atari/osspec.h" + +typedef struct s_font_plotter * FONT_PLOTTER; + +struct s_font_driver_table_entry +{ + const char * name; + int (*ctor)( FONT_PLOTTER self ); + int flags; +}; + +/* declaration of font plotter member functions: (_fpmf_ prefix) */ +typedef int (*_fpmf_str_width)( FONT_PLOTTER self, const plot_font_style_t *fstyle, + const char * str, size_t length, int * width); +typedef int (*_fpmf_str_split)( FONT_PLOTTER self, const plot_font_style_t *fstyle, + const char *string, size_t length, + int x, size_t *char_offset, int *actual_x); +typedef int (*_fpmf_pixel_pos)( FONT_PLOTTER self, const plot_font_style_t *fstyle, + const char *string, size_t length, + int x, size_t *char_offset, int *actual_x); +typedef int (*_fpmf_text)( FONT_PLOTTER self, int x, int y, const char *text, + size_t length, const plot_font_style_t *fstyle); + +typedef void (*_fpmf_draw_glyph)(FONT_PLOTTER self, GRECT * clip, GRECT * loc, + uint8_t * pixdata, int pitch, uint32_t colour); +typedef int (*_fpmf_dtor)( FONT_PLOTTER self ); + + +/* prototype of the font plotter "object" */ +struct s_font_plotter +{ + char * name; + int flags; + int vdi_handle; + void * priv_data; + + _fpmf_str_width str_width; + _fpmf_str_split str_split; + _fpmf_pixel_pos pixel_pos; + _fpmf_text text; + _fpmf_draw_glyph draw_glyph; + _fpmf_dtor dtor; +}; + + +void dump_font_drivers(void); +FONT_PLOTTER new_font_plotter( int vdihandle, char * name, unsigned long flags, + int * error); +int delete_font_plotter( FONT_PLOTTER p ); +#ifdef WITH_VDI_FONT_DRIVER + #include "atari/plot/font_vdi.h" +#endif +#ifdef WITH_INTERNAL_FONT_DRIVER + #include "atari/plot/font_internal.h" +#endif +#ifdef WITH_FREETYPE_FONT_DRIVER + #include "atari/plot/font_freetype.h" +#endif + + + +#endif diff --git a/atari/plot/plot.c b/atari/plot/plot.c new file mode 100755 index 000000000..458e3dd8a --- /dev/null +++ b/atari/plot/plot.c @@ -0,0 +1,2068 @@ +/* + * Copyright 2010 Ole Loots + * + * This file is part of NetSurf, http://www.netsurf-browser.org/ + * + * NetSurf is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * NetSurf is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "image/bitmap.h" +#include "utils/log.h" +#include "utils/utf8.h" +#include "utils/utils.h" +#include "desktop/gui.h" +#include "desktop/plotters.h" + +#include "atari/bitmap.h" +#include "atari/gui.h" +#include "desktop/options.h" +#include "atari/plot/plot.h" + +struct s_view { + short x; /* drawing (screen) offset x */ + short y; /* drawing (screen) offset y */ + short w; /* width of buffer, not in sync with vis_w */ + short h; /* height of buffer, not in sync with vis_w */ + short vis_x; /* visible rectangle of the screen buffer */ + short vis_y; /* coords are relative to plot location */ + short vis_w; /* clipped to screen dimensions */ + short vis_h; /* visible width */ + struct rect clipping; /* clipping rectangle */ +}; + + +#ifdef WITH_8BPP_SUPPORT +static unsigned short sys_pal[256][3]; /*RGB*/ +static unsigned short pal[256][3]; /*RGB*/ +static char rgb_lookup[256][4]; +short web_std_colors[6] = {0, 51, 102, 153, 204, 255}; + +unsigned short vdi_web_pal[216][3] = { + {0x000,0x000,0x000}, {0x0c8,0x000,0x000}, {0x190,0x000,0x000}, {0x258,0x000,0x000}, {0x320,0x000,0x000}, {0x3e8,0x000,0x000}, + {0x000,0x0c8,0x000}, {0x0c8,0x0c8,0x000}, {0x190,0x0c8,0x000}, {0x258,0x0c8,0x000}, {0x320,0x0c8,0x000}, {0x3e8,0x0c8,0x000}, + {0x000,0x190,0x000}, {0x0c8,0x190,0x000}, {0x190,0x190,0x000}, {0x258,0x190,0x000}, {0x320,0x190,0x000}, {0x3e8,0x190,0x000}, + {0x000,0x258,0x000}, {0x0c8,0x258,0x000}, {0x190,0x258,0x000}, {0x258,0x258,0x000}, {0x320,0x258,0x000}, {0x3e8,0x258,0x000}, + {0x000,0x320,0x000}, {0x0c8,0x320,0x000}, {0x190,0x320,0x000}, {0x258,0x320,0x000}, {0x320,0x320,0x000}, {0x3e8,0x320,0x000}, + {0x000,0x3e8,0x000}, {0x0c8,0x3e8,0x000}, {0x190,0x3e8,0x000}, {0x258,0x3e8,0x000}, {0x320,0x3e8,0x000}, {0x3e8,0x3e8,0x000}, + {0x000,0x000,0x0c8}, {0x0c8,0x000,0x0c8}, {0x190,0x000,0x0c8}, {0x258,0x000,0x0c8}, {0x320,0x000,0x0c8}, {0x3e8,0x000,0x0c8}, + {0x000,0x0c8,0x0c8}, {0x0c8,0x0c8,0x0c8}, {0x190,0x0c8,0x0c8}, {0x258,0x0c8,0x0c8}, {0x320,0x0c8,0x0c8}, {0x3e8,0x0c8,0x0c8}, + {0x000,0x190,0x0c8}, {0x0c8,0x190,0x0c8}, {0x190,0x190,0x0c8}, {0x258,0x190,0x0c8}, {0x320,0x190,0x0c8}, {0x3e8,0x190,0x0c8}, + {0x000,0x258,0x0c8}, {0x0c8,0x258,0x0c8}, {0x190,0x258,0x0c8}, {0x258,0x258,0x0c8}, {0x320,0x258,0x0c8}, {0x3e8,0x258,0x0c8}, + {0x000,0x320,0x0c8}, {0x0c8,0x320,0x0c8}, {0x190,0x320,0x0c8}, {0x258,0x320,0x0c8}, {0x320,0x320,0x0c8}, {0x3e8,0x320,0x0c8}, + {0x000,0x3e8,0x0c8}, {0x0c8,0x3e8,0x0c8}, {0x190,0x3e8,0x0c8}, {0x258,0x3e8,0x0c8}, {0x320,0x3e8,0x0c8}, {0x3e8,0x3e8,0x0c8}, + {0x000,0x000,0x190}, {0x0c8,0x000,0x190}, {0x190,0x000,0x190}, {0x258,0x000,0x190}, {0x320,0x000,0x190}, {0x3e8,0x000,0x190}, + {0x000,0x0c8,0x190}, {0x0c8,0x0c8,0x190}, {0x190,0x0c8,0x190}, {0x258,0x0c8,0x190}, {0x320,0x0c8,0x190}, {0x3e8,0x0c8,0x190}, + {0x000,0x190,0x190}, {0x0c8,0x190,0x190}, {0x190,0x190,0x190}, {0x258,0x190,0x190}, {0x320,0x190,0x190}, {0x3e8,0x190,0x190}, + {0x000,0x258,0x190}, {0x0c8,0x258,0x190}, {0x190,0x258,0x190}, {0x258,0x258,0x190}, {0x320,0x258,0x190}, {0x3e8,0x258,0x190}, + {0x000,0x320,0x190}, {0x0c8,0x320,0x190}, {0x190,0x320,0x190}, {0x258,0x320,0x190}, {0x320,0x320,0x190}, {0x3e8,0x320,0x190}, + {0x000,0x3e8,0x190}, {0x0c8,0x3e8,0x190}, {0x190,0x3e8,0x190}, {0x258,0x3e8,0x190}, {0x320,0x3e8,0x190}, {0x3e8,0x3e8,0x190}, + {0x000,0x000,0x258}, {0x0c8,0x000,0x258}, {0x190,0x000,0x258}, {0x258,0x000,0x258}, {0x320,0x000,0x258}, {0x3e8,0x000,0x258}, + {0x000,0x0c8,0x258}, {0x0c8,0x0c8,0x258}, {0x190,0x0c8,0x258}, {0x258,0x0c8,0x258}, {0x320,0x0c8,0x258}, {0x3e8,0x0c8,0x258}, + {0x000,0x190,0x258}, {0x0c8,0x190,0x258}, {0x190,0x190,0x258}, {0x258,0x190,0x258}, {0x320,0x190,0x258}, {0x3e8,0x190,0x258}, + {0x000,0x258,0x258}, {0x0c8,0x258,0x258}, {0x190,0x258,0x258}, {0x258,0x258,0x258}, {0x320,0x258,0x258}, {0x3e8,0x258,0x258}, + {0x000,0x320,0x258}, {0x0c8,0x320,0x258}, {0x190,0x320,0x258}, {0x258,0x320,0x258}, {0x320,0x320,0x258}, {0x3e8,0x320,0x258}, + {0x000,0x3e8,0x258}, {0x0c8,0x3e8,0x258}, {0x190,0x3e8,0x258}, {0x258,0x3e8,0x258}, {0x320,0x3e8,0x258}, {0x3e8,0x3e8,0x258}, + {0x000,0x000,0x320}, {0x0c8,0x000,0x320}, {0x190,0x000,0x320}, {0x258,0x000,0x320}, {0x320,0x000,0x320}, {0x3e8,0x000,0x320}, + {0x000,0x0c8,0x320}, {0x0c8,0x0c8,0x320}, {0x190,0x0c8,0x320}, {0x258,0x0c8,0x320}, {0x320,0x0c8,0x320}, {0x3e8,0x0c8,0x320}, + {0x000,0x190,0x320}, {0x0c8,0x190,0x320}, {0x190,0x190,0x320}, {0x258,0x190,0x320}, {0x320,0x190,0x320}, {0x3e8,0x190,0x320}, + {0x000,0x258,0x320}, {0x0c8,0x258,0x320}, {0x190,0x258,0x320}, {0x258,0x258,0x320}, {0x320,0x258,0x320}, {0x3e8,0x258,0x320}, + {0x000,0x320,0x320}, {0x0c8,0x320,0x320}, {0x190,0x320,0x320}, {0x258,0x320,0x320}, {0x320,0x320,0x320}, {0x3e8,0x320,0x320}, + {0x000,0x3e8,0x320}, {0x0c8,0x3e8,0x320}, {0x190,0x3e8,0x320}, {0x258,0x3e8,0x320}, {0x320,0x3e8,0x320}, {0x3e8,0x3e8,0x320}, + {0x000,0x000,0x3e8}, {0x0c8,0x000,0x3e8}, {0x190,0x000,0x3e8}, {0x258,0x000,0x3e8}, {0x320,0x000,0x3e8}, {0x3e8,0x000,0x3e8}, + {0x000,0x0c8,0x3e8}, {0x0c8,0x0c8,0x3e8}, {0x190,0x0c8,0x3e8}, {0x258,0x0c8,0x3e8}, {0x320,0x0c8,0x3e8}, {0x3e8,0x0c8,0x3e8}, + {0x000,0x190,0x3e8}, {0x0c8,0x190,0x3e8}, {0x190,0x190,0x3e8}, {0x258,0x190,0x3e8}, {0x320,0x190,0x3e8}, {0x3e8,0x190,0x3e8}, + {0x000,0x258,0x3e8}, {0x0c8,0x258,0x3e8}, {0x190,0x258,0x3e8}, {0x258,0x258,0x3e8}, {0x320,0x258,0x3e8}, {0x3e8,0x258,0x3e8}, + {0x000,0x320,0x3e8}, {0x0c8,0x320,0x3e8}, {0x190,0x320,0x3e8}, {0x258,0x320,0x3e8}, {0x320,0x320,0x3e8}, {0x3e8,0x320,0x3e8}, + {0x000,0x3e8,0x3e8}, {0x0c8,0x3e8,0x3e8}, {0x190,0x3e8,0x3e8}, {0x258,0x3e8,0x3e8}, {0x320,0x3e8,0x3e8}, {0x3e8,0x3e8,0x3e8} +}; +#endif + +/* Error code translations: */ +static const char * plot_error_codes[] = { + "None", + "ERR_BUFFERSIZE_EXCEEDS_SCREEN", + "ERR_NO_MEM", + "ERR_PLOTTER_NOT_AVAILABLE" +}; + +FONT_PLOTTER fplotter = NULL; + +extern short vdih; + +/* temp buffer for bitmap conversion: */ +static void * buf_packed; +static int size_buf_packed; + +/* temp buffer for bitmap conversion: */ +void * buf_planar; +int size_buf_planar; + +/* buffer for plot operations that require device format, */ +/* currently used for transparent mfdb blits and snapshots: */ +static MFDB buf_scr; +static int size_buf_scr; + +/* buffer for std form, used during 8bpp snapshot */ +MFDB buf_std; +int size_buf_std; + +struct bitmap * buf_scr_compat; + +/* intermediate bitmap format */ +static HermesFormat vfmt; + +/* no screen format here, hermes may not suitable for it */ + +/* netsurf source bitmap format */ +static HermesFormat nsfmt; + +static struct s_vdi_sysinfo vdi_sysinfo; +/* bit depth of framebuffers: */ +static int atari_plot_bpp_virt; +static struct s_view view; + +static HermesHandle hermes_pal_h; /* hermes palette handle */ +static HermesHandle hermes_cnv_h; /* hermes converter instance handle */ +static HermesHandle hermes_res_h; + +static short prev_vdi_clip[4]; +static struct bitmap snapshot; + +int atari_plot_vdi_handle; +unsigned long atari_plot_flags; +unsigned long atari_font_flags; + +typedef bool (*bitmap_convert_fnc)( struct bitmap * img, int x, int y, + GRECT * clip, uint32_t bg, uint32_t flags, MFDB *out ); +static bitmap_convert_fnc bitmap_convert; + +const char* plot_err_str(int i) +{ + return(plot_error_codes[abs(i)]); +} + + +static inline void vsl_rgbcolor(short vdih, uint32_t cin) +{ + #ifdef WITH_8BPP_SUPPORT + if( vdi_sysinfo.scr_bpp > 8 ) { + #endif + unsigned short c[4]; + rgb_to_vdi1000( (unsigned char*)&cin, (unsigned short*)&c); + vs_color(vdih, OFFSET_CUSTOM_COLOR, (unsigned short*)&c[0]); + vsl_color(vdih, OFFSET_CUSTOM_COLOR); + #ifdef WITH_8BPP_SUPPORT + } else { + if( vdi_sysinfo.scr_bpp >= 4 ){ + vsl_color(vdih, RGB_TO_VDI(cin)); + } + else + vsl_color(vdih, BLACK); + } + #endif +} + +static inline void vsf_rgbcolor(short vdih, uint32_t cin) +{ + #ifdef WITH_8BPP_SUPPORT + if( vdi_sysinfo.scr_bpp > 8 ) { + #endif + unsigned short c[4]; + rgb_to_vdi1000( (unsigned char*)&cin, (unsigned short*)&c ); + vs_color( vdih, OFFSET_CUSTOM_COLOR, &c[0] ); + vsf_color( vdih, OFFSET_CUSTOM_COLOR ); + #ifdef WITH_8BPP_SUPPORT + } else { + if( vdi_sysinfo.scr_bpp >= 4 ){ + vsf_color( vdih, RGB_TO_VDI(cin) ); + } + else + vsf_color( vdih, WHITE ); + } + #endif +} + + + +/* + Get current visible coords +*/ +static inline void plotter_get_visible_grect(GRECT * out) +{ + out->g_x = view.vis_x; + out->g_y = view.vis_y; + out->g_w = view.vis_w; + out->g_h = view.vis_h; +} + + + +/* calculate visible area of framebuffer in coords relative to framebuffer */ +/* position */ +/* result: */ +/* this function should calculates an rectangle relative to the plot origin*/ +/* and size. */ +/* If the ploter coords do not fall within the screen region, */ +/* all values of the region are set to zero. */ +static inline void update_visible_rect(void) +{ + GRECT screen; + GRECT common; + GRECT frame; + + screen.g_x = 0; + screen.g_y = 0; + screen.g_w = vdi_sysinfo.scr_w; + screen.g_h = vdi_sysinfo.scr_h; + + common.g_x = frame.g_x = view.x; + common.g_y = frame.g_y = view.y; + common.g_w = frame.g_w = view.w; + common.g_h = frame.g_h = view.h; + + if( rc_intersect( &screen, &common ) ) { + view.vis_w = common.g_w; + view.vis_h = common.g_h; + if( view.x < screen.g_x ) + view.vis_x = frame.g_w - common.g_w; + else + view.vis_x = 0; + if( view.y vdi_handle = vdih; + if ( tos_getcookie(C_EdDI, &cookie_EdDI) == C_NOTFOUND ) { + info->EdDiVersion = 0; + } else { + info->EdDiVersion = EdDI_version( (void *)cookie_EdDI ); + } + + memset( &out, 0, sizeof(short)*300 ); + vq_extnd( vdih, 0, (short*)&out ); + info->scr_w = out[0]+1; + info->scr_h = out[1]+1; + if( out[39] == 2 ) { + info->scr_bpp = 1; + info->colors = out[39]; + } else { + info->colors = out[39]; + } + + memset( &out, 0, sizeof(short)*300 ); + vq_extnd( vdih, 1, (short*)&out ); + info->scr_bpp = out[4]; + info->maxpolycoords = out[14]; + info->maxintin = out[15]; + if( out[30] & 1 ) { + info->rasterscale = true; + } else { + info->rasterscale = false; + } + + switch( info->scr_bpp ) { + case 8: + info->pixelsize=1; + break; + case 15: + case 16: + info->pixelsize=2; + break; + case 24: + info->pixelsize=3; + break; + case 32: + info->pixelsize=4; + break; + case 64: + info->pixelsize=8; + break; + default: + info->pixelsize=1; + break; + + } + info->pitch = info->scr_w * info->pixelsize; + info->vdiformat = ( (info->scr_bpp <= 8) ? VDI_FORMAT_INTER : VDI_FORMAT_PACK); + info->screensize = ( info->scr_w * info->pixelsize ) * info->scr_h; + + if( info->EdDiVersion >= EDDI_10 ) { + memset( &out, 0, sizeof(short)*300 ); + vq_scrninfo(vdih, (short*)&out); + info->vdiformat = out[0]; + info->clut = out[1]; + info->scr_bpp = out[2]; + info->hicolors = *((unsigned long*) &out[3]); + if( info->EdDiVersion >= EDDI_11 ) { + info->pitch = out[5]; + info->screen = (void *) *((unsigned long *) &out[6]); + } + + switch( info->clut ) { + + case VDI_CLUT_HARDWARE: { + + } + break; + + case VDI_CLUT_SOFTWARE: { + int component; /* red, green, blue, alpha, overlay */ + int num_bit; + unsigned short *tmp_p; + + /* We can build masks with info here */ + tmp_p = (unsigned short *) &out[16]; + for (component=0; component<5; component++) { + for (num_bit=0; num_bit<16; num_bit++) { + unsigned short val; + + val = *tmp_p++; + + if (val == 0xffff) { + continue; + } + + switch(component) { + case 0: + info->mask_r |= 1<< val; + break; + case 1: + info->mask_g |= 1<< val; + break; + case 2: + info->mask_b |= 1<< val; + break; + case 3: + info->mask_a |= 1<< val; + break; + } + } + } + } + + /* Remove lower green bits for Intel endian screen */ + if ((info->mask_g == ((7<<13)|3)) || (info->mask_g == ((7<<13)|7))) { + info->mask_g &= ~(7<<13); + } + break; + + case VDI_CLUT_NONE: + break; + } + } +} + + +/* + Convert an RGB color to an VDI Color +*/ +void rgb_to_vdi1000(unsigned char * in, unsigned short * out) +{ + double r = ((double)in[3]/255); /* prozentsatz red */ + double g = ((double)in[2]/255); /* prozentsatz green */ + double b = ((double)in[1]/255); /* prozentsatz blue */ + out[0] = 1000 * r + 0.5; + out[1] = 1000 * g + 0.5; + out[2] = 1000 * b + 0.5; + return; +} + +void vdi1000_to_rgb(unsigned short * in, unsigned char * out) +{ + double r = ((double)in[0]/1000); /* prozentsatz red */ + double g = ((double)in[1]/1000); /* prozentsatz green */ + double b = ((double)in[2]/1000); /* prozentsatz blue */ + out[2] = 255 * r + 0.5; + out[1] = 255 * g + 0.5; + out[0] = 255 * b + 0.5; + return; +} + + +#ifdef WITH_8BPP_SUPPORT + +static inline void set_stdpx( MFDB * dst, int wdplanesz, int x, int y, unsigned char val ) +{ + short * buf; + short whichbit = (1<<(15-(x%16))); + + buf = dst->fd_addr; + buf += ((dst->fd_wdwidth*(y))+(x>>4)); + + *buf = (val&1) ? ((*buf)|(whichbit)) : ((*buf)&~(whichbit)); + + buf += wdplanesz; + *buf = (val&(1<<1)) ? ((*buf)|(whichbit)) : ((*buf)&~(whichbit)); + + buf += wdplanesz; + *buf = (val&(1<<2)) ? ((*buf)|(whichbit)) : ((*buf)&~(whichbit)); + + buf += wdplanesz; + *buf = (val&(1<<3)) ? ((*buf)|(whichbit)) : ((*buf)&~(whichbit)); + + buf += wdplanesz; + *buf = (val&(1<<4)) ? ((*buf)|(whichbit)) : ((*buf)&~(whichbit)); + + buf += wdplanesz; + *buf = (val&(1<<5)) ? ((*buf)|(whichbit)) : ((*buf)&~(whichbit)); + + buf += wdplanesz; + *buf = (val&(1<<6)) ? ((*buf)|(whichbit)) : ((*buf)&~(whichbit)); + + buf += wdplanesz; + *buf = (val&(1<<7)) ? ((*buf)|(whichbit)) : ((*buf)&~(whichbit)); +} + +static inline unsigned char get_stdpx(MFDB * dst, int wdplanesz, int x, int y) +{ + unsigned char ret=0; + short * buf; + short whichbit = (1<<(15-(x%16))); + + buf = dst->fd_addr; + buf += ((dst->fd_wdwidth*(y))+(x>>4)); + + if( *buf & whichbit ) + ret |= 1; + + buf += wdplanesz; + if( *buf & whichbit ) + ret |= 2; + + buf += wdplanesz; + if( *buf & whichbit ) + ret |= 4; + + buf += wdplanesz; + if( *buf & whichbit ) + ret |= 8; + + buf += wdplanesz; + if( *buf & whichbit ) + ret |= 16; + + buf += wdplanesz; + if( *buf & whichbit ) + ret |= 32; + + buf += wdplanesz; + if( *buf & whichbit ) + ret |= 64; + + buf += wdplanesz; + if( *buf & whichbit ) + ret |= 128; + + return( ret ); +} + +/* + Convert an RGB color into an index into the 216 colors web pallette +*/ +short rgb_to_666_index(unsigned char r, unsigned char g, unsigned char b) +{ + short ret = 0; + short i; + unsigned char rgb[3] = {r,g,b}; + unsigned char tval[3]; + + int diff_a, diff_b, diff_c; + diff_a = abs(r-g); + diff_b = abs(r-b); + diff_c = abs(r-b); + if( diff_a < 2 && diff_b < 2 && diff_c < 2 ) { + if( (r!=0XFF) && (g!=0XFF) && (g!=0XFF) ) { + if( ((r&0xF0)>>4) != 0 ) + //printf("conv gray: %x -> %d\n", ((r&0xF0)>>4) , (OFFSET_CUST_PAL) + ((r&0xF0)>>4) ); + return( (OFFSET_CUST_PAL - OFFSET_WEB_PAL) + ((r&0xF0)>>4) ); + } + } + + /* convert each 8bit color to 6bit web color: */ + for( i=0; i<3; i++) { + if(0 == rgb[i] % web_std_colors[1] ) { + tval[i] = rgb[i] / web_std_colors[1]; + } else { + int pos = ((short)rgb[i] / web_std_colors[1]); + if( abs(rgb[i] - web_std_colors[pos]) > abs(rgb[i] - web_std_colors[pos+1]) ) + tval[i] = pos+1; + else + tval[i] = pos; + } + } + return(tval[2]*36+tval[1]*6+tval[0]); +} +#endif + + +static void dump_vdi_info( short vdih ) +{ + struct s_vdi_sysinfo temp; + read_vdi_sysinfo( vdih, &temp ); + printf("struct s_vdi_sysinfo {\n"); + printf(" short vdi_handle: %d\n", temp.vdi_handle); + printf(" short scr_w: %d \n", temp.scr_w); + printf(" short scr_h: %d\n", temp.scr_h); + printf(" short scr_bpp: %d\n", temp.scr_bpp); + printf(" int colors: %d\n", temp.colors); + printf(" ulong hicolors: %d\n", temp.hicolors); + printf(" short pixelsize: %d\n", temp.pixelsize); + printf(" unsigned short pitch: %d\n", temp.pitch); + printf(" unsigned short vdiformat: %d\n", temp.vdiformat); + printf(" unsigned short clut: %d\n", temp.clut); + printf(" void * screen: 0x0%p\n", temp.screen); + printf(" unsigned long screensize: %d\n", temp.screensize); + printf(" unsigned long mask_r: 0x0%08x\n", temp.mask_r); + printf(" unsigned long mask_g: 0x0%08x\n", temp.mask_g); + printf(" unsigned long mask_b: 0x0%08x\n", temp.mask_b); + printf(" unsigned long mask_a: 0x0%08x\n", temp.mask_a); + printf(" short maxintin: %d\n", temp.maxintin); + printf(" short maxpolycoords: %d\n", temp.maxpolycoords); + printf(" unsigned long EdDiVersion: 0x0%03x\n", temp.EdDiVersion); + printf(" unsigned short rasterscale: 0x%2x\n", temp.rasterscale); + printf("};\n"); +} + +bool plot_resize_bitmap(struct bitmap * img, int nw, int nh) +{ + HermesFormat fmt; + short bpp = bitmap_get_bpp( img ); + int stride = bitmap_get_rowstride( img ); + int err; + + if( img->resized != NULL ) { + if( img->resized->width != nw || img->resized->height != nh ) { + bitmap_destroy( img->resized ); + img->resized = NULL; + } else { + /* the bitmap is already resized */ + return( 0 ); + } + } + + /* allocate the mem for resized bitmap */ + img->resized = bitmap_create_ex( nw, nh, bpp, nw*bpp, 0, NULL ); + if( img->resized == NULL ) { + printf("W: %d, H: %d, bpp: %d\n", nw, nh, bpp); + assert( img->resized ); + return ( -ERR_NO_MEM ); + } + + /* allocate an converter, only for resizing */ + err = Hermes_ConverterRequest( hermes_res_h, + &nsfmt, + &nsfmt + ); + if( err == 0 ) { + return( -ERR_PLOTTER_NOT_AVAILABLE ); + } + + err = Hermes_ConverterCopy( hermes_res_h, + img->pixdata, + 0, /* x src coord of top left in pixel coords */ + 0, /* y src coord of top left in pixel coords */ + bitmap_get_width( img ), bitmap_get_height( img ), + stride, /* stride as bytes */ + img->resized->pixdata, + 0, /* x dst coord of top left in pixel coords */ + 0, /* y dst coord of top left in pixel coords */ + nw, nh, + bitmap_get_rowstride(img->resized) /* stride as bytes */ + ); + if( err == 0 ) { + bitmap_destroy( img->resized ); + img->resized = NULL; + return( -2 ); + } + + return( 0 ); +} + +// create snapshot, native screen format +static MFDB * snapshot_create_native_mfdb(int x, int y, int w, int h) +{ + MFDB scr; + short pxy[8]; + + /* allocate memory for the snapshot */ + { + int scr_stride = MFDB_STRIDE( w ); + int scr_size = ( ((scr_stride >> 3) * h) * vdi_sysinfo.scr_bpp ); + if(size_buf_scr == 0 ){ + /* init screen mfdb */ + buf_scr.fd_addr = malloc( scr_size ); + size_buf_scr = scr_size; + } else { + if( scr_size >size_buf_scr ) { + buf_scr.fd_addr = realloc( + buf_scr.fd_addr, scr_size + ); + size_buf_scr = scr_size; + } + } + if(buf_scr.fd_addr == NULL ) { + size_buf_scr = 0; + return( NULL ); + } + buf_scr.fd_nplanes = vdi_sysinfo.scr_bpp; + buf_scr.fd_w = scr_stride; + buf_scr.fd_h = h; + buf_scr.fd_wdwidth = scr_stride >> 4; + assert(buf_scr.fd_addr != NULL ); + } + init_mfdb( 0, w, h, 0, &scr ); + pxy[0] = x; + pxy[1] = y; + pxy[2] = pxy[0] + w-1; + pxy[3] = pxy[1] + h-1; + pxy[4] = 0; + pxy[5] = 0; + pxy[6] = w-1; + pxy[7] = h-1; + vro_cpyfm( + atari_plot_vdi_handle, S_ONLY, (short*)&pxy, + &scr, &buf_scr + ); + + return( &buf_scr ); +} + +// create snapshot, vdi std. format +static MFDB * snapshot_create_std_mfdb(int x, int y, int w, int h) +{ + /* allocate memory for the snapshot */ + { + int scr_stride = MFDB_STRIDE( w ); + int scr_size = ( ((scr_stride >> 3) * h) * app.nplanes ); + if(size_buf_std == 0 ){ + /* init screen mfdb */ + buf_std.fd_addr = malloc( scr_size ); + size_buf_std = scr_size; + } else { + if( scr_size >size_buf_std ) { + buf_std.fd_addr = realloc( + buf_std.fd_addr, scr_size + ); + size_buf_std = scr_size; + } + } + if(buf_std.fd_addr == NULL ) { + size_buf_std = 0; + return( NULL ); + } + buf_std.fd_nplanes = app.nplanes; + buf_std.fd_w = scr_stride; + buf_std.fd_h = h; + buf_std.fd_stand = 1; + buf_std.fd_wdwidth = scr_stride >> 4; + assert(buf_std.fd_addr != NULL ); + } + MFDB * native = snapshot_create_native_mfdb(x,y,w,h ); + assert( native ); + + vr_trnfm(atari_plot_vdi_handle, native, &buf_std ); + return( &buf_std ); +} + +/* + This will create an snapshot of the screen in netsurf ABGR format +*/ + +static struct bitmap * snapshot_create(int x, int y, int w, int h) +{ + int err; + MFDB * native; + // uint32_t start = clock(); + + // FIXME: This can be optimized a lot. + // 1. do not copy the snapshot to the bitmap buffer + // when the format of screen and bitmap equals. + // just point the bitmap to the native mfdb. + // 2. if we have eddi 1.1, we could optimize that further + // make snapshot_create_native_mfdb just returning a pointer + // to the screen. + + native = snapshot_create_native_mfdb(x, y, w, h ); + + if(vfmt.bits == 32 ) + goto no_copy; + + /* allocate buffer for result bitmap: */ + if(buf_scr_compat == NULL ) { + buf_scr_compat = bitmap_create(w, h, 0); + } else { + buf_scr_compat = bitmap_realloc( w, h, + buf_scr_compat->bpp, + w *buf_scr_compat->bpp, + BITMAP_GROW, + buf_scr_compat ); + } + + /* convert screen buffer to ns format: */ + err = Hermes_ConverterRequest( hermes_cnv_h, + &vfmt, + &nsfmt + ); + assert( err != 0 ); + err = Hermes_ConverterCopy( hermes_cnv_h, + native->fd_addr, + 0, /* x src coord of top left in pixel coords */ + 0, /* y src coord of top left in pixel coords */ + w, h, + native->fd_w * vdi_sysinfo.pixelsize, /* stride as bytes */ + buf_scr_compat->pixdata, + 0, /* x dst coord of top left in pixel coords */ + 0, /* y dst coord of top left in pixel coords */ + w, h, + bitmap_get_rowstride(buf_scr_compat) /* stride as bytes */ + ); + assert( err != 0 ); + return( (struct bitmap * )buf_scr_compat ); + +no_copy: + + snapshot.width = w; + snapshot.height = h; + snapshot.pixdata = native->fd_addr; + snapshot.native = *native; + snapshot.rowstride = MFDB_STRIDE( w )*4; + + uint32_t row, col; + for (row = 0; row<(uint32_t)h; row++) { + // fd_w matches stride! + uint32_t *rowptr = ((uint32_t*)native->fd_addr + ((row*native->fd_w))); + for (col=0; col<(uint32_t)w; col++) { + *(rowptr+col) = (*(rowptr+col)<<8); + } + } + return( &snapshot ); +} + +static void snapshot_suspend(void) +{ + if(size_buf_scr > CONV_KEEP_LIMIT ) { + buf_scr.fd_addr = realloc( + buf_scr.fd_addr, CONV_KEEP_LIMIT + ); + if(buf_scr.fd_addr != NULL ) { + size_buf_scr = CONV_KEEP_LIMIT; + } else { + size_buf_scr = 0; + } + } + + if(size_buf_std > CONV_KEEP_LIMIT ) { + buf_std.fd_addr = realloc( + buf_std.fd_addr, CONV_KEEP_LIMIT + ); + if(buf_std.fd_addr != NULL ) { + size_buf_std = CONV_KEEP_LIMIT; + } else { + size_buf_std = 0; + } + } + + if(buf_scr_compat != NULL ) { + size_t bs = bitmap_buffer_size(buf_scr_compat ); + if( bs > CONV_KEEP_LIMIT ) { + int w = 0; + int h = 1; + w = (CONV_KEEP_LIMIT /buf_scr_compat->bpp); + assert( CONV_KEEP_LIMIT == w*buf_scr_compat->bpp ); + buf_scr_compat = bitmap_realloc( w, h, + buf_scr_compat->bpp, + CONV_KEEP_LIMIT, BITMAP_SHRINK,buf_scr_compat + ); + } + } +} + +static void snapshot_destroy(void) +{ + + free(buf_scr.fd_addr); + if( buf_scr_compat != NULL) { + bitmap_destroy(buf_scr_compat); + } + + buf_scr.fd_addr = NULL; + buf_scr_compat = NULL; + +#ifdef WITH_8BPP_SUPPORT + free(buf_std.fd_addr); + buf_std.fd_addr = NULL; +#endif +} + + +static inline uint32_t ablend(uint32_t pixel, uint32_t scrpixel) +{ + int opacity = pixel & 0xFF; + int transp = 0x100 - opacity; + uint32_t rb, g; + pixel >>= 8; + scrpixel >>= 8; + rb = ((pixel & 0xFF00FF) * opacity + + (scrpixel & 0xFF00FF) * transp) >> 8; + g = ((pixel & 0x00FF00) * opacity + + (scrpixel & 0x00FF00) * transp) >> 8; + + return ((rb & 0xFF00FF) | (g & 0xFF00)) << 8; +} + +/* + Alpha blends an image, using one pixel as the background. + The bitmap receives the result. +*/ +static bool ablend_pixel( struct bitmap * img, uint32_t bg, GRECT * clip ) +{ + uint32_t * imgrow; + int img_x, img_y, img_stride; + + img_stride= bitmap_get_rowstride(img); + + for( img_y = 0; img_y < clip->g_h; img_y++) { + imgrow = (uint32_t *)(img->pixdata + (img_stride * img_y)); + for( img_x = 0; img_x < clip->g_w; img_x++ ) { + imgrow[img_x] = ablend( imgrow[img_x], bg ); + } + } + return(true); +} + + +/* + Aplha blends the foreground image (img) onto the + background images (bg). The background receives the blended + image pixels. +*/ +static bool ablend_bitmap( struct bitmap * img, struct bitmap * bg, + GRECT * img_clip, GRECT * bg_clip ) +{ + uint32_t * imgrow; + uint32_t * screenrow; + int img_x, img_y, bg_x, bg_y, img_stride, bg_stride; + + bg_clip = bg_clip; + img_stride= bitmap_get_rowstride(img); + bg_stride = bitmap_get_rowstride(bg); + + for( img_y = img_clip->g_y, bg_y = 0; bg_y < img_clip->g_h; bg_y++, img_y++) { + imgrow = (uint32_t *)(img->pixdata + (img_stride * img_y)); + screenrow = (uint32_t *)(bg->pixdata + (bg_stride * bg_y)); + for( img_x = img_clip->g_x, bg_x = 0; bg_x < img_clip->g_w; bg_x++, img_x++ ) { + + // when the pixel isn't fully transparent,...: + if( (imgrow[img_x] & 0x0FF) != 0 ){ + screenrow[bg_x] = ablend( imgrow[img_x], screenrow[bg_x]); + } + + // FIXME, maybe this loop would be faster??: + // --- + //if( (imgrow[img_x] & 0x0FF) != 0xFF ){ + // imgrow[bg_x] = ablend( imgrow[img_x], screenrow[bg_x]); + //} + + // or maybe even this??? + // --- + //if( (imgrow[img_x] & 0x0FF) == 0xFF ){ + // screenrow[bg_x] = imgrow[img_x]; + //} else if( (imgrow[img_x] & 0x0FF) != 0x00 ) { + // screenrow[bg_x] = ablend( imgrow[img_x], screenrow[bg_x]); + //} + } + } + return(false); +} + + +#ifdef WITH_8BPP_SUPPORT +static bool bitmap_convert_8(struct bitmap * img, int x, + int y, GRECT * clip, uint32_t bg, uint32_t flags, + MFDB *out ) +{ + MFDB native; + MFDB stdform; + int dststride; /* stride of dest. image */ + int dstsize; /* size of dest. in byte */ + int err; + int bw, bh; + int process_w, process_h; + struct bitmap * scrbuf = NULL; + struct bitmap * source; + bool cache = ( flags & BITMAPF_BUFFER_NATIVE ); + bool opaque = bitmap_get_opaque( img ); + + if( opaque == false ){ + if( ( (atari_plot_flags & PLOT_FLAG_TRANS) == 0) + && + ((flags & (BITMAPF_MONOGLYPH|BITMAPF_BUFFER_NATIVE))==0) ){ + opaque = true; + } + } + + assert( clip->g_h > 0 ); + assert( clip->g_w > 0 ); + + process_w = bw = bitmap_get_width( img ); + process_h = bh = bitmap_get_height( img ); + + // The converted bitmap can be saved for subsequent blits, when + // the bitmap is fully opaque + + if( (opaque == true) || (flags & BITMAPF_BUFFER_NATIVE ) ){ + if( img->converted == true ){ + *out = img->native; + return( 0 ); + } + if( ( flags & BITMAPF_MONOGLYPH ) == 0 ){ + cache = true; + } + } + if( ( flags & BITMAPF_MONOGLYPH ) != 0 ){ + assert(cache == false); + } + + /* (re)allocate buffer for out image: */ + /* altough the buffer is named "buf_packed" on 8bit systems */ + /* it's not... */ + if( cache == false ){ + // the size of the output will match the size of the clipping: + dststride = MFDB_STRIDE( clip->g_w ); + dstsize = ( ((dststride >> 3) * clip->g_h) * atari_plot_bpp_virt); + if( dstsize > size_buf_packed) { + int blocks = (dstsize / (CONV_BLOCK_SIZE-1))+1; + if( buf_packed == NULL ) + buf_packed =(void*)malloc( blocks * CONV_BLOCK_SIZE); + else + buf_packed =(void*)realloc(buf_packed,blocks * CONV_BLOCK_SIZE); + assert( buf_packed ); + if( buf_packed == NULL ) { + return( 0-ERR_NO_MEM ); + } + size_buf_packed = blocks * CONV_BLOCK_SIZE; + } + native.fd_addr = buf_packed; + } + else { + // the output image will be completly saved, so size of the output + // image will match the input image size. + dststride = MFDB_STRIDE( bw ); + dstsize = ( ((dststride >> 3) * bh) * atari_plot_bpp_virt); + assert( out->fd_addr == NULL ); + native.fd_addr = (void*)malloc( dstsize ); + if (native.fd_addr == NULL){ + if (scrbuf != NULL) + bitmap_destroy(scrbuf); + return( 0-ERR_NO_MEM ); + } + } + + + /* + on 8 bit systems we must convert the TC (ABGR) image + to vdi standard format. ( only tested for 256 colors ) + and then convert it to native format with v_trnfm() + */ + // realloc mem for stdform + if( opaque == false ){ + // point image to snapshot buffer, otherwise allocate mem + MFDB * bg = snapshot_create_std_mfdb(x, y, clip->g_w, clip->g_h); + stdform.fd_addr = bg->fd_addr; + bh = clip->g_h; + } else { + if( dstsize > size_buf_planar) { + int blocks = (dstsize / (CONV_BLOCK_SIZE-1))+1; + if( buf_planar == NULL ) + buf_planar =(void*)malloc( blocks * CONV_BLOCK_SIZE ); + else + buf_planar =(void*)realloc( + buf_planar, + blocks * CONV_BLOCK_SIZE + ); + assert( buf_planar ); + if( buf_planar == NULL ) { + return( 0-ERR_NO_MEM ); + } + size_buf_planar = blocks * CONV_BLOCK_SIZE; + } + stdform.fd_addr = buf_planar; + } + stdform.fd_w = dststride; + stdform.fd_h = bh; + stdform.fd_wdwidth = dststride >> 4; + stdform.fd_stand = 1; + stdform.fd_nplanes = (short)atari_plot_bpp_virt; + stdform.fd_r1 = stdform.fd_r2 = stdform.fd_r3 = 0; + + int img_stride = bitmap_get_rowstride(img); + uint32_t prev_pixel = 0x12345678; + unsigned long col = 0; + unsigned char val = 0; + uint32_t * row; + uint32_t pixel; + int wdplanesize = stdform.fd_wdwidth*stdform.fd_h; + + if( opaque == false ){ + // apply transparency and convert to vdi std format + unsigned long bgcol = 0; + unsigned char prev_col = 0; + for( y=0; yg_h; y++ ){ + row = (uint32_t *)(img->pixdata + (img_stride * (y+clip->g_y))); + for( x=0; xg_w; x++ ){ + pixel = row[x+clip->g_x]; + if( (pixel&0xFF) == 0 ){ + continue; + } + if( (pixel&0xFF) < 0xF0 ){ + col = get_stdpx( &stdform, wdplanesize,x,y ); + if( (col != prev_col) || (y == 0) ) + bgcol = (((rgb_lookup[col][2] << 16) | (rgb_lookup[col][1] << 8) | (rgb_lookup[col][0]))<<8); + if( prev_col != col || prev_pixel != pixel ){ + prev_col = col; + pixel = ablend( pixel, bgcol ); + prev_pixel = pixel; + pixel = pixel >> 8; + /* convert pixel value to vdi color index: */ + col = ( ((pixel&0xFF)<<16) + | (pixel&0xFF00) + | ((pixel&0xFF0000)>>16) ); + val = RGB_TO_VDI( col ); + } + set_stdpx( &stdform, wdplanesize, x, y, val ); + } else { + if( pixel != prev_pixel ){ + /* convert pixel value to vdi color index: */ + pixel = pixel >> 8; + col = ( ((pixel&0xFF)<<16) + | (pixel&0xFF00) + | ((pixel&0xFF0000)>>16) ); + val = RGB_TO_VDI( col ); + prev_pixel = pixel; + } + set_stdpx( &stdform, wdplanesize, x, y, val ); + } + } + } + // adjust output position: + clip->g_x = 0; + clip->g_y = 0; + } else { + // convert the whole image data to vdi std format. + for( y=0; y < bh; y++ ){ + row = (uint32_t *)(img->pixdata + (img_stride * y)); + for( x=0; x < bw; x++ ){ + pixel = row[x]; + if( pixel != prev_pixel ){ + /* convert pixel value to vdi color index: */ + pixel = pixel >> 8; + col = ( ((pixel&0xFF)<<16) + | (pixel&0xFF00) + | ((pixel&0xFF0000)>>16) ); + val = RGB_TO_VDI( col ); + prev_pixel = pixel; + } + set_stdpx( &stdform, wdplanesize, x, y, val ); + } + } + } + + // convert into native format: + native.fd_w = stdform.fd_w; + native.fd_h = stdform.fd_h; + native.fd_wdwidth = stdform.fd_wdwidth; + native.fd_stand = 0; + native.fd_nplanes = (short)atari_plot_bpp_virt; + native.fd_r1 = native.fd_r2 = native.fd_r3 = 0; + vr_trnfm(atari_plot_vdi_handle, &stdform, &native ); + *out = native; + if( cache == true ){ + img->native = native; + img->converted = true; + } + + return(0); +} +#endif + + +/* +* +* Convert bitmap to the native screen format +* img: the bitmap +* x: coordinate where the bitmap REGION (described in clip) +* shall be drawn (screen coords) +* y: coordinate where the bitmap REGION (described in clip) +* shall be drawn (screen coords) +* clip: which area of the bitmap shall be drawn +* bg: background color +* flags: blit flags +* out: the result MFDB +*/ +static bool bitmap_convert_tc(struct bitmap * img, int x, int y, + GRECT * clip, uint32_t bg, uint32_t flags, MFDB *out ) +{ + int dststride; /* stride of dest. image */ + int dstsize; /* size of dest. in byte */ + int err; + int bw, bh; + struct bitmap * scrbuf = NULL; + struct bitmap * source = NULL; + bool cache = ( flags & BITMAPF_BUFFER_NATIVE ); + bool opaque = bitmap_get_opaque( img ); + + if( opaque == false ){ + if( ( (atari_plot_flags & PLOT_FLAG_TRANS) == 0) + && + ((flags & (BITMAPF_MONOGLYPH|BITMAPF_BUFFER_NATIVE))==0) ){ + opaque = true; + } + } + + + assert( clip->g_h > 0 ); + assert( clip->g_w > 0 ); + + bw = bitmap_get_width( img ); + bh = bitmap_get_height( img ); + + // The converted bitmap can be saved for subsequent blits, WHEN: + // A.) the bitmap is fully opaque OR + // B.) the bitmap is completly inside the window + // the latter one is important for alpha blits, + // because we must get the window background to apply transparency + // If the image is not completly within the window, + // we can't get the whole background for the image. + // this only works if the image isn't used at several different places. + // In fact in case of alpha bitmap caching it is only used for the + // toolbar buttons right now. + + if( (opaque == true) || (flags & BITMAPF_BUFFER_NATIVE ) ){ + if( img->converted == true ){ + *out = img->native; + return( 0 ); + } + if( ( flags & BITMAPF_MONOGLYPH ) == 0 ){ + cache = true; + } + } + + /* rem. if eddi xy is installed, we could directly access the screen! */ + /* apply transparency to the image: */ + if (( opaque == false )) { + /* copy the screen to an temp buffer: */ + if ((flags & BITMAPF_BUFFER_NATIVE) == 0) { + scrbuf = snapshot_create(x, y, clip->g_w, clip->g_h); + if( scrbuf != NULL ) { + + assert( clip->g_w <= bw ); + assert( clip->g_h <= bh ); + + // copy blended pixels to the screen buffer: + ablend_bitmap( img, scrbuf, clip, NULL ); + /* adjust size which gets converted: */ + bw = clip->g_w; + bh = clip->g_h; + /* adjust output position: */ + clip->g_x = 0; + clip->g_y = 0; + /* set the source of conversion: */ + source = scrbuf; + } + } else { + /* + The whole bitmap can be transformed to an mfdb + (and get's cached) + */ + GRECT region = { 0, 0, bw, bh }; + ablend_pixel( img, bg, ®ion ); + source = img; + } + } else { + source = img; + } + /* (re)allocate buffer for converted image: */ + dststride = MFDB_STRIDE(bw); + dstsize = ( ((dststride >> 3) * bh) * atari_plot_bpp_virt ); + if (cache == false) { + if (dstsize > size_buf_packed) { + int blocks = (dstsize / (CONV_BLOCK_SIZE-1))+1; + if( buf_packed == NULL ) + buf_packed =(void*)malloc( blocks * CONV_BLOCK_SIZE ); + else + buf_packed =(void*)realloc(buf_packed, + blocks * CONV_BLOCK_SIZE); + assert( buf_packed ); + if( buf_packed == NULL ) { + if( scrbuf != NULL ) + bitmap_destroy( scrbuf ); + return( 0-ERR_NO_MEM ); + } + size_buf_packed = blocks * CONV_BLOCK_SIZE; + } + out->fd_addr = buf_packed; + } else { + assert( out->fd_addr == NULL ); + out->fd_addr = (void*)malloc( dstsize ); + if( out->fd_addr == NULL ){ + if( scrbuf != NULL ) + bitmap_destroy( scrbuf ); + return( 0-ERR_NO_MEM ); + } + } + + out->fd_w = dststride; + out->fd_h = bh; + out->fd_wdwidth = dststride >> 4; + out->fd_stand = 0; + out->fd_nplanes = (short)atari_plot_bpp_virt; + out->fd_r1 = out->fd_r2 = out->fd_r3 = 0; + + err = Hermes_ConverterRequest( + hermes_cnv_h, + &nsfmt, + &vfmt + ); + assert( err != 0 ); + + // FIXME: here we can use the same optimization which is used for + // the snapshot creation. + + /* convert image to virtual format: */ + err = Hermes_ConverterCopy( hermes_cnv_h, + source->pixdata, + 0, /* x src coord of top left in pixel coords */ + 0, /* y src coord of top left in pixel coords */ + bw, bh, + source->rowstride, /* stride as bytes */ + out->fd_addr, + 0, /* x dst coord of top left in pixel coords */ + 0, /* y dst coord of top left in pixel coords */ + bw, bh, + (dststride >> 3) * atari_plot_bpp_virt /* stride as bytes */ + ); + assert( err != 0 ); + + if( cache == true ){ + img->native = *out; + img->converted = true; + } + return( 0 ); + +} + +static void convert_bitmap_done(void) +{ + if (size_buf_packed > CONV_KEEP_LIMIT) { + /* free the mem if it was an large allocation ... */ + buf_packed = realloc(buf_packed, CONV_KEEP_LIMIT); + size_buf_packed = CONV_KEEP_LIMIT; + } + snapshot_suspend(); +} + + +bool plot_blit_bitmap(struct bitmap * bmp, int x, int y, + unsigned long bg, unsigned long flags ) +{ + MFDB src_mf; + MFDB scrmf; + short pxy[8]; + GRECT off, clip, vis; + int screen_x, screen_y; + + src_mf.fd_addr = NULL; + scrmf.fd_addr = NULL; + + off.g_x = x; + off.g_y = y; + off.g_h = bmp->height; + off.g_w = bmp->width; + + // clip plotter clip rectangle: + clip.g_x = view.clipping.x0; + clip.g_y = view.clipping.y0; + clip.g_w = view.clipping.x1 - view.clipping.x0; + clip.g_h = view.clipping.y1 - view.clipping.y0; + + if( !rc_intersect( &clip, &off) ) { + return(true); + } + + // clip the visible rectangle of the plot area + // this is the area of the plotter which falls into + // screen region: + plotter_get_visible_grect(&vis); + if( !rc_intersect( &vis, &off) ) { + return(true); + } + + screen_x = view.x + off.g_x; + screen_y = view.y + off.g_y; + + // convert the clipping relative to bitmap: + off.g_x = off.g_x - x; + off.g_y = off.g_y - y; + assert( (off.g_x >= 0) && (off.g_y >= 0) ); + + /* Convert the Bitmap to native screen format - ready for output. */ + /* This includes blending transparent pixels: */ + if (bitmap_convert(bmp, screen_x, screen_y, &off, bg, flags, &src_mf) + != 0 ) { + return(true); + } + + // setup the src region: + pxy[0] = off.g_x; + pxy[1] = off.g_y; + pxy[2] = off.g_x + off.g_w-1; + pxy[3] = off.g_y + off.g_h-1; + + // setup the target region: + pxy[4] = screen_x; + pxy[5] = screen_y; + pxy[6] = screen_x + off.g_w-1; + pxy[7] = screen_y + off.g_h-1; + + vro_cpyfm(atari_plot_vdi_handle, S_ONLY, (short*)&pxy, &src_mf, &scrmf); + convert_bitmap_done(); + return(true); +} + +bool plot_blit_mfdb(GRECT * loc, MFDB * insrc, unsigned char fgcolor, + uint32_t flags) +{ + + MFDB screen, tran; + MFDB * src; + short pxy[8]; + short c[2] = {fgcolor, WHITE}; + GRECT off; + + plotter_get_clip_grect(&off); + if( rc_intersect(loc, &off) == 0 ){ + return( 1 ); + } + + init_mfdb( 0, loc->g_w, loc->g_h, 0, &screen ); + + if( insrc->fd_stand ){ + int size = init_mfdb( insrc->fd_nplanes, loc->g_w, loc->g_h, + MFDB_FLAG_NOALLOC, + &tran + ); + if( size_buf_scr == 0 ){ + buf_scr.fd_addr = malloc( size ); + size_buf_scr = size; + } else { + if( size > size_buf_scr ) { + buf_scr.fd_addr = realloc( + buf_scr.fd_addr, size + ); + size_buf_scr = size; + } + } + tran.fd_addr = buf_scr.fd_addr; + vr_trnfm(atari_plot_vdi_handle, insrc, &tran ); + src = &tran; + } else { + src = insrc; + } + + pxy[0] = off.g_x - loc->g_x; + pxy[1] = off.g_y - loc->g_y; + pxy[2] = pxy[0] + off.g_w - 1; + pxy[3] = pxy[1] + off.g_h - 1; + pxy[4] = view.x + off.g_x; + pxy[5] = view.y + off.g_y; + pxy[6] = pxy[4] + off.g_w-1; + pxy[7] = pxy[5] + off.g_h-1; + + + if( flags & PLOT_FLAG_TRANS && src->fd_nplanes == 1){ + vrt_cpyfm(atari_plot_vdi_handle, MD_TRANS, (short*)pxy, src, &screen, (short*)&c ); + } else { + /* this method only plots transparent bitmaps, right now... */ + } + return( 1 ); +} + +/* +Init screen and font driver objects. +Returns non-zero value > -1 when the objects could be succesfully created. +Returns value < 0 to indicate an error +*/ + +int atari_plotter_init(char * fdrvrname) +{ + + GRECT loc_pos= {0,0,360,400}; + int err=0,i; + + if( nsoption_int(atari_dither) == 1) + atari_plot_flags |= PLOT_FLAG_DITHER; + if( nsoption_int(atari_transparency) == 1 ) + atari_plot_flags |= PLOT_FLAG_TRANS; + if( nsoption_int(atari_font_monochrom) == 1 ) + atari_font_flags |= FONTPLOT_FLAG_MONOGLYPH; + + atari_plot_vdi_handle = app.graf.handle; + read_vdi_sysinfo(atari_plot_vdi_handle, &vdi_sysinfo); + if( verbose_log ) { + dump_vdi_info( atari_plot_vdi_handle ) ; + dump_font_drivers(); + } + + fplotter = new_font_plotter(atari_plot_vdi_handle, fdrvrname, + atari_font_flags, &err); + if(err) { + const char * desc = plot_err_str(err); + die(("Unable to load font plotter %s -> %s", fdrvrname, desc )); + } + + memset(&view, 0, sizeof(struct s_view)); + atari_plot_bpp_virt = app.nplanes; + view.x = loc_pos.g_x; + view.y = loc_pos.g_y; + view.w = loc_pos.g_w; + view.h = loc_pos.g_h; + size_buf_packed = 0; + size_buf_planar = 0; + buf_packed = NULL; + buf_planar = NULL; + if( vdi_sysinfo.vdiformat == VDI_FORMAT_PACK ) { + atari_plot_bpp_virt = vdi_sysinfo.scr_bpp; + } else { + atari_plot_bpp_virt = 8; + } + + update_visible_rect(); + + struct rect clip; + clip.x0 = 0; + clip.y0 = 0; + clip.x1 = view.w; + clip.y1 = view.h; + plot_clip(&clip); + + assert(Hermes_Init()); + +#ifdef WITH_8BPP_SUPPORT + bitmap_convert = (app.nplanes > 8) ? bitmap_convert_tc : bitmap_convert_8; + + /* Setup color lookup tables and palette */ + i = 0; + unsigned char * col; + unsigned char rgbcol[4]; + unsigned char graytone=0; + if( app.nplanes <= 8 ){ + for( i=0; i<=255; i++ ) { + + // get the current color and save it for restore: + vq_color(atari_plot_vdi_handle, i, 1, (unsigned short*)&sys_pal[i][0] ); + if( i= 8 ) { + if ( i < OFFSET_CUST_PAL ){ + pal[i][0] = vdi_web_pal[i-OFFSET_WEB_PAL][0]; + pal[i][1] = vdi_web_pal[i-OFFSET_WEB_PAL][1]; + pal[i][2] = vdi_web_pal[i-OFFSET_WEB_PAL][2]; + //set the new palette color to websafe value: + vs_color(atari_plot_vdi_handle, i, &pal[i][0]); + } + if( i >= OFFSET_CUST_PAL && istroke_width; + uint32_t lt; + + /* current canvas clip: */ + rclip.g_x = view.clipping.x0; + rclip.g_y = view.clipping.y0; + rclip.g_w = view.clipping.x1 - view.clipping.x0; + rclip.g_h = view.clipping.y1 - view.clipping.y0; + + /* physical clipping: */ + sclip.g_x = rclip.g_x; + sclip.g_y = rclip.g_y; + sclip.g_w = view.vis_w; + sclip.g_h = view.vis_h; + + rc_intersect(&sclip, &rclip); + r.g_x = x0; + r.g_y = y0; + r.g_w = x1 - x0; + r.g_h = y1 - y0; + + if (!rc_intersect( &rclip, &r )) { + return(true); + } + if (pstyle->stroke_type != PLOT_OP_TYPE_NONE) { + /* + manually draw the line, because we do not need vdi clipping + for vertical / horizontal line draws. + */ + if( sw == 0) + sw = 1; + + NSLT2VDI(lt, pstyle); + vsl_type(atari_plot_vdi_handle, (lt&0x0F)); + /* + if the line style is not available within VDI system, + define own style: + */ + if( (lt&0x0F) == 7 ){ + vsl_udsty(atari_plot_vdi_handle, ((lt&0xFFFF00) >> 8)); + } + vsl_width(atari_plot_vdi_handle, (short)sw ); + vsl_rgbcolor(atari_plot_vdi_handle, pstyle->stroke_colour); + /* top border: */ + if( r.g_y == y0){ + pxy[0] = view.x + r.g_x; + pxy[1] = view.y + r.g_y ; + pxy[2] = view.x + r.g_x + r.g_w; + pxy[3] = view.y + r.g_y; + v_pline(atari_plot_vdi_handle, 2, (short *)&pxy); + } + + /* right border: */ + if( r.g_x + r.g_w == x1 ){ + pxy[0] = view.x + r.g_x + r.g_w; + pxy[1] = view.y + r.g_y; + pxy[2] = view.x + r.g_x + r.g_w; + pxy[3] = view.y + r.g_y + r.g_h; + v_pline(atari_plot_vdi_handle, 2, (short *)&pxy); + } + + /* bottom border: */ + if( r.g_y+r.g_h == y1 ){ + pxy[0] = view.x + r.g_x; + pxy[1] = view.y + r.g_y+r.g_h; + pxy[2] = view.x + r.g_x+r.g_w; + pxy[3] = view.y + r.g_y+r.g_h; + v_pline(atari_plot_vdi_handle, 2, (short *)&pxy); + } + + /* left border: */ + if( r.g_x == x0 ){ + pxy[0] = view.x + r.g_x; + pxy[1] = view.y + r.g_y; + pxy[2] = view.x + r.g_x; + pxy[3] = view.y + r.g_y + r.g_h; + v_pline(atari_plot_vdi_handle, 2, (short *)&pxy); + } + } + + if( pstyle->fill_type != PLOT_OP_TYPE_NONE ){ + short stroke_width = (short)(pstyle->stroke_type != PLOT_OP_TYPE_NONE) ? + pstyle->stroke_width : 0; + + vsf_rgbcolor(atari_plot_vdi_handle, pstyle->fill_colour); + vsf_perimeter(atari_plot_vdi_handle, 0); + vsf_interior(atari_plot_vdi_handle, FIS_SOLID); + + + pxy[0] = view.x + r.g_x + stroke_width; + pxy[1] = view.y + r.g_y + stroke_width; + pxy[2] = view.x + r.g_x + r.g_w -1 - stroke_width; + pxy[3] = view.y + r.g_y + r.g_h -1 - stroke_width; + + vsf_style(atari_plot_vdi_handle, 1); + v_bar(atari_plot_vdi_handle, (short*)&pxy); + } + return (true); +} + +bool plot_line(int x0, int y0, int x1, int y1, + const plot_style_t *pstyle ) +{ + short pxy[4]; + uint32_t lt; + int sw = pstyle->stroke_width; + + pxy[0] = view.x + x0; + pxy[1] = view.y + y0; + pxy[2] = view.x + x1; + pxy[3] = view.y + y1; + + plotter_vdi_clip(true); + if( sw == 0) + sw = 1; + NSLT2VDI(lt, pstyle) + vsl_type(atari_plot_vdi_handle, (lt&0x0F)); + /* if the line style is not available within VDI system,define own style: */ + if( (lt&0x0F) == 7 ){ + vsl_udsty(atari_plot_vdi_handle, ((lt&0xFFFF00) >> 8)); + } + vsl_width(atari_plot_vdi_handle, (short)sw); + vsl_rgbcolor(atari_plot_vdi_handle, pstyle->stroke_colour); + v_pline(atari_plot_vdi_handle, 2, (short *)&pxy ); + plotter_vdi_clip(false); + return ( true ); +} + +static bool plot_polygon(const int *p, unsigned int n, + const plot_style_t *pstyle) +{ + short pxy[n*2]; + unsigned int i=0; + short d[4]; + if (vdi_sysinfo.maxpolycoords > 0) + assert( (signed int)n < vdi_sysinfo.maxpolycoords); + plotter_vdi_clip(true); + vsf_interior(atari_plot_vdi_handle, FIS_SOLID); + vsf_style(atari_plot_vdi_handle, 1); + for (i = 0; ifill_type == PLOT_OP_TYPE_SOLID) { + vsf_rgbcolor(atari_plot_vdi_handle, pstyle->fill_colour); + v_fillarea(atari_plot_vdi_handle, n, (short*)&pxy); + } else { + pxy[n*2]=pxy[0]; + pxy[n*2+1]=pxy[1]; + vsl_rgbcolor(atari_plot_vdi_handle, pstyle->stroke_colour); + v_pline(atari_plot_vdi_handle, n+1, (short *)&pxy); + } + plotter_vdi_clip(false); + return ( true ); +} + +bool plot_set_dimensions(int x, int y, int w, int h) +{ + bool doupdate = false; + + if (!(w == view.w && h == view.h)) { + struct rect newclip = { 0, 0, w-1, h-1 }; + view.w = (short)w; + view.h = (short)h; + doupdate = true; + } + if (!(x == view.x && y == view.y)) { + view.x = (short)x; + view.y = (short)y; + doupdate = true; + } + if (doupdate==true) + update_visible_rect(); + return(true); +} + +bool plot_clip(const struct rect *clip) +{ + // FIXME: consider the canvas size + view.clipping.x0 = clip->x0; + view.clipping.y0 = clip->y0; + view.clipping.x1 = clip->x1; + view.clipping.y1 = clip->y1; + return ( true ); +} + + +bool plot_get_clip(struct rect * out) +{ + out->x0 = view.clipping.x0; + out->y0 = view.clipping.y0; + out->x1 = view.clipping.x1; + out->y1 = view.clipping.y1; + return( true ); +} + +void plotter_get_clip_grect(GRECT * out) +{ + struct rect clip={0,0,0,0}; + plot_get_clip(&clip); + out->g_x = clip.x0; + out->g_y = clip.y0; + out->g_w = clip.x1 - clip.x0; + out->g_h = clip.y1 - clip.y0; +} + +static bool plot_text(int x, int y, const char *text, size_t length, const plot_font_style_t *fstyle ) +{ + fplotter->text(fplotter, x, y, text, length, fstyle); + return ( true ); +} + +static bool plot_disc(int x, int y, int radius, const plot_style_t *pstyle) +{ + plotter_vdi_clip(true); + if (pstyle->fill_type != PLOT_OP_TYPE_SOLID) { + vsf_rgbcolor(atari_plot_vdi_handle, pstyle->stroke_colour); + vsf_perimeter(atari_plot_vdi_handle, 1); + vsf_interior(atari_plot_vdi_handle, 0); + v_circle(atari_plot_vdi_handle, view.x + x, view.y + y, radius); + } else { + vsf_rgbcolor(atari_plot_vdi_handle, pstyle->fill_colour); + vsf_perimeter(atari_plot_vdi_handle, 0); + vsf_interior(atari_plot_vdi_handle, FIS_SOLID); + v_circle(atari_plot_vdi_handle, view.x + x, view.y + y, radius); + } + plotter_vdi_clip(false); + return ( true ); +} + +static bool plot_arc(int x, int y, int radius, int angle1, int angle2, + const plot_style_t *pstyle) +{ + //plotter_vdi_clip(true); + vswr_mode(atari_plot_vdi_handle, MD_REPLACE ); + if (pstyle->fill_type == PLOT_OP_TYPE_NONE) + return(true); + if ( pstyle->fill_type != PLOT_OP_TYPE_SOLID) { + vsl_rgbcolor(atari_plot_vdi_handle, pstyle->stroke_colour); + vsf_perimeter(atari_plot_vdi_handle, 1); + vsf_interior(atari_plot_vdi_handle, 1 ); + v_arc(atari_plot_vdi_handle, view.x + x, view.y + y, radius, angle1*10, angle2*10); + } else { + vsf_rgbcolor(atari_plot_vdi_handle, pstyle->fill_colour); + vsl_width(atari_plot_vdi_handle, 1 ); + vsf_perimeter(atari_plot_vdi_handle, 1); + v_arc(atari_plot_vdi_handle, view.x + x, view.y + y, radius, angle1*10, angle2*10); + } + //plotter_vdi_clip(true); + return (true); +} + +static bool plot_bitmap(int x, int y, int width, int height, + struct bitmap *bitmap, colour bg, + bitmap_flags_t flags) +{ + struct bitmap * bm = NULL; + bool repeat_x = (flags & BITMAPF_REPEAT_X); + bool repeat_y = (flags & BITMAPF_REPEAT_Y); + int bmpw,bmph; + struct rect clip = {0,0,0,0}; + + bmpw = bitmap_get_width(bitmap); + bmph = bitmap_get_height(bitmap); + + if ( repeat_x || repeat_y ) { + plot_get_clip(&clip); + if( repeat_x && width == 1 && repeat_y && height == 1 ) { + width = MAX( width, clip.x1 - x ); + height = MAX( height, clip.y1 - y ); + } else if( repeat_x && width == 1 ) { + width = MAX( width, clip.x1 - x); + } else if( repeat_y && height == 1) { + height = MAX( height, clip.y1 - y ); + } + } + + if( width != bmpw || height != bmph ) { + plot_resize_bitmap(bitmap, width, height ); + if( bitmap->resized ) + bm = bitmap->resized; + else + bm = bitmap; + } else { + bm = bitmap; + } + + /* out of memory? */ + if( bm == NULL ) { + printf("plot: out of memory! bmp: %p, bmpres: %p\n", bitmap, bitmap->resized ); + return( true ); + } + + if (!(repeat_x || repeat_y) ) { + plot_blit_bitmap(bm, x, y, bg, flags ); + } else { + int xf,yf; + int xoff = x; + int yoff = y; + + if (yoff > clip.y0 ) + yoff = (clip.y0 - height) + ((yoff - clip.y0) % height); + if (xoff > clip.x0 ) + xoff = (clip.x0 - width) + ((xoff - clip.x0) % width); + /* for now, repeating just works in the rigth / down direction */ + /* + if( repeat_x == true ) + xoff = clip.x0; + if(repeat_y == true ) + yoff = clip.y0; + */ + + for( xf = xoff; xf < clip.x1; xf += width ) { + for( yf = yoff; yf < clip.y1; yf += height ) { + plot_blit_bitmap(bm, xf, yf, bg, flags ); + if (!repeat_y) + break; + } + if (!repeat_x) + break; + } + } + return ( true ); +} + +static bool plot_path(const float *p, unsigned int n, colour fill, float width, + colour c, const float transform[6]) +{ + return ( true ); +} + + + +const struct plotter_table atari_plotters = { + .rectangle = plot_rectangle, + .line = plot_line, + .polygon = plot_polygon, + .clip = plot_clip, + .text = plot_text, + .disc = plot_disc, + .arc = plot_arc, + .bitmap = plot_bitmap, + .path = plot_path, + .flush = NULL, + .group_start = NULL, + .group_end = NULL, + .option_knockout = true +}; diff --git a/atari/plot/plot.h b/atari/plot/plot.h new file mode 100755 index 000000000..71546648e --- /dev/null +++ b/atari/plot/plot.h @@ -0,0 +1,187 @@ +/* + * Copyright 2010 Ole Loots + * + * This file is part of NetSurf, http://www.netsurf-browser.org/ + * + * NetSurf is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * NetSurf is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef NS_ATARI_PLOT_H +#define NS_ATARI_PLOT_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "desktop/plotters.h" +#include "desktop/plot_style.h" +#include "image/bitmap.h" + +#include "atari/bitmap.h" +#include "atari/plot/eddi.h" +#include "atari/plot/fontplot.h" + +/* how much memory should be kept allocated for temp. conversion bitmaps: */ +#define CONV_KEEP_LIMIT 512000 +/* how much memory to allocate if some is needed: */ +#define CONV_BLOCK_SIZE 32000 + +/* Plotter Option Flags: */ +#define PLOT_FLAG_DITHER 0x04 /* true if the plotter shall dither images */ +#define PLOT_FLAG_TRANS 0x08 /* true if the plotter supports transparent operations */ + +/* Plotter "feature" flags */ +#define PLOT_FLAG_HAS_DITHER 0x0400 +#define PLOT_FLAG_HAS_ALPHA 0x0800 +#define PLOT_FLAG_OFFSCREEN 0x1000 /* offsreen plotter should set this flag */ + +/* Plotter "internal" flags */ +#define PLOT_FLAG_LOCKED 0x08000 /* plotter should set this flag during screen updates */ + +/* Font Plotter flags: */ +#define FONTPLOT_FLAG_MONOGLYPH 0x01 + +/* Flags for init_mfdb function: */ +#define MFDB_FLAG_STAND 0x01 +#define MFDB_FLAG_ZEROMEM 0x02 +#define MFDB_FLAG_NOALLOC 0x04 + +/* Flags for blit functions: */ +#define BITMAPF_MONOGLYPH 4096 /* The bitmap is an character bitmap */ +#define BITMAPF_BUFFER_NATIVE 8192 /* Bitmap shall be kept converted */ + +/* Error codes: */ +#define ERR_BUFFERSIZE_EXCEEDS_SCREEN 1 /* The buffer allocated is larger than the screen */ +#define ERR_NO_MEM 2 /* Not enough memory for requested operation */ +#define ERR_PLOTTER_NOT_AVAILABLE 3 /* invalid plotter driver name passed */ + +struct s_vdi_sysinfo { + short vdi_handle; /* vdi handle */ + short scr_w; /* resolution horz. */ + short scr_h; /* resolution vert. */ + short scr_bpp; /* bits per pixel */ + int colors; /* 0=hiclor, 2=mono */ + unsigned long hicolors; /* if colors = 0 */ + short pixelsize; /* bytes per pixel */ + unsigned short pitch; /* row pitch */ + unsigned short vdiformat; /* pixel format */ + unsigned short clut; /* type of clut support */ + void * screen; /* pointer to screen, or NULL */ + unsigned long screensize; /* size of screen (in bytes) */ + unsigned long mask_r; /* color masks */ + unsigned long mask_g; + unsigned long mask_b; + unsigned long mask_a; + short maxintin; /* maximum pxy items */ + short maxpolycoords; /* max coords for p_line etc. */ + unsigned long EdDiVersion; /* EdDi Version or 0 */ + bool rasterscale; /* raster scaling support */ +}; + +struct rect; + +extern const struct plotter_table atari_plotters; + +int atari_plotter_init(char *); +int atari_plotter_finalise(void); +/* translate an error number */ +const char* plot_err_str(int i) ; + +bool plot_lock(void); +bool plot_unlock(void); +bool plot_set_dimensions( int x, int y, int w, int h ); +bool plot_get_clip(struct rect * out); +/* Get clipping for current framebuffer as GRECT */ +void plotter_get_clip_grect(GRECT * out); +bool plot_clip(const struct rect *clip); +bool plot_rectangle( int x0, int y0, int x1, int y1,const plot_style_t *style ); +bool plot_line( int x0, int y0, int x1, int y1, const plot_style_t *style ); +bool plot_resize_bitmap(struct bitmap * img, int nw, int nh); +bool plot_blit_bitmap(struct bitmap * bmp, int x, int y, + unsigned long bg, unsigned long flags); +bool plot_blit_mfdb(GRECT * loc, MFDB * insrc, unsigned char fgcolor, + uint32_t flags); +bool plot_copy_rect(GRECT src, GRECT dst); +/* +* Capture the screen at x,y location +* param self instance +* param x absolute screen coords +* param y absolute screen coords +* param w width +* param h height +* +* This creates an snapshot in RGBA format (NetSurf's native format) +* +*/ +static struct bitmap * snapshot_create(int x, int y, int w, int h); + +/* Garbage collection of the snapshot routine */ +/* this should be called after you are done with the data returned by snapshot_create */ +/* don't access the screenshot after you called this function */ +static void snapshot_suspend(void); + +/* destroy memory used by screenshot */ +static void snapshot_destroy(void); + +/* convert an vdi color to bgra */ +void vdi1000_to_rgb( unsigned short * in, unsigned char * out ); + +/* convert an bgra color to vdi1000 color */ +void rgb_to_vdi1000( unsigned char * in, unsigned short * out ); + +/* convert an rgb color to an index into the web palette */ +short rgb_to_666_index(unsigned char r, unsigned char g, unsigned char b); + +/* assign vdi line style to dst ( netsurf type ) */ +#define NSLT2VDI(dst, src) \ + dst = 0;\ + switch( src->stroke_type ) {\ + case PLOT_OP_TYPE_DOT: \ + dst = (0xAAAA00 | 7);\ + break;\ + case PLOT_OP_TYPE_DASH:\ + dst = 3; \ + break;\ + case PLOT_OP_TYPE_SOLID:\ + case PLOT_OP_TYPE_NONE:\ + default:\ + dst = 1;\ + break;\ + }\ + + +#define PLOTTER_IS_LOCKED() ( atari_plot_flags & PLOTTER_FLAG_LOCKED ) + + +#ifdef WITH_8BPP_SUPPORT +/* some Well known indexes into the VDI palette */ +/* common indexes into the VDI palette */ +/* (only used when running with 256 colors or less ) */ +#define OFFSET_WEB_PAL 16 +#define OFFSET_CUST_PAL 232 +#define RGB_TO_VDI(c) rgb_to_666_index( (c&0xFF),(c&0xFF00)>>8,(c&0xFF0000)>>16)+OFFSET_WEB_PAL +#endif + +/* the name of this macro is crap - it should be named bgr_to_rgba ... or so */ +#define ABGR_TO_RGB(c) ( ((c&0xFF)<<16) | (c&0xFF00) | ((c&0xFF0000)>>16) ) << 8 +/* this index into the palette is used by the TC renderer to set current draw color: */ +#define OFFSET_CUSTOM_COLOR 255 + +#endif diff --git a/atari/statusbar.c b/atari/statusbar.c index 24c55526a..f4dbbe578 100755 --- a/atari/statusbar.c +++ b/atari/statusbar.c @@ -42,10 +42,10 @@ #include "atari/misc.h" #include "atari/global_evnt.h" #include "atari/res/netsurf.rsh" -#include "atari/plot/plotter.h" +#include "atari/plot/plot.h" #include "atari/osspec.h" -extern short vdih; +extern int atari_plot_vdi_handle; static void __CDECL evnt_sb_redraw( COMPONENT *c, long buff[8] ) @@ -69,42 +69,43 @@ void __CDECL evnt_sb_redraw( COMPONENT *c, long buff[8] ) if ( !rc_lintersect( (LGRECT*)&buff[4], &lclip ) ) { return; } - vsf_interior( vdih, FIS_SOLID ); - vsl_color( vdih, BLACK ); - vsl_type( vdih, 1); - vsl_width( vdih, 1 ); - vst_color(vdih, BLACK); - - vst_height( vdih, atari_sysinfo.medium_sfont_pxh, &pxy[0], &pxy[1], &pxy[2], &pxy[3] ); - vst_alignment(vdih, 0, 5, &d, &d ); - vst_effects( vdih, 0 ); + vsf_interior(atari_plot_vdi_handle, FIS_SOLID ); + vsl_color(atari_plot_vdi_handle, BLACK ); + vsl_type(atari_plot_vdi_handle, 1); + vsl_width(atari_plot_vdi_handle, 1 ); + vst_color(atari_plot_vdi_handle, BLACK); + + vst_height(atari_plot_vdi_handle, atari_sysinfo.medium_sfont_pxh, &pxy[0], &pxy[1], &pxy[2], &pxy[3] ); + vst_alignment(atari_plot_vdi_handle, 0, 5, &d, &d ); + vst_effects(atari_plot_vdi_handle, 0 ); pxyclip[0] = lclip.g_x; pxyclip[1] = lclip.g_y; pxyclip[2] = lclip.g_x + lclip.g_w-1; pxyclip[3] = lclip.g_y + lclip.g_h-1; - vs_clip(vdih, 1, (short*)&pxyclip ); - vswr_mode( vdih, MD_REPLACE ); + vs_clip(atari_plot_vdi_handle, 1, (short*)&pxyclip ); + vswr_mode(atari_plot_vdi_handle, MD_REPLACE ); if( lclip.g_y <= work.g_y ) { pxy[0] = work.g_x; pxy[1] = work.g_y; pxy[2] = MIN( work.g_x + work.g_w, lclip.g_x + lclip.g_w ); pxy[3] = work.g_y; - v_pline( vdih, 2, (short*)&pxy ); + v_pline(atari_plot_vdi_handle, 2, (short*)&pxy ); } if(app.nplanes > 2) { - vsf_color( vdih, LWHITE); + vsf_color(atari_plot_vdi_handle, LWHITE); } else { - vsf_color( vdih, WHITE ); + vsf_color(atari_plot_vdi_handle, WHITE ); } pxy[0] = work.g_x; pxy[1] = work.g_y+1; pxy[2] = work.g_x + work.g_w-1; pxy[3] = work.g_y + work.g_h-1; - v_bar( vdih, pxy ); + v_bar(atari_plot_vdi_handle, pxy ); + if( sb->textlen > 0 ) { short curx; @@ -114,32 +115,32 @@ void __CDECL evnt_sb_redraw( COMPONENT *c, long buff[8] ) t[1]=0; if( atari_sysinfo.sfont_monospaced ) { t[0]='A'; - int r = vqt_width( vdih, t[0], &vqw[0], &vqw[1], &vqw[2] ); + int r = vqt_width(atari_plot_vdi_handle, t[0], &vqw[0], &vqw[1], &vqw[2] ); cw = vqw[0]; } - vswr_mode( vdih, MD_TRANS ); + vswr_mode(atari_plot_vdi_handle, MD_TRANS ); for( curx = work.g_x + 2, i=0 ; (curx+cw < work.g_x+work.g_w ) && i < sb->textlen; i++ ){ t[0] = sb->text[i]; if( !atari_sysinfo.sfont_monospaced ) { - vqt_width( vdih, t[0], &vqw[0], &vqw[1], &vqw[2] ); + vqt_width(atari_plot_vdi_handle, t[0], &vqw[0], &vqw[1], &vqw[2] ); cw = vqw[0]; } if( curx >= lclip.g_x - cw ) { - v_gtext( vdih, curx, work.g_y + 5, (char*)&t ); + v_gtext(atari_plot_vdi_handle, curx, work.g_y + 5, (char*)&t ); } curx += cw; if( curx >= lclip.g_x + lclip.g_w ) break; } } - vswr_mode( vdih, MD_REPLACE ); + vswr_mode(atari_plot_vdi_handle, MD_REPLACE ); pxy[0] = work.g_x + work.g_w; pxy[1] = work.g_y + work.g_h; pxy[2] = work.g_x + work.g_w; pxy[3] = work.g_y + work.g_h-work.g_h; - v_pline( vdih, 2, (short*)&pxy ); + v_pline(atari_plot_vdi_handle, 2, (short*)&pxy ); - vs_clip(vdih, 0, (short*)&pxyclip ); + vs_clip(atari_plot_vdi_handle, 0, (short*)&pxyclip ); return; } diff --git a/atari/toolbar.c b/atari/toolbar.c index a17ca8a67..dd822ebc5 100755 --- a/atari/toolbar.c +++ b/atari/toolbar.c @@ -37,6 +37,7 @@ #include "desktop/plot_style.h" #include "desktop/plotters.h" #include "desktop/tree.h" +#include "desktop/options.h" #include "utils/utf8.h" #include "atari/clipboard.h" #include "atari/gui.h" @@ -46,17 +47,16 @@ #include "atari/clipboard.h" #include "atari/misc.h" #include "atari/global_evnt.h" -#include "atari/plot.h" +#include "atari/plot/plot.h" #include "cflib.h" #include "atari/res/netsurf.rsh" -#include "atari/plot/plotter.h" extern char * cfg_homepage_url; -extern short vdih; extern void * h_gem_rsrc; -extern GEM_PLOTTER plotter; extern struct gui_window * input_window; +extern long atari_plot_flags; +extern int atari_plot_vdi_handle; static OBJECT * toolbar_buttons = NULL; static OBJECT * throbber_form = NULL; @@ -187,7 +187,7 @@ void toolbar_init( void ) for( i=0; istyle].bgcolor ); - vswr_mode( vdih, MD_REPLACE); + vsf_interior(atari_plot_vdi_handle , 1 ); + vsf_color(atari_plot_vdi_handle, toolbar_styles[tb->style].bgcolor ); + vswr_mode(atari_plot_vdi_handle, MD_REPLACE); /* go through the rectangle list, using classic AES methods. */ /* Windom ComGetLGrect is buggy for WF_FIRST/NEXTXYWH */ @@ -310,8 +310,8 @@ static void __CDECL button_redraw( COMPONENT *c, long buff[8], void * data ) pxy[1] = todo.g_y; pxy[2] = todo.g_w + todo.g_x-1; pxy[3] = todo.g_h + todo.g_y-1; - vs_clip( vdih, 1, (short*)&pxy ); - v_bar( vdih, (short*)&pxy ); + vs_clip(atari_plot_vdi_handle, 1, (short*)&pxy ); + v_bar(atari_plot_vdi_handle, (short*)&pxy ); if( img_toolbar == true ){ atari_plotters.bitmap( bmpx, bmpy, bmpw, bmph, icon, @@ -320,7 +320,7 @@ static void __CDECL button_redraw( COMPONENT *c, long buff[8], void * data ) } else { objc_draw( tree, 0, 0, todo.g_x, todo.g_y, todo.g_w, todo.g_h ); } - vs_clip( vdih, 0, (short*)&clip ); + vs_clip(atari_plot_vdi_handle, 0, (short*)&clip ); } wind_get(gw->root->handle->handle, WF_NEXTXYWH, &todo.g_x, &todo.g_y, &todo.g_w, &todo.g_h ); @@ -389,17 +389,17 @@ void __CDECL evnt_throbber_redraw( COMPONENT *c, long buff[8]) clip = work; if ( !rc_lintersect( (LGRECT*)&buff[4], &clip ) ) return; - vsf_interior( vdih , 1 ); + vsf_interior(atari_plot_vdi_handle , 1 ); if(app.nplanes > 2 ) - vsf_color( vdih, toolbar_styles[tb->style].bgcolor ); + vsf_color(atari_plot_vdi_handle, toolbar_styles[tb->style].bgcolor ); else - vsf_color( vdih, WHITE ); + vsf_color(atari_plot_vdi_handle, WHITE ); pxy[0] = (short)buff[4]; pxy[1] = (short)buff[5]; pxy[2] = (short)buff[4] + buff[6]-1; pxy[3] = (short)buff[5] + buff[7]-2; - v_bar( vdih, (short*)&pxy ); - vs_clip( vdih, 1, (short*)&pxy ); + v_bar(atari_plot_vdi_handle, (short*)&pxy ); + vs_clip(atari_plot_vdi_handle, 1, (short*)&pxy ); if( img_toolbar ){ @@ -492,41 +492,41 @@ void __CDECL evnt_url_redraw( COMPONENT *c, long buff[8] ) pxy[1] = clip.g_y; pxy[2] = clip.g_w + clip.g_x-1; pxy[3] = clip.g_h + clip.g_y-1; - vs_clip( vdih, 1, (short*)&pxy ); + vs_clip(atari_plot_vdi_handle, 1, (short*)&pxy ); - vsf_perimeter( vdih, 0 ); - vsf_interior( vdih , 1 ); - vsf_color( vdih, toolbar_styles[tb->style].bgcolor ); + vsf_perimeter(atari_plot_vdi_handle, 0 ); + vsf_interior(atari_plot_vdi_handle , 1 ); + vsf_color(atari_plot_vdi_handle, toolbar_styles[tb->style].bgcolor ); //left margin: pxy[0] = work.g_x; pxy[1] = work.g_y; pxy[2] = work.g_x + TOOLBAR_URL_MARGIN_LEFT-1; pxy[3] = work.g_y + work.g_h-1; - v_bar( vdih, pxy ); + v_bar(atari_plot_vdi_handle, pxy ); // right margin: pxy[0] = work.g_x+work.g_w-TOOLBAR_URL_MARGIN_RIGHT; pxy[1] = work.g_y; pxy[2] = work.g_x+work.g_w-1; pxy[3] = work.g_y+work.g_h-1; - v_bar( vdih, pxy ); + v_bar(atari_plot_vdi_handle, pxy ); // top margin: pxy[0] = work.g_x; pxy[1] = work.g_y; pxy[2] = work.g_x+work.g_w-1; pxy[3] = work.g_y+TOOLBAR_URL_MARGIN_TOP-1; - v_bar( vdih, pxy ); + v_bar(atari_plot_vdi_handle, pxy ); // bottom margin: pxy[0] = work.g_x; pxy[1] = work.g_y+work.g_h-TOOLBAR_URL_MARGIN_BOTTOM; pxy[2] = work.g_x+work.g_w-1; pxy[3] = work.g_y+work.g_h-1; - v_bar( vdih, pxy ); + v_bar(atari_plot_vdi_handle, pxy ); - vs_clip( vdih, 0, (short*)&pxy ); + vs_clip(atari_plot_vdi_handle, 0, (short*)&pxy ); // TBD: request redraw of textarea for specific region. clip.g_x -= work.g_x+TOOLBAR_URL_MARGIN_LEFT; @@ -619,14 +619,14 @@ static void __CDECL evnt_toolbar_redraw( COMPONENT *c, long buff[8], void *data if( work.g_y + work.g_h != clip.g_y + clip.g_h ) return; - vswr_mode( vdih, MD_REPLACE ); - vsl_color( vdih, BLACK ); - vsl_type( vdih, 1 ); - vsl_width( vdih, 1 ); + vswr_mode(atari_plot_vdi_handle, MD_REPLACE ); + vsl_color(atari_plot_vdi_handle, BLACK ); + vsl_type(atari_plot_vdi_handle, 1 ); + vsl_width(atari_plot_vdi_handle, 1 ); pxy[0] = clip.g_x; pxy[1] = pxy[3] = work.g_y + work.g_h-1 ; pxy[2] = clip.g_x + clip.g_w; - v_pline( vdih, 2, (short*)&pxy ); + v_pline(atari_plot_vdi_handle, 2, (short*)&pxy ); } @@ -659,10 +659,11 @@ static void tb_txt_request_redraw(void *data, int x, int y, int w, int h) } void tb_url_redraw( struct gui_window * gw ) -{ +{ + CMP_TOOLBAR t = gw->root->toolbar; if (t != NULL) { - if( t->url.redraw && ((plotter->flags & PLOT_FLAG_OFFSCREEN) == 0) ) { + if( t->url.redraw && ((atari_plot_flags & PLOT_FLAG_OFFSCREEN) == 0) ) { const struct redraw_context ctx = { .interactive = true, @@ -679,14 +680,14 @@ void tb_url_redraw( struct gui_window * gw ) work.g_h -= TOOLBAR_URL_MARGIN_BOTTOM; plot_set_dimensions( work.g_x, work.g_y, work.g_w, work.g_h ); - if( plotter->lock( plotter ) == 0 ) + if(plot_lock() == false) return; todo[0] = work.g_x; todo[1] = work.g_y; todo[2] = todo[0] + work.g_w-1; todo[3] = todo[1] + work.g_h-1; - vs_clip(plotter->vdi_handle, 1, (short*)&todo ); + vs_clip(atari_plot_vdi_handle, 1, (short*)&todo ); if( wind_get(gw->root->handle->handle, WF_FIRSTXYWH, &todo[0], &todo[1], &todo[2], &todo[3] )!=0 ) { @@ -719,11 +720,11 @@ void tb_url_redraw( struct gui_window * gw ) } } } else { - plotter->unlock( plotter ); + plot_unlock(); return; } - plotter->unlock( plotter ); - vs_clip(plotter->vdi_handle, 0, (short*)&todo); + plot_unlock(); + vs_clip(atari_plot_vdi_handle, 0, (short*)&todo); t->url.redraw = false; t->url.rdw_area.g_x = 65000; t->url.rdw_area.g_y = 65000; diff --git a/atari/treeview.c b/atari/treeview.c index d5f9957d3..4a5cb0a75 100755 --- a/atari/treeview.c +++ b/atari/treeview.c @@ -35,7 +35,7 @@ #include "utils/utils.h" #include "atari/gui.h" #include "atari/treeview.h" -#include "atari/plot.h" +#include "atari/plot/plot.h" #include "atari/misc.h" #include "cflib.h" @@ -43,7 +43,8 @@ extern int mouse_hold_start[3]; extern browser_mouse_state bmstate; extern short last_drag_x; extern short last_drag_y; -extern GEM_PLOTTER plotter; +extern long atari_plot_flags; +extern int atari_plot_vdi_handle; static void atari_treeview_resized(struct tree *tree,int w,int h,void *pw); static void atari_treeview_scroll_visible(int y, int h, void *pw); @@ -265,9 +266,10 @@ bool atari_treeview_mevent( NSTREEVIEW tv, browser_mouse_state bms, int x, int y void atari_treeview_redraw( NSTREEVIEW tv) -{ +{ + if (tv != NULL) { - if( tv->redraw && ((plotter->flags & PLOT_FLAG_OFFSCREEN) == 0) ) { + if( tv->redraw && ((atari_plot_flags & PLOT_FLAG_OFFSCREEN) == 0) ) { short todo[4]; GRECT work; WindGetGrect( tv->window, WF_WORKXYWH, &work ); @@ -277,17 +279,15 @@ void atari_treeview_redraw( NSTREEVIEW tv) .background_images = true, .plot = &atari_plotters }; - - plotter->resize(plotter, work.g_w, work.g_h); - plotter->move(plotter, work.g_x, work.g_y ); - if( plotter->lock( plotter ) == 0 ) + plot_set_dimensions(work.g_x, work.g_y, work.g_w, work.g_h); + if (plot_lock() == false) return; todo[0] = work.g_x; todo[1] = work.g_y; todo[2] = todo[0] + work.g_w-1; todo[3] = todo[1] + work.g_h-1; - vs_clip(plotter->vdi_handle, 1, (short*)&todo ); + vs_clip(atari_plot_vdi_handle, 1, (short*)&todo ); if( wind_get(tv->window->handle, WF_FIRSTXYWH, &todo[0], &todo[1], &todo[2], &todo[3] )!=0 ) { @@ -316,11 +316,11 @@ void atari_treeview_redraw( NSTREEVIEW tv) } } } else { - plotter->unlock( plotter ); + plot_unlock(); return; } - plotter->unlock( plotter ); - vs_clip(plotter->vdi_handle, 0, (short*)&todo); + plot_unlock(); + vs_clip(atari_plot_vdi_handle, 0, (short*)&todo); tv->redraw = false; tv->rdw_area.g_x = 65000; tv->rdw_area.g_y = 65000; diff --git a/atari/verify_ssl.c b/atari/verify_ssl.c index 1f56e46f9..e6a57b7b2 100755 --- a/atari/verify_ssl.c +++ b/atari/verify_ssl.c @@ -33,12 +33,12 @@ #include "atari/verify_ssl.h" /* - todo: this file need to use the treeview api - complete rework, - current implementation is not used in any way. + todo: this file need to use the treeview api - complete rework, + current implementation is not used in any way. */ extern void * h_gem_rsrc; -extern short vdih; +extern short atari_plot_vdi_handle; #define CERT_INF_LINES 8 @@ -95,15 +95,15 @@ static void __CDECL cert_info_draw( WINDOW * win, short buf[8], void * data) work.g_h = 176; maxchars = (work.g_w / 8)+1; - vs_clip( vdih, 1,(short*) &pxy ); - vswr_mode( vdih, MD_REPLACE ); - vsf_interior( vdih, 1 ); - vsf_color( vdih, LWHITE ); - v_bar( vdih, (short*)&pxy ); - vst_height( vdih, 16, &d, &d, &cbw, &cbh ); - vst_alignment(vdih, 0, 5, &d, &d ); - vst_color( vdih, BLACK ); - vst_effects( vdih, 0 ); + vs_clip( atari_plot_vdi_handle, 1,(short*) &pxy ); + vswr_mode( atari_plot_vdi_handle, MD_REPLACE ); + vsf_interior( atari_plot_vdi_handle, 1 ); + vsf_color( atari_plot_vdi_handle, LWHITE ); + v_bar( atari_plot_vdi_handle, (short*)&pxy ); + vst_height( atari_plot_vdi_handle, 16, &d, &d, &cbw, &cbh ); + vst_alignment(atari_plot_vdi_handle, 0, 5, &d, &d ); + vst_color( atari_plot_vdi_handle, BLACK ); + vst_effects( atari_plot_vdi_handle, 0 ); px_ypos = px_xpos = 0; for(i=0; i dp->scrollx ) { if( dp->scrollx + maxchars < 511 && ( (signed int)strlen(line) - dp->scrollx) > maxchars ) line[dp->scrollx + maxchars] = 0; - v_gtext(vdih, work.g_x + 1, work.g_y + px_ypos, &line[dp->scrollx]); + v_gtext(atari_plot_vdi_handle, work.g_x + 1, work.g_y + px_ypos, &line[dp->scrollx]); } px_ypos += cbh; } - vst_alignment(vdih, 0, 0, &d, &d ); - vs_clip( vdih, 0, (short*)&pxy ); + vst_alignment(atari_plot_vdi_handle, 0, 0, &d, &d ); + vs_clip( atari_plot_vdi_handle, 0, (short*)&pxy ); free( line ); } -- cgit v1.2.3