rmagick 1.9.0 → 1.9.1

data/ext/RMagick/MANIFEST

@@ -1,4 +1,4 @@
-MANIFEST for RMagick-1.9.0 - 18:03:12 07/15/05
+MANIFEST for RMagick-1.9.1 - 18:06:01 09/07/05
 
 configure
 README.html
@@ -23,6 +23,7 @@ examples/rotating_text.rb
 examples/pattern_fill.rb
 examples/import_export.rb
 examples/image_opacity.rb
+examples/identify.rb
 examples/histogram.rb
 examples/describe.rb
 uninstall.rb
@@ -134,7 +135,6 @@ doc/ex/rectangle.rb
 doc/ex/rect02.rb
 doc/ex/rect01.rb
 doc/ex/random_threshold_channel.rb
-doc/ex/random_channel_threshold.rb
 doc/ex/raise.rb
 doc/ex/radial_blur.rb
 doc/ex/quantize-m.rb
@@ -219,7 +219,6 @@ doc/ex/circle01.rb
 doc/ex/circle.rb
 doc/ex/chop.rb
 doc/ex/charcoal.rb
-doc/ex/channel_threshold.rb
 doc/ex/channel.rb
 doc/ex/cbezier6.rb
 doc/ex/cbezier5.rb

data/ext/RMagick/rmagick.h

@@ -1,4 +1,4 @@
-/* $Id: rmagick.h,v 1.89 2005/06/19 20:26:34 rmagick Exp $ */
+/* $Id: rmagick.h,v 1.92 2005/09/05 20:27:27 rmagick Exp $ */
 /*=============================================================================
 |               Copyright (C) 2005 by Timothy P. Hunter
 | Name:     rmagick.h
@@ -272,6 +272,7 @@ EXTERN VALUE Class_PaintMethod;
 EXTERN VALUE Class_PreviewType;
 EXTERN VALUE Class_RenderingIntent;
 EXTERN VALUE Class_ResolutionType;
+EXTERN VALUE Class_StorageType;
 EXTERN VALUE Class_StretchType;
 EXTERN VALUE Class_StyleType;
 EXTERN VALUE Class_WeightType;
@@ -774,7 +775,7 @@ extern VALUE Image_get_pixels(VALUE, VALUE, VALUE, VALUE, VALUE);
 extern VALUE Image_gray_q(VALUE);
 extern VALUE Image_grayscale_pseudo_class(int, VALUE *, VALUE);
 extern VALUE Image_implode(int, VALUE *, VALUE);
-extern VALUE Image_import_pixels(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE);
+extern VALUE Image_import_pixels(int, VALUE *, VALUE);
 extern VALUE Image_init_copy(VALUE, VALUE);
 extern VALUE Image_inspect(VALUE);
 extern VALUE Image_level(int, VALUE *, VALUE);
@@ -893,7 +894,9 @@ extern VALUE  Color_to_s(VALUE);
 extern VALUE  Color_from_ColorInfo(const ColorInfo *);
 extern VALUE  ClassType_new(ClassType);
 extern VALUE  ColorspaceType_new(ColorspaceType);
+extern VALUE  CompositeOperator_new(CompositeOperator);
 extern VALUE  CompressionType_new(CompressionType);
+extern VALUE  DisposeType_new(DisposeType);
 extern VALUE  EndianType_new(EndianType);
 extern VALUE  FilterTypes_new(FilterTypes);
 extern VALUE  Font_to_s(VALUE);
@@ -955,6 +958,7 @@ extern VALUE  Statistics_new(ImageStatistics *);
 #if defined(HAVE_IMAGE_ORIENTATION)
 extern VALUE   OrientationType_new(OrientationType);
 #endif
+extern const char *StorageType_name(StorageType);
 
 #if defined(HAVE_RB_DEFINE_ALLOC_FUNC)
 extern VALUE  Enum_alloc(VALUE);

data/ext/RMagick/rmagick_config.h.in

@@ -81,6 +81,7 @@
 #undef HAVE_GETMULTILINETYPEMETRICS
 /* API changed in IM 6.1.3 */
 #undef HAVE_OLD_GETMAGICKINFOLIST
+#undef HAVE_GETNEXTIMAGEATTRIBUTE
 #undef HAVE_GETNEXTIMAGEINLIST
 /* Introduced in IM 6.0.0 */
 #undef HAVE_GETNEXTIMAGEPROFILE
@@ -88,6 +89,7 @@
 #undef HAVE_GETTYPEINFOLIST
 /* API changed in IM 6.1.3 */
 #undef HAVE_OLD_GETTYPEINFOLIST
+#undef HAVE_GRAYCHANNEL
 /* Introduced in GM 1.0 */
 #undef HAVE_GRAYSCALEPSEUDOCLASSIMAGE
 /* Introduced in IM 6.0.0 */
@@ -104,6 +106,7 @@
 #undef HAVE_IMAGE_QUALITY
 /* Introduced in IM 6.0.0 */
 #undef HAVE_IMAGE_ORIENTATION
+#undef HAVE_IMAGE_STORAGE_CLASS
 /* Introduced in IM 5.5.6 */
 #undef HAVE_IMAGEINFO_NUMBER_SCENES
 /* Introduced in IM 5.5.7, GM 1.1 */
@@ -136,6 +139,8 @@
 /* Introduced in IM 5.5.1, GM 1.0 */
 #undef HAVE_PREVIEWIMAGE
 #undef HAVE_QUANTUMOPERATORREGIONIMAGE
+/* Introduced in IM 6.2.0 */
+#undef HAVE_QUANTUMPIXEL
 #undef HAVE_RADIALBLURIMAGE
 #undef HAVE_RANDOMCHANNELTHRESHOLDIMAGE
 #undef HAVE_RANDOMTHRESHOLDIMAGECHANNEL

data/ext/RMagick/rmilist.c

@@ -1,4 +1,4 @@
-/* $Id: rmilist.c,v 1.22 2005/03/05 16:18:39 rmagick Exp $ */
+/* $Id: rmilist.c,v 1.25 2005/08/07 21:21:08 rmagick Exp $ */
 /*============================================================================\
 |                Copyright (C) 2005 by Timothy P. Hunter
 | Name:     rmilist.c
@@ -75,8 +75,8 @@ ImageList_append(VALUE self, VALUE stack_arg)
 
     GetExceptionInfo(&exception);
     result = AppendImages(images, stack, &exception);
-    HANDLE_ERROR
     rm_split(images);
+    HANDLE_ERROR
 
     return rm_image_new(result);
 }
@@ -122,8 +122,8 @@ ImageList_coalesce(VALUE self)
 
     GetExceptionInfo(&exception);
     results = CoalesceImages(images, &exception);
-    HANDLE_ERROR
     rm_split(images);
+    HANDLE_ERROR
 
     return rm_imagelist_from_images(results);
 }
@@ -145,8 +145,8 @@ ImageList_deconstruct(VALUE self)
     images = rm_images_from_imagelist(self);
     GetExceptionInfo(&exception);
     new_images = DeconstructImages(images, &exception);
-    HANDLE_ERROR
     rm_split(images);
+    HANDLE_ERROR
 
     return rm_imagelist_from_images(new_images);
 }
@@ -195,8 +195,8 @@ ImageList_flatten_images(VALUE self)
     images = rm_images_from_imagelist(self);
     GetExceptionInfo(&exception);
     new_image = FlattenImages(images, &exception);
-    HANDLE_ERROR
     rm_split(images);
+    HANDLE_ERROR
 
     return rm_image_new(new_image);
 }
@@ -228,8 +228,8 @@ ImageList_map(VALUE self, VALUE map_image, VALUE dither_arg)
     images = rm_images_from_imagelist(self);
     GetExceptionInfo(&exception);
     clone_images = CloneImageList(images, &exception);
-    HANDLE_ERROR
     rm_split(images);
+    HANDLE_ERROR
 
     // Call ImageMagick
     dither = !(dither_arg == Qfalse || dither_arg == Qnil);
@@ -285,8 +285,8 @@ ImageList_montage(VALUE self)
 
     // MontageImage can return more than one image.
     montage_seq = MontageImages(image_list, montage->info, &exception);
-    HANDLE_ERROR
     rm_split(image_list);
+    HANDLE_ERROR
 
     return rm_imagelist_from_images(montage_seq);
 }
@@ -304,13 +304,15 @@ ImageList_morph(VALUE self, VALUE nimages)
 {
     Image *images, *new_images;
     ExceptionInfo exception;
-    unsigned long number_images;
+    long number_images;
 
     if (rm_imagelist_length(self) < 1)
     {
         rb_raise(rb_eArgError, "no images in this image list");
     }
-    number_images = NUM2ULONG(nimages);
+
+    // Use a signed long so we can test for a negative argument.
+    number_images = NUM2LONG(nimages);
     if (number_images <= 0)
     {
         rb_raise(rb_eArgError, "number of intervening images must be > 0");
@@ -318,7 +320,7 @@ ImageList_morph(VALUE self, VALUE nimages)
 
     images = rm_images_from_imagelist(self);
     GetExceptionInfo(&exception);
-    new_images = MorphImages(images, number_images, &exception);
+    new_images = MorphImages(images, (unsigned long)number_images, &exception);
     HANDLE_ERROR
 
     return rm_imagelist_from_images(new_images);
@@ -338,8 +340,8 @@ ImageList_mosaic(VALUE self)
     images = rm_images_from_imagelist(self);
     GetExceptionInfo(&exception);
     new_image = MosaicImages(images, &exception);
-    HANDLE_ERROR
     rm_split(images);
+    HANDLE_ERROR
 
     return rm_image_new(new_image);
 }
@@ -523,8 +525,8 @@ ImageList_quantize(int argc, VALUE *argv, VALUE self)
     GetExceptionInfo(&exception);
     images = rm_images_from_imagelist(self);
     new_images = CloneImageList(images, &exception);
-    HANDLE_ERROR
     rm_split(images);
+    HANDLE_ERROR
 
     QuantizeImages(&quantize_info, new_images);
 
@@ -583,8 +585,8 @@ ImageList_to_blob(VALUE self)
     info->adjoin = True;
     GetExceptionInfo(&exception);
     blob = ImageToBlob(info, images, &length, &exception);
-    HANDLE_ERROR
     rm_split(images);
+    HANDLE_ERROR
 
     return (blob && length) ? rb_str_new(blob, length) : Qnil;
 }
@@ -673,6 +675,7 @@ ImageList_write(VALUE self, VALUE file)
     for (img = images; img; img = GET_NEXT_IMAGE(img))
     {
         (void) WriteImage(info, img);
+        // images will be split before raising an exception
         rm_handle_all_errors(images);
         if (info->adjoin)
         {

data/ext/RMagick/rmimage.c

@@ -1,4 +1,4 @@
-/* $Id: rmimage.c,v 1.99 2005/06/19 20:26:34 rmagick Exp $ */
+/* $Id: rmimage.c,v 1.118 2005/09/07 21:51:45 rmagick Exp $ */
 /*============================================================================\
 |                Copyright (C) 2005 by Timothy P. Hunter
 | Name:     rmimage.c
@@ -239,52 +239,6 @@ Image_aset(VALUE self, VALUE key_arg, VALUE attr_arg)
     return self;
 }
 
-/*
-    Method:     Image#properties [{ |k,v| block }]
-    Purpose:    Traverse the attributes and yield to the block.
-                If no block, return a hash of all the attribute
-                keys & values
-    Notes:      I use the word "properties" to distinguish between
-                these "user-added" attribute strings and Image
-                object attributes.
-*/
-VALUE
-Image_properties(VALUE self)
-{
-    Image *image;
-    const ImageAttribute *attr;
-    volatile VALUE attr_hash;
-
-    Data_Get_Struct(self, Image, image);
-
-    // If block, iterate over attributes
-    if (rb_block_given_p())
-    {
-        volatile VALUE ary = rb_ary_new2(2);
-        for (attr = image->attributes; attr; attr = Next_Attribute)
-        {
-            // Store the next ptr where Image#aset can see it.
-            // The app may decide to delete that attribute.
-            Next_Attribute = attr->next;
-            rb_ary_store(ary, 0, rb_str_new2(attr->key));
-            rb_ary_store(ary, 1, rb_str_new2(attr->value));
-            rb_yield(ary);
-        }
-
-        return self;
-    }
-
-    // otherwise return properties hash
-    else
-    {
-        attr_hash = rb_hash_new();
-        for (attr = image->attributes; attr; attr = attr->next)
-        {
-            rb_hash_aset(attr_hash, rb_str_new2(attr->key), rb_str_new2(attr->value));
-        }
-        return attr_hash;
-    }
-}
 
 /*
     Method:     Image#background_color
@@ -374,9 +328,13 @@ Image_bilevel_channel(int argc, VALUE *argv, VALUE self)
 
     channels = extract_channels(&argc, argv);
 
+    if (argc > 1)
+    {
+        raise_ChannelType_error(argv[argc-1]);
+    }
     if (argc == 0)
     {
-        rb_raise(rb_eArgError, "wrong number of arguments (0 for 1 or more)");
+        rb_raise(rb_eArgError, "no threshold specified");
     }
 
     GetExceptionInfo(&exception);
@@ -396,32 +354,21 @@ Image_bilevel_channel(int argc, VALUE *argv, VALUE self)
 
 
 /*
-    Method:     Image#border_color
-    Purpose:    Return the name of the border color as a String.
+ *  Method:     Image#black_threshold(red_channel [, green_channel
+ *                                    [, blue_channel [, opacity_channel]]]);
+ *  Purpose:    Call BlackThresholdImage
 */
 VALUE
-Image_border_color(VALUE self)
+Image_black_threshold(int argc, VALUE *argv, VALUE self)
 {
-    Image *image;
-
-    Data_Get_Struct(self, Image, image);
-    return PixelPacket_to_Color_Name(image, &image->border_color);
+#if defined(HAVE_BLACKTHRESHOLDIMAGE)
+    return threshold_image(argc, argv, self, BlackThresholdImage);
+#else
+    rm_not_implemented();
+    return (VALUE)0;
+#endif
 }
 
-/*
-    Method:     Image#border_color=
-    Purpose:    Set the the border color
-*/
-VALUE
-Image_border_color_eq(VALUE self, VALUE color)
-{
-    Image *image;
-
-    rm_check_frozen(self);
-    Data_Get_Struct(self, Image, image);
-    Color_to_PixelPacket(&image->border_color, color);
-    return self;
-}
 
 DEF_ATTR_ACCESSOR(Image, blur, dbl)
 
@@ -467,6 +414,7 @@ Image_blur_channel(int argc, VALUE *argv, VALUE self)
 #endif
 }
 
+
 /*
     Method:     Image#blur_image(radius=0.0, sigma=1.0)
     Purpose:    Blur the image
@@ -478,6 +426,7 @@ Image_blur_image(int argc, VALUE *argv, VALUE self)
     return effect_image(self, argc, argv, BlurImage);
 }
 
+
 /*
     Method:     Image#border(width, height, color)
                 Image#border!(width, height, color)
@@ -543,6 +492,36 @@ Image_border(
     return border(False, self, width, height, color);
 }
 
+
+/*
+    Method:     Image#border_color
+    Purpose:    Return the name of the border color as a String.
+*/
+VALUE
+Image_border_color(VALUE self)
+{
+    Image *image;
+
+    Data_Get_Struct(self, Image, image);
+    return PixelPacket_to_Color_Name(image, &image->border_color);
+}
+
+/*
+    Method:     Image#border_color=
+    Purpose:    Set the the border color
+*/
+VALUE
+Image_border_color_eq(VALUE self, VALUE color)
+{
+    Image *image;
+
+    rm_check_frozen(self);
+    Data_Get_Struct(self, Image, image);
+    Color_to_PixelPacket(&image->border_color, color);
+    return self;
+}
+
+
 /*
     Method:     Image#bounding_box
     Purpose:    returns the bounding box of an image canvas
@@ -560,6 +539,7 @@ VALUE Image_bounding_box(VALUE self)
     return Rectangle_from_RectangleInfo(&box);
 }
 
+
 /*
     Method:     Image.capture(silent=false,
                               frame=false,
@@ -689,6 +669,7 @@ Image_change_geometry(VALUE self, VALUE geom_arg)
 #endif
 }
 
+
 /*
     Method:     Image#changed?
     Purpose:    Return true if any pixel in the image has been altered since
@@ -733,66 +714,6 @@ Image_channel(VALUE self, VALUE channel_arg)
 }
 
 
-/*
-    Method:     Image#compare_channel(ref_image, metric [, channel...])
-    Purpose:    compares one or more channels in two images and returns
-                the specified distortion metric and a comparison image.
-    Notes:      If no channels are specified, the default is AllChannels.
-                That case is the equivalent of the CompareImages method in
-                ImageMagick.
-
-                Originally this method was called channel_compare, but
-                that doesn't match the general naming convention that
-                methods which accept multiple optional ChannelType
-                arguments have names that end in _channel.  So I renamed
-                the method to compare_channel but kept channel_compare as
-                an alias.
-*/
-VALUE Image_compare_channel(
-    int argc,
-    VALUE *argv,
-    VALUE self)
-{
-#if defined(HAVE_COMPAREIMAGECHANNELS)
-
-    Image *image, *r_image, *difference_image;
-    double distortion;
-    volatile VALUE ary;
-    MetricType metric_type;
-    ChannelType channels;
-    ExceptionInfo exception;
-
-    channels = extract_channels(&argc, argv);
-    if (argc < 2)
-    {
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or more)", argc);
-    }
-
-    Data_Get_Struct(self, Image, image);
-    Data_Get_Struct(ImageList_cur_image(argv[0]), Image, r_image);
-    VALUE_TO_ENUM(argv[1], metric_type, MetricType);
-
-    GetExceptionInfo(&exception);
-    difference_image = CompareImageChannels(image
-                                    , r_image
-                                    , channels
-                                    , metric_type
-                                    , &distortion
-                                    , &exception);
-    HANDLE_ERROR
-
-    ary = rb_ary_new2(2);
-    rb_ary_store(ary, 0, rm_image_new(difference_image));
-    rb_ary_store(ary, 1, rb_float_new(distortion));
-
-    return ary;
-#else
-    rm_not_implemented();
-    return (VALUE)0;
-#endif
-}
-
-
 /*
     Method:     Image#channel_depth(channel_depth=AllChannels)
     Purpose:    GetImageChannelDepth
@@ -1064,22 +985,6 @@ Image_channel_mean(int argc, VALUE *argv, VALUE self)
 #endif
 }
 
-/*
- *  Method:     Image#black_threshold(red_channel [, green_channel
- *                                    [, blue_channel [, opacity_channel]]]);
- *  Purpose:    Call BlackThresholdImage
-*/
-VALUE
-Image_black_threshold(int argc, VALUE *argv, VALUE self)
-{
-#if defined(HAVE_BLACKTHRESHOLDIMAGE)
-    return threshold_image(argc, argv, self, BlackThresholdImage);
-#else
-    rm_not_implemented();
-    return (VALUE)0;
-#endif
-}
-
 
 
 /*
@@ -1091,6 +996,8 @@ Image_black_threshold(int argc, VALUE *argv, VALUE self)
 VALUE
 Image_channel_threshold(int argc, VALUE *argv, VALUE self)
 {
+    rb_warning("This method is deprecated in this release of " Q(MAGICKNAME)
+               ". Use bilevel_channel instead.");
     return threshold_image(argc, argv, self,
 #if defined(HAVE_THRESHOLDIMAGECHANNEL)
                          ThresholdImageChannel
@@ -1651,7 +1558,7 @@ Image_colormap(int argc, VALUE *argv, VALUE self)
     return PixelPacket_to_Color_Name(image, &color);
 }
 
-DEF_ATTR_READER(Image, colors, int)
+DEF_ATTR_READER(Image, colors, ulong)
 
 /*
     Method:     Image#colorspace
@@ -1725,8 +1632,87 @@ Image_colorspace_eq(VALUE self, VALUE colorspace)
     return self;
 }
 
+
 DEF_ATTR_READER(Image, columns, int)
-DEF_ATTR_READER(Image, compose, int)
+
+
+/*
+    Method:     Image#compare_channel(ref_image, metric [, channel...])
+    Purpose:    compares one or more channels in two images and returns
+                the specified distortion metric and a comparison image.
+    Notes:      If no channels are specified, the default is AllChannels.
+                That case is the equivalent of the CompareImages method in
+                ImageMagick.
+
+                Originally this method was called channel_compare, but
+                that doesn't match the general naming convention that
+                methods which accept multiple optional ChannelType
+                arguments have names that end in _channel.  So I renamed
+                the method to compare_channel but kept channel_compare as
+                an alias.
+*/
+VALUE Image_compare_channel(
+    int argc,
+    VALUE *argv,
+    VALUE self)
+{
+#if defined(HAVE_COMPAREIMAGECHANNELS)
+
+    Image *image, *r_image, *difference_image;
+    double distortion;
+    volatile VALUE ary;
+    MetricType metric_type;
+    ChannelType channels;
+    ExceptionInfo exception;
+
+    channels = extract_channels(&argc, argv);
+    if (argc > 2)
+    {
+        raise_ChannelType_error(argv[argc-1]);
+    }
+    if (argc != 2)
+    {
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or more)", argc);
+    }
+
+    Data_Get_Struct(self, Image, image);
+    Data_Get_Struct(ImageList_cur_image(argv[0]), Image, r_image);
+    VALUE_TO_ENUM(argv[1], metric_type, MetricType);
+
+    GetExceptionInfo(&exception);
+    difference_image = CompareImageChannels(image
+                                    , r_image
+                                    , channels
+                                    , metric_type
+                                    , &distortion
+                                    , &exception);
+    HANDLE_ERROR
+
+    ary = rb_ary_new2(2);
+    rb_ary_store(ary, 0, rm_image_new(difference_image));
+    rb_ary_store(ary, 1, rb_float_new(distortion));
+
+    return ary;
+#else
+    rm_not_implemented();
+    return (VALUE)0;
+#endif
+}
+
+
+/*
+    Method:     Image#compose -> composite_op
+    Purpose:    Return the composite operator attribute
+*/
+VALUE Image_compose(VALUE self)
+{
+    Image *image;
+
+    Data_Get_Struct(self, Image, image);
+
+    return CompositeOperator_new(image->compose);
+}
+
 
 /*
     Method:     Image#compose=composite_op
@@ -1773,11 +1759,11 @@ static VALUE composite(
     long y_offset;
 
     Data_Get_Struct(self, Image, image);
-    Data_Get_Struct(ImageList_cur_image(argv[0]), Image, comp_image);
 
     switch (argc)
     {
         case 3:                 // argv[1] is gravity, argv[2] is composite_op
+            Data_Get_Struct(ImageList_cur_image(argv[0]), Image, comp_image);
             VALUE_TO_ENUM(argv[1], gravity, GravityType);
             VALUE_TO_ENUM(argv[2], operator, CompositeOperator);
 
@@ -1828,12 +1814,14 @@ static VALUE composite(
 
         case 4:                 // argv[1], argv[2] is x_off, y_off,
                                 // argv[3] is composite_op
+            Data_Get_Struct(ImageList_cur_image(argv[0]), Image, comp_image);
             x_offset = NUM2LONG(argv[1]);
             y_offset = NUM2LONG(argv[2]);
             VALUE_TO_ENUM(argv[3], operator, CompositeOperator);
             break;
 
         case 5:
+            Data_Get_Struct(ImageList_cur_image(argv[0]), Image, comp_image);
             VALUE_TO_ENUM(argv[1], gravity, GravityType);
             x_offset = NUM2LONG(argv[2]);
             y_offset = NUM2LONG(argv[3]);
@@ -1877,6 +1865,7 @@ static VALUE composite(
 
     if (bang)
     {
+        rm_check_frozen(self);
         (void) CompositeImage(image, operator, comp_image, x_offset, y_offset);
         HANDLE_ERROR_IMG(image)
         return self;
@@ -2216,6 +2205,10 @@ Image_convolve_channel(
     channels = extract_channels(&argc, argv);
 
     // There are 2 required arguments.
+    if (argc > 2)
+    {
+        raise_ChannelType_error(argv[argc-1]);
+    }
     if (argc != 2)
     {
         rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or more)", argc);
@@ -2480,8 +2473,10 @@ VALUE Image_difference(VALUE self, VALUE other)
     return rb_ary_new3(3, mean, nmean, nmax);
 }
 
+
 DEF_ATTR_READER(Image, directory, str)
 
+
 /*
     Method:     Image#dispatch(x, y, columns, rows, map <, float>)
     Purpose:    Extracts pixel data from the image and returns it as an
@@ -2608,8 +2603,33 @@ VALUE Image_display(VALUE self)
     return self;
 }
 
-DEF_ATTR_ACCESSOR(Image, dispose, ulong)
+/*
+    Method:     Image#dispose
+    Purpose:    Return the dispose attribute as a DisposeType enum
+*/
+VALUE
+Image_dispose(VALUE self)
+{
+    Image *image;
+
+    Data_Get_Struct(self, Image, image);
+    return DisposeType_new(image->dispose);
+}
+
+/*
+    Method:     Image#dispose=
+    Purpose:    Set the dispose attribute
+*/
+VALUE
+Image_dispose_eq(VALUE self, VALUE dispose)
+{
+    Image *image;
 
+    rm_check_frozen(self);
+    Data_Get_Struct(self, Image, image);
+    VALUE_TO_ENUM(dispose, image->dispose, DisposeType);
+    return self;
+}
 
 /*
     Method:     Image#_dump(aDepth)
@@ -2785,9 +2805,9 @@ effect_image(
     }
 
     Data_Get_Struct(self, Image, image);
-    if (sigma <= 0.0)
+    if (sigma == 0.0)
     {
-        rb_raise(rb_eArgError, "sigma must be > 0.0");
+        rb_raise(rb_eArgError, "sigma must be != 0.0");
     }
 
     GetExceptionInfo(&exception);
@@ -3007,6 +3027,7 @@ Image_extract_info_eq(VALUE self, VALUE rect)
 
 DEF_ATTR_READER(Image, filename, str)
 
+
 /*
     Method:     Image#filesize
     Purpose:    Return the image filesize
@@ -3019,6 +3040,7 @@ VALUE Image_filesize(VALUE self)
     return INT2FIX(GetBlobSize(image));
 }
 
+
 /*
     Method:     Image#filter, filter=
     Purpose:    Get/set filter type
@@ -3043,6 +3065,7 @@ Image_filter_eq(VALUE self, VALUE filter)
     return self;
 }
 
+
 /*
     Method:     Image#flip
                 Image#flip!
@@ -3285,6 +3308,7 @@ VALUE Image_fuzz_eq(VALUE self, VALUE fuzz)
     return self;
 }
 
+
 DEF_ATTR_ACCESSOR(Image, gamma, dbl)
 
 
@@ -3475,7 +3499,7 @@ Image_geometry_eq(
     geom = STRING_PTR(geom_str);
     if (!IsGeometry(geom))
     {
-        rb_raise(rb_eArgError, "invalid geometry: %s", geom);
+        rb_raise(rb_eTypeError, "invalid geometry: %s", geom);
     }
     magick_clone_string(&image->geometry, geom);
     return self;
@@ -3665,77 +3689,145 @@ Image_implode(int argc, VALUE *argv, VALUE self)
     Notes:      See Image#export_pixels
 */
 VALUE
-Image_import_pixels(
-    VALUE self,
-    VALUE x_arg,
-    VALUE y_arg,
-    VALUE cols_arg,
-    VALUE rows_arg,
-    VALUE map_arg,
-    VALUE pixel_ary)
+Image_import_pixels(int argc, VALUE *argv, VALUE self)
 {
 #if defined(HAVE_IMPORTIMAGEPIXELS)
     Image *image, *clone_image;
     long x_off, y_off;
     unsigned long cols, rows;
     unsigned long npixels;
-    long n;
+    long n, buffer_l;
     char *map;
-    volatile int *pixels;
+    volatile VALUE pixel_arg, pixel_ary;
+    StorageType stg_type = CharPixel;
+    size_t type_sz, map_l;
+    volatile int *pixels = NULL;
+    volatile void *buffer;
     unsigned int okay;
     ExceptionInfo exception;
 
     rm_check_frozen(self);
+
+    switch (argc)
+    {
+        case 7:
+            VALUE_TO_ENUM(argv[6], stg_type, StorageType);
+        case 6:
+            x_off = NUM2LONG(argv[0]);
+            y_off = NUM2LONG(argv[1]);
+            cols = NUM2ULONG(argv[2]);
+            rows = NUM2ULONG(argv[3]);
+            map = STRING_PTR(argv[4]);
+            pixel_arg = argv[5];
+            break;
+        default:
+            rb_raise(rb_eArgError, "wrong number of arguments (%d for 6 or 7)", argc);
+            break;
+    }
+
     Data_Get_Struct(self, Image, image);
 
-    map   = STRING_PTR(map_arg);
-    x_off = NUM2LONG(x_arg);
-    y_off = NUM2LONG(y_arg);
-    cols  = NUM2ULONG(cols_arg);
-    rows  = NUM2ULONG(rows_arg);
+    if (x_off < 0 || y_off < 0 || cols <= 0 || rows <= 0)
+    {
+        rb_raise(rb_eArgError, "invalid import geometry");
+    }
+
+    map_l = strlen(map);
+    npixels = cols * rows * map_l;
+
+    // Assume that any object that responds to :to_str is a string buffer containing
+    // binary pixel data.
+    if (rb_respond_to(pixel_arg, rb_intern("to_str")))
+    {
+        buffer = (void *)STRING_PTR_LEN(pixel_arg, buffer_l);
+        switch (stg_type)
+        {
+            case CharPixel:
+                type_sz = 1;
+                break;
+            case ShortPixel:
+                type_sz = sizeof(unsigned short);
+                break;
+            case IntegerPixel:
+                type_sz = sizeof(unsigned int);
+                break;
+            case LongPixel:
+                type_sz = sizeof(unsigned long);
+                break;
+#if defined(HAVE_QUANTUMPIXEL)
+            case QuantumPixel:
+                type_sz = sizeof(Quantum);
+                break;
+#endif
+            default:
+                rb_raise(rb_eArgError, "unsupported storage type %s", StorageType_name(stg_type));
+                break;
+        }
 
-    if (x_off < 0 || y_off < 0 || cols <= 0 || rows <= 0)
-    {
-        rb_raise(rb_eArgError, "invalid import geometry");
+        if (buffer_l % type_sz != 0)
+        {
+            rb_raise(rb_eArgError, "pixel buffer must be an exact multiple of the storage type size");
+        }
+        if ((buffer_l / type_sz) % map_l != 0)
+        {
+            rb_raise(rb_eArgError, "pixel buffer must contain an exact multiple of the map length");
+        }
+        if (buffer_l/type_sz < npixels)
+        {
+            rb_raise(rb_eArgError, "pixel buffer too small (need %lu channel values, got %ld)"
+                   , npixels, buffer_l/type_sz);
+        }
     }
+    // Otherwise convert the argument to an array and convert the array elements
+    // to binary pixel data.
+    else
+    {
+        // rb_Array converts an object that is not an array to an array if possible,
+        // and raises TypeError if it can't. It usually is possible.
+        pixel_ary = rb_Array(pixel_arg);
 
-    npixels = cols * rows * strlen(map);
-
-    // rb_Array converts objects that are not Arrays to Arrays if possible,
-    // and raises TypeError if it can't.
-    pixel_ary = rb_Array(pixel_ary);
+        if (RARRAY(pixel_ary)->len % map_l != 0)
+        {
+            rb_raise(rb_eArgError, "pixel array must contain an exact multiple of the map length");
+        }
+        if (RARRAY(pixel_ary)->len < npixels)
+        {
+            rb_raise(rb_eArgError, "pixel array too small (need %lu elements, got %ld)"
+                   , npixels, RARRAY(pixel_ary)->len);
+        }
 
-    if (RARRAY(pixel_ary)->len < npixels)
-    {
-        rb_raise(rb_eArgError, "pixel array too small (need %lu, got %ld)"
-               , npixels, RARRAY(pixel_ary)->len);
-    }
+        // Get array for integer pixels. Use Ruby's memory so GC will clean up after us
+        // in case of an exception.
+        pixels = ALLOC_N(int, npixels);
+        if (!pixels)        // app recovered from exception...
+        {
+            return self;
+        }
 
-    // Get array for integer pixels. Use Ruby's memory so GC will clean up after us
-    // in case of an exception.
-    pixels = ALLOC_N(int, npixels);
-    if (!pixels)        // app recovered from exception...
-    {
-        return self;
+        for (n = 0; n < npixels; n++)
+        {
+            volatile VALUE p = rb_ary_entry(pixel_ary, n);
+            long q = ScaleQuantumToLong(NUM2LONG(p));
+            pixels[n] = (int) q;
+        }
+        buffer = (void *) pixels;
+        stg_type = IntegerPixel;
     }
 
-    for (n = 0; n < npixels; n++)
-    {
-        volatile VALUE p = rb_ary_entry(pixel_ary, n);
-        long q = ScaleQuantumToLong(NUM2LONG(p));
-        pixels[n] = (int) q;
-    }
 
     // Import into a clone - ImportImagePixels destroys the input image if an error occurs.
     GetExceptionInfo(&exception);
     clone_image = CloneImage(image, 0, 0, True, &exception);
     HANDLE_ERROR
 
-    okay = ImportImagePixels(clone_image, x_off, y_off, cols, rows, map, IntegerPixel, (void *)pixels);
+    okay = ImportImagePixels(clone_image, x_off, y_off, cols, rows, map, stg_type, (const void *)buffer);
 
     // Free pixel array before checking for errors. If an error occurred, ImportImagePixels
     // destroyed the clone image, so we don't have to.
-    xfree((void *)pixels);
+    if (pixels)
+    {
+        xfree((void *)pixels);
+    }
 
     if (!okay)
     {
@@ -3782,7 +3874,11 @@ Image_inspect(VALUE self)
     // Print current filename.
     x += sprintf(buffer+x, "%s", image->filename);
     // Print scene number.
+#if defined(HAVE_GETNEXTIMAGEINLIST)
+    if ((GetPreviousImageInList(image) != NULL) && (GetNextImageInList(image) != NULL) && image->scene > 0)
+#else
     if ((image->previous || image->next) && image->scene > 0)
+#endif
     {
         x += sprintf(buffer+x, "[%lu]", image->scene);
     }
@@ -4568,6 +4664,7 @@ Image_monitor_eq(VALUE self, VALUE monitor)
 #if defined(HAVE_SETIMAGEPROGRESSMONITOR)
     Image *image;
 
+    rm_check_frozen(self);
     Data_Get_Struct(self, Image, image);
 
     if (NIL_P(monitor))
@@ -4663,9 +4760,9 @@ Image_motion_blur(
     sigma  = NUM2DBL(sigma_arg);
     angle  = NUM2DBL(angle_arg);
 
-    if (sigma <= 0.0)
+    if (sigma == 0.0)
     {
-        rb_raise(rb_eArgError, "sigma must be > 0.0");
+        rb_raise(rb_eArgError, "sigma must be != 0.0");
     }
 
     GetExceptionInfo(&exception);
@@ -4996,14 +5093,14 @@ Image_number_colors(VALUE self)
 {
     Image *image;
     ExceptionInfo exception;
-    unsigned int n = 0;
+    unsigned long n = 0;
 
     Data_Get_Struct(self, Image, image);
     GetExceptionInfo(&exception);
 
-    n = GetNumberColors(image, NULL, &exception);
+    n = (unsigned long) GetNumberColors(image, NULL, &exception);
     HANDLE_ERROR
-    return INT2FIX(n);
+    return ULONG2NUM(n);
 }
 
 DEF_ATTR_ACCESSOR(Image, offset, long)
@@ -5238,7 +5335,11 @@ 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];
@@ -5259,12 +5360,20 @@ 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);
@@ -5437,6 +5546,12 @@ Image_profile_bang(
 }
 
 
+#if defined(HAVE_IMAGE_QUALITY)
+DEF_ATTR_READER(Image, quality, ulong)
+#endif
+
+
+
 /*
     Method:     Image#quantum_depth -> 8, 16, or 32
     Purpose:    Return image depth to nearest quantum
@@ -5642,38 +5757,6 @@ Image_quantum_operator(int argc, VALUE *argv, VALUE self)
 }
 
 
-
-/*
-    Method:     Image#radial_blur(angle)
-    Purpose:    Call RadialBlurImage
-    Notes:      Angle is in degrees
-*/
-VALUE
-Image_radial_blur(VALUE self, VALUE angle)
-{
-#if defined(HAVE_RADIALBLURIMAGE)
-    Image *image, *new_image;
-    ExceptionInfo exception;
-
-    Data_Get_Struct(self, Image, image);
-    GetExceptionInfo(&exception);
-
-    new_image = RadialBlurImage(image, NUM2DBL(angle), &exception);
-    HANDLE_ERROR
-
-    return rm_image_new(new_image);
-#else
-    rm_not_implemented();
-    return (VALUE)0;
-#endif
-}
-
-
-#if defined(HAVE_IMAGE_QUALITY)
-DEF_ATTR_READER(Image, quality, ulong)
-#endif
-
-
 /*
     Method:     Image#quantize(<number_colors<, colorspace<, dither<, tree_depth<, measure_error>>>>>)
                 defaults: 256, Magick::RGBColorspace, true, 0, false
@@ -5716,6 +5799,33 @@ Image_quantize(int argc, VALUE *argv, VALUE self)
 }
 
 
+
+/*
+    Method:     Image#radial_blur(angle)
+    Purpose:    Call RadialBlurImage
+    Notes:      Angle is in degrees
+*/
+VALUE
+Image_radial_blur(VALUE self, VALUE angle)
+{
+#if defined(HAVE_RADIALBLURIMAGE)
+    Image *image, *new_image;
+    ExceptionInfo exception;
+
+    Data_Get_Struct(self, Image, image);
+    GetExceptionInfo(&exception);
+
+    new_image = RadialBlurImage(image, NUM2DBL(angle), &exception);
+    HANDLE_ERROR
+
+    return rm_image_new(new_image);
+#else
+    rm_not_implemented();
+    return (VALUE)0;
+#endif
+}
+
+
 /*
     Method:     Image#random_channel_threshold
     Purpose:    changes the value of individual pixels based on the intensity of
@@ -6443,6 +6553,77 @@ Image_opacity_eq(VALUE self, VALUE opacity_arg)
     return self;
 }
 
+
+/*
+    Method:     Image#properties [{ |k,v| block }]
+    Purpose:    Traverse the attributes and yield to the block.
+                If no block, return a hash of all the attribute
+                keys & values
+    Notes:      I use the word "properties" to distinguish between
+                these "user-added" attribute strings and Image
+                object attributes.
+*/
+VALUE
+Image_properties(VALUE self)
+{
+    Image *image;
+    const ImageAttribute *attr;
+    volatile VALUE attr_hash;
+
+    Data_Get_Struct(self, Image, image);
+
+    // If block, iterate over attributes
+    if (rb_block_given_p())
+    {
+        volatile VALUE ary = rb_ary_new2(2);
+
+#if defined(HAVE_GETNEXTIMAGEATTRIBUTE)
+        ResetImageAttributeIterator(image);
+        attr = GetNextImageAttribute(image);
+        while (attr)
+        {
+            rb_ary_store(ary, 0, rb_str_new2(attr->key));
+            rb_ary_store(ary, 1, rb_str_new2(attr->value));
+            rb_yield(ary);
+            attr = GetNextImageAttribute(image);
+        }
+#else
+        for (attr = image->attributes; attr; attr = Next_Attribute)
+        {
+            // Store the next ptr where Image#aset can see it.
+            // The app may decide to delete that attribute.
+            Next_Attribute = attr->next;
+            rb_ary_store(ary, 0, rb_str_new2(attr->key));
+            rb_ary_store(ary, 1, rb_str_new2(attr->value));
+            rb_yield(ary);
+        }
+#endif
+        return self;
+    }
+
+    // otherwise return properties hash
+    else
+    {
+        attr_hash = rb_hash_new();
+#if defined(HAVE_GETNEXTIMAGEATTRIBUTE)
+        ResetImageAttributeIterator(image);
+        attr = GetNextImageAttribute(image);
+        while (attr)
+        {
+            rb_hash_aset(attr_hash, rb_str_new2(attr->key), rb_str_new2(attr->value));
+            attr = GetNextImageAttribute(image);
+        }
+#else
+        for (attr = image->attributes; attr; attr = attr->next)
+        {
+            rb_hash_aset(attr_hash, rb_str_new2(attr->key), rb_str_new2(attr->value));
+        }
+#endif
+        return attr_hash;
+    }
+}
+
+
 /*
     Method:     Image#shade(shading=false, azimuth=30, elevation=30)
     Purpose:    shines a distant light on an image to create a three-dimensional
@@ -6545,33 +6726,6 @@ Image_shadow(int argc, VALUE *argv, VALUE self)
 #endif
 }
 
-/*
-    Method:     Image#shave(width, height)
-                Image#shave!(width, height)
-    Purpose:    shaves pixels from the image edges, leaving a rectangle
-                of the specified width & height in the center
-    Returns:    shave: a new image
-                shave!: self, shaved
-*/
-VALUE
-Image_shave(
-    VALUE self,
-    VALUE width,
-    VALUE height)
-{
-    return xform_image(False, self, INT2FIX(0), INT2FIX(0), width, height, ShaveImage);
-}
-
-VALUE
-Image_shave_bang(
-    VALUE self,
-    VALUE width,
-    VALUE height)
-{
-    rm_check_frozen(self);
-    return xform_image(True, self, INT2FIX(0), INT2FIX(0), width, height, ShaveImage);
-}
-
 /*
     Method:     Image#sharpen(radius=0, sigma=1)
     Purpose:    sharpens an image
@@ -6630,6 +6784,36 @@ Image_sharpen_channel(int argc, VALUE *argv, VALUE self)
 #endif
 }
 
+
+/*
+    Method:     Image#shave(width, height)
+                Image#shave!(width, height)
+    Purpose:    shaves pixels from the image edges, leaving a rectangle
+                of the specified width & height in the center
+    Returns:    shave: a new image
+                shave!: self, shaved
+*/
+VALUE
+Image_shave(
+    VALUE self,
+    VALUE width,
+    VALUE height)
+{
+    return xform_image(False, self, INT2FIX(0), INT2FIX(0), width, height, ShaveImage);
+}
+
+
+VALUE
+Image_shave_bang(
+    VALUE self,
+    VALUE width,
+    VALUE height)
+{
+    rm_check_frozen(self);
+    return xform_image(True, self, INT2FIX(0), INT2FIX(0), width, height, ShaveImage);
+}
+
+
 /*
     Method:     Image#shear(x_shear, y_shear)
     Purpose:    Calls ShearImage
@@ -6799,6 +6983,7 @@ Image_spaceship(VALUE self, VALUE other)
     }
 
     res = memcmp(sigA->value, sigB->value, 64);
+    res = res > 0 ? 1 : (res < 0 ? -1 :  0);    // reduce to 1, -1, 0
 
     return INT2FIX(res);
 }
@@ -7002,7 +7187,11 @@ 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
 }
 
 /*
@@ -7021,20 +7210,32 @@ 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;
 }
 
@@ -7074,6 +7275,9 @@ Image_store_pixels(
                , cols, rows, x, y);
     }
 
+    size = cols * rows;
+    rm_check_ary_len(new_pixels, size);
+
     SetImageType(image, TrueColorType);
 
     // Get a pointer to the pixels. Replace the values with the PixelPackets
@@ -7081,7 +7285,6 @@ Image_store_pixels(
     pixels = GetImagePixels(image, x, y, cols, rows);
     if (pixels)
     {
-        size = cols * rows;
         for (n = 0; n < size; n++)
         {
             new_pixel = rb_ary_entry(new_pixels, n);
@@ -7570,7 +7773,17 @@ Image_to_color(VALUE self, VALUE pixel_arg)
 
 }
 
-DEF_ATTR_READER(Image, total_colors, ulong)
+/*
+    Method:     Image#total_colors
+    Purpose:    alias for Image#number_colors
+    Notes:      This used to be a direct reference to the `total_colors' field in Image
+                but that field is not reliable.
+*/
+VALUE
+Image_total_colors(VALUE self)
+{
+    return Image_number_colors(self);
+}
 
 /*
     Method:     Image#transparent(color-name<, opacity>)
@@ -7674,6 +7887,8 @@ Image_trim_bang(VALUE self)
     Method:     Image#image_type=(type)
     Purpose:    Call SetImageType to set the type of the image
     Note:       Can't use type & type= b/c of Object#type.
+                This setter is useless. Leave for backward compatibility
+                but don't document it.
 */
 VALUE Image_image_type_eq(VALUE self, VALUE type)
 {
@@ -7966,6 +8181,9 @@ DEF_ATTR_ACCESSOR(Image, x_resolution, dbl)
                     gravity, x, y, width, height
                 If the 2nd or 3rd, compute new x, y values.
 
+                The argument list can have a trailing true, false, or nil argument.
+                If present and true, after cropping reset the page fields in the image.
+
                 Call xform_image to do the cropping.
 */
 static VALUE
@@ -7974,9 +8192,27 @@ cropper(int bang, int argc, VALUE *argv, VALUE self)
     volatile VALUE x, y, width, height;
     unsigned long nx = 0, ny = 0;
     unsigned long columns, rows;
+    int reset_page = 0;
     GravityType gravity;
     MagickEnum *magick_enum;
     Image *image;
+    VALUE cropped;
+
+    // Check for a "reset page" trailing argument.
+    if (argc >= 1)
+    {
+        switch (TYPE(argv[argc-1]))
+        {
+            case T_TRUE:
+                reset_page = 1;
+                // fall thru
+            case T_FALSE:
+            case T_NIL:
+                argc -= 1;
+            default:
+                break;
+        }
+    }
 
     switch (argc)
     {
@@ -8083,11 +8319,25 @@ cropper(int bang, int argc, VALUE *argv, VALUE self)
             y = ULONG2NUM(ny);
             break;
         default:
-            rb_raise(rb_eArgError, "wrong number of arguments (%d for 3, 4, or 5)", argc);
+            if (reset_page)
+            {
+                rb_raise(rb_eArgError, "wrong number of arguments (%d for 4, 5, or 6)", argc);
+            }
+            else
+            {
+                rb_raise(rb_eArgError, "wrong number of arguments (%d for 3, 4, or 5)", argc);
+            }
             break;
     }
 
-    return xform_image(bang, self, x, y, width, height, CropImage);
+    cropped = xform_image(bang, self, x, y, width, height, CropImage);
+    if (reset_page)
+    {
+        Data_Get_Struct(cropped, Image, image);
+        image->page.x = image->page.y = 0L;
+        image->page.width = image->page.height = 0UL;
+    }
+    return cropped;
 }
 
 
@@ -8183,12 +8433,12 @@ static ChannelType extract_channels(
 
 /*
     Static:     raise_ChannelType_error
-    Purpose:    raise ArgumentError when an non-ChannelType object
+    Purpose:    raise TypeError when an non-ChannelType object
                 is unexpectedly encountered
 */
 static void
 raise_ChannelType_error(VALUE arg)
 {
-    rb_raise(rb_eArgError, "argument needs to be a ChannelType (%s given)"
+    rb_raise(rb_eTypeError, "argument needs to be a ChannelType (%s given)"
             , rb_class2name(CLASS_OF(arg)));
 }