rmagick 2.12.2 → 2.13.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of rmagick might be problematic. Click here for more details.
- data/ChangeLog +12 -0
- data/Doxyfile +1514 -0
- data/README.html +2 -171
- data/doc/comtasks.html +2 -2
- data/doc/constants.html +2 -2
- data/doc/draw.html +2 -2
- data/doc/ilist.html +2 -2
- data/doc/image1.html +2 -2
- data/doc/image2.html +2 -2
- data/doc/image3.html +2 -2
- data/doc/imageattrs.html +2 -2
- data/doc/imusage.html +2 -2
- data/doc/index.html +3 -3
- data/doc/info.html +2 -2
- data/doc/magick.html +2 -2
- data/doc/optequiv.html +2 -2
- data/doc/rvg.html +2 -2
- data/doc/rvgclip.html +2 -2
- data/doc/rvggroup.html +2 -2
- data/doc/rvgimage.html +2 -2
- data/doc/rvgpattern.html +2 -2
- data/doc/rvgshape.html +2 -2
- data/doc/rvgstyle.html +2 -2
- data/doc/rvgtext.html +2 -2
- data/doc/rvgtspan.html +2 -2
- data/doc/rvgtut.html +2 -2
- data/doc/rvguse.html +2 -2
- data/doc/rvgxform.html +2 -2
- data/doc/struct.html +12 -8
- data/doc/usage.html +2 -2
- data/ext/RMagick/MANIFEST +311 -309
- data/ext/RMagick/extconf.rb +27 -3
- data/ext/RMagick/rmagick.c +151 -69
- data/ext/RMagick/rmagick.h +218 -158
- data/ext/RMagick/rmdraw.c +616 -261
- data/ext/RMagick/rmenum.c +373 -179
- data/ext/RMagick/rmfill.c +166 -71
- data/ext/RMagick/rmilist.c +323 -146
- data/ext/RMagick/rmimage.c +4994 -1756
- data/ext/RMagick/rminfo.c +1004 -366
- data/ext/RMagick/rmmain.c +62 -27
- data/ext/RMagick/rmmontage.c +222 -97
- data/ext/RMagick/rmpixel.c +454 -155
- data/ext/RMagick/rmstruct.c +305 -153
- data/ext/RMagick/rmutil.c +531 -263
- data/lib/rvg/misc.rb +1 -1
- data/rmagick.gemspec +3 -3
- metadata +313 -310
    
        data/ext/RMagick/rminfo.c
    CHANGED
    
    | @@ -1,10 +1,14 @@ | |
| 1 | 
            -
             | 
| 2 | 
            -
             | 
| 3 | 
            -
             | 
| 4 | 
            -
             | 
| 5 | 
            -
             | 
| 6 | 
            -
             | 
| 7 | 
            -
             | 
| 1 | 
            +
            /**************************************************************************//**
         | 
| 2 | 
            +
             * Info class method definitions for RMagick.
         | 
| 3 | 
            +
             *
         | 
| 4 | 
            +
             * Copyright © 2002 - 2009 by Timothy P. Hunter
         | 
| 5 | 
            +
             *
         | 
| 6 | 
            +
             * Changes since Nov. 2009 copyright © by Benjamin Thomas and Omer Bar-or
         | 
| 7 | 
            +
             *
         | 
| 8 | 
            +
             * @file     rminfo.c
         | 
| 9 | 
            +
             * @version  $Id: rminfo.c,v 1.79 2009/12/20 02:33:33 baror Exp $
         | 
| 10 | 
            +
             * @author   Tim Hunter
         | 
| 11 | 
            +
             ******************************************************************************/
         | 
| 8 12 |  | 
| 9 13 | 
             
            #include "rmagick.h"
         | 
| 10 14 |  | 
| @@ -12,10 +16,16 @@ | |
| 12 16 |  | 
| 13 17 |  | 
| 14 18 |  | 
| 15 | 
            -
             | 
| 16 | 
            -
             | 
| 17 | 
            -
             | 
| 18 | 
            -
             | 
| 19 | 
            +
            /**
         | 
| 20 | 
            +
             * Return the value of the specified option.
         | 
| 21 | 
            +
             *
         | 
| 22 | 
            +
             * Ruby usage:
         | 
| 23 | 
            +
             *   - @verbatim Info#get_option(key) @endverbatim
         | 
| 24 | 
            +
             *
         | 
| 25 | 
            +
             * @param self this object
         | 
| 26 | 
            +
             * @param key the option key
         | 
| 27 | 
            +
             * @return the value of key
         | 
| 28 | 
            +
             */
         | 
| 19 29 | 
             
            static VALUE
         | 
| 20 30 | 
             
            get_option(VALUE self, const char *key)
         | 
| 21 31 | 
             
            {
         | 
| @@ -32,11 +42,18 @@ get_option(VALUE self, const char *key) | |
| 32 42 | 
             
                return Qnil;
         | 
| 33 43 | 
             
            }
         | 
| 34 44 |  | 
| 35 | 
            -
             | 
| 36 | 
            -
             | 
| 37 | 
            -
             | 
| 38 | 
            -
             | 
| 39 | 
            -
             | 
| 45 | 
            +
            /**
         | 
| 46 | 
            +
             * Set the specified option to this value. If the value is nil just unset any
         | 
| 47 | 
            +
             * current value.
         | 
| 48 | 
            +
             *
         | 
| 49 | 
            +
             * Ruby usage:
         | 
| 50 | 
            +
             *   - @verbatim Info#set_option(key,string) @endverbatim
         | 
| 51 | 
            +
             *
         | 
| 52 | 
            +
             * @param self this object
         | 
| 53 | 
            +
             * @param key the option key
         | 
| 54 | 
            +
             * @param string the value
         | 
| 55 | 
            +
             * @return self
         | 
| 56 | 
            +
             */
         | 
| 40 57 | 
             
            static VALUE
         | 
| 41 58 | 
             
            set_option(VALUE self, const char *key, VALUE string)
         | 
| 42 59 | 
             
            {
         | 
| @@ -58,11 +75,19 @@ set_option(VALUE self, const char *key, VALUE string) | |
| 58 75 | 
             
            }
         | 
| 59 76 |  | 
| 60 77 |  | 
| 61 | 
            -
             | 
| 62 | 
            -
             | 
| 63 | 
            -
             | 
| 64 | 
            -
             | 
| 65 | 
            -
             | 
| 78 | 
            +
            /**
         | 
| 79 | 
            +
             * Set a color name as the value of the specified option
         | 
| 80 | 
            +
             *
         | 
| 81 | 
            +
             * No Ruby usage (internal function)
         | 
| 82 | 
            +
             *
         | 
| 83 | 
            +
             * Notes:
         | 
| 84 | 
            +
             *   - Call QueryColorDatabase to validate color name.
         | 
| 85 | 
            +
             *
         | 
| 86 | 
            +
             * @param self this object
         | 
| 87 | 
            +
             * @param option the option
         | 
| 88 | 
            +
             * @param color the color name
         | 
| 89 | 
            +
             * @return self
         | 
| 90 | 
            +
             */
         | 
| 66 91 | 
             
            static VALUE set_color_option(VALUE self, const char *option, VALUE color)
         | 
| 67 92 | 
             
            {
         | 
| 68 93 | 
             
                Info *info;
         | 
| @@ -96,11 +121,18 @@ static VALUE set_color_option(VALUE self, const char *option, VALUE color) | |
| 96 121 | 
             
            }
         | 
| 97 122 |  | 
| 98 123 |  | 
| 99 | 
            -
             | 
| 100 | 
            -
             | 
| 101 | 
            -
             | 
| 102 | 
            -
             | 
| 103 | 
            -
             | 
| 124 | 
            +
            /**
         | 
| 125 | 
            +
             * Get an Image::Info option floating-point value.
         | 
| 126 | 
            +
             *
         | 
| 127 | 
            +
             * No Ruby usage (internal function)
         | 
| 128 | 
            +
             *
         | 
| 129 | 
            +
             * Notes:
         | 
| 130 | 
            +
             *   - Convert the string value to a float
         | 
| 131 | 
            +
             *
         | 
| 132 | 
            +
             * @param self this object
         | 
| 133 | 
            +
             * @param option the option name
         | 
| 134 | 
            +
             * @return the Image::Info option
         | 
| 135 | 
            +
             */
         | 
| 104 136 | 
             
            static VALUE get_dbl_option(VALUE self, const char *option)
         | 
| 105 137 | 
             
            {
         | 
| 106 138 | 
             
                Info *info;
         | 
| @@ -122,11 +154,19 @@ static VALUE get_dbl_option(VALUE self, const char *option) | |
| 122 154 | 
             
            }
         | 
| 123 155 |  | 
| 124 156 |  | 
| 125 | 
            -
             | 
| 126 | 
            -
             | 
| 127 | 
            -
             | 
| 128 | 
            -
             | 
| 129 | 
            -
             | 
| 157 | 
            +
            /**
         | 
| 158 | 
            +
             * Set an Image::Info option to a floating-point value.
         | 
| 159 | 
            +
             *
         | 
| 160 | 
            +
             * No Ruby usage (internal function)
         | 
| 161 | 
            +
             *
         | 
| 162 | 
            +
             * Notes:
         | 
| 163 | 
            +
             *   - SetImageOption expects the value to be a string.
         | 
| 164 | 
            +
             *
         | 
| 165 | 
            +
             * @param self this object
         | 
| 166 | 
            +
             * @param option the option name
         | 
| 167 | 
            +
             * @param value the value
         | 
| 168 | 
            +
             * @return self
         | 
| 169 | 
            +
             */
         | 
| 130 170 | 
             
            static VALUE set_dbl_option(VALUE self, const char *option, VALUE value)
         | 
| 131 171 | 
             
            {
         | 
| 132 172 | 
             
                Info *info;
         | 
| @@ -162,11 +202,16 @@ static VALUE set_dbl_option(VALUE self, const char *option, VALUE value) | |
| 162 202 | 
             
            }
         | 
| 163 203 |  | 
| 164 204 |  | 
| 165 | 
            -
            /*
         | 
| 166 | 
            -
                Static:     pixel_packet_to_hexname(pp, name)
         | 
| 167 | 
            -
                Purpose:    convert a PixelPacket to a hex-format color name
         | 
| 168 | 
            -
            */
         | 
| 169 205 | 
             
            #if 0
         | 
| 206 | 
            +
            /**
         | 
| 207 | 
            +
             * Convert a PixelPacket to a hex-format color name.
         | 
| 208 | 
            +
             *
         | 
| 209 | 
            +
             * No Ruby usage (internal function)
         | 
| 210 | 
            +
             *
         | 
| 211 | 
            +
             * @param pp the pixel packet
         | 
| 212 | 
            +
             * @param name pointer to the name
         | 
| 213 | 
            +
             * @return the name
         | 
| 214 | 
            +
             */
         | 
| 170 215 | 
             
            static char *pixel_packet_to_hexname(PixelPacket *pp, char *name)
         | 
| 171 216 | 
             
            {
         | 
| 172 217 | 
             
                MagickPixelPacket mpp;
         | 
| @@ -181,17 +226,27 @@ static char *pixel_packet_to_hexname(PixelPacket *pp, char *name) | |
| 181 226 |  | 
| 182 227 | 
             
            DEF_ATTR_ACCESSOR(Info, antialias, bool)
         | 
| 183 228 |  | 
| 184 | 
            -
             | 
| 185 | 
            -
               Method:  value = Info[format, key]
         | 
| 186 | 
            -
                        value = Info[key]
         | 
| 187 | 
            -
               Purpose: get the value of an option set by Info[]=
         | 
| 188 | 
            -
                        The 2 argument form is the original form. Added support for a
         | 
| 189 | 
            -
                        single argument after ImageMagick started using Set/GetImageOption
         | 
| 190 | 
            -
                        for options that aren't represented by fields in the ImageInfo
         | 
| 191 | 
            -
                        structure.
         | 
| 192 | 
            -
            */
         | 
| 229 | 
            +
            /** Maximum length of a format (@see Info_aref) */
         | 
| 193 230 | 
             
            #define MAX_FORMAT_LEN 60
         | 
| 194 231 |  | 
| 232 | 
            +
            /**
         | 
| 233 | 
            +
             * Get the value of an option set by Info[]=
         | 
| 234 | 
            +
             *
         | 
| 235 | 
            +
             * Ruby usage:
         | 
| 236 | 
            +
             *   - @verbatim Info[format, key] @endverbatim
         | 
| 237 | 
            +
             *   - @verbatim Info[key] @endverbatim
         | 
| 238 | 
            +
             *
         | 
| 239 | 
            +
             * Notes:
         | 
| 240 | 
            +
             *   - The 2 argument form is the original form. Added support for a single
         | 
| 241 | 
            +
             *     argument after ImageMagick started using Set/GetImageOption for options
         | 
| 242 | 
            +
             *     that aren't represented by fields in the ImageInfo structure.
         | 
| 243 | 
            +
             *
         | 
| 244 | 
            +
             * @param argc number of input arguments
         | 
| 245 | 
            +
             * @param argv array of input arguments
         | 
| 246 | 
            +
             * @param self this object
         | 
| 247 | 
            +
             * @return the option value
         | 
| 248 | 
            +
             * @see Info_aset
         | 
| 249 | 
            +
             */
         | 
| 195 250 | 
             
            VALUE
         | 
| 196 251 | 
             
            Info_aref(int argc, VALUE *argv, VALUE self)
         | 
| 197 252 | 
             
            {
         | 
| @@ -236,17 +291,28 @@ Info_aref(int argc, VALUE *argv, VALUE self) | |
| 236 291 | 
             
            }
         | 
| 237 292 |  | 
| 238 293 |  | 
| 239 | 
            -
             | 
| 240 | 
            -
             | 
| 241 | 
            -
             | 
| 242 | 
            -
             | 
| 243 | 
            -
             | 
| 244 | 
            -
             | 
| 245 | 
            -
             | 
| 246 | 
            -
             | 
| 247 | 
            -
             | 
| 248 | 
            -
             | 
| 249 | 
            -
             | 
| 294 | 
            +
            /**
         | 
| 295 | 
            +
             * Call SetImageOption
         | 
| 296 | 
            +
             *
         | 
| 297 | 
            +
             * Ruby usage:
         | 
| 298 | 
            +
             *   - @verbatim Info[format, key]= @endverbatim
         | 
| 299 | 
            +
             *   - @verbatim Info[key]= @endverbatim
         | 
| 300 | 
            +
             *
         | 
| 301 | 
            +
             * Notes:
         | 
| 302 | 
            +
             *   - Essentially the same function as Info_define but paired with Info_aref
         | 
| 303 | 
            +
             *   - If the value is nil it is equivalent to Info_undefine. 
         | 
| 304 | 
            +
             *   - The 2 argument form is the original form. Added support for a single
         | 
| 305 | 
            +
             *     argument after ImageMagick started using Set/GetImageOption for options
         | 
| 306 | 
            +
             *     that aren't represented by fields in the ImageInfo structure.
         | 
| 307 | 
            +
             *
         | 
| 308 | 
            +
             * @param argc number of input arguments
         | 
| 309 | 
            +
             * @param argv array of input arguments
         | 
| 310 | 
            +
             * @param self this object
         | 
| 311 | 
            +
             * @return self
         | 
| 312 | 
            +
             * @see Info_aref
         | 
| 313 | 
            +
             * @see Info_define
         | 
| 314 | 
            +
             * @see Info_undefine
         | 
| 315 | 
            +
             */
         | 
| 250 316 | 
             
            VALUE
         | 
| 251 317 | 
             
            Info_aset(int argc, VALUE *argv, VALUE self)
         | 
| 252 318 | 
             
            {
         | 
| @@ -312,6 +378,15 @@ Info_aset(int argc, VALUE *argv, VALUE self) | |
| 312 378 | 
             
            }
         | 
| 313 379 |  | 
| 314 380 |  | 
| 381 | 
            +
            /**
         | 
| 382 | 
            +
             * Get the attenuate attribute.
         | 
| 383 | 
            +
             *
         | 
| 384 | 
            +
             * Ruby usage:
         | 
| 385 | 
            +
             *   - @verbatim Info#attenuate @endverbatim
         | 
| 386 | 
            +
             *
         | 
| 387 | 
            +
             * @param self this object
         | 
| 388 | 
            +
             * @return the attenuate
         | 
| 389 | 
            +
             */
         | 
| 315 390 | 
             
            VALUE
         | 
| 316 391 | 
             
            Info_attenuate(VALUE self)
         | 
| 317 392 | 
             
            {
         | 
| @@ -319,6 +394,16 @@ Info_attenuate(VALUE self) | |
| 319 394 | 
             
            }
         | 
| 320 395 |  | 
| 321 396 |  | 
| 397 | 
            +
            /**
         | 
| 398 | 
            +
             * Set the attenuate attribute.
         | 
| 399 | 
            +
             *
         | 
| 400 | 
            +
             * Ruby usage:
         | 
| 401 | 
            +
             *   - @verbatim Info#attenuate= @endverbatim
         | 
| 402 | 
            +
             *
         | 
| 403 | 
            +
             * @param self this object
         | 
| 404 | 
            +
             * @param value the attenuate
         | 
| 405 | 
            +
             * @return self
         | 
| 406 | 
            +
             */
         | 
| 322 407 | 
             
            VALUE
         | 
| 323 408 | 
             
            Info_attenuate_eq(VALUE self, VALUE value)
         | 
| 324 409 | 
             
            {
         | 
| @@ -326,6 +411,15 @@ Info_attenuate_eq(VALUE self, VALUE value) | |
| 326 411 | 
             
            }
         | 
| 327 412 |  | 
| 328 413 |  | 
| 414 | 
            +
            /**
         | 
| 415 | 
            +
             * Get the authenticate attribute.
         | 
| 416 | 
            +
             *
         | 
| 417 | 
            +
             * Ruby usage:
         | 
| 418 | 
            +
             *   - @verbatim Info#authenticate @endverbatim
         | 
| 419 | 
            +
             *
         | 
| 420 | 
            +
             * @param self this object
         | 
| 421 | 
            +
             * @return the authenticate
         | 
| 422 | 
            +
             */
         | 
| 329 423 | 
             
            VALUE
         | 
| 330 424 | 
             
            Info_authenticate(VALUE self)
         | 
| 331 425 | 
             
            {
         | 
| @@ -343,6 +437,16 @@ Info_authenticate(VALUE self) | |
| 343 437 | 
             
            }
         | 
| 344 438 |  | 
| 345 439 |  | 
| 440 | 
            +
            /**
         | 
| 441 | 
            +
             * Set the authenticate attribute.
         | 
| 442 | 
            +
             *
         | 
| 443 | 
            +
             * Ruby usage:
         | 
| 444 | 
            +
             *   - @verbatim Info#authenticate= @endverbatim
         | 
| 445 | 
            +
             *
         | 
| 446 | 
            +
             * @param self this object
         | 
| 447 | 
            +
             * @param passwd the authenticating password
         | 
| 448 | 
            +
             * @return self
         | 
| 449 | 
            +
             */
         | 
| 346 450 | 
             
            VALUE
         | 
| 347 451 | 
             
            Info_authenticate_eq(VALUE self, VALUE passwd)
         | 
| 348 452 | 
             
            {
         | 
| @@ -371,11 +475,16 @@ Info_authenticate_eq(VALUE self, VALUE passwd) | |
| 371 475 | 
             
            }
         | 
| 372 476 |  | 
| 373 477 |  | 
| 374 | 
            -
             | 
| 375 | 
            -
             | 
| 376 | 
            -
             | 
| 377 | 
            -
             | 
| 378 | 
            -
             | 
| 478 | 
            +
            /**
         | 
| 479 | 
            +
             * Return the name of the background color as a String
         | 
| 480 | 
            +
             *
         | 
| 481 | 
            +
             * Ruby usage:
         | 
| 482 | 
            +
             *   - @verbatim Info#background_color @endverbatim
         | 
| 483 | 
            +
             *
         | 
| 484 | 
            +
             * @param self this object
         | 
| 485 | 
            +
             * @return the name of the background color
         | 
| 486 | 
            +
             * @see Image_background_color
         | 
| 487 | 
            +
             */
         | 
| 379 488 | 
             
            VALUE
         | 
| 380 489 | 
             
            Info_background_color(VALUE self)
         | 
| 381 490 | 
             
            {
         | 
| @@ -386,11 +495,20 @@ Info_background_color(VALUE self) | |
| 386 495 | 
             
            }
         | 
| 387 496 |  | 
| 388 497 |  | 
| 389 | 
            -
             | 
| 390 | 
            -
             | 
| 391 | 
            -
             | 
| 392 | 
            -
             | 
| 393 | 
            -
             | 
| 498 | 
            +
            /**
         | 
| 499 | 
            +
             * Set the background color.
         | 
| 500 | 
            +
             *
         | 
| 501 | 
            +
             * Ruby usage:
         | 
| 502 | 
            +
             *   - @verbatim Info#background_color= @endverbatim
         | 
| 503 | 
            +
             *
         | 
| 504 | 
            +
             * Notes:
         | 
| 505 | 
            +
             *   - Color should be a string
         | 
| 506 | 
            +
             *
         | 
| 507 | 
            +
             * @param self this object
         | 
| 508 | 
            +
             * @param bc_arg the background color
         | 
| 509 | 
            +
             * @return self
         | 
| 510 | 
            +
             * @throw ArgumentError
         | 
| 511 | 
            +
             */
         | 
| 394 512 | 
             
            VALUE
         | 
| 395 513 | 
             
            Info_background_color_eq(VALUE self, VALUE bc_arg)
         | 
| 396 514 | 
             
            {
         | 
| @@ -403,11 +521,16 @@ Info_background_color_eq(VALUE self, VALUE bc_arg) | |
| 403 521 | 
             
                return self;
         | 
| 404 522 | 
             
            }
         | 
| 405 523 |  | 
| 406 | 
            -
             | 
| 407 | 
            -
             | 
| 408 | 
            -
             | 
| 409 | 
            -
             | 
| 410 | 
            -
             | 
| 524 | 
            +
            /**
         | 
| 525 | 
            +
             * Return the name of the border color as a String.
         | 
| 526 | 
            +
             *
         | 
| 527 | 
            +
             * Ruby usage:
         | 
| 528 | 
            +
             *   - @verbatim Info#border_color @endverbatim
         | 
| 529 | 
            +
             *
         | 
| 530 | 
            +
             * @param self this object
         | 
| 531 | 
            +
             * @return the border color
         | 
| 532 | 
            +
             * @see Image_border_color
         | 
| 533 | 
            +
             */
         | 
| 411 534 | 
             
            VALUE
         | 
| 412 535 | 
             
            Info_border_color(VALUE self)
         | 
| 413 536 | 
             
            {
         | 
| @@ -417,11 +540,20 @@ Info_border_color(VALUE self) | |
| 417 540 | 
             
                return rm_pixelpacket_to_color_name_info(info, &info->border_color);
         | 
| 418 541 | 
             
            }
         | 
| 419 542 |  | 
| 420 | 
            -
             | 
| 421 | 
            -
             | 
| 422 | 
            -
             | 
| 423 | 
            -
             | 
| 424 | 
            -
             | 
| 543 | 
            +
            /**
         | 
| 544 | 
            +
             * set the border color
         | 
| 545 | 
            +
             *
         | 
| 546 | 
            +
             * Ruby usage:
         | 
| 547 | 
            +
             *   - @verbatim Info#border_color= @endverbatim
         | 
| 548 | 
            +
             *
         | 
| 549 | 
            +
             * Notes:
         | 
| 550 | 
            +
             *   - Color should be a string
         | 
| 551 | 
            +
             *
         | 
| 552 | 
            +
             * @param self this object
         | 
| 553 | 
            +
             * @param bc_arg the border color
         | 
| 554 | 
            +
             * @return self
         | 
| 555 | 
            +
             * @throw ArgumentError
         | 
| 556 | 
            +
             */
         | 
| 425 557 | 
             
            VALUE
         | 
| 426 558 | 
             
            Info_border_color_eq(VALUE self, VALUE bc_arg)
         | 
| 427 559 | 
             
            {
         | 
| @@ -436,10 +568,15 @@ Info_border_color_eq(VALUE self, VALUE bc_arg) | |
| 436 568 |  | 
| 437 569 |  | 
| 438 570 |  | 
| 439 | 
            -
             | 
| 440 | 
            -
             | 
| 441 | 
            -
             | 
| 442 | 
            -
             | 
| 571 | 
            +
            /**
         | 
| 572 | 
            +
             * Emulate the -caption option.
         | 
| 573 | 
            +
             *
         | 
| 574 | 
            +
             * Ruby usage:
         | 
| 575 | 
            +
             *   - @verbatim Info#caption @endverbatim
         | 
| 576 | 
            +
             *
         | 
| 577 | 
            +
             * @param self this object
         | 
| 578 | 
            +
             * @return the caption
         | 
| 579 | 
            +
             */
         | 
| 443 580 | 
             
            VALUE
         | 
| 444 581 | 
             
            Info_caption(VALUE self)
         | 
| 445 582 | 
             
            {
         | 
| @@ -448,6 +585,16 @@ Info_caption(VALUE self) | |
| 448 585 |  | 
| 449 586 |  | 
| 450 587 |  | 
| 588 | 
            +
            /**
         | 
| 589 | 
            +
             * Emulate the -caption option.
         | 
| 590 | 
            +
             *
         | 
| 591 | 
            +
             * Ruby usage:
         | 
| 592 | 
            +
             *   - @verbatim Info#caption= @endverbatim
         | 
| 593 | 
            +
             *
         | 
| 594 | 
            +
             * @param self this object
         | 
| 595 | 
            +
             * @param caption the caption
         | 
| 596 | 
            +
             * @return self
         | 
| 597 | 
            +
             */
         | 
| 451 598 | 
             
            VALUE
         | 
| 452 599 | 
             
            Info_caption_eq(VALUE self, VALUE caption)
         | 
| 453 600 | 
             
            {
         | 
| @@ -455,11 +602,23 @@ Info_caption_eq(VALUE self, VALUE caption) | |
| 455 602 | 
             
            }
         | 
| 456 603 |  | 
| 457 604 |  | 
| 458 | 
            -
             | 
| 459 | 
            -
             | 
| 460 | 
            -
             | 
| 461 | 
            -
             | 
| 462 | 
            -
             | 
| 605 | 
            +
            /**
         | 
| 606 | 
            +
             * Set the channels
         | 
| 607 | 
            +
             *
         | 
| 608 | 
            +
             * Ruby usage:
         | 
| 609 | 
            +
             *   - @verbatim Info#channel @endverbatim
         | 
| 610 | 
            +
             *   - @verbatim Info#channel(channel) @endverbatim
         | 
| 611 | 
            +
             *   - @verbatim Info#channel(channel, ...) @endverbatim
         | 
| 612 | 
            +
             *
         | 
| 613 | 
            +
             * Notes:
         | 
| 614 | 
            +
             *   - Default channel is AllChannels
         | 
| 615 | 
            +
             *   - Thanks to Douglas Sellers.
         | 
| 616 | 
            +
             *
         | 
| 617 | 
            +
             * @param argc number of input arguments
         | 
| 618 | 
            +
             * @param argv array of input arguments
         | 
| 619 | 
            +
             * @param self this object
         | 
| 620 | 
            +
             * @return self
         | 
| 621 | 
            +
             */
         | 
| 463 622 | 
             
            VALUE
         | 
| 464 623 | 
             
            Info_channel(int argc, VALUE *argv, VALUE self)
         | 
| 465 624 | 
             
            {
         | 
| @@ -481,10 +640,15 @@ Info_channel(int argc, VALUE *argv, VALUE self) | |
| 481 640 | 
             
            }
         | 
| 482 641 |  | 
| 483 642 |  | 
| 484 | 
            -
             | 
| 485 | 
            -
             | 
| 486 | 
            -
             | 
| 487 | 
            -
             | 
| 643 | 
            +
            /**
         | 
| 644 | 
            +
             * Get the colorspace type.
         | 
| 645 | 
            +
             *
         | 
| 646 | 
            +
             * Ruby usage:
         | 
| 647 | 
            +
             *   - @verbatim Info#colorspace @endverbatim
         | 
| 648 | 
            +
             *
         | 
| 649 | 
            +
             * @param self this object
         | 
| 650 | 
            +
             * @return the colorspace type
         | 
| 651 | 
            +
             */
         | 
| 488 652 | 
             
            VALUE
         | 
| 489 653 | 
             
            Info_colorspace(VALUE self)
         | 
| 490 654 | 
             
            {
         | 
| @@ -494,11 +658,17 @@ Info_colorspace(VALUE self) | |
| 494 658 | 
             
                return ColorspaceType_new(info->colorspace);
         | 
| 495 659 | 
             
            }
         | 
| 496 660 |  | 
| 497 | 
            -
             | 
| 498 | 
            -
             | 
| 499 | 
            -
             | 
| 500 | 
            -
             | 
| 501 | 
            -
             | 
| 661 | 
            +
            /**
         | 
| 662 | 
            +
             * Set the colorspace type
         | 
| 663 | 
            +
             *
         | 
| 664 | 
            +
             * Ruby usage:
         | 
| 665 | 
            +
             *   - @verbatim Info#colorspace= @endverbatim
         | 
| 666 | 
            +
             *
         | 
| 667 | 
            +
             * @param self this object
         | 
| 668 | 
            +
             * @param colorspace the colorspace type
         | 
| 669 | 
            +
             * @return self
         | 
| 670 | 
            +
             * @throw ArgumentError
         | 
| 671 | 
            +
             */
         | 
| 502 672 | 
             
            VALUE
         | 
| 503 673 | 
             
            Info_colorspace_eq(VALUE self, VALUE colorspace)
         | 
| 504 674 | 
             
            {
         | 
| @@ -511,11 +681,15 @@ Info_colorspace_eq(VALUE self, VALUE colorspace) | |
| 511 681 |  | 
| 512 682 | 
             
            OPTION_ATTR_ACCESSOR(comment, Comment)
         | 
| 513 683 |  | 
| 514 | 
            -
             | 
| 515 | 
            -
             | 
| 516 | 
            -
             | 
| 517 | 
            -
             | 
| 518 | 
            -
             | 
| 684 | 
            +
            /**
         | 
| 685 | 
            +
             * Get the compression type.
         | 
| 686 | 
            +
             *
         | 
| 687 | 
            +
             * Ruby usage:
         | 
| 688 | 
            +
             *   - @verbatim Info#compression @endverbatim
         | 
| 689 | 
            +
             *
         | 
| 690 | 
            +
             * @param self this object
         | 
| 691 | 
            +
             * @return the compression type
         | 
| 692 | 
            +
             */
         | 
| 519 693 | 
             
            VALUE
         | 
| 520 694 | 
             
            Info_compression(VALUE self)
         | 
| 521 695 | 
             
            {
         | 
| @@ -525,11 +699,17 @@ Info_compression(VALUE self) | |
| 525 699 | 
             
                return CompressionType_new(info->compression);
         | 
| 526 700 | 
             
            }
         | 
| 527 701 |  | 
| 528 | 
            -
             | 
| 529 | 
            -
             | 
| 530 | 
            -
             | 
| 531 | 
            -
             | 
| 532 | 
            -
             | 
| 702 | 
            +
            /**
         | 
| 703 | 
            +
             * Set the compression type
         | 
| 704 | 
            +
             *
         | 
| 705 | 
            +
             * Ruby usage:
         | 
| 706 | 
            +
             *   - @verbatim Info#compression= @endverbatim
         | 
| 707 | 
            +
             *
         | 
| 708 | 
            +
             * @param self this object
         | 
| 709 | 
            +
             * @param type the compression type
         | 
| 710 | 
            +
             * @return self
         | 
| 711 | 
            +
             * @throw ArgumentError
         | 
| 712 | 
            +
             */
         | 
| 533 713 | 
             
            VALUE
         | 
| 534 714 | 
             
            Info_compression_eq(VALUE self, VALUE type)
         | 
| 535 715 | 
             
            {
         | 
| @@ -540,12 +720,22 @@ Info_compression_eq(VALUE self, VALUE type) | |
| 540 720 | 
             
                return self;
         | 
| 541 721 | 
             
            }
         | 
| 542 722 |  | 
| 543 | 
            -
             | 
| 544 | 
            -
             | 
| 545 | 
            -
             | 
| 546 | 
            -
             | 
| 547 | 
            -
             | 
| 548 | 
            -
             | 
| 723 | 
            +
            /**
         | 
| 724 | 
            +
             * Call SetImageOption
         | 
| 725 | 
            +
             *
         | 
| 726 | 
            +
             * Ruby usage:
         | 
| 727 | 
            +
             *   - @verbatim Info#define(format, key) @endverbatim
         | 
| 728 | 
            +
             *   - @verbatim Info#define(format, key, value) @endverbatim
         | 
| 729 | 
            +
             *
         | 
| 730 | 
            +
             * Notes:
         | 
| 731 | 
            +
             *   - Default value is the empty string
         | 
| 732 | 
            +
             *   - This is the only method in Info that is not an attribute accessor.
         | 
| 733 | 
            +
             *
         | 
| 734 | 
            +
             * @param argc number of input arguments
         | 
| 735 | 
            +
             * @param argv array of input arguments
         | 
| 736 | 
            +
             * @param self this object
         | 
| 737 | 
            +
             * @return self
         | 
| 738 | 
            +
             */
         | 
| 549 739 | 
             
            VALUE
         | 
| 550 740 | 
             
            Info_define(int argc, VALUE *argv, VALUE self)
         | 
| 551 741 | 
             
            {
         | 
| @@ -590,11 +780,18 @@ Info_define(int argc, VALUE *argv, VALUE self) | |
| 590 780 | 
             
                return self;
         | 
| 591 781 | 
             
            }
         | 
| 592 782 |  | 
| 593 | 
            -
             | 
| 594 | 
            -
             | 
| 595 | 
            -
             | 
| 596 | 
            -
             | 
| 597 | 
            -
             | 
| 783 | 
            +
            /**
         | 
| 784 | 
            +
             * Get the delay attribute.
         | 
| 785 | 
            +
             *
         | 
| 786 | 
            +
             * Ruby usage:
         | 
| 787 | 
            +
             *   - @verbatim Info#delay @endverbatim
         | 
| 788 | 
            +
             *
         | 
| 789 | 
            +
             * Notes:
         | 
| 790 | 
            +
             *   - Convert from string to numeric
         | 
| 791 | 
            +
             *
         | 
| 792 | 
            +
             * @param self this object
         | 
| 793 | 
            +
             * @return the delay
         | 
| 794 | 
            +
             */
         | 
| 598 795 | 
             
            VALUE
         | 
| 599 796 | 
             
            Info_delay(VALUE self)
         | 
| 600 797 | 
             
            {
         | 
| @@ -618,9 +815,14 @@ Info_delay(VALUE self) | |
| 618 815 | 
             
                return Qnil;
         | 
| 619 816 | 
             
            }
         | 
| 620 817 |  | 
| 621 | 
            -
             | 
| 818 | 
            +
            /**
         | 
| 622 819 | 
             
             * Will raise an exception if `arg' can't be converted to an int.
         | 
| 623 | 
            -
             | 
| 820 | 
            +
             *
         | 
| 821 | 
            +
             * No Ruby usage (internal function)
         | 
| 822 | 
            +
             *
         | 
| 823 | 
            +
             * @param arg the argument
         | 
| 824 | 
            +
             * @return arg
         | 
| 825 | 
            +
             */
         | 
| 624 826 | 
             
            static VALUE
         | 
| 625 827 | 
             
            arg_is_integer(VALUE arg)
         | 
| 626 828 | 
             
            {
         | 
| @@ -629,11 +831,19 @@ arg_is_integer(VALUE arg) | |
| 629 831 | 
             
                return arg;
         | 
| 630 832 | 
             
            }
         | 
| 631 833 |  | 
| 632 | 
            -
             | 
| 633 | 
            -
             | 
| 634 | 
            -
             | 
| 635 | 
            -
             | 
| 636 | 
            -
             | 
| 834 | 
            +
            /**
         | 
| 835 | 
            +
             * Set the delay attribute.
         | 
| 836 | 
            +
             *
         | 
| 837 | 
            +
             * Ruby usage:
         | 
| 838 | 
            +
             *   - @verbatim Info#delay= @endverbatim
         | 
| 839 | 
            +
             *
         | 
| 840 | 
            +
             * Notes:
         | 
| 841 | 
            +
             *   - Convert from numeric value to string.
         | 
| 842 | 
            +
             *
         | 
| 843 | 
            +
             * @param self this object
         | 
| 844 | 
            +
             * @param string the delay
         | 
| 845 | 
            +
             * @return self
         | 
| 846 | 
            +
             */
         | 
| 637 847 | 
             
            VALUE
         | 
| 638 848 | 
             
            Info_delay_eq(VALUE self, VALUE string)
         | 
| 639 849 | 
             
            {
         | 
| @@ -664,13 +874,31 @@ Info_delay_eq(VALUE self, VALUE string) | |
| 664 874 | 
             
                return self;
         | 
| 665 875 | 
             
            }
         | 
| 666 876 |  | 
| 877 | 
            +
            /**
         | 
| 878 | 
            +
             * Get the density attribute
         | 
| 879 | 
            +
             *
         | 
| 880 | 
            +
             * Ruby usage:
         | 
| 881 | 
            +
             *   - @verbatim Info#density @endverbatim
         | 
| 882 | 
            +
             *
         | 
| 883 | 
            +
             * @param self this object
         | 
| 884 | 
            +
             * @return the density
         | 
| 885 | 
            +
             */
         | 
| 667 886 | 
             
            DEF_ATTR_READER(Info, density, str)
         | 
| 668 887 |  | 
| 669 | 
            -
             | 
| 670 | 
            -
             | 
| 671 | 
            -
             | 
| 672 | 
            -
             | 
| 673 | 
            -
             | 
| 888 | 
            +
            /**
         | 
| 889 | 
            +
             * Set the text rendering density
         | 
| 890 | 
            +
             *
         | 
| 891 | 
            +
             * Ruby usage:
         | 
| 892 | 
            +
             *   - @verbatim Info#density= @endverbatim
         | 
| 893 | 
            +
             *
         | 
| 894 | 
            +
             * Notes:
         | 
| 895 | 
            +
             *   - density should be a string, e.g., "72x72"
         | 
| 896 | 
            +
             *
         | 
| 897 | 
            +
             * @param self this object
         | 
| 898 | 
            +
             * @param density_arg the density
         | 
| 899 | 
            +
             * @return self
         | 
| 900 | 
            +
             * @throw ArgumentError
         | 
| 901 | 
            +
             */
         | 
| 674 902 | 
             
            VALUE
         | 
| 675 903 | 
             
            Info_density_eq(VALUE self, VALUE density_arg)
         | 
| 676 904 | 
             
            {
         | 
| @@ -699,13 +927,28 @@ Info_density_eq(VALUE self, VALUE density_arg) | |
| 699 927 | 
             
                return self;
         | 
| 700 928 | 
             
            }
         | 
| 701 929 |  | 
| 930 | 
            +
            /**
         | 
| 931 | 
            +
             * Get the depth attribute
         | 
| 932 | 
            +
             *
         | 
| 933 | 
            +
             * Ruby usage:
         | 
| 934 | 
            +
             *   - @verbatim Info#depth @endverbatim
         | 
| 935 | 
            +
             *
         | 
| 936 | 
            +
             * @param self this object
         | 
| 937 | 
            +
             * @return the depth
         | 
| 938 | 
            +
             */
         | 
| 702 939 | 
             
            DEF_ATTR_READER(Info, depth, int)
         | 
| 703 940 |  | 
| 704 | 
            -
             | 
| 705 | 
            -
             | 
| 706 | 
            -
             | 
| 707 | 
            -
             | 
| 708 | 
            -
             | 
| 941 | 
            +
            /**
         | 
| 942 | 
            +
             * Set the depth (8, 16, 32).
         | 
| 943 | 
            +
             *
         | 
| 944 | 
            +
             * Ruby usage:
         | 
| 945 | 
            +
             *   - @verbatim Info#depth= @endverbatim
         | 
| 946 | 
            +
             *
         | 
| 947 | 
            +
             * @param self this object
         | 
| 948 | 
            +
             * @param depth the depth
         | 
| 949 | 
            +
             * @return self
         | 
| 950 | 
            +
             * @throw ArgumentError
         | 
| 951 | 
            +
             */
         | 
| 709 952 | 
             
            VALUE
         | 
| 710 953 | 
             
            Info_depth_eq(VALUE self, VALUE depth)
         | 
| 711 954 | 
             
            {
         | 
| @@ -736,16 +979,12 @@ Info_depth_eq(VALUE self, VALUE depth) | |
| 736 979 | 
             
                return self;
         | 
| 737 980 | 
             
            }
         | 
| 738 981 |  | 
| 739 | 
            -
             | 
| 740 | 
            -
                Method:     Info#dispose
         | 
| 741 | 
            -
                Purpose:    Retrieve a dispose option string and convert it to
         | 
| 742 | 
            -
                            a DisposeType enumerator
         | 
| 743 | 
            -
            */
         | 
| 982 | 
            +
            /** A dispose option */
         | 
| 744 983 | 
             
            static struct
         | 
| 745 984 | 
             
            {
         | 
| 746 | 
            -
                const char *string;
         | 
| 747 | 
            -
                const char *enum_name;
         | 
| 748 | 
            -
                DisposeType enumerator;
         | 
| 985 | 
            +
                const char *string; /**< the argument given by the user */
         | 
| 986 | 
            +
                const char *enum_name; /**< the enumerator name */
         | 
| 987 | 
            +
                DisposeType enumerator; /**< the enumerator itself */
         | 
| 749 988 | 
             
            } Dispose_Option[] = {
         | 
| 750 989 | 
             
                { "Background", "BackgroundDispose", BackgroundDispose},
         | 
| 751 990 | 
             
                { "None",       "NoneDispose",       NoneDispose},
         | 
| @@ -756,9 +995,19 @@ static struct | |
| 756 995 | 
             
                { "2",          "BackgroundDispose", BackgroundDispose},
         | 
| 757 996 | 
             
                { "3",          "PreviousDispose",   PreviousDispose},
         | 
| 758 997 | 
             
            };
         | 
| 998 | 
            +
             | 
| 999 | 
            +
            /** Number of dispose options */
         | 
| 759 1000 | 
             
            #define N_DISPOSE_OPTIONS (int)(sizeof(Dispose_Option)/sizeof(Dispose_Option[0]))
         | 
| 760 1001 |  | 
| 761 1002 |  | 
| 1003 | 
            +
            /**
         | 
| 1004 | 
            +
             * Retrieve a dispose option string and convert it to a DisposeType enumerator.
         | 
| 1005 | 
            +
             *
         | 
| 1006 | 
            +
             * No Ruby usage (internal function)
         | 
| 1007 | 
            +
             *
         | 
| 1008 | 
            +
             * @param name the dispose string
         | 
| 1009 | 
            +
             * @return the DisposeType enumerator
         | 
| 1010 | 
            +
             */
         | 
| 762 1011 | 
             
            DisposeType rm_dispose_to_enum(const char *name)
         | 
| 763 1012 | 
             
            {
         | 
| 764 1013 | 
             
                DisposeType dispose = UndefinedDispose;
         | 
| @@ -777,6 +1026,16 @@ DisposeType rm_dispose_to_enum(const char *name) | |
| 777 1026 | 
             
            }
         | 
| 778 1027 |  | 
| 779 1028 |  | 
| 1029 | 
            +
            /**
         | 
| 1030 | 
            +
             * Retrieve the dispose option string and convert it to a DisposeType
         | 
| 1031 | 
            +
             * enumerator.
         | 
| 1032 | 
            +
             *
         | 
| 1033 | 
            +
             * Ruby usage:
         | 
| 1034 | 
            +
             *   - @verbatim Info#dispose @endverbatim
         | 
| 1035 | 
            +
             *
         | 
| 1036 | 
            +
             * @param self this object
         | 
| 1037 | 
            +
             * @return a DisposeType enumerator
         | 
| 1038 | 
            +
             */
         | 
| 780 1039 | 
             
            VALUE
         | 
| 781 1040 | 
             
            Info_dispose(VALUE self)
         | 
| 782 1041 | 
             
            {
         | 
| @@ -806,11 +1065,16 @@ Info_dispose(VALUE self) | |
| 806 1065 | 
             
                return rb_const_get(Module_Magick, dispose_id);
         | 
| 807 1066 | 
             
            }
         | 
| 808 1067 |  | 
| 809 | 
            -
             | 
| 810 | 
            -
             | 
| 811 | 
            -
             | 
| 812 | 
            -
             | 
| 813 | 
            -
             | 
| 1068 | 
            +
            /**
         | 
| 1069 | 
            +
             * Convert a DisposeType enumerator into the equivalent dispose option string.
         | 
| 1070 | 
            +
             *
         | 
| 1071 | 
            +
             * Ruby usage:
         | 
| 1072 | 
            +
             *   - @verbatim Info#dispose= @endverbatim
         | 
| 1073 | 
            +
             *
         | 
| 1074 | 
            +
             * @param self this object
         | 
| 1075 | 
            +
             * @param disp the DisposeType enumerator
         | 
| 1076 | 
            +
             * @return self
         | 
| 1077 | 
            +
             */
         | 
| 814 1078 | 
             
            VALUE
         | 
| 815 1079 | 
             
            Info_dispose_eq(VALUE self, VALUE disp)
         | 
| 816 1080 | 
             
            {
         | 
| @@ -846,11 +1110,15 @@ Info_dispose_eq(VALUE self, VALUE disp) | |
| 846 1110 | 
             
            DEF_ATTR_ACCESSOR(Info, dither, bool)
         | 
| 847 1111 |  | 
| 848 1112 |  | 
| 849 | 
            -
             | 
| 850 | 
            -
             | 
| 851 | 
            -
             | 
| 852 | 
            -
             | 
| 853 | 
            -
             | 
| 1113 | 
            +
            /**
         | 
| 1114 | 
            +
             * Get the endian attribute.
         | 
| 1115 | 
            +
             *
         | 
| 1116 | 
            +
             * Ruby usage:
         | 
| 1117 | 
            +
             *   - @verbatim Info#endian @endverbatim
         | 
| 1118 | 
            +
             *
         | 
| 1119 | 
            +
             * @param self this object
         | 
| 1120 | 
            +
             * @return the endian (Magick::MSBEndian or Magick::LSBEndian)
         | 
| 1121 | 
            +
             */
         | 
| 854 1122 | 
             
            VALUE
         | 
| 855 1123 | 
             
            Info_endian(VALUE self)
         | 
| 856 1124 | 
             
            {
         | 
| @@ -861,6 +1129,16 @@ Info_endian(VALUE self) | |
| 861 1129 | 
             
            }
         | 
| 862 1130 |  | 
| 863 1131 |  | 
| 1132 | 
            +
            /**
         | 
| 1133 | 
            +
             * Set the endian attribute.
         | 
| 1134 | 
            +
             *
         | 
| 1135 | 
            +
             * Ruby usage:
         | 
| 1136 | 
            +
             *   - @verbatim Info#endian= @endverbatim
         | 
| 1137 | 
            +
             *
         | 
| 1138 | 
            +
             * @param self this object
         | 
| 1139 | 
            +
             * @param endian the endian (Magick::MSBEndian or Magick::LSBEndian)
         | 
| 1140 | 
            +
             * @return self
         | 
| 1141 | 
            +
             */
         | 
| 864 1142 | 
             
            VALUE
         | 
| 865 1143 | 
             
            Info_endian_eq(VALUE self, VALUE endian)
         | 
| 866 1144 | 
             
            {
         | 
| @@ -878,15 +1156,34 @@ Info_endian_eq(VALUE self, VALUE endian) | |
| 878 1156 | 
             
            }
         | 
| 879 1157 |  | 
| 880 1158 |  | 
| 881 | 
            -
             | 
| 882 | 
            -
             | 
| 883 | 
            -
             | 
| 884 | 
            -
             | 
| 885 | 
            -
             | 
| 886 | 
            -
             | 
| 887 | 
            -
             | 
| 1159 | 
            +
            /**
         | 
| 1160 | 
            +
             * Get the extract string, e.g. "200x200+100+100"
         | 
| 1161 | 
            +
             *
         | 
| 1162 | 
            +
             * Ruby usage:
         | 
| 1163 | 
            +
             *   - @verbatim Info#extract @endverbatim
         | 
| 1164 | 
            +
             *
         | 
| 1165 | 
            +
             * Notes:
         | 
| 1166 | 
            +
             *   - Defined for ImageMagick 5.5.6 and later
         | 
| 1167 | 
            +
             *
         | 
| 1168 | 
            +
             * @param self this object
         | 
| 1169 | 
            +
             * @return the extract string
         | 
| 1170 | 
            +
             */
         | 
| 888 1171 | 
             
            DEF_ATTR_READER(Info, extract, str)
         | 
| 889 1172 |  | 
| 1173 | 
            +
            /**
         | 
| 1174 | 
            +
             * Set the extract string, e.g. "200x200+100+100"
         | 
| 1175 | 
            +
             *
         | 
| 1176 | 
            +
             * Ruby usage:
         | 
| 1177 | 
            +
             *   - @verbatim Info#extract= @endverbatim
         | 
| 1178 | 
            +
             *
         | 
| 1179 | 
            +
             * Notes:
         | 
| 1180 | 
            +
             *   - Defined for ImageMagick 5.5.6 and later
         | 
| 1181 | 
            +
             *
         | 
| 1182 | 
            +
             * @param self this object
         | 
| 1183 | 
            +
             * @param extract_arg the extract string
         | 
| 1184 | 
            +
             * @return self
         | 
| 1185 | 
            +
             * @throw ArgumentError
         | 
| 1186 | 
            +
             */
         | 
| 890 1187 | 
             
            VALUE
         | 
| 891 1188 | 
             
            Info_extract_eq(VALUE self, VALUE extract_arg)
         | 
| 892 1189 | 
             
            {
         | 
| @@ -916,13 +1213,19 @@ Info_extract_eq(VALUE self, VALUE extract_arg) | |
| 916 1213 | 
             
            }
         | 
| 917 1214 |  | 
| 918 1215 |  | 
| 919 | 
            -
             | 
| 920 | 
            -
             | 
| 921 | 
            -
             | 
| 922 | 
            -
             | 
| 923 | 
            -
             | 
| 924 | 
            -
             | 
| 925 | 
            -
             | 
| 1216 | 
            +
            /**
         | 
| 1217 | 
            +
             * Get the "filename".
         | 
| 1218 | 
            +
             *
         | 
| 1219 | 
            +
             * Ruby usage:
         | 
| 1220 | 
            +
             *   - @verbatim Info#filename @endverbatim
         | 
| 1221 | 
            +
             *
         | 
| 1222 | 
            +
             * Notes:
         | 
| 1223 | 
            +
             *   - Only used for Image_capture
         | 
| 1224 | 
            +
             *
         | 
| 1225 | 
            +
             * @param self this object
         | 
| 1226 | 
            +
             * @return the filename ("" if filename not set)
         | 
| 1227 | 
            +
             * @see Image_capture
         | 
| 1228 | 
            +
             */
         | 
| 926 1229 | 
             
            VALUE
         | 
| 927 1230 | 
             
            Info_filename(VALUE self)
         | 
| 928 1231 | 
             
            {
         | 
| @@ -932,6 +1235,20 @@ Info_filename(VALUE self) | |
| 932 1235 | 
             
                return rb_str_new2(info->filename);
         | 
| 933 1236 | 
             
            }
         | 
| 934 1237 |  | 
| 1238 | 
            +
            /**
         | 
| 1239 | 
            +
             * Set the "filename".
         | 
| 1240 | 
            +
             *
         | 
| 1241 | 
            +
             * Ruby usage:
         | 
| 1242 | 
            +
             *   - @verbatim Info#filename= @endverbatim
         | 
| 1243 | 
            +
             *
         | 
| 1244 | 
            +
             * Notes:
         | 
| 1245 | 
            +
             *   - Only used for Image_capture
         | 
| 1246 | 
            +
             *
         | 
| 1247 | 
            +
             * @param self this object
         | 
| 1248 | 
            +
             * @param filename the filename
         | 
| 1249 | 
            +
             * @return self
         | 
| 1250 | 
            +
             * @see Image_capture
         | 
| 1251 | 
            +
             */
         | 
| 935 1252 | 
             
            VALUE
         | 
| 936 1253 | 
             
            Info_filename_eq(VALUE self, VALUE filename)
         | 
| 937 1254 | 
             
            {
         | 
| @@ -955,21 +1272,32 @@ Info_filename_eq(VALUE self, VALUE filename) | |
| 955 1272 | 
             
            }
         | 
| 956 1273 |  | 
| 957 1274 |  | 
| 958 | 
            -
             | 
| 959 | 
            -
             | 
| 960 | 
            -
             | 
| 961 | 
            -
             | 
| 1275 | 
            +
            /**
         | 
| 1276 | 
            +
             * Return the fill color as a String.
         | 
| 1277 | 
            +
             *
         | 
| 1278 | 
            +
             * Ruby usage:
         | 
| 1279 | 
            +
             *   - @verbatim Info#fill @endverbatim
         | 
| 1280 | 
            +
             *
         | 
| 1281 | 
            +
             * @param self this object
         | 
| 1282 | 
            +
             * @return the fill color
         | 
| 1283 | 
            +
             */
         | 
| 962 1284 | 
             
            VALUE
         | 
| 963 1285 | 
             
            Info_fill(VALUE self)
         | 
| 964 1286 | 
             
            {
         | 
| 965 1287 | 
             
                return get_option(self, "fill");
         | 
| 966 1288 | 
             
            }
         | 
| 967 1289 |  | 
| 968 | 
            -
             | 
| 969 | 
            -
             | 
| 970 | 
            -
             | 
| 971 | 
            -
             | 
| 972 | 
            -
             | 
| 1290 | 
            +
            /**
         | 
| 1291 | 
            +
             * Set the fill color
         | 
| 1292 | 
            +
             *
         | 
| 1293 | 
            +
             * Ruby usage:
         | 
| 1294 | 
            +
             *   - @verbatim Info#fill= @endverbatim
         | 
| 1295 | 
            +
             *
         | 
| 1296 | 
            +
             * @param self this object
         | 
| 1297 | 
            +
             * @param color the fill color (as a String)
         | 
| 1298 | 
            +
             * @return self
         | 
| 1299 | 
            +
             * @throw ArgumentError
         | 
| 1300 | 
            +
             */
         | 
| 973 1301 | 
             
            VALUE
         | 
| 974 1302 | 
             
            Info_fill_eq(VALUE self, VALUE color)
         | 
| 975 1303 | 
             
            {
         | 
| @@ -977,13 +1305,27 @@ Info_fill_eq(VALUE self, VALUE color) | |
| 977 1305 | 
             
            }
         | 
| 978 1306 |  | 
| 979 1307 |  | 
| 980 | 
            -
             | 
| 981 | 
            -
             | 
| 982 | 
            -
             | 
| 983 | 
            -
             | 
| 984 | 
            -
             | 
| 1308 | 
            +
            /**
         | 
| 1309 | 
            +
             * Get the text font.
         | 
| 1310 | 
            +
             *
         | 
| 1311 | 
            +
             * Ruby usage:
         | 
| 1312 | 
            +
             *   - @verbatim Info#font @endverbatim
         | 
| 1313 | 
            +
             *
         | 
| 1314 | 
            +
             * @param self this object
         | 
| 1315 | 
            +
             * @return the font
         | 
| 1316 | 
            +
             */
         | 
| 985 1317 | 
             
            DEF_ATTR_READER(Info, font, str)
         | 
| 986 1318 |  | 
| 1319 | 
            +
            /**
         | 
| 1320 | 
            +
             * Set the text font.
         | 
| 1321 | 
            +
             *
         | 
| 1322 | 
            +
             * Ruby usage:
         | 
| 1323 | 
            +
             *   - @verbatim Info#font= @endverbatim
         | 
| 1324 | 
            +
             *
         | 
| 1325 | 
            +
             * @param self this object
         | 
| 1326 | 
            +
             * @param font_arg the font (as a String)
         | 
| 1327 | 
            +
             * @return self
         | 
| 1328 | 
            +
             */
         | 
| 987 1329 | 
             
            VALUE
         | 
| 988 1330 | 
             
            Info_font_eq(VALUE self, VALUE font_arg)
         | 
| 989 1331 | 
             
            {
         | 
| @@ -1004,10 +1346,15 @@ Info_font_eq(VALUE self, VALUE font_arg) | |
| 1004 1346 | 
             
                return self;
         | 
| 1005 1347 | 
             
            }
         | 
| 1006 1348 |  | 
| 1007 | 
            -
             | 
| 1008 | 
            -
             | 
| 1009 | 
            -
             | 
| 1010 | 
            -
             | 
| 1349 | 
            +
            /**
         | 
| 1350 | 
            +
             * Return the image encoding format.
         | 
| 1351 | 
            +
             *
         | 
| 1352 | 
            +
             * Ruby usage:
         | 
| 1353 | 
            +
             *   - @verbatim Info#format @endverbatim
         | 
| 1354 | 
            +
             *
         | 
| 1355 | 
            +
             * @param self this object
         | 
| 1356 | 
            +
             * @return the encoding format
         | 
| 1357 | 
            +
             */
         | 
| 1011 1358 | 
             
            VALUE Info_format(VALUE self)
         | 
| 1012 1359 | 
             
            {
         | 
| 1013 1360 | 
             
                Info *info;
         | 
| @@ -1027,10 +1374,16 @@ VALUE Info_format(VALUE self) | |
| 1027 1374 | 
             
                return Qnil;
         | 
| 1028 1375 | 
             
            }
         | 
| 1029 1376 |  | 
| 1030 | 
            -
             | 
| 1031 | 
            -
             | 
| 1032 | 
            -
             | 
| 1033 | 
            -
             | 
| 1377 | 
            +
            /**
         | 
| 1378 | 
            +
             * Set the image encoding format.
         | 
| 1379 | 
            +
             *
         | 
| 1380 | 
            +
             * Ruby usage:
         | 
| 1381 | 
            +
             *   - @verbatim Info#format= @endverbatim
         | 
| 1382 | 
            +
             *
         | 
| 1383 | 
            +
             * @param self this object
         | 
| 1384 | 
            +
             * @param magick the encoding format
         | 
| 1385 | 
            +
             * @return self
         | 
| 1386 | 
            +
             */
         | 
| 1034 1387 | 
             
            VALUE
         | 
| 1035 1388 | 
             
            Info_format_eq(VALUE self, VALUE magick)
         | 
| 1036 1389 | 
             
            {
         | 
| @@ -1057,13 +1410,30 @@ Info_format_eq(VALUE self, VALUE magick) | |
| 1057 1410 | 
             
                return self;
         | 
| 1058 1411 | 
             
            }
         | 
| 1059 1412 |  | 
| 1413 | 
            +
            /**
         | 
| 1414 | 
            +
             * Get the fuzz.
         | 
| 1415 | 
            +
             *
         | 
| 1416 | 
            +
             * Ruby usage:
         | 
| 1417 | 
            +
             *   - @verbatim Info#fuzz @endverbatim
         | 
| 1418 | 
            +
             *
         | 
| 1419 | 
            +
             * @param self this object
         | 
| 1420 | 
            +
             * @return the fuzz
         | 
| 1421 | 
            +
             * @see Image_fuzz
         | 
| 1422 | 
            +
             */
         | 
| 1060 1423 | 
             
            DEF_ATTR_READER(Info, fuzz, dbl)
         | 
| 1061 1424 |  | 
| 1062 | 
            -
             | 
| 1063 | 
            -
             | 
| 1064 | 
            -
             | 
| 1065 | 
            -
             | 
| 1066 | 
            -
             | 
| 1425 | 
            +
            /**
         | 
| 1426 | 
            +
             * Set the fuzz.
         | 
| 1427 | 
            +
             *
         | 
| 1428 | 
            +
             * Ruby usage:
         | 
| 1429 | 
            +
             *   - @verbatim Info#fuzz=number @endverbatim
         | 
| 1430 | 
            +
             *   - @verbatim Info#fuzz=NN% @endverbatim
         | 
| 1431 | 
            +
             *
         | 
| 1432 | 
            +
             * @param self this object
         | 
| 1433 | 
            +
             * @param fuzz the fuzz
         | 
| 1434 | 
            +
             * @return self
         | 
| 1435 | 
            +
             * @see Image_fuzz_eq
         | 
| 1436 | 
            +
             */
         | 
| 1067 1437 | 
             
            VALUE Info_fuzz_eq(VALUE self, VALUE fuzz)
         | 
| 1068 1438 | 
             
            {
         | 
| 1069 1439 | 
             
                Info *info;
         | 
| @@ -1073,16 +1443,12 @@ VALUE Info_fuzz_eq(VALUE self, VALUE fuzz) | |
| 1073 1443 | 
             
                return self;
         | 
| 1074 1444 | 
             
            }
         | 
| 1075 1445 |  | 
| 1076 | 
            -
             | 
| 1077 | 
            -
                Method:     Info#gravity
         | 
| 1078 | 
            -
                Purpose:    Return the value of the gravity option as a GravityType enumerator
         | 
| 1079 | 
            -
            */
         | 
| 1080 | 
            -
             | 
| 1446 | 
            +
            /** A gravity option */
         | 
| 1081 1447 | 
             
            static struct
         | 
| 1082 1448 | 
             
            {
         | 
| 1083 | 
            -
                const char *string;
         | 
| 1084 | 
            -
                const char *enum_name;
         | 
| 1085 | 
            -
                GravityType enumerator;
         | 
| 1449 | 
            +
                const char *string; /**< the argument given by the user */
         | 
| 1450 | 
            +
                const char *enum_name; /**< the enumerator name */
         | 
| 1451 | 
            +
                GravityType enumerator; /**< the enumerator itself */
         | 
| 1086 1452 | 
             
            } Gravity_Option[] = {
         | 
| 1087 1453 | 
             
                { "Undefined",  "UndefinedGravity", UndefinedGravity},
         | 
| 1088 1454 | 
             
                { "None",       "UndefinedGravity", UndefinedGravity},
         | 
| @@ -1098,9 +1464,19 @@ static struct | |
| 1098 1464 | 
             
                { "West",       "WestGravity",      WestGravity},
         | 
| 1099 1465 | 
             
                { "Static",     "StaticGravity",    StaticGravity}
         | 
| 1100 1466 | 
             
            };
         | 
| 1467 | 
            +
             | 
| 1468 | 
            +
            /** Number of gravity options */
         | 
| 1101 1469 | 
             
            #define N_GRAVITY_OPTIONS (int)(sizeof(Gravity_Option)/sizeof(Gravity_Option[0]))
         | 
| 1102 1470 |  | 
| 1103 1471 |  | 
| 1472 | 
            +
            /**
         | 
| 1473 | 
            +
             * Return the value of the gravity option as a GravityType enumerator.
         | 
| 1474 | 
            +
             *
         | 
| 1475 | 
            +
             * No Ruby usage (internal function)
         | 
| 1476 | 
            +
             *
         | 
| 1477 | 
            +
             * @param name the name of the gravity option
         | 
| 1478 | 
            +
             * @return the enumerator for name
         | 
| 1479 | 
            +
             */
         | 
| 1104 1480 | 
             
            GravityType rm_gravity_to_enum(const char *name)
         | 
| 1105 1481 | 
             
            {
         | 
| 1106 1482 | 
             
                GravityType gravity = UndefinedGravity;
         | 
| @@ -1119,6 +1495,15 @@ GravityType rm_gravity_to_enum(const char *name) | |
| 1119 1495 | 
             
            }
         | 
| 1120 1496 |  | 
| 1121 1497 |  | 
| 1498 | 
            +
            /**
         | 
| 1499 | 
            +
             * Return the value of the gravity option as a GravityType enumerator.
         | 
| 1500 | 
            +
             *
         | 
| 1501 | 
            +
             * Ruby usage:
         | 
| 1502 | 
            +
             *   - @verbatim Info#gravity @endverbatim
         | 
| 1503 | 
            +
             *
         | 
| 1504 | 
            +
             * @param self this object
         | 
| 1505 | 
            +
             * @return the gravity enumerator
         | 
| 1506 | 
            +
             */
         | 
| 1122 1507 | 
             
            VALUE Info_gravity(VALUE self)
         | 
| 1123 1508 | 
             
            {
         | 
| 1124 1509 | 
             
                Info *info;
         | 
| @@ -1147,11 +1532,17 @@ VALUE Info_gravity(VALUE self) | |
| 1147 1532 | 
             
                return rb_const_get(Module_Magick, gravity_id);
         | 
| 1148 1533 | 
             
            }
         | 
| 1149 1534 |  | 
| 1150 | 
            -
             | 
| 1151 | 
            -
             | 
| 1152 | 
            -
             | 
| 1153 | 
            -
             | 
| 1154 | 
            -
             | 
| 1535 | 
            +
            /**
         | 
| 1536 | 
            +
             * Convert a GravityType enum to a gravity option name and store in the Info
         | 
| 1537 | 
            +
             * structure.
         | 
| 1538 | 
            +
             *
         | 
| 1539 | 
            +
             * Ruby usage:
         | 
| 1540 | 
            +
             *   - @verbatim Info#gravity= @endverbatim
         | 
| 1541 | 
            +
             *
         | 
| 1542 | 
            +
             * @param self this object
         | 
| 1543 | 
            +
             * @param grav the gravity enumerator
         | 
| 1544 | 
            +
             * @return self
         | 
| 1545 | 
            +
             */
         | 
| 1155 1546 | 
             
            VALUE
         | 
| 1156 1547 | 
             
            Info_gravity_eq(VALUE self, VALUE grav)
         | 
| 1157 1548 | 
             
            {
         | 
| @@ -1187,11 +1578,15 @@ Info_gravity_eq(VALUE self, VALUE grav) | |
| 1187 1578 |  | 
| 1188 1579 | 
             
            DEF_ATTR_ACCESSOR(Info, group, long)
         | 
| 1189 1580 |  | 
| 1190 | 
            -
             | 
| 1191 | 
            -
             | 
| 1192 | 
            -
             | 
| 1193 | 
            -
             | 
| 1194 | 
            -
             | 
| 1581 | 
            +
            /**
         | 
| 1582 | 
            +
             * Get the classification type.
         | 
| 1583 | 
            +
             *
         | 
| 1584 | 
            +
             * Ruby usage:
         | 
| 1585 | 
            +
             *   - @verbatim Info#image_type @endverbatim
         | 
| 1586 | 
            +
             *
         | 
| 1587 | 
            +
             * @param self this object
         | 
| 1588 | 
            +
             * @return the classification type
         | 
| 1589 | 
            +
             */
         | 
| 1195 1590 | 
             
            VALUE
         | 
| 1196 1591 | 
             
            Info_image_type(VALUE self)
         | 
| 1197 1592 | 
             
            {
         | 
| @@ -1201,11 +1596,17 @@ Info_image_type(VALUE self) | |
| 1201 1596 | 
             
                return ImageType_new(info->type);
         | 
| 1202 1597 | 
             
            }
         | 
| 1203 1598 |  | 
| 1204 | 
            -
             | 
| 1205 | 
            -
             | 
| 1206 | 
            -
             | 
| 1207 | 
            -
             | 
| 1208 | 
            -
             | 
| 1599 | 
            +
            /**
         | 
| 1600 | 
            +
             * Set the classification type.
         | 
| 1601 | 
            +
             *
         | 
| 1602 | 
            +
             * Ruby usage:
         | 
| 1603 | 
            +
             *   - @verbatim Info#image_type= @endverbatim
         | 
| 1604 | 
            +
             *
         | 
| 1605 | 
            +
             * @param self this object
         | 
| 1606 | 
            +
             * @param type the classification type
         | 
| 1607 | 
            +
             * @return self
         | 
| 1608 | 
            +
             * @throw ArgumentError
         | 
| 1609 | 
            +
             */
         | 
| 1209 1610 | 
             
            VALUE
         | 
| 1210 1611 | 
             
            Info_image_type_eq(VALUE self, VALUE type)
         | 
| 1211 1612 | 
             
            {
         | 
| @@ -1216,11 +1617,15 @@ Info_image_type_eq(VALUE self, VALUE type) | |
| 1216 1617 | 
             
                return self;
         | 
| 1217 1618 | 
             
            }
         | 
| 1218 1619 |  | 
| 1219 | 
            -
             | 
| 1220 | 
            -
             | 
| 1221 | 
            -
             | 
| 1222 | 
            -
             | 
| 1223 | 
            -
             | 
| 1620 | 
            +
            /**
         | 
| 1621 | 
            +
             * Get the interlace type.
         | 
| 1622 | 
            +
             *
         | 
| 1623 | 
            +
             * Ruby usage:
         | 
| 1624 | 
            +
             *   - @verbatim Info#interlace @endverbatim
         | 
| 1625 | 
            +
             *
         | 
| 1626 | 
            +
             * @param self this object
         | 
| 1627 | 
            +
             * @return the interlace type
         | 
| 1628 | 
            +
             */
         | 
| 1224 1629 | 
             
            VALUE
         | 
| 1225 1630 | 
             
            Info_interlace(VALUE self)
         | 
| 1226 1631 | 
             
            {
         | 
| @@ -1230,11 +1635,17 @@ Info_interlace(VALUE self) | |
| 1230 1635 | 
             
                return InterlaceType_new(info->interlace);
         | 
| 1231 1636 | 
             
            }
         | 
| 1232 1637 |  | 
| 1233 | 
            -
             | 
| 1234 | 
            -
             | 
| 1235 | 
            -
             | 
| 1236 | 
            -
             | 
| 1237 | 
            -
             | 
| 1638 | 
            +
            /**
         | 
| 1639 | 
            +
             * Set the interlace type
         | 
| 1640 | 
            +
             *
         | 
| 1641 | 
            +
             * Ruby usage:
         | 
| 1642 | 
            +
             *   - @verbatim Info#interlace= @endverbatim
         | 
| 1643 | 
            +
             *
         | 
| 1644 | 
            +
             * @param self this object
         | 
| 1645 | 
            +
             * @param inter the interlace type
         | 
| 1646 | 
            +
             * @return self
         | 
| 1647 | 
            +
             * @throw ArgumentError
         | 
| 1648 | 
            +
             */
         | 
| 1238 1649 | 
             
            VALUE
         | 
| 1239 1650 | 
             
            Info_interlace_eq(VALUE self, VALUE inter)
         | 
| 1240 1651 | 
             
            {
         | 
| @@ -1247,11 +1658,16 @@ Info_interlace_eq(VALUE self, VALUE inter) | |
| 1247 1658 |  | 
| 1248 1659 | 
             
            OPTION_ATTR_ACCESSOR(label, Label)
         | 
| 1249 1660 |  | 
| 1250 | 
            -
             | 
| 1251 | 
            -
             | 
| 1252 | 
            -
             | 
| 1253 | 
            -
             | 
| 1254 | 
            -
             | 
| 1661 | 
            +
            /**
         | 
| 1662 | 
            +
             * Return the name of the matte color as a String.
         | 
| 1663 | 
            +
             *
         | 
| 1664 | 
            +
             * Ruby usage:
         | 
| 1665 | 
            +
             *   - @verbatim Info#matte_color @endverbatim
         | 
| 1666 | 
            +
             *
         | 
| 1667 | 
            +
             * @param self this object
         | 
| 1668 | 
            +
             * @return the name of the matte color
         | 
| 1669 | 
            +
             * @see Image_matte_color
         | 
| 1670 | 
            +
             */
         | 
| 1255 1671 | 
             
            VALUE
         | 
| 1256 1672 | 
             
            Info_matte_color(VALUE self)
         | 
| 1257 1673 | 
             
            {
         | 
| @@ -1261,11 +1677,17 @@ Info_matte_color(VALUE self) | |
| 1261 1677 | 
             
                return rm_pixelpacket_to_color_name_info(info, &info->matte_color);
         | 
| 1262 1678 | 
             
            }
         | 
| 1263 1679 |  | 
| 1264 | 
            -
             | 
| 1265 | 
            -
             | 
| 1266 | 
            -
             | 
| 1267 | 
            -
             | 
| 1268 | 
            -
             | 
| 1680 | 
            +
            /**
         | 
| 1681 | 
            +
             * Set the matte color.
         | 
| 1682 | 
            +
             *
         | 
| 1683 | 
            +
             * Ruby usage:
         | 
| 1684 | 
            +
             *   - @verbatim Info#matte_color= @endverbatim
         | 
| 1685 | 
            +
             *
         | 
| 1686 | 
            +
             * @param self this object
         | 
| 1687 | 
            +
             * @param matte_arg the name of the matte as a String
         | 
| 1688 | 
            +
             * @return self
         | 
| 1689 | 
            +
             * @throw ArgumentError
         | 
| 1690 | 
            +
             */
         | 
| 1269 1691 | 
             
            VALUE
         | 
| 1270 1692 | 
             
            Info_matte_color_eq(VALUE self, VALUE matte_arg)
         | 
| 1271 1693 | 
             
            {
         | 
| @@ -1278,11 +1700,17 @@ Info_matte_color_eq(VALUE self, VALUE matte_arg) | |
| 1278 1700 | 
             
                return self;
         | 
| 1279 1701 | 
             
            }
         | 
| 1280 1702 |  | 
| 1281 | 
            -
             | 
| 1282 | 
            -
             | 
| 1283 | 
            -
             | 
| 1284 | 
            -
             | 
| 1285 | 
            -
             | 
| 1703 | 
            +
            /**
         | 
| 1704 | 
            +
             * Establish a progress monitor.
         | 
| 1705 | 
            +
             *
         | 
| 1706 | 
            +
             * Ruby usage:
         | 
| 1707 | 
            +
             *   - @verbatim Info#monitor= @endverbatim
         | 
| 1708 | 
            +
             *
         | 
| 1709 | 
            +
             * @param self this object
         | 
| 1710 | 
            +
             * @param monitor the monitor
         | 
| 1711 | 
            +
             * @return self
         | 
| 1712 | 
            +
             * @see Image_monitor_eq
         | 
| 1713 | 
            +
             */
         | 
| 1286 1714 | 
             
            VALUE
         | 
| 1287 1715 | 
             
            Info_monitor_eq(VALUE self, VALUE monitor)
         | 
| 1288 1716 | 
             
            {
         | 
| @@ -1310,10 +1738,15 @@ DEF_ATTR_ACCESSOR(Info, monochrome, bool) | |
| 1310 1738 |  | 
| 1311 1739 | 
             
            DEF_ATTR_ACCESSOR(Info, number_scenes, ulong)
         | 
| 1312 1740 |  | 
| 1313 | 
            -
             | 
| 1314 | 
            -
             | 
| 1315 | 
            -
             | 
| 1316 | 
            -
             | 
| 1741 | 
            +
            /**
         | 
| 1742 | 
            +
             * Return the orientation attribute as an OrientationType enum value.
         | 
| 1743 | 
            +
             *
         | 
| 1744 | 
            +
             * Ruby usage:
         | 
| 1745 | 
            +
             *   - @verbatim Info#orientation @endverbatim
         | 
| 1746 | 
            +
             *
         | 
| 1747 | 
            +
             * @param self this object
         | 
| 1748 | 
            +
             * @return the orientation
         | 
| 1749 | 
            +
             */
         | 
| 1317 1750 | 
             
            VALUE
         | 
| 1318 1751 | 
             
            Info_orientation(VALUE self)
         | 
| 1319 1752 | 
             
            {
         | 
| @@ -1324,11 +1757,17 @@ Info_orientation(VALUE self) | |
| 1324 1757 | 
             
            }
         | 
| 1325 1758 |  | 
| 1326 1759 |  | 
| 1327 | 
            -
             | 
| 1328 | 
            -
             | 
| 1329 | 
            -
             | 
| 1330 | 
            -
             | 
| 1331 | 
            -
             | 
| 1760 | 
            +
            /**
         | 
| 1761 | 
            +
             * Set the Orientation type.
         | 
| 1762 | 
            +
             *
         | 
| 1763 | 
            +
             * Ruby usage:
         | 
| 1764 | 
            +
             *   - @verbatim Info#Orientation= @endverbatim
         | 
| 1765 | 
            +
             *
         | 
| 1766 | 
            +
             * @param self this object
         | 
| 1767 | 
            +
             * @param inter the orientation type as an OrientationType enum value
         | 
| 1768 | 
            +
             * @return self
         | 
| 1769 | 
            +
             * @throw ArgumentError
         | 
| 1770 | 
            +
             */
         | 
| 1332 1771 | 
             
            VALUE
         | 
| 1333 1772 | 
             
            Info_orientation_eq(VALUE self, VALUE inter)
         | 
| 1334 1773 | 
             
            {
         | 
| @@ -1340,10 +1779,15 @@ Info_orientation_eq(VALUE self, VALUE inter) | |
| 1340 1779 | 
             
            }
         | 
| 1341 1780 |  | 
| 1342 1781 |  | 
| 1343 | 
            -
             | 
| 1344 | 
            -
             | 
| 1345 | 
            -
             | 
| 1346 | 
            -
             | 
| 1782 | 
            +
            /**
         | 
| 1783 | 
            +
             * Return origin geometry.
         | 
| 1784 | 
            +
             *
         | 
| 1785 | 
            +
             * Ruby usage:
         | 
| 1786 | 
            +
             *   - @verbatim Info#origin @endverbatim
         | 
| 1787 | 
            +
             *
         | 
| 1788 | 
            +
             * @param self this object
         | 
| 1789 | 
            +
             * @return the origin geometry
         | 
| 1790 | 
            +
             */
         | 
| 1347 1791 | 
             
            VALUE
         | 
| 1348 1792 | 
             
            Info_origin(VALUE self)
         | 
| 1349 1793 | 
             
            {
         | 
| @@ -1357,11 +1801,17 @@ Info_origin(VALUE self) | |
| 1357 1801 | 
             
            }
         | 
| 1358 1802 |  | 
| 1359 1803 |  | 
| 1360 | 
            -
             | 
| 1361 | 
            -
             | 
| 1362 | 
            -
             | 
| 1363 | 
            -
             | 
| 1364 | 
            -
             | 
| 1804 | 
            +
            /**
         | 
| 1805 | 
            +
             * Set origin geometry. Argument may be a Geometry object as well as a geometry
         | 
| 1806 | 
            +
             * string.
         | 
| 1807 | 
            +
             *
         | 
| 1808 | 
            +
             * Ruby usage:
         | 
| 1809 | 
            +
             *   - @verbatim Info#origin=+-x+-y @endverbatim
         | 
| 1810 | 
            +
             *
         | 
| 1811 | 
            +
             * @param self this object
         | 
| 1812 | 
            +
             * @param origin_arg the origin geometry
         | 
| 1813 | 
            +
             * @return self
         | 
| 1814 | 
            +
             */
         | 
| 1365 1815 | 
             
            VALUE
         | 
| 1366 1816 | 
             
            Info_origin_eq(VALUE self, VALUE origin_arg)
         | 
| 1367 1817 | 
             
            {
         | 
| @@ -1390,6 +1840,15 @@ Info_origin_eq(VALUE self, VALUE origin_arg) | |
| 1390 1840 | 
             
            }
         | 
| 1391 1841 |  | 
| 1392 1842 |  | 
| 1843 | 
            +
            /**
         | 
| 1844 | 
            +
             * Get the Postscript page geometry.
         | 
| 1845 | 
            +
             *
         | 
| 1846 | 
            +
             * Ruby usage:
         | 
| 1847 | 
            +
             *   - @verbatim Info_page @endverbatim
         | 
| 1848 | 
            +
             *
         | 
| 1849 | 
            +
             * @param self this object
         | 
| 1850 | 
            +
             * @return the page geometry
         | 
| 1851 | 
            +
             */
         | 
| 1393 1852 | 
             
            VALUE
         | 
| 1394 1853 | 
             
            Info_page(VALUE self)
         | 
| 1395 1854 | 
             
            {
         | 
| @@ -1400,10 +1859,17 @@ Info_page(VALUE self) | |
| 1400 1859 |  | 
| 1401 1860 | 
             
            }
         | 
| 1402 1861 |  | 
| 1403 | 
            -
             | 
| 1404 | 
            -
             | 
| 1405 | 
            -
             | 
| 1406 | 
            -
             | 
| 1862 | 
            +
            /**
         | 
| 1863 | 
            +
             * Store the Postscript page geometry. Argument may be a Geometry object as well
         | 
| 1864 | 
            +
             * as a geometry string.
         | 
| 1865 | 
            +
             *
         | 
| 1866 | 
            +
             * Ruby usage:
         | 
| 1867 | 
            +
             *   - @verbatim Info#page= @endverbatim
         | 
| 1868 | 
            +
             *
         | 
| 1869 | 
            +
             * @param self this object
         | 
| 1870 | 
            +
             * @param page_arg the geometry
         | 
| 1871 | 
            +
             * @return self
         | 
| 1872 | 
            +
             */
         | 
| 1407 1873 | 
             
            VALUE
         | 
| 1408 1874 | 
             
            Info_page_eq(VALUE self, VALUE page_arg)
         | 
| 1409 1875 | 
             
            {
         | 
| @@ -1434,11 +1900,15 @@ Info_page_eq(VALUE self, VALUE page_arg) | |
| 1434 1900 | 
             
            DEF_ATTR_ACCESSOR(Info, pointsize, dbl)
         | 
| 1435 1901 | 
             
            DEF_ATTR_ACCESSOR(Info, quality, ulong)
         | 
| 1436 1902 |  | 
| 1437 | 
            -
             | 
| 1438 | 
            -
             | 
| 1439 | 
            -
             | 
| 1440 | 
            -
             | 
| 1441 | 
            -
             | 
| 1903 | 
            +
            /**
         | 
| 1904 | 
            +
             * Get sampling factors used by JPEG or MPEG-2 encoder and YUV decoder/encoder.
         | 
| 1905 | 
            +
             *
         | 
| 1906 | 
            +
             * Ruby usage:
         | 
| 1907 | 
            +
             *   - @verbatim Info#sampling_factor @endverbatim
         | 
| 1908 | 
            +
             *
         | 
| 1909 | 
            +
             * @param self this object
         | 
| 1910 | 
            +
             * @return the sampling factors
         | 
| 1911 | 
            +
             */
         | 
| 1442 1912 | 
             
            VALUE
         | 
| 1443 1913 | 
             
            Info_sampling_factor(VALUE self)
         | 
| 1444 1914 | 
             
            {
         | 
| @@ -1455,6 +1925,16 @@ Info_sampling_factor(VALUE self) | |
| 1455 1925 | 
             
                }
         | 
| 1456 1926 | 
             
            }
         | 
| 1457 1927 |  | 
| 1928 | 
            +
            /**
         | 
| 1929 | 
            +
             * Set sampling factors used by JPEG or MPEG-2 encoder and YUV decoder/encoder.
         | 
| 1930 | 
            +
             *
         | 
| 1931 | 
            +
             * Ruby usage:
         | 
| 1932 | 
            +
             *   - @verbatim Info#sampling_factor= @endverbatim
         | 
| 1933 | 
            +
             *
         | 
| 1934 | 
            +
             * @param self this object
         | 
| 1935 | 
            +
             * @param sampling_factor the sampling factors
         | 
| 1936 | 
            +
             * @return self
         | 
| 1937 | 
            +
             */
         | 
| 1458 1938 | 
             
            VALUE
         | 
| 1459 1939 | 
             
            Info_sampling_factor_eq(VALUE self, VALUE sampling_factor)
         | 
| 1460 1940 | 
             
            {
         | 
| @@ -1483,11 +1963,15 @@ Info_sampling_factor_eq(VALUE self, VALUE sampling_factor) | |
| 1483 1963 | 
             
            }
         | 
| 1484 1964 |  | 
| 1485 1965 |  | 
| 1486 | 
            -
             | 
| 1487 | 
            -
             | 
| 1488 | 
            -
             | 
| 1489 | 
            -
             | 
| 1490 | 
            -
             | 
| 1966 | 
            +
            /**
         | 
| 1967 | 
            +
             * Get the scene number.
         | 
| 1968 | 
            +
             *
         | 
| 1969 | 
            +
             * Ruby usage:
         | 
| 1970 | 
            +
             *   - @verbatim Info#scene @endverbatim
         | 
| 1971 | 
            +
             *
         | 
| 1972 | 
            +
             * @param self this object
         | 
| 1973 | 
            +
             * @return the scene number
         | 
| 1974 | 
            +
             */
         | 
| 1491 1975 | 
             
            VALUE
         | 
| 1492 1976 | 
             
            Info_scene(VALUE self)
         | 
| 1493 1977 | 
             
            {
         | 
| @@ -1498,6 +1982,16 @@ Info_scene(VALUE self) | |
| 1498 1982 | 
             
            }
         | 
| 1499 1983 |  | 
| 1500 1984 |  | 
| 1985 | 
            +
            /**
         | 
| 1986 | 
            +
             * Set the scene number.
         | 
| 1987 | 
            +
             *
         | 
| 1988 | 
            +
             * Ruby usage:
         | 
| 1989 | 
            +
             *   - @verbatim Info#scene= @endverbatim
         | 
| 1990 | 
            +
             *
         | 
| 1991 | 
            +
             * @param self this object
         | 
| 1992 | 
            +
             * @param scene the scene number
         | 
| 1993 | 
            +
             * @return self
         | 
| 1994 | 
            +
             */
         | 
| 1501 1995 | 
             
            VALUE
         | 
| 1502 1996 | 
             
            Info_scene_eq(VALUE self, VALUE scene)
         | 
| 1503 1997 | 
             
            {
         | 
| @@ -1518,13 +2012,28 @@ Info_scene_eq(VALUE self, VALUE scene) | |
| 1518 2012 | 
             
            }
         | 
| 1519 2013 |  | 
| 1520 2014 |  | 
| 2015 | 
            +
            /**
         | 
| 2016 | 
            +
             * Get the server name.
         | 
| 2017 | 
            +
             *
         | 
| 2018 | 
            +
             * Ruby usage:
         | 
| 2019 | 
            +
             *   - @verbatim Info#server_name @endverbatim
         | 
| 2020 | 
            +
             *
         | 
| 2021 | 
            +
             * @param self this object
         | 
| 2022 | 
            +
             * @return the server name
         | 
| 2023 | 
            +
             */
         | 
| 1521 2024 | 
             
            DEF_ATTR_READER(Info, server_name, str)
         | 
| 1522 2025 |  | 
| 1523 2026 |  | 
| 1524 | 
            -
             | 
| 1525 | 
            -
             | 
| 1526 | 
            -
             | 
| 1527 | 
            -
             | 
| 2027 | 
            +
            /**
         | 
| 2028 | 
            +
             * Set the server name.
         | 
| 2029 | 
            +
             *
         | 
| 2030 | 
            +
             * Ruby usage:
         | 
| 2031 | 
            +
             *   - @verbatim Info#server_name= @endverbatim
         | 
| 2032 | 
            +
             *
         | 
| 2033 | 
            +
             * @param self this object
         | 
| 2034 | 
            +
             * @param server_arg the server name as a String
         | 
| 2035 | 
            +
             * @return self
         | 
| 2036 | 
            +
             */
         | 
| 1528 2037 | 
             
            VALUE
         | 
| 1529 2038 | 
             
            Info_server_name_eq(VALUE self, VALUE server_arg)
         | 
| 1530 2039 | 
             
            {
         | 
| @@ -1545,14 +2054,29 @@ Info_server_name_eq(VALUE self, VALUE server_arg) | |
| 1545 2054 | 
             
                return self;
         | 
| 1546 2055 | 
             
            }
         | 
| 1547 2056 |  | 
| 2057 | 
            +
            /**
         | 
| 2058 | 
            +
             * Get ths size
         | 
| 2059 | 
            +
             *
         | 
| 2060 | 
            +
             * Ruby usage:
         | 
| 2061 | 
            +
             *   - @verbatim Info#size @endverbatim
         | 
| 2062 | 
            +
             *
         | 
| 2063 | 
            +
             * @param self this object
         | 
| 2064 | 
            +
             * @return the size as a Geometry object
         | 
| 2065 | 
            +
             */
         | 
| 1548 2066 | 
             
            DEF_ATTR_READER(Info, size, str)
         | 
| 1549 2067 |  | 
| 1550 | 
            -
             | 
| 1551 | 
            -
             | 
| 1552 | 
            -
             | 
| 1553 | 
            -
             | 
| 1554 | 
            -
             | 
| 1555 | 
            -
             | 
| 2068 | 
            +
            /**
         | 
| 2069 | 
            +
             * Set the size (either as a Geometry object or a Geometry string, i.e.
         | 
| 2070 | 
            +
             * WxH{+-}x{+-}y)
         | 
| 2071 | 
            +
             *
         | 
| 2072 | 
            +
             * Ruby usage:
         | 
| 2073 | 
            +
             *   - @verbatim Info#size= @endverbatim
         | 
| 2074 | 
            +
             *
         | 
| 2075 | 
            +
             * @param self this object
         | 
| 2076 | 
            +
             * @param size_arg the size
         | 
| 2077 | 
            +
             * @return self
         | 
| 2078 | 
            +
             * @throw ArgumentError
         | 
| 2079 | 
            +
             */
         | 
| 1556 2080 | 
             
            VALUE
         | 
| 1557 2081 | 
             
            Info_size_eq(VALUE self, VALUE size_arg)
         | 
| 1558 2082 | 
             
            {
         | 
| @@ -1582,21 +2106,32 @@ Info_size_eq(VALUE self, VALUE size_arg) | |
| 1582 2106 | 
             
            }
         | 
| 1583 2107 |  | 
| 1584 2108 |  | 
| 1585 | 
            -
             | 
| 1586 | 
            -
             | 
| 1587 | 
            -
             | 
| 1588 | 
            -
             | 
| 2109 | 
            +
            /**
         | 
| 2110 | 
            +
             * Return the stroke color as a String.
         | 
| 2111 | 
            +
             *
         | 
| 2112 | 
            +
             * Ruby usage:
         | 
| 2113 | 
            +
             *   - @verbatim Info#stroke @endverbatim
         | 
| 2114 | 
            +
             *
         | 
| 2115 | 
            +
             * @param self this object
         | 
| 2116 | 
            +
             * @return the stroke color
         | 
| 2117 | 
            +
             */
         | 
| 1589 2118 | 
             
            VALUE
         | 
| 1590 2119 | 
             
            Info_stroke(VALUE self)
         | 
| 1591 2120 | 
             
            {
         | 
| 1592 2121 | 
             
                return get_option(self, "stroke");
         | 
| 1593 2122 | 
             
            }
         | 
| 1594 2123 |  | 
| 1595 | 
            -
             | 
| 1596 | 
            -
             | 
| 1597 | 
            -
             | 
| 1598 | 
            -
             | 
| 1599 | 
            -
             | 
| 2124 | 
            +
            /**
         | 
| 2125 | 
            +
             * Set the stroke color
         | 
| 2126 | 
            +
             *
         | 
| 2127 | 
            +
             * Ruby usage:
         | 
| 2128 | 
            +
             *   - @verbatim Info#stroke= @endverbatim
         | 
| 2129 | 
            +
             *
         | 
| 2130 | 
            +
             * @param self this object
         | 
| 2131 | 
            +
             * @param color the stroke color as a String
         | 
| 2132 | 
            +
             * @return self
         | 
| 2133 | 
            +
             * @throw ArgumentError
         | 
| 2134 | 
            +
             */
         | 
| 1600 2135 | 
             
            VALUE
         | 
| 1601 2136 | 
             
            Info_stroke_eq(VALUE self, VALUE color)
         | 
| 1602 2137 | 
             
            {
         | 
| @@ -1604,11 +2139,18 @@ Info_stroke_eq(VALUE self, VALUE color) | |
| 1604 2139 | 
             
            }
         | 
| 1605 2140 |  | 
| 1606 2141 |  | 
| 1607 | 
            -
             | 
| 1608 | 
            -
             | 
| 1609 | 
            -
             | 
| 1610 | 
            -
             | 
| 1611 | 
            -
             | 
| 2142 | 
            +
            /**
         | 
| 2143 | 
            +
             * Support for caption: format.
         | 
| 2144 | 
            +
             *
         | 
| 2145 | 
            +
             * Ruby usage:
         | 
| 2146 | 
            +
             *   - @verbatim Info#stroke_width @endverbatim
         | 
| 2147 | 
            +
             *
         | 
| 2148 | 
            +
             * Notes:
         | 
| 2149 | 
            +
             *   - Supported in ImageMagick >= 6.3.2-6
         | 
| 2150 | 
            +
             *
         | 
| 2151 | 
            +
             * @param self this object
         | 
| 2152 | 
            +
             * @return the stroke width
         | 
| 2153 | 
            +
             */
         | 
| 1612 2154 | 
             
            VALUE
         | 
| 1613 2155 | 
             
            Info_stroke_width(VALUE self)
         | 
| 1614 2156 | 
             
            {
         | 
| @@ -1616,11 +2158,19 @@ Info_stroke_width(VALUE self) | |
| 1616 2158 | 
             
            }
         | 
| 1617 2159 |  | 
| 1618 2160 |  | 
| 1619 | 
            -
             | 
| 1620 | 
            -
             | 
| 1621 | 
            -
             | 
| 1622 | 
            -
             | 
| 1623 | 
            -
             | 
| 2161 | 
            +
            /**
         | 
| 2162 | 
            +
             * Support for caption: format.
         | 
| 2163 | 
            +
             *
         | 
| 2164 | 
            +
             * Ruby usage:
         | 
| 2165 | 
            +
             *   - @verbatim Info#stroke_width= @endverbatim
         | 
| 2166 | 
            +
             *
         | 
| 2167 | 
            +
             * Notes:
         | 
| 2168 | 
            +
             *   - Supported in ImageMagick >= 6.3.2-6
         | 
| 2169 | 
            +
             *
         | 
| 2170 | 
            +
             * @param self this object
         | 
| 2171 | 
            +
             * @param stroke_width the stroke width
         | 
| 2172 | 
            +
             * @return self
         | 
| 2173 | 
            +
             */
         | 
| 1624 2174 | 
             
            VALUE
         | 
| 1625 2175 | 
             
            Info_stroke_width_eq(VALUE self, VALUE stroke_width)
         | 
| 1626 2176 | 
             
            {
         | 
| @@ -1628,10 +2178,16 @@ Info_stroke_width_eq(VALUE self, VALUE stroke_width) | |
| 1628 2178 | 
             
            }
         | 
| 1629 2179 |  | 
| 1630 2180 |  | 
| 1631 | 
            -
             | 
| 1632 | 
            -
             | 
| 1633 | 
            -
             | 
| 1634 | 
            -
             | 
| 2181 | 
            +
            /**
         | 
| 2182 | 
            +
             * Set name of texture to tile onto the image background.
         | 
| 2183 | 
            +
             *
         | 
| 2184 | 
            +
             * Ruby usage:
         | 
| 2185 | 
            +
             *   - @verbatim Image::Info#texture= @endverbatim
         | 
| 2186 | 
            +
             *
         | 
| 2187 | 
            +
             * @param self this object
         | 
| 2188 | 
            +
             * @param texture the name of the texture image
         | 
| 2189 | 
            +
             * @return self
         | 
| 2190 | 
            +
             */
         | 
| 1635 2191 | 
             
            VALUE
         | 
| 1636 2192 | 
             
            Info_texture_eq(VALUE self, VALUE texture)
         | 
| 1637 2193 | 
             
            {
         | 
| @@ -1665,10 +2221,16 @@ Info_texture_eq(VALUE self, VALUE texture) | |
| 1665 2221 | 
             
            }
         | 
| 1666 2222 |  | 
| 1667 2223 |  | 
| 1668 | 
            -
             | 
| 1669 | 
            -
             | 
| 1670 | 
            -
             | 
| 1671 | 
            -
             | 
| 2224 | 
            +
            /**
         | 
| 2225 | 
            +
             * info.tile_offset = [+/-]x[+/-]y.
         | 
| 2226 | 
            +
             *
         | 
| 2227 | 
            +
             * Ruby usage:
         | 
| 2228 | 
            +
             *   - @verbatim Image::Info#tile_offset= @endverbatim
         | 
| 2229 | 
            +
             *
         | 
| 2230 | 
            +
             * @param self this object
         | 
| 2231 | 
            +
             * @param offset the offset
         | 
| 2232 | 
            +
             * @return self
         | 
| 2233 | 
            +
             */
         | 
| 1672 2234 | 
             
            VALUE
         | 
| 1673 2235 | 
             
            Info_tile_offset_eq(VALUE self, VALUE offset)
         | 
| 1674 2236 | 
             
            {
         | 
| @@ -1691,11 +2253,16 @@ Info_tile_offset_eq(VALUE self, VALUE offset) | |
| 1691 2253 | 
             
            }
         | 
| 1692 2254 |  | 
| 1693 2255 |  | 
| 1694 | 
            -
             | 
| 1695 | 
            -
             | 
| 1696 | 
            -
             | 
| 1697 | 
            -
             | 
| 1698 | 
            -
             | 
| 2256 | 
            +
            /**
         | 
| 2257 | 
            +
             * Return the name of the transparent color as a String.
         | 
| 2258 | 
            +
             *
         | 
| 2259 | 
            +
             * Ruby usage:
         | 
| 2260 | 
            +
             *   - @verbatim Info#transparent_color @endverbatim
         | 
| 2261 | 
            +
             *
         | 
| 2262 | 
            +
             * @param self this object
         | 
| 2263 | 
            +
             * @return the name of the transparent color
         | 
| 2264 | 
            +
             * @see Image_transparent_color
         | 
| 2265 | 
            +
             */
         | 
| 1699 2266 | 
             
            VALUE
         | 
| 1700 2267 | 
             
            Info_transparent_color(VALUE self)
         | 
| 1701 2268 | 
             
            {
         | 
| @@ -1706,11 +2273,17 @@ Info_transparent_color(VALUE self) | |
| 1706 2273 | 
             
            }
         | 
| 1707 2274 |  | 
| 1708 2275 |  | 
| 1709 | 
            -
             | 
| 1710 | 
            -
             | 
| 1711 | 
            -
             | 
| 1712 | 
            -
             | 
| 1713 | 
            -
             | 
| 2276 | 
            +
            /**
         | 
| 2277 | 
            +
             * Set the transparent color.
         | 
| 2278 | 
            +
             *
         | 
| 2279 | 
            +
             * Ruby usage:
         | 
| 2280 | 
            +
             *   - @verbatim Info#transparent_color= @endverbatim
         | 
| 2281 | 
            +
             *
         | 
| 2282 | 
            +
             * @param self this object
         | 
| 2283 | 
            +
             * @param tc_arg the transparent color as a String
         | 
| 2284 | 
            +
             * @return self
         | 
| 2285 | 
            +
             * @throw ArgumentError
         | 
| 2286 | 
            +
             */
         | 
| 1714 2287 | 
             
            VALUE
         | 
| 1715 2288 | 
             
            Info_transparent_color_eq(VALUE self, VALUE tc_arg)
         | 
| 1716 2289 | 
             
            {
         | 
| @@ -1724,10 +2297,15 @@ Info_transparent_color_eq(VALUE self, VALUE tc_arg) | |
| 1724 2297 | 
             
            }
         | 
| 1725 2298 |  | 
| 1726 2299 |  | 
| 1727 | 
            -
             | 
| 1728 | 
            -
             | 
| 1729 | 
            -
             | 
| 1730 | 
            -
             | 
| 2300 | 
            +
            /**
         | 
| 2301 | 
            +
             * Return tile_offset attribute values.
         | 
| 2302 | 
            +
             *
         | 
| 2303 | 
            +
             * Ruby usage:
         | 
| 2304 | 
            +
             *   - @verbatim Image::Info#tile_offset @endverbatim
         | 
| 2305 | 
            +
             *
         | 
| 2306 | 
            +
             * @param self this object
         | 
| 2307 | 
            +
             * @return the tile offset
         | 
| 2308 | 
            +
             */
         | 
| 1731 2309 | 
             
            VALUE
         | 
| 1732 2310 | 
             
            Info_tile_offset(VALUE self)
         | 
| 1733 2311 | 
             
            {
         | 
| @@ -1747,11 +2325,17 @@ Info_tile_offset(VALUE self) | |
| 1747 2325 | 
             
            }
         | 
| 1748 2326 |  | 
| 1749 2327 |  | 
| 1750 | 
            -
             | 
| 1751 | 
            -
             | 
| 1752 | 
            -
             | 
| 1753 | 
            -
             | 
| 1754 | 
            -
             | 
| 2328 | 
            +
            /**
         | 
| 2329 | 
            +
             * Undefine image option.
         | 
| 2330 | 
            +
             *
         | 
| 2331 | 
            +
             * Ruby usage:
         | 
| 2332 | 
            +
             *   - @verbatim Info#undefine(format,key) @endverbatim
         | 
| 2333 | 
            +
             *
         | 
| 2334 | 
            +
             * @param self this object
         | 
| 2335 | 
            +
             * @param format the format
         | 
| 2336 | 
            +
             * @param key the key
         | 
| 2337 | 
            +
             * @return self
         | 
| 2338 | 
            +
             */
         | 
| 1755 2339 | 
             
            VALUE
         | 
| 1756 2340 | 
             
            Info_undefine(VALUE self, VALUE format, VALUE key)
         | 
| 1757 2341 | 
             
            {
         | 
| @@ -1779,31 +2363,47 @@ Info_undefine(VALUE self, VALUE format, VALUE key) | |
| 1779 2363 | 
             
            }
         | 
| 1780 2364 |  | 
| 1781 2365 |  | 
| 1782 | 
            -
             | 
| 1783 | 
            -
             | 
| 1784 | 
            -
             | 
| 1785 | 
            -
             | 
| 2366 | 
            +
            /**
         | 
| 2367 | 
            +
             * Return the undercolor color as a String.
         | 
| 2368 | 
            +
             *
         | 
| 2369 | 
            +
             * Ruby usage:
         | 
| 2370 | 
            +
             *   - @verbatim Info#undercolor @endverbatim
         | 
| 2371 | 
            +
             *
         | 
| 2372 | 
            +
             * @param self this object
         | 
| 2373 | 
            +
             * @return the undercolor
         | 
| 2374 | 
            +
             */
         | 
| 1786 2375 | 
             
            VALUE
         | 
| 1787 2376 | 
             
            Info_undercolor(VALUE self)
         | 
| 1788 2377 | 
             
            {
         | 
| 1789 2378 | 
             
                return get_option(self, "undercolor");
         | 
| 1790 2379 | 
             
            }
         | 
| 1791 2380 |  | 
| 1792 | 
            -
             | 
| 1793 | 
            -
             | 
| 1794 | 
            -
             | 
| 1795 | 
            -
             | 
| 1796 | 
            -
             | 
| 2381 | 
            +
            /**
         | 
| 2382 | 
            +
             * Set the undercolor color.
         | 
| 2383 | 
            +
             *
         | 
| 2384 | 
            +
             * Ruby usage:
         | 
| 2385 | 
            +
             *   - @verbatim Info#undercolor= @endverbatim
         | 
| 2386 | 
            +
             *
         | 
| 2387 | 
            +
             * @param self this object
         | 
| 2388 | 
            +
             * @param color the undercolor color as a String
         | 
| 2389 | 
            +
             * @return self
         | 
| 2390 | 
            +
             * @throw ArgumentError
         | 
| 2391 | 
            +
             */
         | 
| 1797 2392 | 
             
            VALUE
         | 
| 1798 2393 | 
             
            Info_undercolor_eq(VALUE self, VALUE color)
         | 
| 1799 2394 | 
             
            {
         | 
| 1800 2395 | 
             
                return set_color_option(self, "undercolor", color);
         | 
| 1801 2396 | 
             
            }
         | 
| 1802 2397 |  | 
| 1803 | 
            -
             | 
| 1804 | 
            -
             | 
| 1805 | 
            -
             | 
| 1806 | 
            -
             | 
| 2398 | 
            +
            /**
         | 
| 2399 | 
            +
             * Get the resolution type.
         | 
| 2400 | 
            +
             *
         | 
| 2401 | 
            +
             * Ruby usage:
         | 
| 2402 | 
            +
             *   - @verbatim Info#units @endverbatim
         | 
| 2403 | 
            +
             *
         | 
| 2404 | 
            +
             * @param self this object
         | 
| 2405 | 
            +
             * @return the resolution type
         | 
| 2406 | 
            +
             */
         | 
| 1807 2407 | 
             
            VALUE
         | 
| 1808 2408 | 
             
            Info_units(VALUE self)
         | 
| 1809 2409 | 
             
            {
         | 
| @@ -1813,11 +2413,17 @@ Info_units(VALUE self) | |
| 1813 2413 | 
             
                return ResolutionType_new(info->units);
         | 
| 1814 2414 | 
             
            }
         | 
| 1815 2415 |  | 
| 1816 | 
            -
             | 
| 1817 | 
            -
             | 
| 1818 | 
            -
             | 
| 1819 | 
            -
             | 
| 1820 | 
            -
             | 
| 2416 | 
            +
            /**
         | 
| 2417 | 
            +
             * Set the resolution type
         | 
| 2418 | 
            +
             *
         | 
| 2419 | 
            +
             * Ruby usage:
         | 
| 2420 | 
            +
             *   - @verbatim Info#units= @endverbatim
         | 
| 2421 | 
            +
             *
         | 
| 2422 | 
            +
             * @param self this object
         | 
| 2423 | 
            +
             * @param units the resolution type
         | 
| 2424 | 
            +
             * @return self
         | 
| 2425 | 
            +
             * @throw ArgumentError
         | 
| 2426 | 
            +
             */
         | 
| 1821 2427 | 
             
            VALUE
         | 
| 1822 2428 | 
             
            Info_units_eq(VALUE self, VALUE units)
         | 
| 1823 2429 | 
             
            {
         | 
| @@ -1828,12 +2434,27 @@ Info_units_eq(VALUE self, VALUE units) | |
| 1828 2434 | 
             
                return self;
         | 
| 1829 2435 | 
             
            }
         | 
| 1830 2436 |  | 
| 2437 | 
            +
            /**
         | 
| 2438 | 
            +
             * Get FlashPix viewing parameters.
         | 
| 2439 | 
            +
             *
         | 
| 2440 | 
            +
             * Ruby usage:
         | 
| 2441 | 
            +
             *   - @verbatim Info#view @endverbatim
         | 
| 2442 | 
            +
             *
         | 
| 2443 | 
            +
             * @param self this object.
         | 
| 2444 | 
            +
             * @return the viewing parameters
         | 
| 2445 | 
            +
             */
         | 
| 1831 2446 | 
             
            DEF_ATTR_READER(Info, view, str)
         | 
| 1832 2447 |  | 
| 1833 | 
            -
             | 
| 1834 | 
            -
             | 
| 1835 | 
            -
             | 
| 1836 | 
            -
             | 
| 2448 | 
            +
            /**
         | 
| 2449 | 
            +
             * Set FlashPix viewing parameters.
         | 
| 2450 | 
            +
             *
         | 
| 2451 | 
            +
             * Ruby usage:
         | 
| 2452 | 
            +
             *   - @verbatim Info#view= @endverbatim
         | 
| 2453 | 
            +
             *
         | 
| 2454 | 
            +
             * @param self this object
         | 
| 2455 | 
            +
             * @param view_arg the viewing parameters
         | 
| 2456 | 
            +
             * @return self
         | 
| 2457 | 
            +
             */
         | 
| 1837 2458 | 
             
            VALUE
         | 
| 1838 2459 | 
             
            Info_view_eq(VALUE self, VALUE view_arg)
         | 
| 1839 2460 | 
             
            {
         | 
| @@ -1856,11 +2477,14 @@ Info_view_eq(VALUE self, VALUE view_arg) | |
| 1856 2477 | 
             
            }
         | 
| 1857 2478 |  | 
| 1858 2479 |  | 
| 1859 | 
            -
             | 
| 1860 | 
            -
             | 
| 1861 | 
            -
             | 
| 1862 | 
            -
             | 
| 1863 | 
            -
             | 
| 2480 | 
            +
            /**
         | 
| 2481 | 
            +
             * If there is a texture image, delete it before destroying the ImageInfo
         | 
| 2482 | 
            +
             * structure.
         | 
| 2483 | 
            +
             *
         | 
| 2484 | 
            +
             * No Ruby usage (internal function)
         | 
| 2485 | 
            +
             *
         | 
| 2486 | 
            +
             * @param infoptr pointer to the Info object
         | 
| 2487 | 
            +
             */
         | 
| 1864 2488 | 
             
            static void
         | 
| 1865 2489 | 
             
            destroy_Info(void *infoptr)
         | 
| 1866 2490 | 
             
            {
         | 
| @@ -1877,10 +2501,14 @@ destroy_Info(void *infoptr) | |
| 1877 2501 | 
             
            }
         | 
| 1878 2502 |  | 
| 1879 2503 |  | 
| 1880 | 
            -
             | 
| 1881 | 
            -
             | 
| 1882 | 
            -
             | 
| 1883 | 
            -
             | 
| 2504 | 
            +
            /**
         | 
| 2505 | 
            +
             * Create an ImageInfo object.
         | 
| 2506 | 
            +
             *
         | 
| 2507 | 
            +
             * No Ruby usage (internal function)
         | 
| 2508 | 
            +
             *
         | 
| 2509 | 
            +
             * @param class the Ruby class to use
         | 
| 2510 | 
            +
             * @return a new ImageInfo object
         | 
| 2511 | 
            +
             */
         | 
| 1884 2512 | 
             
            VALUE
         | 
| 1885 2513 | 
             
            Info_alloc(VALUE class)
         | 
| 1886 2514 | 
             
            {
         | 
| @@ -1897,11 +2525,16 @@ Info_alloc(VALUE class) | |
| 1897 2525 | 
             
            }
         | 
| 1898 2526 |  | 
| 1899 2527 |  | 
| 1900 | 
            -
             | 
| 1901 | 
            -
             | 
| 1902 | 
            -
             | 
| 1903 | 
            -
             | 
| 1904 | 
            -
             | 
| 2528 | 
            +
            /**
         | 
| 2529 | 
            +
             * Provide a Info.new method for internal use.
         | 
| 2530 | 
            +
             *
         | 
| 2531 | 
            +
             * No Ruby usage (internal function)
         | 
| 2532 | 
            +
             *
         | 
| 2533 | 
            +
             * Notes:
         | 
| 2534 | 
            +
             *   - Takes no parameters, but runs the parm block if present
         | 
| 2535 | 
            +
             *
         | 
| 2536 | 
            +
             * @return a new ImageInfo object
         | 
| 2537 | 
            +
             */
         | 
| 1905 2538 | 
             
            VALUE
         | 
| 1906 2539 | 
             
            rm_info_new(void)
         | 
| 1907 2540 | 
             
            {
         | 
| @@ -1912,10 +2545,15 @@ rm_info_new(void) | |
| 1912 2545 | 
             
            }
         | 
| 1913 2546 |  | 
| 1914 2547 |  | 
| 1915 | 
            -
             | 
| 1916 | 
            -
             | 
| 1917 | 
            -
             | 
| 1918 | 
            -
             | 
| 2548 | 
            +
            /**
         | 
| 2549 | 
            +
             * If an initializer block is present, run it.
         | 
| 2550 | 
            +
             *
         | 
| 2551 | 
            +
             * Ruby usage:
         | 
| 2552 | 
            +
             *   - @verbatim Info#initialize @endverbatim
         | 
| 2553 | 
            +
             *
         | 
| 2554 | 
            +
             * @param self this object
         | 
| 2555 | 
            +
             * @return self
         | 
| 2556 | 
            +
             */
         | 
| 1919 2557 | 
             
            VALUE
         | 
| 1920 2558 | 
             
            Info_initialize(VALUE self)
         | 
| 1921 2559 | 
             
            {
         |