rmagick 1.9.1 → 1.9.2

data/ext/RMagick/MANIFEST

@@ -1,4 +1,4 @@
-MANIFEST for RMagick-1.9.1 - 18:06:01 09/07/05
+MANIFEST for RMagick-1.9.2 - 17:43:02 09/15/05
 
 configure
 README.html

data/ext/RMagick/rmagick.h

@@ -1,4 +1,4 @@
-/* $Id: rmagick.h,v 1.92 2005/09/05 20:27:27 rmagick Exp $ */
+/* $Id: rmagick.h,v 1.94 2005/09/13 23:37:21 rmagick Exp $ */
 /*=============================================================================
 |               Copyright (C) 2005 by Timothy P. Hunter
 | Name:     rmagick.h
@@ -268,6 +268,9 @@ EXTERN VALUE Class_GravityType;
 EXTERN VALUE Class_ImageType;
 EXTERN VALUE Class_InterlaceType;
 EXTERN VALUE Class_NoiseType;
+#if defined(HAVE_IMAGE_ORIENTATION)
+EXTERN VALUE Class_OrientationType;
+#endif
 EXTERN VALUE Class_PaintMethod;
 EXTERN VALUE Class_PreviewType;
 EXTERN VALUE Class_RenderingIntent;
@@ -276,9 +279,7 @@ EXTERN VALUE Class_StorageType;
 EXTERN VALUE Class_StretchType;
 EXTERN VALUE Class_StyleType;
 EXTERN VALUE Class_WeightType;
-#if defined(HAVE_IMAGE_ORIENTATION)
-EXTERN VALUE Class_OrientationType;
-#endif
+EXTERN VALUE Class_VirtualPixelMethod;
 
 /*
 *   Commonly-used IDs
@@ -482,6 +483,7 @@ Pixel_##_channel_##_eq(VALUE self, VALUE v) \
    e = (type)(magick_enum->val);\
    } while(0)
 
+#define ENUM_TO_NAME(_enum) case _enum: return #_enum;
 
 
 // Method, external function declarations. These declarations are
@@ -649,6 +651,7 @@ ATTR_ACCESSOR(Image, blur)
 ATTR_ACCESSOR(Image, border_color)
 ATTR_READER(Image, bounding_box)
 ATTR_ACCESSOR(Image, chromaticity)
+ATTR_ACCESSOR(Image, class_type)
 ATTR_WRITER(Image, clip_mask)
 ATTR_ACCESSOR(Image, color_profile)
 ATTR_READER(Image, colors)
@@ -693,10 +696,11 @@ ATTR_ACCESSOR(Image, rendering_intent)
 ATTR_READER(Image, rows)
 ATTR_READER(Image, scene)
 ATTR_ACCESSOR(Image, start_loop)
-ATTR_ACCESSOR(Image, class_type)
+ATTR_ACCESSOR(Image, ticks_per_second)
 ATTR_ACCESSOR(Image, tile_info)
 ATTR_READER(Image, total_colors)
 ATTR_ACCESSOR(Image, units)
+ATTR_ACCESSOR(Image, virtual_pixel_method)
 ATTR_ACCESSOR(Image, x_resolution)
 ATTR_ACCESSOR(Image, y_resolution)
 
@@ -959,6 +963,7 @@ extern VALUE  Statistics_new(ImageStatistics *);
 extern VALUE   OrientationType_new(OrientationType);
 #endif
 extern const char *StorageType_name(StorageType);
+extern VALUE   VirtualPixelMethod_new(VirtualPixelMethod);
 
 #if defined(HAVE_RB_DEFINE_ALLOC_FUNC)
 extern VALUE  Enum_alloc(VALUE);

data/ext/RMagick/rmagick_config.h.in

@@ -106,7 +106,8 @@
 #undef HAVE_IMAGE_QUALITY
 /* Introduced in IM 6.0.0 */
 #undef HAVE_IMAGE_ORIENTATION
-#undef HAVE_IMAGE_STORAGE_CLASS
+/* Introduced in IM 6.2.4 */
+#undef HAVE_IMAGE_TICKS_PER_SECOND
 /* Introduced in IM 5.5.6 */
 #undef HAVE_IMAGEINFO_NUMBER_SCENES
 /* Introduced in IM 5.5.7, GM 1.1 */
@@ -176,6 +177,8 @@
 #undef HAVE_THRESHOLDIMAGECHANNEL
 #undef HAVE_THUMBNAILIMAGE
 #undef HAVE_TINTIMAGE
+/* Introduced in IM 6.2.4 */
+#undef HAVE_TRANSPARENTVIRTUALPIXELMETHOD
 /* Introduced in IM 6.0.0 */
 #undef HAVE_UNDEFINEDGRAVITY
 #undef HAVE_UNISTD_H

data/ext/RMagick/rmimage.c

