/**************************************************************************//** * Info class method definitions for RMagick. * * Copyright © 2002 - 2009 by Timothy P. Hunter * * Changes since Nov. 2009 copyright © by Benjamin Thomas and Omer Bar-or * * @file rminfo.c * @version $Id: rminfo.c,v 1.79 2009/12/20 02:33:33 baror Exp $ * @author Tim Hunter ******************************************************************************/ #include "rmagick.h" /** * Return the value of the specified option. * * Ruby usage: * - @verbatim Info#get_option(key) @endverbatim * * @param self this object * @param key the option key * @return the value of key */ static VALUE get_option(VALUE self, const char *key) { Info *info; const char *value; Data_Get_Struct(self, Info, info); value = GetImageOption(info, key); if (value) { return rb_str_new2(value); } return Qnil; } /** * Set the specified option to this value. If the value is nil just unset any * current value. * * Ruby usage: * - @verbatim Info#set_option(key,string) @endverbatim * * @param self this object * @param key the option key * @param string the value * @return self */ static VALUE set_option(VALUE self, const char *key, VALUE string) { Info *info; char *value; Data_Get_Struct(self, Info, info); if (NIL_P(string)) { (void) RemoveImageOption(info, key); } else { value = StringValuePtr(string); (void) SetImageOption(info, key, value); } return self; } /** * Set a color name as the value of the specified option * * No Ruby usage (internal function) * * Notes: * - Call QueryColorDatabase to validate color name. * * @param self this object * @param option the option * @param color the color name * @return self */ static VALUE set_color_option(VALUE self, const char *option, VALUE color) { Info *info; char *name; PixelPacket pp; ExceptionInfo exception; MagickBooleanType okay; Data_Get_Struct(self, Info, info); if (NIL_P(color)) { (void) RemoveImageOption(info, option); } else { GetExceptionInfo(&exception); name = StringValuePtr(color); okay = QueryColorDatabase(name, &pp, &exception); (void) DestroyExceptionInfo(&exception); if (!okay) { rb_raise(rb_eArgError, "invalid color name `%s'", name); } (void) RemoveImageOption(info, option); (void) SetImageOption(info, option, name); } return self; } /** * Get an Image::Info option floating-point value. * * No Ruby usage (internal function) * * Notes: * - Convert the string value to a float * * @param self this object * @param option the option name * @return the Image::Info option */ static VALUE get_dbl_option(VALUE self, const char *option) { Info *info; const char *value; double d; long n; Data_Get_Struct(self, Info, info); value = GetImageOption(info, option); if (!value) { return Qnil; } d = atof(value); n = (long) floor(d); return d == (double)n ? LONG2NUM(n) : rb_float_new(d); } /** * Set an Image::Info option to a floating-point value. * * No Ruby usage (internal function) * * Notes: * - SetImageOption expects the value to be a string. * * @param self this object * @param option the option name * @param value the value * @return self */ static VALUE set_dbl_option(VALUE self, const char *option, VALUE value) { Info *info; char buff[50]; double d; long n; int len; Data_Get_Struct(self, Info, info); if (NIL_P(value)) { (void) RemoveImageOption(info, option); } else { d = NUM2DBL(value); n = floor(d); if (d == n) { len = sprintf(buff, "%-10ld", n); } else { len = sprintf(buff, "%-10.2f", d); } memset(buff+len, '\0', sizeof(buff)-len); (void) RemoveImageOption(info, option); (void) SetImageOption(info, option, buff); } return self; } #if 0 /** * Convert a PixelPacket to a hex-format color name. * * No Ruby usage (internal function) * * @param pp the pixel packet * @param name pointer to the name * @return the name */ static char *pixel_packet_to_hexname(PixelPacket *pp, char *name) { MagickPixelPacket mpp; GetMagickPixelPacket(NULL, &mpp); rm_set_magick_pixel_packet(pp, &mpp); (void) GetColorTuple(&mpp, MagickTrue, name); return name; } #endif DEF_ATTR_ACCESSOR(Info, antialias, bool) /** Maximum length of a format (@see Info_aref) */ #define MAX_FORMAT_LEN 60 /** * Get the value of an option set by Info[]= * * Ruby usage: * - @verbatim Info[format, key] @endverbatim * - @verbatim Info[key] @endverbatim * * Notes: * - The 2 argument form is the original form. Added support for a single * argument after ImageMagick started using Set/GetImageOption for options * that aren't represented by fields in the ImageInfo structure. * * @param argc number of input arguments * @param argv array of input arguments * @param self this object * @return the option value * @see Info_aset */ VALUE Info_aref(int argc, VALUE *argv, VALUE self) { Info *info; char *format_p, *key_p; long format_l, key_l; const char *value; char fkey[MaxTextExtent]; switch (argc) { case 2: format_p = rm_str2cstr(argv[0], &format_l); key_p = rm_str2cstr(argv[1], &key_l); if (format_l > MAX_FORMAT_LEN || format_l + key_l > MaxTextExtent-1) { rb_raise(rb_eArgError, "can't reference %.60s:%.1024s - too long", format_p, key_p); } sprintf(fkey, "%.60s:%.*s", format_p, (int)(MaxTextExtent-61), key_p); break; case 1: strncpy(fkey, StringValuePtr(argv[0]), sizeof(fkey)-1); fkey[sizeof(fkey)-1] = '\0'; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } Data_Get_Struct(self, Info, info); value = GetImageOption(info, fkey); if (!value) { return Qnil; } return rb_str_new2(value); } /** * Call SetImageOption * * Ruby usage: * - @verbatim Info[format, key]= @endverbatim * - @verbatim Info[key]= @endverbatim * * Notes: * - Essentially the same function as Info_define but paired with Info_aref * - If the value is nil it is equivalent to Info_undefine. * - The 2 argument form is the original form. Added support for a single * argument after ImageMagick started using Set/GetImageOption for options * that aren't represented by fields in the ImageInfo structure. * * @param argc number of input arguments * @param argv array of input arguments * @param self this object * @return self * @see Info_aref * @see Info_define * @see Info_undefine */ VALUE Info_aset(int argc, VALUE *argv, VALUE self) { Info *info; volatile VALUE value; char *format_p, *key_p, *value_p = NULL; long format_l, key_l; char ckey[MaxTextExtent]; unsigned int okay; Data_Get_Struct(self, Info, info); switch (argc) { case 3: format_p = rm_str2cstr(argv[0], &format_l); key_p = rm_str2cstr(argv[1], &key_l); if (format_l > MAX_FORMAT_LEN || format_l+key_l > MaxTextExtent-1) { rb_raise(rb_eArgError, "%.60s:%.1024s not defined - too long", format_p, key_p); } (void) sprintf(ckey, "%.60s:%.*s", format_p, (int)(sizeof(ckey)-MAX_FORMAT_LEN), key_p); value = argv[2]; break; case 2: strncpy(ckey, StringValuePtr(argv[0]), sizeof(ckey)-1); ckey[sizeof(ckey)-1] = '\0'; value = argv[1]; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } if (NIL_P(value)) { (void) RemoveImageOption(info, ckey); } else { /* Allow any argument that supports to_s */ value = rm_to_s(value); value_p = StringValuePtr(value); (void) RemoveImageOption(info, ckey); okay = SetImageOption(info, ckey, value_p); if (!okay) { rb_warn("`%s' not defined - SetImageOption failed.", ckey); return Qnil; } } return self; } /** * Get the attenuate attribute. * * Ruby usage: * - @verbatim Info#attenuate @endverbatim * * @param self this object * @return the attenuate */ VALUE Info_attenuate(VALUE self) { return get_dbl_option(self, "attenuate"); } /** * Set the attenuate attribute. * * Ruby usage: * - @verbatim Info#attenuate= @endverbatim * * @param self this object * @param value the attenuate * @return self */ VALUE Info_attenuate_eq(VALUE self, VALUE value) { return set_dbl_option(self, "attenuate", value); } /** * Get the authenticate attribute. * * Ruby usage: * - @verbatim Info#authenticate @endverbatim * * @param self this object * @return the authenticate */ VALUE Info_authenticate(VALUE self) { Info *info; Data_Get_Struct(self, Info, info); if (info->authenticate) { return rb_str_new2(info->authenticate); } else { return Qnil; } } /** * Set the authenticate attribute. * * Ruby usage: * - @verbatim Info#authenticate= @endverbatim * * @param self this object * @param passwd the authenticating password * @return self */ VALUE Info_authenticate_eq(VALUE self, VALUE passwd) { Info *info; char *passwd_p = NULL; long passwd_l = 0; Data_Get_Struct(self, Info, info); if (!NIL_P(passwd)) { passwd_p = rm_str2cstr(passwd, &passwd_l); } if (info->authenticate) { magick_free(info->authenticate); info->authenticate = NULL; } if (passwd_l > 0) { magick_clone_string(&info->authenticate, passwd_p); } return self; } /** * Return the name of the background color as a String * * Ruby usage: * - @verbatim Info#background_color @endverbatim * * @param self this object * @return the name of the background color * @see Image_background_color */ VALUE Info_background_color(VALUE self) { Info *info; Data_Get_Struct(self, Info, info); return rm_pixelpacket_to_color_name_info(info, &info->background_color); } /** * Set the background color. * * Ruby usage: * - @verbatim Info#background_color= @endverbatim * * Notes: * - Color should be a string * * @param self this object * @param bc_arg the background color * @return self * @throw ArgumentError */ VALUE Info_background_color_eq(VALUE self, VALUE bc_arg) { Info *info; //char colorname[MaxTextExtent]; Data_Get_Struct(self, Info, info); Color_to_PixelPacket(&info->background_color, bc_arg); //SetImageOption(info, "background", pixel_packet_to_hexname(&info->background_color, colorname)); return self; } /** * Return the name of the border color as a String. * * Ruby usage: * - @verbatim Info#border_color @endverbatim * * @param self this object * @return the border color * @see Image_border_color */ VALUE Info_border_color(VALUE self) { Info *info; Data_Get_Struct(self, Info, info); return rm_pixelpacket_to_color_name_info(info, &info->border_color); } /** * set the border color * * Ruby usage: * - @verbatim Info#border_color= @endverbatim * * Notes: * - Color should be a string * * @param self this object * @param bc_arg the border color * @return self * @throw ArgumentError */ VALUE Info_border_color_eq(VALUE self, VALUE bc_arg) { Info *info; //char colorname[MaxTextExtent]; Data_Get_Struct(self, Info, info); Color_to_PixelPacket(&info->border_color, bc_arg); //SetImageOption(info, "bordercolor", pixel_packet_to_hexname(&info->border_color, colorname)); return self; } /** * Emulate the -caption option. * * Ruby usage: * - @verbatim Info#caption @endverbatim * * @param self this object * @return the caption */ VALUE Info_caption(VALUE self) { return get_option(self, "caption"); } /** * Emulate the -caption option. * * Ruby usage: * - @verbatim Info#caption= @endverbatim * * @param self this object * @param caption the caption * @return self */ VALUE Info_caption_eq(VALUE self, VALUE caption) { return set_option(self, "caption", caption); } /** * Set the channels * * Ruby usage: * - @verbatim Info#channel @endverbatim * - @verbatim Info#channel(channel) @endverbatim * - @verbatim Info#channel(channel, ...) @endverbatim * * Notes: * - Default channel is AllChannels * - Thanks to Douglas Sellers. * * @param argc number of input arguments * @param argv array of input arguments * @param self this object * @return self */ VALUE Info_channel(int argc, VALUE *argv, VALUE self) { Info *info; ChannelType channels; channels = extract_channels(&argc, argv); // Ensure all arguments consumed. if (argc > 0) { raise_ChannelType_error(argv[argc-1]); } Data_Get_Struct(self, Info, info); info->channel = channels; return self; } /** * Get the colorspace type. * * Ruby usage: * - @verbatim Info#colorspace @endverbatim * * @param self this object * @return the colorspace type */ VALUE Info_colorspace(VALUE self) { Info *info; Data_Get_Struct(self, Info, info); return ColorspaceType_new(info->colorspace); } /** * Set the colorspace type * * Ruby usage: * - @verbatim Info#colorspace= @endverbatim * * @param self this object * @param colorspace the colorspace type * @return self * @throw ArgumentError */ VALUE Info_colorspace_eq(VALUE self, VALUE colorspace) { Info *info; Data_Get_Struct(self, Info, info); VALUE_TO_ENUM(colorspace, info->colorspace, ColorspaceType); return self; } OPTION_ATTR_ACCESSOR(comment, Comment) /** * Get the compression type. * * Ruby usage: * - @verbatim Info#compression @endverbatim * * @param self this object * @return the compression type */ VALUE Info_compression(VALUE self) { Info *info; Data_Get_Struct(self, Info, info); return CompressionType_new(info->compression); } /** * Set the compression type * * Ruby usage: * - @verbatim Info#compression= @endverbatim * * @param self this object * @param type the compression type * @return self * @throw ArgumentError */ VALUE Info_compression_eq(VALUE self, VALUE type) { Info *info; Data_Get_Struct(self, Info, info); VALUE_TO_ENUM(type, info->compression, CompressionType); return self; } /** * Call SetImageOption * * Ruby usage: * - @verbatim Info#define(format, key) @endverbatim * - @verbatim Info#define(format, key, value) @endverbatim * * Notes: * - Default value is the empty string * - This is the only method in Info that is not an attribute accessor. * * @param argc number of input arguments * @param argv array of input arguments * @param self this object * @return self */ VALUE Info_define(int argc, VALUE *argv, VALUE self) { Info *info; char *format, *key; const char *value = ""; long format_l, key_l; char ckey[100]; unsigned int okay; volatile VALUE fmt_arg; Data_Get_Struct(self, Info, info); switch (argc) { case 3: /* Allow any argument that supports to_s */ fmt_arg = rb_String(argv[2]); value = (const char *)StringValuePtr(fmt_arg); case 2: key = rm_str2cstr(argv[1], &key_l); format = rm_str2cstr(argv[0], &format_l); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); } if (2 + format_l + key_l > (long)sizeof(ckey)) { rb_raise(rb_eArgError, "%.20s:%.20s not defined - format or key too long", format, key); } (void) sprintf(ckey, "%s:%s", format, key); (void) RemoveImageOption(info, ckey); okay = SetImageOption(info, ckey, value); if (!okay) { rb_warn("%.20s=\"%.78s\" not defined - SetImageOption failed.", ckey, value); return Qnil; } return self; } /** * Get the delay attribute. * * Ruby usage: * - @verbatim Info#delay @endverbatim * * Notes: * - Convert from string to numeric * * @param self this object * @return the delay */ VALUE Info_delay(VALUE self) { Info *info; const char *delay; char *p; long d; Data_Get_Struct(self, Info, info); delay = GetImageOption(info, "delay"); if (delay) { d = strtol(delay, &p, 10); if (*p != '\0') { rb_raise(rb_eRangeError, "failed to convert %s to Numeric", delay); } return LONG2NUM(d); } return Qnil; } /** * Will raise an exception if `arg' can't be converted to an int. * * No Ruby usage (internal function) * * @param arg the argument * @return arg */ static VALUE arg_is_integer(VALUE arg) { int d = NUM2INT(arg); d = d; // satisfy icc return arg; } /** * Set the delay attribute. * * Ruby usage: * - @verbatim Info#delay= @endverbatim * * Notes: * - Convert from numeric value to string. * * @param self this object * @param string the delay * @return self */ VALUE Info_delay_eq(VALUE self, VALUE string) { Info *info; int delay; int not_num; char dstr[20]; Data_Get_Struct(self, Info, info); if (NIL_P(string)) { (void) RemoveImageOption(info, "delay"); } else { not_num = 0; (void) rb_protect(arg_is_integer, string, ¬_num); if (not_num) { rb_raise(rb_eTypeError, "failed to convert %s into Integer", rb_class2name(CLASS_OF(string))); } delay = NUM2INT(string); sprintf(dstr, "%d", delay); (void) RemoveImageOption(info, "delay"); (void) SetImageOption(info, "delay", dstr); } return self; } /** * Get the density attribute * * Ruby usage: * - @verbatim Info#density @endverbatim * * @param self this object * @return the density */ DEF_ATTR_READER(Info, density, str) /** * Set the text rendering density * * Ruby usage: * - @verbatim Info#density= @endverbatim * * Notes: * - density should be a string, e.g., "72x72" * * @param self this object * @param density_arg the density * @return self * @throw ArgumentError */ VALUE Info_density_eq(VALUE self, VALUE density_arg) { Info *info; volatile VALUE density; char *dens; Data_Get_Struct(self, Info, info); if (NIL_P(density_arg)) { magick_free(info->density); info->density = NULL; return self; } density = rm_to_s(density_arg); dens = StringValuePtr(density); if (!IsGeometry(dens)) { rb_raise(rb_eArgError, "invalid density geometry: %s", dens); } magick_clone_string(&info->density, dens); return self; } /** * Get the depth attribute * * Ruby usage: * - @verbatim Info#depth @endverbatim * * @param self this object * @return the depth */ DEF_ATTR_READER(Info, depth, int) /** * Set the depth (8, 16, 32). * * Ruby usage: * - @verbatim Info#depth= @endverbatim * * @param self this object * @param depth the depth * @return self * @throw ArgumentError */ VALUE Info_depth_eq(VALUE self, VALUE depth) { Info *info; unsigned long d; Data_Get_Struct(self, Info, info); d = NUM2ULONG(depth); switch (d) { case 8: // always okay #if QuantumDepth == 16 || QuantumDepth == 32 || QuantumDepth == 64 case 16: #if QuantumDepth == 32 || QuantumDepth == 64 case 32: #if QuantumDepth == 64 case 64: #endif #endif #endif break; default: rb_raise(rb_eArgError, "invalid depth (%lu)", d); break; } info->depth = d; return self; } /** A dispose option */ static struct { const char *string; /**< the argument given by the user */ const char *enum_name; /**< the enumerator name */ DisposeType enumerator; /**< the enumerator itself */ } Dispose_Option[] = { { "Background", "BackgroundDispose", BackgroundDispose}, { "None", "NoneDispose", NoneDispose}, { "Previous", "PreviousDispose", PreviousDispose}, { "Undefined", "UndefinedDispose", UndefinedDispose}, { "0", "UndefinedDispose", UndefinedDispose}, { "1", "NoneDispose", NoneDispose}, { "2", "BackgroundDispose", BackgroundDispose}, { "3", "PreviousDispose", PreviousDispose}, }; /** Number of dispose options */ #define N_DISPOSE_OPTIONS (int)(sizeof(Dispose_Option)/sizeof(Dispose_Option[0])) /** * Retrieve a dispose option string and convert it to a DisposeType enumerator. * * No Ruby usage (internal function) * * @param name the dispose string * @return the DisposeType enumerator */ DisposeType rm_dispose_to_enum(const char *name) { DisposeType dispose = UndefinedDispose; int x; for (x = 0; x < N_DISPOSE_OPTIONS; x++) { if (strcmp(Dispose_Option[x].string, name) == 0) { dispose = Dispose_Option[x].enumerator; break; } } return dispose; } /** * Retrieve the dispose option string and convert it to a DisposeType * enumerator. * * Ruby usage: * - @verbatim Info#dispose @endverbatim * * @param self this object * @return a DisposeType enumerator */ VALUE Info_dispose(VALUE self) { Info *info; int x; ID dispose_id; const char *dispose; Data_Get_Struct(self, Info, info); dispose_id = rb_intern("UndefinedDispose"); // Map the dispose option string to a DisposeType enumerator. dispose=GetImageOption(info, "dispose"); if (dispose) { for (x = 0; x < N_DISPOSE_OPTIONS; x++) { if (strcmp(dispose, Dispose_Option[x].string) == 0) { dispose_id = rb_intern(Dispose_Option[x].enum_name); break; } } } return rb_const_get(Module_Magick, dispose_id); } /** * Convert a DisposeType enumerator into the equivalent dispose option string. * * Ruby usage: * - @verbatim Info#dispose= @endverbatim * * @param self this object * @param disp the DisposeType enumerator * @return self */ VALUE Info_dispose_eq(VALUE self, VALUE disp) { Info *info; DisposeType dispose; const char *option; int x; Data_Get_Struct(self, Info, info); if (NIL_P(disp)) { (void) RemoveImageOption(info, "dispose"); return self; } VALUE_TO_ENUM(disp, dispose, DisposeType); option = "Undefined"; for (x = 0; x < N_DISPOSE_OPTIONS; x++) { if (dispose == Dispose_Option[x].enumerator) { option = Dispose_Option[x].string; break; } } (void) SetImageOption(info, "dispose", option); return self; } DEF_ATTR_ACCESSOR(Info, dither, bool) /** * Get the endian attribute. * * Ruby usage: * - @verbatim Info#endian @endverbatim * * @param self this object * @return the endian (Magick::MSBEndian or Magick::LSBEndian) */ VALUE Info_endian(VALUE self) { Info *info; Data_Get_Struct(self, Info, info); return EndianType_new(info->endian); } /** * Set the endian attribute. * * Ruby usage: * - @verbatim Info#endian= @endverbatim * * @param self this object * @param endian the endian (Magick::MSBEndian or Magick::LSBEndian) * @return self */ VALUE Info_endian_eq(VALUE self, VALUE endian) { Info *info; EndianType type = UndefinedEndian; if (endian != Qnil) { VALUE_TO_ENUM(endian, type, EndianType); } Data_Get_Struct(self, Info, info); info->endian = type; return self; } /** * Get the extract string, e.g. "200x200+100+100" * * Ruby usage: * - @verbatim Info#extract @endverbatim * * Notes: * - Defined for ImageMagick 5.5.6 and later * * @param self this object * @return the extract string */ DEF_ATTR_READER(Info, extract, str) /** * Set the extract string, e.g. "200x200+100+100" * * Ruby usage: * - @verbatim Info#extract= @endverbatim * * Notes: * - Defined for ImageMagick 5.5.6 and later * * @param self this object * @param extract_arg the extract string * @return self * @throw ArgumentError */ VALUE Info_extract_eq(VALUE self, VALUE extract_arg) { Info *info; char *extr; volatile VALUE extract; Data_Get_Struct(self, Info, info); if (NIL_P(extract_arg)) { magick_free(info->extract); info->extract = NULL; return self; } extract = rm_to_s(extract_arg); extr = StringValuePtr(extract); if (!IsGeometry(extr)) { rb_raise(rb_eArgError, "invalid extract geometry: %s", extr); } magick_clone_string(&info->extract, extr); return self; } /** * Get the "filename". * * Ruby usage: * - @verbatim Info#filename @endverbatim * * Notes: * - Only used for Image_capture * * @param self this object * @return the filename ("" if filename not set) * @see Image_capture */ VALUE Info_filename(VALUE self) { Info *info; Data_Get_Struct(self, Info, info); return rb_str_new2(info->filename); } /** * Set the "filename". * * Ruby usage: * - @verbatim Info#filename= @endverbatim * * Notes: * - Only used for Image_capture * * @param self this object * @param filename the filename * @return self * @see Image_capture */ VALUE Info_filename_eq(VALUE self, VALUE filename) { Info *info; char *fname; Data_Get_Struct(self, Info, info); // Allow "nil" - remove current filename if (NIL_P(filename) || StringValuePtr(filename) == NULL) { info->filename[0] = '\0'; } else { // Otherwise copy in filename fname = StringValuePtr(filename); strncpy(info->filename, fname, MaxTextExtent); } return self; } /** * Return the fill color as a String. * * Ruby usage: * - @verbatim Info#fill @endverbatim * * @param self this object * @return the fill color */ VALUE Info_fill(VALUE self) { return get_option(self, "fill"); } /** * Set the fill color * * Ruby usage: * - @verbatim Info#fill= @endverbatim * * @param self this object * @param color the fill color (as a String) * @return self * @throw ArgumentError */ VALUE Info_fill_eq(VALUE self, VALUE color) { return set_color_option(self, "fill", color); } /** * Get the text font. * * Ruby usage: * - @verbatim Info#font @endverbatim * * @param self this object * @return the font */ DEF_ATTR_READER(Info, font, str) /** * Set the text font. * * Ruby usage: * - @verbatim Info#font= @endverbatim * * @param self this object * @param font_arg the font (as a String) * @return self */ VALUE Info_font_eq(VALUE self, VALUE font_arg) { Info *info; char *font; Data_Get_Struct(self, Info, info); if (NIL_P(font_arg) || StringValuePtr(font_arg) == NULL) { magick_free(info->font); info->font = NULL; } else { font = StringValuePtr(font_arg); magick_clone_string(&info->font, font); } return self; } /** * Return the image encoding format. * * Ruby usage: * - @verbatim Info#format @endverbatim * * @param self this object * @return the encoding format */ VALUE Info_format(VALUE self) { Info *info; const MagickInfo *magick_info ; ExceptionInfo exception; Data_Get_Struct(self, Info, info); if (*info->magick) { GetExceptionInfo(&exception); magick_info = GetMagickInfo(info->magick, &exception); (void) DestroyExceptionInfo(&exception); return magick_info ? rb_str_new2(magick_info->name) : Qnil; } return Qnil; } /** * Set the image encoding format. * * Ruby usage: * - @verbatim Info#format= @endverbatim * * @param self this object * @param magick the encoding format * @return self */ VALUE Info_format_eq(VALUE self, VALUE magick) { Info *info; const MagickInfo *m; char *mgk; ExceptionInfo exception; Data_Get_Struct(self, Info, info); GetExceptionInfo(&exception); mgk = StringValuePtr(magick); m = GetMagickInfo(mgk, &exception); CHECK_EXCEPTION() (void) DestroyExceptionInfo(&exception); if (!m) { rb_raise(rb_eArgError, "unknown format: %s", mgk); } strncpy(info->magick, m->name, MaxTextExtent-1); return self; } /** * Get the fuzz. * * Ruby usage: * - @verbatim Info#fuzz @endverbatim * * @param self this object * @return the fuzz * @see Image_fuzz */ DEF_ATTR_READER(Info, fuzz, dbl) /** * Set the fuzz. * * Ruby usage: * - @verbatim Info#fuzz=number @endverbatim * - @verbatim Info#fuzz=NN% @endverbatim * * @param self this object * @param fuzz the fuzz * @return self * @see Image_fuzz_eq */ VALUE Info_fuzz_eq(VALUE self, VALUE fuzz) { Info *info; Data_Get_Struct(self, Info, info); info->fuzz = rm_fuzz_to_dbl(fuzz); return self; } /** A gravity option */ static struct { const char *string; /**< the argument given by the user */ const char *enum_name; /**< the enumerator name */ GravityType enumerator; /**< the enumerator itself */ } Gravity_Option[] = { { "Undefined", "UndefinedGravity", UndefinedGravity}, { "None", "UndefinedGravity", UndefinedGravity}, { "Center", "CenterGravity", CenterGravity}, { "East", "EastGravity", EastGravity}, { "Forget", "ForgetGravity", ForgetGravity}, { "NorthEast", "NorthEastGravity", NorthEastGravity}, { "North", "NorthGravity", NorthGravity}, { "NorthWest", "NorthWestGravity", NorthWestGravity}, { "SouthEast", "SouthEastGravity", SouthEastGravity}, { "South", "SouthGravity", SouthGravity}, { "SouthWest", "SouthWestGravity", SouthWestGravity}, { "West", "WestGravity", WestGravity}, { "Static", "StaticGravity", StaticGravity} }; /** Number of gravity options */ #define N_GRAVITY_OPTIONS (int)(sizeof(Gravity_Option)/sizeof(Gravity_Option[0])) /** * Return the value of the gravity option as a GravityType enumerator. * * No Ruby usage (internal function) * * @param name the name of the gravity option * @return the enumerator for name */ GravityType rm_gravity_to_enum(const char *name) { GravityType gravity = UndefinedGravity; int x; for (x = 0; x < N_GRAVITY_OPTIONS; x++) { if (strcmp(name, Gravity_Option[x].string) == 0) { gravity = Gravity_Option[x].enumerator; break; } } return gravity; } /** * Return the value of the gravity option as a GravityType enumerator. * * Ruby usage: * - @verbatim Info#gravity @endverbatim * * @param self this object * @return the gravity enumerator */ VALUE Info_gravity(VALUE self) { Info *info; const char *gravity; int x; ID gravity_id; Data_Get_Struct(self, Info, info); gravity_id = rb_intern("UndefinedGravity"); // Map the gravity option string to a GravityType enumerator. gravity=GetImageOption(info, "gravity"); if (gravity) { for (x = 0; x < N_GRAVITY_OPTIONS; x++) { if (strcmp(gravity, Gravity_Option[x].string) == 0) { gravity_id = rb_intern(Gravity_Option[x].enum_name); break; } } } return rb_const_get(Module_Magick, gravity_id); } /** * Convert a GravityType enum to a gravity option name and store in the Info * structure. * * Ruby usage: * - @verbatim Info#gravity= @endverbatim * * @param self this object * @param grav the gravity enumerator * @return self */ VALUE Info_gravity_eq(VALUE self, VALUE grav) { Info *info; GravityType gravity; const char *option; int x; Data_Get_Struct(self, Info, info); if (NIL_P(grav)) { (void) RemoveImageOption(info, "gravity"); return self; } VALUE_TO_ENUM(grav, gravity, GravityType); option = "Undefined"; for (x = 0; x < N_GRAVITY_OPTIONS; x++) { if (gravity == Gravity_Option[x].enumerator) { option = Gravity_Option[x].string; break; } } (void) SetImageOption(info, "gravity", option); return self; } DEF_ATTR_ACCESSOR(Info, group, long) /** * Get the classification type. * * Ruby usage: * - @verbatim Info#image_type @endverbatim * * @param self this object * @return the classification type */ VALUE Info_image_type(VALUE self) { Info *info; Data_Get_Struct(self, Info, info); return ImageType_new(info->type); } /** * Set the classification type. * * Ruby usage: * - @verbatim Info#image_type= @endverbatim * * @param self this object * @param type the classification type * @return self * @throw ArgumentError */ VALUE Info_image_type_eq(VALUE self, VALUE type) { Info *info; Data_Get_Struct(self, Info, info); VALUE_TO_ENUM(type, info->type, ImageType); return self; } /** * Get the interlace type. * * Ruby usage: * - @verbatim Info#interlace @endverbatim * * @param self this object * @return the interlace type */ VALUE Info_interlace(VALUE self) { Info *info; Data_Get_Struct(self, Info, info); return InterlaceType_new(info->interlace); } /** * Set the interlace type * * Ruby usage: * - @verbatim Info#interlace= @endverbatim * * @param self this object * @param inter the interlace type * @return self * @throw ArgumentError */ VALUE Info_interlace_eq(VALUE self, VALUE inter) { Info *info; Data_Get_Struct(self, Info, info); VALUE_TO_ENUM(inter, info->interlace, InterlaceType); return self; } OPTION_ATTR_ACCESSOR(label, Label) /** * Return the name of the matte color as a String. * * Ruby usage: * - @verbatim Info#matte_color @endverbatim * * @param self this object * @return the name of the matte color * @see Image_matte_color */ VALUE Info_matte_color(VALUE self) { Info *info; Data_Get_Struct(self, Info, info); return rm_pixelpacket_to_color_name_info(info, &info->matte_color); } /** * Set the matte color. * * Ruby usage: * - @verbatim Info#matte_color= @endverbatim * * @param self this object * @param matte_arg the name of the matte as a String * @return self * @throw ArgumentError */ VALUE Info_matte_color_eq(VALUE self, VALUE matte_arg) { Info *info; //char colorname[MaxTextExtent]; Data_Get_Struct(self, Info, info); Color_to_PixelPacket(&info->matte_color, matte_arg); //SetImageOption(info, "mattecolor", pixel_packet_to_hexname(&info->matte_color, colorname)); return self; } /** * Establish a progress monitor. * * Ruby usage: * - @verbatim Info#monitor= @endverbatim * * @param self this object * @param monitor the monitor * @return self * @see Image_monitor_eq */ VALUE Info_monitor_eq(VALUE self, VALUE monitor) { Info *info; Data_Get_Struct(self, Info, info); if (NIL_P(monitor)) { info->progress_monitor = NULL; } else { (void) SetImageInfoProgressMonitor(info, rm_progress_monitor, (void *)monitor); } return self; } DEF_ATTR_ACCESSOR(Info, monochrome, bool) DEF_ATTR_ACCESSOR(Info, number_scenes, ulong) /** * Return the orientation attribute as an OrientationType enum value. * * Ruby usage: * - @verbatim Info#orientation @endverbatim * * @param self this object * @return the orientation */ VALUE Info_orientation(VALUE self) { Info *info; Data_Get_Struct(self, Info, info); return OrientationType_new(info->orientation); } /** * Set the Orientation type. * * Ruby usage: * - @verbatim Info#Orientation= @endverbatim * * @param self this object * @param inter the orientation type as an OrientationType enum value * @return self * @throw ArgumentError */ VALUE Info_orientation_eq(VALUE self, VALUE inter) { Info *info; Data_Get_Struct(self, Info, info); VALUE_TO_ENUM(inter, info->orientation, OrientationType); return self; } /** * Return origin geometry. * * Ruby usage: * - @verbatim Info#origin @endverbatim * * @param self this object * @return the origin geometry */ VALUE Info_origin(VALUE self) { Info *info; const char *origin; Data_Get_Struct(self, Info, info); origin = GetImageOption(info, "origin"); return origin ? rb_str_new2(origin) : Qnil; } /** * Set origin geometry. Argument may be a Geometry object as well as a geometry * string. * * Ruby usage: * - @verbatim Info#origin=+-x+-y @endverbatim * * @param self this object * @param origin_arg the origin geometry * @return self */ VALUE Info_origin_eq(VALUE self, VALUE origin_arg) { Info *info; volatile VALUE origin_str; char *origin; Data_Get_Struct(self, Info, info); if (NIL_P(origin_arg)) { (void) RemoveImageOption(info, "origin"); return self; } origin_str = rm_to_s(origin_arg); origin = GetPageGeometry(StringValuePtr(origin_str)); if (IsGeometry(origin) == MagickFalse) { rb_raise(rb_eArgError, "invalid origin geometry: %s", origin); } (void) SetImageOption(info, "origin", origin); return self; } /** * Get the Postscript page geometry. * * Ruby usage: * - @verbatim Info_page @endverbatim * * @param self this object * @return the page geometry */ VALUE Info_page(VALUE self) { Info *info; Data_Get_Struct(self, Info, info); return info->page ? rb_str_new2(info->page) : Qnil; } /** * Store the Postscript page geometry. Argument may be a Geometry object as well * as a geometry string. * * Ruby usage: * - @verbatim Info#page= @endverbatim * * @param self this object * @param page_arg the geometry * @return self */ VALUE Info_page_eq(VALUE self, VALUE page_arg) { Info *info; volatile VALUE geom_str; char *geometry; Data_Get_Struct(self, Info, info); if (NIL_P(page_arg)) { magick_free(info->page); info->page = NULL; return self; } geom_str = rm_to_s(page_arg); geometry=GetPageGeometry(StringValuePtr(geom_str)); if (*geometry == '\0') { magick_free(info->page); info->page = NULL; return self; } magick_clone_string(&info->page, geometry); return self; } DEF_ATTR_ACCESSOR(Info, pointsize, dbl) DEF_ATTR_ACCESSOR(Info, quality, ulong) /** * Get sampling factors used by JPEG or MPEG-2 encoder and YUV decoder/encoder. * * Ruby usage: * - @verbatim Info#sampling_factor @endverbatim * * @param self this object * @return the sampling factors */ VALUE Info_sampling_factor(VALUE self) { Info *info; Data_Get_Struct(self, Info, info); if (info->sampling_factor) { return rb_str_new2(info->sampling_factor); } else { return Qnil; } } /** * Set sampling factors used by JPEG or MPEG-2 encoder and YUV decoder/encoder. * * Ruby usage: * - @verbatim Info#sampling_factor= @endverbatim * * @param self this object * @param sampling_factor the sampling factors * @return self */ VALUE Info_sampling_factor_eq(VALUE self, VALUE sampling_factor) { Info *info; char *sampling_factor_p = NULL; long sampling_factor_len = 0; Data_Get_Struct(self, Info, info); if (!NIL_P(sampling_factor)) { sampling_factor_p = rm_str2cstr(sampling_factor, &sampling_factor_len); } if (info->sampling_factor) { magick_free(info->sampling_factor); info->sampling_factor = NULL; } if (sampling_factor_len > 0) { magick_clone_string(&info->sampling_factor, sampling_factor_p); } return self; } /** * Get the scene number. * * Ruby usage: * - @verbatim Info#scene @endverbatim * * @param self this object * @return the scene number */ VALUE Info_scene(VALUE self) { Info *info; Data_Get_Struct(self, Info, info); return ULONG2NUM(info->scene); } /** * Set the scene number. * * Ruby usage: * - @verbatim Info#scene= @endverbatim * * @param self this object * @param scene the scene number * @return self */ VALUE Info_scene_eq(VALUE self, VALUE scene) { Info *info; char buf[25]; Data_Get_Struct(self, Info, info); info->scene = NUM2ULONG(scene); #if defined(HAVE_SNPRINTF) (void) snprintf(buf, sizeof(buf), "%-ld", info->scene); #else (void) sprintf(buf, "%-l", info->scene); #endif (void) SetImageOption(info, "scene", buf); return self; } /** * Get the server name. * * Ruby usage: * - @verbatim Info#server_name @endverbatim * * @param self this object * @return the server name */ DEF_ATTR_READER(Info, server_name, str) /** * Set the server name. * * Ruby usage: * - @verbatim Info#server_name= @endverbatim * * @param self this object * @param server_arg the server name as a String * @return self */ VALUE Info_server_name_eq(VALUE self, VALUE server_arg) { Info *info; char *server; Data_Get_Struct(self, Info, info); if (NIL_P(server_arg) || StringValuePtr(server_arg) == NULL) { magick_free(info->server_name); info->server_name = NULL; } else { server = StringValuePtr(server_arg); magick_clone_string(&info->server_name, server); } return self; } /** * Get ths size * * Ruby usage: * - @verbatim Info#size @endverbatim * * @param self this object * @return the size as a Geometry object */ DEF_ATTR_READER(Info, size, str) /** * Set the size (either as a Geometry object or a Geometry string, i.e. * WxH{+-}x{+-}y) * * Ruby usage: * - @verbatim Info#size= @endverbatim * * @param self this object * @param size_arg the size * @return self * @throw ArgumentError */ VALUE Info_size_eq(VALUE self, VALUE size_arg) { Info *info; volatile VALUE size; char *sz; Data_Get_Struct(self, Info, info); if (NIL_P(size_arg)) { magick_free(info->size); info->size = NULL; return self; } size = rm_to_s(size_arg); sz = StringValuePtr(size); if (!IsGeometry(sz)) { rb_raise(rb_eArgError, "invalid size geometry: %s", sz); } magick_clone_string(&info->size, sz); return self; } /** * Return the stroke color as a String. * * Ruby usage: * - @verbatim Info#stroke @endverbatim * * @param self this object * @return the stroke color */ VALUE Info_stroke(VALUE self) { return get_option(self, "stroke"); } /** * Set the stroke color * * Ruby usage: * - @verbatim Info#stroke= @endverbatim * * @param self this object * @param color the stroke color as a String * @return self * @throw ArgumentError */ VALUE Info_stroke_eq(VALUE self, VALUE color) { return set_color_option(self, "stroke", color); } /** * Support for caption: format. * * Ruby usage: * - @verbatim Info#stroke_width @endverbatim * * Notes: * - Supported in ImageMagick >= 6.3.2-6 * * @param self this object * @return the stroke width */ VALUE Info_stroke_width(VALUE self) { return get_dbl_option(self, "strokewidth"); } /** * Support for caption: format. * * Ruby usage: * - @verbatim Info#stroke_width= @endverbatim * * Notes: * - Supported in ImageMagick >= 6.3.2-6 * * @param self this object * @param stroke_width the stroke width * @return self */ VALUE Info_stroke_width_eq(VALUE self, VALUE stroke_width) { return set_dbl_option(self, "strokewidth", stroke_width); } /** * Set name of texture to tile onto the image background. * * Ruby usage: * - @verbatim Image::Info#texture= @endverbatim * * @param self this object * @param texture the name of the texture image * @return self */ VALUE Info_texture_eq(VALUE self, VALUE texture) { Info *info; Image *image; char name[MaxTextExtent]; Data_Get_Struct(self, Info, info); // Delete any existing texture file if (info->texture) { rm_delete_temp_image(info->texture); magick_free(info->texture); info->texture = NULL; } // If argument is nil we're done if (texture == Qnil) { return self; } // Create a temp copy of the texture and store its name in the texture field image = rm_check_destroyed(texture); rm_write_temp_image(image, name); magick_clone_string(&info->texture, name); return self; } /** * info.tile_offset = [+/-]x[+/-]y. * * Ruby usage: * - @verbatim Image::Info#tile_offset= @endverbatim * * @param self this object * @param offset the offset * @return self */ VALUE Info_tile_offset_eq(VALUE self, VALUE offset) { Info *info; volatile VALUE offset_str; char *tile_offset; offset_str = rm_to_s(offset); tile_offset = StringValuePtr(offset_str); if (!IsGeometry(tile_offset)) { rb_raise(rb_eArgError, "invalid tile offset geometry: %s", tile_offset); } Data_Get_Struct(self, Info, info); (void) DeleteImageOption(info, "tile-offset"); (void) SetImageOption(info, "tile-offset", tile_offset); return self; } /** * Return the name of the transparent color as a String. * * Ruby usage: * - @verbatim Info#transparent_color @endverbatim * * @param self this object * @return the name of the transparent color * @see Image_transparent_color */ VALUE Info_transparent_color(VALUE self) { Info *info; Data_Get_Struct(self, Info, info); return rm_pixelpacket_to_color_name_info(info, &info->transparent_color); } /** * Set the transparent color. * * Ruby usage: * - @verbatim Info#transparent_color= @endverbatim * * @param self this object * @param tc_arg the transparent color as a String * @return self * @throw ArgumentError */ VALUE Info_transparent_color_eq(VALUE self, VALUE tc_arg) { Info *info; //char colorname[MaxTextExtent]; Data_Get_Struct(self, Info, info); Color_to_PixelPacket(&info->transparent_color, tc_arg); //SetImageOption(info, "transparent", pixel_packet_to_hexname(&info->transparent_color, colorname)); return self; } /** * Return tile_offset attribute values. * * Ruby usage: * - @verbatim Image::Info#tile_offset @endverbatim * * @param self this object * @return the tile offset */ VALUE Info_tile_offset(VALUE self) { Info *info; const char *tile_offset; Data_Get_Struct(self, Info, info); tile_offset = GetImageOption(info, "tile-offset"); if (!tile_offset) { return Qnil; } return rb_str_new2(tile_offset); } /** * Undefine image option. * * Ruby usage: * - @verbatim Info#undefine(format,key) @endverbatim * * @param self this object * @param format the format * @param key the key * @return self */ VALUE Info_undefine(VALUE self, VALUE format, VALUE key) { Info *info; char *format_p, *key_p; long format_l, key_l; char fkey[MaxTextExtent]; format_p = rm_str2cstr(format, &format_l); key_p = rm_str2cstr(key, &key_l); if (format_l > MAX_FORMAT_LEN || format_l + key_l > MaxTextExtent) { rb_raise(rb_eArgError, "can't undefine %.60s:%.1024s - too long", format_p, key_p); } sprintf(fkey, "%.60s:%.*s", format_p, (int)(MaxTextExtent-61), key_p); Data_Get_Struct(self, Info, info); /* Depending on the IM version, RemoveImageOption returns either */ /* char * or MagickBooleanType. Ignore the return value. */ (void) RemoveImageOption(info, fkey); return self; } /** * Return the undercolor color as a String. * * Ruby usage: * - @verbatim Info#undercolor @endverbatim * * @param self this object * @return the undercolor */ VALUE Info_undercolor(VALUE self) { return get_option(self, "undercolor"); } /** * Set the undercolor color. * * Ruby usage: * - @verbatim Info#undercolor= @endverbatim * * @param self this object * @param color the undercolor color as a String * @return self * @throw ArgumentError */ VALUE Info_undercolor_eq(VALUE self, VALUE color) { return set_color_option(self, "undercolor", color); } /** * Get the resolution type. * * Ruby usage: * - @verbatim Info#units @endverbatim * * @param self this object * @return the resolution type */ VALUE Info_units(VALUE self) { Info *info; Data_Get_Struct(self, Info, info); return ResolutionType_new(info->units); } /** * Set the resolution type * * Ruby usage: * - @verbatim Info#units= @endverbatim * * @param self this object * @param units the resolution type * @return self * @throw ArgumentError */ VALUE Info_units_eq(VALUE self, VALUE units) { Info *info; Data_Get_Struct(self, Info, info); VALUE_TO_ENUM(units, info->units, ResolutionType); return self; } /** * Get FlashPix viewing parameters. * * Ruby usage: * - @verbatim Info#view @endverbatim * * @param self this object. * @return the viewing parameters */ DEF_ATTR_READER(Info, view, str) /** * Set FlashPix viewing parameters. * * Ruby usage: * - @verbatim Info#view= @endverbatim * * @param self this object * @param view_arg the viewing parameters * @return self */ VALUE Info_view_eq(VALUE self, VALUE view_arg) { Info *info; char *view; Data_Get_Struct(self, Info, info); if (NIL_P(view_arg) || StringValuePtr(view_arg) == NULL) { magick_free(info->view); info->view = NULL; } else { view = StringValuePtr(view_arg); magick_clone_string(&info->view, view); } return self; } /** * If there is a texture image, delete it before destroying the ImageInfo * structure. * * No Ruby usage (internal function) * * @param infoptr pointer to the Info object */ static void destroy_Info(void *infoptr) { Info *info = (Info *)infoptr; if (info->texture) { rm_delete_temp_image(info->texture); magick_free(info->texture); info->texture = NULL; } (void) DestroyImageInfo(info); } /** * Create an ImageInfo object. * * No Ruby usage (internal function) * * @param class the Ruby class to use * @return a new ImageInfo object */ VALUE Info_alloc(VALUE class) { Info *info; volatile VALUE info_obj; info = CloneImageInfo(NULL); if (!info) { rb_raise(rb_eNoMemError, "not enough memory to initialize Info object"); } info_obj = Data_Wrap_Struct(class, NULL, destroy_Info, info); return info_obj; } /** * Provide a Info.new method for internal use. * * No Ruby usage (internal function) * * Notes: * - Takes no parameters, but runs the parm block if present * * @return a new ImageInfo object */ VALUE rm_info_new(void) { volatile VALUE info_obj; info_obj = Info_alloc(Class_Info); return Info_initialize(info_obj); } /** * If an initializer block is present, run it. * * Ruby usage: * - @verbatim Info#initialize @endverbatim * * @param self this object * @return self */ VALUE Info_initialize(VALUE self) { if (rb_block_given_p()) { // Run the block in self's context (void) rb_obj_instance_eval(0, NULL, self); } return self; }