Refactor plot implementation (removed old files)

8 files changed, 0 insertions, 3416 deletions

diff --git a/atari/plot.c b/atari/plot.c
deleted file mode 100755
index 861460f49..000000000
--- a/atari/plot.c
+++ /dev/null
@@ -1,255 +0,0 @@
-/*

- * Copyright 2010 Ole Loots <ole@monochrom.net>

- *

- * 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 <http://www.gnu.org/licenses/>.

- */

-

-#include <sys/types.h>

-#include <stdint.h>

-#include <string.h>

-#include <limits.h>

-#include <math.h>

-#include <stdbool.h>

-#include <windom.h>

-

-#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 "atari/plot.h"

-#include "desktop/options.h"

-#include "atari/plot.h"

-

-GEM_PLOTTER plotter = NULL;

-GEM_FONT_PLOTTER fplotter = NULL;

-

-extern short vdih;

-

-/*

-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* drvrname, char * fdrvrname )

-{

-	GRECT loc_pos={0,0,360,400};

-	int err=0;

-	struct s_driver_table_entry * drvinfo;

-	int flags = 0;
-	unsigned long font_flags = 0;

-

-	if( nsoption_int(atari_dither) == 1)

-		flags |= PLOT_FLAG_DITHER;

-	if( nsoption_int(atari_transparency) == 1 )

-		flags |= PLOT_FLAG_TRANS;
-	if( nsoption_int(atari_font_monochrom) == 1 )
-		font_flags |= FONTPLOT_FLAG_MONOGLYPH;

-

-	vdih = app.graf.handle;

-	if( verbose_log ) {

-		dump_vdi_info( vdih ) ;

-		dump_plot_drivers();

-		dump_font_drivers();

-	}

-	drvinfo = get_screen_driver_entry( drvrname );

-

-	LOG(("using plotters: %s, %s", drvrname, fdrvrname));

-	fplotter = new_font_plotter(vdih, fdrvrname, font_flags, &err );

-	if(err){
-		const char * desc = plotter_err_str(err);

-		die(("Unable to load font plotter %s -> %s", fdrvrname, desc ));
-	}

-

-	plotter = new_plotter( vdih, drvrname, &loc_pos, drvinfo->max_bpp,

-							flags, fplotter, &err );

-	if(err){
-		const char * desc = plotter_err_str(err);

-		die(("Unable to load graphics plotter %s -> %s", drvrname, desc ));
-	}

-

-	return( err );

-}

-

-int atari_plotter_finalise( void )

-{

-	delete_plotter( plotter );

-	delete_font_plotter( fplotter );

-}

-

-bool plot_rectangle( int x0, int y0, int x1, int y1,

-			const plot_style_t *style )

-{

-	plotter->rectangle( plotter, x0, y0, x1, y1, style );

-	return ( true );

-}

-

-bool plot_line( int x0, int y0, int x1, int y1,

-			const plot_style_t *style )

-{

-	plotter->line( plotter, x0, y0, x1, y1, style );

-	return ( true );

-}

-

-static bool plot_polygon(const int *p, unsigned int n,

-				const plot_style_t *style)

-{

-	plotter->polygon( plotter, p, n, style );

-	return ( true );

-}
-
-bool plot_set_dimensions( int x, int y, int w, int h )
-{
-	plotter->resize( plotter, w, h );

-	plotter->move( plotter, x, y );
-}
-

-bool plot_clip(const struct rect *clip)

-{

-	plotter->set_clip( plotter, clip );

-	return ( true );

-}

-

-

-bool plot_get_clip(struct rect * out)
-{

-	plotter->get_clip( plotter, out );

-	return( true );

-}

-

-

-static bool plot_text(int x, int y, const char *text, size_t length, const plot_font_style_t *fstyle )

-{

-	plotter->text( plotter, x, y, text, length, fstyle );

-	return ( true );

-}

-

-static bool plot_disc(int x, int y, int radius, const plot_style_t *style)

-{

-	plotter->disc(plotter, x, y, radius, style );

-	return ( true );

-}

-

-static bool plot_arc(int x, int y, int radius, int angle1, int angle2,

-	    		const plot_style_t *style)

-{

-	plotter->arc( plotter, x, y, radius, angle1, angle2, style );

-	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;
-

-	bmpw = bitmap_get_width(bitmap);

-	bmph = bitmap_get_height(bitmap);
-
-	if ( repeat_x || repeat_y ) {

-		plotter->get_clip( plotter, &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 ) {

-		plotter->bitmap_resize(plotter, 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) ) {

-		plotter->bitmap( plotter, 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 ) {

-				plotter->bitmap( plotter, 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])

-{

-	plotter->path( plotter, p, n, fill, width, c, transform );

-	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.h b/atari/plot.h
deleted file mode 100755
index b3f93b219..000000000
--- a/atari/plot.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*

- * Copyright 2010 Ole Loots <ole@monochrom.net>

- *

- * 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 <http://www.gnu.org/licenses/>.

- */

-

-#ifndef NS_ATARI_PLOT_H

-#define NS_ATARI_PLOT_H

-

-#include "desktop/plotters.h"

-#include "atari/plot/plotter.h"

-

-struct rect;

-

-extern const struct plotter_table atari_plotters;

-

-int atari_plotter_init( char*, char * );

-int atari_plotter_finalise( void );
-bool plot_set_dimensions( int x, int y, int w, int h );

-bool plot_get_clip(struct rect * 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 );

-

-#endif

diff --git a/atari/plot/plotter.c b/atari/plot/plotter.c
deleted file mode 100755
index 25d065ec8..000000000
--- a/atari/plot/plotter.c
+++ /dev/null
@@ -1,662 +0,0 @@
-/*

- * Copyright 2010 Ole Loots <ole@monochrom.net>

- *

- * 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 <http://www.gnu.org/licenses/>.

- */

-#include <stdlib.h>

-#include <stdbool.h>

-#include <stdio.h>

-#include <string.h>

-#include <math.h>

-#include <windom.h>

-#include <assert.h>

-#include <mint/osbind.h>

-#include <mint/cookie.h>

-#include <Hermes/Hermes.h>

-

-#include "desktop/plot_style.h"

-#include "atari/bitmap.h"

-#include "image/bitmap.h"

-#include "atari/plot/eddi.h"

-#include "atari/plot/plotter.h"
-#include "atari/plot/plotter_vdi.h"
-#ifdef WITH_GD_PLOTTER

- #include "atari/plot/plotter_gd.h"
-#endif
-

-#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

-#include "atari/gui.h"

-#include "utils/log.h"

-#include "atari/misc.h"

-#include "atari/osspec.h"
-
-

-struct s_driver_table_entry screen_driver_table[] =

-{

-	{
-		(char*)"vdi",
-		ctor_plotter_vdi,
-		PLOT_FLAG_HAS_ALPHA,
-		32
-	},

-#ifdef WITH_GD_PLOTTER
-	{
-		(char*)"gd",
-		ctor_plotter_gd,
-		PLOT_FLAG_OFFSCREEN | PLOT_FLAG_HAS_ALPHA,
-		32
-	},
-#endif
-	{(char*)NULL, NULL, 0, 0 }

-};

-

-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}

-};
-
-

-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}

-};
-
-
-/* get index to driver in driver list by name */

-static int drvrname_idx( char * name );
-
-/* Error code translations: */

-static const char * plot_error_codes[] =

-{

-	"None",

-	"ERR_BUFFERSIZE_EXCEEDS_SCREEN",

-	"ERR_NO_MEM",

-	"ERR_PLOTTER_NOT_AVAILABLE"

-};
-

-struct s_vdi_sysinfo vdi_sysinfo;

-

-struct s_vdi_sysinfo * read_vdi_sysinfo( short vdih, struct s_vdi_sysinfo * info ) {

-

-	unsigned long cookie_EdDI=0;

-	short out[300];

-	memset( info, 0, sizeof(struct s_vdi_sysinfo) );

-

-	info->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;

-		}

-	}

-}

-

-

-/*

-	lookup an plotter ID by name

-*/

-static int drvrname_idx( char * name )

-{

-	int i;

-	for( i = 0; ; i++) {

-		if( screen_driver_table[i].name == NULL ) {

-			return( -1 );

-		}

-		else {

-			if( strcmp(name, screen_driver_table[i].name) == 0 ) {

-				return( i );

-			}

-		}

-	}

-}

-

-/*

-	lookup of font plotter ID by name

-*/

-static int font_drvrname_idx( char * name )

-{

-	int i;

-	for( i = 0; ; i++) {

-		if( font_driver_table[i].name == NULL ) {

-			return( -1 );

-		}

-		else {

-			if( strcmp(name, font_driver_table[i].name) == 0 ) {

-				return( i );

-			}

-		}

-	}

-}

-

-/*

-	Get an plotter info entry, the entry contains an pointer to ctor

-*/

-struct s_driver_table_entry * get_screen_driver_entry( char * name )

-{

-	int idx = drvrname_idx( name );

-	if( idx < 0 )

-		return( 0 );

-	else

-	return( &screen_driver_table[idx] );

-}

-

-/*

-	Get an font plotter info entry, the entry contains an pointer to ctor.

-*/

-struct s_font_driver_table_entry * get_font_driver_entry( char * name )

-{

-	int idx = font_drvrname_idx( name );

-	if( idx < 0 )

-		return( 0 );

-	else

-	return( (struct s_font_driver_table_entry *)&font_driver_table[idx] );

-}

-

-

-/*

-	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 );

-   	}

-	fplotter->plotter = NULL;

-	return( fplotter );

-}

-

-static bool init=false;

-static int inst=0;

-

-/*

-	Create an new plotter object

-*/

-GEM_PLOTTER new_plotter(int vdihandle, char * name, GRECT * loc_size,

-						int virt_bpp, unsigned long flags, FONT_PLOTTER fplotter, int * error )

-{

-	int res = 0-ERR_PLOTTER_NOT_AVAILABLE;

-	int i;

-	assert( fplotter != NULL );

-

-	GEM_PLOTTER gemplotter = (GEM_PLOTTER)malloc( sizeof(struct s_gem_plotter) );

-	if( !gemplotter ) {

-		*error = 0-ERR_NO_MEM;

-		return( NULL );

-   	}

-	memset( gemplotter, 0, sizeof(struct s_gem_plotter));

-

-	gemplotter->name = name;

-	gemplotter->vdi_handle = vdihandle;

-	gemplotter->flags = 0;

-	gemplotter->font_plotter = fplotter;

-	gemplotter->bpp_virt = virt_bpp;

-

-	/* request vdi info once, so every plotter is able to access the info */

-	if( !init ) {

-		/* vdi_sysinfo */

-		read_vdi_sysinfo( vdihandle, &vdi_sysinfo );

-		init = true;

-	}

-	for( i = 0; ; i++) {

-		if( screen_driver_table[i].name == NULL ) {

-			res = 0-ERR_PLOTTER_NOT_AVAILABLE;

-			break;

-		}

-		else {

-			if( strcmp(name, screen_driver_table[i].name) == 0 ) {

-				if( screen_driver_table[i].ctor  ) {

-					gemplotter->flags = (screen_driver_table[i].flags | flags);

-					res = screen_driver_table[i].ctor( gemplotter, loc_size );

-					*error = 0;

-				} else {

-					res = 0-ERR_PLOTTER_NOT_AVAILABLE;

-					*error = res;

-					return (NULL);

-				}

-				break;

-			}

-		}

-	}

-	if( res < 0 ) {

-		free( gemplotter );

-		*error = res;

-		return( NULL );

-   	}

-	inst++;

-	gemplotter->font_plotter->plotter = gemplotter;

-	return( gemplotter );

-}

-

-/*

-	Free an plotter

-*/

-int delete_plotter( GEM_PLOTTER p )

-{

-	if( p ) {

-		p->dtor( p );

-		free( p );

-		p = NULL;

-		inst--;

-		if( inst == 0 ){

-

-		}

-	}

-	else

-		return( -1 );

-	return( 0 );

-}

-

-/*

-	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 );

-}

-

-/*

-	x - x coord

-	y - y coord

-	stride - stride in bytes

-	bpp - bits per pixel

-*/

-int calc_chunked_buffer_size(int x, int y, int stride, int bpp)

-{

-   return( (x * (bpp >> 3)) * y );

-}

-

-/*

-	x - x coord

-	y - y coord

-	stride - stride in bytes

-	bpp - bits per pixel

-*/

-int get_pixel_offset( int x, int y, int stride, int bpp )

-{

-   LOG(("byte_pp: %d, pure: %d, result: %d\n",(bpp >> 3),(y * stride + x), (y * stride + x) * (bpp >> 3)));

-   return( ( (y * stride) + x) * (bpp >> 3) );

-}

-

-const char* plotter_err_str(int i) { return(plot_error_codes[abs(i)]); }

-

-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");

-}

-

-void dump_plot_drivers(void)

-{

-	int i = 0;

-	while( screen_driver_table[i].name != NULL ) {

-		printf("%s -> max_bpp: %d, flags: %d\n",

-			screen_driver_table[i].name,

-			screen_driver_table[i].max_bpp,

-			screen_driver_table[i].flags

-		);

-		i++;

-	}

-}

-

-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++;

-	}

-}

-

-/*
-	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 );

-}

-

-void plotter_get_clip_grect( GEM_PLOTTER self, GRECT * out )

-{
-	struct rect clip;
-	self->get_clip( self, &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;

-}
-
-/*

-	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

-

-

-short web_std_colors[6] = {0, 51, 102, 153, 204, 255};
-

-/*

-	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

-

-

diff --git a/atari/plot/plotter.h b/atari/plot/plotter.h
deleted file mode 100755
index 40fe6c62d..000000000
--- a/atari/plot/plotter.h
+++ /dev/null
@@ -1,364 +0,0 @@
-/*

- * Copyright 2010 Ole Loots <ole@monochrom.net>

- *

- * 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 <http://www.gnu.org/licenses/>.

- */

-#ifndef _GEM_PLOTTER_API_H_

-#define _GEM_PLOTTER_API_H_

-#include <stdlib.h>

-#include <stdbool.h>

-#include <stdio.h>

-#include <math.h>

-#include <assert.h>

-#include <string.h>

-#include <windom.h>

-

-#include "desktop/plotters.h"

-#include "desktop/plot_style.h"

-#include "image/bitmap.h"

-#include "atari/bitmap.h"

-#include "atari/osspec.h"

-#include "atari/gui.h"

-#include "atari/font.h"

-#include "desktop/options.h"

-#include "atari/findfile.h"

-#include "utils/utf8.h"

-#include "utils/log.h"

-

-#ifndef ceilf

-#warning "ceilf emulation"

-#define ceilf(x) (float)ceil((double)x)

-#endif

-

-#ifdef TEST_PLOTTER

-#define verbose_log 1

-#define LOG(x) do { if (verbose_log) (printf(__FILE__ " %s %i: ", __PRETTY_FUNCTION__, __LINE__), printf x, fputc('\n', stdout)); } while (0)

-#endif

-

-#define MAX_FRAMEBUFS 0x010

-#define C2P (1<<0)					/* C2P convert buffer 1 to buffer 2 */

-/* TODO: implement offscreen buffer switch */

-

-/* 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 */

-

-/* Grapics & Font Plotter "Objects": */

-typedef struct s_font_plotter * FONT_PLOTTER;

-typedef struct s_gem_plotter * GEM_PLOTTER;

-typedef struct s_font_plotter * GEM_FONT_PLOTTER; /* for public use ... */

-

-

-/* 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;

-	GEM_PLOTTER plotter;

-

-	_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;

-};

-

-

-struct rect;

-

-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	*/

-};

-

-

-/* declaration of plotter member functions ( _pmf_ prefix )*/

-typedef int (*_pmf_resize)(GEM_PLOTTER self, int w, int h);

-typedef	int (*_pmf_move)(GEM_PLOTTER self, short x, short y );

-typedef	void * (*_pmf_create_framebuffer)(GEM_PLOTTER self);

-typedef	void * (*_pmf_switch_to_framebuffer)(GEM_PLOTTER self);
-typedef	int (*_pmf_lock)(GEM_PLOTTER self);

-typedef	int (*_pmf_unlock)(GEM_PLOTTER self);

-typedef	int (*_pmf_put_pixel)(GEM_PLOTTER self, int x, int y, int color );

-typedef	int (*_pmf_copy_rect)(GEM_PLOTTER self, GRECT src, GRECT dst );

-typedef	int (*_pmf_set_clip)(GEM_PLOTTER self, const struct rect * clip );
-typedef	int (*_pmf_get_clip)(GEM_PLOTTER self, struct rect * clip_out );

-typedef	int (*_pmf_arc)(GEM_PLOTTER self, int x, int y, int radius, int angle1, int angle2, const plot_style_t * pstyle);

-typedef	int (*_pmf_disc)(GEM_PLOTTER self, int x, int y, int radius, const plot_style_t * pstyle);

-typedef	int (*_pmf_line)(GEM_PLOTTER self, int x0, int y0, int x1,	int y1, const plot_style_t * pstyle);

-typedef	int (*_pmf_rectangle)(GEM_PLOTTER self, int x0, int y0, int x1, int y1, const plot_style_t * pstyle);

-typedef	int (*_pmf_polygon)(GEM_PLOTTER self, const int *p, unsigned int n,  const plot_style_t * pstyle);

-typedef	int (*_pmf_path)(GEM_PLOTTER self, const float *p, unsigned int n, int fill, float width, int c, const float transform[6]);

-typedef	int (*_pmf_bitmap_resize) ( GEM_PLOTTER self, struct bitmap * bm, int nw, int nh );

-typedef int (*_pmf_bitmap_convert)( GEM_PLOTTER self, struct bitmap * img, int x, int y,
-				GRECT * clip, uint32_t bg, uint32_t flags, MFDB *out  );
-typedef	int (*_pmf_bitmap)(GEM_PLOTTER self, struct bitmap * bmp, int x, int y,

-				unsigned long bg, unsigned long flags );

-typedef int (*_pmf_plot_mfdb)(GEM_PLOTTER self, GRECT * loc, MFDB * mfdb, unsigned char fgcolor, uint32_t flags);

-typedef	int (*_pmf_text)(GEM_PLOTTER self, int x, int y, const char *text, size_t length, const plot_font_style_t *fstyle);
-typedef int (*_pmf_blit)(GEM_PLOTTER self, GRECT * region);

-typedef	int (*_pmf_dtor)(GEM_PLOTTER self);

-

-

-/* this is the prototype of an plotter "object" */

-struct s_gem_plotter

-{

-	char * name;         /* name that identifies the Plotter */

-	unsigned long flags;

-	int vdi_handle;

-	struct s_vdi_sysinfo * scr;

-	void * priv_data;

-	/* bit depth of framebuffers: */

-	int bpp_virt;

-

-	FONT_PLOTTER font_plotter;

-	/* set new dimensions (realloc memory): */

-	_pmf_resize resize;

-	/* set drawing origin: */

-	_pmf_move move;

-	_pmf_lock lock;

-	_pmf_unlock unlock;

-	_pmf_create_framebuffer create_framebuffer;

-	_pmf_switch_to_framebuffer switch_to_framebuffer;

-	_pmf_put_pixel put_pixel;

-	_pmf_copy_rect copy_rect;

-	_pmf_set_clip set_clip;
-	_pmf_get_clip get_clip;

-	_pmf_arc arc;

-	_pmf_disc disc;

-	_pmf_line line;

-	_pmf_rectangle rectangle;

-	_pmf_polygon polygon;

-	_pmf_path path;

-	/* scale an netsurf bitmap: */

-	_pmf_bitmap_resize bitmap_resize;
-	/* convert an ABGR (netsurf) bitmap to screen format, ready for vro_cpyfm */
-	_pmf_bitmap_convert bitmap_convert;

-	/* plot an netsurf bitmap into the buffer / screen: */

-	_pmf_bitmap bitmap;

-	/* plot an mfdb into the buffer / screen: */

-	_pmf_plot_mfdb plot_mfdb;
-	/* draw to screen, only valid for offscreen plotters: */
-	_pmf_blit blit;

-	_pmf_text text;

-	_pmf_dtor dtor;

-};

-

-

-/* these 2 structs hold info about an specific driver. */

-/* a table in plotter.c defines all the available plotters */

-struct s_driver_table_entry

-{
-
-	/* name (unique) */

-	char * name;

-
-	/* pointer to ctor of the plotter */
-	int (*ctor)( GEM_PLOTTER self, GRECT * log_isze );
-
-	/* a bitmask containing info about supported operations */

-	int flags;
-
-	/* the maximum supported screen depth of the plotter */

-	int max_bpp;

-};

-

-struct s_font_driver_table_entry

-{

-	const char * name;

-	int (*ctor)( FONT_PLOTTER self );

-	int flags;

-};

-

-typedef struct s_driver_table_entry * PLOTTER_INFO;

-typedef struct s_font_driver_table_entry * FONT_PLOTTER_INFO;

-

-/* get s_driver_table_entry from driver table */

-struct s_driver_table_entry * get_screen_driver_entry(char * name);

-

-/* get s_font_driver_table_entry from driver table */

-struct s_font_driver_table_entry * get_font_driver_entry(char * name);

-

-/* fill screen / sys info */

-struct s_vdi_sysinfo * read_vdi_sysinfo(short vdih, struct s_vdi_sysinfo * info );

-

-/*

-   Create an new plotter object

-   Error Values:

-      -1 no mem

-      -2 error configuring plotter

-      -3 Plotter not available

-*/

-GEM_PLOTTER new_plotter(int vdihandle, char * name,

-	GRECT *, int virt_bpp, unsigned long flags, FONT_PLOTTER font_renderer,

-	int * error);

-

-/*

-   Create an new font plotter object

-   Error Values:

-      -1 no mem

-      -2 error configuring font plotter

-      -3 Font Plotter not available

-*/

-FONT_PLOTTER new_font_plotter(int vdihandle, char * name, unsigned long flags, int * error );

-

-/* free the plotter resources */

-int delete_plotter( GEM_PLOTTER p );

-int delete_font_plotter( FONT_PLOTTER p );

-

-

-/* calculate size of intermediate buffer */

-int calc_chunked_buffer_size(int x, int y, int stride, int bpp);

-

-/* calculates the pixel offset from x,y pos */

-int get_pixel_offset( int x, int y, int stride, int bpp );

-

-/* translate an error number */

-const char* plotter_err_str(int i) ;

-

-void dump_font_drivers(void);

-void dump_plot_drivers(void);

-void dump_vdi_info(short);

-
-/* 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);

-

-/*

-	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 );

-

-/* shared / static methods follows */

-

-/*

-	Get clipping for current framebuffer

-*/

-int plotter_get_clip( GEM_PLOTTER self, struct rect * out );

-

-/*

-	Get clipping for current framebuffer as GRECT

-*/

-void plotter_get_clip_grect( GEM_PLOTTER self, GRECT * out );

-

-

-#define PLOTTER_IS_LOCKED(plotter) ( plotter->private_flags & PLOTTER_FLAG_LOCKED )

-

-

-/*
-	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 )
-
-#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/plot/plotter_gd.c b/atari/plot/plotter_gd.c
deleted file mode 100644
index 39b44be07..000000000
--- a/atari/plot/plotter_gd.c
+++ /dev/null
@@ -1,237 +0,0 @@
-/*

- * Copyright 2012 Ole Loots <ole@monochrom.net>

- *

- * 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 <http://www.gnu.org/licenses/>.

- */
-
-#ifdef WITH_GD_PLOTTER
-
-#include <stdlib.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <string.h>
-#include <math.h>
-#include <assert.h>
-#include <windom.h>

-#include <gd.h>
-
-#include "atari/plot/eddi.h"

-#include "atari/plot/plotter.h"
-#include "atari/plot/plotter_gd.h"
-
-#include "plotter.h"
-
-static int dtor( GEM_PLOTTER self );
-static int resize( GEM_PLOTTER self, int w, int h );
-static int move( GEM_PLOTTER self, short x, short y );
-static int lock( GEM_PLOTTER self );
-static int unlock( GEM_PLOTTER self );
-static int put_pixel(GEM_PLOTTER self, int x, int y, int color );
-static int copy_rect( GEM_PLOTTER self, GRECT src, GRECT dst );
-static int get_clip( GEM_PLOTTER instance, struct rect * clip);
-static int set_clip( GEM_PLOTTER instance, const struct rect * clip );
-static int arc(GEM_PLOTTER self,int x, int y, int radius, int angle1, int angle2, const plot_style_t * pstyle);
-static int disc(GEM_PLOTTER self,int x, int y, int radius, const plot_style_t * pstyle);
-static int line(GEM_PLOTTER self,int x0, int y0, int x1, int y1, const plot_style_t * pstyle);
-static int rectangle(GEM_PLOTTER self,int x0, int y0, int x1, int y1, const plot_style_t * pstyle);
-static int polygon(GEM_PLOTTER self,const int *p, unsigned int n, const plot_style_t * pstyle);
-static int path(GEM_PLOTTER self,const float *p, unsigned int n, int fill, float width, int c, const float transform[6]);
-static int bitmap_resize( GEM_PLOTTER self, struct bitmap * img, int nw, int nh );
-static int bitmap_convert( GEM_PLOTTER self, struct bitmap * img, int x, int y,
-	GRECT * clip,uint32_t bg,uint32_t flags, MFDB *out  );
-static int bitmap( GEM_PLOTTER self, struct bitmap * bmp, int x, int y,
-					unsigned long bg, unsigned long flags );
-static int plot_mfdb( GEM_PLOTTER self, GRECT * where, MFDB * mfdb, unsigned char fgcolor, uint32_t flags);
-static int text(GEM_PLOTTER self, int x, int y, const char *text,size_t length, const plot_font_style_t *fstyle);
-static int clip(GEM_PLOTTER self, const struct rect * clip);
-
-int ctor_plotter_gd( GEM_PLOTTER instance, GRECT * origin_size )
-{
-
-	instance->dtor = dtor;
-	instance->resize= resize;
-	instance->move = move;
-	instance->lock = lock;
-	instance->unlock = unlock;
-	instance->put_pixel = put_pixel;
-	instance->copy_rect = copy_rect;
-	instance->get_clip = get_clip;
-	instance->set_clip = set_clip;
-	instance->arc = arc;
-	instance->disc = disc;
-	instance->line = line;
-	instance->rectangle = rectangle;
-	instance->polygon = polygon;
-	instance->path = path;
-	instance->bitmap = bitmap;
-	instance->bitmap_resize = bitmap_resize;
-	instance->bitmap_convert = bitmap_convert;
-	instance->plot_mfdb = NULL;
-	instance->text = text;
-
-	instance->priv_data = malloc( sizeof(struct s_gd_priv_data) );
-	if( instance->priv_data == NULL )
-		return( 0-ERR_NO_MEM );
-	memset( instance->priv_data, 0, sizeof(struct s_gd_priv_data) );
-
-	// allocate framebuffer
-	THIS(instance)->vbuf = gdImageCreateTrueColor( origin_size->g_w,
-												origin_size->g_h );
-
-	THIS(instance)->origin_x = origin_size->g_x;
-	THIS(instance)->origin_y = origin_size->g_y;
-
-	return( 1 );
-}
-
-static int dtor( GEM_PLOTTER instance )
-{
-	int i;
-	free( instance->priv_data );
-	gdImageDestroy( THIS(instance)->vbuf );
-	return( 1 );
-}
-
-static int resize( GEM_PLOTTER instance, int w, int h )
-{
-	return( 1 );
-}
-
-static int move( GEM_PLOTTER instance, short x, short y )
-{
-	THIS(instance)->origin_x = x;
-	THIS(instance)->origin_y = y;
-	return( 1 );
-}
-
-static int lock( GEM_PLOTTER instance ){
-	instance->flags |= PLOT_FLAG_LOCKED;
-	return( 1 );
-}
-
-static int unlock( GEM_PLOTTER instance )
-{
-	instance->flags &=  ~PLOT_FLAG_LOCKED;
-	return( 1 );
-}
-
-static int put_pixel(GEM_PLOTTER instance, int x, int y, int color )
-{
-	gdImageSetPixel( THIS(instance)->vbuf, x, y, color );
-	return( 1 );
-}
-
-static int copy_rect( GEM_PLOTTER instance, GRECT src, GRECT dst )
-{
-	return( 1 );
-}
-
-static int arc(GEM_PLOTTER instance,int x, int y, int radius, int angle1, int angle2, const plot_style_t * pstyle)
-{
-	return( 1 );
-}
-
-static int disc(GEM_PLOTTER instance,int x, int y, int radius, const plot_style_t * pstyle)
-{
-	return( 1 );
-}
-
-static int line(GEM_PLOTTER instance,int x0, int y0, int x1, int y1, const plot_style_t * pstyle)
-{
-	int w = pstyle->stroke_width;
-	if( ((w % 2) == 0) || (w < 1) ){
-		w++;
-	}
-	gdImageSetThickness( THIS(instance)->vbuf, w );
-	// FIXME: set stroke style
-	//gdImageSetStyle( THIS(instance), style, nofpix );
-	gdImageLine( THIS(instance)->vbuf, x0, y0, x1, y1, pstyle->stroke_colour );
-	return( 1 );
-}
-
-static int rectangle(GEM_PLOTTER instance,int x0, int y0, int x1, int y1, const plot_style_t * pstyle)
-{
-	int lw = pstyle->stroke_width;
-
-	if( pstyle->fill_type != PLOT_OP_TYPE_NONE ){
-		gdImageFilledRectangle( THIS(instance)->vbuf,
-								x0, y0, x1, y1,
-								pstyle->fill_colour );
-	}
-
-	if( pstyle->stroke_type != PLOT_OP_TYPE_NONE ){
-		gdImageLine( THIS(instance)->vbuf,
-					x0, y0, x1, y1,
-					pstyle->stroke_colour );
-	}
-	return( 1 );
-}
-
-static int polygon(GEM_PLOTTER instance,const int *p, unsigned int n, const plot_style_t * pstyle)
-{
-	//gdImagePolygon( THIS(instance).vbuf, points, count, c );
-	return( 1 );
-}
-static int path(GEM_PLOTTER instance,const float *p, unsigned int n, int fill, float width, int c, const float transform[6])
-{
-	return( 1 );
-}
-
-static int bitmap_resize( GEM_PLOTTER instance, struct bitmap * img, int nw, int nh )
-{
-	return( 1 );
-}
-
-static int bitmap_convert( GEM_PLOTTER instance, struct bitmap * img, int x, int y,
-	GRECT * clip,uint32_t bg,uint32_t flags, MFDB *out  )
-{
-		return( 1 );
-}
-
-static int bitmap( GEM_PLOTTER instance, struct bitmap * bmp, int x, int y,
-					unsigned long bg, unsigned long flags )
-{
-	return( 1 );
-}
-
-static int plot_mfdb( GEM_PLOTTER instance, GRECT * where, MFDB * mfdb, unsigned char fgcolor, uint32_t flags)
-{
-	return( 1 );
-}
-
-static int text( GEM_PLOTTER instance, int x, int y, const char *text,size_t length, const plot_font_style_t *fstyle)
-{
-	return( 1 );
-}
-
-
-static int get_clip( GEM_PLOTTER instance, struct rect * clip)

-{
-	gdImageGetClip( THIS(instance)->vbuf,
-					&clip->x0, &clip->y0,
-					&clip->x0, &clip->y0 );
-	return( 1 );

-}
-
-static int set_clip( GEM_PLOTTER instance, const struct rect * clip )
-{
-	gdImageSetClip( THIS(instance)->vbuf, clip->x0,
-						clip->y0, clip->x1,
-						clip->y1 );

-	return ( 1 );
-}
-
-
-#endif
diff --git a/atari/plot/plotter_gd.h b/atari/plot/plotter_gd.h
deleted file mode 100644
index b449997d8..000000000
--- a/atari/plot/plotter_gd.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/*

- * Copyright 2012 Ole Loots <ole@monochrom.net>

- *

- * 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 <http://www.gnu.org/licenses/>.

- */

-#ifdef WITH_GD_PLOTTER
-#ifndef GEM_PLOTTER_GD_H_INCLUDED

-#define GEM_PLOTTER_GD_H_INCLUDED

-
-
-#include <gd.h>

-#include "plotter.h"
-

-struct s_gd_priv_data {
-	gdImagePtr vbuf;
-	int origin_x;
-	int origin_y;

-};

-

-/* this is an shortcut cast to access the members of the s_gd_priv_data */

-#define THIS(instance) ((struct s_gd_priv_data*)instance->priv_data)

-

-/* Each driver object must export 1 it's own constructor: */

-int ctor_plotter_gd( GEM_PLOTTER p, GRECT * loc_size );

-

-#endif

-#endif
diff --git a/atari/plot/plotter_vdi.c b/atari/plot/plotter_vdi.c
deleted file mode 100755
index 8b4550e80..000000000
--- a/atari/plot/plotter_vdi.c
+++ /dev/null
@@ -1,1713 +0,0 @@
-/*
- * Copyright 2010 Ole Loots <ole@monochrom.net>
- *
- * 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 <http://www.gnu.org/licenses/>.
- */
-#include <stdlib.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <string.h>
-#include <math.h>
-#include <assert.h>
-#include <windom.h>
-#include <Hermes/Hermes.h>

-

-#include "atari/plot/eddi.h"

-#include "atari/plot/plotter.h"

-#include "atari/plot/plotter_vdi.h"
-
-
-/* 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;\

-	}\
-
-static int dtor( GEM_PLOTTER self );
-static int resize( GEM_PLOTTER self, int w, int h );
-static int move( GEM_PLOTTER self, short x, short y );
-static int lock( GEM_PLOTTER self );
-static int unlock( GEM_PLOTTER self );
-static int put_pixel(GEM_PLOTTER self, int x, int y, int color );
-static int copy_rect( GEM_PLOTTER self, GRECT src, GRECT dst );
-static int set_clip(GEM_PLOTTER self, const struct rect * clip);
-static int get_clip( GEM_PLOTTER self, struct rect * out );
-static int arc(GEM_PLOTTER self,int x, int y, int radius, int angle1, int angle2, const plot_style_t * pstyle);
-static int disc(GEM_PLOTTER self,int x, int y, int radius, const plot_style_t * pstyle);
-static int line(GEM_PLOTTER self,int x0, int y0, int x1, int y1, const plot_style_t * pstyle);
-static int rectangle(GEM_PLOTTER self,int x0, int y0, int x1, int y1, const plot_style_t * pstyle);
-static int polygon(GEM_PLOTTER self,const int *p, unsigned int n, const plot_style_t * pstyle);
-static int path(GEM_PLOTTER self,const float *p, unsigned int n, int fill, float width, int c, const float transform[6]);
-static int bitmap_resize( GEM_PLOTTER self, struct bitmap * img, int nw, int nh );
-static int bitmap_convert( GEM_PLOTTER self, struct bitmap * img, int x, int y,
-	GRECT * clip,uint32_t bg,uint32_t flags, MFDB *out  );
-static int bitmap_convert_8( GEM_PLOTTER self, struct bitmap * img,int x, int y,
-	GRECT * clip,uint32_t bg,uint32_t flags, MFDB *out  );
-static int bitmap( GEM_PLOTTER self, struct bitmap * bmp, int x, int y,
-					unsigned long bg, unsigned long flags );
-static int plot_mfdb( GEM_PLOTTER self, GRECT * where, MFDB * mfdb, unsigned char fgcolor, uint32_t flags);
-static int text(GEM_PLOTTER self, int x, int y, const char *text,size_t length, const plot_font_style_t *fstyle);
-
-static inline void set_stdpx( MFDB * dst, int wdplanesz, int x, int y, unsigned char val );
-static inline unsigned char get_stdpx(MFDB * dst, int wdplanesz, int x, int y );
-
-/*

-	Set clipping for current framebuffer

-*/

-static int plotter_std_clip(GEM_PLOTTER self, const struct rect * clip);
-

-
-extern struct s_vdi_sysinfo vdi_sysinfo;

-

-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;
-
-#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];
-extern unsigned short vdi_web_pal[216][3];
-#endif
-
-
-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
-}
-
-static int set_clip(GEM_PLOTTER self, const struct rect * clip)

-{
-	// FIXME: consider the canvas size
-	VIEW( self ).clipping.x0 = clip->x0;

-	VIEW( self ).clipping.y0 = clip->y0;

-	VIEW( self ).clipping.x1 = clip->x1;

-	VIEW( self ).clipping.y1 = clip->y1;

-	return ( 1 );

-}
-
-static int get_clip( GEM_PLOTTER self, struct rect * out )

-{

-	out->x0 = VIEW( self ).clipping.x0;

-	out->y0 = VIEW( self ).clipping.y0;
-	out->x1 = VIEW( self ).clipping.x1;

-	out->y1 = VIEW( self ).clipping.y1;

-	return( 1 );

-}
-

-/*

-	Get current visible coords

-*/
-static inline void plotter_get_visible_grect( GEM_PLOTTER self, GRECT * out )

-{

-	out->g_x = VIEW( self ).vis_x;

-	out->g_y = VIEW( self ).vis_y;

-	out->g_w = VIEW( self ).vis_w;

-	out->g_h = VIEW( self ).vis_h;

-}
-
-

-/*

-	1. 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( GEM_PLOTTER p )

-{

-	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(p).x;

-	common.g_y = frame.g_y = VIEW(p).y;

-	common.g_w = frame.g_w = VIEW(p).w;

-	common.g_h = frame.g_h = VIEW(p).h;

-

-	if( rc_intersect( &screen, &common ) ) {

-		VIEW(p).vis_w = common.g_w;

-		VIEW(p).vis_h = common.g_h;

-		if( VIEW(p).x < screen.g_x )

-			VIEW(p).vis_x = frame.g_w - common.g_w;

-		else

-			VIEW(p).vis_x = 0;

-		if( VIEW(p).y <screen.g_y )

-			VIEW(p).vis_y = frame.g_h - common.g_h;

-		else

-			VIEW(p).vis_y = 0;

-	} else {

-		VIEW(p).vis_w = VIEW(p).vis_h = 0;

-		VIEW(p).vis_x = VIEW(p).vis_y = 0;

-	}

-}

-

-/*

-	Returns the visible parts of the box (relative coords within framebuffer),

-   	relative to screen coords (normally starting at 0,0 )

-*/

-static inline bool fbrect_to_screen( GEM_PLOTTER self, GRECT box, GRECT * ret )

-{

-	GRECT out, vis, screen;

-

-	screen.g_x = 0;

-	screen.g_y = 0;

-	screen.g_w = vdi_sysinfo.scr_w;

-	screen.g_h = vdi_sysinfo.scr_h;

-

-	/* get visible region: */

-    vis.g_x = VIEW(self).x;

-	vis.g_y = VIEW(self).y;

-	vis.g_w = VIEW(self).w;

-	vis.g_h = VIEW(self).h;

-

-	if ( !rc_intersect( &screen, &vis ) ) {

-		return( false );

-	}

-	vis.g_x = VIEW(self).w - vis.g_w;

-	vis.g_y = VIEW(self).h - vis.g_h;

-

-	/* clip box to visible region: */

-	if( !rc_intersect(&vis, &box) ) {

-		return( false );

-	}

-	out.g_x = box.g_x + VIEW(self).x;

-	out.g_y = box.g_y + VIEW(self).y;

-	out.g_w = box.g_w;

-	out.g_h = box.g_h;

-	*ret = out;

-	return ( true );

-}
-
-/*

-	convert framebuffer clipping to vdi clipping and activates it

-*/
-

-static inline void plotter_vdi_clip( GEM_PLOTTER self, bool set)

-{
-	return;

-	if( set == true ) {

-		struct rect c;

-		short vdiflags[58];

-		short newclip[4];
-		self->get_clip( self, &c );

-		vq_extnd( self->vdi_handle, 1, (short*)&vdiflags);

-		prev_vdi_clip[0] = vdiflags[45];

-		prev_vdi_clip[1] = vdiflags[46];

-		prev_vdi_clip[2] = vdiflags[47];

-		prev_vdi_clip[3] = vdiflags[48];

-		newclip[0] = VIEW(self).x + MAX(c.x0, 0);

-		newclip[1] = VIEW(self).y + MAX(c.y0, 0);

-		newclip[2] = MIN(VIEW(self).x+VIEW(self).w, newclip[0] + (c.x1 - c.x0) )-1;

-		newclip[3] = MIN(VIEW(self).y+VIEW(self).h, newclip[1] + (c.y1 - c.y0) )-1;

-		vs_clip( self->vdi_handle, 1, (short*)&newclip );

-	} else {

-		vs_clip( self->vdi_handle, 1, (short *)&prev_vdi_clip );

-	}

-}
-
-int ctor_plotter_vdi( GEM_PLOTTER self , GRECT * loc_size )
-{
-	int retval = 0;
-	int i;
-	struct rect clip;
-
-	self->dtor = dtor;
-	self->resize= resize;
-	self->move = move;
-	self->lock = lock;
-	self->unlock = unlock;
-	self->put_pixel = put_pixel;
-	self->copy_rect = copy_rect;
-	self->set_clip = set_clip;
-	self->get_clip = get_clip;
-	self->arc = arc;
-	self->disc = disc;
-	self->line = line;
-	self->rectangle = rectangle;
-	self->polygon = polygon;
-	self->path = path;
-	self->bitmap = bitmap;
-	self->bitmap_resize = bitmap_resize;
-	/* override virtual bpp - must be in sync with screen for this driver: 	*/
-	self->bpp_virt = app.nplanes;
-#ifdef WITH_8BPP_SUPPORT
-	self->bitmap_convert =(app.nplanes > 8) ? bitmap_convert : bitmap_convert_8;
-#else
-	self->bitmap_convert = bitmap_convert;
-#endif
-	self->plot_mfdb = plot_mfdb;
-	self->text = text;
-	LOG(("Screen: x: %d, y: %d\n", vdi_sysinfo.scr_w, vdi_sysinfo.scr_h));
-
-	self->priv_data = malloc( sizeof(struct s_vdi_priv_data) );
-	if( self->priv_data == NULL )
-		return( 0-ERR_NO_MEM );
-	memset( self->priv_data, 0, sizeof(struct s_vdi_priv_data) );
-	memset( &VIEW(self), 0, sizeof( struct s_view) );
-	VIEW( self ).x = loc_size->g_x;
-	VIEW( self ).y = loc_size->g_y;
-	VIEW( self ).w = loc_size->g_w;
-	VIEW( self ).h = loc_size->g_h;
-	DUMMY_PRIV(self)->bufops = 0;
-	DUMMY_PRIV(self)->size_buf_packed = 0;
-	DUMMY_PRIV(self)->size_buf_planar = 0;
-	DUMMY_PRIV(self)->buf_packed = NULL;
-	DUMMY_PRIV(self)->buf_planar = NULL;
-	if( vdi_sysinfo.vdiformat == VDI_FORMAT_PACK  ) {
-		self->bpp_virt = vdi_sysinfo.scr_bpp;
-	} else {
-		DUMMY_PRIV(self)->bufops = C2P;
-		self->bpp_virt = 8;
-	}
-
-	VIEW(self).mem = NULL;
-	update_visible_rect( self );
-
-	clip.x0 = 0;
-	clip.y0 = 0;
-	clip.x1 = VIEW(self).w;
-	clip.y1 = VIEW(self).h;
-	self->set_clip( self, &clip );
-
-	assert( Hermes_Init() );
-	/* store system palette & setup the new (web) palette: */
-#ifdef WITH_8BPP_SUPPORT
-	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(self->vdi_handle, i, 1, (unsigned short*)&sys_pal[i][0] );
-			if( i<OFFSET_WEB_PAL ) {
-				pal[i][0] = sys_pal[i][0];
-		 		pal[i][1] = sys_pal[i][1];
-				pal[i][2] = sys_pal[i][2];
-			} else if( app.nplanes >= 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( self->vdi_handle, i, &pal[i][0] );
-				}
-				if( i >= OFFSET_CUST_PAL && i<OFFSET_CUST_PAL+16 ) {
-					/* here we define 20 additional gray colors... */
-					rgbcol[1] = rgbcol[2] = rgbcol[3] = ((graytone&0x0F) << 4);
-					rgb_to_vdi1000( &rgbcol[0], &pal[i][0] );
-					vs_color( self->vdi_handle, i, &pal[i][0] );
-					graytone++;
-				}
-
-			}
-			vdi1000_to_rgb( &pal[i][0],  &rgb_lookup[i][0] );
-		}
-
-	} else {
-		/* no need to change the palette - its application specific */
-	}
-
-
-#endif
-
-	unsigned long flags = ( self->flags & PLOT_FLAG_DITHER ) ? HERMES_CONVERT_DITHER : 0;
-	hermes_cnv_h = Hermes_ConverterInstance( flags );
-	assert( hermes_cnv_h );
-	hermes_res_h = Hermes_ConverterInstance( flags );
-	assert( hermes_res_h );
-
-	/* set up the src & dst format: */
-	/* netsurf uses RGBA ... */
-	DUMMY_PRIV(self)->nsfmt.a = 0xFFUL;
-	DUMMY_PRIV(self)->nsfmt.b = 0x0FF00UL;
-	DUMMY_PRIV(self)->nsfmt.g = 0x0FF0000UL;
-	DUMMY_PRIV(self)->nsfmt.r = 0x0FF000000UL;
-	DUMMY_PRIV(self)->nsfmt.bits = 32;
-	DUMMY_PRIV(self)->nsfmt.indexed = false;
-	DUMMY_PRIV(self)->nsfmt.has_colorkey = false;
-
-	DUMMY_PRIV(self)->vfmt.r = vdi_sysinfo.mask_r;
-	DUMMY_PRIV(self)->vfmt.g = vdi_sysinfo.mask_g;
-	DUMMY_PRIV(self)->vfmt.b = vdi_sysinfo.mask_b;
-	DUMMY_PRIV(self)->vfmt.a = vdi_sysinfo.mask_a;
-	DUMMY_PRIV(self)->vfmt.bits = self->bpp_virt;
-	DUMMY_PRIV(self)->vfmt.indexed = ( app.nplanes <= 8 ) ? 1 : 0;
-	DUMMY_PRIV(self)->vfmt.has_colorkey = 0;
-
-	return( 1 );
-}
-
-static int dtor( GEM_PLOTTER self )
-{
-	int i=0;
-	LOG(("%s: %s\n", (char*)__FILE__, __FUNCTION__));
-
-	if( VIEW(self).mem )
-		free( VIEW(self).mem );
-
-#ifdef WITH_8BPP_SUPPORT
-	if( DUMMY_PRIV(self)->vfmt.indexed ){
-		for( i=OFFSET_WEB_PAL; i<OFFSET_CUST_PAL+16; i++){
-			vs_color( self->vdi_handle, i, &sys_pal[i][0] );
-		}
-	}
-#endif
-
-	/* close Hermes stuff: */
-	Hermes_ConverterReturn( hermes_cnv_h );
-
-	Hermes_Done();
-
-	if( self->priv_data != NULL ){
-		if( DUMMY_PRIV(self)->buf_packed )
-			free( DUMMY_PRIV(self)->buf_packed );
-		if( DUMMY_PRIV(self)->buf_planar )
-			free( DUMMY_PRIV(self)->buf_planar );
-		free( self->priv_data );
-	}
-	snapshot_destroy( self );
-	return( 1 );
-}
-
-static int resize( GEM_PLOTTER self, int w, int h )
-{
-	if( w == VIEW(self).w && h == VIEW(self).h )
-		return( 1 );
-	struct rect newclip = { 0, 0, w-1, h-1 };
-	VIEW(self).w = w;
-	VIEW(self).h = h;
-	update_visible_rect( self );
-	set_clip( self, &newclip);
-	LOG(("%s: %s\n", (char*)__FILE__, (char*)__FUNCTION__));
-	return( 1 );
-}
-static int move( GEM_PLOTTER self,short x, short y )
-{
-	bool upd;
-	if(x == VIEW(self).x && y == VIEW(self).y ){
-		return 1;
-	}
-	LOG(("%s: x: %d, y: %d\n",(char*)__FUNCTION__, x, y));
-	VIEW(self).x = x;
-	VIEW(self).y = y;
-	update_visible_rect( self );
-	return( 1 );
-}
-
-
-static int lock( GEM_PLOTTER self )
-{
-	LOG(("%s: %s\n", (char*)__FILE__, __FUNCTION__));
-	if( (self->flags & PLOT_FLAG_LOCKED) != 0 )
-		return(1);
-	self->flags |= PLOT_FLAG_LOCKED;
-	if( !wind_update(BEG_UPDATE|0x100) )
-		return(0);
-	if( !wind_update(BEG_MCTRL|0x100) ){
-		wind_update(END_UPDATE);
-		return(0);
-	}
-	graf_mouse(M_OFF, NULL);
-	return( 1 );
-}
-
-static int unlock( GEM_PLOTTER self )
-{
-	LOG(("%s: %s\n", (char*)__FILE__, __FUNCTION__));
-	if( (self->flags & PLOT_FLAG_LOCKED) == 0 )
-		return(1);
-	self->flags &=  ~PLOT_FLAG_LOCKED;
-	wind_update(END_MCTRL);
-	wind_update(END_UPDATE);
-	graf_mouse(M_ON, NULL);
-	return( 1 );
-}
-
-static int put_pixel(GEM_PLOTTER self, int x, int y, int color )
-{
-   LOG(("%s: %s\n", (char*)__FILE__, __FUNCTION__));
-   return( 1 );
-}
-
-/* copy an rectangle from the plot buffer to screen */
-/* because this is an on-screen plotter, this is an screen to screen copy. */
-static int copy_rect( GEM_PLOTTER self, GRECT src, GRECT dst )
-{
-	MFDB devmf;
-	MFDB scrmf;
-	short pxy[8];
-	GRECT vis;
-
-	/* clip to visible rect, only needed for onscreen renderer: */
-	plotter_get_visible_grect( self, &vis );
-
-	if( !rc_intersect(&vis, &src) )
-		return 1;
-	if( !rc_intersect(&vis, &dst) )
-		return 1;
-
-	src.g_x = VIEW(self).x + src.g_x;
-	src.g_y = VIEW(self).y + src.g_y;
-	dst.g_x = VIEW(self).x + dst.g_x;
-	dst.g_y = VIEW(self).y + dst.g_y;
-
-	devmf.fd_addr = NULL;
-	devmf.fd_w = src.g_w;
-	devmf.fd_h = src.g_h;
-	devmf.fd_wdwidth = 0;
-	devmf.fd_stand = 0;
-	devmf.fd_nplanes = 0;
-	devmf.fd_r1 = devmf.fd_r2 = devmf.fd_r3 = 0;
-
-	scrmf.fd_addr = NULL;
-	scrmf.fd_w = dst.g_w;
-	scrmf.fd_h = dst.g_h;
-	scrmf.fd_wdwidth = 0 ;
-	scrmf.fd_stand = 0;
-	scrmf.fd_nplanes = 0;
-	scrmf.fd_r1 = scrmf.fd_r2 = scrmf.fd_r3 = 0;
-
-	pxy[0] = src.g_x;
-	pxy[1] = src.g_y;
-	pxy[2] = pxy[0] + src.g_w-1;
-	pxy[3] = pxy[1] + src.g_h-1;
-	pxy[4] = dst.g_x;
-	pxy[5] = dst.g_y;
-	pxy[6] = pxy[4] + dst.g_w-1;
-	pxy[7] = pxy[5] + dst.g_h-1;
-	self->lock( self );
-	vro_cpyfm( self->vdi_handle, S_ONLY, (short*)&pxy, &devmf,  &scrmf);
-	self->unlock( self );
-
-	return( 1 );
-}
-
-static int arc(GEM_PLOTTER self,int x, int y, int radius, int angle1, int angle2, const plot_style_t * pstyle)
-{
-	//plotter_vdi_clip( self, 1);
-	vswr_mode( self->vdi_handle, MD_REPLACE );
-	if( pstyle->fill_type == PLOT_OP_TYPE_NONE )
-		return 1;
-	if( pstyle->fill_type != PLOT_OP_TYPE_SOLID) {
-		vsl_rgbcolor( self->vdi_handle, pstyle->stroke_colour);
-		vsf_perimeter( self->vdi_handle, 1);
-		vsf_interior( self->vdi_handle, 1 );
-		v_arc( self->vdi_handle, VIEW(self).x + x, VIEW(self).y + y, radius, angle1*10, angle2*10 );
-	} else {
-		vsf_rgbcolor( self->vdi_handle, pstyle->fill_colour);
-		vsl_width( self->vdi_handle, 1 );
-		vsf_perimeter( self->vdi_handle, 1);
-		v_arc( self->vdi_handle, VIEW(self).x + x, VIEW(self).y + y, radius, angle1*10, angle2*10 );
-	}
-	//plotter_vdi_clip( self, 0);
-	return ( 1 );
-}
-
-static int disc(GEM_PLOTTER self,int x, int y, int radius, const plot_style_t * pstyle)
-{
-	plotter_vdi_clip( self, 1);
-	if( pstyle->fill_type != PLOT_OP_TYPE_SOLID) {
-		vsf_rgbcolor( self->vdi_handle, pstyle->stroke_colour );
-		vsf_perimeter( self->vdi_handle, 1);
-		vsf_interior( self->vdi_handle, 0 );
-		v_circle( self->vdi_handle, VIEW(self).x + x, VIEW(self).y + y, radius  );
-	} else {
-		vsf_rgbcolor( self->vdi_handle, pstyle->fill_colour );
-		vsf_perimeter( self->vdi_handle, 0);
-		vsf_interior( self->vdi_handle, FIS_SOLID );
-		v_circle( self->vdi_handle, VIEW(self).x + x, VIEW(self).y + y, radius  );
-	}
-	plotter_vdi_clip( self, 0);
-	return ( 1 );
-}
-
-
-static int line(GEM_PLOTTER self,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(self).x + x0;
-	pxy[1] = VIEW(self).y + y0;
-	pxy[2] = VIEW(self).x + x1;
-	pxy[3] = VIEW(self).y + y1;
-
-	plotter_vdi_clip( self, 1);
-	if( sw == 0)
-		sw = 1;
-	NSLT2VDI(lt, pstyle)
-	vsl_type( self->vdi_handle, (lt&0x0F) );
-	/* if the line style is not available within VDI system,define own style: */
-	if( (lt&0x0F) == 7 ){
-		vsl_udsty(self->vdi_handle, ((lt&0xFFFF00) >> 8) );
-	}
-	vsl_width( self->vdi_handle, (short)sw );
-	vsl_rgbcolor( self->vdi_handle, pstyle->stroke_colour );
-	v_pline(self->vdi_handle, 2, (short *)&pxy );
-	plotter_vdi_clip( self, 0);
-   return ( 1 );
-}
-
-static int rectangle(GEM_PLOTTER self,int x0, int y0, int x1, int y1,  const plot_style_t * pstyle)
-{
-	short pxy[4];
-	GRECT r, rclip, sclip;
-	int sw = pstyle->stroke_width;
-	uint32_t lt;
-
-	/* current canvas clip: */
-	rclip.g_x = VIEW( self ).clipping.x0;
-	rclip.g_y = VIEW( self ).clipping.y0;
-	rclip.g_w = VIEW( self ).clipping.x1 - VIEW( self ).clipping.x0;
-	rclip.g_h = VIEW( self ).clipping.y1 - VIEW( self ).clipping.y0;
-
-	/* physical clipping: */
-	sclip.g_x = rclip.g_x;
-	sclip.g_y = rclip.g_y;
-	sclip.g_w = VIEW(self).vis_w;
-	sclip.g_h = VIEW(self).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( 1 );
-	}
-	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( self->vdi_handle, (lt&0x0F) );
-		/*
-			if the line style is not available within VDI system,
-			define own style:
-		*/
-		if( (lt&0x0F) == 7 ){
-			vsl_udsty(self->vdi_handle, ((lt&0xFFFF00) >> 8) );
-		}
-		vsl_width( self->vdi_handle, (short)sw );
-		vsl_rgbcolor( self->vdi_handle, pstyle->stroke_colour );
-		/* top border: */
-		if( r.g_y == y0){
-			pxy[0] = VIEW(self).x + r.g_x;
-			pxy[1] = VIEW(self).y + r.g_y ;
-			pxy[2] = VIEW(self).x + r.g_x + r.g_w;
-			pxy[3] = VIEW(self).y + r.g_y;
-			v_pline(self->vdi_handle, 2, (short *)&pxy );
-		}
-
-		/* right border: */
-		if( r.g_x + r.g_w == x1 ){
-			pxy[0] = VIEW(self).x + r.g_x + r.g_w;
-			pxy[1] = VIEW(self).y + r.g_y;
-			pxy[2] = VIEW(self).x + r.g_x + r.g_w;
-			pxy[3] = VIEW(self).y + r.g_y + r.g_h;
-			v_pline(self->vdi_handle, 2, (short *)&pxy );
-		}
-
-		/* bottom border: */
-		if( r.g_y+r.g_h == y1 ){
-			pxy[0] = VIEW(self).x + r.g_x;
-			pxy[1] = VIEW(self).y + r.g_y+r.g_h;
-			pxy[2] = VIEW(self).x + r.g_x+r.g_w;
-			pxy[3] = VIEW(self).y + r.g_y+r.g_h;
-			v_pline(self->vdi_handle, 2, (short *)&pxy );
-		}
-
-		/* left border: */
-		if( r.g_x == x0 ){
-			pxy[0] = VIEW(self).x + r.g_x;
-			pxy[1] = VIEW(self).y + r.g_y;
-			pxy[2] = VIEW(self).x + r.g_x;
-			pxy[3] = VIEW(self).y + r.g_y + r.g_h;
-			v_pline(self->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( self->vdi_handle, pstyle->fill_colour );
-		vsf_perimeter( self->vdi_handle, 0);
-		vsf_interior( self->vdi_handle, FIS_SOLID );
-
-
-		pxy[0] = VIEW(self).x + r.g_x + stroke_width;
-		pxy[1] = VIEW(self).y + r.g_y + stroke_width;
-		pxy[2] = VIEW(self).x + r.g_x + r.g_w -1 - stroke_width ;
-		pxy[3] = VIEW(self).y + r.g_y + r.g_h -1 - stroke_width;
-
-		vsf_style( self->vdi_handle, 1);
-		v_bar( self->vdi_handle, (short*)&pxy );
-	}
-
-	return ( 1 );

-}

-

-static int polygon(GEM_PLOTTER self,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( self, 1);

-	vsf_interior( self->vdi_handle, FIS_SOLID );

-	vsf_style( self->vdi_handle, 1);

-	for( i = 0; i<n*2; i=i+2 ) {

-		pxy[i] = (short)VIEW(self).x+p[i];

-		pxy[i+1] = (short)VIEW(self).y+p[i+1];

-	}

-	if( pstyle->fill_type == PLOT_OP_TYPE_SOLID){

-		vsf_rgbcolor( self->vdi_handle, pstyle->fill_colour);

-		v_fillarea(self->vdi_handle, n, (short*)&pxy);

-

-	} else {

-		pxy[n*2]=pxy[0];

-		pxy[n*2+1]=pxy[1];

-		vsl_rgbcolor( self->vdi_handle, pstyle->stroke_colour);

-		v_pline(self->vdi_handle, n+1,  (short *)&pxy );

-	}

-	plotter_vdi_clip( self, 0);

-	return ( 1 );

-}

-

-static int path(GEM_PLOTTER self,const float *p, unsigned int n, int fill, float width,

-			int c, const float transform[6])

-{
-	LOG(("%s: %s\n", (char*)__FILE__, __FUNCTION__));

-	return ( 1 );

-}

-

-

-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;

-}

-

-static int bitmap_resize( GEM_PLOTTER self, 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,

-			&DUMMY_PRIV(self)->nsfmt,

-			&DUMMY_PRIV(self)->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( GEM_PLOTTER self, 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( DUMMY_PRIV(self)->size_buf_scr == 0 ){
-			/* init screen mfdb */
-			DUMMY_PRIV(self)->buf_scr.fd_addr = malloc( scr_size );
-			DUMMY_PRIV(self)->size_buf_scr = scr_size;
-		} else {
-			if( scr_size > DUMMY_PRIV(self)->size_buf_scr ) {
-				DUMMY_PRIV(self)->buf_scr.fd_addr = realloc(
-					DUMMY_PRIV(self)->buf_scr.fd_addr, scr_size
-				);
-				DUMMY_PRIV(self)->size_buf_scr = scr_size;
-			}
-		}
-		if( DUMMY_PRIV(self)->buf_scr.fd_addr == NULL ) {
-			DUMMY_PRIV(self)->size_buf_scr = 0;
-			return( NULL );
-		}
-		DUMMY_PRIV(self)->buf_scr.fd_nplanes = vdi_sysinfo.scr_bpp;
-		DUMMY_PRIV(self)->buf_scr.fd_w = scr_stride;
-		DUMMY_PRIV(self)->buf_scr.fd_h = h;
-		DUMMY_PRIV(self)->buf_scr.fd_wdwidth = scr_stride >> 4;
-		assert( DUMMY_PRIV(self)->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(
-			self->vdi_handle, S_ONLY, (short*)&pxy,
-			&scr,  &DUMMY_PRIV(self)->buf_scr
-	);
-
-	return( &DUMMY_PRIV(self)->buf_scr );
-}
-
-// create snapshot, vdi std. format
-static MFDB * snapshot_create_std_mfdb(GEM_PLOTTER self, 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( DUMMY_PRIV(self)->size_buf_std == 0 ){
-			/* init screen mfdb */
-			DUMMY_PRIV(self)->buf_std.fd_addr = malloc( scr_size );
-			DUMMY_PRIV(self)->size_buf_std = scr_size;
-		} else {
-			if( scr_size > DUMMY_PRIV(self)->size_buf_std ) {
-				DUMMY_PRIV(self)->buf_std.fd_addr = realloc(
-					DUMMY_PRIV(self)->buf_std.fd_addr, scr_size
-				);
-				DUMMY_PRIV(self)->size_buf_std = scr_size;
-			}
-		}
-		if( DUMMY_PRIV(self)->buf_std.fd_addr == NULL ) {
-			DUMMY_PRIV(self)->size_buf_std = 0;
-			return( NULL );
-		}
-		DUMMY_PRIV(self)->buf_std.fd_nplanes = app.nplanes;
-		DUMMY_PRIV(self)->buf_std.fd_w = scr_stride;
-		DUMMY_PRIV(self)->buf_std.fd_h = h;
-		DUMMY_PRIV(self)->buf_std.fd_stand = 1;
-		DUMMY_PRIV(self)->buf_std.fd_wdwidth = scr_stride >> 4;
-		assert( DUMMY_PRIV(self)->buf_std.fd_addr != NULL );
-	}
-	MFDB * native = snapshot_create_native_mfdb( self, x,y,w,h );
-	assert( native );
-
-	vr_trnfm( self->vdi_handle, native, &DUMMY_PRIV(self)->buf_std );
-	return( &DUMMY_PRIV(self)->buf_std );
-}
-
-/*
-	This will create an snapshot of the screen in netsurf ABGR format
-*/
-
-static struct bitmap * snapshot_create(GEM_PLOTTER self, 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( self, x, y, w, h );
-
-	if( DUMMY_PRIV(self)->vfmt.bits == 32 )
-		goto no_copy;
-
-	/* allocate buffer for result bitmap: */
-	if( DUMMY_PRIV(self)->buf_scr_compat == NULL ) {
-		DUMMY_PRIV(self)->buf_scr_compat = bitmap_create(w, h, 0);
-	} else {
-		DUMMY_PRIV(self)->buf_scr_compat = bitmap_realloc( w, h,
-			DUMMY_PRIV(self)->buf_scr_compat->bpp,
-			w * DUMMY_PRIV(self)->buf_scr_compat->bpp,
-			BITMAP_GROW,
-			DUMMY_PRIV(self)->buf_scr_compat );
-	}
-
-	/* convert screen buffer to ns format: */
-	err = Hermes_ConverterRequest( hermes_cnv_h,
-			&DUMMY_PRIV(self)->vfmt,
-			&DUMMY_PRIV(self)->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 */
-		DUMMY_PRIV(self)->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(DUMMY_PRIV(self)->buf_scr_compat) /* stride as bytes */
-	);
-	assert( err != 0 );
-	return( (struct bitmap * )DUMMY_PRIV(self)->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<h; row++ ){
-		// fd_w matches stride!
-		uint32_t *rowptr = ((uint32_t*)native->fd_addr + ((row*native->fd_w)));
-		for( col=0; col<w; col++){
-			*(rowptr+col) = (*(rowptr+col)<<8);
-		}
-	}
-	return( &snapshot );
-}
-
-static void snapshot_suspend(GEM_PLOTTER self )
-{
-	if( DUMMY_PRIV(self)->size_buf_scr > CONV_KEEP_LIMIT  ) {
-		DUMMY_PRIV(self)->buf_scr.fd_addr = realloc(
-			DUMMY_PRIV(self)->buf_scr.fd_addr, CONV_KEEP_LIMIT
-		);
-		if( DUMMY_PRIV(self)->buf_scr.fd_addr != NULL ) {
-			DUMMY_PRIV(self)->size_buf_scr = CONV_KEEP_LIMIT;
-		} else {
-			DUMMY_PRIV(self)->size_buf_scr = 0;
-		}
-	}
-
-	if( DUMMY_PRIV(self)->size_buf_std > CONV_KEEP_LIMIT  ) {
-		DUMMY_PRIV(self)->buf_std.fd_addr = realloc(
-			DUMMY_PRIV(self)->buf_std.fd_addr, CONV_KEEP_LIMIT
-		);
-		if( DUMMY_PRIV(self)->buf_std.fd_addr != NULL ) {
-			DUMMY_PRIV(self)->size_buf_std = CONV_KEEP_LIMIT;
-		} else {
-			DUMMY_PRIV(self)->size_buf_std = 0;
-		}
-	}
-
-	if( DUMMY_PRIV(self)->buf_scr_compat != NULL ) {
-		size_t bs = bitmap_buffer_size( DUMMY_PRIV(self)->buf_scr_compat );
-		if( bs > CONV_KEEP_LIMIT ) {
-			int w = 0;
-			int h = 1;
-			w = (CONV_KEEP_LIMIT / DUMMY_PRIV(self)->buf_scr_compat->bpp);
-			assert( CONV_KEEP_LIMIT == w*DUMMY_PRIV(self)->buf_scr_compat->bpp );
-			DUMMY_PRIV(self)->buf_scr_compat = bitmap_realloc( w, h,
-				DUMMY_PRIV(self)->buf_scr_compat->bpp,
-				CONV_KEEP_LIMIT, BITMAP_SHRINK, DUMMY_PRIV(self)->buf_scr_compat
-			);
-		}
-	}
-}
-
-static void snapshot_destroy( GEM_PLOTTER self )
-{
-
-	free( DUMMY_PRIV(self)->buf_scr.fd_addr  );
-	if( DUMMY_PRIV(self)->buf_scr_compat != NULL ) {
-		bitmap_destroy( DUMMY_PRIV(self)->buf_scr_compat );
-	}
-
-	DUMMY_PRIV(self)->buf_scr.fd_addr = NULL;
-	DUMMY_PRIV(self)->buf_scr_compat = NULL;
-
-#ifdef WITH_8BPP_SUPPORT
-	free( DUMMY_PRIV(self)->buf_std.fd_addr  );
-	DUMMY_PRIV(self)->buf_std.fd_addr = NULL;
-#endif
-}
-
-
-#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 );
-}
-
-static int bitmap_convert_8( GEM_PLOTTER self, 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( ( (self->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) * self->bpp_virt );
-		if( dstsize > DUMMY_PRIV(self)->size_buf_packed) {
-			int blocks = (dstsize / (CONV_BLOCK_SIZE-1))+1;
-			if( DUMMY_PRIV(self)->buf_packed == NULL )
-				DUMMY_PRIV(self)->buf_packed =(void*)malloc( blocks * CONV_BLOCK_SIZE );
-			 else
-				DUMMY_PRIV(self)->buf_packed =(void*)realloc(
-														DUMMY_PRIV(self)->buf_packed,
-														blocks * CONV_BLOCK_SIZE
-													);
-			assert( DUMMY_PRIV(self)->buf_packed );
-			if( DUMMY_PRIV(self)->buf_packed == NULL ) {
-				return( 0-ERR_NO_MEM );
-			}
-			DUMMY_PRIV(self)->size_buf_packed = blocks * CONV_BLOCK_SIZE;
-		}
-		native.fd_addr = DUMMY_PRIV(self)->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) * self->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( self, x, y, clip->g_w,
-												clip->g_h );
-		stdform.fd_addr = bg->fd_addr;
-		bh = clip->g_h;
-	} else {
-		if( dstsize > DUMMY_PRIV(self)->size_buf_planar) {
-			int blocks = (dstsize / (CONV_BLOCK_SIZE-1))+1;
-			if( DUMMY_PRIV(self)->buf_planar == NULL )
-				DUMMY_PRIV(self)->buf_planar =(void*)malloc( blocks * CONV_BLOCK_SIZE );
-			 else
-				DUMMY_PRIV(self)->buf_planar =(void*)realloc(
-														DUMMY_PRIV(self)->buf_planar,
-														blocks * CONV_BLOCK_SIZE
-													);
-			assert( DUMMY_PRIV(self)->buf_planar );
-			if( DUMMY_PRIV(self)->buf_planar == NULL ) {
-				return( 0-ERR_NO_MEM );
-			}
-			DUMMY_PRIV(self)->size_buf_planar = blocks * CONV_BLOCK_SIZE;
-		}
-		stdform.fd_addr = DUMMY_PRIV(self)->buf_planar;
-	}
-	stdform.fd_w = dststride;
-	stdform.fd_h = bh;
-	stdform.fd_wdwidth = dststride >> 4;
-	stdform.fd_stand = 1;
-	stdform.fd_nplanes = (short)self->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; y<clip->g_h; y++ ){
-			row = (uint32_t *)(img->pixdata + (img_stride * (y+clip->g_y)));
-			for( x=0; x<clip->g_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)self->bpp_virt;
-	native.fd_r1 = native.fd_r2 = native.fd_r3 = 0;
-	vr_trnfm( self->vdi_handle, &stdform, &native );
-	*out = native;
-	if( cache == true ){
-		img->native = native;
-		img->converted = true;
-	}
-
-	return(0);
-}
-#endif
-
-/*
-	Aplha blends the foreground image (img) onto the
-	background images (bg). The background receives the blended
-	image pixels.
-*/
-static int 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( 0 );
-}
-
-/*
-	Alpha blends an image, using one pixel as the background.
-	The bitmap receives the result.
-*/
-static int 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( 0 );
-}
-
-/*
-*
-* Convert bitmap to the native screen format
-*	self: 	the plotter instance
-*	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 int bitmap_convert( GEM_PLOTTER self, 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( ( (self->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(self, 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, &region );
-			source = img;
-		}
-	} else {
-		source = img;
-	}

-	/* (re)allocate buffer for converted image: */

-	dststride = MFDB_STRIDE( bw );

-	dstsize = ( ((dststride >> 3) * bh) * self->bpp_virt );
-	if( cache == false ){

-		if( dstsize > DUMMY_PRIV(self)->size_buf_packed) {

-			int blocks = (dstsize / (CONV_BLOCK_SIZE-1))+1;

-			if( DUMMY_PRIV(self)->buf_packed == NULL )

-				DUMMY_PRIV(self)->buf_packed =(void*)malloc( blocks * CONV_BLOCK_SIZE );

-			 else

-				DUMMY_PRIV(self)->buf_packed =(void*)realloc(

-														DUMMY_PRIV(self)->buf_packed,

-														blocks * CONV_BLOCK_SIZE

-													);

-			assert( DUMMY_PRIV(self)->buf_packed );

-			if( DUMMY_PRIV(self)->buf_packed == NULL ) {

-				if( scrbuf != NULL )

-					bitmap_destroy( scrbuf );

-				return( 0-ERR_NO_MEM );

-			}

-			DUMMY_PRIV(self)->size_buf_packed = blocks * CONV_BLOCK_SIZE;

-		}
-		out->fd_addr = DUMMY_PRIV(self)->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)self->bpp_virt;

-	out->fd_r1 = out->fd_r2 = out->fd_r3 = 0;

-

-	err = Hermes_ConverterRequest(

-			hermes_cnv_h,

-			&DUMMY_PRIV(self)->nsfmt,

-			&DUMMY_PRIV(self)->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) *  self->bpp_virt 			/* stride as bytes */

-	);
-	assert( err != 0 );
-
-	if( cache == true ){
-		img->native = *out;
-		img->converted = true;
-	}

-	return( 0 );

-

-}

-

-static void convert_bitmap_done( GEM_PLOTTER self )

-{

-	if( DUMMY_PRIV(self)->size_buf_packed > CONV_KEEP_LIMIT ) {

-		/* free the mem if it was an large allocation ... */

-		DUMMY_PRIV(self)->buf_packed = realloc( DUMMY_PRIV(self)->buf_packed, CONV_KEEP_LIMIT );

-		DUMMY_PRIV(self)->size_buf_packed = CONV_KEEP_LIMIT;

-	}

-	snapshot_suspend( self );

-}

-

-

-static int bitmap( GEM_PLOTTER self, 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( self ).clipping.x0;

-	clip.g_y = VIEW( self ).clipping.y0;

-	clip.g_w = VIEW( self ).clipping.x1 - VIEW( self ).clipping.x0;

-	clip.g_h = VIEW( self ).clipping.y1 - VIEW( self ).clipping.y0;

-

-	if( !rc_intersect( &clip, &off) ) {

-		return( 1 );

-	}
-
-	// clip the visible rectangle of the plot area
-	// this is the area of the plotter which falls into
-	// screen region:

-	plotter_get_visible_grect( self, &vis );
-	if( !rc_intersect( &vis, &off) ) {

-		return( 1 );

-	}

-
-	screen_x = VIEW(self).x + off.g_x;
-	screen_y = VIEW(self).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( self->bitmap_convert( self, bmp, screen_x, screen_y, &off, bg, flags, &src_mf) != 0 ) {

-		return( 1 );

-	}
-

-	// 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( self->vdi_handle, S_ONLY, (short*)&pxy, &src_mf,  &scrmf);

-	convert_bitmap_done( self );

-	return( 1 );

-}

-

-static int plot_mfdb (GEM_PLOTTER self, 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( self, &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( DUMMY_PRIV(self)->size_buf_scr == 0 ){

-			DUMMY_PRIV(self)->buf_scr.fd_addr = malloc( size );

-			DUMMY_PRIV(self)->size_buf_scr = size;

-		} else {

-			if( size > DUMMY_PRIV(self)->size_buf_scr ) {

-				DUMMY_PRIV(self)->buf_scr.fd_addr = realloc(

-					DUMMY_PRIV(self)->buf_scr.fd_addr, size

-				);

-				DUMMY_PRIV(self)->size_buf_scr = size;

-			}

-		}

-		tran.fd_addr = DUMMY_PRIV(self)->buf_scr.fd_addr;

-		vr_trnfm( self->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(self).x + off.g_x;

-	pxy[5] = VIEW(self).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( self->vdi_handle, MD_TRANS, (short*)pxy, src, &screen, (short*)&c );

-	} else {

-		/* this method only plots transparent bitmaps, right now... */

-	}

-	return( 1 );

-}

-

-static int text(GEM_PLOTTER self, int x, int y, const char *text, size_t length, const plot_font_style_t *fstyle)

-{

-	self->font_plotter->text( self->font_plotter, x, y,

-		text, length, fstyle

-	);

-	return ( 1 );

-}

diff --git a/atari/plot/plotter_vdi.h b/atari/plot/plotter_vdi.h
deleted file mode 100755
index 0dd8dcb17..000000000
--- a/atari/plot/plotter_vdi.h
+++ /dev/null
@@ -1,109 +0,0 @@
-/*

- * Copyright 2010 Ole Loots <ole@monochrom.net>

- *

- * 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 <http://www.gnu.org/licenses/>.

- */

-#ifndef GEM_PLOTTER_DUMMY_H_INCLUDED

-#define GEM_PLOTTER_DUMMY_H_INCLUDED

-

-#include "plotter.h"

-#include <Hermes/Hermes.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;		/*  												*/
-	struct rect clipping;

-	int size;

-	bool swapped;

-	void * mem;

-};

-

-struct s_vdi_priv_data {

-	short bufops;
-	/* temp buffer for bitmap conversion: */

-	void * buf_packed;

-	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: */
-	MFDB buf_scr;
-	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 */

-	HermesFormat vfmt;
-
-	/* no screen format here, hermes may not suitable for it */
-
-	/* netsurf source bitmap format */

-	HermesFormat nsfmt;
-
-	/* Some internal structure used everywhere 								*/
-	/* trying to describe screen position, plotting origins and maxmimum 	*/
-	/* extent. 																*/
-	struct s_view  view;

-};

-
-/* 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

-

-/* this is an shortcut cast to access the members of the s_vdi_priv_data */

-#define DUMMY_PRIV(_self) ((struct s_vdi_priv_data*)_self->priv_data)
-
-#define VIEW( priv ) DUMMY_PRIV( priv )->view

-

-/* Each driver object must export 1 it's own constructor: */

-int ctor_plotter_vdi( GEM_PLOTTER p, GRECT * loc_size );

-

-/*

-* 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(GEM_PLOTTER self, 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(GEM_PLOTTER self );

-

-/* destroy memory used by screenshot */

-static void snapshot_destroy( GEM_PLOTTER self );

-

-#endif