@@ -1,4 +1,4 @@
-/* $Id: rmimage.c,v 1.118 2005/09/07 21:51:45 rmagick Exp $ */
+/* $Id: rmimage.c,v 1.121 2005/09/13 23:37:21 rmagick Exp $ */
 /*============================================================================\
 |                Copyright (C) 2005 by Timothy P. Hunter
 | Name:     rmimage.c
@@ -5335,11 +5335,7 @@ Image_pixel_color(
         HANDLE_ERROR
 
         // PseudoClass
-#if defined(HAVE_IMAGE_STORAGE_CLASS)
         if (image->storage_class == PseudoClass)
-#else
-        if (image->class == PseudoClass)
-#endif
         {
             IndexPacket *indexes = GetIndexes(image);
             old_color = image->colormap[*indexes];
@@ -5360,20 +5356,12 @@ Image_pixel_color(
 
     // Set the color of a pixel. Return previous color.
     // Convert to DirectClass
-#if defined(HAVE_IMAGE_STORAGE_CLASS)
     if (image->storage_class == PseudoClass)
-#else
-    if (image->class == PseudoClass)
-#endif
     {
         SyncImage(image);
         magick_free(image->colormap);
         image->colormap = NULL;
-#if defined(HAVE_IMAGE_STORAGE_CLASS)
         image->storage_class = DirectClass;
-#else
-        image->class = DirectClass;
-#endif
     }
 
     pixel = GetImagePixels(image, x, y, 1, 1);
@@ -7187,11 +7175,7 @@ Image_class_type(VALUE self)
     Image *image;
     Data_Get_Struct(self, Image, image);
 
-#if defined(HAVE_IMAGE_STORAGE_CLASS)
     return ClassType_new(image->storage_class);
-#else
-    return ClassType_new(image->class);
-#endif
 }
 
 /*
@@ -7210,32 +7194,20 @@ Image_class_type_eq(VALUE self, VALUE new_class_type)
     Data_Get_Struct(self, Image, image);
     VALUE_TO_ENUM(new_class_type, class_type, ClassType);
 
-#if defined(HAVE_IMAGE_STORAGE_CLASS)
     if (image->storage_class == PseudoClass && class_type == DirectClass)
-#else
-    if (image->class == PseudoClass && class_type == DirectClass)
-#endif
     {
         SyncImage(image);
         magick_free(image->colormap);
         image->colormap = NULL;
     }
-#if defined(HAVE_IMAGE_STORAGE_CLASS)
     else if (image->storage_class == DirectClass && class_type == PseudoClass)
-#else
-    else if (image->class == DirectClass && class_type == PseudoClass)
-#endif
     {
         GetQuantizeInfo(&qinfo);
         qinfo.number_colors = MaxRGB+1;
         QuantizeImage(&qinfo, image);
     }
 
-#if defined(HAVE_IMAGE_STORAGE_CLASS)
     image->storage_class = class_type;
-#else
-    image->class = class_type;
-#endif
     return self;
 }
 
@@ -7568,6 +7540,43 @@ Image_thumbnail_bang(int argc, VALUE *argv, VALUE self)
     return thumbnail(True, argc, argv, self);
 }
 
+
+/*
+    Method:     Image#ticks_per_second, ticks_per_second=
+    Purpose:    the ticks_per_second attribute accessors
+*/
+VALUE
+Image_ticks_per_second(VALUE self)
+{
+#if defined(HAVE_IMAGE_TICKS_PER_SECOND)
+    Image *image;
+
+    Data_Get_Struct(self, Image, image);
+    return INT2FIX(image->ticks_per_second);
+#else
+    rm_not_implemented();
+    return (VALUE)0;
+#endif
+}
+
+
+VALUE
+Image_ticks_per_second_eq(VALUE self, VALUE tps)
+{
+#if defined(HAVE_IMAGE_TICKS_PER_SECOND)
+    Image *image;
+
+    rm_check_frozen(self);
+    Data_Get_Struct(self, Image, image);
+    image->ticks_per_second = NUM2INT(tps);
+    return self;
+#else
+    rm_not_implemented();
+    return (VALUE)0;
+#endif
+}
+
+
 /*
     Method:     Image#tile_info, tile_info=
     Purpose:    the tile_info attribute accessors
@@ -8056,6 +8065,41 @@ Image_unsharp_mask_channel(int argc, VALUE *argv, VALUE self)
 #endif
 }
 
+
+/*
+  Method:   Image#virtual_pixel_method
+  Purpose:  get the VirtualPixelMethod for the image
+*/
+VALUE
+Image_virtual_pixel_method(VALUE self)
+{
+    Image *image;
+    VirtualPixelMethod vpm;
+
+    Data_Get_Struct(self, Image, image);
+    vpm = GetImageVirtualPixelMethod(image);
+
+    return VirtualPixelMethod_new(vpm);
+}
+
+
+/*
+  Method:   Image#virtual_pixel_method=
+  Purpose:  set the virtual pixel method for the image
+*/
+VALUE
+Image_virtual_pixel_method_eq(VALUE self, VALUE method)
+{
+    Image *image;
+    VirtualPixelMethod vpm;
+
+    rm_check_frozen(self);
+    Data_Get_Struct(self, Image, image);
+    VALUE_TO_ENUM(method, vpm, VirtualPixelMethod);
+    (void) SetImageVirtualPixelMethod(image, vpm);
+    return self;
+}
+
 /*
   Method:   Image#wave(amplitude=25.0, wavelength=150.0)
   Purpose:  creates a "ripple" effect in the image by shifting the pixels

data/ext/RMagick/rmmain.c

@@ -1,4 +1,4 @@
-/* $Id: rmmain.c,v 1.95 2005/09/07 21:51:45 rmagick Exp $ */
+/* $Id: rmmain.c,v 1.97 2005/09/13 23:37:21 rmagick Exp $ */
 /*============================================================================\
 |                Copyright (C) 2005 by Timothy P. Hunter
 | Name:     rmmain.c
@@ -617,9 +617,11 @@ Init_RMagick(void)
     DCL_ATTR_READER(Image, scene)
     DCL_ATTR_ACCESSOR(Image, start_loop)
     DCL_ATTR_ACCESSOR(Image, class_type)
+    DCL_ATTR_ACCESSOR(Image, ticks_per_second)
     DCL_ATTR_ACCESSOR(Image, tile_info)
     DCL_ATTR_READER(Image, total_colors)
     DCL_ATTR_ACCESSOR(Image, units)
+    DCL_ATTR_ACCESSOR(Image, virtual_pixel_method)
     DCL_ATTR_ACCESSOR(Image, x_resolution)
     DCL_ATTR_ACCESSOR(Image, y_resolution)
 
@@ -1461,6 +1463,18 @@ Init_RMagick(void)
         ENUMERATOR(AnyStyle)
     END_ENUM
 
+    // VirtualPixelMethod
+    DEF_ENUM(VirtualPixelMethod)
+        ENUMERATOR(UndefinedVirtualPixelMethod)
+        ENUMERATOR(EdgeVirtualPixelMethod)
+        ENUMERATOR(MirrorVirtualPixelMethod)
+        ENUMERATOR(TileVirtualPixelMethod)
+#if defined(HAVE_TRANSPARENTVIRTUALPIXELMETHOD)
+        ENUMERATOR(BackgroundVirtualPixelMethod)
+        ENUMERATOR(TransparentVirtualPixelMethod)
+#endif
+    END_ENUM
+
     // WeightType constants
     DEF_ENUM(WeightType)
         ENUMERATOR(AnyWeight)
@@ -1558,7 +1572,7 @@ static void version_constants(void)
 
     rb_define_const(Module_Magick, "Version", rb_str_new2(PACKAGE_STRING));
     sprintf(long_version,
-        "This is %s ($Date: 2005/09/07 21:51:45 $) Copyright (C) 2005 by Timothy P. Hunter\n"
+        "This is %s ($Date: 2005/09/13 23:37:21 $) Copyright (C) 2005 by Timothy P. Hunter\n"
         "Built with %s\n"
         "Built for %s\n"
         "Web page: http://rmagick.rubyforge.org\n"

data/ext/RMagick/rmutil.c

@@ -1,4 +1,4 @@
-/* $Id: rmutil.c,v 1.57 2005/09/07 21:51:45 rmagick Exp $ */
+/* $Id: rmutil.c,v 1.59 2005/09/11 16:41:40 rmagick Exp $ */
 /*============================================================================\
 |                Copyright (C) 2005 by Timothy P. Hunter
 | Name:     rmutil.c
@@ -9,8 +9,8 @@
 #include "rmagick.h"
 #include <errno.h>
 
-static const char *Compliance_Const_Name(ComplianceType *);
-static const char *StyleType_Const_Name(StyleType);
+static const char *Compliance_name(ComplianceType *);
+static const char *StyleType_name(StyleType);
 static const char *StretchType_name(StretchType);
 static void Color_Name_to_PixelPacket(PixelPacket *, VALUE);
 static VALUE Enum_type_values(VALUE);
@@ -1070,244 +1070,157 @@ ComplianceType_new(ComplianceType compliance)
 
     // Turn off undefined bits
     compliance &= (SVGCompliance|X11Compliance|XPMCompliance);
-    name = Compliance_Const_Name(&compliance);
+    name = Compliance_name(&compliance);
     return rm_enum_new(Class_ComplianceType, ID2SYM(rb_intern(name)), INT2FIX(compliance));
 }
 
 
 /*
-   External:    CompositeOperator_new
-   Purpose:     Construct a CompositeOperator enum object for the specified value
+    Static:     CompositeOperator_new
+    Purpose:    return the name of a CompositeOperator enum as a string
 */
-VALUE
-CompositeOperator_new(CompositeOperator op)
+static const char *
+CompositeOperator_name(CompositeOperator op)
 {
-    const char *name;
-
     switch (op)
     {
         default:
-        case UndefinedCompositeOp:
-            name = "UndefinedCompositeOp";
-            break;
-        case NoCompositeOp:
-            name = "NoCompositeOp";
-            break;
-        case AddCompositeOp:
-            name = "AddCompositeOp";
-            break;
-        case AtopCompositeOp:
-            name = "AtopCompositeOp";
-            break;
-        case BumpmapCompositeOp:
-            name = "BumpmapCompositeOp";
-            break;
-        case ClearCompositeOp:
-            name = "ClearCompositeOp";
-            break;
+        ENUM_TO_NAME(UndefinedCompositeOp)
+        ENUM_TO_NAME(NoCompositeOp)
+        ENUM_TO_NAME(AddCompositeOp)
+        ENUM_TO_NAME(AtopCompositeOp)
+        ENUM_TO_NAME(BumpmapCompositeOp)
+        ENUM_TO_NAME(ClearCompositeOp)
 #if defined(HAVE_COLORDODGECOMPOSITEOP)
-        case ColorBurnCompositeOp:
-            name = "ColorBurnCompositeOp";
-            break;
-        case BlendCompositeOp:
-            name = "BlendCompositeOp";
-            break;
-        case ColorDodgeCompositeOp:
-            name = "ColorDodgeCompositeOp";
-            break;
-        case ExclusionCompositeOp:
-            name = "ExclusionCompositeOp";
-            break;
-        case HardLightCompositeOp:
-            name = "HardLightCompositeOp";
-            break;
-        case SoftLightCompositeOp:
-            name = "SoftLightCompositeOp";
-            break;
+        ENUM_TO_NAME(ColorBurnCompositeOp)
+        ENUM_TO_NAME(BlendCompositeOp)
+        ENUM_TO_NAME(ColorDodgeCompositeOp)
+        ENUM_TO_NAME(ExclusionCompositeOp)
+        ENUM_TO_NAME(HardLightCompositeOp)
+        ENUM_TO_NAME(SoftLightCompositeOp)
 #endif
-        case ColorizeCompositeOp:
-            name = "ColorizeCompositeOp";
-            break;
-        case CopyBlueCompositeOp:
-            name = "CopyBlueCompositeOp";
-            break;
-        case CopyCompositeOp:
-            name = "CopyCompositeOp";
-            break;
+        ENUM_TO_NAME(ColorizeCompositeOp)
+        ENUM_TO_NAME(CopyBlueCompositeOp)
+        ENUM_TO_NAME(CopyCompositeOp)
 #if defined(HAVE_COPYCYANCOMPOSITEOP)   // CYMK added 5.5.7
-        case CopyCyanCompositeOp:
-            name = "CopyCyanCompositeOp";
-            break;
-        case CopyMagentaCompositeOp:
-            name = "CopyMagentaCompositeOp";
-            break;
-        case CopyYellowCompositeOp:
-            name = "CopyYellowCompositeOp";
-            break;
-        case CopyBlackCompositeOp:
-            name = "CopyBlackCompositeOp";
-            break;
+        ENUM_TO_NAME(CopyCyanCompositeOp)
+        ENUM_TO_NAME(CopyMagentaCompositeOp)
+        ENUM_TO_NAME(CopyYellowCompositeOp)
+        ENUM_TO_NAME(CopyBlackCompositeOp)
 #endif
-        case CopyGreenCompositeOp:
-            name = "CopyGreenCompositeOp";
-            break;
-        case CopyOpacityCompositeOp:
-            name = "CopyOpacityCompositeOp";
-            break;
-        case CopyRedCompositeOp:
-            name = "CopyRedCompositeOp";
-            break;
-        case DarkenCompositeOp:
-            name = "DarkenCompositeOp";
-            break;
+        ENUM_TO_NAME(CopyGreenCompositeOp)
+        ENUM_TO_NAME(CopyOpacityCompositeOp)
+        ENUM_TO_NAME(CopyRedCompositeOp)
+        ENUM_TO_NAME(DarkenCompositeOp)
 #if defined(HAVE_DSTCOMPOSITEOP)
-        case DstAtopCompositeOp:
-            name = "DstAtopCompositeOp";
-            break;
-        case DstCompositeOp:
-            name = "DstCompositeOp";
-            break;
-        case DstInCompositeOp:
-            name = "DstInCompositeOp";
-            break;
-        case DstOutCompositeOp:
-            name = "DstOutCompositeOp";
-            break;
-        case DstOverCompositeOp:
-            name = "DstOverCompositeOp";
-            break;
+        ENUM_TO_NAME(DstAtopCompositeOp)
+        ENUM_TO_NAME(DstCompositeOp)
+        ENUM_TO_NAME(DstInCompositeOp)
+        ENUM_TO_NAME(DstOutCompositeOp)
+        ENUM_TO_NAME(DstOverCompositeOp)
 #endif
-        case DifferenceCompositeOp:
-            name = "DifferenceCompositeOp";
-            break;
-        case DisplaceCompositeOp:
-            name = "DisplaceCompositeOp";
-            break;
-        case DissolveCompositeOp:
-            name = "DissolveCompositeOp";
-            break;
-        case HueCompositeOp:
-            name = "HueCompositeOp";
-            break;
-        case InCompositeOp:
-            name = "InCompositeOp";
-            break;
-        case LightenCompositeOp:
-            name = "LightenCompositeOp";
-            break;
-        case LuminizeCompositeOp:
-            name = "LuminizeCompositeOp";
-            break;
-        case MinusCompositeOp:
-            name = "MinusCompositeOp";
-            break;
-        case ModulateCompositeOp:
-            name = "ModulateCompositeOp";
-            break;
-        case MultiplyCompositeOp:
-            name = "MultiplyCompositeOp";
-            break;
-        case OutCompositeOp:
-            name = "OutCompositeOp";
-            break;
-        case OverCompositeOp:
-            name = "OverCompositeOp";
-            break;
-        case OverlayCompositeOp:
-            name = "OverlayCompositeOp";
-            break;
-        case PlusCompositeOp:
-            name = "PlusCompositeOp";
-            break;
+        ENUM_TO_NAME(DifferenceCompositeOp)
+        ENUM_TO_NAME(DisplaceCompositeOp)
+        ENUM_TO_NAME(DissolveCompositeOp)
+        ENUM_TO_NAME(HueCompositeOp)
+        ENUM_TO_NAME(InCompositeOp)
+        ENUM_TO_NAME(LightenCompositeOp)
+        ENUM_TO_NAME(LuminizeCompositeOp)
+        ENUM_TO_NAME(MinusCompositeOp)
+        ENUM_TO_NAME(ModulateCompositeOp)
+        ENUM_TO_NAME(MultiplyCompositeOp)
+        ENUM_TO_NAME(OutCompositeOp)
+        ENUM_TO_NAME(OverCompositeOp)
+        ENUM_TO_NAME(OverlayCompositeOp)
+        ENUM_TO_NAME(PlusCompositeOp)
 #if defined(HAVE_REPLACECOMPOSITEOP)    // Added 5.5.8
-        case ReplaceCompositeOp:
-            name = "ReplaceCompositeOp";
-            break;
+        ENUM_TO_NAME(ReplaceCompositeOp)
 #endif
-        case SaturateCompositeOp:
-            name = "SaturateCompositeOp";
-            break;
-        case ScreenCompositeOp:
-            name = "ScreenCompositeOp";
-            break;
+        ENUM_TO_NAME(SaturateCompositeOp)
+        ENUM_TO_NAME(ScreenCompositeOp)
 #if defined(HAVE_DSTCOMPOSITEOP)
-        case SrcAtopCompositeOp:
-            name = "SrcAtopCompositeOp";
-            break;
-        case SrcCompositeOp:
-            name = "SrcCompositeOp";
-            break;
-        case SrcInCompositeOp:
-            name = "SrcInCompositeOp";
-            break;
-        case SrcOutCompositeOp:
-            name = "SrcOutCompositeOp";
-            break;
-        case SrcOverCompositeOp:
-            name = "SrcOverCompositeOp";
-            break;
+        ENUM_TO_NAME(SrcAtopCompositeOp)
+        ENUM_TO_NAME(SrcCompositeOp)
+        ENUM_TO_NAME(SrcInCompositeOp)
+        ENUM_TO_NAME(SrcOutCompositeOp)
+        ENUM_TO_NAME(SrcOverCompositeOp)
 #endif
-        case SubtractCompositeOp:
-            name = "SubtractCompositeOp";
-            break;
-        case ThresholdCompositeOp:
-            name = "ThresholdCompositeOp";
-            break;
-        case XorCompositeOp:
-            name = "XorCompositeOp";
-            break;
+        ENUM_TO_NAME(SubtractCompositeOp)
+        ENUM_TO_NAME(ThresholdCompositeOp)
+        ENUM_TO_NAME(XorCompositeOp)
     }
+}
 
+/*
+   External:    CompositeOperator_new
+   Purpose:     Construct a CompositeOperator enum object for the specified value
+*/
+VALUE
+CompositeOperator_new(CompositeOperator op)
+{
+    const char *name;
+
+    name = CompositeOperator_name(op);
     return rm_enum_new(Class_CompositeOperator, ID2SYM(rb_intern(name)), INT2FIX(op));
 }
 
+
+/*
+    Static:     CompressionType_name
+    Purpose:    Return the name of a CompressionType enum as a string
+*/
+static const char *
+CompressionType_name(CompressionType ct)
+{
+    switch (ct)
+    {
+        default:
+        ENUM_TO_NAME(UndefinedCompression)
+        ENUM_TO_NAME(NoCompression)
+        ENUM_TO_NAME(BZipCompression)
+        ENUM_TO_NAME(FaxCompression)
+        ENUM_TO_NAME(Group4Compression)
+        ENUM_TO_NAME(JPEGCompression)
+        ENUM_TO_NAME(LosslessJPEGCompression)
+        ENUM_TO_NAME(LZWCompression)
+        ENUM_TO_NAME(RLECompression)
+        ENUM_TO_NAME(ZipCompression)
+    }
+}
+
+
 /*
  * External:    CompressionType_new
-   Purpose:     Construct a CompressionTYpe enum object for the specified value
+   Purpose:     Construct a CompressionType enum object for the specified value
 */
 VALUE
 CompressionType_new(CompressionType ct)
 {
     const char *name;
 
-    switch (ct)
+    name = CompressionType_name(ct);
+    return rm_enum_new(Class_CompressionType, ID2SYM(rb_intern(name)), INT2FIX(ct));
+}
+
+
+/*
+    Static:     DisposeType_name
+    Purpose:    Return the name of a DisposeType enum as a string
+*/
+static const char *
+DisposeType_name(type)
+{
+    switch(type)
     {
         default:
-        case UndefinedCompression:
-            name = "UndefinedCompression";
-            break;
-        case NoCompression:
-            name = "NoCompression";
-            break;
-        case BZipCompression:
-            name = "BZipCompression";
-            break;
-        case FaxCompression:
-            name = "FaxCompression";
-            break;
-        case Group4Compression:
-            name = "Group4Compression";
-            break;
-        case JPEGCompression:
-            name = "JPEGCompression";
-            break;
-        case LosslessJPEGCompression:
-            name = "LosslessJPEGCompression";
-            break;
-        case LZWCompression:
-            name = "LZWCompression";
-            break;
-        case RLECompression:
-            name = "RLECompression";
-            break;
-        case ZipCompression:
-            name = "ZipCompression";
-            break;
+        ENUM_TO_NAME(UndefinedDispose)
+        ENUM_TO_NAME(BackgroundDispose)
+        ENUM_TO_NAME(NoneDispose)
+        ENUM_TO_NAME(PreviousDispose)
     }
-
-    return rm_enum_new(Class_CompressionType, ID2SYM(rb_intern(name)), INT2FIX(ct));
 }
 
+
 /*
     External:   DisposeType.new
     Purpose:    Construct a DisposeType enum object for the specified value..new
@@ -1317,26 +1230,41 @@ DisposeType_new(DisposeType type)
 {
     const char *name;
 
+    name = DisposeType_name(type);
+    return rm_enum_new(Class_DisposeType, ID2SYM(rb_intern(name)), INT2FIX(type));
+}
+
+
+/*
+    Static:     FilterTypes_name
+    Purpose:    Return the name of a FilterTypes enum as a string
+*/
+static const char *
+FilterTypes_name(FilterTypes type)
+{
     switch(type)
     {
         default:
-        case UndefinedDispose:
-            name = "UndefinedDispose";
-            break;
-        case BackgroundDispose:
-            name = "BackgroundDispose";
-            break;
-        case NoneDispose:
-            name = "NoneDispose";
-            break;
-        case PreviousDispose:
-            name = "PreviousDispose";
-            break;
+        ENUM_TO_NAME(UndefinedFilter)
+        ENUM_TO_NAME(PointFilter)
+        ENUM_TO_NAME(BoxFilter)
+        ENUM_TO_NAME(TriangleFilter)
+        ENUM_TO_NAME(HermiteFilter)
+        ENUM_TO_NAME(HanningFilter)
+        ENUM_TO_NAME(HammingFilter)
+        ENUM_TO_NAME(BlackmanFilter)
+        ENUM_TO_NAME(GaussianFilter)
+        ENUM_TO_NAME(QuadraticFilter)
+        ENUM_TO_NAME(CubicFilter)
+        ENUM_TO_NAME(CatromFilter)
+        ENUM_TO_NAME(MitchellFilter)
+        ENUM_TO_NAME(LanczosFilter)
+        ENUM_TO_NAME(BesselFilter)
+        ENUM_TO_NAME(SincFilter)
     }
-
-    return rm_enum_new(Class_DisposeType, ID2SYM(rb_intern(name)), INT2FIX(type));
 }
 
+
 /*
     External:  FilterTypes.new
     Purpose: Construct an FilterTypes enum object for the specified value
@@ -1346,64 +1274,28 @@ FilterTypes_new(FilterTypes type)
 {
     const char *name;
 
+    name = FilterTypes_name(type);
+    return rm_enum_new(Class_FilterTypes, ID2SYM(rb_intern(name)), INT2FIX(type));
+}
+
+
+
+/*
+    Static:     EndianType_name
+    Purpose:    Return the name of a EndianType enum as a string
+*/
+static const char *
+EndianType_name(type)
+{
     switch(type)
     {
         default:
-        case UndefinedFilter:
-            name = "UndefinedFilter";
-            break;
-        case PointFilter:
-            name = "PointFilter";
-            break;
-        case BoxFilter:
-            name = "BoxFilter";
-            break;
-        case TriangleFilter:
-            name = "TriangleFilter";
-            break;
-        case HermiteFilter:
-            name = "HermiteFilter";
-            break;
-        case HanningFilter:
-            name = "HanningFilter";
-            break;
-        case HammingFilter:
-            name = "HammingFilter";
-            break;
-        case BlackmanFilter:
-            name = "BlackmanFilter";
-            break;
-        case GaussianFilter:
-            name = "GaussianFilter";
-            break;
-        case QuadraticFilter:
-            name = "QuadraticFilter";
-            break;
-        case CubicFilter:
-            name = "CubicFilter";
-            break;
-        case CatromFilter:
-            name = "CatromFilter";
-            break;
-        case MitchellFilter:
-            name = "MitchellFilter";
-            break;
-        case LanczosFilter:
-            name = "LanczosFilter";
-            break;
-        case BesselFilter:
-            name = "BesselFilter";
-            break;
-        case SincFilter:
-            name = "SincFilter";
-            break;
-
+        ENUM_TO_NAME(UndefinedEndian)
+        ENUM_TO_NAME(LSBEndian)
+        ENUM_TO_NAME(MSBEndian)
     }
-    return rm_enum_new(Class_FilterTypes, ID2SYM(rb_intern(name)), INT2FIX(type));
 }
 
-
-
 /*
     External:   EndianType.new
     Purpose:    Construct an EndianType enum object
@@ -1413,21 +1305,34 @@ EndianType_new(EndianType type)
 {
     const char *name;
 
-    switch(type)
+    name = EndianType_name(type);
+    return rm_enum_new(Class_EndianType, ID2SYM(rb_intern(name)), INT2FIX(type));
+}
+
+
+
+/*
+    Static:     ImageType_name
+    Purpose:    Return the name of a ImageType enum as a string
+*/
+static char *
+ImageType_name(type)
+{    switch(type)
     {
         default:
-        case UndefinedEndian:
-            name = "UndefinedEndian";
-            break;
-        case LSBEndian:
-            name = "LSBEndian";
-            break;
-        case MSBEndian:
-            name = "MSBEndian";
-            break;
+        ENUM_TO_NAME(UndefinedType)
+        ENUM_TO_NAME(BilevelType)
+        ENUM_TO_NAME(GrayscaleType)
+        ENUM_TO_NAME(GrayscaleMatteType)
+        ENUM_TO_NAME(PaletteType)
+        ENUM_TO_NAME(PaletteMatteType)
+        ENUM_TO_NAME(TrueColorType)
+        ENUM_TO_NAME(TrueColorMatteType)
+        ENUM_TO_NAME(ColorSeparationType)
+        ENUM_TO_NAME(ColorSeparationMatteType)
+        ENUM_TO_NAME(OptimizeType)
     }
 
-    return rm_enum_new(Class_EndianType, ID2SYM(rb_intern(name)), INT2FIX(type));
 }
 
 
@@ -1440,47 +1345,30 @@ ImageType_new(ImageType type)
 {
     const char *name;
 
-    switch(type)
+    name = ImageType_name(type);
+    return rm_enum_new(Class_ImageType, ID2SYM(rb_intern(name)), INT2FIX(type));
+}
+
+
+/*
+    Static:     InterlaceType_name
+    Purpose:    Return the name of a InterlaceType enum as a string
+*/
+static const char *
+InterlaceType_name(interlace)
+{
+    switch(interlace)
     {
         default:
-        case UndefinedType:
-            name = "UndefinedType";
-            break;
-        case BilevelType:
-            name = "BilevelType";
-            break;
-        case GrayscaleType:
-            name = "GrayscaleType";
-            break;
-        case GrayscaleMatteType:
-            name = "GrayscaleMatteType";
-            break;
-        case PaletteType:
-            name = "PaletteType";
-            break;
-        case PaletteMatteType:
-            name = "PaletteMatteType";
-            break;
-        case TrueColorType:
-            name = "TrueColorType";
-            break;
-        case TrueColorMatteType:
-            name = "TrueColorMatteType";
-            break;
-        case ColorSeparationType:
-            name = "ColorSeparationType";
-            break;
-        case ColorSeparationMatteType:
-            name = "ColorSeparationMatteType";
-            break;
-        case OptimizeType:
-            name = "OptimizeType";
-            break;
+        ENUM_TO_NAME(UndefinedInterlace)
+        ENUM_TO_NAME(NoInterlace)
+        ENUM_TO_NAME(LineInterlace)
+        ENUM_TO_NAME(PlaneInterlace)
+        ENUM_TO_NAME(PartitionInterlace)
     }
-
-    return rm_enum_new(Class_ImageType, ID2SYM(rb_intern(name)), INT2FIX(type));
 }
 
+
 /*
     External:   InterlaceType_new
     Purpose:    Construct an InterlaceType enum object for the specified value.
@@ -1490,29 +1378,33 @@ InterlaceType_new(InterlaceType interlace)
 {
     const char *name;
 
-    switch(interlace)
+    name = InterlaceType_name(interlace);
+    return rm_enum_new(Class_InterlaceType, ID2SYM(rb_intern(name)), INT2FIX(interlace));
+}
+
+
+
+/*
+    Static:     RenderingIntent_name
+    Purpose:    Return the name of a RenderingIntent enum as a string
+*/
+static const char *
+RenderingIntent_name(intent)
+{
+    switch(intent)
     {
         default:
-        case UndefinedInterlace:
-            name = "UndefinedInterlace";
-            break;
-        case NoInterlace:
-            name = "NoInterlace";
-            break;
-        case LineInterlace:
-            name = "LineInterlace";
-            break;
-        case PlaneInterlace:
-            name = "PlaneInterlace";
-            break;
-        case PartitionInterlace:
-            name = "PartitionInterlace";
-            break;
+        ENUM_TO_NAME(UndefinedIntent)
+        ENUM_TO_NAME(SaturationIntent)
+        ENUM_TO_NAME(PerceptualIntent)
+        ENUM_TO_NAME(AbsoluteIntent)
+        ENUM_TO_NAME(RelativeIntent)
     }
 
-    return rm_enum_new(Class_InterlaceType, ID2SYM(rb_intern(name)), INT2FIX(interlace));
 }
 
+
+
 /*
     External:   RenderingIntent_new
     Purpose:    Construct an RenderingIntent enum object for the specified value.
@@ -1522,29 +1414,29 @@ RenderingIntent_new(RenderingIntent intent)
 {
     const char *name;
 
-    switch(intent)
+    name = RenderingIntent_name(intent);
+    return rm_enum_new(Class_RenderingIntent, ID2SYM(rb_intern(name)), INT2FIX(intent));
+}
+
+
+/*
+    Static:     ResolutionType_name
+    Purpose:    Return the name of a ResolutionType enum as a string
+*/
+static const char *
+ResolutionType_name(type)
+{
+    switch(type)
     {
         default:
-        case UndefinedIntent:
-            name = "UndefinedIntent";
-            break;
-        case SaturationIntent:
-            name = "SaturationIntent";
-            break;
-        case PerceptualIntent:
-            name = "PerceptualIntent";
-            break;
-        case AbsoluteIntent:
-            name = "AbsoluteIntent";
-            break;
-        case RelativeIntent:
-            name = "RelativeIntent";
-            break;
+        ENUM_TO_NAME(UndefinedResolution)
+        ENUM_TO_NAME(PixelsPerInchResolution)
+        ENUM_TO_NAME(PixelsPerCentimeterResolution)
     }
 
-    return rm_enum_new(Class_RenderingIntent, ID2SYM(rb_intern(name)), INT2FIX(intent));
 }
 
+
 /*
     External:   ResolutionType_new
     Purpose:    Construct an ResolutionType enum object for the specified value.
@@ -1554,66 +1446,51 @@ ResolutionType_new(ResolutionType type)
 {
     const char *name;
 
+    name = ResolutionType_name(type);
+    return rm_enum_new(Class_ResolutionType, ID2SYM(rb_intern(name)), INT2FIX(type));
+}
+
+
+
+#if defined(HAVE_IMAGE_ORIENTATION)
+/*
+    Static:     OrientationType_name
+    Purpose:    Return the name of a OrientationType enum as a string
+*/
+static const char *
+OrientationType_name(type)
+{
     switch(type)
     {
         default:
-        case UndefinedResolution:
-            name = "UndefinedResolution";
-            break;
-        case PixelsPerInchResolution:
-            name = "PixelsPerInchResolution";
-            break;
-        case PixelsPerCentimeterResolution:
-            name = "PixelsPerCentimeterResolution";
-            break;
+        ENUM_TO_NAME(UndefinedOrientation)
+        ENUM_TO_NAME(TopLeftOrientation)
+        ENUM_TO_NAME(TopRightOrientation)
+        ENUM_TO_NAME(BottomRightOrientation)
+        ENUM_TO_NAME(BottomLeftOrientation)
+        ENUM_TO_NAME(LeftTopOrientation)
+        ENUM_TO_NAME(RightTopOrientation)
+        ENUM_TO_NAME(RightBottomOrientation)
+        ENUM_TO_NAME(LeftBottomOrientation)
     }
-    return rm_enum_new(Class_ResolutionType, ID2SYM(rb_intern(name)), INT2FIX(type));
 }
 
+
 /*
     External:   OrientationType_new
     Purpose:    Construct an OrientationType enum object for the specified value.
 */
-#if defined(HAVE_IMAGE_ORIENTATION)
 VALUE
 OrientationType_new(OrientationType type)
 {
     const char *name;
 
-    switch(type)
-    {
-        default:
-        case UndefinedOrientation:
-            name = "UndefinedOrientation";
-            break;
-        case TopLeftOrientation:
-            name = "TopLeftOrientation";
-            break;
-        case TopRightOrientation:
-            name = "TopRightOrientation";
-            break;
-        case BottomRightOrientation:
-            name = "BottomRightOrientation";
-            break;
-        case BottomLeftOrientation:
-            name = "BottomLeftOrientation";
-            break;
-        case LeftTopOrientation:
-            name = "LeftTopOrientation";
-            break;
-        case RightTopOrientation:
-            name = "RightTopOrientation";
-            break;
-        case RightBottomOrientation:
-            name = "RightBottomOrientation";
-            break;
-        case LeftBottomOrientation:
-            name = "LeftBottomOrientation";
-            break;
-    }
+    name = OrientationType_name(type);
     return rm_enum_new(Class_OrientationType, ID2SYM(rb_intern(name)), INT2FIX(type));
 }
 #endif
+
+
 /*
     External:   Color_from_ColorInfo
     Purpose:    Convert a ColorInfo structure to a Magick::Color
@@ -1700,7 +1577,7 @@ Color_to_s(VALUE self)
     sprintf(buff, "name=%s, compliance=%s, "
                   "color.red=%d, color.green=%d, color.blue=%d, color.opacity=%d ",
                   ci.name,
-                  Compliance_Const_Name(&ci.compliance),
+                  Compliance_name(&ci.compliance),
                   ci.color.red, ci.color.green, ci.color.blue, ci.color.opacity);
 
     destroy_ColorInfo(&ci);
@@ -2018,7 +1895,7 @@ StyleType_new(StyleType style)
 {
     const char *name;
 
-    name = StyleType_Const_Name(style);
+    name = StyleType_name(style);
     return rm_enum_new(Class_StyleType, ID2SYM(rb_intern(name)), INT2FIX(style));
 }
 
@@ -2150,7 +2027,7 @@ Font_to_s(VALUE self)
                   ti.name,
                   ti.description,
                   ti.family,
-                  StyleType_Const_Name(ti.style),
+                  StyleType_name(ti.style),
                   StretchType_name(ti.stretch),
                   weight,
                   ti.encoding ? ti.encoding : "",
@@ -2253,6 +2130,43 @@ TypeMetric_to_s(VALUE self)
 }
 
 
+
+/*
+    Static:     VirtualPixelMethod_name
+    Purpose:    Return the string representation of a VirtualPixelMethod value
+*/
+static const char *
+VirtualPixelMethod_name(VirtualPixelMethod method)
+{
+    switch (method)
+    {
+        default:
+        ENUM_TO_NAME(UndefinedVirtualPixelMethod)
+        ENUM_TO_NAME(EdgeVirtualPixelMethod)
+        ENUM_TO_NAME(MirrorVirtualPixelMethod)
+        ENUM_TO_NAME(TileVirtualPixelMethod)
+#if defined(HAVE_TRANSPARENTVIRTUALPIXELMETHOD)
+        ENUM_TO_NAME(TransparentVirtualPixelMethod)
+        ENUM_TO_NAME(BackgroundVirtualPixelMethod)
+#endif
+    }
+}
+
+
+/*
+    Static:     VirtualPixelMethod_new
+    Purpose:    Construct a VirtualPixelMethod enum for a specified VirtualPixelMethod value
+*/
+VALUE
+VirtualPixelMethod_new(VirtualPixelMethod style)
+{
+    const char *name;
+
+    name = VirtualPixelMethod_name(style);
+    return rm_enum_new(Class_VirtualPixelMethod, ID2SYM(rb_intern(name)), INT2FIX(style));
+}
+
+
 /*
  *  Extern:     rm_define_enum_type
  *  Purpose:    set up a subclass of Enum
@@ -2483,14 +2397,14 @@ static VALUE Enum_type_values(VALUE class)
 
 
 /*
-    Static:     Compliance_Const_Name
+    Static:     Compliance_name
     Purpose:    Return the string representation of a ComplianceType value
     Notes:      xMagick will OR multiple compliance types so we have to
                 arbitrarily pick one name. Set the compliance argument
                 to the selected value.
 */
 static const char *
-Compliance_Const_Name(ComplianceType *c)
+Compliance_name(ComplianceType *c)
 {
     if ((*c & (SVGCompliance|X11Compliance|XPMCompliance))
         == (SVGCompliance|X11Compliance|XPMCompliance))
@@ -2588,40 +2502,20 @@ Statistics_new(ImageStatistics *stats)
 const char *
 StorageType_name(StorageType type)
 {
-    const char *name;
-
     switch (type)
     {
         default:
-        case UndefinedPixel:
-            name = "UndefinedPixel";
-            break;
-        case CharPixel:
-            name = "CharPixel";
-            break;
-        case DoublePixel:
-            name = "DoublePixel";
-            break;
-        case FloatPixel:
-            name = "FloatPixel";
-            break;
-        case IntegerPixel:
-            name = "IntegerPixel";
-            break;
-        case LongPixel:
-            name = "LongPixel";
-            break;
+        ENUM_TO_NAME(UndefinedPixel)
+        ENUM_TO_NAME(CharPixel)
+        ENUM_TO_NAME(DoublePixel)
+        ENUM_TO_NAME(FloatPixel)
+        ENUM_TO_NAME(IntegerPixel)
+        ENUM_TO_NAME(LongPixel)
 #if defined(HAVE_QUANTUMPIXEL)
-        case QuantumPixel:
-            name = "QuantumPixel";
-            break;
+        ENUM_TO_NAME(QuantumPixel)
 #endif
-        case ShortPixel:
-            name = "ShortPixel";
-            break;
+        ENUM_TO_NAME(ShortPixel)
     }
-
-    return name;
 }
 
 /*
@@ -2633,51 +2527,37 @@ StretchType_name(StretchType stretch)
 {
     switch (stretch)
     {
-        case NormalStretch:
-            return "NormalStretch";
-        case UltraCondensedStretch:
-            return "UltraCondensedStretch";
-        case ExtraCondensedStretch:
-            return "ExtraCondensedStretch";
-        case CondensedStretch:
-            return "CondensedStretch";
-        case SemiCondensedStretch:
-            return "SemiCondensedStretch";
-        case SemiExpandedStretch:
-            return "SemiExpandedStretch";
-        case ExpandedStretch:
-            return "ExpandedStretch";
-        case ExtraExpandedStretch:
-            return "ExtraExpandedStretch";
-        case UltraExpandedStretch:
-            return "UltraExpandedStretch";
-        case AnyStretch:
-            return "AnyStretch";
         default:
-            return "unknown";
+        ENUM_TO_NAME(UndefinedStretch)
+        ENUM_TO_NAME(NormalStretch)
+        ENUM_TO_NAME(UltraCondensedStretch)
+        ENUM_TO_NAME(ExtraCondensedStretch)
+        ENUM_TO_NAME(CondensedStretch)
+        ENUM_TO_NAME(SemiCondensedStretch)
+        ENUM_TO_NAME(SemiExpandedStretch)
+        ENUM_TO_NAME(ExpandedStretch)
+        ENUM_TO_NAME(ExtraExpandedStretch)
+        ENUM_TO_NAME(UltraExpandedStretch)
+        ENUM_TO_NAME(AnyStretch)
     }
 }
 
 
 /*
-    Static:     StyleType_Const_Name
+    Static:     StyleType_name
     Purpose:    Return the string representation of a StyleType value
 */
 static const char *
-StyleType_Const_Name(StyleType style)
+StyleType_name(StyleType style)
 {
     switch (style)
     {
-        case NormalStyle:
-            return "NormalStyle";
-        case ItalicStyle:
-            return "ItalicStyle";
-        case ObliqueStyle:
-            return "ObliqueStyle";
-        case AnyStyle:
-            return "AnyStyle";
+        ENUM_TO_NAME(NormalStyle)
+        ENUM_TO_NAME(ItalicStyle)
+        ENUM_TO_NAME(ObliqueStyle)
+        ENUM_TO_NAME(AnyStyle)
         default:
-            return "unknown";
+        ENUM_TO_NAME(UndefinedStyle)
     }
 }
 
@@ -2940,12 +2820,12 @@ rm_handle_error(ExceptionInfo *ex)
     if (ex->reason)
     {
         strncpy(reason, ex->reason, RM_MAX_ERROR_CLAUSE);
-        reason[250] = '\0';
+        reason[RM_MAX_ERROR_CLAUSE] = '\0';
     }
     if (ex->description)
     {
         strncpy(desc, ex->description, RM_MAX_ERROR_CLAUSE);
-        desc[250] = '\0';
+        desc[RM_MAX_ERROR_CLAUSE] = '\0';
     }
 
 #if defined(HAVE_EXCEPTIONINFO_MODULE)
@@ -2955,12 +2835,12 @@ rm_handle_error(ExceptionInfo *ex)
     if (ex->module)
     {
         strncpy(module, ex->module, RM_MAX_ERROR_CLAUSE);
-        module[250] = '\0';
+        module[RM_MAX_ERROR_CLAUSE] = '\0';
     }
     if (ex->function)
     {
         strncpy(function, ex->function, RM_MAX_ERROR_CLAUSE);
-        function[250] = '\0';
+        function[RM_MAX_ERROR_CLAUSE] = '\0';
     }
     line = ex->line;
 #endif