parser3/src/classes/image.C - diff

Return to image.C CVS log

Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/image.C between versions 1.25 and 1.46

version 1.25, 2001/05/07 15:31:36	version 1.46, 2001/09/26 10:32:25
Line 2	Line 2
Parser: @b image parser class.	Parser: @b image parser class.

Copyright(c) 2001 ArtLebedev Group(http://www.artlebedev.com)	Copyright(c) 2001 ArtLebedev Group(http://www.artlebedev.com)

Author: Alexander Petrosyan <paf@design.ru>(http://design.ru/paf)	Author: Alexander Petrosyan <paf@design.ru>(http://design.ru/paf)

$Id$	$Id$
*/	*/

	/*
	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"	#include "pa_config_includes.h"

#include "gif.h"	#include "gif.h"
Line 37 public: // Methoded	Line 45 public: // Methoded

// helpers	// helpers

/// simple buffered reader[from memory/file], used in _measure	#ifndef DOXYGEN
class Measure_reader {	class Measure_reader {
public:	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);	typedef size_t(Func)(void & buf, size_t limit, void *info);

Measure_reader(Func afunc, void *ainfo) :	Measure_reader(Func afunc, void *ainfo) :
Line 48 public:	Line 56 public:
chunk(0), offset(0), size(0) {	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+limit>size) // nothing left
if(offset==0 \|\| limit==1) { // only one-byte continuations allowed	if(offset==0 \|\| limit==1) { // only one-byte continuations allowed
size=(*func)(chunk, READ_CHUNK_SIZE, info);	size=(*func)(chunk, READ_CHUNK_SIZE, info);
Line 73 private:	Line 81 private:
size_t offset;	size_t offset;
size_t size;	size_t size;
};	};
	#endif

/// GIF file header	/// GIF file header
struct GIF_Header {	struct GIF_Header {
Line 85 struct GIF_Header {	Line 94 struct GIF_Header {
char nulls;	char nulls;
};	};

/// JPEG file header	/// JPEG record head
struct JFIF_Header {	struct JPG_Segment_head {
char length[2]; // length of JFIF segment marker	unsigned char marker;
char identifier[5]; // JFIF identifier	unsigned char code;
char version[2]; // version	unsigned char length[2];
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 frame header	/// JPEG frame header
struct JPG_Frame {	struct JPG_Size_segment_body {
char length[2]; // length of image marker	char data; //< data precision of bits/sample
char data; // data precision of bits/sample	unsigned char height[2]; //< image height
char height[2]; // image height	unsigned char width[2]; //< image width
char width[2]; // image width	char numComponents; //< number of color components
char numComponents; // number of color components
};	};

//	//

inline short bytes_to_int(unsigned char HI, unsigned char LO) {	inline short x_endian_to_int(unsigned char L, unsigned char H) {
return(short)((HI<<8) + LO);	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,	void measure_gif(Pool& pool, const String *origin_string,
Measure_reader& reader, int& width, int& height) {	Measure_reader& reader, int& width, int& height) {

unsigned char *buf;	void *buf;
const int head_size=sizeof(GIF_Header);	const int head_size=sizeof(GIF_Header);
if(reader.read(buf, head_size)<head_size)	if(reader.read(buf, head_size)<head_size)
PTHROW(0, 0,	PTHROW(0, 0,
origin_string,	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(head->type, "GIF", 3)!=0)
if(strncmp(screenD.type, "GIF", 3)!=0)
PTHROW(0, 0,	PTHROW(0, 0,
origin_string,	origin_string,
"bad image file - GIF signature not found");	"not GIF file - wrong signature");

width=bytes_to_int(screenD.width[1], screenD.width[0]);	width=little_endian_to_int(head->width);
height=bytes_to_int(screenD.height[1], screenD.height[0]);	height=little_endian_to_int(head->height);
}	}

void measure_jpeg(Pool& pool, const String *origin_string,	void measure_jpeg(Pool& pool, const String *origin_string,
Measure_reader& reader, int& width, int& height) {	Measure_reader& reader, int& width, int& height) {
// JFIF format markers	// JFIF format markers
const unsigned char SOI=0xD8;	const unsigned char MARKER=0xFF;
const unsigned char EOI=0xD9;	const unsigned char CODE_SIZE_FIRST=0xC0;
const unsigned char APP0=0xE0;	const unsigned char CODE_SIZE_LAST=0xC3;
const unsigned char SOF0=0xC0;
const unsigned char SOF2=0xC2;
const unsigned char COM=0xFE;

unsigned char *screenD_buf;	void *buf;
unsigned char *h_buf=0;

bool flag=false;

unsigned char *prefix;
const size_t prefix_size=2;	const size_t prefix_size=2;
if(reader.read(prefix, prefix_size)<prefix_size)	if(reader.read(buf, prefix_size)<prefix_size)
PTHROW(0, 0,	PTHROW(0, 0,
origin_string,	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)	if(!(signature[0]==0xFF && signature[1]==0xD8))
PTHROW(0, 0,	PTHROW(0, 0,
origin_string,	origin_string,
"broken JPEG file - second byte of header is not 0x%02X", SOI);	"not JPEG file - wrong signature");

unsigned char zero=0;	bool found=false;
unsigned char *marker=&zero;	while(true) {
	void *buf;
do {	// Extract the segment header.
while((*marker)!=0xFF)	if(reader.read(buf, sizeof(JPG_Segment_head))<sizeof(JPG_Segment_head))
if(reader.read(marker, sizeof(char))<=0) break;	break;
if(reader.read(marker, sizeof(char))<=0) break;	JPG_Segment_head head=(JPG_Segment_head )buf;
switch(*marker) {
case EOI:	// Verify that it's a valid segment.
marker=&zero;	if(head->marker!=MARKER)
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;
}
break;	break;
case SOF0:
case SOF2:	if(head->code >= CODE_SIZE_FIRST && head->code <= CODE_SIZE_LAST) {
if(reader.read(h_buf, sizeof(JPG_Frame))<sizeof(JPG_Frame))	// Segments that contain size info
flag=false;	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;	break;
default: break;	} else {
}	// Dummy read to skip over data
} while(*marker!=EOI);	size_t limit=big_endian_to_int(head->length) - 2;
	if(reader.read(buf, limit)<limit)
if(flag && h_buf) {	break;
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	if(!found)
PTHROW(0, 0,	PTHROW(0, 0,
origin_string,	origin_string,
"broken JPEG file - APP0 frame not found");	"broken JPEG file - size frame not found");
}	}

// measure center	// measure center
Line 219 void measure(Pool& pool, const String& f	Line 218 void measure(Pool& pool, const String& f
"can not determine image type - no file name extension");	"can not determine image type - no file name extension");
}	}

/// used by image: _measure / read_mem	#ifndef DOXYGEN
struct Read_mem_info {	struct Read_mem_info {
unsigned char *ptr;	unsigned char *ptr;
unsigned char *eof;	unsigned char *eof;
};	};
	#endif
static size_t read_mem(void& buf, size_t limit, void info) {	static size_t read_mem(void& buf, size_t limit, void info) {
Read_mem_info& rmi=static_cast<Read_mem_info >(info);	Read_mem_info& rmi=static_cast<Read_mem_info >(info);
buf=rmi.ptr;	buf=rmi.ptr;
Line 232 static size_t read_mem(void*& buf, size_	Line 232 static size_t read_mem(void*& buf, size_
return read_size;	return read_size;
}	}

/// used by image: _measure / read_disk	#ifndef DOXYGEN
struct Read_disk_info {	struct Read_disk_info {
const String *file_spec;	const String *file_spec;
size_t offset;	size_t offset;
};	};
	#endif
static size_t read_disk(void& buf, size_t limit, void info) {	static size_t read_disk(void& buf, size_t limit, void info) {
Read_disk_info& rdi=static_cast<Read_disk_info >(info);	Read_disk_info& rdi=static_cast<Read_disk_info >(info);
Pool& pool=rdi.file_spec->pool();	Pool& pool=rdi.file_spec->pool();
Line 257 static size_t read_disk(void*& buf, size	Line 258 static size_t read_disk(void*& buf, size
static void _measure(Request& r, const String& method_name, MethodParams *params) {	static void _measure(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	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;	void *info;Measure_reader::Func read_func;
Read_mem_info read_mem_info;	Read_mem_info read_mem_info;
Line 283 static void _measure(Request& r, const S	Line 284 static void _measure(Request& r, const S
static_cast<VImage *>(r.self)->set(file_name, width, height);	static_cast<VImage *>(r.self)->set(file_name, width, height);
}	}

/// used by image: _html / append_attrib_pair	#ifndef DOXYGEN
struct Attrib_info {	struct Attrib_info {
String *tag; ///< html tag being constructed	String *tag; ///< html tag being constructed
Hash *skip; ///< tag attributes not to append to tag string [to skip]	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) {	static void append_attrib_pair(const Hash::Key& key, Hash::Val val, void info) {
Attrib_info& ai=static_cast<Attrib_info >(info);	Attrib_info& ai=static_cast<Attrib_info >(info);

Line 297 static void append_attrib_pair(const Has	Line 299 static void append_attrib_pair(const Has
Value& value=static_cast<Value >(val);	Value& value=static_cast<Value >(val);
// src="a.gif" width=123 ismap[=-1]	// src="a.gif" width=123 ismap[=-1]
*ai.tag << " " << key;	*ai.tag << " " << key;
if(value.is_string() \|\| value.as_double()>=0)	if(value.is_string() \|\| value.as_int()>=0)
*ai.tag << "=\"" << value.as_string() << "\"";	*ai.tag << "=\"" << value.as_string() << "\"";
}	}
static void _html(Request& r, const String& method_name, MethodParams *params) {	static void _html(Request& r, const String& method_name, MethodParams *params) {
Line 309 static void _html(Request& r, const Stri	Line 311 static void _html(Request& r, const Stri
const Hash& fields=static_cast<VImage *>(r.self)->fields();	const Hash& fields=static_cast<VImage *>(r.self)->fields();
Hash *attribs=0;	Hash *attribs=0;

if(params->size())	if(params->size()) {
if(attribs=params->get(0).get_hash()) {	Value &vattribs=params->get(0);
Attrib_info attrib_info={&tag, 0};	if(vattribs.is_defined()) // allow 'void'
attribs->for_each(append_attrib_pair, &attrib_info);	if(Hash *attribs=vattribs.get_hash()) {
} else	Attrib_info attrib_info={&tag, 0};
PTHROW(0, 0,	attribs->for_each(append_attrib_pair, &attrib_info);
&method_name,	} else
"attributes must be must be hash");	PTHROW(0, 0,
	&method_name,
	"attributes must be hash");
	}

Attrib_info attrib_info={&tag, attribs};	Attrib_info attrib_info={&tag, attribs};
fields.for_each(append_attrib_pair, &attrib_info);	fields.for_each(append_attrib_pair, &attrib_info);
Line 328 static gdImage *load(Request& r, const S	Line 333 static gdImage *load(Request& r, const S
const String& file_name){	const String& file_name){
Pool& pool=r.pool();	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")) {	if(FILE *f=fopen(file_name_cstr, "rb")) {
gdImage& image=*new(pool) gdImage(pool);	gdImage& image=*new(pool) gdImage(pool);
bool ok=image.CreateFromGif(f);	bool ok=image.CreateFromGif(f);
Line 350 static gdImage *load(Request& r, const S	Line 355 static gdImage *load(Request& r, const S
static void _load(Request& r, const String& method_name, MethodParams *params) {	static void _load(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();

Value& vfile_name=params->get_no_junction(0, "file name must not be code");	const String& file_name=params->as_string(0, "file name must not be code");
const String& file_name=vfile_name.as_string();

gdImage& image=*load(r, method_name, file_name);	gdImage& image=*load(r, method_name, file_name);
int width=image.SX();	int width=image.SX();
Line 362 static void _load(Request& r, const Stri	Line 366 static void _load(Request& r, const Stri
static void _create(Request& r, const String& method_name, MethodParams *params) {	static void _create(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();

int width=(int)r.process(params->get(0)).as_double();	int width=params->as_int(0, r);
int height=(int)r.process(params->get(1)).as_double();	int height=params->as_int(1, r);
int bgcolor_value=0xffFFff;	int bgcolor_value=0xffFFff;
if(params->size()>2)	if(params->size()>2)
bgcolor_value=(int)r.process(params->get(2)).as_double();	bgcolor_value=params->as_int(2, r);
gdImage& image=*new(pool) gdImage(pool);	gdImage& image=*new(pool) gdImage(pool);
image.Create(width, height);	image.Create(width, height);
image.FilledRectangle(0, 0, width-1, height-1, image.Color(bgcolor_value));	image.FilledRectangle(0, 0, width-1, height-1, image.Color(bgcolor_value));
Line 387 static void _gif(Request& r, const Strin	Line 391 static void _gif(Request& r, const Strin
String out(pool); image->Gif(out);	String out(pool); image->Gif(out);

VFile& vfile=*new(pool) VFile(pool);	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/,	vfile.set(false/not tainted/,
out.cstr(String::UL_AS_IS), out.size(), 0, &image_gif);	out.cstr(String::UL_AS_IS), out.size(), 0, content_type);

r.write_no_lang(vfile);	r.write_no_lang(vfile);
}	}
Line 404 static void _line(Request& r, const Stri	Line 408 static void _line(Request& r, const Stri
"does not contain an image");	"does not contain an image");

image->Line(	image->Line(
(int)r.process(params->get(0)).as_double(),	params->as_int(0, r),
(int)r.process(params->get(1)).as_double(),	params->as_int(1, r),
(int)r.process(params->get(2)).as_double(),	params->as_int(2, r),
(int)r.process(params->get(3)).as_double(),	params->as_int(3, r),
image->Color((int)r.process(params->get(4)).as_double()));	image->Color(params->as_int(4, r)));
}	}

static void _fill(Request& r, const String& method_name, MethodParams *params) {	static void _fill(Request& r, const String& method_name, MethodParams *params) {
Line 421 static void _fill(Request& r, const Stri	Line 425 static void _fill(Request& r, const Stri
"does not contain an image");	"does not contain an image");

image->Fill(	image->Fill(
(int)r.process(params->get(0)).as_double(),	params->as_int(0, r),
(int)r.process(params->get(1)).as_double(),	params->as_int(1, r),
image->Color((int)r.process(params->get(2)).as_double()));	image->Color(params->as_int(2, r)));
}	}

static void _rectangle(Request& r, const String& method_name, MethodParams *params) {	static void _rectangle(Request& r, const String& method_name, MethodParams *params) {
Line 436 static void _rectangle(Request& r, const	Line 440 static void _rectangle(Request& r, const
"does not contain an image");	"does not contain an image");

image->Rectangle(	image->Rectangle(
(int)r.process(params->get(0)).as_double(),	params->as_int(0, r),
(int)r.process(params->get(1)).as_double(),	params->as_int(1, r),
(int)r.process(params->get(2)).as_double(),	params->as_int(2, r),
(int)r.process(params->get(3)).as_double(),	params->as_int(3, r),
image->Color((int)r.process(params->get(4)).as_double()));	image->Color(params->as_int(4, r)));
}	}

static void _bar(Request& r, const String& method_name, MethodParams *params) {	static void _bar(Request& r, const String& method_name, MethodParams *params) {
Line 453 static void _bar(Request& r, const Strin	Line 457 static void _bar(Request& r, const Strin
"does not contain an image");	"does not contain an image");

image->FilledRectangle(	image->FilledRectangle(
(int)r.process(params->get(0)).as_double(),	params->as_int(0, r),
(int)r.process(params->get(1)).as_double(),	params->as_int(1, r),
(int)r.process(params->get(2)).as_double(),	params->as_int(2, r),
(int)r.process(params->get(3)).as_double(),	params->as_int(3, r),
image->Color((int)r.process(params->get(4)).as_double()));	image->Color(params->as_int(4, 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)++;
}	}
	#endif
static void _replace(Request& r, const String& method_name, MethodParams *params) {	static void _replace(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();

Line 469 static void _replace(Request& r, const S	Line 483 static void _replace(Request& r, const S
&method_name,	&method_name,
"does not contain an image");	"does not contain an image");

if((params->size()-2)%2) // I see your thoughts, but that's more readable	Table *table=params->as_no_junction(2, "coordinates must not be code").get_table();
	if(!table)
	PTHROW(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, r)), // src color
	image->Color(params->as_int(1, r)));// dest color
	}

	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)
PTHROW(0, 0,	PTHROW(0, 0,
&method_name,	&method_name,
"y coordinate missing");	"does not contain an image");

int n=(params->size()-2)/2;	Table *table=params->as_no_junction(1, "coordinates must not be code").get_table();
	if(!table)
gdImage::Point p=(gdImage::Point )pool.malloc(sizeof(gdImage::Point)*n);	PTHROW(0, 0,
for(int i=0; i<n; i++) {	&method_name,
p[i].x=(int)r.process(params->get(2+i*2+0)).as_double();	"coordinates must be table");
p[i].y=(int)r.process(params->get(2+i*2+1)).as_double();
}	gdImage::Point all_p=(gdImage::Point )pool.malloc(sizeof(gdImage::Point)*table->size());
image->FilledPolygonReplaceColor(p, n,	gdImage::Point *add_p=all_p;
image->Color((int)r.process(params->get(0)).as_double()), // src color	table->for_each(add_point, &add_p);
image->Color((int)r.process(params->get(1)).as_double()));// dest color	image->Polygon(all_p, table->size(),
	image->Color(params->as_int(0, r)),
	false/not closed/);
}	}

static void _polygon(Request& r, const String& method_name, MethodParams *params) {	static void _polygon(Request& r, const String& method_name, MethodParams *params) {
Line 495 static void _polygon(Request& r, const S	Line 529 static void _polygon(Request& r, const S
&method_name,	&method_name,
"does not contain an image");	"does not contain an image");

if((params->size()-1)%2) // [I see..] see now?	Table *table=params->as_no_junction(1, "coordinates must not be code").get_table();
PTHROW(0, 0,	if(!table)
&method_name,	PTHROW(0, 0,
"y coordinate missing");	&method_name,
	"coordinates must be table");
int n=(params->size()-1)/2;
	gdImage::Point all_p=(gdImage::Point )pool.malloc(sizeof(gdImage::Point)*table->size());
gdImage::Point p=(gdImage::Point )pool.malloc(sizeof(gdImage::Point)*n);	gdImage::Point *add_p=all_p;
for(int i=0; i<n; i++) {	table->for_each(add_point, &add_p);
p[i].x=(int)r.process(params->get(1+i*2+0)).as_double();	image->Polygon(all_p, table->size(),
p[i].y=(int)r.process(params->get(1+i*2+1)).as_double();	image->Color(params->as_int(0, r)));
}
image->Polygon(p, n,
image->Color((int)r.process(params->get(0)).as_double()));
}	}

static void _polybar(Request& r, const String& method_name, MethodParams *params) {	static void _polybar(Request& r, const String& method_name, MethodParams *params) {
Line 520 static void _polybar(Request& r, const S	Line 551 static void _polybar(Request& r, const S
&method_name,	&method_name,
"does not contain an image");	"does not contain an image");

if((params->size()-1)%2) // [I see..] see now?	Table *table=params->as_no_junction(1, "coordinates must not be code").get_table();
PTHROW(0, 0,	if(!table)
&method_name,	PTHROW(0, 0,
"y coordinate missing");	&method_name,
	"coordinates must be table");
int n=(params->size()-1)/2;
	gdImage::Point all_p=(gdImage::Point )pool.malloc(sizeof(gdImage::Point)*table->size());
gdImage::Point p=(gdImage::Point )pool.malloc(sizeof(gdImage::Point)*n);	gdImage::Point *add_p=all_p;
for(int i=0; i<n; i++) {	table->for_each(add_point, &add_p);
p[i].x=(int)r.process(params->get(1+i*2+0)).as_double();	image->FilledPolygon(all_p, table->size(),
p[i].y=(int)r.process(params->get(1+i*2+1)).as_double();	image->Color(params->as_int(0, r)));
}
image->FilledPolygon(p, n,
image->Color((int)r.process(params->get(0)).as_double()));
}	}

// font	// font
Line 544 static void _polybar(Request& r, const S	Line 572 static void _polybar(Request& r, const S
class Font : public Pooled {	class Font : public Pooled {
public:	public:

int height; /* Font heigth */	const static int letter_spacing;
int space; /* Default char width */	int height; ///< Font heigth
	int monospace; ///< Default char width
	int spacebarspace; ///< spacebar width
gdImage& ifont;	gdImage& ifont;
const String& alphabet;	const String& alphabet;

Font(Pool& pool,	Font(Pool& pool,
const String& aalphabet,	const String& aalphabet,
gdImage& aifont, int aheight, int aspace) : Pooled(pool),	gdImage& aifont, int aheight, int amonospace, int aspacebarspace) : Pooled(pool),
alphabet(aalphabet),	alphabet(aalphabet),
height(aheight), space(aspace),	height(aheight), monospace(amonospace), spacebarspace(aspacebarspace),
ifont(aifont) {	ifont(aifont) {
}	}

Line 566 public:	Line 596 public:

int index_width(int index) {	int index_width(int index) {
if(index<0)	if(index<0)
index=index_of('.');	return spacebarspace;
if(index<0)
return 0;
int tr=ifont.GetTransparent();	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++)	for(int y=0; y<height-1; y++)
if(ifont.GetPixel(x, Y(y))!=tr)	if(ifont.GetPixel(x, Y(y))!=tr)
return x+2;	return x+1;
}	}
return 0;	return 0;
}	}
Line 598 public:	Line 626 public:
if(cstr) for(; *cstr; cstr++) {	if(cstr) for(; *cstr; cstr++) {
int index=index_of(*cstr);	int index=index_of(*cstr);
index_display(image, x, y, index);	index_display(image, x, y, index);
x+=space ? space : index_width(index);	x+=letter_spacing + (monospace ? monospace : index_width(index));
}	}
}	}

};	};
	const int Font::letter_spacing=1;

static void _font(Request& r, const String& method_name, MethodParams *params) {	static void _font(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();

Value& valphabet=params->get_no_junction(0, "alphabet must not be code");	const String& alphabet=params->as_string(0, "alphabet must not be code");
Value& file_name=params->get_no_junction(1, "file_name must not be code");	gdImage& image=*load(r, method_name, params->as_string(1, "file_name must not be code"));
int height=(int)r.process(params->get(2)).as_double();	int spacebar_width=params->as_int(2, r);
	int monospace_width;
int width=params->size()>3?(int)r.process(params->get(3)).as_double():0;	if(params->size()>3) {
	monospace_width=params->as_int(3, r);
	if(!monospace_width)
	monospace_width=image.SX();
	} else
	monospace_width=0;

	if(!alphabet.size())
	PTHROW(0, 0,
	&method_name,
	"alphabet must not be empty");

static_cast<VImage *>(r.self)->font=new(pool) Font(pool,	static_cast<VImage *>(r.self)->font=new(pool) Font(pool,
valphabet.as_string(),	alphabet,
*load(r, method_name, file_name.as_string()),	image,
height, width);	image.SY() / alphabet.size(), monospace_width, spacebar_width);
}	}

static void _text(Request& r, const String& method_name, MethodParams *params) {	static void _text(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();

int x=(int)r.process(params->get(0)).as_double();	int x=params->as_int(0, r);
int y=(int)r.process(params->get(1)).as_double();	int y=params->as_int(1, r);
const String& s=r.process(params->get(2)).as_string();	const String& s=params->as_string(2, "text must not be code");

VImage& vimage=static_cast<VImage >(r.self);	VImage& vimage=static_cast<VImage >(r.self);
if(vimage.image)	if(vimage.image)
Line 674 MImage::MImage(Pool& apool) : Methoded(a	Line 714 MImage::MImage(Pool& apool) : Methoded(a
// ^image.bar(x0;y0;x1;y1;color)	// ^image.bar(x0;y0;x1;y1;color)
add_native_method("bar", Method::CT_DYNAMIC, _bar, 5, 5);	add_native_method("bar", Method::CT_DYNAMIC, _bar, 5, 5);

// ^image.replace(color-source;color-dest)(x;y)... point coord pairs	// ^image.replace(color-source;color-dest)[table x:y]
add_native_method("replace", Method::CT_DYNAMIC, _replace, 2+32, 2+1002);	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	// ^image.polygon(color)[table x:y]
add_native_method("polygon", Method::CT_DYNAMIC, _polygon, 1+32, 1+1002);	add_native_method("polygon", Method::CT_DYNAMIC, _polygon, 2, 2);

// ^image.polybar(color)(x;y)... point coord pairs	// ^image.polybar(color)[table x:y]
add_native_method("polybar", Method::CT_DYNAMIC, _polybar, 1+32, 1+1002);	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](spacebar_width)
// ^image.font[alPHAbet;font-file-name.gif](height;width)	// ^image.font[alPHAbet;font-file-name.gif](spacebar_width;width)
add_native_method("font", Method::CT_DYNAMIC, _font, 3, 4);	add_native_method("font", Method::CT_DYNAMIC, _font, 3, 4);

// ^image.text(x;y)[text]	// ^image.text(x;y)[text]

E-mail:

Removed from v.1.25
changed lines
	Added in v.1.46