[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.15 and 1.22

version 1.15, 2001/04/12 14:50:26 version 1.22, 2001/04/28 08:43:47
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 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$
 */  */
   
 #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 17
 #include "pa_vfile.h"  #include "pa_vfile.h"
 #include "pa_vimage.h"  #include "pa_vimage.h"
   
 // global var  // defines
   
   #define IMAGE_CLASS_NAME "image"
   
   // class
   
   class MImage : public Methoded {
   public: // VStateless_class
           
           Value *create_new_value(Pool& pool) { return new(pool) VImage(pool); }
   
   public:
           MImage(Pool& pool);
           bool used_directly() { return true; }
   
 VStateless_class *image_class;  };
   
 // helpers  // helpers
   
   /// simple buffered reader[from memory/file], used in _measure
 class Measure_reader {  class Measure_reader {
 public:  public:
         enum { READ_CHUNK_SIZE=0x400 }; // 1K          enum { READ_CHUNK_SIZE=0x400 };// 1K
         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) : 
                 func(afunc), info(ainfo),                   func(afunc), info(ainfo), 
Line 45  public: Line 53  public:
                                 size=(*func)(chunk, READ_CHUNK_SIZE, info);                                  size=(*func)(chunk, READ_CHUNK_SIZE, info);
                                 offset=0;                                  offset=0;
                         } else                          } else
                                 return 0; // as if EOF                                  return 0;// as if EOF
                 if(!size) // EOF                  if(!size) // EOF
                         return 0;                          return 0;
                                                   
Line 65  private: Line 73  private:
         size_t size;          size_t size;
 };  };
   
 // GIF  /// GIF file header
 struct GIF_Header {  struct GIF_Header {
         char       type[3];          // 'GIF'          char       type[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 84  struct GIF_Header {
         char       nulls;          char       nulls;
 };  };
   
 // JPEG  /// JPEG file header
 struct JFIF_Header {  struct JFIF_Header {
         char length[2];               // length of JFIF segment marker          char length[2];              // length of JFIF segment marker
         char identifier[5];           // JFIF identifier          char identifier[5];          // JFIF identifier
         char version[2];              // version          char version[2];             // version
         char units;                   // units X of Y pixel density          char units;                  // units X of Y pixel density
         char xdensity[2];             // X pixel density          char xdensity[2];            // X pixel density
         char ydensity[2];             // X pixel density          char ydensity[2];            // X pixel density
         char xthumbnails;             // width of thumbnails          char xthumbnails;            // width of thumbnails
         char ythumbnails;             // height of thumbnails          char ythumbnails;            // height of thumbnails
         char reserved;                // reserved          char reserved;               // reserved
 };  };
   /// JPEG frame header
 struct JPG_Frame {  struct JPG_Frame {
         char length[2];                // length of image marker          char length[2];               // length of image marker
         char data;                     // data precision of bits/sample          char data;                    // data precision of bits/sample
         char height[2];                // image height          char height[2];               // image height
         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 bytes_to_int(unsigned char HI, unsigned char LO) {
         return (short)((HI<<8) + LO);          return(short)((HI<<8) + LO);
 }  }
   
 void measure_gif(Pool& pool, const String *origin_string,   void measure_gif(Pool& pool, const String *origin_string, 
Line 138  void measure_jpeg(Pool& pool, const Stri Line 147  void measure_jpeg(Pool& pool, const Stri
         bool flag=false;          bool flag=false;
                   
         unsigned char *prefix;          unsigned char *prefix;
         const prefix_size=2;          const size_t prefix_size=2;
         if(reader.read(prefix, prefix_size)<prefix_size)          if(reader.read(prefix, prefix_size)<prefix_size)
                 PTHROW(0, 0,                   PTHROW(0, 0, 
                         origin_string,                           origin_string, 
Line 184  void measure_jpeg(Pool& pool, const Stri Line 193  void measure_jpeg(Pool& pool, const Stri
                 width=bytes_to_int(h.width[0], h.width[1]);                  width=bytes_to_int(h.width[0], h.width[1]);
                 height=bytes_to_int(h.height[0], h.height[1]);                  height=bytes_to_int(h.height[0], h.height[1]);
         } else          } else
                 PTHROW(0, 0,                  PTHROW(0, 0, 
                         origin_string,                          origin_string, 
                         "broken JPEG file - APP0 frame not found");                                               "broken JPEG file - APP0 frame not found");                     
 }  }
   
Line 209  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");
 }  }
   
 // read from somewhere  /// used by image: _measure / read_mem
   
 struct Read_mem_info {  struct Read_mem_info {
         unsigned char *ptr;          unsigned char *ptr;
         unsigned char *eof;          unsigned char *eof;
Line 223  static size_t read_mem(void*& buf, size_ Line 231  static size_t read_mem(void*& buf, size_
         return read_size;          return read_size;
 }  }
   
   /// used by image: _measure / read_disk
 struct Read_disk_info {  struct Read_disk_info {
         const String *file_spec;          const String *file_spec;
         size_t offset;          size_t offset;
Line 245  static size_t read_disk(void*& buf, size Line 254  static size_t read_disk(void*& buf, size
 // methods  // methods
   
 /// ^image:measure[DATA]  /// ^image:measure[DATA]
 static void _measure(Request& r, const String& method_name, Array *params) {  static void _measure(Request& r, const String& method_name, MethodParams *params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         Value& data=*static_cast<Value *>(params->get(0));          Value& data=params->get_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;           void *info;Measure_reader::Func read_func;
         Read_mem_info read_mem_info;          Read_mem_info read_mem_info;
         Read_disk_info read_disk_info;          Read_disk_info read_disk_info;
         const String *file_name;          const String *file_name;
Line 260  static void _measure(Request& r, const S Line 267  static void _measure(Request& r, const S
                 file_name=data.get_string();                  file_name=data.get_string();
                 read_disk_info.file_spec=&r.absolute(*file_name);                  read_disk_info.file_spec=&r.absolute(*file_name);
                 read_disk_info.offset=0;                  read_disk_info.offset=0;
                 info=&read_disk_info; read_func=read_disk;                  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();                  read_mem_info.ptr=(unsigned char *)vfile.value_ptr();
                 read_mem_info.eof=read_mem_info.ptr+vfile.value_size();                  read_mem_info.eof=read_mem_info.ptr+vfile.value_size();
                 info=&read_mem_info; read_func=read_mem;                  info=&read_mem_info;read_func=read_mem;
         }          }
   
         Measure_reader reader(read_func, info);          Measure_reader reader(read_func, info);
Line 276  static void _measure(Request& r, const S Line 283  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
 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]
 };  };
 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 292  static void append_attrib_pair(const Has Line 300  static void append_attrib_pair(const Has
         if(value.is_string() || value.as_double()>=0)          if(value.is_string() || value.as_double()>=0)
                 *ai.tag << "=\"" << value.as_string() << "\"";                  *ai.tag << "=\"" << value.as_string() << "\"";
 }  }
 /// ^image.html[]  /**     ^image.html[]
 /// ^image.html[hash]          ^image.html[hash]
 static void _html(Request& r, const String& method_name, Array *params) {  */
   static void _html(Request& r, const String& method_name, MethodParams *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.self)->fields();
         Hash *attribs=0;          Hash *attribs=0;
   
         if(params->size())          if(params->size())
                 if(attribs=static_cast<Value *>(params->get(0))->get_hash()) {                  if(attribs=params->get(0).get_hash()) {
                         Attrib_info attrib_info={&tag, 0};                          Attrib_info attrib_info={&tag, 0};
                         attribs->for_each(append_attrib_pair, &attrib_info);                          attribs->for_each(append_attrib_pair, &attrib_info);
                 } else                  } else
                         PTHROW(0, 0,                          PTHROW(0, 0, 
                                 &method_name,                                  &method_name, 
                                 "attributes must be must be hash");                                  "attributes must be must be hash");
   
         Attrib_info attrib_info={&tag, attribs};          Attrib_info attrib_info={&tag, attribs};
Line 318  static void _html(Request& r, const Stri Line 327  static void _html(Request& r, const Stri
         r.write_pass_lang(tag);          r.write_pass_lang(tag);
 }  }
   
 /// ^image.load[background.gif]  static gdImage *load(Request& r, const String& method_name, 
 static void _load(Request& r, const String& method_name, Array *params) {                                           const String& file_name){
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         Value& vfile_name=*static_cast<Value *>(params->get(0));  
         // 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);          const char *file_name_cstr=r.absolute(file_name).cstr(String::UL_FILE_NAME);
         gdImage& image=*new(pool) gdImage(pool);  
         if(FILE *f=fopen(file_name_cstr, "rb")) {          if(FILE *f=fopen(file_name_cstr, "rb")) {
                   gdImage& image=*new(pool) gdImage(pool);
                 image.CreateFromGif(f);                  image.CreateFromGif(f);
                 int width=image.SX();  
                 int height=image.SY();  
                 fclose(f);                  fclose(f);
                   return &image;
           } else {
                   PTHROW(0, 0, 
                           &method_name, 
                           "can not open '%s'", file_name_cstr);
                   return 0;
           }
   }
   
                 static_cast<VImage *>(r.self)->set(&file_name, width, height, &image);  
         } else  /// ^image.load[background.gif]
                 PTHROW(0, 0,  static void _load(Request& r, const String& method_name, MethodParams *params) {
                         &method_name,          Pool& pool=r.pool();
                         "can not open background image '%s'", file_name_cstr);  
           Value& vfile_name=params->get_no_junction(0, "file name must not be code");
           const String& file_name=vfile_name.as_string();
   
           gdImage& image=*load(r, method_name, file_name);
           int width=image.SX();
           int height=image.SY();
           static_cast<VImage *>(r.self)->set(&file_name, width, height, &image);
 }  }
   
 /// ^image.create[width;height] bgcolor=white  /**     ^image.create[width;height] bgcolor=white
 /// ^image.create[width;height;bgcolor]          ^image.create[width;height;bgcolor]
 static void _create(Request& r, const String& method_name, Array *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(*static_cast<Value *>(params->get(0))).as_double();          int width=(int)r.process(params->get(0)).as_double();
         int height=(int)r.process(*static_cast<Value *>(params->get(1))).as_double();          int height=(int)r.process(params->get(1)).as_double();
         int bgcolor_value=0xffFFff;          int bgcolor_value=0xffFFff;
         if(params->size()>2)          if(params->size()>2)
                 bgcolor_value=                  bgcolor_value=(int)r.process(params->get(2)).as_double();
                         (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));
Line 360  static void _create(Request& r, const St Line 377  static void _create(Request& r, const St
 }  }
   
 /// ^image.gif[]  /// ^image.gif[]
 static void _gif(Request& r, const String& method_name, Array *params) {  static void _gif(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.self)->image;
         if(!image)          if(!image)
                 PTHROW(0, 0,                  PTHROW(0, 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");          String& image_gif=*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(String::UL_AS_IS), out.size(), 0, &image_gif);
   
         r.write_no_lang(vfile);          r.write_no_lang(vfile);
 }  }
   
 /// ^image.line(x0;y0;x1;y1;color)  /// ^image.line(x0;y0;x1;y1;color)
 static void _line(Request& r, const String& method_name, Array *params) {  static void _line(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.self)->image;
         if(!image)          if(!image)
                 PTHROW(0, 0,                  PTHROW(0, 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(),                  (int)r.process(params->get(0)).as_double(), 
                 (int)r.process(*static_cast<Value *>(params->get(1))).as_double(),                  (int)r.process(params->get(1)).as_double(), 
                 (int)r.process(*static_cast<Value *>(params->get(2))).as_double(),                  (int)r.process(params->get(2)).as_double(), 
                 (int)r.process(*static_cast<Value *>(params->get(3))).as_double(),                  (int)r.process(params->get(3)).as_double(), 
                 image->Color((int)r.process(*static_cast<Value *>(params->get(4))).as_double()));                  image->Color((int)r.process(params->get(4)).as_double()));
 }  }
   
 /// ^image.fill(x;y;color)  /// ^image.fill(x;y;color)
 static void _fill(Request& r, const String& method_name, Array *params) {  static void _fill(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.self)->image;
         if(!image)          if(!image)
                 PTHROW(0, 0,                  PTHROW(0, 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(),                  (int)r.process(params->get(0)).as_double(), 
                 (int)r.process(*static_cast<Value *>(params->get(1))).as_double(),                  (int)r.process(params->get(1)).as_double(), 
                 image->Color((int)r.process(*static_cast<Value *>(params->get(2))).as_double()));                  image->Color((int)r.process(params->get(2)).as_double()));
 }  }
   
 /// ^image.rectangle(x0;y0;x1;y1;color)  /// ^image.rectangle(x0;y0;x1;y1;color)
 static void _rectangle(Request& r, const String& method_name, Array *params) {  static void _rectangle(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.self)->image;
         if(!image)          if(!image)
                 PTHROW(0, 0,                  PTHROW(0, 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(),                  (int)r.process(params->get(0)).as_double(), 
                 (int)r.process(*static_cast<Value *>(params->get(1))).as_double(),                  (int)r.process(params->get(1)).as_double(), 
                 (int)r.process(*static_cast<Value *>(params->get(2))).as_double(),                  (int)r.process(params->get(2)).as_double(), 
                 (int)r.process(*static_cast<Value *>(params->get(3))).as_double(),                  (int)r.process(params->get(3)).as_double(), 
                 image->Color((int)r.process(*static_cast<Value *>(params->get(4))).as_double()));                  image->Color((int)r.process(params->get(4)).as_double()));
 }  }
   
 /// ^image.bar(x0;y0;x1;y1;color)  /// ^image.bar(x0;y0;x1;y1;color)
 static void _bar(Request& r, const String& method_name, Array *params) {  static void _bar(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.self)->image;
         if(!image)          if(!image)
                 PTHROW(0, 0,                  PTHROW(0, 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(),                  (int)r.process(params->get(0)).as_double(), 
                 (int)r.process(*static_cast<Value *>(params->get(1))).as_double(),                  (int)r.process(params->get(1)).as_double(), 
                 (int)r.process(*static_cast<Value *>(params->get(2))).as_double(),                  (int)r.process(params->get(2)).as_double(), 
                 (int)r.process(*static_cast<Value *>(params->get(3))).as_double(),                  (int)r.process(params->get(3)).as_double(), 
                 image->Color((int)r.process(*static_cast<Value *>(params->get(4))).as_double()));                  image->Color((int)r.process(params->get(4)).as_double()));
 }  }
   
 /// ^image.replace(color-source;color-dest)(x;y)... point coord pairs  /// ^image.replace(color-source;color-dest)(x;y)... point coord pairs
 static void _replace(Request& r, const String& method_name, Array *params) {  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.self)->image;
         if(!image)          if(!image)
                 PTHROW(0, 0,                  PTHROW(0, 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          if((params->size()-2)%2) // I see your thoughts, but that's more readable
                 PTHROW(0, 0,                  PTHROW(0, 0, 
                         &method_name,                          &method_name, 
                         "y coordinate missing");                          "y coordinate missing");
   
         int n=(params->size()-2)/2;          int n=(params->size()-2)/2;
                   
         gdImage::Point *p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*n);          gdImage::Point *p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*n);
         for(int i=0; i<n; i++) {          for(int i=0; i<n; i++) {
                 p[i].x=(int)r.process(*static_cast<Value *>(params->get(2+i*2+0))).as_double();                  p[i].x=(int)r.process(params->get(2+i*2+0)).as_double();
                 p[i].y=(int)r.process(*static_cast<Value *>(params->get(2+i*2+1))).as_double();                  p[i].y=(int)r.process(params->get(2+i*2+1)).as_double();
         }          }
         image->FilledPolygonReplaceColor(p, n,          image->FilledPolygonReplaceColor(p, n, 
                 image->Color((int)r.process(*static_cast<Value *>(params->get(0))).as_double()), // src color                  image->Color((int)r.process(params->get(0)).as_double()), // src color
                 image->Color((int)r.process(*static_cast<Value *>(params->get(1))).as_double())); // dest color                  image->Color((int)r.process(params->get(1)).as_double()));// dest color
 }  }
   
 /// ^image.polygon(color)(x;y)... point coord pairs  /// ^image.polygon(color)(x;y)... point coord pairs
 static void _polygon(Request& r, const String& method_name, Array *params) {  static void _polygon(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.self)->image;
         if(!image)          if(!image)
                 PTHROW(0, 0,                  PTHROW(0, 0, 
                         &method_name,                          &method_name, 
                         "does not contain an image");                          "does not contain an image");
   
         if((params->size()-1)%2) // [I see..] see now?          if((params->size()-1)%2) // [I see..] see now?
                 PTHROW(0, 0,                  PTHROW(0, 0, 
                         &method_name,                          &method_name, 
                         "y coordinate missing");                          "y coordinate missing");
   
         int n=(params->size()-1)/2;          int n=(params->size()-1)/2;
                   
         gdImage::Point *p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*n);          gdImage::Point *p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*n);
         for(int i=0; i<n; i++) {          for(int i=0; i<n; i++) {
                 p[i].x=(int)r.process(*static_cast<Value *>(params->get(1+i*2+0))).as_double();                  p[i].x=(int)r.process(params->get(1+i*2+0)).as_double();
                 p[i].y=(int)r.process(*static_cast<Value *>(params->get(1+i*2+1))).as_double();                  p[i].y=(int)r.process(params->get(1+i*2+1)).as_double();
         }          }
         image->Polygon(p, n,          image->Polygon(p, n, 
                 image->Color((int)r.process(*static_cast<Value *>(params->get(0))).as_double()));                  image->Color((int)r.process(params->get(0)).as_double()));
 }  }
   
 /// ^image.polybar(color)(x;y)... point coord pairs  /// ^image.polybar(color)(x;y)... point coord pairs
 static void _polybar(Request& r, const String& method_name, Array *params) {  static void _polybar(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.self)->image;
         if(!image)          if(!image)
                 PTHROW(0, 0,                  PTHROW(0, 0, 
                         &method_name,                          &method_name, 
                         "does not contain an image");                          "does not contain an image");
   
         if((params->size()-1)%2) // [I see..] see now?          if((params->size()-1)%2) // [I see..] see now?
                 PTHROW(0, 0,                  PTHROW(0, 0, 
                         &method_name,                          &method_name, 
                         "y coordinate missing");                          "y coordinate missing");
   
         int n=(params->size()-1)/2;          int n=(params->size()-1)/2;
                   
         gdImage::Point *p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*n);          gdImage::Point *p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*n);
         for(int i=0; i<n; i++) {          for(int i=0; i<n; i++) {
                 p[i].x=(int)r.process(*static_cast<Value *>(params->get(1+i*2+0))).as_double();                  p[i].x=(int)r.process(params->get(1+i*2+0)).as_double();
                 p[i].y=(int)r.process(*static_cast<Value *>(params->get(1+i*2+1))).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()));
   }
   
   // font
   
   #define Y(y)(y+index*height+1)
   
   /// simple gdImage-based font storage & text output 
   class Font : public Pooled {
   public:
           
           int height;         /* Font heigth */
           int space;          /* Default char width */
           gdImage& ifont;
           const String& alphabet;
           
           Font(Pool& pool, 
                   const String& aalphabet, 
                   gdImage& aifont, int aheight, int aspace) : Pooled(pool), 
                   alphabet(aalphabet), 
                   height(aheight), space(aspace), 
                   ifont(aifont) {
           }
           
           /* ******************************** char ********************************** */
           
           int index_of(char ch) {
                   if(ch==' ') return -1;
                   return alphabet.pos(&ch, 1);
           }
           
           int index_width(int index) {
                   if(index<0)
                           index=index_of('.');
                   if(index<0) 
                           return 0;
                   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+2;
                   }
                   return 0;
         }          }
         image->FilledPolygon(p, n,          
                 image->Color((int)r.process(*static_cast<Value *>(params->get(0))).as_double()));          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 char *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);
                   if(cstr) for(; *cstr; cstr++) {
                           int index=index_of(*cstr);
                           index_display(image, x, y, index);
                           x+=space ? space : index_width(index);
                   }
           }
           
   };
   /**
           ^image.font[alPHAbet;font-file-name.gif](height)
           ^image.font[alPHAbet;font-file-name.gif](height;width)
   */
   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;
   
           static_cast<VImage *>(r.self)->font=new(pool) Font(pool, 
                   valphabet.as_string(), 
                   *load(r, method_name, file_name.as_string()), 
                   height, width);
 }  }
   
 // initialize  /// ^image.text(x;y)[text]
 void initialize_image_class(Pool& pool, VStateless_class& vclass) {  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();
   
           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,
                                   &method_name,
                                   "set the font first");
           else
                   PTHROW(0, 0, 
                           &method_name, 
                           "does not contain an image");
   }
   
   // constructor
   
   MImage::MImage(Pool& apool) : Methoded(apool) {
           set_name(*NEW String(pool(), IMAGE_CLASS_NAME));
   
   
         // ^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)(x;y)... point coord pairs          /// ^image.replace(color-source;color-dest)(x;y)... point coord pairs
         vclass.add_native_method("replace", Method::CT_DYNAMIC, _replace, 2+3*2, 2+100*2);          add_native_method("replace", Method::CT_DYNAMIC, _replace, 2+3*2, 2+100*2);
   
         /// ^image.polygon(color)(x;y)... point coord pairs          /// ^image.polygon(color)(x;y)... point coord pairs
         vclass.add_native_method("polygon", Method::CT_DYNAMIC, _polygon, 1+3*2, 1+100*2);          add_native_method("polygon", Method::CT_DYNAMIC, _polygon, 1+3*2, 1+100*2);
   
         /// ^image.polybar(color)(x;y)... point coord pairs          /// ^image.polybar(color)(x;y)... point coord pairs
         vclass.add_native_method("polybar", Method::CT_DYNAMIC, _polybar, 1+3*2, 1+100*2);          add_native_method("polybar", Method::CT_DYNAMIC, _polybar, 1+3*2, 1+100*2);
   
       /// ^image.font[alPHAbet;font-file-name.gif](height)
       /// ^image.font[alPHAbet;font-file-name.gif](height;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);
           
   }
   
   // global variable
   
   Methoded *image_class;
   
   // creator
   
   Methoded *MImage_create(Pool& pool) {
           return image_class=new(pool) MImage(pool);
 }  }
Removed from v.1.15  
changed lines
  Added in v.1.22

E-mail: