[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.104 and 1.145

version 1.104, 2004/02/03 16:45:24 version 1.145, 2015/04/08 18:08:52
Line 1 Line 1
 /** @file  /** @file
         Parser: @b image parser class.          Parser: @b image parser class.
   
         Copyright(c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2001-2012 Art. Lebedev Studio (http://www.artlebedev.com)
         Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)          Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */  */
   
 static const char * const IDENT_IMAGE_C="$Date$";  
   
 /*  /*
         jpegsize: gets the width and height (in pixels) of a jpeg file          jpegsize: gets the width and height (in pixels) of a jpeg file
         Andrew Tong, werdna@ugcs.caltech.edu           February 14, 1995          Andrew Tong, werdna@ugcs.caltech.edu           February 14, 1995
Line 17  static const char * const IDENT_IMAGE_C= Line 15  static const char * const IDENT_IMAGE_C=
 */  */
   
 #include "pa_config_includes.h"  #include "pa_config_includes.h"
   
 #include "pa_vmethod_frame.h"  
   
 #include "gif.h"  #include "gif.h"
   
   #include "pa_vmethod_frame.h"
 #include "pa_common.h"  #include "pa_common.h"
 #include "pa_request.h"  #include "pa_request.h"
 #include "pa_vfile.h"  #include "pa_vfile.h"
Line 29  static const char * const IDENT_IMAGE_C= Line 25  static const char * const IDENT_IMAGE_C=
 #include "pa_vdate.h"  #include "pa_vdate.h"
 #include "pa_table.h"  #include "pa_table.h"
   
   volatile const char * IDENT_IMAGE_C="$Id$";
   
   // defines
   
   static const String spacebar_width_name("space");
   static const String monospace_width_name("width");
   static const String letter_spacing_name("spacing");
   
 // class  // class
   
 class MImage: public Methoded {  class MImage: public Methoded {
Line 37  public: // VStateless_class Line 41  public: // VStateless_class
   
 public:  public:
         MImage();          MImage();
   
 public: // Methoded  
         bool used_directly() { return true; }  
   
 };  };
   
 // globals  // globals
Line 49  DECLARE_CLASS_VAR(image, new MImage, 0); Line 49  DECLARE_CLASS_VAR(image, new MImage, 0);
   
 // helpers  // helpers
   
   #define EXIF_TAG(tag, name) put(tag, #name);
   
 /// value of exif tag -> it's value  /// value of exif tag -> it's value
 class EXIF_tag_value2name: public Hash<int, const char*> {  class EXIF_tag_value2name: public Hash<int, const char*> {
 public:  public:
         EXIF_tag_value2name() {          EXIF_tag_value2name() {
         // image JPEG Exif          // image JPEG Exif
                 #define EXIF_TAG(tag, name) \  
                         put(tag, #name);  
                 // Tags used by IFD0 (main image)                  // Tags used by IFD0 (main image)
                 EXIF_TAG(0x010e,        ImageDescription);                  EXIF_TAG(0x010e,        ImageDescription);
                 EXIF_TAG(0x010f,        Make);                  EXIF_TAG(0x010f,        Make);
Line 130  public: Line 130  public:
                 EXIF_TAG(0x83bb,        IPTC/NAA);                  EXIF_TAG(0x83bb,        IPTC/NAA);
                 EXIF_TAG(0x8773,        InterColorProfile);                  EXIF_TAG(0x8773,        InterColorProfile);
                 EXIF_TAG(0x8824,        SpectralSensitivity);                  EXIF_TAG(0x8824,        SpectralSensitivity);
                 EXIF_TAG(0x8825,        GPSInfo);                  //EXIF_TAG(0x8825,      GPSInfo);
                 EXIF_TAG(0x8828,        OECF);                  EXIF_TAG(0x8828,        OECF);
                 EXIF_TAG(0x8829,        Interlace);                  EXIF_TAG(0x8829,        Interlace);
                 EXIF_TAG(0x882a,        TimeZoneOffset);                  EXIF_TAG(0x882a,        TimeZoneOffset);
Line 147  public: Line 147  public:
                 EXIF_TAG(0xa20b,        FlashEnergy);                  EXIF_TAG(0xa20b,        FlashEnergy);
                 EXIF_TAG(0xa20c,        SpatialFrequencyResponse);                  EXIF_TAG(0xa20c,        SpatialFrequencyResponse);
                 EXIF_TAG(0xa214,        SubjectLocation);                  EXIF_TAG(0xa214,        SubjectLocation);
                 #undef EXIF_TAG  
                   // additional things added by misha@
                   EXIF_TAG(0x0100,        ImageWidth);
                   EXIF_TAG(0x0101,        ImageLength);
                   EXIF_TAG(0x0102,        BitsPerSample);
                   EXIF_TAG(0x0103,        Compression);
                   EXIF_TAG(0x0106,        PhotometricInterpretation);
                   EXIF_TAG(0x010a,        FillOrder);
                   EXIF_TAG(0x010d,        DocumentName);
                   EXIF_TAG(0x0111,        StripOffsets);
                   EXIF_TAG(0x0115,        SamplesPerPixel);
                   EXIF_TAG(0x0116,        RowsPerStrip);
                   EXIF_TAG(0x0117,        StripByteCounts);
                   EXIF_TAG(0x011c,        PlanarConfiguration);
                   EXIF_TAG(0x0156,        TransferRange);
                   EXIF_TAG(0x0200,        JPEGProc);
                   EXIF_TAG(0x0201,        JPEGInterchangeFormat);
                   EXIF_TAG(0x0202,        JPEGInterchangeFormatLength);
                   EXIF_TAG(0x0212,        YCbCrSubSampling);
                   EXIF_TAG(0xa401,        CustomRendered);
                   EXIF_TAG(0xa402,        ExposureMode);
                   EXIF_TAG(0xa403,        WhiteBalance);
                   EXIF_TAG(0xa404,        DigitalZoomRatio);
                   EXIF_TAG(0xa405,        FocalLengthIn35mmFilm);
                   EXIF_TAG(0xa406,        SceneCaptureType);
                   EXIF_TAG(0xa407,        GainControl);
                   EXIF_TAG(0xa408,        Contrast);
                   EXIF_TAG(0xa409,        Saturation);
                   EXIF_TAG(0xa40a,        Sharpness);
                   EXIF_TAG(0xa40b,        DeviceSettingDescription);
                   EXIF_TAG(0xa40c,        SubjectDistanceRange);
                   EXIF_TAG(0xa420,        ImageUniqueID);
         }          }
 } exif_tag_value2name;  } exif_tag_value2name;
   
   class EXIF_gps_tag_value2name: public Hash<int, const char*> {
   public:
                   EXIF_gps_tag_value2name() {
                   EXIF_TAG(0x0,   GPSVersionID);
                   EXIF_TAG(0x1,   GPSLatitudeRef);
                   EXIF_TAG(0x2,   GPSLatitude);
                   EXIF_TAG(0x3,   GPSLongitudeRef);
                   EXIF_TAG(0x4,   GPSLongitude);
                   EXIF_TAG(0x5,   GPSAltitudeRef);
                   EXIF_TAG(0x6,   GPSAltitude);
                   EXIF_TAG(0x7,   GPSTimeStamp);
                   EXIF_TAG(0x8,   GPSSatellites);
                   EXIF_TAG(0x9,   GPSStatus);
                   EXIF_TAG(0xA,   GPSMeasureMode);
                   EXIF_TAG(0xB,   GPSDOP);
                   EXIF_TAG(0xC,   GPSSpeedRef);
                   EXIF_TAG(0xD,   GPSSpeed);
                   EXIF_TAG(0xE,   GPSTrackRef);
                   EXIF_TAG(0xF,   GPSTrack);
                   EXIF_TAG(0x10,  GPSImgDirectionRef);
                   EXIF_TAG(0x11,  GPSImgDirection);
                   EXIF_TAG(0x12,  GPSMapDatum);
                   EXIF_TAG(0x13,  GPSDestLatitudeRef);
                   EXIF_TAG(0x14,  GPSDestLatitude);
                   EXIF_TAG(0x15,  GPSDestLongitudeRef);
                   EXIF_TAG(0x16,  GPSDestLongitude);
                   EXIF_TAG(0x17,  GPSDestBearingRef);
                   EXIF_TAG(0x18,  GPSDestBearing);
                   EXIF_TAG(0x19,  GPSDestDistanceRef);
                   EXIF_TAG(0x1A,  GPSDestDistance);
                   EXIF_TAG(0x1B,  GPSProcessingMethod);
                   EXIF_TAG(0x1C,  GPSAreaInformation);
                   EXIF_TAG(0x1D,  GPSDateStamp);
                   EXIF_TAG(0x1E,  GPSDifferential);
           }
   } exif_gps_tag_value2name;
   
   #undef EXIF_TAG
   
 #ifndef DOXYGEN  #ifndef DOXYGEN
 class Measure_reader {  class Measure_reader {
Line 174  public: Line 243  public:
                         return 0;                          return 0;
   
                 char* lbuf=new(PointerFreeGC) char[limit];                  char* lbuf=new(PointerFreeGC) char[limit];
                 size_t read_size=(size_t)::read(f, lbuf, limit);  abuf=lbuf;                  ssize_t read_size=::read(f, lbuf, limit);  abuf=lbuf;
                 if(ssize_t(read_size)<0 || read_size>limit)                  if(read_size<0)
                         throw Exception(0,                          throw Exception(0, &file_name, "measure read failed: %s (%d)", strerror(errno), errno);
                                 &file_name,   
                                 "measure failed: actually read %u bytes count not in [0..%u] valid range",   
                         read_size, limit);  
   
                 return read_size;                  return read_size;
         }          }
   
         override void seek(long value, int whence) {          override void seek(long value, int whence) {
                 if(lseek(f, value, whence)<0)                  if(lseek(f, value, whence)<0)
                         throw Exception("image.format",                          throw Exception(IMAGE_FORMAT,
                                 &file_name,                                   &file_name, 
                                 "seek(value=%ld, whence=%d) failed: %s (%d), actual filename '%s'",                                   "seek(value=%ld, whence=%d) failed: %s (%d), actual filename '%s'", 
                                         value, whence, strerror(errno), errno, fname);                                          value, whence, strerror(errno), errno, fname);
Line 228  public: Line 293  public:
                 }                  }
                                   
                 if((ssize_t)new_offset<0 || new_offset>size)                  if((ssize_t)new_offset<0 || new_offset>size)
                         throw Exception("image.format",                          throw Exception(IMAGE_FORMAT,
                                 &file_name,                                   &file_name, 
                                 "seek(value=%l, whence=%d) failed: out of buffer, new_offset>size (%l>%l) or new_offset<0",                                   "seek(value=%l, whence=%d) failed: out of buffer, new_offset>size (%l>%l) or new_offset<0", 
                                         value, whence, new_offset, size);                                          value, whence, new_offset, size);
Line 303  struct JPG_Exif_IFD_entry { Line 368  struct JPG_Exif_IFD_entry {
   
 #define JPG_IFD_TAG_EXIF_OFFSET 0x8769  #define JPG_IFD_TAG_EXIF_OFFSET 0x8769
   
   #define JPG_IFD_TAG_EXIF_GPS_OFFSET 0x8825
   
 #define JPEG_EXIF_DATE_CHARS 20  #define JPEG_EXIF_DATE_CHARS 20
   
 //  //
Line 331  static void measure_gif(const String& or Line 398  static void measure_gif(const String& or
         const char* buf;          const char* buf;
         const size_t head_size=sizeof(GIF_Header);          const size_t head_size=sizeof(GIF_Header);
         if(reader.read(buf, head_size)<head_size)          if(reader.read(buf, head_size)<head_size)
                 throw Exception("image.format",                   throw Exception(IMAGE_FORMAT, 
                         &origin_string,                           &origin_string, 
                         "not GIF file - too small");                          "not GIF file - too small");
         GIF_Header *head=(GIF_Header *)buf;          GIF_Header *head=(GIF_Header *)buf;
   
         if(strncmp(head->signature, "GIF", 3)!=0)          if(strncmp(head->signature, "GIF", 3)!=0)
                 throw Exception("image.format",                   throw Exception(IMAGE_FORMAT, 
                         &origin_string,                           &origin_string, 
                         "not GIF file - wrong signature");                                "not GIF file - wrong signature");      
   
Line 382  static Value* parse_IFD_entry_formatted_ Line 449  static Value* parse_IFD_entry_formatted_
                 }                  }
                 /*                  /*
         case 11: // single float          case 11: // single float
                 todo                  @todo
         case 12: // double float          case 12: // double float
                 todo                  @todo
                 */                  */
         };                };      
                   
Line 392  static Value* parse_IFD_entry_formatted_ Line 459  static Value* parse_IFD_entry_formatted_
 }  }
   
 // date.C  // date.C
 time_t cstr_to_time_t(char *cstr, bool fail_on_error);  tm cstr_to_time_t(char *cstr);
   
 static Value* parse_IFD_entry_formatted_value(bool is_big, ushort format,   static Value* parse_IFD_entry_formatted_value(bool is_big, ushort format, 
                                               size_t component_size, uint components_count,                                                 size_t component_size, uint components_count, 
Line 402  static Value* parse_IFD_entry_formatted_ Line 469  static Value* parse_IFD_entry_formatted_
                 size_t length=components_count;                  size_t length=components_count;
                 // Data format is "YYYY:MM:DD HH:MM:SS"+0x00, total 20bytes                  // Data format is "YYYY:MM:DD HH:MM:SS"+0x00, total 20bytes
                 if(length==JPEG_EXIF_DATE_CHARS                   if(length==JPEG_EXIF_DATE_CHARS 
                         && isdigit(cstr[0])                          && isdigit((unsigned char)cstr[0])
                         && cstr[length-1]==0) {                          && cstr[length-1]==0) {
                         char cstr_writable[JPEG_EXIF_DATE_CHARS];                           char cstr_writable[JPEG_EXIF_DATE_CHARS]; 
                         strcpy(cstr_writable, cstr);                          strcpy(cstr_writable, cstr);
   
                         time_t t=cstr_to_time_t(cstr_writable,                           try {
                                 false/* do not throw exception, just return bad result */);                                  return new VDate(cstr_to_time_t(cstr_writable));
                         if(t>=0)                          }
                                 return new VDate(t);                          catch(...) { /*ignore bad date times*/ }
                 }                  }
   
                 if(const char* premature_zero_pos=(const char* )memchr(cstr, 0, length))                  return new VString(*new String(cstr, String::L_TAINTED));
                         length=premature_zero_pos-cstr;  
                 return new VString(*new String(cstr, length, true/*tainted*/));  
         }          }
   
         if(components_count==1)          if(components_count==1)
Line 464  static Value* parse_IFD_entry_value( Line 529  static Value* parse_IFD_entry_value(
         // You can get the total data byte length by multiplies           // You can get the total data byte length by multiplies 
         // a 'bytes/components' value (see above chart) by number of components stored 'NNNNNNNN' area          // a 'bytes/components' value (see above chart) by number of components stored 'NNNNNNNN' area
         uint components_count=endian_to_uint(is_big, entry.components_count);          uint components_count=endian_to_uint(is_big, entry.components_count);
         size_t value_size=component_size*components_count;          uint value_size=component_size*components_count;
         // If its size is over 4bytes, 'DDDDDDDD' contains the offset to data stored address          // If its size is over 4bytes, 'DDDDDDDD' contains the offset to data stored address
         Value* result;          Value* result;
   
Line 492  static Value* parse_IFD_entry_value( Line 557  static Value* parse_IFD_entry_value(
 }  }
   
 static void parse_IFD(HashStringValue& hash,  static void parse_IFD(HashStringValue& hash,
                       bool is_big, Measure_reader& reader, long tiff_base);                        bool is_big, Measure_reader& reader, long tiff_base, bool gps=false);
   
 static void parse_IFD_entry(HashStringValue& hash,  static void parse_IFD_entry(HashStringValue& hash,
                             bool is_big, Measure_reader& reader, long tiff_base,                              bool is_big, Measure_reader& reader, long tiff_base,
                             JPG_Exif_IFD_entry& entry) {                              JPG_Exif_IFD_entry& entry, bool gps=false) {
         ushort tag=endian_to_ushort(is_big, entry.tag);          ushort tag=endian_to_ushort(is_big, entry.tag);
         if(tag==JPG_IFD_TAG_EXIF_OFFSET) {  
           if(tag==JPG_IFD_TAG_EXIF_OFFSET || tag==JPG_IFD_TAG_EXIF_GPS_OFFSET){
                 long remembered=reader.tell();                  long remembered=reader.tell();
                 {                  {
                         reader.seek(tiff_base+endian_to_uint(is_big, entry.value_or_offset_to_it), SEEK_SET);                          reader.seek(tiff_base+endian_to_uint(is_big, entry.value_or_offset_to_it), SEEK_SET);
                         parse_IFD(hash, is_big, reader, tiff_base);                          parse_IFD(hash, is_big, reader, tiff_base, (tag==JPG_IFD_TAG_EXIF_GPS_OFFSET)?true:gps);
                 }                  }
                 reader.seek(remembered, SEEK_SET);                  reader.seek(remembered, SEEK_SET);
                 return;                  return;
         }          }
           
         if(Value* value=parse_IFD_entry_value(is_big, reader, tiff_base, entry)) {          if(Value* value=parse_IFD_entry_value(is_big, reader, tiff_base, entry)) {
                 if(const char* name=exif_tag_value2name.get(tag))                  if(const char* name=(gps)?exif_gps_tag_value2name.get(tag):exif_tag_value2name.get(tag))
                         hash.put(String::Body(name), value);                          hash.put(String::Body(name), value);
                 else                  else
                         hash.put(String::Body::Format(tag), value);                          hash.put(String::Body::Format(tag), value);
Line 518  static void parse_IFD_entry(HashStringVa Line 584  static void parse_IFD_entry(HashStringVa
   
 static void parse_IFD(  static void parse_IFD(
                       HashStringValue& hash,                        HashStringValue& hash,
                       bool is_big, Measure_reader& reader, long tiff_base) {                        bool is_big, Measure_reader& reader, long tiff_base, bool gps) {
         const char* buf;          const char* buf;
         if(reader.read(buf, sizeof(JPG_Exif_IFD_begin))<sizeof(JPG_Exif_IFD_begin))          if(reader.read(buf, sizeof(JPG_Exif_IFD_begin))<sizeof(JPG_Exif_IFD_begin))
                 return;                  return;
Line 529  static void parse_IFD( Line 595  static void parse_IFD(
                 if(reader.read(buf, sizeof(JPG_Exif_IFD_entry))<sizeof(JPG_Exif_IFD_entry))                  if(reader.read(buf, sizeof(JPG_Exif_IFD_entry))<sizeof(JPG_Exif_IFD_entry))
                         return;                          return;
   
                 parse_IFD_entry(hash, is_big, reader, tiff_base, *(JPG_Exif_IFD_entry *)buf);                  parse_IFD_entry(hash, is_big, reader, tiff_base, *(JPG_Exif_IFD_entry *)buf, gps);
         }          }
         // then goes: LLLLLLLL Offset to next IFD [not going there]          // then goes: LLLLLLLL Offset to next IFD [not going there]
 }  }
Line 537  static void parse_IFD( Line 603  static void parse_IFD(
 static Value* parse_exif(Measure_reader& reader, const String& origin_string) {  static Value* parse_exif(Measure_reader& reader, const String& origin_string) {
         const char* buf;          const char* buf;
         if(reader.read(buf, sizeof(JPG_Exif_segment_begin))<sizeof(JPG_Exif_segment_begin))          if(reader.read(buf, sizeof(JPG_Exif_segment_begin))<sizeof(JPG_Exif_segment_begin))
                 throw Exception("image.format",                   throw Exception(IMAGE_FORMAT, 
                         &origin_string,                           &origin_string, 
                         "not JPEG file - can not fully read Exif segment start");                          "not JPEG file - can not fully read Exif segment start");
   
Line 576  static void measure_jpeg(const String& o Line 642  static void measure_jpeg(const String& o
         const char* buf;          const char* buf;
         const size_t prefix_size=2;          const size_t prefix_size=2;
         if(reader.read(buf, prefix_size)<prefix_size)          if(reader.read(buf, prefix_size)<prefix_size)
                 throw Exception("image.format",                   throw Exception(IMAGE_FORMAT, 
                         &origin_string,                           &origin_string, 
                         "not JPEG file - too small");                          "not JPEG file - too small");
         uchar *signature=(uchar *)buf;          uchar *signature=(uchar *)buf;
                   
         if(!(signature[0]==0xFF && signature[1]==0xD8))           if(!(signature[0]==0xFF && signature[1]==0xD8)) 
                 throw Exception("image.format",                   throw Exception(IMAGE_FORMAT, 
                         &origin_string,                           &origin_string, 
                         "not JPEG file - wrong signature");                          "not JPEG file - wrong signature");
   
Line 594  static void measure_jpeg(const String& o Line 660  static void measure_jpeg(const String& o
   
         // Verify that it's a valid segment.          // Verify that it's a valid segment.
                 if(head->marker!=MARKER)                  if(head->marker!=MARKER)
                         throw Exception("image.format",                           throw Exception(IMAGE_FORMAT, 
                                 &origin_string,                                   &origin_string, 
                                 "not JPEG file - marker not found");                                  "not JPEG file - marker not found");
   
                 switch(head->code) {                  switch(head->code) {
                 // http://www.ba.wakwak.com/~tsuruzoh/Computer/Digicams/exif-e.html                  // http://park2.wakwak.com/~tsuruzoh/Computer/Digicams/exif-e.html
                 case CODE_EXIF:                  case CODE_EXIF:
                         if(exif && !*exif) // seen .jpg with some xml under EXIF tag, after real exif block :)                          if(exif && !*exif) // seen .jpg with some xml under EXIF tag, after real exif block :)
                                 *exif=parse_exif(reader, origin_string);                                  *exif=parse_exif(reader, origin_string);
Line 612  static void measure_jpeg(const String& o Line 678  static void measure_jpeg(const String& o
                         {                          {
                                 // Segments that contain size info                                  // Segments that contain size info
                                 if(reader.read(buf, sizeof(JPG_Size_segment_body))<sizeof(JPG_Size_segment_body))                                  if(reader.read(buf, sizeof(JPG_Size_segment_body))<sizeof(JPG_Size_segment_body))
                                         throw Exception("image.format",                                           throw Exception(IMAGE_FORMAT, 
                                                 &origin_string,                                                   &origin_string, 
                                                 "not JPEG file - can not fully read Size segment");                                                  "not JPEG file - can not fully read Size segment");
                                 JPG_Size_segment_body *body=(JPG_Size_segment_body *)buf;                                  JPG_Size_segment_body *body=(JPG_Size_segment_body *)buf;
Line 626  static void measure_jpeg(const String& o Line 692  static void measure_jpeg(const String& o
                 reader.seek(segment_base+endian_to_ushort(true, head->length), SEEK_SET);                  reader.seek(segment_base+endian_to_ushort(true, head->length), SEEK_SET);
         }          }
   
         throw Exception("image.format",           throw Exception(IMAGE_FORMAT, 
                 &origin_string,                   &origin_string, 
                 "broken JPEG file - size frame not found");                  "broken JPEG file - size frame not found");
 }  }
Line 637  static void measure_png(const String& or Line 703  static void measure_png(const String& or
         const char* buf;          const char* buf;
         const size_t head_size=sizeof(PNG_Header);          const size_t head_size=sizeof(PNG_Header);
         if(reader.read(buf, head_size)<head_size)          if(reader.read(buf, head_size)<head_size)
                 throw Exception("image.format",                   throw Exception(IMAGE_FORMAT, 
                         &origin_string,                           &origin_string, 
                         "not PNG file - too small");                          "not PNG file - too small");
         PNG_Header *head=(PNG_Header *)buf;          PNG_Header *head=(PNG_Header *)buf;
   
         if(strncmp(head->signature, "IHDR", 4)!=0)          if(strncmp(head->signature, "IHDR", 4)!=0)
                 throw Exception("image.format",                   throw Exception(IMAGE_FORMAT, 
                         &origin_string,                           &origin_string, 
                         "not PNG file - wrong signature");                                "not PNG file - wrong signature");      
   
Line 655  static void measure_png(const String& or Line 721  static void measure_png(const String& or
   
 static void measure(const String& file_name,   static void measure(const String& file_name, 
                          Measure_reader& reader, ushort& width, ushort& height, Value** exif) {                           Measure_reader& reader, ushort& width, ushort& height, Value** exif) {
         const char* file_name_cstr=file_name.cstr(String::L_FILE_SPEC);          const char* file_name_cstr=file_name.taint_cstr(String::L_FILE_SPEC);
         if(const char* cext=strrchr(file_name_cstr, '.')) {          if(const char* cext=strrchr(file_name_cstr, '.')) {
                 cext++;                  cext++;
                 if(strcasecmp(cext, "GIF")==0)                  if(strcasecmp(cext, "GIF")==0)
Line 665  static void measure(const String& file_n Line 731  static void measure(const String& file_n
                 else if(strcasecmp(cext, "PNG")==0)                  else if(strcasecmp(cext, "PNG")==0)
                         measure_png(file_name, reader, width, height);                          measure_png(file_name, reader, width, height);
                 else                  else
                         throw Exception("image.format",                           throw Exception(IMAGE_FORMAT, 
                                 &file_name,                                   &file_name, 
                                 "unhandled image file name extension '%s'", cext);                                  "unhandled image file name extension '%s'", cext);
         } else          } else
                 throw Exception("image.format",                   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");
 }  }
Line 710  static void _measure(Request& r, MethodP Line 776  static void _measure(Request& r, MethodP
                 file_read_action_under_lock(r.absolute(*file_name),                   file_read_action_under_lock(r.absolute(*file_name), 
                         "measure", file_measure_action, &info);                          "measure", file_measure_action, &info);
         } else {          } else {
                 VFile* vfile=data.as_vfile();                  VFile* vfile=data.as_vfile(String::L_AS_IS);
                 file_name=&vfile->fields().get(name_name)->as_string();                  file_name=&vfile->fields().get(name_name)->as_string();
                 Measure_buf_reader reader(                  Measure_buf_reader reader(
                         vfile->value_ptr(),                          vfile->value_ptr(),
Line 730  struct Attrib_info { Line 796  struct Attrib_info {
 };  };
 #endif  #endif
 static void append_attrib_pair(  static void append_attrib_pair(
                                HashStringValue::key_type key,                                   HashStringValue::key_type key, 
                                HashStringValue::value_type value,                                   HashStringValue::value_type value, 
                                Attrib_info* info) {                                  Attrib_info* info) {
         // skip user-specified and internal(starting with "line-") attributes           // skip user-specified, internal(starting with "line-") attributes and border attribute with empty value
         if(info->skip && info->skip->get(key) || key.pos("line-")==0)          if(
                   (info->skip && info->skip->get(key))
                   || key.pos("line-")==0
                   || (key=="border" && !value->is_defined())
           )
                 return;                  return;
   
         // src="a.gif" width=123 ismap[=-1]          // src="a.gif" width="123" ismap[=-1]
         *info->tag << " " << key;          *info->tag << " " << key;
         if(value->is_string() || value->as_int()>=0)          if(value->is_string() || value->as_int()>=0)
                 *info->tag << "=\"" << value->as_string() << "\"";                  *info->tag << "=\"" << value->as_string() << "\"";
Line 752  static void _html(Request& r, MethodPara Line 822  static void _html(Request& r, MethodPara
   
         if(params.count()) {          if(params.count()) {
                 // for backward compatibility: someday was ^html{}                  // for backward compatibility: someday was ^html{}
                 Value& vattribs=r.process_to_value(params[0],                  Value& vattribs=r.process_to_value(params[0], false/*don't intercept string*/);
                         false/*don't intercept string*/);                  if(!vattribs.is_string()) { // allow empty
                 if(!vattribs.is_string()) // allow empty  
                         if((attribs=vattribs.get_hash())) {                          if((attribs=vattribs.get_hash())) {
                                 Attrib_info info={&tag, 0};                                  Attrib_info info={&tag, 0};
                                 attribs->for_each(append_attrib_pair, &info);                                  attribs->for_each<Attrib_info*>(append_attrib_pair, &info);
                         } else                          } else
                                 throw Exception("parser.runtime",                                   throw Exception(PARSER_RUNTIME, 
                                         0,                                           0, 
                                         "attributes must be hash");                                          "attributes must be hash");
                   }
         }          }
   
         {          {
                 Attrib_info info={&tag, attribs};                  Attrib_info info={&tag, attribs};
                 fields.for_each(append_attrib_pair, &info);                  fields.for_each<Attrib_info*>(append_attrib_pair, &info);
         }          }
         tag << " />";          tag << " />";
         r.write_pass_lang(tag);          r.write_pass_lang(tag);
Line 775  static void _html(Request& r, MethodPara Line 845  static void _html(Request& r, MethodPara
 /// @test wrap FILE to auto-object  /// @test wrap FILE to auto-object
 static gdImage* load(Request& r,   static gdImage* load(Request& r, 
                                          const String& file_name){                                           const String& file_name){
         const char* file_name_cstr=r.absolute(file_name).cstr(String::L_FILE_SPEC);          const char* file_name_cstr=r.absolute(file_name).taint_cstr(String::L_FILE_SPEC);
         if(FILE *f=fopen(file_name_cstr, "rb")) {          if(FILE *f=fopen(file_name_cstr, "rb")) {
                 gdImage* image=new gdImage;                  gdImage* image=new gdImage;
                 bool ok=image->CreateFromGif(f);                  bool ok=image->CreateFromGif(f);
                 fclose(f);                  fclose(f);
                 if(!ok)                  if(!ok)
                         throw Exception("image.format",                           throw Exception(IMAGE_FORMAT, 
                                 &file_name,                                  &file_name,
                                 "is not in GIF format");                                  "is not in GIF format");
                 return image;                  return image;
Line 794  static gdImage* load(Request& r, Line 864  static gdImage* load(Request& r,
   
   
 static void _load(Request& r, MethodParams& params) {  static void _load(Request& r, MethodParams& params) {
         const String& file_name=params.as_string(0, "file name must not be code");          const String& file_name=params.as_string(0, FILE_NAME_MUST_NOT_BE_CODE);
   
         gdImage* image=load(r, file_name);          gdImage* image=load(r, file_name);
         GET_SELF(r, VImage).set(&file_name, image->SX(), image->SY(), image);          GET_SELF(r, VImage).set(&file_name, image->SX(), image->SY(), image);
Line 813  static void _create(Request& r, MethodPa Line 883  static void _create(Request& r, MethodPa
 }  }
   
 static void _gif(Request& r, MethodParams& params) {  static void _gif(Request& r, MethodParams& params) {
         gdImage* image=GET_SELF(r, VImage).image;          gdImage& image=GET_SELF(r, VImage).image();
         if(!image)  
                 throw Exception(0,   
                         0,   
                         "does not contain an image");  
   
         const String *file_name=0;          const String *file_name=params.count()>0?&params.as_string(0, FILE_NAME_MUST_BE_STRING):0;
         if(params.count()>0)  
                 file_name=&params.as_string(0, "file name must be string");  
   
         gdBuf buf=image->Gif();          gdBuf buf=image.Gif();
                   
         VFile& vfile=*new VFile;          VFile& vfile=*new VFile;
         Value* content_type=new VString(*new String("image/gif"));  
         vfile.set(false/*not tainted*/,           vfile.set_binary(false/*not tainted*/, (const char *)buf.ptr, buf.size, file_name, new VString(*new String("image/gif")));
                 (const char*)buf.ptr, buf.size,   
                 file_name? file_name->cstr(String::L_FILE_SPEC): 0,   
                 content_type);  
   
         r.write_no_lang(vfile);          r.write_no_lang(vfile);
 }  }
   
 static void _line(Request& r, MethodParams& params) {  static void _line(Request& r, MethodParams& params) {
         gdImage* image=GET_SELF(r, VImage).image;          gdImage& image=GET_SELF(r, VImage).image();
         if(!image)  
                 throw Exception(0,   
                         0,   
                         "does not contain an image");  
   
         image->Line(          image.Line(
                 params.as_int(0, "x0 must be int", r),                   params.as_int(0, "x0 must be int", r), 
                 params.as_int(1, "y0 must be int", r),                   params.as_int(1, "y0 must be int", r), 
                 params.as_int(2, "x1 must be int", r),                   params.as_int(2, "x1 must be int", r), 
                 params.as_int(3, "y1 must be int", r),                   params.as_int(3, "y1 must be int", r), 
                 image->Color(params.as_int(4, "color must be int", r)));                  image.Color(params.as_int(4, "color must be int", r)));
 }  }
   
 static void _fill(Request& r, MethodParams& params) {  static void _fill(Request& r, MethodParams& params) {
         gdImage* image=GET_SELF(r, VImage).image;          gdImage& image=GET_SELF(r, VImage).image();
         if(!image)  
                 throw Exception(0,   
                         0,   
                         "does not contain an image");  
   
         image->Fill(          image.Fill(
                 params.as_int(0, "x must be int", r),                   params.as_int(0, "x must be int", r), 
                 params.as_int(1, "y must be int", r),                   params.as_int(1, "y must be int", r), 
                 image->Color(params.as_int(2, "color must be int", r)));                  image.Color(params.as_int(2, "color must be int", r)));
 }  }
   
 static void _rectangle(Request& r, MethodParams& params) {  static void _rectangle(Request& r, MethodParams& params) {
         gdImage* image=GET_SELF(r, VImage).image;          gdImage& image=GET_SELF(r, VImage).image();
         if(!image)  
                 throw Exception(0,   
                         0,   
                         "does not contain an image");  
   
         image->Rectangle(          image.Rectangle(
                 params.as_int(0, "x0 must be int", r),                   params.as_int(0, "x0 must be int", r), 
                 params.as_int(1, "y0 must be int", r),                   params.as_int(1, "y0 must be int", r), 
                 params.as_int(2, "x1 must be int", r),                   params.as_int(2, "x1 must be int", r), 
                 params.as_int(3, "y1 must be int", r),                   params.as_int(3, "y1 must be int", r), 
                 image->Color(params.as_int(4, "color must be int", r)));                  image.Color(params.as_int(4, "color must be int", r)));
 }  }
   
 static void _bar(Request& r, MethodParams& params) {  static void _bar(Request& r, MethodParams& params) {
         gdImage* image=GET_SELF(r, VImage).image;          gdImage& image=GET_SELF(r, VImage).image();
         if(!image)  
                 throw Exception(0,   
                         0,   
                         "does not contain an image");  
   
         image->FilledRectangle(          image.FilledRectangle(
                 params.as_int(0, "x0 must be int", r),                   params.as_int(0, "x0 must be int", r), 
                 params.as_int(1, "y0 must be int", r),                   params.as_int(1, "y0 must be int", r), 
                 params.as_int(2, "x1 must be int", r),                   params.as_int(2, "x1 must be int", r), 
                 params.as_int(3, "y1 must be int", r),                   params.as_int(3, "y1 must be int", r), 
                 image->Color(params.as_int(4, "color must be int", r)));                  image.Color(params.as_int(4, "color must be int", r)));
 }  }
   
 #ifndef DOXYGEN  #ifndef DOXYGEN
 static void add_point(Table::element_type row,   static void add_point(Table::element_type row, 
                                           gdImage::Point **p) {                                            gdImage::Point **p) {
           if(row->count()!=2)
                   throw Exception(0,
                           0,
                           "coordinates table must contain two columns: x and y values");
         (**p).x=row->get(0)->as_int();          (**p).x=row->get(0)->as_int();
         (**p).y=row->get(1)->as_int();          (**p).y=row->get(1)->as_int();
         (*p)++;          (*p)++;
 }  }
 #endif  #endif
   #ifndef DOXYGEN
   static void add_point(int x, int y, 
                                             gdImage::Point **p) {
           (**p).x=x;
           (**p).y=y;
           (*p)++;
   }
   #endif
 static void _replace(Request& r, MethodParams& params) {  static void _replace(Request& r, MethodParams& params) {
         gdImage* image=GET_SELF(r, VImage).image;          int src_color=params.as_int(0, "src color must be int", r);
         if(!image)          int dest_color=params.as_int(1, "dest color must be int", r);
                 throw Exception(0,   
                         0,   
                         "does not contain an image");  
   
         Table* table=params.as_no_junction(2, "coordinates must not be code").get_table();          gdImage& image=GET_SELF(r, VImage).image();
         if(!table)   
                 throw Exception(0,  
                         0,  
                         "coordinates must be table");  
   
         gdImage::Point *all_p=new(PointerFreeGC) gdImage::Point[table->count()];          gdImage::Point* all_p=0;
         gdImage::Point *add_p=all_p;              size_t count=0;
         table->for_each(add_point, &add_p);          if(params.count() == 3){
         image->FilledPolygonReplaceColor(all_p, table->count(),                   Table* table=params.as_table(2, "coordinates");
                 image->Color(params.as_int(0, "src color must be int", r)),                  count=table->count();
                 image->Color(params.as_int(1, "dest color must be int", r)));                  all_p=new(PointerFreeGC) gdImage::Point[count];
                   gdImage::Point* add_p=all_p;
                   table->for_each(add_point, &add_p);
           } else {
                   int max_x=image.SX()-1;
                   int max_y=image.SY()-1;
                   if(max_x > 0 && max_y > 0){
                           count=4;
                           all_p=new(PointerFreeGC) gdImage::Point[count];
                           gdImage::Point* add_p=all_p;
                           add_point(0, 0, &add_p);
                           add_point(max_x, 0, &add_p);
                           add_point(max_x, max_y, &add_p);
                           add_point(0, max_y, &add_p);
                   }
           }
   
           if(count)
                   image.FilledPolygonReplaceColor(all_p, count, image.Color(src_color), image.Color(dest_color));
 }  }
   
 static void _polyline(Request& r, MethodParams& params) {  static void _polyline(Request& r, MethodParams& params) {
         gdImage* image=GET_SELF(r, VImage).image;          gdImage& image=GET_SELF(r, VImage).image();
         if(!image)  
                 throw Exception(0,   
                         0,   
                         "does not contain an image");  
   
         Table* table=params.as_no_junction(1, "coordinates must not be code").get_table();          Table* table=params.as_table(1, "coordinates");
         if(!table)   
                 throw Exception(0,  
                         0,  
                         "coordinates must be table");  
   
         gdImage::Point* all_p=new(PointerFreeGC) gdImage::Point[table->count()];          gdImage::Point* all_p=new(PointerFreeGC) gdImage::Point[table->count()];
         gdImage::Point *add_p=all_p;              gdImage::Point *add_p=all_p;    
         table->for_each(add_point, &add_p);          table->for_each(add_point, &add_p);
         image->Polygon(all_p, table->count(),           image.Polygon(all_p, table->count(), 
                 image->Color(params.as_int(0, "color must be int", r)),                  image.Color(params.as_int(0, "color must be int", r)),
                 false/*not closed*/);                  false/*not closed*/);
 }  }
   
 static void _polygon(Request& r, MethodParams& params) {  static void _polygon(Request& r, MethodParams& params) {
         gdImage* image=GET_SELF(r, VImage).image;          gdImage& image=GET_SELF(r, VImage).image();
         if(!image)  
                 throw Exception(0,   
                         0,   
                         "does not contain an image");  
   
         Table* table=params.as_no_junction(1, "coordinates must not be code").get_table();          Table* table=(Table*)params.as_table(1, "coordinates");
         if(!table)   
                 throw Exception(0,  
                         0,  
                         "coordinates must be table");  
   
         gdImage::Point* all_p=new(PointerFreeGC) gdImage::Point[table->count()];          gdImage::Point* all_p=new(PointerFreeGC) gdImage::Point[table->count()];
         gdImage::Point *add_p=all_p;              gdImage::Point *add_p=all_p;    
         table->for_each(add_point, &add_p);          table->for_each(add_point, &add_p);
         image->Polygon(all_p, table->count(),           image.Polygon(all_p, table->count(), 
                 image->Color(params.as_int(0, "color must be int", r)));                  image.Color(params.as_int(0, "color must be int", r)));
 }  }
   
 static void _polybar(Request& r, MethodParams& params) {  static void _polybar(Request& r, MethodParams& params) {
         gdImage* image=GET_SELF(r, VImage).image;          gdImage& image=GET_SELF(r, VImage).image();
         if(!image)  
                 throw Exception(0,   
                         0,   
                         "does not contain an image");  
   
         Table* table=params.as_no_junction(1, "coordinates must not be code").get_table();          Table* table=(Table*)params.as_table(1, "coordinates");
         if(!table)   
                 throw Exception("parser.runtime",  
                         0,  
                         "coordinates must be table");  
   
         gdImage::Point* all_p=new(PointerFreeGC) gdImage::Point[table->count()];          gdImage::Point* all_p=new(PointerFreeGC) gdImage::Point[table->count()];
         gdImage::Point *add_p=all_p;              gdImage::Point *add_p=all_p;    
         table->for_each(add_point, &add_p);          table->for_each(add_point, &add_p);
         image->FilledPolygon(all_p, table->count(),           image.FilledPolygon(all_p, table->count(), 
                 image->Color(params.as_int(0, "color must be int", r)));                  image.Color(params.as_int(0, "color must be int", r)));
 }  }
   
 // font  // font
Line 989  static void _polybar(Request& r, MethodP Line 1033  static void _polybar(Request& r, MethodP
   
 // Font class  // Font class
   
 const int Font::letter_spacing=1;  Font::Font(
           Charset& asource_charset, 
 Font::Font(//,   
         const String& aalphabet,           const String& aalphabet, 
         gdImage* aifont, int aheight, int amonospace, int aspacebarspace):          gdImage* aifont, int aheight, int amonospace, int aspacebarspace, int aletterspacing):
         height(aheight), monospace(amonospace),  spacebarspace(aspacebarspace),          fsource_charset(asource_charset),
           height(aheight),
           monospace(amonospace),
           spacebarspace(aspacebarspace),
           letterspacing(aletterspacing),
         ifont(aifont),          ifont(aifont),
         alphabet(aalphabet)     {          alphabet(aalphabet)     {
   
           if(fsource_charset.isUTF8()){
                   size_t index=0;
                   for(UTF8_string_iterator i(alphabet); i.has_next(); )
                           fletter2index.put_dont_replace(i.next(), index++);
           }
 }  }
   
 /* ******************************** char ********************************** */  /* ******************************** char ********************************** */
Line 1006  size_t Font::index_of(char ch) { Line 1059  size_t Font::index_of(char ch) {
         return alphabet.pos(ch);          return alphabet.pos(ch);
 }  }
   
   size_t Font::index_of(XMLCh ch) {
           if(ch==' ') return STRING_NOT_FOUND;
           return fletter2index.get(ch);
   }
   
 int Font::index_width(size_t index) {  int Font::index_width(size_t index) {
         if(index==STRING_NOT_FOUND)          if(index==STRING_NOT_FOUND)
                 return spacebarspace;                  return spacebarspace;
Line 1018  int Font::index_width(size_t index) { Line 1076  int Font::index_width(size_t index) {
         return 0;          return 0;
 }  }
   
 void Font::index_display(gdImage* image, int x, int y, size_t index){  void Font::index_display(gdImage& image, int x, int y, size_t index){
         if(index!=STRING_NOT_FOUND)           if(index!=STRING_NOT_FOUND) 
                 ifont->Copy(*image, x, y, 0, Y(0), index_width(index), height);                  ifont->Copy(image, x, y, 0, Y(0), index_width(index), height);
 }  }
   
 /* ******************************** string ********************************** */  /* ******************************** string ********************************** */
   
 int Font::step_width(int index) {  int Font::step_width(int index) {
         return letter_spacing + (monospace ? monospace : index_width(index));          return letterspacing + (monospace ? monospace : index_width(index));
 }  }
   
 // counts trailing letter_spacing, consider this OK. useful for contiuations  // counts trailing letter_spacing, consider this OK. useful for contiuations
 int Font::string_width(const String& s){  int Font::string_width(const String& s){
         const char* cstr=s.cstr();          const char* cstr=s.cstr();
         int result=0;          int result=0;
         for(const char* current=cstr; *current; current++)  
                 result+=step_width(index_of(*current));          if(fsource_charset.isUTF8()){
                   for(UTF8_string_iterator i(s); i.has_next(); )
                           result+=step_width(index_of(i.next()));
           } else {
                   for(const char* current=cstr; *current; current++)
                           result+=step_width(index_of(*current));
           }
   
         return result;          return result;
 }  }
   
 void Font::string_display(gdImage* image, int x, int y, const String& s){  void Font::string_display(gdImage& image, int x, int y, const String& s){
         const char* cstr=s.cstr();          const char* cstr=s.cstr();
         for(const char* current=cstr; *current; current++) {  
                 size_t index=index_of(*current);          if(fsource_charset.isUTF8()){
                 index_display(image, x, y, index);                  for(UTF8_string_iterator i(s); i.has_next(); ){
                 x+=step_width(index);                          size_t index=index_of(i.next());
                           index_display(image, x, y, index);
                           x+=step_width(index);
                   }
           } else {
                   for(const char* current=cstr; *current; current++) {
                           size_t index=index_of(*current);
                           index_display(image, x, y, index);
                           x+=step_width(index);
                   }
         }          }
 }  }
   
Line 1052  void Font::string_display(gdImage* image Line 1126  void Font::string_display(gdImage* image
   
 static void _font(Request& r, MethodParams& params) {  static void _font(Request& r, MethodParams& params) {
         const String& alphabet=params.as_string(0, "alphabet must not be code");          const String& alphabet=params.as_string(0, "alphabet must not be code");
         gdImage* image=load(r, params.as_string(1, "file_name must not be code"));          size_t alphabet_length=alphabet.length(r.charsets.source());
         int spacebar_width=params.as_int(2, "spacebar_width must be int", r);          if(!alphabet_length)
         int monospace_width;                  throw Exception(PARSER_RUNTIME,
         if(params.count()>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.length())  
                 throw Exception("parser.runtime",  
                         0,                          0,
                         "alphabet must not be empty");                          "alphabet must not be empty");
   
         if(int remainder=image->SY() % alphabet.length())          gdImage* image=load(r, params.as_string(1, FILE_NAME_MUST_NOT_BE_CODE));
                 throw Exception("parser.runtime",  
           int spacebar_width=image->SX();
           int monospace_width=0; // proportional
           int letter_spacing=1;
           if(params.count()>2){
                   if(HashStringValue* options=params[2].get_hash()){
                           // third option is hash
                           if(params.count()>3)
                                   throw Exception(PARSER_RUNTIME, 0, "too many params were specified");
                           int valid_options=0;
                           if(Value* vspacebar_width=options->get(spacebar_width_name)){
                                   valid_options++;
                                   spacebar_width=r.process_to_value(*vspacebar_width).as_int();
                           }
                           if(Value* vmonospace_width=options->get(monospace_width_name)){
                                   valid_options++;
                                   monospace_width=r.process_to_value(*vmonospace_width).as_int();
                                   if(!monospace_width)
                                           monospace_width=image->SX();
                           }
                           if(Value* vletter_spacing=options->get(letter_spacing_name)){
                                   valid_options++;
                                   letter_spacing=r.process_to_value(*vletter_spacing).as_int();
                           }
                           if(valid_options!=options->count())
                                   throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
                   } else {
                           // backward
                           spacebar_width=params.as_int(2, "param must be int or hash", r);
                           if(params.count()>3) {
                                   monospace_width=params.as_int(3, "monospace_width must be int", r);
                                   if(!monospace_width)
                                           monospace_width=image->SX();
                           }
                   }
           }
   
           if(int remainder=image->SY() % alphabet_length)
                   throw Exception(PARSER_RUNTIME,
                         0,                          0,
                         "font-file height(%d) not divisable by alphabet size(%d), remainder=%d",                          "font-file height(%d) not divisable by alphabet size(%d), remainder=%d",
                                 image->SY(), alphabet.length(), remainder);                                  image->SY(), alphabet_length, remainder);
                   
         GET_SELF(r, VImage).font=new Font(          GET_SELF(r, VImage).set_font(new Font(
                   r.charsets.source(),
                 alphabet,                   alphabet, 
                 image,                   image, 
                 image->SY() / alphabet.length(), monospace_width, spacebar_width);                  image->SY() / alphabet_length, monospace_width, spacebar_width, letter_spacing));
 }  }
   
 static void _text(Request& r, MethodParams& params) {  static void _text(Request& r, MethodParams& params) {
Line 1085  static void _text(Request& r, MethodPara Line 1189  static void _text(Request& r, MethodPara
         const String& s=params.as_string(2, "text must not be code");          const String& s=params.as_string(2, "text must not be code");
   
         VImage& vimage=GET_SELF(r, VImage);          VImage& vimage=GET_SELF(r, VImage);
         if(vimage.image)          vimage.font().string_display(vimage.image(), x, y, s);
                 if(vimage.font)  
                         vimage.font->string_display(vimage.image, x, y, s);  
                 else  
                         throw Exception("parser.runtime",  
                                 0,  
                                 "set the font first");  
         else  
                 throw Exception(0,   
                         0,   
                         "does not contain an image");  
 }  }
   
 static void _length(Request& r, MethodParams& params) {  static void _length(Request& r, MethodParams& params) {
         const String& s=params.as_string(0, "text must not be code");          const String& s=params.as_string(0, "text must not be code");
   
         VImage& vimage=GET_SELF(r, VImage);          VImage& vimage=GET_SELF(r, VImage);
         if(vimage.image)          r.write_no_lang(*new VInt(vimage.font().string_width(s)));
                 if(vimage.font) {  
                         r.write_no_lang(*new VInt(vimage.font->string_width(s)));  
                 } else  
                         throw Exception("parser.runtime",  
                                 0,  
                                 "set the font first");  
         else  
                 throw Exception(0,   
                         0,   
                         "does not contain an image");  
 }  }
   
 static void _arc(Request& r, MethodParams& params) {  static void _arc(Request& r, MethodParams& params) {
         gdImage* image=GET_SELF(r, VImage).image;          gdImage& image=GET_SELF(r, VImage).image();
         if(!image)  
                 throw Exception(0,   
                         0,   
                         "does not contain an image");  
   
         image->Arc(          image.Arc(
                 params.as_int(0, "center_x must be int", r),                   params.as_int(0, "center_x must be int", r), 
                 params.as_int(1, "center_y 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(2, "width must be int", r), 
                 params.as_int(3, "height 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(4, "start degrees must be int", r), 
                 params.as_int(5, "end 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)));                  image.Color(params.as_int(6, "cx must be int", r)));
 }  }
   
 static void _sector(Request& r, MethodParams& params) {  static void _sector(Request& r, MethodParams& params) {
         gdImage* image=GET_SELF(r, VImage).image;          gdImage& image=GET_SELF(r, VImage).image();
         if(!image)  
                 throw Exception(0,   
                         0,   
                         "does not contain an image");  
   
         image->Sector(          image.Sector(
                 params.as_int(0, "center_x must be int", r),                   params.as_int(0, "center_x must be int", r), 
                 params.as_int(1, "center_y 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(2, "width must be int", r), 
                 params.as_int(3, "height 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(4, "start degrees must be int", r), 
                 params.as_int(5, "end 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)));                  image.Color(params.as_int(6, "color must be int", r)));
 }  }
   
 static void _circle(Request& r, MethodParams& params) {  static void _circle(Request& r, MethodParams& params) {
         gdImage* image=GET_SELF(r, VImage).image;          gdImage& image=GET_SELF(r, VImage).image();
         if(!image)  
                 throw Exception(0,   
                         0,   
                         "does not contain an image");  
   
         int size=params.as_int(2, "radius must be int", r)*2;          int size=params.as_int(2, "radius must be int", r)*2;
         image->Arc(          image.Arc(
                 params.as_int(0, "center_x must be int", r),                   params.as_int(0, "center_x must be int", r), 
                 params.as_int(1, "center_y must be int", r),                   params.as_int(1, "center_y must be int", r), 
                 size, //w                  size, //w
                 size, //h                  size, //h
                 0, //s                  0, //s
                 360, //e                  360, //e
                 image->Color(params.as_int(3, "color must be int", r)));                  image.Color(params.as_int(3, "color must be int", r)));
 }  }
   
 gdImage* as_image(MethodParams& params, int index, const char* msg) {  gdImage& as_image(MethodParams& params, int index, const char* msg) {
         gdImage* src=0;  
   
         Value& value=params.as_no_junction(index, msg);          Value& value=params.as_no_junction(index, msg);
   
         if(Value* vimage=value.as(VIMAGE_TYPE, false)) {          if(Value* vimage=value.as(VIMAGE_TYPE)) {
                 src=static_cast<VImage *>(vimage)->image;                  return static_cast<VImage *>(vimage)->image();
                 if(!src)  
                         throw Exception("parser.runtime",   
                                 0,   
                                 msg);  
         } else          } else
                 throw Exception("parser.runtime",                   throw Exception(PARSER_RUNTIME, 
                         0,                           0, 
                         msg);                          msg);
   
         return src;  
 }  }
   
 static void _copy(Request& r, MethodParams& params) {  static void _copy(Request& r, MethodParams& params) {
         gdImage* dest=GET_SELF(r, VImage).image;          gdImage& dest=GET_SELF(r, VImage).image();
         if(!dest)  
                 throw Exception(0,   
                         0,   
                         "self does not contain an image");  
   
         gdImage* src=as_image(params, 0, "src must be image");          gdImage& src=as_image(params, 0, "src must be image");
   
         int sx=params.as_int(1, "src_x must be int", r);          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 sy=params.as_int(2, "src_y must be int", r);
Line 1208  static void _copy(Request& r, MethodPara Line 1268  static void _copy(Request& r, MethodPara
                 int tolerance=params.count()>1+2+2+2+2?                  int tolerance=params.count()>1+2+2+2+2?
                         params.as_int(1+2+2+2+2, "tolerance must be int", r):150;                          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);                  src.CopyResampled(dest, dx, dy, sx, sy, dw, dh, sw, sh, tolerance);
         } else          } else
                 src->Copy(*dest, dx, dy, sx, sy, sw, sh);                  src.Copy(dest, dx, dy, sx, sy, sw, sh);
   }
   
   static void _pixel(Request& r, MethodParams& params) {
           gdImage& image=GET_SELF(r, VImage).image();
   
           int x=params.as_int(0, "x must be int", r); 
           int y=params.as_int(1, "y must be int", r);
   
           if(params.count()>2) {
                   image.SetPixel(x, y, 
                           image.Color(params.as_int(2, "color must be int", r)));
           } else 
                   r.write_no_lang(*new VInt(image.DecodeColor(image.GetPixel(x, y))));
 }  }
   
   
Line 1247  MImage::MImage(): Methoded("image") { Line 1320  MImage::MImage(): Methoded("image") {
         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]          // ^image.replace(color-source;color-dest)[table x:y]
         add_native_method("replace", Method::CT_DYNAMIC, _replace, 3, 3);          // ^image.replace(color-source;color-dest)
           add_native_method("replace", Method::CT_DYNAMIC, _replace, 2, 3);
   
         // ^image.polyline(color)[table x:y]          // ^image.polyline(color)[table x:y]
         add_native_method("polyline", Method::CT_DYNAMIC, _polyline, 2, 2);          add_native_method("polyline", Method::CT_DYNAMIC, _polyline, 2, 2);
Line 1258  MImage::MImage(): Methoded("image") { Line 1332  MImage::MImage(): Methoded("image") {
         // ^image.polybar(color)[table x:y]          // ^image.polybar(color)[table x:y]
         add_native_method("polybar", Method::CT_DYNAMIC, _polybar, 2, 2);          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]
     // ^image.font[alPHAbet;font-file-name.gif](spacebar_width;width)          // ^image.font[alPHAbet;font-file-name.gif](spacebar_width)
         add_native_method("font", Method::CT_DYNAMIC, _font, 3, 4);          // ^image.font[alPHAbet;font-file-name.gif](spacebar_width;letter_width)
           // ^image.font[alPHAbet;font-file-name.gif][$.space-width(.) $.letter-width(.) $.letter-space(.)]
           add_native_method("font", Method::CT_DYNAMIC, _font, 2, 4);
   
     // ^image.text(x;y)[text]          // ^image.text(x;y)[text]
         add_native_method("text", Method::CT_DYNAMIC, _text, 3, 3);          add_native_method("text", Method::CT_DYNAMIC, _text, 3, 3);
                   
     // ^image.ngth[text]          // ^image.length[text]
         add_native_method("length", Method::CT_DYNAMIC, _length, 1, 1);          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)          // ^image.arc(center x;center y;width;height;start in degrees;end in degrees;color)
Line 1279  MImage::MImage(): Methoded("image") { Line 1355  MImage::MImage(): Methoded("image") {
   
         // ^image.copy[source](src x;src y;src w;src h;dst x;dst y[;dest w[;dest h[;tolerance]]])          // ^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);          add_native_method("copy", Method::CT_DYNAMIC, _copy, 1+2+2+2, (1+2+2+2)+2+1);
   
           // ^image.pixel(x;y)[(color)]
           add_native_method("pixel", Method::CT_DYNAMIC, _pixel, 2, 3);
 }  }
Removed from v.1.104  
changed lines
  Added in v.1.145

E-mail: