[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.131 and 1.167

version 1.131, 2009/10/03 02:15:02 version 1.167, 2020/11/10 22:42:24
Line 1 Line 1
 /** @file  /** @file
         Parser: @b image parser class.          Parser: @b image parser class.
   
         Copyright(c) 2001-2009 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2001-2017 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"
 #include "pa_vimage.h"  #include "pa_vimage.h"
 #include "pa_vdate.h"  #include "pa_vdate.h"
 #include "pa_table.h"  #include "pa_table.h"
   #include "pa_charsets.h"
   
   volatile const char * IDENT_IMAGE_C="$Id$";
   
 // defines  // defines
   
Line 43  public: // VStateless_class Line 42  public: // VStateless_class
   
 public:  public:
         MImage();          MImage();
   
 public: // Methoded  
         bool used_directly() { return true; }  
   
 };  };
   
 // globals  // globals
   
 DECLARE_CLASS_VAR(image, new MImage, 0);  DECLARE_CLASS_VAR(image, new MImage);
   
 // helpers  // helpers
   
Line 185  public: Line 180  public:
                 EXIF_TAG(0xa40b,        DeviceSettingDescription);                  EXIF_TAG(0xa40b,        DeviceSettingDescription);
                 EXIF_TAG(0xa40c,        SubjectDistanceRange);                  EXIF_TAG(0xa40c,        SubjectDistanceRange);
                 EXIF_TAG(0xa420,        ImageUniqueID);                  EXIF_TAG(0xa420,        ImageUniqueID);
   
                   // other tags
                   EXIF_TAG(0xa430,        CameraOwnerName);
                   EXIF_TAG(0xa431,        BodySerialNumber);
                   EXIF_TAG(0xa432,        LensSpecification);
                   EXIF_TAG(0xa433,        LensManufactor);
                   EXIF_TAG(0xa434,        LensModel);
                   EXIF_TAG(0xa435,        LensSerialNumber);
         }          }
 } exif_tag_value2name;  } exif_tag_value2name;
   
Line 236  public: Line 239  public:
 };  };
   
 class Measure_file_reader: public Measure_reader {  class Measure_file_reader: public Measure_reader {
         const String& file_name; const char* fname;          const String& file_name;
         int f;          int f;
   
 public:  public:
         Measure_file_reader(int af, const String& afile_name, const char* afname):           Measure_file_reader(int af, const String& afile_name):
                 file_name(afile_name), fname(afname), f(af) {                  file_name(afile_name), f(af) {
         }          }
   
         override size_t read(const char* &abuf, size_t limit) {          override size_t read(const char* &abuf, size_t limit) {
Line 249  public: Line 252  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, "seek(value=%ld, whence=%d) failed: %s (%d)", value, whence, strerror(errno), errno);
                                 &file_name,   
                                 "seek(value=%ld, whence=%d) failed: %s (%d), actual filename '%s'",   
                                         value, whence, strerror(errno), errno, fname);  
         }          }
   
         override long tell() { return lseek(f, 0, SEEK_CUR); }          override long tell() { return lseek(f, 0, SEEK_CUR); }
Line 295  public: Line 291  public:
                 switch(whence) {                  switch(whence) {
                 case SEEK_CUR: new_offset=offset+value; break;                  case SEEK_CUR: new_offset=offset+value; break;
                 case SEEK_SET: new_offset=(size_t)value; break;                  case SEEK_SET: new_offset=(size_t)value; break;
                   case SEEK_END: new_offset=size; break;
                 default:                   default: 
                         throw Exception(0,                           throw Exception(0, 0, "whence #%d not supported", 0, whence); 
                                 0,   
                                 "whence #%d not supported", 0, whence);   
                         break; // never                          break; // never
                 }                  }
                                   
                 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, "seek(value=%l, whence=%d) failed: out of buffer, new_offset>size (%l>%l) or new_offset<0", 
                                 &file_name,   
                                 "seek(value=%l, whence=%d) failed: out of buffer, new_offset>size (%l>%l) or new_offset<0",   
                                         value, whence, new_offset, size);                                          value, whence, new_offset, size);
                 offset=new_offset;                  offset=new_offset;
         }          }
Line 318  public: Line 311  public:
   
 /// PNG file header  /// PNG file header
 struct PNG_Header {  struct PNG_Header {
         char dummy[12];          char    dummy[12];
         char signature[4]; //< must be "IHDR"          char    signature[4];   //< must be "IHDR"
         uchar high_width[2]; //< image width high bytes [we ignore for now]          uchar   high_width[2];  //< image width high bytes [we ignore for now]
         uchar width[2]; //< image width low bytes          uchar   width[2];       //< image width low bytes
         uchar high_height[2]; //< image height high bytes [we ignore for now]          uchar   high_height[2]; //< image height high bytes [we ignore for now]
         uchar height[4]; //< image height          uchar   height[4];      //< image height
 };  };
   
 /// GIF file header  /// GIF file header
 struct GIF_Header {  struct GIF_Header {
         char       signature[3];         // 'GIF'          char    signature[3];   // 'GIF'
         char       version[3];          char    version[3];
         uchar       width[2];          uchar   width[2];
         uchar       height[2];          uchar   height[2];
         char       dif;          char    dif;
         char       fonColor;          char    fonColor;
         char       nulls;          char    nulls;
   };
   
   /// BMP file header + DIB header part
   struct BMP_Header {
           char    signature[2];   // 'BM'
           uchar   file_size[4];
           uchar   reserved[4];
           uchar   bitmap_offset[4];
           uchar   header_size[4];
           uchar   width[2];
           uchar   high_width[2];  //< image width high bytes [we ignore for now]
           uchar   height[2];
           uchar   high_height[2]; //< image height high bytes [we ignore for now]
 };  };
   
 /// JPEG record head  /// JPEG record head
Line 345  struct JPG_Segment_head { Line 351  struct JPG_Segment_head {
 };  };
 /// JPEG frame header  /// JPEG frame header
 struct JPG_Size_segment_body {  struct JPG_Size_segment_body {
         char data;                    //< data precision of bits/sample          char data;              //< data precision of bits/sample
         uchar height[2];               //< image height          uchar height[2];        //< image height
         uchar width[2];                //< image width          uchar width[2];         //< image width
         char numComponents;           //< number of color components          char numComponents;     //< number of color components
 };  
   
 /// JPEG frame header  
 struct JPG_Exif_segment_begin {  
         char signature[6]; // Exif\0\0  
 };  };
   
 /// JPEG Exif TIFF Header  /// JPEG Exif TIFF Header
 struct JPG_Exif_TIFF_header {  struct JPG_Exif_TIFF_header {
         uchar byte_align_identifier[2];          char byte_align_identifier[2];
         char dummy[2]; // always 000A [or 0A00]          uchar signature[2]; // always 000A [or 0A00]
         uchar first_IFD_offset[4]; // Usually the first IFD starts immediately next to TIFF header, so this offset has value '0x00000008'.          uchar first_IFD_offset[4]; // Usually the first IFD starts immediately next to TIFF header, so this offset has value '0x00000008'.
 };  };
   
Line 382  struct JPG_Exif_IFD_entry { Line 383  struct JPG_Exif_IFD_entry {
   
 #define JPEG_EXIF_DATE_CHARS 20  #define JPEG_EXIF_DATE_CHARS 20
   
   
   #ifndef DOXYGEN
   struct Measure_info {
           ushort width;
           ushort height;
           Value** exif;
           Value** xmp;
           Charset* xmp_charset;
   };
   #endif
   
 //  //
   
 inline ushort x_endian_to_ushort(uchar b0, uchar b1) {  inline ushort x_endian_to_ushort(uchar b0, uchar b1) {
Line 402  inline uint endian_to_uint(bool is_big, Line 414  inline uint endian_to_uint(bool is_big,
                 x_endian_to_uint(b[0], b[1], b[2], b[3]);                  x_endian_to_uint(b[0], b[1], b[2], b[3]);
 }  }
   
 static void measure_gif(const String& origin_string,   static Value* parse_IFD_entry_formatted_one_value(bool is_big, ushort format, size_t component_size, const uchar *value) {
                          Measure_reader& reader, ushort& width, ushort& height) {  
   
         const char* buf;  
         const size_t head_size=sizeof(GIF_Header);  
         if(reader.read(buf, head_size)<head_size)  
                 throw Exception(IMAGE_FORMAT,   
                         &origin_string,   
                         "not GIF file - too small");  
         GIF_Header *head=(GIF_Header *)buf;  
   
         if(strncmp(head->signature, "GIF", 3)!=0)  
                 throw Exception(IMAGE_FORMAT,   
                         &origin_string,   
                         "not GIF file - wrong signature");        
   
         width=endian_to_ushort(false, head->width);  
         height=endian_to_ushort(false, head->height);  
 }  
   
 static Value* parse_IFD_entry_formatted_one_value(  
                                                                                                   bool is_big,  
                                                                                                   ushort format,   
                                                                                                   size_t component_size,   
                                                                                                   const uchar *value) {  
         switch(format) {          switch(format) {
         case 1: // unsigned byte          case 1: // unsigned byte
                 return new VInt((uchar)value[0]);                  return new VInt((uchar)value[0]);
Line 469  static Value* parse_IFD_entry_formatted_ Line 457  static Value* parse_IFD_entry_formatted_
 }  }
   
 // date.C  // date.C
 tm cstr_to_time_t(char *cstr);  tm cstr_to_time_t(char *, const char **);
   
 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, const uchar *value) {
                                               size_t component_size, uint components_count,   
                                               const uchar *value) {  
         if(format==2) { // ascii string, exception: the only type with varying size          if(format==2) { // ascii string, exception: the only type with varying size
                 const char* cstr=(const char* )value;                  const char* cstr=(const char* )value;
                 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((unsigned char)cstr[0]) && cstr[length-1]==0) {
                         && isdigit((unsigned char)cstr[0])                          char cstr_writable[JPEG_EXIF_DATE_CHARS];
                         && cstr[length-1]==0) {  
                         char cstr_writable[JPEG_EXIF_DATE_CHARS];   
                         strcpy(cstr_writable, cstr);                          strcpy(cstr_writable, cstr);
   
                         try {                          try {
                                 return new VDate(cstr_to_time_t(cstr_writable));                                  tm tmIn=cstr_to_time_t(cstr_writable, 0);
                                   return new VDate(tmIn);
                         }                          }
                         catch(...) { /*ignore bad date times*/ }                          catch(...) { /*ignore bad date times*/ }
                 }                  }
Line 507  static Value* parse_IFD_entry_formatted_ Line 492  static Value* parse_IFD_entry_formatted_
         return result;          return result;
 }  }
   
 static Value* parse_IFD_entry_value(  static Value* parse_IFD_entry_value(bool is_big, Measure_reader& reader, long tiff_base, JPG_Exif_IFD_entry& entry) {
                                                                         bool is_big, Measure_reader& reader, long tiff_base,  
                                                                         JPG_Exif_IFD_entry& entry) {  
         size_t format2component_size[]={          size_t format2component_size[]={
                 0, // undefined                  0, // undefined
                 1, // unsigned byte                  1, // unsigned byte
Line 544  static Value* parse_IFD_entry_value( Line 527  static Value* parse_IFD_entry_value(
         Value* result;          Value* result;
   
         if(value_size<=4)          if(value_size<=4)
                 result=parse_IFD_entry_formatted_value(                  result=parse_IFD_entry_formatted_value(is_big, format, component_size, components_count, entry.value_or_offset_to_it);
                         is_big, format,   
                         component_size, components_count,   
                         entry.value_or_offset_to_it);  
         else {          else {
                 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);
                         const char* value;                          const char* value;
                         if(reader.read(value, value_size)<sizeof(value_size))                          if(reader.read(value, value_size)<value_size)
                                 return 0;                                  return 0;
                         result=parse_IFD_entry_formatted_value(                          result=parse_IFD_entry_formatted_value(is_big, format, component_size, components_count, (const uchar*)value);
                                 is_big, format,   
                                 component_size, components_count,   
                                 (const uchar*)value);  
                 }                  }
                 reader.seek(remembered, SEEK_SET);                  reader.seek(remembered, SEEK_SET);
         }          }
Line 566  static Value* parse_IFD_entry_value( Line 543  static Value* parse_IFD_entry_value(
         return result;          return result;
 }  }
   
 static void parse_IFD(HashStringValue& hash,  static void parse_IFD(HashStringValue& hash, bool is_big, Measure_reader& reader, long tiff_base, bool gps=false);
                       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, JPG_Exif_IFD_entry& entry, bool gps=false) {
                             bool is_big, Measure_reader& reader, long tiff_base,  
                             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 || tag==JPG_IFD_TAG_EXIF_GPS_OFFSET){          if(tag==JPG_IFD_TAG_EXIF_OFFSET || tag==JPG_IFD_TAG_EXIF_GPS_OFFSET){
Line 586  static void parse_IFD_entry(HashStringVa Line 560  static void parse_IFD_entry(HashStringVa
   
         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=(gps)?exif_gps_tag_value2name.get(tag):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(name, value);
                 else                  else
                         hash.put(String::Body::Format(tag), value);                          hash.put(String::Body::Format(tag), value);
         }          }
 }  }
   
 static void parse_IFD(  static void parse_IFD(HashStringValue& hash, bool is_big, Measure_reader& reader, long tiff_base, bool gps) {
                       HashStringValue& hash,  
                       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 610  static void parse_IFD( Line 582  static void parse_IFD(
         // then goes: LLLLLLLL Offset to next IFD [not going there]          // then goes: LLLLLLLL Offset to next IFD [not going there]
 }  }
   
 static Value* parse_exif(Measure_reader& reader, const String& origin_string) {  static Value* parse_exif(Measure_reader& reader) {
         const char* buf;          const char* buf;
         if(reader.read(buf, sizeof(JPG_Exif_segment_begin))<sizeof(JPG_Exif_segment_begin))  
                 throw Exception(IMAGE_FORMAT,   
                         &origin_string,   
                         "not JPEG file - can not fully read Exif segment start");  
   
         JPG_Exif_segment_begin *start=(JPG_Exif_segment_begin *)buf;  
         if(memcmp(start->signature, "Exif\0\0", 4+2)!=0) //signature invalid?  
                 return 0; // ignore invalid block  
   
         uint tiff_base=reader.tell();          uint tiff_base=reader.tell();
         if(reader.read(buf, sizeof(JPG_Exif_TIFF_header))<sizeof(JPG_Exif_TIFF_header))          if(reader.read(buf, sizeof(JPG_Exif_TIFF_header))<sizeof(JPG_Exif_TIFF_header))
Line 639  static Value* parse_exif(Measure_reader& Line 603  static Value* parse_exif(Measure_reader&
         return vhash;          return vhash;
 }  }
   
 static void measure_jpeg(const String& origin_string,   static Value* parse_xmp(Measure_reader& reader, ushort xmp_length, Measure_info &info) {
                          Measure_reader& reader, ushort& width, ushort& height, Value** exif) {          const char* buf;
           if(reader.read(buf, xmp_length)<xmp_length)
                   return 0;
   
           String::C xmp = Charset::transcode(String::C(pa_strdup(buf, xmp_length), xmp_length), *info.xmp_charset, pa_thread_request().charsets.source());
           return new VString(*new String(xmp, String::L_TAINTED));
   }
   
   static void measure_jpeg(const String& origin_string, Measure_reader& reader, Measure_info &info) {
         // JFIF format markers          // JFIF format markers
         const uchar MARKER=0xFF;          const uchar MARKER=0xFF;
         const uchar CODE_SIZE_A=0xC0;          const uchar CODE_SIZE_A=0xC0;
         const uchar CODE_SIZE_B=0xC1;          const uchar CODE_SIZE_B=0xC1;
         const uchar CODE_SIZE_C=0xC2;          const uchar CODE_SIZE_C=0xC2;
         const uchar CODE_SIZE_D=0xC3;          const uchar CODE_SIZE_D=0xC3;
         const uchar CODE_EXIF=0xE1;          const uchar CODE_APP1=0xE1;
   
         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, "not JPEG file - too small");
                         &origin_string,   
                         "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, "not JPEG file - wrong signature");
                         &origin_string,   
                         "not JPEG file - wrong signature");  
   
         while(true) {          while(true) {
                 uint segment_base=reader.tell()+2/*marker,code*/;                  uint segment_base=reader.tell()+2/*marker,code*/;
Line 668  static void measure_jpeg(const String& o Line 636  static void measure_jpeg(const String& o
                         break;                          break;
                 JPG_Segment_head *head=(JPG_Segment_head *)buf;                  JPG_Segment_head *head=(JPG_Segment_head *)buf;
   
         // 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, "not JPEG file - marker not found");
                                 &origin_string,   
                                 "not JPEG file - marker not found");                  ushort segment_length=endian_to_ushort(true, head->length);
   
                 switch(head->code) {                  switch(head->code) {
                 // http://park2.wakwak.com/~tsuruzoh/Computer/Digicams/exif-e.html                  // http://dev.exiv2.org/projects/exiv2/wiki/The_Metadata_in_JPEG_files
                 case CODE_EXIF:                  case CODE_APP1:
                         if(exif && !*exif) // seen .jpg with some xml under EXIF tag, after real exif block :)                          {
                                 *exif=parse_exif(reader, origin_string);                                  const size_t EXIF_SIG_LEN=6; // Exif\0\0
                                   const size_t XMP_SIG_LEN=29; // http://ns.adobe.com/xap/1.0/\0
   
                                   if(segment_length<EXIF_SIG_LEN+2 || reader.read(buf, EXIF_SIG_LEN)<EXIF_SIG_LEN)
                                           break;
                                   if(memcmp(buf, "Exif\0\0", EXIF_SIG_LEN)==0){
                                           if(info.exif && !*info.exif) // backward compatibility: using first segment
                                                   *info.exif=parse_exif(reader);
                                           break;
                                   }
   
                                   if(memcmp(buf, "http:/", EXIF_SIG_LEN))
                                           break;
                                   if(segment_length<XMP_SIG_LEN+2 || reader.read(buf, XMP_SIG_LEN-EXIF_SIG_LEN)<XMP_SIG_LEN-EXIF_SIG_LEN)
                                           break;
                                   if(memcmp(buf, "/ns.adobe.com/xap/1.0/\0", XMP_SIG_LEN-EXIF_SIG_LEN)==0){
                                           if(info.xmp && !*info.xmp) // backward compatibility: using first segment
                                                   *info.xmp=parse_xmp(reader, segment_length - XMP_SIG_LEN - 2 /* segment_length */, info);
                                   }
   
                           }
                         break;                          break;
   
                 case CODE_SIZE_A:                  case CODE_SIZE_A:
Line 688  static void measure_jpeg(const String& o Line 676  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, "not JPEG file - can not fully read Size segment");
                                                 &origin_string,   
                                                 "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;
                                                                   
                                 width=endian_to_ushort(true, body->width);                                  info.width=endian_to_ushort(true, body->width);
                                 height=endian_to_ushort(true, body->height);                                  info.height=endian_to_ushort(true, body->height);
                         }                                                 }
                         return;                          return;
                 };                  };
   
                 reader.seek(segment_base+endian_to_ushort(true, head->length), SEEK_SET);                  reader.seek(segment_base + segment_length, SEEK_SET);
           }
   
           throw Exception(IMAGE_FORMAT, &origin_string, "broken JPEG file - size frame not found");
   }
   
   static bool parse_tiff_IFD(bool is_big, Measure_reader& reader, Measure_info &info) {
           const char* buf;
           if(reader.read(buf, sizeof(JPG_Exif_IFD_begin))<sizeof(JPG_Exif_IFD_begin))
                   return false;
           JPG_Exif_IFD_begin *start=(JPG_Exif_IFD_begin *)buf;
   
           ushort directory_entry_count=endian_to_ushort(is_big, start->directory_entry_count);
           for(int i=0; i<directory_entry_count; i++) {
                   if(reader.read(buf, sizeof(JPG_Exif_IFD_entry))<sizeof(JPG_Exif_IFD_entry))
                           return false;
   
                   JPG_Exif_IFD_entry *entry=(JPG_Exif_IFD_entry *)buf;
                   ushort entry_tag=endian_to_ushort(is_big, entry->tag);
   
                   if(entry_tag == 256 || entry_tag == 257){
                           ushort entry_format=endian_to_ushort(is_big, entry->format);
                           if(entry_format != 3 && entry_format != 4 || endian_to_uint(is_big, entry->components_count) != 1)
                                   return false;
                           uint value = (entry_format == 3) ? endian_to_ushort(is_big, entry->value_or_offset_to_it) : endian_to_uint(is_big, entry->value_or_offset_to_it);
                           (entry_tag == 256) ? info.width=value : info.height=value;
                           if(info.width && info.height)
                                   return true;
                   }
         }          }
   
         throw Exception(IMAGE_FORMAT,           return false;
                 &origin_string,           // then goes: LLLLLLLL Offset to next IFD [not going there]
                 "broken JPEG file - size frame not found");  }
   
   static void measure_tiff(const String& origin_string, Measure_reader& reader, Measure_info &info) {
           const char* buf;
   
           if(reader.read(buf, sizeof(JPG_Exif_TIFF_header))<sizeof(JPG_Exif_TIFF_header))
                   throw Exception(IMAGE_FORMAT, &origin_string, "not TIFF file - too small");
   
           JPG_Exif_TIFF_header *head=(JPG_Exif_TIFF_header *)buf;
   
           if(strncmp(head->byte_align_identifier, "II", 2)!=0 && strncmp(head->byte_align_identifier, "MM", 2)!=0)
                   throw Exception(IMAGE_FORMAT, &origin_string, "not TIFF file - wrong signature");
   
           bool is_big=head->byte_align_identifier[0]=='M'; // [M]otorola vs [I]ntel
   
           if(endian_to_ushort(is_big, head->signature) != 42)
                   throw Exception(IMAGE_FORMAT, &origin_string, "not TIFF file - wrong signature");
   
           reader.seek(endian_to_uint(is_big, head->first_IFD_offset), SEEK_SET);
           if(!parse_tiff_IFD(is_big, reader, info))
                   throw Exception(IMAGE_FORMAT, &origin_string, "broken TIFF file - size field entry not found");
   }
   
   static void measure_gif(const String& origin_string, Measure_reader& reader, ushort& width, ushort& height) {
   
           const char* buf;
           const size_t head_size=sizeof(GIF_Header);
           if(reader.read(buf, head_size)<head_size)
                   throw Exception(IMAGE_FORMAT, &origin_string, "not GIF file - too small");
           GIF_Header *head=(GIF_Header *)buf;
   
           if(strncmp(head->signature, "GIF", 3)!=0)
                   throw Exception(IMAGE_FORMAT, &origin_string, "not GIF file - wrong signature");
   
           width=endian_to_ushort(false, head->width);
           height=endian_to_ushort(false, head->height);
 }  }
   
 static void measure_png(const String& origin_string,   static void measure_png(const String& origin_string, Measure_reader& reader, ushort& width, ushort& height) {
                          Measure_reader& reader, ushort& width, ushort& height) {  
   
         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, "not PNG file - too small");
                         &origin_string,   
                         "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, "not PNG file - wrong signature");
                         &origin_string,   
                         "not PNG file - wrong signature");        
   
         width=endian_to_ushort(true, head->width);          width=endian_to_ushort(true, head->width);
         height=endian_to_ushort(true, head->height);          height=endian_to_ushort(true, head->height);
 }  }
   
   static void measure_bmp(const String& origin_string, Measure_reader& reader, ushort& width, ushort& height) {
   
           const char* buf;
           const size_t head_size=sizeof(BMP_Header);
           if(reader.read(buf, head_size)<head_size)
                   throw Exception(IMAGE_FORMAT, &origin_string, "not BMP file - too small");
           BMP_Header *head=(BMP_Header *)buf;
   
           if(strncmp(head->signature, "BM", 2)!=0)
                   throw Exception(IMAGE_FORMAT, &origin_string, "not BMP file - wrong signature");
   
           reader.seek(0, SEEK_END);
           if((uint)reader.tell() != endian_to_uint(false, head->file_size))
                   throw Exception(IMAGE_FORMAT, &origin_string, "not BMP file - length header and file size do not match");
   
           width=endian_to_ushort(false, head->width);
           height=endian_to_ushort(false, head->height);
   }
   
 // measure center  // measure center
   
 static void measure(const String& file_name,   static void measure(const String& file_name, Measure_reader& reader, Measure_info &info) {
                          Measure_reader& reader, ushort& width, ushort& height, Value** exif) {  
         const char* file_name_cstr=file_name.taint_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)
                         measure_gif(file_name, reader, width, height);                          measure_gif(file_name, reader, info.width, info.height);
                 else if(strcasecmp(cext, "JPG")==0 || strcasecmp(cext, "JPEG")==0)                   else if(strcasecmp(cext, "JPG")==0 || strcasecmp(cext, "JPEG")==0)
                         measure_jpeg(file_name, reader, width, height, exif);                          measure_jpeg(file_name, reader, info);
                 else if(strcasecmp(cext, "PNG")==0)                  else if(strcasecmp(cext, "PNG")==0)
                         measure_png(file_name, reader, width, height);                          measure_png(file_name, reader, info.width, info.height);
                   else if(strcasecmp(cext, "BMP")==0)
                           measure_bmp(file_name, reader, info.width, info.height);
                   else if(strcasecmp(cext, "TIF")==0 || strcasecmp(cext, "TIFF")==0)
                           measure_tiff(file_name, reader, info);
                 else                  else
                         throw Exception(IMAGE_FORMAT,                           throw Exception(IMAGE_FORMAT, &file_name, "unhandled image file name extension '%s'", cext);
                                 &file_name,   
                                 "unhandled image file name extension '%s'", cext);  
         } else          } else
                 throw Exception(IMAGE_FORMAT,                   throw Exception(IMAGE_FORMAT, &file_name, "can not determine image type - no file name extension");
                         &file_name,   
                         "can not determine image type - no file name extension");  
 }  }
   
 // methods  // methods
   
 #ifndef DOXYGEN  static void file_measure_action(struct stat& /*finfo*/, int f, const String& file_spec, void *context) {
 struct File_measure_action_info {          Measure_file_reader reader(f, file_spec);
         ushort* width;          measure(file_spec, reader, *static_cast<Measure_info *>(context));
         ushort* height;  
         Value** exif;  
         const String* file_name;  
 };  
 #endif  
 static void file_measure_action(  
                                                                 struct stat& /*finfo*/, int f,   
                                                                 const String& /*file_spec*/, const char* fname, bool /*as_text*/,  
                                                                 void *context) {  
         File_measure_action_info& info=*static_cast<File_measure_action_info *>(context);  
   
         Measure_file_reader reader(f, *info.file_name, fname);  
         measure(*info.file_name, reader, *info.width, *info.height, info.exif);  
 }  }
   
 static void _measure(Request& r, MethodParams& params) {  static void _measure(Request& r, MethodParams& params) {
         Value& data=params.as_no_junction(0, "data must not be code");          Value& data=params.as_no_junction(0, "data must not be code");
   
         ushort width=0;  
         ushort height=0;  
         Value* exif=0;          Value* exif=0;
           Value* xmp=0;
           Measure_info info={ 0, 0, 0, 0, &pa_UTF8_charset };
   
           if(params.count()>1)
                   if(HashStringValue* options=params.as_hash(1, "methods options")) {
                           int valid_options=0;
                           for(HashStringValue::Iterator i(*options); i; i.next() ){
                                   String::Body key=i.key();
                                   Value* value=i.value();
                                   if(key == "exif") {
                                           if(r.process(*value).as_bool())
                                                   info.exif=&exif;
                                           valid_options++;
                                   }
                                   if(key == "xmp") {
                                           if(r.process(*value).as_bool())
                                                   info.xmp=&xmp;
                                           valid_options++;
                                   }
                                   if(key == "xmp-charset") {
                                           info.xmp_charset=&pa_charsets.get(value->as_string());
                                           valid_options++;
                                   }
                           }
                           if(valid_options!=options->count())
                                   throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
                   }
   
         const String* file_name;          const String* file_name;
         if((file_name=data.get_string())) {  
                 File_measure_action_info info={          if(file_name=data.get_string()) {
                         &width, &height,                  file_read_action_under_lock(r.full_disk_path(*file_name), "measure", file_measure_action, &info);
                         &exif,  
                         file_name  
                 };  
                 file_read_action_under_lock(r.absolute(*file_name),   
                         "measure", file_measure_action, &info);  
         } else {          } else {
                 VFile* vfile=data.as_vfile(String::L_AS_IS);                  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_size(), *file_name);
                         vfile->value_ptr(),                  measure(*file_name, reader, info);
                         vfile->value_size(),  
                         *file_name  
                 );  
                 measure(*file_name, reader, width, height, &exif);  
         }          }
   
         GET_SELF(r, VImage).set(file_name, width, height, 0, exif);          GET_SELF(r, VImage).set(file_name, info.width, info.height, 0, exif, xmp);
 }  }
   
 #ifndef DOXYGEN  static void append_attrib_pair(String &tag, String::Body key, Value* value){
 struct Attrib_info {          // skip border attribute with empty value
         String* tag; ///< html tag being constructed          if(key=="border" && !value->is_defined())
         HashStringValue* skip; ///< tag attributes not to append to tag string [to skip]  
 };  
 #endif  
 static void append_attrib_pair(  
                                HashStringValue::key_type key,   
                                HashStringValue::value_type value,   
                                Attrib_info* info) {  
         // skip user-specified and internal(starting with "line-") attributes   
         if(info->skip && info->skip->get(key) || key.pos("line-")==0)  
                 return;                  return;
   
         // src="a.gif" width=123 ismap[=-1]          // src="a.gif" width="123" ismap[=-1]
         *info->tag << " " << key;          tag << " " << key;
         if(value->is_string() || value->as_int()>=0)          if(value->is_string() || value->as_int()>=0)
                 *info->tag << "=\"" << value->as_string() << "\"";                  tag << "=\"" << value->as_string() << "\"";
 }  }
 static void _html(Request& r, MethodParams& params) {  
   
   static void _html(Request& r, MethodParams& params) {
         String tag;          String tag;
         tag << "<img";          tag << "<img";
   
Line 828  static void _html(Request& r, MethodPara Line 885  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(params[0]);
                         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};                                  for(HashStringValue::Iterator i(*attribs); i; i.next() )
                                 attribs->for_each<Attrib_info*>(append_attrib_pair, &info);                                          append_attrib_pair(tag, i.key(), i.value());
                         } else                          } else
                                 throw Exception(PARSER_RUNTIME,                                   throw Exception(PARSER_RUNTIME, 0, "attributes must be hash");
                                         0,                   }
                                         "attributes must be hash");  
         }          }
   
         {          for(HashStringValue::Iterator i(fields); i; i.next() ){
                 Attrib_info info={&tag, attribs};                  String::Body key=i.key();
                 fields.for_each<Attrib_info*>(append_attrib_pair, &info);                  // skip user-specified attributes
                   if(attribs && attribs->get(key))
                           continue;
                   // allow only html attributes (to exclude exif, line-*)
                   if(key=="src" || key=="width" || key=="height" || key=="border")
                           append_attrib_pair(tag, key, i.value());
         }          }
   
         tag << " />";          tag << " />";
         r.write_pass_lang(tag);          r.write(tag);
 }  }
   
 /// @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.full_disk_path(file_name).taint_cstr(String::L_FILE_SPEC);
         const char* file_name_cstr=r.absolute(file_name).taint_cstr(String::L_FILE_SPEC);          if(FILE *f=pa_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, "is not in GIF format");
                                 &file_name,  
                                 "is not in GIF format");  
                 return image;                  return image;
         } else {          } else {
                 throw Exception("file.missing",                   throw Exception("file.missing", 0, "can not open '%s'", file_name_cstr);
                         0,   
                         "can not open '%s'", file_name_cstr);  
         }          }
 }  }
   
Line 891  static void _create(Request& r, MethodPa Line 947  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();
   
         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*/,   
                 (const char*)buf.ptr, buf.size,   
                 file_name? file_name->taint_cstr(String::L_FILE_SPEC): 0,   
                 content_type);  
   
         r.write_no_lang(vfile);          vfile.set_binary(false/*not tainted*/, (const char *)buf.ptr, buf.size, file_name, new VString(*new String("image/gif")));
   
           r.write(vfile);
 }  }
   
 static void _line(Request& r, MethodParams& params) {  static void _line(Request& r, MethodParams& params) {
Line 950  static void _bar(Request& r, MethodParam Line 1001  static void _bar(Request& r, MethodParam
 }  }
   
 #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)          if(row->count()!=2)
                 throw Exception(0,                  throw Exception(0, 0, "coordinates table must contain two columns: x and y values");
                         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) {
           int src_color=params.as_int(0, "src color must be int", r);
           int dest_color=params.as_int(1, "dest color must be int", r);
   
         gdImage& image=GET_SELF(r, VImage).image();          gdImage& image=GET_SELF(r, VImage).image();
   
         Table* table=params.as_no_junction(2, COORDINATES_MUST_NOT_BE_CODE).get_table();          gdImage::Point* all_p=0;
         if(!table)           size_t count=0;
                 throw Exception(PARSER_RUNTIME,          if(params.count() == 3){
                         0,                  Table* table=params.as_table(2, "coordinates");
                         "coordinates must be table");                  count=table->count();
                   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);
                   }
           }
   
         gdImage::Point *all_p=new(PointerFreeGC) gdImage::Point[table->count()];          if(count)
         gdImage::Point *add_p=all_p;                      image.FilledPolygonReplaceColor(all_p, count, image.Color(src_color), image.Color(dest_color));
         table->for_each(add_point, &add_p);  
         image.FilledPolygonReplaceColor(all_p, table->count(),   
                 image.Color(params.as_int(0, "src color must be int", r)),  
                 image.Color(params.as_int(1, "dest color must be int", r)));  
 }  }
   
 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();
   
         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(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;    
Line 998  static void _polyline(Request& r, Method Line 1064  static void _polyline(Request& r, Method
 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();
   
         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;    
Line 1014  static void _polygon(Request& r, MethodP Line 1076  static void _polygon(Request& r, MethodP
 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();
   
         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;    
Line 1033  static void _polybar(Request& r, MethodP Line 1091  static void _polybar(Request& r, MethodP
   
 // Font class  // Font class
   
 Font::Font(//,   Font::Font(Charset& asource_charset, const String& aalphabet, gdImage* aifont, int aheight, int amonospace, int aspacebarspace, int aletterspacing):
         const String& aalphabet,   
         gdImage* aifont, int aheight, int amonospace, int aspacebarspace, int aletterspacing):  
         height(aheight), monospace(amonospace),  spacebarspace(aspacebarspace),  
         letterspacing(aletterspacing),          letterspacing(aletterspacing),
           height(aheight),
           monospace(amonospace),
           spacebarspace(aspacebarspace),
         ifont(aifont),          ifont(aifont),
         alphabet(aalphabet)     {          alphabet(aalphabet),
           fsource_charset(asource_charset){
   
           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 1049  size_t Font::index_of(char ch) { Line 1114  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 1076  int Font::step_width(int index) { Line 1146  int Font::step_width(int index) {
 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 1097  static void _font(Request& r, MethodPara Line 1183  static void _font(Request& r, MethodPara
         const String& alphabet=params.as_string(0, "alphabet must not be code");          const String& alphabet=params.as_string(0, "alphabet must not be code");
         size_t alphabet_length=alphabet.length(r.charsets.source());          size_t alphabet_length=alphabet.length(r.charsets.source());
         if(!alphabet_length)          if(!alphabet_length)
                 throw Exception(PARSER_RUNTIME,                  throw Exception(PARSER_RUNTIME, 0, "alphabet must not be empty");
                         0,  
                         "alphabet must not be empty");  
   
         gdImage* image=load(r, params.as_string(1, FILE_NAME_MUST_NOT_BE_CODE));          gdImage* image=load(r, params.as_string(1, FILE_NAME_MUST_NOT_BE_CODE));
   
Line 1107  static void _font(Request& r, MethodPara Line 1191  static void _font(Request& r, MethodPara
         int monospace_width=0; // proportional          int monospace_width=0; // proportional
         int letter_spacing=1;          int letter_spacing=1;
         if(params.count()>2){          if(params.count()>2){
                 if(HashStringValue* options=params.as_no_junction(2, "param must be int or hash").get_hash()){                  if(HashStringValue* options=params[2].get_hash()){
                         // third option is hash                          // third option is hash
                         if(params.count()>3)                          if(params.count()>3)
                                 throw Exception(PARSER_RUNTIME,                                  throw Exception(PARSER_RUNTIME, 0, "too many params were specified");
                                         0,  
                                         "too many options were specified");  
                         int valid_options=0;                          int valid_options=0;
                         if(Value* vspacebar_width=options->get(spacebar_width_name)){                          if(Value* vspacebar_width=options->get(spacebar_width_name)){
                                 valid_options++;                                  valid_options++;
                                 spacebar_width=r.process_to_value(*vspacebar_width).as_int();                                  spacebar_width=r.process(*vspacebar_width).as_int();
                         }                          }
                         if(Value* vmonospace_width=options->get(monospace_width_name)){                          if(Value* vmonospace_width=options->get(monospace_width_name)){
                                 valid_options++;                                  valid_options++;
                                 monospace_width=r.process_to_value(*vmonospace_width).as_int();                                  monospace_width=r.process(*vmonospace_width).as_int();
                                 if(!monospace_width)                                  if(!monospace_width)
                                         monospace_width=image->SX();                                          monospace_width=image->SX();
                         }                          }
                         if(Value* vletter_spacing=options->get(letter_spacing_name)){                          if(Value* vletter_spacing=options->get(letter_spacing_name)){
                                 valid_options++;                                  valid_options++;
                                 letter_spacing=r.process_to_value(*vletter_spacing).as_int();                                  letter_spacing=r.process(*vletter_spacing).as_int();
                         }                          }
                         if(valid_options!=options->count())                          if(valid_options!=options->count())
                                 throw Exception(PARSER_RUNTIME,                                  throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
                                         0,  
                                         "called with invalid option");  
                 } else {                  } else {
                         // backward                          // backward
                         spacebar_width=params.as_int(2, "spacebar_width must be int", r);                          spacebar_width=params.as_int(2, "param must be int or hash", r);
                         if(params.count()>3) {                          if(params.count()>3) {
                                 monospace_width=params.as_int(3, "monospace_width must be int", r);                                  monospace_width=params.as_int(3, "monospace_width must be int", r);
                                 if(!monospace_width)                                  if(!monospace_width)
Line 1144  static void _font(Request& r, MethodPara Line 1224  static void _font(Request& r, MethodPara
         }          }
   
         if(int remainder=image->SY() % alphabet_length)          if(int remainder=image->SY() % alphabet_length)
                 throw Exception(PARSER_RUNTIME,                  throw Exception(PARSER_RUNTIME, 0, "font-file height(%d) not divisable by alphabet size(%d), remainder=%d", image->SY(), alphabet_length, remainder);
                         0,  
                         "font-file height(%d) not divisable by alphabet size(%d), remainder=%d",  
                                 image->SY(), alphabet_length, remainder);  
                   
         GET_SELF(r, VImage).set_font(new Font(          GET_SELF(r, VImage).set_font(new Font(r.charsets.source(), alphabet, image, image->SY() / alphabet_length, monospace_width, spacebar_width, letter_spacing));
                 alphabet,   
                 image,   
                 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 1168  static void _length(Request& r, MethodPa Line 1242  static void _length(Request& r, MethodPa
         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);
         r.write_no_lang(*new VInt(vimage.font().string_width(s)));          r.write(*new VInt(vimage.font().string_width(s)));
 }  }
   
 static void _arc(Request& r, MethodParams& params) {  static void _arc(Request& r, MethodParams& params) {
Line 1217  gdImage& as_image(MethodParams& params, Line 1291  gdImage& as_image(MethodParams& params,
         if(Value* vimage=value.as(VIMAGE_TYPE)) {          if(Value* vimage=value.as(VIMAGE_TYPE)) {
                 return static_cast<VImage *>(vimage)->image();                  return static_cast<VImage *>(vimage)->image();
         } else          } else
                 throw Exception(PARSER_RUNTIME,                   throw Exception(PARSER_RUNTIME, 0, msg);
                         0,   
                         msg);  
 }  }
   
 static void _copy(Request& r, MethodParams& params) {  static void _copy(Request& r, MethodParams& params) {
Line 1255  static void _pixel(Request& r, MethodPar Line 1327  static void _pixel(Request& r, MethodPar
                 image.SetPixel(x, y,                   image.SetPixel(x, y, 
                         image.Color(params.as_int(2, "color must be int", r)));                          image.Color(params.as_int(2, "color must be int", r)));
         } else           } else 
                 r.write_no_lang(*new VInt(image.DecodeColor(image.GetPixel(x, y))));                  r.write(*new VInt(image.DecodeColor(image.GetPixel(x, y))));
 }  }
   
   
Line 1263  static void _pixel(Request& r, MethodPar Line 1335  static void _pixel(Request& r, MethodPar
   
 MImage::MImage(): Methoded("image") {  MImage::MImage(): Methoded("image") {
         // ^image:measure[DATA]          // ^image:measure[DATA]
         add_native_method("measure", Method::CT_DYNAMIC, _measure, 1, 1);          // ^image:measure[DATA; $.exif(false) $.xmp(false) $.xmp-charset[UTF-8] ]
           add_native_method("measure", Method::CT_DYNAMIC, _measure, 1, 2);
   
         // ^image.html[]          // ^image.html[]
         // ^image.html[hash]          // ^image.html[hash]
Line 1292  MImage::MImage(): Methoded("image") { Line 1365  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);
Removed from v.1.131  
changed lines
  Added in v.1.167

E-mail: