[BACK]Return to image.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/image.C between versions 1.14 and 1.79

version 1.14, 2001/04/12 14:08:57 version 1.79, 2002/11/21 11:04:39
Line 1 Line 1
 /** @file  /** @file
         Parser: @b image parser class.          Parser: @b image parser class.
   
         Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)          Copyright(c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)
           Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
   */
   
         Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)  static const char* IDENT_IMAGE_C="$Date$";
   
         $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 <stdio.h>  
   
 #ifdef WIN32  
 #       include "smtp/smtp.h"  
 #endif  
   
 #include "gif.h"  #include "gif.h"
   
 #include "pa_common.h"  #include "pa_common.h"
Line 23 Line 25
 #include "pa_vfile.h"  #include "pa_vfile.h"
 #include "pa_vimage.h"  #include "pa_vimage.h"
   
 // global var  // class
   
   class MImage : public Methoded {
   public: // VStateless_class
           Value *create_new_value(Pool& pool) { return new(pool) VImage(pool); }
   
   public:
           MImage(Pool& pool);
   
 VStateless_class *image_class;  public: // Methoded
           bool used_directly() { return true; }
   
   };
   
 // helpers  // helpers
   
   #ifndef DOXYGEN
 class Measure_reader {  class Measure_reader {
 public:  public:
         enum { READ_CHUNK_SIZE=0x400 }; // 1K          virtual size_t read(const void *&buf, size_t limit)=0;
         typedef size_t (*Func)(void *& buf, size_t limit, void *info);          virtual void seek(long value, int whence)=0;
           virtual long tell()=0;
   };
   
         Measure_reader(Func afunc, void *ainfo) :   class Measure_file_reader: public Measure_reader {
                 func(afunc), info(ainfo),   public:
                 chunk(0), offset(0), size(0) {          Measure_file_reader(Pool& apool, int af, const String& afile_name, const char *afname): 
                   pool(apool), file_name(afile_name), fname(afname), f(af) {
         }          }
   
         size_t read(unsigned char *& buf, size_t limit) {          /*override*/size_t read(const void *&abuf, size_t limit) {
                 if(offset+limit>size) // nothing left                  if(limit==0)
                         if(offset==0 || limit==1) { // only one-byte continuations allowed  
                                 size=(*func)(chunk, READ_CHUNK_SIZE, info);  
                                 offset=0;  
                         } else  
                                 return 0; // as if EOF  
                 if(!size) // EOF  
                         return 0;                          return 0;
                           
                 // something left                  void *lbuf=pool.malloc(limit);
                 size_t read_size=min(offset+limit, size)-offset;                  size_t read_size=(size_t)::read(f, lbuf, limit);  abuf=lbuf;
                 buf=((unsigned char *)chunk)+offset;                  if(ssize_t(read_size)<0 || read_size>limit)
                 offset+=read_size;                          throw Exception(0,
                                   &file_name, 
                                   "measure failed: actually read %lu bytes count not in [0..%lu] valid range", 
                           read_size, limit);
   
                 return read_size;                  return read_size;
         }          }
   
           /*override*/void seek(long value, int whence) {
                   if(lseek(f, value, whence)<0)
                           throw Exception("file.seek",
                                   &file_name, 
                                   "seek(value=%ld, whence=%d) failed: %s (%d), actual filename '%s'", 
                                           value, whence, strerror(errno), errno, fname);
           }
   
           /*override*/long tell() { return ::tell(f); }
   
 private:  private:
         Func func;          Pool& pool;
         void *info;          const String& file_name; const char *fname;
           int f;
   };
   
   class Measure_buf_reader: public Measure_reader {
   public:
           Measure_buf_reader(const void *abuf, size_t asize, const String& afile_name): 
                   buf(abuf), size(asize), file_name(afile_name), offset(0) {
           }
           
           /*override*/size_t read(const void *&abuf, size_t limit) {
                   size_t to_read=min(limit, size-offset);
                   abuf=(const char*)buf+offset;
                   offset+=to_read;
                   return to_read;
           }
   
           /*override*/void seek(long value, int whence) {
                   size_t new_offset;
                   switch(whence) {
                   case SEEK_CUR: new_offset=offset+value; break;
                   case SEEK_SET: new_offset=(size_t)value; break;
                   default: throw Exception("file.seek", 0, "whence #%d not supported", 0, whence); break;
                   }
                   
                   if((ssize_t)new_offset<0 || new_offset>size)
                           throw Exception("file.seek",
                                   &file_name, 
                                   "seek(value=%l, whence=%d) failed: out of buffer, new_offset>size (%l>%l) or new_offset<0", 
                                           value, whence, new_offset, size);
                   offset=new_offset;
           }
   
           /*override*/long tell() { return offset; }
   
   private:
   
           const void *buf; size_t size;
           const String& file_name; 
   
         void *chunk;  
         size_t offset;          size_t offset;
         size_t size;  
 };  };
   
 // GIF  #endif
   
   /// PNG file header
   struct PNG_Header {
           char dummy[12];
           char signature[4]; //< must be "IHDR"
           unsigned char high_width[2]; //< image width high bytes [we ignore for now]
           unsigned char width[2]; //< image width low bytes
           unsigned char high_height[2]; //< image height high bytes [we ignore for now]
           unsigned char height[4]; //< image height
   };
   
   /// GIF file header
 struct GIF_Header {  struct GIF_Header {
         char       type[3];          // 'GIF'          char       signature[3];         // 'GIF'
         char       version[3];          char       version[3];
         unsigned char       width[2];          unsigned char       width[2];
         unsigned char       height[2];          unsigned char       height[2];
Line 76  struct GIF_Header { Line 148  struct GIF_Header {
         char       nulls;          char       nulls;
 };  };
   
 // JPEG  /// 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  /// JPEG frame header
         char ydensity[2];             // X pixel density  struct JPG_Size_segment_body {
         char xthumbnails;             // width of thumbnails          char data;                    //< data precision of bits/sample
         char ythumbnails;             // height of thumbnails          unsigned char height[2];               //< image height
         char reserved;                // reserved          unsigned char width[2];                //< image width
 };          char numComponents;           //< number of color components
 struct JPG_Frame {  };
         char length[2];                // length of image marker  
         char data;                     // data precision of bits/sample  /// JPEG frame header
         char height[2];                // image height  struct JPG_Exif_segment_start {
         char width[2];                 // image width          char signature[6]; // Exif\0\0
         char numComponents;            // number of color components  
 };  };
   
 //  //
   
 inline short bytes_to_int(unsigned char HI, unsigned char LO) {  inline ushort x_endian_to_ushort(unsigned char L, unsigned char H) {
         return (short)((HI<<8) + LO);          return(short)((H<<8) + L);
   }
   
   inline ushort big_endian_to_ushort(unsigned char b[2]) {
           return x_endian_to_ushort(b[1], b[0]);
   }
   
   inline ushort little_endian_to_ushort(unsigned char b[2]) {
           return x_endian_to_ushort(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, ushort& width, ushort& 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,                   throw Exception("image.format", 
                         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->signature, "GIF", 3)!=0)
         if(strncmp(screenD.type, "GIF", 3)!=0)                  throw Exception("image.format", 
                 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_ushort(head->width);
         height=bytes_to_int(screenD.height[1], screenD.height[0]);          height=little_endian_to_ushort(head->height);
 }  }
   
   /// @test remove ugly mech in reader - 20K limit
 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, ushort& width, ushort& 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_A=0xC0;
         const unsigned char APP0=0xE0;          const unsigned char CODE_SIZE_B=0xC1;
         const unsigned char SOF0=0xC0;          const unsigned char CODE_SIZE_C=0xC2;
         const unsigned char SOF2=0xC2;          const unsigned char CODE_SIZE_D=0xC3;
         const unsigned char COM=0xFE;          const unsigned char CODE_EXIF=0xE1;
   
         unsigned char *screenD_buf;          void *buf;
         unsigned char *h_buf=0;          const size_t prefix_size=2;
                   if(reader.read(buf, prefix_size)<prefix_size)
         bool flag=false;                  throw Exception("image.format", 
           
         unsigned char *prefix;  
         const prefix_size=2;  
         if(reader.read(prefix, prefix_size)<prefix_size)  
                 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,                   throw Exception("image.format", 
                         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;  
         unsigned char *marker=&zero;  
   
         do {          while(true) {
                 while((*marker)!=0xFF)                  long segment_base_offset=reader.tell()+2/*marker,code*/;
                         if(reader.read(marker, sizeof(char))<=0) break;                  if(reader.read(buf, sizeof(JPG_Segment_head))<sizeof(JPG_Segment_head))
                 if(reader.read(marker, sizeof(char))<=0) break;  
                 switch(*marker) {  
                 case EOI:  
                         marker=&zero;  
                         break;                          break;
                 case APP0:                  JPG_Segment_head *head=(JPG_Segment_head *)buf;
                         if(!flag) {  
                                 flag=true;          // Verify that it's a valid segment.
                                 if(reader.read(screenD_buf, sizeof(JFIF_Header)) < sizeof(JFIF_Header))                  if(head->marker!=MARKER)
                                         break;                          throw Exception("image.format", 
                                 JFIF_Header& screenD=*reinterpret_cast<JFIF_Header *>(screenD_buf);                                  origin_string, 
                                 if((bytes_to_int(screenD.length[0], screenD.length[1]) < 16) ||                                  "not JPEG file - marker not found");
                                         strcasecmp(screenD.identifier, "JFIF")) flag=false;  
                   switch(head->code) {
                   // http://www.ba.wakwak.com/~tsuruzoh/Computer/Digicams/exif-e.html
                   case CODE_EXIF:
                           {
                                   if(reader.read(buf, sizeof(JPG_Exif_segment_start))<sizeof(JPG_Exif_segment_start))
                                           throw Exception("image.format", 
                                                   origin_string, 
                                                   "not JPEG file - can not fully read Exif segment start");
   
                                   JPG_Exif_segment_start *start=(JPG_Exif_segment_start *)buf;
                                   if(memcmp(start->signature, "Exif\0\0", 4+2)!=0) //signature invalid?
                                           break; // ignore invalid block
   
                                   // parse Exif block
                         }                          }
                         break;                          break;
                 case SOF0:  
                 case SOF2:                  case CODE_SIZE_A:
                         if(reader.read(h_buf, sizeof(JPG_Frame))<sizeof(JPG_Frame))                  case CODE_SIZE_B:
                                 flag=false;                  case CODE_SIZE_C:
                         break;                  case CODE_SIZE_D:
                 default: break;                          {
                 }                                  // Segments that contain size info
         } while(*marker!=EOI);                                  if(reader.read(buf, sizeof(JPG_Size_segment_body))<sizeof(JPG_Size_segment_body))
                                                   throw Exception("image.format", 
         if(flag && h_buf) {                                                  origin_string, 
                 JPG_Frame& h=*reinterpret_cast<JPG_Frame *>(h_buf);                                                  "not JPEG file - can not fully read Size segment");
                 width=bytes_to_int(h.width[0], h.width[1]);                                  JPG_Size_segment_body *body=(JPG_Size_segment_body *)buf;
                 height=bytes_to_int(h.height[0], h.height[1]);                                  
         } else                                  width=big_endian_to_ushort(body->width);
                 PTHROW(0, 0,                                  height=big_endian_to_ushort(body->height);
                         origin_string,                                  return;
                         "broken JPEG file - APP0 frame not found");                                               }                       
                   };
   
                   reader.seek(segment_base_offset+big_endian_to_ushort(head->length), SEEK_SET);
           }
   
           throw Exception("image.format", 
                   origin_string, 
                   "broken JPEG file - size frame not found");
   }
   
   void measure_png(Pool& pool, const String *origin_string, 
                            Measure_reader& reader, ushort& width, ushort& height) {
   
           void *buf;
           const int head_size=sizeof(PNG_Header);
           if(reader.read(buf, head_size)<head_size)
                   throw Exception("image.format", 
                           origin_string, 
                           "not PNG file - too small");
           PNG_Header *head=(PNG_Header *)buf;
   
           if(strncmp(head->signature, "IHDR", 4)!=0)
                   throw Exception("image.format", 
                           origin_string, 
                           "not PNG file - wrong signature");      
   
           width=big_endian_to_ushort(head->width);
           height=big_endian_to_ushort(head->height);
 }  }
   
 // measure center  // measure center
   
 void measure(Pool& pool, const String& file_name,   void measure(Pool& pool, const String& file_name, 
                          Measure_reader& reader, int& width, int& height) {                           Measure_reader& reader, ushort& width, ushort& height) {
         if(const char *cext=strrchr(file_name.cstr(), '.')) {          if(const char *cext=strrchr(file_name.cstr(String::UL_FILE_SPEC), '.')) {
                 cext++;                  cext++;
                 if(strcasecmp(cext, "GIF")==0)                  if(strcasecmp(cext, "GIF")==0)
                         measure_gif(pool, &file_name, reader, width, height);                          measure_gif(pool, &file_name, reader, width, height);
                 else if(strcasecmp(cext, "JPG")==0 || strcasecmp(cext, "JPEG")==0)                   else if(strcasecmp(cext, "JPG")==0 || strcasecmp(cext, "JPEG")==0) 
                         measure_jpeg(pool, &file_name, reader, width, height);                          measure_jpeg(pool, &file_name, reader, width, height);
                   else if(strcasecmp(cext, "PNG")==0)
                           measure_png(pool, &file_name, reader, width, height);
                 else                  else
                         PTHROW(0, 0,                           throw Exception("image.format", 
                                 &file_name,                                   &file_name, 
                                 "unhandled image file name extension '%s'", cext);                                  "unhandled image file name extension '%s'", cext);
         } else          } else
                 PTHROW(0, 0,                   throw Exception("image.format", 
                         &file_name,                           &file_name, 
                         "can not determine image type - no file name extension");                          "can not determine image type - no file name extension");
 }  }
   
 // read from somewhere  // methods
   
 struct Read_mem_info {  
         unsigned char *ptr;  
         unsigned char *eof;  
 };  
 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;  
         size_t read_size=min(limit, (size_t)(rmi.eof-rmi.ptr));  
         rmi.ptr+=read_size;  
         return read_size;  
 }  
   
 struct Read_disk_info {  #ifndef DOXYGEN
         const String *file_spec;  struct File_measure_action_info {
         size_t offset;          ushort *width;
           ushort *height;
           const String *file_name;
 };  };
 static size_t read_disk(void*& buf, size_t limit, void *info) {  #endif
         Read_disk_info& rdi=*static_cast<Read_disk_info *>(info);  static void file_measure_action(Pool& pool,
         Pool& pool=rdi.file_spec->pool();                                                                  int f, 
                                                                   const String& file_spec, const char *fname, bool as_text,
         size_t read_size;                                                                  void *context) {
         file_read(pool, *rdi.file_spec,           File_measure_action_info& info=*static_cast<File_measure_action_info *>(context);
                            buf, read_size,   
                            false/*as_text*/,   
                            true/*fail_on_read_problem*/,   
                            rdi.offset, limit);  
   
         rdi.offset+=read_size;          Measure_file_reader reader(pool, f, *info.file_name, fname);
         return read_size;          measure(pool, *info.file_name, reader, *info.width, *info.height);
 }  }
   
 // methods  static void _measure(Request& r, const String& method_name, MethodParams *params) {
   
 /// ^image:measure[DATA]  
 static void _measure(Request& r, const String& method_name, Array *params) {  
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         Value& data=*static_cast<Value *>(params->get(0));          Value& data=params->as_no_junction(0, "data must not be code");
         // forcing [this body type]  
         r.fail_if_junction_(true, data, method_name, "data must not be code");  
   
         void *info; Measure_reader::Func read_func;           ushort width=0;
         Read_mem_info read_mem_info;          ushort height=0;
         Read_disk_info read_disk_info;  
         const String *file_name;          const String *file_name;
         if(data.is_string()) {          if(file_name=data.get_string()) {
                 file_name=data.get_string();                  File_measure_action_info info={&width, &height, file_name};
                 read_disk_info.file_spec=&r.absolute(*file_name);                  file_read_action_under_lock(pool, r.absolute(*file_name), 
                 read_disk_info.offset=0;                          "measure", file_measure_action, &info);
                 info=&read_disk_info; read_func=read_disk;  
         } else {          } else {
                 const VFile& vfile=*data.as_vfile();                  const VFile& vfile=*data.as_vfile();
                 file_name=&static_cast<Value *>(vfile.fields().get(*name_name))->as_string();                  file_name=&static_cast<Value *>(vfile.fields().get(*name_name))->as_string();
                 read_mem_info.ptr=(unsigned char *)vfile.value_ptr();                  Measure_buf_reader reader(
                 read_mem_info.eof=read_mem_info.ptr+vfile.value_size();                          vfile.value_ptr(),
                 info=&read_mem_info; read_func=read_mem;                          vfile.value_size(),
                           *file_name
                   );
                   measure(pool, *file_name, reader, width, height);
         }          }
   
         Measure_reader reader(read_func, info);          static_cast<VImage *>(r.get_self())->set(file_name, width, height);
         int width, height;  
         measure(pool, *file_name, reader, width, height);  
   
         static_cast<VImage *>(r.self)->set(file_name, width, height);  
 }  }
   
   #ifndef DOXYGEN
 struct Attrib_info {  struct Attrib_info {
         String *tag;          String *tag; ///< html tag being constructed
         Hash *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);
   
         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;                  return;
   
         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() << "\"";
 }  }
 /// ^image.html[]  static void _html(Request& r, const String& method_name, MethodParams *params) {
 /// ^image.html[hash]  
 static void _html(Request& r, const String& method_name, Array *params) {  
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         String tag(pool);          String tag(pool);
         tag << "<img";          tag << "<img";
   
         Hash& fields=static_cast<VImage *>(r.self)->fields();          const Hash& fields=static_cast<VImage *>(r.get_self())->fields();
         Hash *attribs=0;          Hash *attribs=0;
   
         if(params->size())          if(params->size()) {
                 if(attribs=static_cast<Value *>(params->get(0))->get_hash()) {                  // for backward compatibility: someday was ^html{}
                         Attrib_info attrib_info={&tag, 0};                  Value &vattribs=r.process_to_value(params->get(0),
                         attribs->for_each(append_attrib_pair, &attrib_info);                          /*0/*no name* /,*/
                 } else                          false/*don't intercept string*/);
                         PTHROW(0, 0,                  if(vattribs.is_defined()) // allow 'void'
                                 &method_name,                          if(attribs=vattribs.get_hash(&method_name)) {
                                 "attributes must be must be hash");                                  Attrib_info attrib_info={&tag, 0};
                                   attribs->for_each(append_attrib_pair, &attrib_info);
                           } else
                                   throw Exception("parser.runtime", 
                                           &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 318  static void _html(Request& r, const Stri Line 416  static void _html(Request& r, const Stri
         r.write_pass_lang(tag);          r.write_pass_lang(tag);
 }  }
   
 /// ^image.load[background.gif]  /// @test wrap FILE to auto-object
 static void _load(Request& r, const String& method_name, Array *params) {  static gdImage *load(Request& r, const String& method_name, 
                                            const String& file_name){
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         Value& vfile_name=*static_cast<Value *>(params->get(0));          const char *file_name_cstr=r.absolute(file_name).cstr(String::UL_FILE_SPEC);
         // forcing [this body type]  
         r.fail_if_junction_(true, vfile_name, method_name, "file name must not be code");  
         const String& file_name=vfile_name.as_string();  
   
         const char *file_name_cstr=r.absolute(file_name).cstr(String::UL_FILE_NAME);  
         gdImage image(pool);  
         if(FILE *f=fopen(file_name_cstr, "rb")) {          if(FILE *f=fopen(file_name_cstr, "rb")) {
                 image.CreateFromGif(f);                  gdImage& image=*new(pool) gdImage(pool);
                 int width=image.SX();                  bool ok=image.CreateFromGif(f);
                 int height=image.SY();  
                 fclose(f);                  fclose(f);
                   if(!ok)
                           throw Exception("image.format", 
                                   &file_name,
                                   "is not in GIF format");
                   return &image;
           } else {
                   throw Exception("file.missing", 
                           &method_name, 
                           "can not open '%s'", file_name_cstr);
                   return 0;
           }
   }
   
                 static_cast<VImage *>(r.self)->set(&file_name, width, height, &image);  
         } else  static void _load(Request& r, const String& method_name, MethodParams *params) {
                 PTHROW(0, 0,          Pool& pool=r.pool();
                         &method_name,  
                         "can not open background image '%s'", file_name_cstr);          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();
           int height=image.SY();
           static_cast<VImage *>(r.get_self())->set(&file_name, width, height, &image);
 }  }
   
 /// ^image.create[width;height] bgcolor=white  static void _create(Request& r, const String& method_name, MethodParams *params) {
 /// ^image.create[width;height;bgcolor]  
 static void _create(Request& r, const String& method_name, Array *params) {  
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         int width=(int)r.process(*static_cast<Value *>(params->get(0))).as_double();          int width=params->as_int(0, "width must be int", r);
         int height=(int)r.process(*static_cast<Value *>(params->get(1))).as_double();          int height=params->as_int(1, "height must be int", r);
         int bgcolor_value=0xffFFff;          int bgcolor_value=0xffFFff;
         if(params->size()>2)          if(params->size()>2)
                 bgcolor_value=                  bgcolor_value=params->as_int(2, "color must be int", r);
                         (int)r.process(*static_cast<Value *>(params->get(2))).as_double();          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));          static_cast<VImage *>(r.get_self())->set(0, width, height, &image);
         static_cast<VImage *>(r.self)->set(0, width, height, image);  
 }  }
   
 /// ^image.gif[]  static void _gif(Request& r, const String& method_name, MethodParams *params) {
 static void _gif(Request& r, const String& method_name, Array *params) {  
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         gdImage *image=static_cast<VImage *>(r.self)->image;          gdImage *image=static_cast<VImage *>(r.get_self())->image;
         if(!image)          if(!image)
                 PTHROW(0, 0,                  throw Exception(0, 
                         &method_name,                          &method_name, 
                         "does not contain an image");                          "does not contain an image");
   
         // could _ but don't thing it's wise to use $image.src for vfile.name          // could _ but don't thing it's wise to use $image.src for vfile.name
   
         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*/, out.cstr(), out.size(), 0, &image_gif);          vfile.set(false/*not tainted*/, 
                   out.cstr(), out.size(), 0, content_type);
   
         r.write_no_lang(vfile);          r.write_no_lang(vfile);
 }  }
   
 /// ^image.line(x0;y0;x1;y1;color)  static void _line(Request& r, const String& method_name, MethodParams *params) {
 static void _line(Request& r, const String& method_name, Array *params) {  
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         gdImage *image=static_cast<VImage *>(r.self)->image;          gdImage *image=static_cast<VImage *>(r.get_self())->image;
         if(!image)          if(!image)
                 PTHROW(0, 0,                  throw Exception(0, 
                         &method_name,                          &method_name, 
                         "does not contain an image");                          "does not contain an image");
   
         image->Line(          image->Line(
                 (int)r.process(*static_cast<Value *>(params->get(0))).as_double(),                  params->as_int(0, "x0 must be int", r), 
                 (int)r.process(*static_cast<Value *>(params->get(1))).as_double(),                  params->as_int(1, "y0 must be int", r), 
                 (int)r.process(*static_cast<Value *>(params->get(2))).as_double(),                  params->as_int(2, "x1 must be int", r), 
                 (int)r.process(*static_cast<Value *>(params->get(3))).as_double(),                  params->as_int(3, "y1 must be int", r), 
                 image->Color((int)r.process(*static_cast<Value *>(params->get(4))).as_double()));                  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) {
 static void _fill(Request& r, const String& method_name, Array *params) {  
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         gdImage *image=static_cast<VImage *>(r.self)->image;          gdImage *image=static_cast<VImage *>(r.get_self())->image;
         if(!image)          if(!image)
                 PTHROW(0, 0,                  throw Exception(0, 
                         &method_name,                          &method_name, 
                         "does not contain an image");                          "does not contain an image");
   
         image->Fill(          image->Fill(
                 (int)r.process(*static_cast<Value *>(params->get(0))).as_double(),                  params->as_int(0, "x must be int", r), 
                 (int)r.process(*static_cast<Value *>(params->get(1))).as_double(),                  params->as_int(1, "y must be int", r), 
                 image->Color((int)r.process(*static_cast<Value *>(params->get(2))).as_double()));                  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) {
 static void _rectangle(Request& r, const String& method_name, Array *params) {  
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         gdImage *image=static_cast<VImage *>(r.self)->image;          gdImage *image=static_cast<VImage *>(r.get_self())->image;
         if(!image)          if(!image)
                 PTHROW(0, 0,                  throw Exception(0, 
                         &method_name,                          &method_name, 
                         "does not contain an image");                          "does not contain an image");
   
         image->Rectangle(          image->Rectangle(
                 (int)r.process(*static_cast<Value *>(params->get(0))).as_double(),                  params->as_int(0, "x0 must be int", r), 
                 (int)r.process(*static_cast<Value *>(params->get(1))).as_double(),                  params->as_int(1, "y0 must be int", r), 
                 (int)r.process(*static_cast<Value *>(params->get(2))).as_double(),                  params->as_int(2, "x1 must be int", r), 
                 (int)r.process(*static_cast<Value *>(params->get(3))).as_double(),                  params->as_int(3, "y1 must be int", r), 
                 image->Color((int)r.process(*static_cast<Value *>(params->get(4))).as_double()));                  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) {
 static void _bar(Request& r, const String& method_name, Array *params) {  
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         gdImage *image=static_cast<VImage *>(r.self)->image;          gdImage *image=static_cast<VImage *>(r.get_self())->image;
         if(!image)          if(!image)
                 PTHROW(0, 0,                  throw Exception(0, 
                         &method_name,                          &method_name, 
                         "does not contain an image");                          "does not contain an image");
   
         image->FilledRectangle(          image->FilledRectangle(
                 (int)r.process(*static_cast<Value *>(params->get(0))).as_double(),                  params->as_int(0, "x0 must be int", r), 
                 (int)r.process(*static_cast<Value *>(params->get(1))).as_double(),                  params->as_int(1, "y0 must be int", r), 
                 (int)r.process(*static_cast<Value *>(params->get(2))).as_double(),                  params->as_int(2, "x1 must be int", r), 
                 (int)r.process(*static_cast<Value *>(params->get(3))).as_double(),                  params->as_int(3, "y1 must be int", r), 
                 image->Color((int)r.process(*static_cast<Value *>(params->get(4))).as_double()));                  image->Color(params->as_int(4, "color must be int", r)));
 }  }
   
 /// ^image.replace(color-source;color-dest)(x;y)... point coord pairs  #ifndef DOXYGEN
 static void _replace(Request& r, const String& method_name, Array *params) {  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) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         gdImage *image=static_cast<VImage *>(r.self)->image;          gdImage *image=static_cast<VImage *>(r.get_self())->image;
         if(!image)          if(!image)
                 PTHROW(0, 0,                  throw Exception(0, 
                         &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();
                 PTHROW(0, 0,          if(!table) 
                   throw Exception(0,
                         &method_name,                          &method_name,
                         "y coordinate missing");                          "coordinates must be table");
   
         int n=(params->size()-2)/2;          gdImage::Point *all_p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*table->size());
                   gdImage::Point *add_p=all_p;    
         gdImage::Point *p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*n);          table->for_each(add_point, &add_p);
         for(int i=0; i<n; i++) {          image->FilledPolygonReplaceColor(all_p, table->size(), 
                 p[i].x=(int)r.process(*static_cast<Value *>(params->get(2+i*2+0))).as_double();                  image->Color(params->as_int(0, "src color must be int", r)),
                 p[i].y=(int)r.process(*static_cast<Value *>(params->get(2+i*2+1))).as_double();                  image->Color(params->as_int(1, "dest color must be int", r)));
         }  
         image->FilledPolygonReplaceColor(p, n,  
                 image->Color((int)r.process(*static_cast<Value *>(params->get(0))).as_double()), // src color  
                 image->Color((int)r.process(*static_cast<Value *>(params->get(1))).as_double())); // dest color  
 }  }
   
 /// ^image.polygon(color)(x;y)... point coord pairs  static void _polyline(Request& r, const String& method_name, MethodParams *params) {
 static void _polygon(Request& r, const String& method_name, Array *params) {  
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         gdImage *image=static_cast<VImage *>(r.self)->image;          gdImage *image=static_cast<VImage *>(r.get_self())->image;
         if(!image)          if(!image)
                 PTHROW(0, 0,                  throw Exception(0, 
                         &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) 
                   throw Exception(0,
                         &method_name,                          &method_name,
                         "y coordinate missing");                          "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 *add_p=all_p;    
         gdImage::Point *p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*n);          table->for_each(add_point, &add_p);
         for(int i=0; i<n; i++) {          image->Polygon(all_p, table->size(), 
                 p[i].x=(int)r.process(*static_cast<Value *>(params->get(1+i*2+0))).as_double();                  image->Color(params->as_int(0, "color must be int", r)),
                 p[i].y=(int)r.process(*static_cast<Value *>(params->get(1+i*2+1))).as_double();                  false/*not closed*/);
         }  
         image->Polygon(p, n,  
                 image->Color((int)r.process(*static_cast<Value *>(params->get(0))).as_double()));  
 }  }
   
 /// ^image.polybar(color)(x;y)... point coord pairs  static void _polygon(Request& r, const String& method_name, MethodParams *params) {
 static void _polybar(Request& r, const String& method_name, Array *params) {  
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         gdImage *image=static_cast<VImage *>(r.self)->image;          gdImage *image=static_cast<VImage *>(r.get_self())->image;
         if(!image)          if(!image)
                 PTHROW(0, 0,                  throw Exception(0, 
                           &method_name, 
                           "does not contain an image");
   
           Table *table=params->as_no_junction(1, "coordinates must not be code").get_table();
           if(!table) 
                   throw Exception(0,
                         &method_name,                          &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)));
   }
   
   static void _polybar(Request& r, const String& method_name, MethodParams *params) {
           Pool& pool=r.pool();
   
           gdImage *image=static_cast<VImage *>(r.get_self())->image;
           if(!image)
                   throw Exception(0, 
                           &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) 
                   throw Exception("parser.runtime",
                         &method_name,                          &method_name,
                         "y coordinate missing");                          "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)));
   }
   
         int n=(params->size()-1)/2;  // font
   
   #define Y(y)(y+index*height+1)
   
   /// simple gdImage-based font storage & text output 
   class Font : public Pooled {
   public:
           
           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 amonospace, int aspacebarspace) : Pooled(pool), 
                   alphabet(aalphabet), 
                   height(aheight), monospace(amonospace),  spacebarspace(aspacebarspace),
                   ifont(aifont) {
           }
           
           /* ******************************** char ********************************** */
           
           int index_of(char ch) {
                   if(ch==' ') return -1;
                   return alphabet.pos(&ch, 1);
           }
                   
         gdImage::Point *p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*n);          int index_width(int index) {
         for(int i=0; i<n; i++) {                  if(index<0)
                 p[i].x=(int)r.process(*static_cast<Value *>(params->get(1+i*2+0))).as_double();                          return spacebarspace;
                 p[i].y=(int)r.process(*static_cast<Value *>(params->get(1+i*2+1))).as_double();                  int tr=ifont.GetTransparent();
                   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+1;
                   }
                   return 0;
           }
           
           void index_display(gdImage& image, int x, int y, int index){
                   if(index>=0) 
                           ifont.Copy(image, x, y, 0, Y(0), index_width(index), height-1);
           }
           
           /* ******************************** string ********************************** */
           
           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;
         }          }
         image->FilledPolygon(p, n,          
                 image->Color((int)r.process(*static_cast<Value *>(params->get(0))).as_double()));          void string_display(gdImage& image, int x, int y, const String& s){
                   const char *cstr=s.cstr();
                   if(cstr) for(; *cstr; cstr++) {
                           int index=index_of(*cstr);
                           index_display(image, x, y, 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) {
           Pool& pool=r.pool();
   
           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("parser.runtime",
                           &method_name,
                           "alphabet must not be empty");
           
           static_cast<VImage *>(r.get_self())->font=new(pool) Font(pool, 
                   alphabet, 
                   image, 
                   image.SY() / alphabet.size(), monospace_width, spacebar_width);
   }
   
   static void _text(Request& r, const String& method_name, MethodParams *params) {
           Pool& pool=r.pool();
   
           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.get_self());
           if(vimage.image)
                   if(vimage.font)
                           vimage.font->string_display(*vimage.image, x, y, s);
                   else
                           throw Exception("parser.runtime",
                                   &method_name,
                                   "set the font first");
           else
                   throw Exception(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.get_self());
           if(vimage.image)
                   if(vimage.font) {
                           r.write_no_lang(*new(pool) VInt(pool, vimage.font->string_width(s)));
                   } else
                           throw Exception("parser.runtime",
                                   &method_name,
                                   "set the font first");
           else
                   throw Exception(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.get_self())->image;
           if(!image)
                   throw Exception(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.get_self())->image;
           if(!image)
                   throw Exception(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)));
 }  }
   
 // initialize  static void _circle(Request& r, const String& method_name, MethodParams *params) {
 void initialize_image_class(Pool& pool, VStateless_class& vclass) {          Pool& pool=r.pool();
   
           gdImage *image=static_cast<VImage *>(r.get_self())->image;
           if(!image)
                   throw Exception(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) {
           gdImage *src=0;
   
           Value& value=params->as_no_junction(index, msg);
   
           if(Value *vimage=value.as(VIMAGE_TYPE, false)) {
                   src=static_cast<VImage *>(vimage)->image;
                   if(!src)
                           throw Exception("parser.runtime", 
                                   &method_name, 
                                   msg);
           } else
                   throw Exception("parser.runtime", 
                           &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.get_self())->image;
           if(!dest)
                   throw Exception(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, "image") {
         // ^image:measure[DATA]          // ^image:measure[DATA]
         vclass.add_native_method("measure", Method::CT_DYNAMIC, _measure, 1, 1);          add_native_method("measure", Method::CT_DYNAMIC, _measure, 1, 1);
   
         /// ^image.html[]          // ^image.html[]
         /// ^image.html[hash]          // ^image.html[hash]
         vclass.add_native_method("html", Method::CT_DYNAMIC, _html, 0, 1);          add_native_method("html", Method::CT_DYNAMIC, _html, 0, 1);
   
         /// ^image.load[background.gif]          // ^image.load[background.gif]
         vclass.add_native_method("load", Method::CT_DYNAMIC, _load, 1, 1);          add_native_method("load", Method::CT_DYNAMIC, _load, 1, 1);
   
         /// ^image.create[width;height] bgcolor=white          // ^image.create[width;height] bgcolor=white
         /// ^image.create[width;height;bgcolor]          // ^image.create[width;height;bgcolor]
         vclass.add_native_method("create", Method::CT_DYNAMIC, _create, 2, 3);          add_native_method("create", Method::CT_DYNAMIC, _create, 2, 3);
   
         /// ^image.gif[]          // ^image.gif[]
         vclass.add_native_method("gif", Method::CT_DYNAMIC, _gif, 0, 0);          add_native_method("gif", Method::CT_DYNAMIC, _gif, 0, 0);
   
         /// ^image.line(x0;y0;x1;y1;color)          // ^image.line(x0;y0;x1;y1;color)
         vclass.add_native_method("line", Method::CT_DYNAMIC, _line, 5, 5);          add_native_method("line", Method::CT_DYNAMIC, _line, 5, 5);
   
         /// ^image.fill(x;y;color)          // ^image.fill(x;y;color)
         vclass.add_native_method("fill", Method::CT_DYNAMIC, _fill, 3, 3);          add_native_method("fill", Method::CT_DYNAMIC, _fill, 3, 3);
   
         /// ^image.rectangle(x0;y0;x1;y1;color)          // ^image.rectangle(x0;y0;x1;y1;color)
         vclass.add_native_method("rectangle", Method::CT_DYNAMIC, _rectangle, 5, 5);          add_native_method("rectangle", Method::CT_DYNAMIC, _rectangle, 5, 5);
   
         /// ^image.bar(x0;y0;x1;y1;color)          // ^image.bar(x0;y0;x1;y1;color)
         vclass.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)[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)[table x:y]
           add_native_method("polygon", Method::CT_DYNAMIC, _polygon, 2, 2);
   
           // ^image.polybar(color)[table x:y]
           add_native_method("polybar", Method::CT_DYNAMIC, _polybar, 2, 2);
   
       // ^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]
           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);
   }
   
         /// ^image.replace(color-source;color-dest)(x;y)... point coord pairs  // global variable
         vclass.add_native_method("replace", Method::CT_DYNAMIC, _replace, 2+3*2, 2+100*2);  
   
         /// ^image.polygon(color)(x;y)... point coord pairs  Methoded *image_class;
         vclass.add_native_method("polygon", Method::CT_DYNAMIC, _polygon, 1+3*2, 1+100*2);  
   
         /// ^image.polybar(color)(x;y)... point coord pairs  // creator
         vclass.add_native_method("polybar", Method::CT_DYNAMIC, _polybar, 1+3*2, 1+100*2);  
   
   Methoded *MImage_create(Pool& pool) {
           return image_class=new(pool) MImage(pool);
 }  }
Removed from v.1.14  
changed lines
  Added in v.1.79

E-mail: