[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.16 and 1.37

version 1.16, 2001/04/12 16:26:20 version 1.37, 2001/09/01 14:47:11
Line 7 Line 7
   
         $Id$          $Id$
 */  */
   static const char *RCSId="$Id$"; 
   
 #include "pa_config_includes.h"  /*
           jpegsize: gets the width and height (in pixels) of a jpeg file
 #include <stdio.h>          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
   */
   
 #ifdef WIN32  #include "pa_config_includes.h"
 #       include "smtp/smtp.h"  
 #endif  
   
 #include "gif.h"  #include "gif.h"
   
Line 23 Line 27
 #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
   
 VStateless_class *image_class;  class MImage : public Methoded {
   public: // VStateless_class
           Value *create_new_value(Pool& pool) { return new(pool) VImage(pool); }
   
   public:
           MImage(Pool& pool);
   
   public: // Methoded
           bool used_directly() { return true; }
   
   };
   
 // helpers  // 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*10 };// 10K
         typedef size_t(*Func)(void *& buf, size_t limit, void *info);          typedef size_t(*Func)(void *& buf, size_t limit, void *info);
   
         Measure_reader(Func afunc, void *ainfo) :           Measure_reader(Func afunc, void *ainfo) : 
Line 39  public: Line 58  public:
                 chunk(0), offset(0), size(0) {                  chunk(0), offset(0), size(0) {
         }          }
   
         size_t read(unsigned char *& buf, size_t limit) {          size_t read(void *&buf, size_t limit) {
                 if(offset+limit>size) // nothing left                  if(offset+limit>size) // nothing left
                         if(offset==0 || limit==1) { // only one-byte continuations allowed                          if(offset==0 || limit==1) { // only one-byte continuations allowed
                                 size=(*func)(chunk, READ_CHUNK_SIZE, info);                                  size=(*func)(chunk, READ_CHUNK_SIZE, info);
Line 65  private: Line 84  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];
Line 76  struct GIF_Header { Line 95  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  
         char ydensity[2];            // X pixel density  
         char xthumbnails;            // width of thumbnails  
         char ythumbnails;            // height of thumbnails  
         char reserved;               // reserved  
 };  };
 struct JPG_Frame {  /// JPEG frame header
         char length[2];               // length of image marker  struct JPG_Size_segment_body {
         char data;                    // data precision of bits/sample          char data;                    //< data precision of bits/sample
         char height[2];               // image height          unsigned char height[2];               //< image height
         char width[2];                // image width          unsigned char width[2];                //< image width
         char numComponents;           // number of color components          char numComponents;           //< number of color components
 };  };
   
 //  //
   
 inline short bytes_to_int(unsigned char HI, unsigned char LO) {  inline short x_endian_to_int(unsigned char L, unsigned char H) {
         return(short)((HI<<8) + LO);          return(short)((H<<8) + L);
   }
   
   inline short big_endian_to_int(unsigned char b[2]) {
           return x_endian_to_int(b[1], b[0]);
   }
   
   inline short little_endian_to_int(unsigned char b[2]) {
           return x_endian_to_int(b[0], b[1]);
 }  }
   
 void measure_gif(Pool& pool, const String *origin_string,   void measure_gif(Pool& pool, const String *origin_string, 
                          Measure_reader& reader, int& width, int& height) {                           Measure_reader& reader, int& width, int& height) {
   
         unsigned char *buf;          void *buf;
         const int head_size=sizeof(GIF_Header);          const int head_size=sizeof(GIF_Header);
         if(reader.read(buf, head_size)<head_size)          if(reader.read(buf, head_size)<head_size)
                 PTHROW(0, 0,                   PTHROW(0, 0, 
                         origin_string,                           origin_string, 
                         "broken GIF header - file size is less then %d bytes", head_size);                          "not GIF file - too small");
           GIF_Header *head=(GIF_Header *)buf;
   
         GIF_Header& screenD=*reinterpret_cast<GIF_Header *>(buf);          if(strncmp(head->type, "GIF", 3)!=0)
         if(strncmp(screenD.type, "GIF", 3)!=0)  
                 PTHROW(0, 0,                   PTHROW(0, 0, 
                         origin_string,                           origin_string, 
                         "bad image file - GIF signature not found");                              "not GIF file - signature not found");  
   
         width=bytes_to_int(screenD.width[1], screenD.width[0]);          width=little_endian_to_int(head->width);
         height=bytes_to_int(screenD.height[1], screenD.height[0]);          height=little_endian_to_int(head->height);
 }  }
   
 void measure_jpeg(Pool& pool, const String *origin_string,   void measure_jpeg(Pool& pool, const String *origin_string, 
                          Measure_reader& reader, int& width, int& height) {                           Measure_reader& reader, int& width, int& height) {
         // JFIF format markers          // JFIF format markers
         const unsigned char SOI=0xD8;          const unsigned char MARKER=0xFF;
         const unsigned char EOI=0xD9;          const unsigned char CODE_SIZE_FIRST=0xC0;
         const unsigned char APP0=0xE0;          const unsigned char CODE_SIZE_LAST=0xC3;
         const unsigned char SOF0=0xC0;  
         const unsigned char SOF2=0xC2;          void *buf;
         const unsigned char COM=0xFE;          const size_t prefix_size=2;
           if(reader.read(buf, prefix_size)<prefix_size)
         unsigned char *screenD_buf;  
         unsigned char *h_buf=0;  
           
         bool flag=false;  
           
         unsigned char *prefix;  
         const prefix_size=2;  
         if(reader.read(prefix, prefix_size)<prefix_size)  
                 PTHROW(0, 0,                   PTHROW(0, 0, 
                         origin_string,                           origin_string, 
                         "broken JPEG file - size is less then %d bytes", prefix_size);                          "not JPEG file - too small");
           unsigned char *signature=(unsigned char *)buf;
                   
         if(((unsigned char *)prefix)[1]!=SOI)           if(!(signature[0]==0xFF && signature[1]==0xD8)) 
                 PTHROW(0, 0,                   PTHROW(0, 0, 
                         origin_string,                           origin_string, 
                         "broken JPEG file - second byte of header is not 0x%02X", SOI);                          "not JPEG file - signature not found");
                   
         unsigned char zero=0;          bool found=false;
         unsigned char *marker=&zero;          while(true) {
                   void *buf;
         do {          // Extract the segment header.
                 while((*marker)!=0xFF)                  if(reader.read(buf, sizeof(JPG_Segment_head))<sizeof(JPG_Segment_head))
                         if(reader.read(marker, sizeof(char))<=0) break;                          break;          
                 if(reader.read(marker, sizeof(char))<=0) break;                  JPG_Segment_head *head=(JPG_Segment_head *)buf;
                 switch(*marker) {  
                 case EOI:          // Verify that it's a valid segment.
                         marker=&zero;                  if(head->marker!=MARKER)
                         break;  
                 case APP0:  
                         if(!flag) {  
                                 flag=true;  
                                 if(reader.read(screenD_buf, sizeof(JFIF_Header)) < sizeof(JFIF_Header))  
                                         break;  
                                 JFIF_Header& screenD=*reinterpret_cast<JFIF_Header *>(screenD_buf);  
                                 if((bytes_to_int(screenD.length[0], screenD.length[1]) < 16) ||  
                                         strcasecmp(screenD.identifier, "JFIF")) flag=false;  
                         }  
                         break;                          break;
                 case SOF0:  
                 case SOF2:                  if(head->code >= CODE_SIZE_FIRST && head->code  <= CODE_SIZE_LAST) {
                         if(reader.read(h_buf, sizeof(JPG_Frame))<sizeof(JPG_Frame))              // Segments that contain size info
                                 flag=false;                          if(reader.read(buf, sizeof(JPG_Size_segment_body))<sizeof(JPG_Size_segment_body))
                                   break;
                           JPG_Size_segment_body *body=(JPG_Size_segment_body *)buf;
                           
                           width=big_endian_to_int(body->width);
                           height=big_endian_to_int(body->height);
                           found=true;
                         break;                          break;
                 default: break;                  } else {
                 }              // Dummy read to skip over data
         } while(*marker!=EOI);              size_t limit=big_endian_to_int(head->length) - 2;
                                   if(reader.read(buf, limit)<limit)
         if(flag && h_buf) {                                  break;
                 JPG_Frame& h=*reinterpret_cast<JPG_Frame *>(h_buf);          }
                 width=bytes_to_int(h.width[0], h.width[1]);          }
                 height=bytes_to_int(h.height[0], h.height[1]);  
         } else          if(!found)
                 PTHROW(0, 0,                   PTHROW(0, 0, 
                         origin_string,                           origin_string, 
                         "broken JPEG file - APP0 frame not found");                                               "broken JPEG file - size frame not found");
 }  }
   
 // measure center  // measure center
Line 209  void measure(Pool& pool, const String& f Line 219  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 232  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 244  static size_t read_disk(void*& buf, size Line 254  static size_t read_disk(void*& buf, size
   
 // methods  // methods
   
 /// ^image:measure[DATA]  static void _measure(Request& r, const String& method_name, MethodParams *params) {
 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;          void *info;Measure_reader::Func read_func;
         Read_mem_info read_mem_info;          Read_mem_info read_mem_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 289  static void append_attrib_pair(const Has Line 297  static void append_attrib_pair(const Has
         Value& value=*static_cast<Value *>(val);          Value& value=*static_cast<Value *>(val);
         // src="a.gif" width=123 ismap[=-1]          // src="a.gif" width=123 ismap[=-1]
         *ai.tag << " " << key;          *ai.tag << " " << key;
         if(value.is_string() || value.as_double()>=0)          if(value.is_string() || value.as_int()>=0)
                 *ai.tag << "=\"" << value.as_string() << "\"";                  *ai.tag << "=\"" << value.as_string() << "\"";
 }  }
 /// ^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.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
Line 325  static gdImage *load(Request& r, const S Line 331  static gdImage *load(Request& r, const S
         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);
         if(FILE *f=fopen(file_name_cstr, "rb")) {          if(FILE *f=fopen(file_name_cstr, "rb")) {
                 gdImage& image=*new(pool) gdImage(pool);                  gdImage& image=*new(pool) gdImage(pool);
                 image.CreateFromGif(f);                  bool ok=image.CreateFromGif(f);
                 fclose(f);                  fclose(f);
                   if(!ok)
                           PTHROW(0, 0, 
                                   &file_name,
                                   "is not in GIF format");
                 return &image;                  return &image;
         } else {          } else {
                 PTHROW(0, 0,                   PTHROW(0, 0, 
Line 337  static gdImage *load(Request& r, const S Line 347  static gdImage *load(Request& r, const S
 }  }
   
   
 /// ^image.load[background.gif]  static void _load(Request& r, const String& method_name, MethodParams *params) {
 static void _load(Request& r, const String& method_name, Array *params) {  
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         Value& vfile_name=*static_cast<Value *>(params->get(0));          Value& vfile_name=params->as_no_junction(0, "file name must not be code");
         // 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 String& file_name=vfile_name.as_string();
   
         gdImage& image=*load(r, method_name, file_name);          gdImage& image=*load(r, method_name, file_name);
Line 352  static void _load(Request& r, const Stri Line 359  static void _load(Request& r, const Stri
         static_cast<VImage *>(r.self)->set(&file_name, width, height, &image);          static_cast<VImage *>(r.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, r);
         int height=(int)r.process(*static_cast<Value *>(params->get(1))).as_double();          int height=params->as_int(1, r);
         int bgcolor_value=0xffFFff;          int bgcolor_value=0xffFFff;
         if(params->size()>2)          if(params->size()>2)
                 bgcolor_value=                  bgcolor_value=params->as_int(2, 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.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.self)->image;
Line 385  static void _gif(Request& r, const Strin Line 388  static void _gif(Request& r, const Strin
                   
         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)  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.self)->image;
Line 401  static void _line(Request& r, const Stri Line 404  static void _line(Request& r, const Stri
                         "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, r), 
                 (int)r.process(*static_cast<Value *>(params->get(1))).as_double(),                   params->as_int(1, r), 
                 (int)r.process(*static_cast<Value *>(params->get(2))).as_double(),                   params->as_int(2, r), 
                 (int)r.process(*static_cast<Value *>(params->get(3))).as_double(),                   params->as_int(3, r), 
                 image->Color((int)r.process(*static_cast<Value *>(params->get(4))).as_double()));                  image->Color(params->as_int(4, 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.self)->image;
Line 419  static void _fill(Request& r, const Stri Line 421  static void _fill(Request& r, const Stri
                         "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, r), 
                 (int)r.process(*static_cast<Value *>(params->get(1))).as_double(),                   params->as_int(1, r), 
                 image->Color((int)r.process(*static_cast<Value *>(params->get(2))).as_double()));                  image->Color(params->as_int(2, 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.self)->image;
Line 435  static void _rectangle(Request& r, const Line 436  static void _rectangle(Request& r, const
                         "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, r), 
                 (int)r.process(*static_cast<Value *>(params->get(1))).as_double(),                   params->as_int(1, r), 
                 (int)r.process(*static_cast<Value *>(params->get(2))).as_double(),                   params->as_int(2, r), 
                 (int)r.process(*static_cast<Value *>(params->get(3))).as_double(),                   params->as_int(3, r), 
                 image->Color((int)r.process(*static_cast<Value *>(params->get(4))).as_double()));                  image->Color(params->as_int(4, 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.self)->image;
Line 453  static void _bar(Request& r, const Strin Line 453  static void _bar(Request& r, const Strin
                         "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, r), 
                 (int)r.process(*static_cast<Value *>(params->get(1))).as_double(),                   params->as_int(1, r), 
                 (int)r.process(*static_cast<Value *>(params->get(2))).as_double(),                   params->as_int(2, r), 
                 (int)r.process(*static_cast<Value *>(params->get(3))).as_double(),                   params->as_int(3, r), 
                 image->Color((int)r.process(*static_cast<Value *>(params->get(4))).as_double()));                  image->Color(params->as_int(4, r)));
 }  }
   
 /// ^image.replace(color-source;color-dest)(x;y)... point coord pairs  static void _replace(Request& r, const String& method_name, MethodParams *params) {
 static void _replace(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.self)->image;
Line 479  static void _replace(Request& r, const S Line 478  static void _replace(Request& r, const S
                   
         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=params->as_int(2+i*2+0, r);
                 p[i].y=(int)r.process(*static_cast<Value *>(params->get(2+i*2+1))).as_double();                  p[i].y=params->as_int(2+i*2+1, r);
         }          }
         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(params->as_int(0, r)), // src color
                 image->Color((int)r.process(*static_cast<Value *>(params->get(1))).as_double()));// dest color                  image->Color(params->as_int(1, r)));// dest color
 }  }
   
 /// ^image.polygon(color)(x;y)... point coord pairs  static void _polygon(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.self)->image;
Line 506  static void _polygon(Request& r, const S Line 504  static void _polygon(Request& r, const S
                   
         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=params->as_int(2+i*2+0, r);
                 p[i].y=(int)r.process(*static_cast<Value *>(params->get(1+i*2+1))).as_double();                  p[i].y=params->as_int(2+i*2+1, r);
         }          }
         image->Polygon(p, n,           image->Polygon(p, n, 
                 image->Color((int)r.process(*static_cast<Value *>(params->get(0))).as_double()));                  image->Color(params->as_int(0, r)));
 }  }
   
 /// ^image.polybar(color)(x;y)... point coord pairs  static void _polybar(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.self)->image;
Line 532  static void _polybar(Request& r, const S Line 529  static void _polybar(Request& r, const S
                   
         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=params->as_int(2+i*2+0, r);
                 p[i].y=(int)r.process(*static_cast<Value *>(params->get(1+i*2+1))).as_double();                  p[i].y=params->as_int(2+i*2+1, r);
         }          }
         image->FilledPolygon(p, n,           image->FilledPolygon(p, n, 
                 image->Color((int)r.process(*static_cast<Value *>(params->get(0))).as_double()));                  image->Color(params->as_int(0, r)));
 }  }
   
 // font  // font
   
 #define Y(y)(y+index*height+1)  #define Y(y)(y+index*height+1)
   
   /// simple gdImage-based font storage & text output 
 class Font : public Pooled {  class Font : public Pooled {
 public:  public:
                   
         int height;         /* Font heigth */          const static int kerning;
         int space;          /* Default char width */          int height;         ///< Font heigth
           int monospace;      ///< Default char width
           int spacebarspace; ///< spacebar width
         gdImage& ifont;          gdImage& ifont;
         const String& alphabet;          const String& alphabet;
                   
         Font(Pool& pool,           Font(Pool& pool, 
                 const String& aalphabet,                   const String& aalphabet, 
                 gdImage& aifont, int aheight, int aspace) : Pooled(pool),                   gdImage& aifont, int aheight, int amonospace, int aspacebarspace) : Pooled(pool), 
                 alphabet(aalphabet),                   alphabet(aalphabet), 
                 height(aheight), space(aspace),                   height(aheight), monospace(amonospace),  spacebarspace(aspacebarspace),
                 ifont(aifont) {                  ifont(aifont) {
         }          }
                   
Line 567  public: Line 568  public:
                   
         int index_width(int index) {          int index_width(int index) {
                 if(index<0)                  if(index<0)
                         index=index_of('.');                          return spacebarspace;
                 if(index<0)   
                         return 0;  
                 int tr=ifont.GetTransparent();                  int tr=ifont.GetTransparent();
                 for(int x=ifont.SX()-1; x>0; x--) {                  for(int x=ifont.SX()-1; x>=0; x--) {
                         for(int y=0; y<height-1; y++)                          for(int y=0; y<height-1; y++)
                                 if(ifont.GetPixel(x, Y(y))!=tr)                                   if(ifont.GetPixel(x, Y(y))!=tr) 
                                         return x+2;                                          return x+1;
                 }                  }
                 return 0;                  return 0;
         }          }
Line 599  public: Line 598  public:
                 if(cstr) for(; *cstr; cstr++) {                  if(cstr) for(; *cstr; cstr++) {
                         int index=index_of(*cstr);                          int index=index_of(*cstr);
                         index_display(image, x, y, index);                          index_display(image, x, y, index);
                         x+=space ? space : index_width(index);                          x+=kerning + (monospace ? monospace : index_width(index));
                 }                  }
         }          }
                   
 };  };
 /// ^image.font[alPHAbet;font-file-name.gif](height)  const int Font::kerning=1;
 /// ^image.font[alPHAbet;font-file-name.gif](height;width)  
 static void _font(Request& r, const String& method_name, Array *params) {  
         Pool& pool=r.pool();  
   
         Value& valphabet=*static_cast<Value *>(params->get(0));  
         // forcing [this body type]  
         r.fail_if_junction_(true, valphabet, method_name, "alphabet must not be code");  
   
         Value& file_name=*static_cast<Value *>(params->get(1));  static void _font(Request& r, const String& method_name, MethodParams *params) {
         // forcing [this body type]          Pool& pool=r.pool();
         r.fail_if_junction_(true, file_name, method_name, "file_name must not be code");  
   
         Value& vheight=*static_cast<Value *>(params->get(2));  
         int height=(int)r.process(vheight).as_double();  
   
         int width=0;          const String& alphabet=params->as_string(0, "alphabet must not be code");
           gdImage& image=*load(r, method_name, params->as_string(1, "file_name must not be code"));
           int spacebar_width=params->as_int(2, r);
           int monospace_width;
         if(params->size()>3) {          if(params->size()>3) {
                 Value& vwidth=*static_cast<Value *>(params->get(3));                  monospace_width=params->as_int(3, r);
                 width=(int)r.process(vwidth).as_double();                  if(!monospace_width)
         }                          monospace_width=image.SX();
           } else
                   monospace_width=0;
   
           if(!alphabet.size())
                   PTHROW(0, 0,
                           &method_name,
                           "alphabet must not be empty");
           
         static_cast<VImage *>(r.self)->font=new(pool) Font(pool,           static_cast<VImage *>(r.self)->font=new(pool) Font(pool, 
                 valphabet.as_string(),                   alphabet, 
                 *load(r, method_name, file_name.as_string()),                   image, 
                 height, width);                  image.SY() / alphabet.size(), monospace_width, spacebar_width);
 }  }
   
 /// ^image.text(x;y)[text]  static void _text(Request& r, const String& method_name, MethodParams *params) {
 static void _text(Request& r, const String& method_name, Array *params) {  
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         int x=(int)r.process(*static_cast<Value *>(params->get(0))).as_double();          int x=params->as_int(0, r);
         int y=(int)r.process(*static_cast<Value *>(params->get(1))).as_double();          int y=params->as_int(1, r);
         const String& s=          const String& s=params->as_string(2, "text must not be code");
                 r.process(*static_cast<Value *>(params->get(2))).as_string();  
   
         VImage& vimage=*static_cast<VImage *>(r.self);          VImage& vimage=*static_cast<VImage *>(r.self);
         if(vimage.image)          if(vimage.image)
Line 655  static void _text(Request& r, const Stri Line 651  static void _text(Request& r, const Stri
                         "does not contain an image");                          "does not contain an image");
 }  }
   
 // initialize  // constructor
 void initialize_image_class(Pool& pool, VStateless_class& vclass) {  
   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](spacebar_width)
     /// ^image.font[alPHAbet;font-file-name.gif](height;width)      // ^image.font[alPHAbet;font-file-name.gif](spacebar_width;width)
         vclass.add_native_method("font", Method::CT_DYNAMIC, _font, 3, 4);          add_native_method("font", Method::CT_DYNAMIC, _font, 3, 4);
   
     /// ^image.text(x;y)[text]      // ^image.text(x;y)[text]
         vclass.add_native_method("text", Method::CT_DYNAMIC, _text, 3, 3);          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.16  
changed lines
  Added in v.1.37

E-mail: