--- parser3/src/classes/image.C	2001/04/28 08:43:47	1.22
+++ parser3/src/classes/image.C	2001/12/17 14:02:44	1.63
@@ -1,11 +1,20 @@
+123
 /** @file
 	Parser: @b image parser class.
 
 	Copyright(c) 2001 ArtLebedev Group(http://www.artlebedev.com)
+	Author: Alexander Petrosyan <paf@design.ru>(http://paf.design.ru)
 
-	Author: Alexander Petrosyan <paf@design.ru>(http://design.ru/paf)
+	$Id: image.C,v 1.63 2001/12/17 14:02:44 paf Exp $
+*/
 
-	$Id: image.C,v 1.22 2001/04/28 08:43:47 paf Exp $
+/*
+	jpegsize: gets the width and height (in pixels) of a jpeg file
+	Andrew Tong, werdna@ugcs.caltech.edu           February 14, 1995
+	modified slightly by alex@ed.ac.uk
+	and further still by rjray@uswest.com
+	optimization and general re-write from tmetro@vl.com
+	from perl by paf@design.ru
 */
 
 #include "pa_config_includes.h"
@@ -25,21 +34,22 @@
 
 class MImage : public Methoded {
 public: // VStateless_class
-	
 	Value *create_new_value(Pool& pool) { return new(pool) VImage(pool); }
 
 public:
 	MImage(Pool& pool);
+
+public: // Methoded
 	bool used_directly() { return true; }
 
 };
 
 // helpers
 
-/// simple buffered reader[from memory/file], used in _measure
+#ifndef DOXYGEN
 class Measure_reader {
 public:
-	enum { READ_CHUNK_SIZE=0x400 };// 1K
+	enum { READ_CHUNK_SIZE=0x400*20 };// 20K
 	typedef size_t(*Func)(void *& buf, size_t limit, void *info);
 
 	Measure_reader(Func afunc, void *ainfo) : 
@@ -47,7 +57,7 @@ public:
 		chunk(0), offset(0), size(0) {
 	}
 
-	size_t read(unsigned char *& buf, size_t limit) {
+	size_t read(void *&buf, size_t limit) {
 		if(offset+limit>size) // nothing left
 			if(offset==0 || limit==1) { // only one-byte continuations allowed
 				size=(*func)(chunk, READ_CHUNK_SIZE, info);
@@ -72,6 +82,7 @@ private:
 	size_t offset;
 	size_t size;
 };
+#endif
 
 /// GIF file header
 struct GIF_Header {
@@ -84,145 +95,137 @@ struct GIF_Header {
 	char       nulls;
 };
 
-/// JPEG file header
-struct JFIF_Header {
-	char length[2];              // length of JFIF segment marker
-	char identifier[5];          // JFIF identifier
-	char version[2];             // version
-	char units;                  // units X of Y pixel density
-	char xdensity[2];            // X pixel density
-	char ydensity[2];            // X pixel density
-	char xthumbnails;            // width of thumbnails
-	char ythumbnails;            // height of thumbnails
-	char reserved;               // reserved
+/// JPEG record head
+struct JPG_Segment_head {
+	unsigned char marker;
+	unsigned char code;
+	unsigned char length[2];
 };
 /// JPEG frame header
-struct JPG_Frame {
-	char length[2];               // length of image marker
-	char data;                    // data precision of bits/sample
-	char height[2];               // image height
-	char width[2];                // image width
-	char numComponents;           // number of color components
+struct JPG_Size_segment_body {
+	char data;                    //< data precision of bits/sample
+	unsigned char height[2];               //< image height
+	unsigned char width[2];                //< image width
+	char numComponents;           //< number of color components
 };
 
 //
 
-inline short bytes_to_int(unsigned char HI, unsigned char LO) {
-	return(short)((HI<<8) + LO);
+inline short x_endian_to_int(unsigned char L, unsigned char H) {
+	return(short)((H<<8) + L);
+}
+
+inline short big_endian_to_int(unsigned char b[2]) {
+	return x_endian_to_int(b[1], b[0]);
+}
+
+inline short little_endian_to_int(unsigned char b[2]) {
+	return x_endian_to_int(b[0], b[1]);
 }
 
 void measure_gif(Pool& pool, const String *origin_string, 
 			 Measure_reader& reader, int& width, int& height) {
 
-	unsigned char *buf;
+	void *buf;
 	const int head_size=sizeof(GIF_Header);
 	if(reader.read(buf, head_size)<head_size)
-		PTHROW(0, 0, 
+		throw Exception(0, 0, 
 			origin_string, 
-			"broken GIF header - file size is less then %d bytes", head_size);
+			"not GIF file - too small");
+	GIF_Header *head=(GIF_Header *)buf;
 
-	GIF_Header& screenD=*reinterpret_cast<GIF_Header *>(buf);
-	if(strncmp(screenD.type, "GIF", 3)!=0)
-		PTHROW(0, 0, 
+	if(strncmp(head->type, "GIF", 3)!=0)
+		throw Exception(0, 0, 
 			origin_string, 
-			"bad image file - GIF signature not found");	
+			"not GIF file - wrong signature");	
 
-	width=bytes_to_int(screenD.width[1], screenD.width[0]);
-	height=bytes_to_int(screenD.height[1], screenD.height[0]);
+	width=little_endian_to_int(head->width);
+	height=little_endian_to_int(head->height);
 }
 
+/// @test remove ugly mech in reader - 20K limit
 void measure_jpeg(Pool& pool, const String *origin_string, 
 			 Measure_reader& reader, int& width, int& height) {
 	// JFIF format markers
-	const unsigned char SOI=0xD8;
-	const unsigned char EOI=0xD9;
-	const unsigned char APP0=0xE0;
-	const unsigned char SOF0=0xC0;
-	const unsigned char SOF2=0xC2;
-	const unsigned char COM=0xFE;
+	const unsigned char MARKER=0xFF;
+	const unsigned char CODE_SIZE_FIRST=0xC0;
+	const unsigned char CODE_SIZE_LAST=0xC3;
 
-	unsigned char *screenD_buf;
-	unsigned char *h_buf=0;
-	
-	bool flag=false;
-	
-	unsigned char *prefix;
+	void *buf;
 	const size_t prefix_size=2;
-	if(reader.read(prefix, prefix_size)<prefix_size)
-		PTHROW(0, 0, 
+	if(reader.read(buf, prefix_size)<prefix_size)
+		throw Exception(0, 0, 
 			origin_string, 
-			"broken JPEG file - size is less then %d bytes", prefix_size);
+			"not JPEG file - too small");
+	unsigned char *signature=(unsigned char *)buf;
 	
-	if(((unsigned char *)prefix)[1]!=SOI) 
-		PTHROW(0, 0, 
+	if(!(signature[0]==0xFF && signature[1]==0xD8)) 
+		throw Exception(0, 0, 
 			origin_string, 
-			"broken JPEG file - second byte of header is not 0x%02X", SOI);
-		
-	unsigned char zero=0;
-	unsigned char *marker=&zero;
-
-	do {
-		while((*marker)!=0xFF)
-			if(reader.read(marker, sizeof(char))<=0) break;
-		if(reader.read(marker, sizeof(char))<=0) break;
-		switch(*marker) {
-		case EOI:
-			marker=&zero;
-			break;
-		case APP0:
-			if(!flag) {
-				flag=true;
-				if(reader.read(screenD_buf, sizeof(JFIF_Header)) < sizeof(JFIF_Header))
-					break;
-				JFIF_Header& screenD=*reinterpret_cast<JFIF_Header *>(screenD_buf);
-				if((bytes_to_int(screenD.length[0], screenD.length[1]) < 16) ||
-					strcasecmp(screenD.identifier, "JFIF")) flag=false;
-			}
+			"not JPEG file - wrong signature");
+
+	bool found=false;
+	while(true) {
+		void *buf;
+        // Extract the segment header.
+		if(reader.read(buf, sizeof(JPG_Segment_head))<sizeof(JPG_Segment_head))
+			break;		
+		JPG_Segment_head *head=(JPG_Segment_head *)buf;
+
+        // Verify that it's a valid segment.
+		if(head->marker!=MARKER)
 			break;
-		case SOF0:
-		case SOF2:
-			if(reader.read(h_buf, sizeof(JPG_Frame))<sizeof(JPG_Frame))
-				flag=false;
+
+		if(head->code >= CODE_SIZE_FIRST && head->code  <= CODE_SIZE_LAST) {
+            // Segments that contain size info
+			if(reader.read(buf, sizeof(JPG_Size_segment_body))<sizeof(JPG_Size_segment_body))
+				break;
+			JPG_Size_segment_body *body=(JPG_Size_segment_body *)buf;
+			
+			width=big_endian_to_int(body->width);
+			height=big_endian_to_int(body->height);
+			found=true;
 			break;
-		default: break;
-		}
-	} while(*marker!=EOI);
-	
-	if(flag && h_buf) {
-		JPG_Frame& h=*reinterpret_cast<JPG_Frame *>(h_buf);
-		width=bytes_to_int(h.width[0], h.width[1]);
-		height=bytes_to_int(h.height[0], h.height[1]);
-	} else
-		PTHROW(0, 0, 
+		} else {
+            // Dummy read to skip over data
+            size_t limit=big_endian_to_int(head->length) - 2;
+			if(reader.read(buf, limit)<limit)
+				break;
+        }
+	}
+
+	if(!found)
+		throw Exception(0, 0, 
 			origin_string, 
-			"broken JPEG file - APP0 frame not found");			
+			"broken JPEG file - size frame not found");
 }
 
 // measure center
 
 void measure(Pool& pool, const String& file_name, 
 			 Measure_reader& reader, int& width, int& height) {
-	if(const char *cext=strrchr(file_name.cstr(), '.')) {
+	if(const char *cext=strrchr(file_name.cstr(String::UL_FILE_SPEC), '.')) {
 		cext++;
 		if(strcasecmp(cext, "GIF")==0)
 			measure_gif(pool, &file_name, reader, width, height);
 		else if(strcasecmp(cext, "JPG")==0 || strcasecmp(cext, "JPEG")==0) 
 			measure_jpeg(pool, &file_name, reader, width, height);
 		else
-			PTHROW(0, 0, 
+			throw Exception(0, 0, 
 				&file_name, 
 				"unhandled image file name extension '%s'", cext);
 	} else
-		PTHROW(0, 0, 
+		throw Exception(0, 0, 
 			&file_name, 
 			"can not determine image type - no file name extension");
 }
 
-/// used by image: _measure / read_mem
+#ifndef DOXYGEN
 struct Read_mem_info {
 	unsigned char *ptr;
 	unsigned char *eof;
 };
+#endif
 static size_t read_mem(void*& buf, size_t limit, void *info) {
 	Read_mem_info& rmi=*static_cast<Read_mem_info *>(info);
 	buf=rmi.ptr;
@@ -231,11 +234,12 @@ static size_t read_mem(void*& buf, size_
 	return read_size;
 }
 
-/// used by image: _measure / read_disk
+#ifndef DOXYGEN
 struct Read_disk_info {
 	const String *file_spec;
 	size_t offset;
 };
+#endif
 static size_t read_disk(void*& buf, size_t limit, void *info) {
 	Read_disk_info& rdi=*static_cast<Read_disk_info *>(info);
 	Pool& pool=rdi.file_spec->pool();
@@ -253,11 +257,10 @@ static size_t read_disk(void*& buf, size
 
 // methods
 
-/// ^image:measure[DATA]
 static void _measure(Request& r, const String& method_name, MethodParams *params) {
 	Pool& pool=r.pool();
 
-	Value& data=params->get_no_junction(0, "data must not be code");
+	Value& data=params->as_no_junction(0, "data must not be code");
 
 	void *info;Measure_reader::Func read_func;
 	Read_mem_info read_mem_info;
@@ -283,26 +286,25 @@ static void _measure(Request& r, const S
 	static_cast<VImage *>(r.self)->set(file_name, width, height);
 }
 
-/// used by image: _html / append_attrib_pair
+#ifndef DOXYGEN
 struct Attrib_info {
 	String *tag; ///< html tag being constructed
 	Hash *skip; ///< tag attributes not to append to tag string [to skip]
 };
+#endif
 static void append_attrib_pair(const Hash::Key& key, Hash::Val *val, void *info) {
 	Attrib_info& ai=*static_cast<Attrib_info *>(info);
 
-	if(ai.skip && ai.skip->get(key))
+	// skip user-specified and internal(starting with "line-") attributes 
+	if(ai.skip && ai.skip->get(key) || key.pos("line-")==0)
 		return;
 
 	Value& value=*static_cast<Value *>(val);
 	// src="a.gif" width=123 ismap[=-1]
 	*ai.tag << " " << key;
-	if(value.is_string() || value.as_double()>=0)
+	if(value.is_string() || value.as_int()>=0)
 		*ai.tag << "=\"" << value.as_string() << "\"";
 }
-/**	^image.html[]
-	^image.html[hash]
-*/
 static void _html(Request& r, const String& method_name, MethodParams *params) {
 	Pool& pool=r.pool();
 
@@ -312,14 +314,19 @@ static void _html(Request& r, const Stri
 	const Hash& fields=static_cast<VImage *>(r.self)->fields();
 	Hash *attribs=0;
 
-	if(params->size())
-		if(attribs=params->get(0).get_hash()) {
-			Attrib_info attrib_info={&tag, 0};
-			attribs->for_each(append_attrib_pair, &attrib_info);
-		} else
-			PTHROW(0, 0, 
-				&method_name, 
-				"attributes must be must be hash");
+	if(params->size()) {
+		Value &vattribs=r.process(params->get(0),
+			0/*no name*/,
+			false/*don't intercept string*/);
+		if(vattribs.is_defined()) // allow 'void'
+			if(attribs=vattribs.get_hash(&method_name)) {
+				Attrib_info attrib_info={&tag, 0};
+				attribs->for_each(append_attrib_pair, &attrib_info);
+			} else
+				throw Exception(0, 0, 
+					&method_name, 
+					"attributes must be hash");
+	}
 
 	Attrib_info attrib_info={&tag, attribs};
 	fields.for_each(append_attrib_pair, &attrib_info);
@@ -331,14 +338,18 @@ static gdImage *load(Request& r, const S
 					 const String& file_name){
 	Pool& pool=r.pool();
 
-	const char *file_name_cstr=r.absolute(file_name).cstr(String::UL_FILE_NAME);
+	const char *file_name_cstr=r.absolute(file_name).cstr(String::UL_FILE_SPEC);
 	if(FILE *f=fopen(file_name_cstr, "rb")) {
 		gdImage& image=*new(pool) gdImage(pool);
-		image.CreateFromGif(f);
+		bool ok=image.CreateFromGif(f);
 		fclose(f);
+		if(!ok)
+			throw Exception(0, 0, 
+				&file_name,
+				"is not in GIF format");
 		return &image;
 	} else {
-		PTHROW(0, 0, 
+		throw Exception(0, 0, 
 			&method_name, 
 			"can not open '%s'", file_name_cstr);
 		return 0;
@@ -346,12 +357,10 @@ static gdImage *load(Request& r, const S
 }
 
 
-/// ^image.load[background.gif]
 static void _load(Request& r, const String& method_name, MethodParams *params) {
 	Pool& pool=r.pool();
 
-	Value& vfile_name=params->get_no_junction(0, "file name must not be code");
-	const String& file_name=vfile_name.as_string();
+	const String& file_name=params->as_string(0, "file name must not be code");
 
 	gdImage& image=*load(r, method_name, file_name);
 	int width=image.SX();
@@ -359,30 +368,26 @@ static void _load(Request& r, const Stri
 	static_cast<VImage *>(r.self)->set(&file_name, width, height, &image);
 }
 
-/**	^image.create[width;height] bgcolor=white
-	^image.create[width;height;bgcolor]
-*/
 static void _create(Request& r, const String& method_name, MethodParams *params) {
 	Pool& pool=r.pool();
 
-	int width=(int)r.process(params->get(0)).as_double();
-	int height=(int)r.process(params->get(1)).as_double();
+	int width=params->as_int(0, "width must be int", r);
+	int height=params->as_int(1, "height must be int", r);
 	int bgcolor_value=0xffFFff;
 	if(params->size()>2)
-		bgcolor_value=(int)r.process(params->get(2)).as_double();
+		bgcolor_value=params->as_int(2, "color must be int", r);
 	gdImage& image=*new(pool) gdImage(pool);
 	image.Create(width, height);
 	image.FilledRectangle(0, 0, width-1, height-1, image.Color(bgcolor_value));
 	static_cast<VImage *>(r.self)->set(0, width, height, &image);
 }
 
-/// ^image.gif[]
 static void _gif(Request& r, const String& method_name, MethodParams *params) {
 	Pool& pool=r.pool();
 
 	gdImage *image=static_cast<VImage *>(r.self)->image;
 	if(!image)
-		PTHROW(0, 0, 
+		throw Exception(0, 0, 
 			&method_name, 
 			"does not contain an image");
 
@@ -391,160 +396,177 @@ static void _gif(Request& r, const Strin
 	String out(pool); image->Gif(out);
 	
 	VFile& vfile=*new(pool) VFile(pool);
-	String& image_gif=*new(pool) String(pool, "image/gif");
+	Value *content_type=new(pool) VString(*new(pool) String(pool, "image/gif"));
 	vfile.set(false/*not tainted*/, 
-		out.cstr(String::UL_AS_IS), out.size(), 0, &image_gif);
+		out.cstr(), out.size(), 0, content_type);
 
 	r.write_no_lang(vfile);
 }
 
-/// ^image.line(x0;y0;x1;y1;color)
 static void _line(Request& r, const String& method_name, MethodParams *params) {
 	Pool& pool=r.pool();
 
 	gdImage *image=static_cast<VImage *>(r.self)->image;
 	if(!image)
-		PTHROW(0, 0, 
+		throw Exception(0, 0, 
 			&method_name, 
 			"does not contain an image");
 
 	image->Line(
-		(int)r.process(params->get(0)).as_double(), 
-		(int)r.process(params->get(1)).as_double(), 
-		(int)r.process(params->get(2)).as_double(), 
-		(int)r.process(params->get(3)).as_double(), 
-		image->Color((int)r.process(params->get(4)).as_double()));
+		params->as_int(0, "x0 must be int", r), 
+		params->as_int(1, "y0 must be int", r), 
+		params->as_int(2, "x1 must be int", r), 
+		params->as_int(3, "y1 must be int", r), 
+		image->Color(params->as_int(4, "color must be int", r)));
 }
 
-/// ^image.fill(x;y;color)
 static void _fill(Request& r, const String& method_name, MethodParams *params) {
 	Pool& pool=r.pool();
 
 	gdImage *image=static_cast<VImage *>(r.self)->image;
 	if(!image)
-		PTHROW(0, 0, 
+		throw Exception(0, 0, 
 			&method_name, 
 			"does not contain an image");
 
 	image->Fill(
-		(int)r.process(params->get(0)).as_double(), 
-		(int)r.process(params->get(1)).as_double(), 
-		image->Color((int)r.process(params->get(2)).as_double()));
+		params->as_int(0, "x must be int", r), 
+		params->as_int(1, "y must be int", r), 
+		image->Color(params->as_int(2, "color must be int", r)));
 }
 
-/// ^image.rectangle(x0;y0;x1;y1;color)
 static void _rectangle(Request& r, const String& method_name, MethodParams *params) {
 	Pool& pool=r.pool();
 
 	gdImage *image=static_cast<VImage *>(r.self)->image;
 	if(!image)
-		PTHROW(0, 0, 
+		throw Exception(0, 0, 
 			&method_name, 
 			"does not contain an image");
 
 	image->Rectangle(
-		(int)r.process(params->get(0)).as_double(), 
-		(int)r.process(params->get(1)).as_double(), 
-		(int)r.process(params->get(2)).as_double(), 
-		(int)r.process(params->get(3)).as_double(), 
-		image->Color((int)r.process(params->get(4)).as_double()));
+		params->as_int(0, "x0 must be int", r), 
+		params->as_int(1, "y0 must be int", r), 
+		params->as_int(2, "x1 must be int", r), 
+		params->as_int(3, "y1 must be int", r), 
+		image->Color(params->as_int(4, "color must be int", r)));
 }
 
-/// ^image.bar(x0;y0;x1;y1;color)
 static void _bar(Request& r, const String& method_name, MethodParams *params) {
 	Pool& pool=r.pool();
 
 	gdImage *image=static_cast<VImage *>(r.self)->image;
 	if(!image)
-		PTHROW(0, 0, 
+		throw Exception(0, 0, 
 			&method_name, 
 			"does not contain an image");
 
 	image->FilledRectangle(
-		(int)r.process(params->get(0)).as_double(), 
-		(int)r.process(params->get(1)).as_double(), 
-		(int)r.process(params->get(2)).as_double(), 
-		(int)r.process(params->get(3)).as_double(), 
-		image->Color((int)r.process(params->get(4)).as_double()));
+		params->as_int(0, "x0 must be int", r), 
+		params->as_int(1, "y0 must be int", r), 
+		params->as_int(2, "x1 must be int", r), 
+		params->as_int(3, "y1 must be int", r), 
+		image->Color(params->as_int(4, "color must be int", r)));
+}
+
+#ifndef DOXYGEN
+static void add_point(Array::Item *value, void *info) {
+	Array& row=*static_cast<Array *>(value);
+	gdImage::Point **p=static_cast<gdImage::Point **>(info);
+	
+	(**p).x=row.get_string(0)->as_int();
+	(**p).y=row.get_string(1)->as_int();
+	(*p)++;
 }
-
-/// ^image.replace(color-source;color-dest)(x;y)... point coord pairs
+#endif
 static void _replace(Request& r, const String& method_name, MethodParams *params) {
 	Pool& pool=r.pool();
 
 	gdImage *image=static_cast<VImage *>(r.self)->image;
 	if(!image)
-		PTHROW(0, 0, 
+		throw Exception(0, 0, 
 			&method_name, 
 			"does not contain an image");
 
-	if((params->size()-2)%2) // I see your thoughts, but that's more readable
-		PTHROW(0, 0, 
+	Table *table=params->as_no_junction(2, "coordinates must not be code").get_table();
+	if(!table) 
+		throw Exception(0, 0,
+			&method_name,
+			"coordinates must be table");
+
+	gdImage::Point *all_p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*table->size());
+	gdImage::Point *add_p=all_p;	
+	table->for_each(add_point, &add_p);
+	image->FilledPolygonReplaceColor(all_p, table->size(), 
+		image->Color(params->as_int(0, "src color must be int", r)),
+		image->Color(params->as_int(1, "dest color must be int", r)));
+}
+
+static void _polyline(Request& r, const String& method_name, MethodParams *params) {
+	Pool& pool=r.pool();
+
+	gdImage *image=static_cast<VImage *>(r.self)->image;
+	if(!image)
+		throw Exception(0, 0, 
 			&method_name, 
-			"y coordinate missing");
+			"does not contain an image");
 
-	int n=(params->size()-2)/2;
-	
-	gdImage::Point *p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*n);
-	for(int i=0; i<n; i++) {
-		p[i].x=(int)r.process(params->get(2+i*2+0)).as_double();
-		p[i].y=(int)r.process(params->get(2+i*2+1)).as_double();
-	}
-	image->FilledPolygonReplaceColor(p, n, 
-		image->Color((int)r.process(params->get(0)).as_double()), // src color
-		image->Color((int)r.process(params->get(1)).as_double()));// dest color
+	Table *table=params->as_no_junction(1, "coordinates must not be code").get_table();
+	if(!table) 
+		throw Exception(0, 0,
+			&method_name,
+			"coordinates must be table");
+
+	gdImage::Point *all_p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*table->size());
+	gdImage::Point *add_p=all_p;	
+	table->for_each(add_point, &add_p);
+	image->Polygon(all_p, table->size(), 
+		image->Color(params->as_int(0, "color must be int", r)),
+		false/*not closed*/);
 }
 
-/// ^image.polygon(color)(x;y)... point coord pairs
 static void _polygon(Request& r, const String& method_name, MethodParams *params) {
 	Pool& pool=r.pool();
 
 	gdImage *image=static_cast<VImage *>(r.self)->image;
 	if(!image)
-		PTHROW(0, 0, 
+		throw Exception(0, 0, 
 			&method_name, 
 			"does not contain an image");
 
-	if((params->size()-1)%2) // [I see..] see now?
-		PTHROW(0, 0, 
-			&method_name, 
-			"y coordinate missing");
-
-	int n=(params->size()-1)/2;
-	
-	gdImage::Point *p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*n);
-	for(int i=0; i<n; i++) {
-		p[i].x=(int)r.process(params->get(1+i*2+0)).as_double();
-		p[i].y=(int)r.process(params->get(1+i*2+1)).as_double();
-	}
-	image->Polygon(p, n, 
-		image->Color((int)r.process(params->get(0)).as_double()));
+	Table *table=params->as_no_junction(1, "coordinates must not be code").get_table();
+	if(!table) 
+		throw Exception(0, 0,
+			&method_name,
+			"coordinates must be table");
+
+	gdImage::Point *all_p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*table->size());
+	gdImage::Point *add_p=all_p;	
+	table->for_each(add_point, &add_p);
+	image->Polygon(all_p, table->size(), 
+		image->Color(params->as_int(0, "color must be int", r)));
 }
 
-/// ^image.polybar(color)(x;y)... point coord pairs
 static void _polybar(Request& r, const String& method_name, MethodParams *params) {
 	Pool& pool=r.pool();
 
 	gdImage *image=static_cast<VImage *>(r.self)->image;
 	if(!image)
-		PTHROW(0, 0, 
+		throw Exception(0, 0, 
 			&method_name, 
 			"does not contain an image");
 
-	if((params->size()-1)%2) // [I see..] see now?
-		PTHROW(0, 0, 
-			&method_name, 
-			"y coordinate missing");
-
-	int n=(params->size()-1)/2;
-	
-	gdImage::Point *p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*n);
-	for(int i=0; i<n; i++) {
-		p[i].x=(int)r.process(params->get(1+i*2+0)).as_double();
-		p[i].y=(int)r.process(params->get(1+i*2+1)).as_double();
-	}
-	image->FilledPolygon(p, n, 
-		image->Color((int)r.process(params->get(0)).as_double()));
+	Table *table=params->as_no_junction(1, "coordinates must not be code").get_table();
+	if(!table) 
+		throw Exception(0, 0,
+			&method_name,
+			"coordinates must be table");
+
+	gdImage::Point *all_p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*table->size());
+	gdImage::Point *add_p=all_p;	
+	table->for_each(add_point, &add_p);
+	image->FilledPolygon(all_p, table->size(), 
+		image->Color(params->as_int(0, "color must be int", r)));
 }
 
 // font
@@ -555,16 +577,18 @@ static void _polybar(Request& r, const S
 class Font : public Pooled {
 public:
 	
-	int height;	    /* Font heigth */
-	int space;	    /* Default char width */
+	const static int letter_spacing;
+	int height;	    ///< Font heigth
+	int monospace;	    ///< Default char width
+	int spacebarspace; ///< spacebar width
 	gdImage& ifont;
 	const String& alphabet;
 	
 	Font(Pool& pool, 
 		const String& aalphabet, 
-		gdImage& aifont, int aheight, int aspace) : Pooled(pool), 
+		gdImage& aifont, int aheight, int amonospace, int aspacebarspace) : Pooled(pool), 
 		alphabet(aalphabet), 
-		height(aheight), space(aspace), 
+		height(aheight), monospace(amonospace),  spacebarspace(aspacebarspace),
 		ifont(aifont) {
 	}
 	
@@ -577,14 +601,12 @@ public:
 	
 	int index_width(int index) {
 		if(index<0)
-			index=index_of('.');
-		if(index<0) 
-			return 0;
+			return spacebarspace;
 		int tr=ifont.GetTransparent();
-		for(int x=ifont.SX()-1; x>0; x--) {
+		for(int x=ifont.SX()-1; x>=0; x--) {
 			for(int y=0; y<height-1; y++)
 				if(ifont.GetPixel(x, Y(y))!=tr) 
-					return x+2;
+					return x+1;
 		}
 		return 0;
 	}
@@ -595,66 +617,200 @@ public:
 	}
 	
 	/* ******************************** string ********************************** */
-	/*
-	int string_width(const char *cstr){
+	
+	int string_width(const String& s){
+		const char *cstr=s.cstr();
 		int result=0;
 		for(; *cstr; cstr++)
 			result+=index_width(index_of(*cstr));
 		return result;
 	}
-	*/
 	
 	void string_display(gdImage& image, int x, int y, const String& s){
-		const char *cstr=s.cstr(String::UL_AS_IS);
+		const char *cstr=s.cstr();
 		if(cstr) for(; *cstr; cstr++) {
 			int index=index_of(*cstr);
 			index_display(image, x, y, index);
-			x+=space ? space : index_width(index);
+			x+=letter_spacing + (monospace ? monospace : index_width(index));
 		}
 	}
 	
 };
-/**
-	^image.font[alPHAbet;font-file-name.gif](height)
-	^image.font[alPHAbet;font-file-name.gif](height;width)
-*/
+const int Font::letter_spacing=1;
+
 static void _font(Request& r, const String& method_name, MethodParams *params) {
 	Pool& pool=r.pool();
 
-	Value& valphabet=params->get_no_junction(0, "alphabet must not be code");
-	Value& file_name=params->get_no_junction(1, "file_name must not be code");
-	int height=(int)r.process(params->get(2)).as_double();
-
-	int width=params->size()>3?(int)r.process(params->get(3)).as_double():0;
+	const String& alphabet=params->as_string(0, "alphabet must not be code");
+	gdImage& image=*load(r, method_name, params->as_string(1, "file_name must not be code"));
+	int spacebar_width=params->as_int(2, "spacebar_width must be int", r);
+	int monospace_width;
+	if(params->size()>3) {
+		monospace_width=params->as_int(3, "monospace_width must be int", r);
+		if(!monospace_width)
+			monospace_width=image.SX();
+	} else
+		monospace_width=0;
 
+	if(!alphabet.size())
+		throw Exception(0, 0,
+			&method_name,
+			"alphabet must not be empty");
+	
 	static_cast<VImage *>(r.self)->font=new(pool) Font(pool, 
-		valphabet.as_string(), 
-		*load(r, method_name, file_name.as_string()), 
-		height, width);
+		alphabet, 
+		image, 
+		image.SY() / alphabet.size(), monospace_width, spacebar_width);
 }
 
-/// ^image.text(x;y)[text]
 static void _text(Request& r, const String& method_name, MethodParams *params) {
 	Pool& pool=r.pool();
 
-	int x=(int)r.process(params->get(0)).as_double();
-	int y=(int)r.process(params->get(1)).as_double();
-	const String& s=r.process(params->get(2)).as_string();
+	int x=params->as_int(0, "x must be int", r);
+	int y=params->as_int(1, "y must be int", r);
+	const String& s=params->as_string(2, "text must not be code");
 
 	VImage& vimage=*static_cast<VImage *>(r.self);
 	if(vimage.image)
 		if(vimage.font)
 			vimage.font->string_display(*vimage.image, x, y, s);
 		else
-			PTHROW(0, 0,
+			throw Exception(0, 0,
 				&method_name,
 				"set the font first");
 	else
-		PTHROW(0, 0, 
+		throw Exception(0, 0, 
 			&method_name, 
 			"does not contain an image");
 }
 
+static void _length(Request& r, const String& method_name, MethodParams *params) {
+	Pool& pool=r.pool();
+
+	const String& s=params->as_string(0, "text must not be code");
+
+	VImage& vimage=*static_cast<VImage *>(r.self);
+	if(vimage.image)
+		if(vimage.font) {
+			VInt& result=*new(pool) VInt(pool, vimage.font->string_width(s));
+			result.set_name(method_name);
+			r.write_assign_lang(result);
+		} else
+			throw Exception(0, 0,
+				&method_name,
+				"set the font first");
+	else
+		throw Exception(0, 0, 
+			&method_name, 
+			"does not contain an image");
+}
+
+static void _arc(Request& r, const String& method_name, MethodParams *params) {
+	Pool& pool=r.pool();
+
+	gdImage *image=static_cast<VImage *>(r.self)->image;
+	if(!image)
+		throw Exception(0, 0, 
+			&method_name, 
+			"does not contain an image");
+
+	image->Arc(
+		params->as_int(0, "center_x must be int", r), 
+		params->as_int(1, "center_y must be int", r), 
+		params->as_int(2, "width must be int", r), 
+		params->as_int(3, "height must be int", r), 
+		params->as_int(4, "start degrees must be int", r), 
+		params->as_int(5, "end degrees must be int", r), 
+		image->Color(params->as_int(6, "cx must be int", r)));
+}
+
+static void _sector(Request& r, const String& method_name, MethodParams *params) {
+	Pool& pool=r.pool();
+
+	gdImage *image=static_cast<VImage *>(r.self)->image;
+	if(!image)
+		throw Exception(0, 0, 
+			&method_name, 
+			"does not contain an image");
+
+	image->Sector(
+		params->as_int(0, "center_x must be int", r), 
+		params->as_int(1, "center_y must be int", r), 
+		params->as_int(2, "width must be int", r), 
+		params->as_int(3, "height must be int", r), 
+		params->as_int(4, "start degrees must be int", r), 
+		params->as_int(5, "end degrees must be int", r), 
+		image->Color(params->as_int(6, "color must be int", r)));
+}
+
+static void _circle(Request& r, const String& method_name, MethodParams *params) {
+	Pool& pool=r.pool();
+
+	gdImage *image=static_cast<VImage *>(r.self)->image;
+	if(!image)
+		throw Exception(0, 0, 
+			&method_name, 
+			"does not contain an image");
+
+	int size=params->as_int(2, "radius must be int", r)*2;
+	image->Arc(
+		params->as_int(0, "center_x must be int", r), 
+		params->as_int(1, "center_y must be int", r), 
+		size, //w
+		size, //h
+		0, //s
+		360, //e
+		image->Color(params->as_int(3, "color must be int", r)));
+}
+
+gdImage& as_image(Pool& pool, const String& method_name, MethodParams *params, 
+						int index, const char *msg) {
+	Value& value=params->as_no_junction(index, msg);
+
+	if(strcmp(value.type(), VIMAGE_TYPE)!=0)
+		throw Exception(0, 0, 
+			&method_name, 
+			msg);
+
+	gdImage *src=static_cast<VImage *>(&value)->image;
+	if(!src)
+		throw Exception(0, 0, 
+			&method_name, 
+			msg);
+
+	return *src;
+}
+
+static void _copy(Request& r, const String& method_name, MethodParams *params) {
+	Pool& pool=r.pool();
+
+	gdImage *dest=static_cast<VImage *>(r.self)->image;
+	if(!dest)
+		throw Exception(0, 0, 
+			&method_name, 
+			"self does not contain an image");
+
+	gdImage& src=as_image(pool, method_name, params, 0, "src must be image");
+
+	int sx=params->as_int(1, "src_x must be int", r);
+	int sy=params->as_int(2, "src_y must be int", r);
+	int sw=params->as_int(3, "src_w must be int", r);
+	int sh=params->as_int(4, "src_h must be int", r);
+	int dx=params->as_int(5, "dest_x must be int", r);
+	int dy=params->as_int(6, "dest_y must be int", r);
+	if(params->size()>1+2+2+2) {
+		int dw=params->as_int(1+2+2+2, "dest_w must be int", r);
+		int dh=(int)(params->size()>1+2+2+2+1?
+			params->as_int(1+2+2+2+1, "dest_h must be int", r):sh*(((double)dw)/((double)sw)));
+		int tolerance=params->size()>1+2+2+2+2?
+			params->as_int(1+2+2+2+2, "tolerance must be int", r):150;
+
+		src.CopyResampled(*dest, dx, dy, sx, sy, dw, dh, sw, sh, tolerance);
+	} else
+		src.Copy(*dest, dx, dy, sx, sy, sw, sh);
+}
+
+
 // constructor
 
 MImage::MImage(Pool& apool) : Methoded(apool) {
@@ -664,48 +820,65 @@ MImage::MImage(Pool& apool) : Methoded(a
 	// ^image:measure[DATA]
 	add_native_method("measure", Method::CT_DYNAMIC, _measure, 1, 1);
 
-	/// ^image.html[]
-	/// ^image.html[hash]
+	// ^image.html[]
+	// ^image.html[hash]
 	add_native_method("html", Method::CT_DYNAMIC, _html, 0, 1);
 
-	/// ^image.load[background.gif]
+	// ^image.load[background.gif]
 	add_native_method("load", Method::CT_DYNAMIC, _load, 1, 1);
 
-	/// ^image.create[width;height] bgcolor=white
-	/// ^image.create[width;height;bgcolor]
+	// ^image.create[width;height] bgcolor=white
+	// ^image.create[width;height;bgcolor]
 	add_native_method("create", Method::CT_DYNAMIC, _create, 2, 3);
 
-	/// ^image.gif[]
+	// ^image.gif[]
 	add_native_method("gif", Method::CT_DYNAMIC, _gif, 0, 0);
 
-	/// ^image.line(x0;y0;x1;y1;color)
+	// ^image.line(x0;y0;x1;y1;color)
 	add_native_method("line", Method::CT_DYNAMIC, _line, 5, 5);
 
-	/// ^image.fill(x;y;color)
+	// ^image.fill(x;y;color)
 	add_native_method("fill", Method::CT_DYNAMIC, _fill, 3, 3);
 
-	/// ^image.rectangle(x0;y0;x1;y1;color)
+	// ^image.rectangle(x0;y0;x1;y1;color)
 	add_native_method("rectangle", Method::CT_DYNAMIC, _rectangle, 5, 5);
 
-	/// ^image.bar(x0;y0;x1;y1;color)
+	// ^image.bar(x0;y0;x1;y1;color)
 	add_native_method("bar", Method::CT_DYNAMIC, _bar, 5, 5);
 
-	/// ^image.replace(color-source;color-dest)(x;y)... point coord pairs
-	add_native_method("replace", Method::CT_DYNAMIC, _replace, 2+3*2, 2+100*2);
+	// ^image.replace(color-source;color-dest)[table x:y]
+	add_native_method("replace", Method::CT_DYNAMIC, _replace, 3, 3);
+
+	// ^image.polyline(color)[table x:y]
+	add_native_method("polyline", Method::CT_DYNAMIC, _polyline, 2, 2);
 
-	/// ^image.polygon(color)(x;y)... point coord pairs
-	add_native_method("polygon", Method::CT_DYNAMIC, _polygon, 1+3*2, 1+100*2);
+	// ^image.polygon(color)[table x:y]
+	add_native_method("polygon", Method::CT_DYNAMIC, _polygon, 2, 2);
 
-	/// ^image.polybar(color)(x;y)... point coord pairs
-	add_native_method("polybar", Method::CT_DYNAMIC, _polybar, 1+3*2, 1+100*2);
+	// ^image.polybar(color)[table x:y]
+	add_native_method("polybar", Method::CT_DYNAMIC, _polybar, 2, 2);
 
-    /// ^image.font[alPHAbet;font-file-name.gif](height)
-    /// ^image.font[alPHAbet;font-file-name.gif](height;width)
+    // ^image.font[alPHAbet;font-file-name.gif](spacebar_width)
+    // ^image.font[alPHAbet;font-file-name.gif](spacebar_width;width)
 	add_native_method("font", Method::CT_DYNAMIC, _font, 3, 4);
 
-    /// ^image.text(x;y)[text]
+    // ^image.text(x;y)[text]
 	add_native_method("text", Method::CT_DYNAMIC, _text, 3, 3);
 	
+    // ^image.ngth[text]
+	add_native_method("length", Method::CT_DYNAMIC, _length, 1, 1);
+	
+	// ^image.arc(center x;center y;width;height;start in degrees;end in degrees;color)
+	add_native_method("arc", Method::CT_DYNAMIC, _arc, 7, 7);
+
+	// ^image.sector(center x;center y;width;height;start in degrees;end in degrees;color)
+	add_native_method("sector", Method::CT_DYNAMIC, _sector, 7, 7);
+
+	// ^image.circle(center x;center y;r;color)
+	add_native_method("circle", Method::CT_DYNAMIC, _circle, 4, 4);
+
+	// ^image.copy[source](src x;src y;src w;src h;dst x;dst y[;dest w[;dest h[;tolerance]]])
+	add_native_method("copy", Method::CT_DYNAMIC, _copy, 1+2+2+2, (1+2+2+2)+2+1);
 }
 
 // global variable