[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.38 and 1.47

version 1.38, 2001/09/01 14:49:01 version 1.47, 2001/10/04 14:56:29
Line 2 Line 2
         Parser: @b image parser class.          Parser: @b image parser class.
   
         Copyright(c) 2001 ArtLebedev Group(http://www.artlebedev.com)          Copyright(c) 2001 ArtLebedev Group(http://www.artlebedev.com)
   
         Author: Alexander Petrosyan <paf@design.ru>(http://design.ru/paf)          Author: Alexander Petrosyan <paf@design.ru>(http://design.ru/paf)
   
         $Id$          $Id$
 */  */
 static const char *RCSId="$Id$";   
   
 /*  /*
         jpegsize: gets the width and height (in pixels) of a jpeg file          jpegsize: gets the width and height (in pixels) of a jpeg file
Line 47  public: // Methoded Line 45  public: // Methoded
   
 // helpers  // helpers
   
 /// simple buffered reader[from memory/file], used in _measure  #ifndef DOXYGEN
 class Measure_reader {  class Measure_reader {
 public:  public:
         enum { READ_CHUNK_SIZE=0x400*10 };// 10K          enum { READ_CHUNK_SIZE=0x400*20 };// 20K
         typedef size_t(*Func)(void *& buf, size_t limit, void *info);          typedef size_t(*Func)(void *& buf, size_t limit, void *info);
   
         Measure_reader(Func afunc, void *ainfo) :           Measure_reader(Func afunc, void *ainfo) : 
Line 83  private: Line 81  private:
         size_t offset;          size_t offset;
         size_t size;          size_t size;
 };  };
   #endif
   
 /// GIF file header  /// GIF file header
 struct GIF_Header {  struct GIF_Header {
Line 137  void measure_gif(Pool& pool, const Strin Line 136  void measure_gif(Pool& pool, const Strin
         if(strncmp(head->type, "GIF", 3)!=0)          if(strncmp(head->type, "GIF", 3)!=0)
                 PTHROW(0, 0,                   PTHROW(0, 0, 
                         origin_string,                           origin_string, 
                         "not GIF file - signature not found");                            "not GIF file - wrong signature");      
   
         width=little_endian_to_int(head->width);          width=little_endian_to_int(head->width);
         height=little_endian_to_int(head->height);          height=little_endian_to_int(head->height);
Line 161  void measure_jpeg(Pool& pool, const Stri Line 160  void measure_jpeg(Pool& pool, const Stri
         if(!(signature[0]==0xFF && signature[1]==0xD8))           if(!(signature[0]==0xFF && signature[1]==0xD8)) 
                 PTHROW(0, 0,                   PTHROW(0, 0, 
                         origin_string,                           origin_string, 
                         "not JPEG file - signature not found");                          "not JPEG file - wrong signature");
   
         bool found=false;          bool found=false;
         while(true) {          while(true) {
Line 219  void measure(Pool& pool, const String& f Line 218  void measure(Pool& pool, const String& f
                         "can not determine image type - no file name extension");                          "can not determine image type - no file name extension");
 }  }
   
 /// used by image: _measure / read_mem  #ifndef DOXYGEN
 struct Read_mem_info {  struct Read_mem_info {
         unsigned char *ptr;          unsigned char *ptr;
         unsigned char *eof;          unsigned char *eof;
 };  };
   #endif
 static size_t read_mem(void*& buf, size_t limit, void *info) {  static size_t read_mem(void*& buf, size_t limit, void *info) {
         Read_mem_info& rmi=*static_cast<Read_mem_info *>(info);          Read_mem_info& rmi=*static_cast<Read_mem_info *>(info);
         buf=rmi.ptr;          buf=rmi.ptr;
Line 232  static size_t read_mem(void*& buf, size_ Line 232  static size_t read_mem(void*& buf, size_
         return read_size;          return read_size;
 }  }
   
 /// used by image: _measure / read_disk  #ifndef DOXYGEN
 struct Read_disk_info {  struct Read_disk_info {
         const String *file_spec;          const String *file_spec;
         size_t offset;          size_t offset;
 };  };
   #endif
 static size_t read_disk(void*& buf, size_t limit, void *info) {  static size_t read_disk(void*& buf, size_t limit, void *info) {
         Read_disk_info& rdi=*static_cast<Read_disk_info *>(info);          Read_disk_info& rdi=*static_cast<Read_disk_info *>(info);
         Pool& pool=rdi.file_spec->pool();          Pool& pool=rdi.file_spec->pool();
Line 283  static void _measure(Request& r, const S Line 284  static void _measure(Request& r, const S
         static_cast<VImage *>(r.self)->set(file_name, width, height);          static_cast<VImage *>(r.self)->set(file_name, width, height);
 }  }
   
 /// used by image: _html / append_attrib_pair  #ifndef DOXYGEN
 struct Attrib_info {  struct Attrib_info {
         String *tag; ///< html tag being constructed          String *tag; ///< html tag being constructed
         Hash *skip; ///< tag attributes not to append to tag string [to skip]          Hash *skip; ///< tag attributes not to append to tag string [to skip]
 };  };
   #endif
 static void append_attrib_pair(const Hash::Key& key, Hash::Val *val, void *info) {  static void append_attrib_pair(const Hash::Key& key, Hash::Val *val, void *info) {
         Attrib_info& ai=*static_cast<Attrib_info *>(info);          Attrib_info& ai=*static_cast<Attrib_info *>(info);
   
Line 309  static void _html(Request& r, const Stri Line 311  static void _html(Request& r, const Stri
         const Hash& fields=static_cast<VImage *>(r.self)->fields();          const Hash& fields=static_cast<VImage *>(r.self)->fields();
         Hash *attribs=0;          Hash *attribs=0;
   
         if(params->size())          if(params->size()) {
                 if(attribs=params->get(0).get_hash()) {                  Value &vattribs=params->get(0);
                         Attrib_info attrib_info={&tag, 0};                  if(vattribs.is_defined()) // allow 'void'
                         attribs->for_each(append_attrib_pair, &attrib_info);                          if(Hash *attribs=vattribs.get_hash()) {
                 } else                                  Attrib_info attrib_info={&tag, 0};
                         PTHROW(0, 0,                                   attribs->for_each(append_attrib_pair, &attrib_info);
                                 &method_name,                           } else
                                 "attributes must be must be hash");                                  PTHROW(0, 0, 
                                           &method_name, 
                                           "attributes must be hash");
           }
   
         Attrib_info attrib_info={&tag, attribs};          Attrib_info attrib_info={&tag, attribs};
         fields.for_each(append_attrib_pair, &attrib_info);          fields.for_each(append_attrib_pair, &attrib_info);
Line 328  static gdImage *load(Request& r, const S Line 333  static gdImage *load(Request& r, const S
                                          const String& file_name){                                           const String& file_name){
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         const char *file_name_cstr=r.absolute(file_name).cstr(String::UL_FILE_NAME);          const char *file_name_cstr=r.absolute(file_name).cstr(String::UL_FILE_SPEC);
         if(FILE *f=fopen(file_name_cstr, "rb")) {          if(FILE *f=fopen(file_name_cstr, "rb")) {
                 gdImage& image=*new(pool) gdImage(pool);                  gdImage& image=*new(pool) gdImage(pool);
                 bool ok=image.CreateFromGif(f);                  bool ok=image.CreateFromGif(f);
Line 350  static gdImage *load(Request& r, const S Line 355  static gdImage *load(Request& r, const S
 static void _load(Request& r, const String& method_name, MethodParams *params) {  static void _load(Request& r, const String& method_name, MethodParams *params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         Value& vfile_name=params->as_no_junction(0, "file name must not be code");          const String& file_name=params->as_string(0, "file name must not be code");
         const String& file_name=vfile_name.as_string();  
   
         gdImage& image=*load(r, method_name, file_name);          gdImage& image=*load(r, method_name, file_name);
         int width=image.SX();          int width=image.SX();
Line 387  static void _gif(Request& r, const Strin Line 391  static void _gif(Request& r, const Strin
         String out(pool); image->Gif(out);          String out(pool); image->Gif(out);
                   
         VFile& vfile=*new(pool) VFile(pool);          VFile& vfile=*new(pool) VFile(pool);
         String& image_gif=*new(pool) String(pool, "image/gif");          Value *content_type=new(pool) VString(*new(pool) String(pool, "image/gif"));
         vfile.set(false/*not tainted*/,           vfile.set(false/*not tainted*/, 
                 out.cstr(String::UL_AS_IS), out.size(), 0, &image_gif);                  out.cstr(String::UL_AS_IS), out.size(), 0, content_type);
   
         r.write_no_lang(vfile);          r.write_no_lang(vfile);
 }  }
Line 460  static void _bar(Request& r, const Strin Line 464  static void _bar(Request& r, const Strin
                 image->Color(params->as_int(4, r)));                  image->Color(params->as_int(4, r)));
 }  }
   
   #ifndef DOXYGEN
   static void add_point(Array::Item *value, void *info) {
           Array& row=*static_cast<Array *>(value);
           gdImage::Point **p=static_cast<gdImage::Point **>(info);
           
           (**p).x=row.get_string(0)->as_int();
           (**p).y=row.get_string(1)->as_int();
           (*p)++;
   }
   #endif
 static void _replace(Request& r, const String& method_name, MethodParams *params) {  static void _replace(Request& r, const String& method_name, MethodParams *params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
Line 469  static void _replace(Request& r, const S Line 483  static void _replace(Request& r, const S
                         &method_name,                           &method_name, 
                         "does not contain an image");                          "does not contain an image");
   
         if((params->size()-2)%2) // I see your thoughts, but that's more readable          Table *table=params->as_no_junction(2, "coordinates must not be code").get_table();
                 PTHROW(0, 0,           if(!table) 
                         &method_name,                   PTHROW(0, 0,
                         "y coordinate missing");                          &method_name,
                           "coordinates must be table");
   
         int n=(params->size()-2)/2;          gdImage::Point *all_p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*table->size());
                   gdImage::Point *add_p=all_p;    
         gdImage::Point *p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*n);          table->for_each(add_point, &add_p);
         for(int i=0; i<n; i++) {          image->FilledPolygonReplaceColor(all_p, table->size(), 
                 p[i].x=params->as_int(2+i*2+0, r);  
                 p[i].y=params->as_int(2+i*2+1, r);  
         }  
         image->FilledPolygonReplaceColor(p, n,   
                 image->Color(params->as_int(0, r)), // src color                  image->Color(params->as_int(0, r)), // src color
                 image->Color(params->as_int(1, r)));// dest color                  image->Color(params->as_int(1, r)));// dest color
 }  }
   
 static void _polygon(Request& r, const String& method_name, MethodParams *params) {  static void _polyline(Request& r, const String& method_name, MethodParams *params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         gdImage *image=static_cast<VImage *>(r.self)->image;          gdImage *image=static_cast<VImage *>(r.self)->image;
Line 495  static void _polygon(Request& r, const S Line 506  static void _polygon(Request& r, const S
                         &method_name,                           &method_name, 
                         "does not contain an image");                          "does not contain an image");
   
         if((params->size()-1)%2) // [I see..] see now?          Table *table=params->as_no_junction(1, "coordinates must not be code").get_table();
           if(!table) 
                   PTHROW(0, 0,
                           &method_name,
                           "coordinates must be table");
   
           gdImage::Point *all_p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*table->size());
           gdImage::Point *add_p=all_p;    
           table->for_each(add_point, &add_p);
           image->Polygon(all_p, table->size(), 
                   image->Color(params->as_int(0, r)),
                   false/*not closed*/);
   }
   
   static void _polygon(Request& r, const String& method_name, MethodParams *params) {
           Pool& pool=r.pool();
   
           gdImage *image=static_cast<VImage *>(r.self)->image;
           if(!image)
                 PTHROW(0, 0,                   PTHROW(0, 0, 
                         &method_name,                           &method_name, 
                         "y coordinate missing");                          "does not contain an image");
   
         int n=(params->size()-1)/2;          Table *table=params->as_no_junction(1, "coordinates must not be code").get_table();
                   if(!table) 
         gdImage::Point *p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*n);                  PTHROW(0, 0,
         for(int i=0; i<n; i++) {                          &method_name,
                 p[i].x=params->as_int(2+i*2+0, r);                          "coordinates must be table");
                 p[i].y=params->as_int(2+i*2+1, r);  
         }          gdImage::Point *all_p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*table->size());
         image->Polygon(p, n,           gdImage::Point *add_p=all_p;    
           table->for_each(add_point, &add_p);
           image->Polygon(all_p, table->size(), 
                 image->Color(params->as_int(0, r)));                  image->Color(params->as_int(0, r)));
 }  }
   
Line 520  static void _polybar(Request& r, const S Line 551  static void _polybar(Request& r, const S
                         &method_name,                           &method_name, 
                         "does not contain an image");                          "does not contain an image");
   
         if((params->size()-1)%2) // [I see..] see now?          Table *table=params->as_no_junction(1, "coordinates must not be code").get_table();
                 PTHROW(0, 0,           if(!table) 
                         &method_name,                   PTHROW(0, 0,
                         "y coordinate missing");                          &method_name,
                           "coordinates must be table");
   
         int n=(params->size()-1)/2;          gdImage::Point *all_p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*table->size());
                   gdImage::Point *add_p=all_p;    
         gdImage::Point *p=(gdImage::Point *)pool.malloc(sizeof(gdImage::Point)*n);          table->for_each(add_point, &add_p);
         for(int i=0; i<n; i++) {          image->FilledPolygon(all_p, table->size(), 
                 p[i].x=params->as_int(2+i*2+0, r);  
                 p[i].y=params->as_int(2+i*2+1, r);  
         }  
         image->FilledPolygon(p, n,   
                 image->Color(params->as_int(0, r)));                  image->Color(params->as_int(0, r)));
 }  }
   
Line 584  public: Line 612  public:
         }          }
                   
         /* ******************************** string ********************************** */          /* ******************************** string ********************************** */
         /*          
         int string_width(const char *cstr){          int string_width(const String& s){
                   const char *cstr=s.cstr(String::UL_AS_IS);
                 int result=0;                  int result=0;
                 for(; *cstr; cstr++)                  for(; *cstr; cstr++)
                         result+=index_width(index_of(*cstr));                          result+=index_width(index_of(*cstr));
                 return result;                  return result;
         }          }
         */  
                   
         void string_display(gdImage& image, int x, int y, const String& s){          void string_display(gdImage& image, int x, int y, const String& s){
                 const char *cstr=s.cstr(String::UL_AS_IS);                  const char *cstr=s.cstr(String::UL_AS_IS);
Line 651  static void _text(Request& r, const Stri Line 679  static void _text(Request& r, const Stri
                         "does not contain an image");                          "does not contain an image");
 }  }
   
   static void _length(Request& r, const String& method_name, MethodParams *params) {
           Pool& pool=r.pool();
   
           const String& s=params->as_string(0, "text must not be code");
   
           VImage& vimage=*static_cast<VImage *>(r.self);
           if(vimage.image)
                   if(vimage.font) {
                           VInt& result=*new(pool) VInt(pool, vimage.font->string_width(s));
                           result.set_name(method_name);
                           r.write_assign_lang(result);
                   } else
                           PTHROW(0, 0,
                                   &method_name,
                                   "set the font first");
           else
                   PTHROW(0, 0, 
                           &method_name, 
                           "does not contain an image");
   }
   
 // constructor  // constructor
   
 MImage::MImage(Pool& apool) : Methoded(apool) {  MImage::MImage(Pool& apool) : Methoded(apool) {
Line 686  MImage::MImage(Pool& apool) : Methoded(a Line 735  MImage::MImage(Pool& apool) : Methoded(a
         // ^image.bar(x0;y0;x1;y1;color)          // ^image.bar(x0;y0;x1;y1;color)
         add_native_method("bar", Method::CT_DYNAMIC, _bar, 5, 5);          add_native_method("bar", Method::CT_DYNAMIC, _bar, 5, 5);
   
         // ^image.replace(color-source;color-dest)(x;y)... point coord pairs          // ^image.replace(color-source;color-dest)[table x:y]
         add_native_method("replace", Method::CT_DYNAMIC, _replace, 2+3*2, 2+100*2);          add_native_method("replace", Method::CT_DYNAMIC, _replace, 3, 3);
   
           // ^image.polyline(color)[table x:y]
           add_native_method("polyline", Method::CT_DYNAMIC, _polyline, 2, 2);
   
         // ^image.polygon(color)(x;y)... point coord pairs          // ^image.polygon(color)[table x:y]
         add_native_method("polygon", Method::CT_DYNAMIC, _polygon, 1+3*2, 1+100*2);          add_native_method("polygon", Method::CT_DYNAMIC, _polygon, 2, 2);
   
         // ^image.polybar(color)(x;y)... point coord pairs          // ^image.polybar(color)[table x:y]
         add_native_method("polybar", Method::CT_DYNAMIC, _polybar, 1+3*2, 1+100*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](spacebar_width)
     // ^image.font[alPHAbet;font-file-name.gif](spacebar_width;width)      // ^image.font[alPHAbet;font-file-name.gif](spacebar_width;width)
Line 702  MImage::MImage(Pool& apool) : Methoded(a Line 754  MImage::MImage(Pool& apool) : Methoded(a
     // ^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]
           add_native_method("length", Method::CT_DYNAMIC, _length, 1, 1);
           
 }  }
   
 // global variable  // global variable
Removed from v.1.38  
changed lines
  Added in v.1.47

E-mail: