rmagick 3.2.0 → 4.3.0

data/ext/RMagick/rmmain.c

@@ -14,6 +14,18 @@
 #define MAIN                        // Define external variables
 #include "rmagick.h"
 
+#if defined(HAVE_SETMAGICKALIGNEDMEMORYMETHODS) && defined(HAVE_RB_GC_ADJUST_MEMORY_USAGE)
+    #if defined(HAVE_POSIX_MEMALIGN) || defined(HAVE__ALIGNED_MSIZE)
+        #define USE_RM_ALIGNED_MALLOC 1
+
+        #if defined(HAVE_MALLOC_H)
+            #include <malloc.h>
+        #elif defined(HAVE_MALLOC_MALLOC_H)
+            #include <malloc/malloc.h>
+        #endif
+    #endif
+#endif
+
 /*----------------------------------------------------------------------------\
 | External declarations
 \----------------------------------------------------------------------------*/
@@ -98,6 +110,78 @@ static void rm_free(void *ptr)
 }
 
 
+
+#if USE_RM_ALIGNED_MALLOC
+
+static size_t
+rm_aligned_malloc_size(void *ptr)
+{
+#if defined(HAVE_MALLOC_USABLE_SIZE)
+    return malloc_usable_size(ptr);
+#elif defined(HAVE_MALLOC_SIZE)
+    return malloc_size(ptr);
+#elif defined(HAVE__ALIGNED_MSIZE)
+// Refered to https://github.com/ImageMagick/ImageMagick/blob/master/MagickCore/memory-private.h
+#define MAGICKCORE_SIZEOF_VOID_P 8
+#define CACHE_LINE_SIZE  (8 * MAGICKCORE_SIZEOF_VOID_P)
+    size_t _aligned_msize(void *memblock, size_t alignment, size_t offset);
+    return _aligned_msize(ptr, CACHE_LINE_SIZE, 0);
+#endif
+}
+
+
+/**
+ * Allocate aligned memory.
+ *
+ * No Ruby usage (internal function)
+ *
+ * @param size the size of memory to allocate
+ * @return pointer to a block of memory
+ */
+static void *rm_aligned_malloc(size_t size, size_t alignment)
+{
+    void *res;
+    size_t allocated_size;
+
+#if defined(HAVE_POSIX_MEMALIGN)
+    if (posix_memalign(&res, alignment, size) != 0) {
+        return NULL;
+    }
+#elif defined(HAVE__ALIGNED_MSIZE)
+    res = _aligned_malloc(size, alignment);
+#endif
+
+    allocated_size = rm_aligned_malloc_size(res);
+    rb_gc_adjust_memory_usage(allocated_size);
+    return res;
+}
+
+
+
+
+/**
+ * Free aligned memory.
+ *
+ * No Ruby usage (internal function)
+ *
+ * @param ptr pointer to the existing block of memory
+ */
+static void rm_aligned_free(void *ptr)
+{
+    size_t allocated_size = rm_aligned_malloc_size(ptr);
+    rb_gc_adjust_memory_usage(-allocated_size);
+
+#if defined(HAVE_POSIX_MEMALIGN)
+    free(ptr);
+#elif defined(HAVE__ALIGNED_MSIZE)
+    _aligned_free(ptr);
+#endif
+}
+
+#endif
+
+
+
 /**
  * Use managed memory.
  *
@@ -108,6 +192,9 @@ static inline void managed_memory_enable(VALUE enable)
     if (enable)
     {
         SetMagickMemoryMethods(rm_malloc, rm_realloc, rm_free);
+#if USE_RM_ALIGNED_MALLOC
+        SetMagickAlignedMemoryMethods(rm_aligned_malloc, rm_aligned_free);
+#endif
     }
     rb_define_const(Module_Magick, "MANAGED_MEMORY", enable);
 }
@@ -147,8 +234,6 @@ static void set_managed_memory(void)
 void
 Init_RMagick2(void)
 {
-    VALUE observable;
-
     Module_Magick = rb_define_module("Magick");
 
     set_managed_memory();
@@ -157,6 +242,8 @@ Init_RMagick2(void)
 
     test_Magick_version();
 
+    rm_main_thread_id = rm_current_thread_id();
+
     /*-----------------------------------------------------------------------*/
     /* Create IDs for frequently used methods, etc.                          */
     /*-----------------------------------------------------------------------*/
@@ -167,24 +254,14 @@ Init_RMagick2(void)
     rm_ID_cur_image        = rb_intern("cur_image");
     rm_ID_dup              = rb_intern("dup");
     rm_ID_fill             = rb_intern("fill");
-    rm_ID_flag             = rb_intern("flag");
-    rm_ID_from_s           = rb_intern("from_s");
     rm_ID_Geometry         = rb_intern("Geometry");
-    rm_ID_GeometryValue    = rb_intern("GeometryValue");
-    rm_ID_has_key_q        = rb_intern("has_key?");
     rm_ID_height           = rb_intern("height");
     rm_ID_initialize_copy  = rb_intern("initialize_copy");
-    rm_ID_length           = rb_intern("length");
     rm_ID_notify_observers = rb_intern("notify_observers");
     rm_ID_new              = rb_intern("new");
     rm_ID_push             = rb_intern("push");
-    rm_ID_spaceship        = rb_intern("<=>");
-    rm_ID_to_i             = rb_intern("to_i");
-    rm_ID_to_s             = rb_intern("to_s");
     rm_ID_values           = rb_intern("values");
     rm_ID_width            = rb_intern("width");
-    rm_ID_x                = rb_intern("x");
-    rm_ID_y                = rb_intern("y");
 
     /*-----------------------------------------------------------------------*/
     /* Module Magick methods                                                 */
@@ -210,7 +287,6 @@ Init_RMagick2(void)
     rb_define_alloc_func(Class_Image, Image_alloc);
     rb_define_method(Class_Image, "initialize", Image_initialize, -1);
 
-    rb_define_singleton_method(Class_Image, "combine", Image_combine, -1);
     rb_define_singleton_method(Class_Image, "constitute", Image_constitute, 4);
     rb_define_singleton_method(Class_Image, "_load", Image__load, 1);
     rb_define_singleton_method(Class_Image, "capture", Image_capture, -1);
@@ -219,72 +295,106 @@ Init_RMagick2(void)
     rb_define_singleton_method(Class_Image, "read_inline", Image_read_inline, 1);
     rb_define_singleton_method(Class_Image, "from_blob", Image_from_blob, 1);
 
-    DCL_ATTR_WRITER(Image, alpha)
-    DCL_ATTR_ACCESSOR(Image, background_color)
-    DCL_ATTR_READER(Image, base_columns)
-    DCL_ATTR_READER(Image, base_filename)
-    DCL_ATTR_READER(Image, base_rows)
-    DCL_ATTR_ACCESSOR(Image, bias)
-    DCL_ATTR_ACCESSOR(Image, black_point_compensation)
-    DCL_ATTR_ACCESSOR(Image, blur)
-    DCL_ATTR_ACCESSOR(Image, border_color)
-    DCL_ATTR_READER(Image, bounding_box)
-    DCL_ATTR_ACCESSOR(Image, chromaticity)
-    DCL_ATTR_ACCESSOR(Image, color_profile)
-    DCL_ATTR_READER(Image, colors)
-    DCL_ATTR_ACCESSOR(Image, colorspace)
-    DCL_ATTR_READER(Image, columns)
-    DCL_ATTR_ACCESSOR(Image, compose)
-    DCL_ATTR_ACCESSOR(Image, compression)
-    DCL_ATTR_ACCESSOR(Image, delay)
-    DCL_ATTR_ACCESSOR(Image, density)
-    DCL_ATTR_READER(Image, depth)
-    DCL_ATTR_READER(Image, directory)
-    DCL_ATTR_ACCESSOR(Image, dispose)
-    DCL_ATTR_ACCESSOR(Image, endian)
-    DCL_ATTR_ACCESSOR(Image, extract_info)
-    DCL_ATTR_READER(Image, filename)
-    DCL_ATTR_READER(Image, filesize)
-    DCL_ATTR_ACCESSOR(Image, filter)
-    DCL_ATTR_ACCESSOR(Image, format)
-    DCL_ATTR_ACCESSOR(Image, fuzz)
-    DCL_ATTR_ACCESSOR(Image, gamma)
-    DCL_ATTR_ACCESSOR(Image, geometry)
-    DCL_ATTR_ACCESSOR(Image, gravity)
-    DCL_ATTR_ACCESSOR(Image, image_type)
-    DCL_ATTR_ACCESSOR(Image, interlace)
-    DCL_ATTR_ACCESSOR(Image, iptc_profile)
-    DCL_ATTR_ACCESSOR(Image, iterations)        // do not document! Only used by Image#iterations=
-    DCL_ATTR_WRITER(Image, mask)
-    DCL_ATTR_ACCESSOR(Image, matte)
-    DCL_ATTR_ACCESSOR(Image, matte_color)
-    DCL_ATTR_READER(Image, mean_error_per_pixel)
-    DCL_ATTR_READER(Image, mime_type)
-    DCL_ATTR_WRITER(Image, monitor)
-    DCL_ATTR_READER(Image, montage)
-    DCL_ATTR_READER(Image, normalized_mean_error)
-    DCL_ATTR_READER(Image, normalized_maximum_error)
-    DCL_ATTR_READER(Image, number_colors)
-    DCL_ATTR_ACCESSOR(Image, offset)
-    DCL_ATTR_WRITER(Image, opacity)
-    DCL_ATTR_ACCESSOR(Image, orientation)
-    DCL_ATTR_ACCESSOR(Image, page)
-    DCL_ATTR_ACCESSOR(Image, pixel_interpolation_method)
-    DCL_ATTR_READER(Image, quality)
-    DCL_ATTR_READER(Image, quantum_depth)
-    DCL_ATTR_ACCESSOR(Image, rendering_intent)
-    DCL_ATTR_READER(Image, rows)
-    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_READER(Image, total_colors)
-    DCL_ATTR_READER(Image, total_ink_density)
-    DCL_ATTR_ACCESSOR(Image, transparent_color)
-    DCL_ATTR_ACCESSOR(Image, units)
-    DCL_ATTR_ACCESSOR(Image, virtual_pixel_method)
-    DCL_ATTR_ACCESSOR(Image, x_resolution)
-    DCL_ATTR_ACCESSOR(Image, y_resolution)
+    // Define the attributes
+    rb_define_method(Class_Image, "background_color", Image_background_color, 0);
+    rb_define_method(Class_Image, "background_color=", Image_background_color_eq, 1);
+    rb_define_method(Class_Image, "base_columns", Image_base_columns, 0);
+    rb_define_method(Class_Image, "base_filename", Image_base_filename, 0);
+    rb_define_method(Class_Image, "base_rows", Image_base_rows, 0);
+    rb_define_method(Class_Image, "bias", Image_bias, 0);
+    rb_define_method(Class_Image, "bias=", Image_bias_eq, 1);
+    rb_define_method(Class_Image, "black_point_compensation", Image_black_point_compensation, 0);
+    rb_define_method(Class_Image, "black_point_compensation=", Image_black_point_compensation_eq, 1);
+    rb_define_method(Class_Image, "border_color", Image_border_color, 0);
+    rb_define_method(Class_Image, "border_color=", Image_border_color_eq, 1);
+    rb_define_method(Class_Image, "bounding_box", Image_bounding_box, 0);
+    rb_define_method(Class_Image, "chromaticity", Image_chromaticity, 0);
+    rb_define_method(Class_Image, "chromaticity=", Image_chromaticity_eq, 1);
+    rb_define_method(Class_Image, "color_profile", Image_color_profile, 0);
+    rb_define_method(Class_Image, "color_profile=", Image_color_profile_eq, 1);
+    rb_define_method(Class_Image, "colors", Image_colors, 0);
+    rb_define_method(Class_Image, "colorspace", Image_colorspace, 0);
+    rb_define_method(Class_Image, "colorspace=", Image_colorspace_eq, 1);
+    rb_define_method(Class_Image, "columns", Image_columns, 0);
+    rb_define_method(Class_Image, "compose", Image_compose, 0);
+    rb_define_method(Class_Image, "compose=", Image_compose_eq, 1);
+    rb_define_method(Class_Image, "compression", Image_compression, 0);
+    rb_define_method(Class_Image, "compression=", Image_compression_eq, 1);
+    rb_define_method(Class_Image, "delay", Image_delay, 0);
+    rb_define_method(Class_Image, "delay=", Image_delay_eq, 1);
+    rb_define_method(Class_Image, "density", Image_density, 0);
+    rb_define_method(Class_Image, "density=", Image_density_eq, 1);
+    rb_define_method(Class_Image, "depth", Image_depth, 0);
+    rb_define_method(Class_Image, "directory", Image_directory, 0);
+    rb_define_method(Class_Image, "dispose", Image_dispose, 0);
+    rb_define_method(Class_Image, "dispose=", Image_dispose_eq, 1);
+    rb_define_method(Class_Image, "endian", Image_endian, 0);
+    rb_define_method(Class_Image, "endian=", Image_endian_eq, 1);
+    rb_define_method(Class_Image, "extract_info", Image_extract_info, 0);
+    rb_define_method(Class_Image, "extract_info=", Image_extract_info_eq, 1);
+    rb_define_method(Class_Image, "filename", Image_filename, 0);
+    rb_define_method(Class_Image, "filesize", Image_filesize, 0);
+    rb_define_method(Class_Image, "filter", Image_filter, 0);
+    rb_define_method(Class_Image, "filter=", Image_filter_eq, 1);
+    rb_define_method(Class_Image, "format", Image_format, 0);
+    rb_define_method(Class_Image, "format=", Image_format_eq, 1);
+    rb_define_method(Class_Image, "fuzz", Image_fuzz, 0);
+    rb_define_method(Class_Image, "fuzz=", Image_fuzz_eq, 1);
+    rb_define_method(Class_Image, "gamma", Image_gamma, 0);
+    rb_define_method(Class_Image, "gamma=", Image_gamma_eq, 1);
+    rb_define_method(Class_Image, "geometry", Image_geometry, 0);
+    rb_define_method(Class_Image, "geometry=", Image_geometry_eq, 1);
+    rb_define_method(Class_Image, "gravity", Image_gravity, 0);
+    rb_define_method(Class_Image, "gravity=", Image_gravity_eq, 1);
+    rb_define_method(Class_Image, "image_type", Image_image_type, 0);
+    rb_define_method(Class_Image, "image_type=", Image_image_type_eq, 1);
+    rb_define_method(Class_Image, "interlace", Image_interlace, 0);
+    rb_define_method(Class_Image, "interlace=", Image_interlace_eq, 1);
+    rb_define_method(Class_Image, "iptc_profile", Image_iptc_profile, 0);
+    rb_define_method(Class_Image, "iptc_profile=", Image_iptc_profile_eq, 1);
+    rb_define_method(Class_Image, "iterations", Image_iterations, 0);        // do not document! Only used by Image#iterations=
+    rb_define_method(Class_Image, "iterations=", Image_iterations_eq, 1);        // do not document! Only used by Image#iterations=
+    rb_define_method(Class_Image, "matte_color", Image_matte_color, 0);
+    rb_define_method(Class_Image, "matte_color=", Image_matte_color_eq, 1);
+    rb_define_method(Class_Image, "mean_error_per_pixel", Image_mean_error_per_pixel, 0);
+    rb_define_method(Class_Image, "mime_type", Image_mime_type, 0);
+    rb_define_method(Class_Image, "monitor=", Image_monitor_eq, 1);
+    rb_define_method(Class_Image, "montage", Image_montage, 0);
+    rb_define_method(Class_Image, "normalized_mean_error", Image_normalized_mean_error, 0);
+    rb_define_method(Class_Image, "normalized_maximum_error", Image_normalized_maximum_error, 0);
+    rb_define_method(Class_Image, "number_colors", Image_number_colors, 0);
+    rb_define_method(Class_Image, "offset", Image_offset, 0);
+    rb_define_method(Class_Image, "offset=", Image_offset_eq, 1);
+    rb_define_method(Class_Image, "orientation", Image_orientation, 0);
+    rb_define_method(Class_Image, "orientation=", Image_orientation_eq, 1);
+    rb_define_method(Class_Image, "page", Image_page, 0);
+    rb_define_method(Class_Image, "page=", Image_page_eq, 1);
+    rb_define_method(Class_Image, "pixel_interpolation_method", Image_pixel_interpolation_method, 0);
+    rb_define_method(Class_Image, "pixel_interpolation_method=", Image_pixel_interpolation_method_eq, 1);
+    rb_define_method(Class_Image, "quality", Image_quality, 0);
+    rb_define_method(Class_Image, "quantum_depth", Image_quantum_depth, 0);
+    rb_define_method(Class_Image, "rendering_intent", Image_rendering_intent, 0);
+    rb_define_method(Class_Image, "rendering_intent=", Image_rendering_intent_eq, 1);
+    rb_define_method(Class_Image, "rows", Image_rows, 0);
+    rb_define_method(Class_Image, "scene", Image_scene, 0);
+    rb_define_method(Class_Image, "start_loop", Image_start_loop, 0);
+    rb_define_method(Class_Image, "start_loop=", Image_start_loop_eq, 1);
+    rb_define_method(Class_Image, "class_type", Image_class_type, 0);
+    rb_define_method(Class_Image, "class_type=", Image_class_type_eq, 1);
+    rb_define_method(Class_Image, "ticks_per_second", Image_ticks_per_second, 0);
+    rb_define_method(Class_Image, "ticks_per_second=", Image_ticks_per_second_eq, 1);
+    rb_define_method(Class_Image, "total_colors", Image_total_colors, 0);
+    rb_define_method(Class_Image, "total_ink_density", Image_total_ink_density, 0);
+    rb_define_method(Class_Image, "transparent_color", Image_transparent_color, 0);
+    rb_define_method(Class_Image, "transparent_color=", Image_transparent_color_eq, 1);
+    rb_define_method(Class_Image, "units", Image_units, 0);
+    rb_define_method(Class_Image, "units=", Image_units_eq, 1);
+    rb_define_method(Class_Image, "virtual_pixel_method", Image_virtual_pixel_method, 0);
+    rb_define_method(Class_Image, "virtual_pixel_method=", Image_virtual_pixel_method_eq, 1);
+    rb_define_method(Class_Image, "x_resolution", Image_x_resolution, 0);
+    rb_define_method(Class_Image, "x_resolution=", Image_x_resolution_eq, 1);
+    rb_define_method(Class_Image, "y_resolution", Image_y_resolution, 0);
+    rb_define_method(Class_Image, "y_resolution=", Image_y_resolution_eq, 1);
 
     rb_define_method(Class_Image, "adaptive_blur", Image_adaptive_blur, -1);
     rb_define_method(Class_Image, "adaptive_blur_channel", Image_adaptive_blur_channel, -1);
@@ -412,7 +522,6 @@ Init_RMagick2(void)
     rb_define_method(Class_Image, "liquid_rescale", Image_liquid_rescale, -1);
     rb_define_method(Class_Image, "magnify", Image_magnify, 0);
     rb_define_method(Class_Image, "magnify!", Image_magnify_bang, 0);
-    rb_define_method(Class_Image, "map", Image_map, -1);
     rb_define_method(Class_Image, "marshal_dump", Image_marshal_dump, 0);
     rb_define_method(Class_Image, "marshal_load", Image_marshal_load, 1);
     rb_define_method(Class_Image, "mask", Image_mask, -1);
@@ -484,7 +593,6 @@ Init_RMagick2(void)
     rb_define_method(Class_Image, "strip!", Image_strip_bang, 0);
     rb_define_method(Class_Image, "store_pixels", Image_store_pixels, 5);
     rb_define_method(Class_Image, "swirl", Image_swirl, 1);
-    rb_define_method(Class_Image, "sync_profiles", Image_sync_profiles, 0);
     rb_define_method(Class_Image, "texture_flood_fill", Image_texture_flood_fill, 5);
     rb_define_method(Class_Image, "threshold", Image_threshold, 1);
     rb_define_method(Class_Image, "thumbnail", Image_thumbnail, -1);
@@ -529,8 +637,6 @@ Init_RMagick2(void)
     rb_define_method(Class_ImageList, "deconstruct", ImageList_deconstruct, 0);
     rb_define_method(Class_ImageList, "display", ImageList_display, 0);
     rb_define_method(Class_ImageList, "flatten_images", ImageList_flatten_images, 0);
-    rb_define_method(Class_ImageList, "fx", ImageList_fx, -1);
-    rb_define_method(Class_ImageList, "map", ImageList_map, -1);
     rb_define_method(Class_ImageList, "montage", ImageList_montage, 0);
     rb_define_method(Class_ImageList, "morph", ImageList_morph, 1);
     rb_define_method(Class_ImageList, "mosaic", ImageList_mosaic, 0);
@@ -546,30 +652,31 @@ Init_RMagick2(void)
     Class_Draw = rb_define_class_under(Module_Magick, "Draw", rb_cObject);
     rb_define_alloc_func(Class_Draw, Draw_alloc);
 
-    DCL_ATTR_WRITER(Draw, affine)
-    DCL_ATTR_WRITER(Draw, align)
-    DCL_ATTR_WRITER(Draw, decorate)
-    DCL_ATTR_WRITER(Draw, density)
-    DCL_ATTR_WRITER(Draw, encoding)
-    DCL_ATTR_WRITER(Draw, fill)
-    DCL_ATTR_WRITER(Draw, fill_pattern)
-    DCL_ATTR_WRITER(Draw, font)
-    DCL_ATTR_WRITER(Draw, font_family)
-    DCL_ATTR_WRITER(Draw, font_stretch)
-    DCL_ATTR_WRITER(Draw, font_style)
-    DCL_ATTR_WRITER(Draw, font_weight)
-    DCL_ATTR_WRITER(Draw, gravity)
-    DCL_ATTR_WRITER(Draw, interline_spacing)
-    DCL_ATTR_WRITER(Draw, interword_spacing)
-    DCL_ATTR_WRITER(Draw, kerning)
-    DCL_ATTR_WRITER(Draw, pointsize)
-    DCL_ATTR_WRITER(Draw, rotation)
-    DCL_ATTR_WRITER(Draw, stroke)
-    DCL_ATTR_WRITER(Draw, stroke_pattern)
-    DCL_ATTR_WRITER(Draw, stroke_width)
-    DCL_ATTR_WRITER(Draw, text_antialias)
-    DCL_ATTR_WRITER(Draw, tile)
-    DCL_ATTR_WRITER(Draw, undercolor)
+    // Define the attributes
+    rb_define_method(Class_Draw, "affine=", Draw_affine_eq, 1);
+    rb_define_method(Class_Draw, "align=", Draw_align_eq, 1);
+    rb_define_method(Class_Draw, "decorate=", Draw_decorate_eq, 1);
+    rb_define_method(Class_Draw, "density=", Draw_density_eq, 1);
+    rb_define_method(Class_Draw, "encoding=", Draw_encoding_eq, 1);
+    rb_define_method(Class_Draw, "fill=", Draw_fill_eq, 1);
+    rb_define_method(Class_Draw, "fill_pattern=", Draw_fill_pattern_eq, 1);
+    rb_define_method(Class_Draw, "font=", Draw_font_eq, 1);
+    rb_define_method(Class_Draw, "font_family=", Draw_font_family_eq, 1);
+    rb_define_method(Class_Draw, "font_stretch=", Draw_font_stretch_eq, 1);
+    rb_define_method(Class_Draw, "font_style=", Draw_font_style_eq, 1);
+    rb_define_method(Class_Draw, "font_weight=", Draw_font_weight_eq, 1);
+    rb_define_method(Class_Draw, "gravity=", Draw_gravity_eq, 1);
+    rb_define_method(Class_Draw, "interline_spacing=", Draw_interline_spacing_eq, 1);
+    rb_define_method(Class_Draw, "interword_spacing=", Draw_interword_spacing_eq, 1);
+    rb_define_method(Class_Draw, "kerning=", Draw_kerning_eq, 1);
+    rb_define_method(Class_Draw, "pointsize=", Draw_pointsize_eq, 1);
+    rb_define_method(Class_Draw, "rotation=", Draw_rotation_eq, 1);
+    rb_define_method(Class_Draw, "stroke=", Draw_stroke_eq, 1);
+    rb_define_method(Class_Draw, "stroke_pattern=", Draw_stroke_pattern_eq, 1);
+    rb_define_method(Class_Draw, "stroke_width=", Draw_stroke_width_eq, 1);
+    rb_define_method(Class_Draw, "text_antialias=", Draw_text_antialias_eq, 1);
+    rb_define_method(Class_Draw, "tile=", Draw_tile_eq, 1);
+    rb_define_method(Class_Draw, "undercolor=", Draw_undercolor_eq, 1);
 
     rb_define_method(Class_Draw, "annotate", Draw_annotate, 6);
     rb_define_method(Class_Draw, "clone", Draw_clone, 0);
@@ -597,27 +704,27 @@ Init_RMagick2(void)
 
     rb_define_method(Class_DrawOptions, "initialize", DrawOptions_initialize, 0);
 
-    SHARE_ATTR_WRITER(DrawOptions, Draw, affine)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, align)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, decorate)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, density)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, encoding)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, fill)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, fill_pattern)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, font)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, font_family)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, font_stretch)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, font_style)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, font_weight)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, gravity)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, pointsize)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, rotation)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, stroke)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, stroke_pattern)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, stroke_width)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, text_antialias)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, tile)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, undercolor)
+    rb_define_method(Class_DrawOptions, "affine=", Draw_affine_eq, 1);
+    rb_define_method(Class_DrawOptions, "align=", Draw_align_eq, 1);
+    rb_define_method(Class_DrawOptions, "decorate=", Draw_decorate_eq, 1);
+    rb_define_method(Class_DrawOptions, "density=", Draw_density_eq, 1);
+    rb_define_method(Class_DrawOptions, "encoding=", Draw_encoding_eq, 1);
+    rb_define_method(Class_DrawOptions, "fill=", Draw_fill_eq, 1);
+    rb_define_method(Class_DrawOptions, "fill_pattern=", Draw_fill_pattern_eq, 1);
+    rb_define_method(Class_DrawOptions, "font=", Draw_font_eq, 1);
+    rb_define_method(Class_DrawOptions, "font_family=", Draw_font_family_eq, 1);
+    rb_define_method(Class_DrawOptions, "font_stretch=", Draw_font_stretch_eq, 1);
+    rb_define_method(Class_DrawOptions, "font_style=", Draw_font_style_eq, 1);
+    rb_define_method(Class_DrawOptions, "font_weight=", Draw_font_weight_eq, 1);
+    rb_define_method(Class_DrawOptions, "gravity=", Draw_gravity_eq, 1);
+    rb_define_method(Class_DrawOptions, "pointsize=", Draw_pointsize_eq, 1);
+    rb_define_method(Class_DrawOptions, "rotation=", Draw_rotation_eq, 1);
+    rb_define_method(Class_DrawOptions, "stroke=", Draw_stroke_eq, 1);
+    rb_define_method(Class_DrawOptions, "stroke_pattern=", Draw_stroke_pattern_eq, 1);
+    rb_define_method(Class_DrawOptions, "stroke_width=", Draw_stroke_width_eq, 1);
+    rb_define_method(Class_DrawOptions, "text_antialias=", Draw_text_antialias_eq, 1);
+    rb_define_method(Class_DrawOptions, "tile=", Draw_tile_eq, 1);
+    rb_define_method(Class_DrawOptions, "undercolor=", Draw_undercolor_eq, 1);
 
     /*-----------------------------------------------------------------------*/
     /* Class Magick::Pixel                                                   */
@@ -625,11 +732,6 @@ Init_RMagick2(void)
 
     Class_Pixel = rb_define_class_under(Module_Magick, "Pixel", rb_cObject);
 
-    // include Observable in Pixel for Image::View class
-    (void) rb_require("observer");
-    observable = rb_const_get(rb_cObject, rb_intern("Observable"));
-    rb_include_module(Class_Pixel, observable);
-
     // include Comparable
     rb_include_module(Class_Pixel, rb_mComparable);
 
@@ -637,21 +739,27 @@ Init_RMagick2(void)
     // and the deprecated "from_HSL".
     rb_define_alloc_func(Class_Pixel, Pixel_alloc);
     rb_define_singleton_method(Class_Pixel, "from_color", Pixel_from_color, 1);
-    rb_define_singleton_method(Class_Pixel, "from_HSL", Pixel_from_HSL, 1);
     rb_define_singleton_method(Class_Pixel, "from_hsla", Pixel_from_hsla, -1);
 
     // Define the RGBA attributes
-    DCL_ATTR_ACCESSOR(Pixel, red)
-    DCL_ATTR_ACCESSOR(Pixel, green)
-    DCL_ATTR_ACCESSOR(Pixel, blue)
-    DCL_ATTR_ACCESSOR(Pixel, alpha)
-    DCL_ATTR_ACCESSOR(Pixel, opacity)
+    rb_define_method(Class_Pixel, "red", Pixel_red, 0);
+    rb_define_method(Class_Pixel, "red=", Pixel_red_eq, 1);
+    rb_define_method(Class_Pixel, "green", Pixel_green, 0);
+    rb_define_method(Class_Pixel, "green=", Pixel_green_eq, 1);
+    rb_define_method(Class_Pixel, "blue", Pixel_blue, 0);
+    rb_define_method(Class_Pixel, "blue=", Pixel_blue_eq, 1);
+    rb_define_method(Class_Pixel, "alpha", Pixel_alpha, 0);
+    rb_define_method(Class_Pixel, "alpha=", Pixel_alpha_eq, 1);
 
     // Define the CMYK attributes
-    DCL_ATTR_ACCESSOR(Pixel, cyan)
-    DCL_ATTR_ACCESSOR(Pixel, magenta)
-    DCL_ATTR_ACCESSOR(Pixel, yellow)
-    DCL_ATTR_ACCESSOR(Pixel, black)
+    rb_define_method(Class_Pixel, "cyan", Pixel_cyan, 0);
+    rb_define_method(Class_Pixel, "cyan=", Pixel_cyan_eq, 1);
+    rb_define_method(Class_Pixel, "magenta", Pixel_magenta, 0);
+    rb_define_method(Class_Pixel, "magenta=", Pixel_magenta_eq, 1);
+    rb_define_method(Class_Pixel, "yellow", Pixel_yellow, 0);
+    rb_define_method(Class_Pixel, "yellow=", Pixel_yellow_eq, 1);
+    rb_define_method(Class_Pixel, "black", Pixel_black, 0);
+    rb_define_method(Class_Pixel, "black=", Pixel_black_eq, 1);
 
 
     // Define the instance methods
@@ -668,7 +776,6 @@ Init_RMagick2(void)
     rb_define_method(Class_Pixel, "marshal_dump", Pixel_marshal_dump, 0);
     rb_define_method(Class_Pixel, "marshal_load", Pixel_marshal_load, 1);
     rb_define_method(Class_Pixel, "to_color", Pixel_to_color, -1);
-    rb_define_method(Class_Pixel, "to_HSL", Pixel_to_HSL, 0);   // deprecated
     rb_define_method(Class_Pixel, "to_hsla", Pixel_to_hsla, 0);
     rb_define_method(Class_Pixel, "to_s", Pixel_to_s, 0);
 
@@ -684,23 +791,23 @@ Init_RMagick2(void)
     rb_define_method(Class_Montage, "freeze", rm_no_freeze, 0);
 
     // These accessors supply optional arguments for Magick::ImageList::Montage.new
-    DCL_ATTR_WRITER(Montage, background_color)
-    DCL_ATTR_WRITER(Montage, border_color)
-    DCL_ATTR_WRITER(Montage, border_width)
-    DCL_ATTR_WRITER(Montage, compose)
-    DCL_ATTR_WRITER(Montage, filename)
-    DCL_ATTR_WRITER(Montage, fill)
-    DCL_ATTR_WRITER(Montage, font)
-    DCL_ATTR_WRITER(Montage, frame)
-    DCL_ATTR_WRITER(Montage, geometry)
-    DCL_ATTR_WRITER(Montage, gravity)
-    DCL_ATTR_WRITER(Montage, matte_color)
-    DCL_ATTR_WRITER(Montage, pointsize)
-    DCL_ATTR_WRITER(Montage, shadow)
-    DCL_ATTR_WRITER(Montage, stroke)
-    DCL_ATTR_WRITER(Montage, texture)
-    DCL_ATTR_WRITER(Montage, tile)
-    DCL_ATTR_WRITER(Montage, title)
+    rb_define_method(Class_Montage, "background_color=", Montage_background_color_eq, 1);
+    rb_define_method(Class_Montage, "border_color=", Montage_border_color_eq, 1);
+    rb_define_method(Class_Montage, "border_width=", Montage_border_width_eq, 1);
+    rb_define_method(Class_Montage, "compose=", Montage_compose_eq, 1);
+    rb_define_method(Class_Montage, "filename=", Montage_filename_eq, 1);
+    rb_define_method(Class_Montage, "fill=", Montage_fill_eq, 1);
+    rb_define_method(Class_Montage, "font=", Montage_font_eq, 1);
+    rb_define_method(Class_Montage, "frame=", Montage_frame_eq, 1);
+    rb_define_method(Class_Montage, "geometry=", Montage_geometry_eq, 1);
+    rb_define_method(Class_Montage, "gravity=", Montage_gravity_eq, 1);
+    rb_define_method(Class_Montage, "matte_color=", Montage_matte_color_eq, 1);
+    rb_define_method(Class_Montage, "pointsize=", Montage_pointsize_eq, 1);
+    rb_define_method(Class_Montage, "shadow=", Montage_shadow_eq, 1);
+    rb_define_method(Class_Montage, "stroke=", Montage_stroke_eq, 1);
+    rb_define_method(Class_Montage, "texture=", Montage_texture_eq, 1);
+    rb_define_method(Class_Montage, "tile=", Montage_tile_eq, 1);
+    rb_define_method(Class_Montage, "title=", Montage_title_eq, 1);
 
     /*-----------------------------------------------------------------------*/
     /* Class Magick::Image::Info                                             */
@@ -718,53 +825,97 @@ Init_RMagick2(void)
     rb_define_method(Class_Info, "[]", Info_aref, -1);
     rb_define_method(Class_Info, "undefine", Info_undefine, 2);
 
-    DCL_ATTR_ACCESSOR(Info, antialias)
-    DCL_ATTR_ACCESSOR(Info, attenuate)
-    DCL_ATTR_ACCESSOR(Info, authenticate)
-    DCL_ATTR_ACCESSOR(Info, background_color)
-    DCL_ATTR_ACCESSOR(Info, border_color)
-    DCL_ATTR_ACCESSOR(Info, caption)
-    DCL_ATTR_ACCESSOR(Info, colorspace)
-    DCL_ATTR_ACCESSOR(Info, comment)
-    DCL_ATTR_ACCESSOR(Info, compression)
-    DCL_ATTR_ACCESSOR(Info, delay)
-    DCL_ATTR_ACCESSOR(Info, density)
-    DCL_ATTR_ACCESSOR(Info, depth)
-    DCL_ATTR_ACCESSOR(Info, dispose)
-    DCL_ATTR_ACCESSOR(Info, dither)
-    DCL_ATTR_ACCESSOR(Info, endian)
-    DCL_ATTR_ACCESSOR(Info, extract)
-    DCL_ATTR_ACCESSOR(Info, filename)
-    DCL_ATTR_ACCESSOR(Info, fill)
-    DCL_ATTR_ACCESSOR(Info, font)
-    DCL_ATTR_ACCESSOR(Info, format)
-    DCL_ATTR_ACCESSOR(Info, fuzz)
-    DCL_ATTR_ACCESSOR(Info, gravity)
-    DCL_ATTR_ACCESSOR(Info, group)
-    DCL_ATTR_ACCESSOR(Info, image_type)
-    DCL_ATTR_ACCESSOR(Info, interlace)
-    DCL_ATTR_ACCESSOR(Info, label)
-    DCL_ATTR_ACCESSOR(Info, matte_color)
-    DCL_ATTR_WRITER(Info, monitor)
-    DCL_ATTR_ACCESSOR(Info, monochrome)
-    DCL_ATTR_ACCESSOR(Info, number_scenes)
-    DCL_ATTR_ACCESSOR(Info, orientation)
-    DCL_ATTR_ACCESSOR(Info, origin)         // new in 6.3.1
-    DCL_ATTR_ACCESSOR(Info, page)
-    DCL_ATTR_ACCESSOR(Info, pointsize)
-    DCL_ATTR_ACCESSOR(Info, quality)
-    DCL_ATTR_ACCESSOR(Info, sampling_factor)
-    DCL_ATTR_ACCESSOR(Info, scene)
-    DCL_ATTR_ACCESSOR(Info, server_name)
-    DCL_ATTR_ACCESSOR(Info, size)
-    DCL_ATTR_ACCESSOR(Info, stroke)
-    DCL_ATTR_ACCESSOR(Info, stroke_width)
-    DCL_ATTR_WRITER(Info, texture)
-    DCL_ATTR_ACCESSOR(Info, tile_offset)
-    DCL_ATTR_ACCESSOR(Info, transparent_color)
-    DCL_ATTR_ACCESSOR(Info, undercolor)
-    DCL_ATTR_ACCESSOR(Info, units)
-    DCL_ATTR_ACCESSOR(Info, view)
+    // Define the attributes
+    rb_define_method(Class_Info, "antialias", Info_antialias, 0);
+    rb_define_method(Class_Info, "antialias=", Info_antialias_eq, 1);
+    rb_define_method(Class_Info, "attenuate", Info_attenuate, 0);
+    rb_define_method(Class_Info, "attenuate=", Info_attenuate_eq, 1);
+    rb_define_method(Class_Info, "authenticate", Info_authenticate, 0);
+    rb_define_method(Class_Info, "authenticate=", Info_authenticate_eq, 1);
+    rb_define_method(Class_Info, "background_color", Info_background_color, 0);
+    rb_define_method(Class_Info, "background_color=", Info_background_color_eq, 1);
+    rb_define_method(Class_Info, "border_color", Info_border_color, 0);
+    rb_define_method(Class_Info, "border_color=", Info_border_color_eq, 1);
+    rb_define_method(Class_Info, "caption", Info_caption, 0);
+    rb_define_method(Class_Info, "caption=", Info_caption_eq, 1);
+    rb_define_method(Class_Info, "colorspace", Info_colorspace, 0);
+    rb_define_method(Class_Info, "colorspace=", Info_colorspace_eq, 1);
+    rb_define_method(Class_Info, "comment", Info_comment, 0);
+    rb_define_method(Class_Info, "comment=", Info_comment_eq, 1);
+    rb_define_method(Class_Info, "compression", Info_compression, 0);
+    rb_define_method(Class_Info, "compression=", Info_compression_eq, 1);
+    rb_define_method(Class_Info, "delay", Info_delay, 0);
+    rb_define_method(Class_Info, "delay=", Info_delay_eq, 1);
+    rb_define_method(Class_Info, "density", Info_density, 0);
+    rb_define_method(Class_Info, "density=", Info_density_eq, 1);
+    rb_define_method(Class_Info, "depth", Info_depth, 0);
+    rb_define_method(Class_Info, "depth=", Info_depth_eq, 1);
+    rb_define_method(Class_Info, "dispose", Info_dispose, 0);
+    rb_define_method(Class_Info, "dispose=", Info_dispose_eq, 1);
+    rb_define_method(Class_Info, "dither", Info_dither, 0);
+    rb_define_method(Class_Info, "dither=", Info_dither_eq, 1);
+    rb_define_method(Class_Info, "endian", Info_endian, 0);
+    rb_define_method(Class_Info, "endian=", Info_endian_eq, 1);
+    rb_define_method(Class_Info, "extract", Info_extract, 0);
+    rb_define_method(Class_Info, "extract=", Info_extract_eq, 1);
+    rb_define_method(Class_Info, "filename", Info_filename, 0);
+    rb_define_method(Class_Info, "filename=", Info_filename_eq, 1);
+    rb_define_method(Class_Info, "fill", Info_fill, 0);
+    rb_define_method(Class_Info, "fill=", Info_fill_eq, 1);
+    rb_define_method(Class_Info, "font", Info_font, 0);
+    rb_define_method(Class_Info, "font=", Info_font_eq, 1);
+    rb_define_method(Class_Info, "format", Info_format, 0);
+    rb_define_method(Class_Info, "format=", Info_format_eq, 1);
+    rb_define_method(Class_Info, "fuzz", Info_fuzz, 0);
+    rb_define_method(Class_Info, "fuzz=", Info_fuzz_eq, 1);
+    rb_define_method(Class_Info, "gravity", Info_gravity, 0);
+    rb_define_method(Class_Info, "gravity=", Info_gravity_eq, 1);
+    rb_define_method(Class_Info, "image_type", Info_image_type, 0);
+    rb_define_method(Class_Info, "image_type=", Info_image_type_eq, 1);
+    rb_define_method(Class_Info, "interlace", Info_interlace, 0);
+    rb_define_method(Class_Info, "interlace=", Info_interlace_eq, 1);
+    rb_define_method(Class_Info, "label", Info_label, 0);
+    rb_define_method(Class_Info, "label=", Info_label_eq, 1);
+    rb_define_method(Class_Info, "matte_color", Info_matte_color, 0);
+    rb_define_method(Class_Info, "matte_color=", Info_matte_color_eq, 1);
+    rb_define_method(Class_Info, "monitor=", Info_monitor_eq, 1);
+    rb_define_method(Class_Info, "monochrome", Info_monochrome, 0);
+    rb_define_method(Class_Info, "monochrome=", Info_monochrome_eq, 1);
+    rb_define_method(Class_Info, "number_scenes", Info_number_scenes, 0);
+    rb_define_method(Class_Info, "number_scenes=", Info_number_scenes_eq, 1);
+    rb_define_method(Class_Info, "orientation", Info_orientation, 0);
+    rb_define_method(Class_Info, "orientation=", Info_orientation_eq, 1);
+    rb_define_method(Class_Info, "origin", Info_origin, 0);         // new in 6.3.1
+    rb_define_method(Class_Info, "origin=", Info_origin_eq, 1);         // new in 6.3.1
+    rb_define_method(Class_Info, "page", Info_page, 0);
+    rb_define_method(Class_Info, "page=", Info_page_eq, 1);
+    rb_define_method(Class_Info, "pointsize", Info_pointsize, 0);
+    rb_define_method(Class_Info, "pointsize=", Info_pointsize_eq, 1);
+    rb_define_method(Class_Info, "quality", Info_quality, 0);
+    rb_define_method(Class_Info, "quality=", Info_quality_eq, 1);
+    rb_define_method(Class_Info, "sampling_factor", Info_sampling_factor, 0);
+    rb_define_method(Class_Info, "sampling_factor=", Info_sampling_factor_eq, 1);
+    rb_define_method(Class_Info, "scene", Info_scene, 0);
+    rb_define_method(Class_Info, "scene=", Info_scene_eq, 1);
+    rb_define_method(Class_Info, "server_name", Info_server_name, 0);
+    rb_define_method(Class_Info, "server_name=", Info_server_name_eq, 1);
+    rb_define_method(Class_Info, "size", Info_size, 0);
+    rb_define_method(Class_Info, "size=", Info_size_eq, 1);
+    rb_define_method(Class_Info, "stroke", Info_stroke, 0);
+    rb_define_method(Class_Info, "stroke=", Info_stroke_eq, 1);
+    rb_define_method(Class_Info, "stroke_width", Info_stroke_width, 0);
+    rb_define_method(Class_Info, "stroke_width=", Info_stroke_width_eq, 1);
+    rb_define_method(Class_Info, "texture=", Info_texture_eq, 1);
+    rb_define_method(Class_Info, "tile_offset", Info_tile_offset, 0);
+    rb_define_method(Class_Info, "tile_offset=", Info_tile_offset_eq, 1);
+    rb_define_method(Class_Info, "transparent_color", Info_transparent_color, 0);
+    rb_define_method(Class_Info, "transparent_color=", Info_transparent_color_eq, 1);
+    rb_define_method(Class_Info, "undercolor", Info_undercolor, 0);
+    rb_define_method(Class_Info, "undercolor=", Info_undercolor_eq, 1);
+    rb_define_method(Class_Info, "units", Info_units, 0);
+    rb_define_method(Class_Info, "units=", Info_units_eq, 1);
+    rb_define_method(Class_Info, "view", Info_view, 0);
+    rb_define_method(Class_Info, "view=", Info_view_eq, 1);
 
     /*-----------------------------------------------------------------------*/
     /* Class Magick::KernelInfo                                              */
@@ -775,9 +926,7 @@ Init_RMagick2(void)
     rb_define_alloc_func(Class_KernelInfo, KernelInfo_alloc);
 
     rb_define_method(Class_KernelInfo, "initialize", KernelInfo_initialize, 1);
-    rb_define_method(Class_KernelInfo, "zero_nans", KernelInfo_zero_nans, 0);
     rb_define_method(Class_KernelInfo, "unity_add", KernelInfo_unity_add, 1);
-    rb_define_method(Class_KernelInfo, "show", KernelInfo_show, 0);
     rb_define_method(Class_KernelInfo, "scale", KernelInfo_scale, 2);
     rb_define_method(Class_KernelInfo, "scale_geometry", KernelInfo_scale_geometry, 1);
     rb_define_method(Class_KernelInfo, "clone", KernelInfo_clone, 0);
@@ -796,27 +945,29 @@ Init_RMagick2(void)
 
     rb_define_method(Class_PolaroidOptions, "initialize", PolaroidOptions_initialize, 0);
 
-    DCL_ATTR_WRITER(PolaroidOptions, shadow_color)
-    DCL_ATTR_WRITER(PolaroidOptions, border_color)
+    // Define the attributes
+    rb_define_method(Class_PolaroidOptions, "shadow_color=", PolaroidOptions_shadow_color_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "border_color=", PolaroidOptions_border_color_eq, 1);
+
     // The other attribute writer methods are implemented by Draw's functions
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, align)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, decorate)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, density)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, encoding)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, fill)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, fill_pattern)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, font)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, font_family)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, font_stretch)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, font_style)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, font_weight)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, gravity)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, pointsize)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, stroke)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, stroke_pattern)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, stroke_width)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, text_antialias)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, undercolor)
+    rb_define_method(Class_PolaroidOptions, "align=", Draw_align_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "decorate=", Draw_decorate_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "density=", Draw_density_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "encoding=", Draw_encoding_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "fill=", Draw_fill_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "fill_pattern=", Draw_fill_pattern_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "font=", Draw_font_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "font_family=", Draw_font_family_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "font_stretch=", Draw_font_stretch_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "font_style=", Draw_font_style_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "font_weight=", Draw_font_weight_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "gravity=", Draw_gravity_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "pointsize=", Draw_pointsize_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "stroke=", Draw_stroke_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "stroke_pattern=", Draw_stroke_pattern_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "stroke_width=", Draw_stroke_width_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "text_antialias=", Draw_text_antialias_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "undercolor=", Draw_undercolor_eq, 1);
 
 
     /*-----------------------------------------------------------------------*/
@@ -861,9 +1012,7 @@ Init_RMagick2(void)
     DEF_CONST(QuantumRange);
     DEF_CONST(MAGICKCORE_QUANTUM_DEPTH);
     DEF_CONSTV(OpaqueAlpha, QuantumRange);
-    DEF_CONST(OpaqueOpacity);
     DEF_CONSTV(TransparentAlpha, 0);
-    DEF_CONST(TransparentOpacity);
 
     version_constants();
     features_constant();
@@ -898,7 +1047,6 @@ Init_RMagick2(void)
         ENUMERATOR(UndefinedAlphaChannel)
         ENUMERATOR(ActivateAlphaChannel)
         ENUMERATOR(DeactivateAlphaChannel)
-        ENUMERATOR(ResetAlphaChannel)  /* deprecated */
         ENUMERATOR(SetAlphaChannel)
         ENUMERATOR(RemoveAlphaChannel)
         ENUMERATOR(CopyAlphaChannel)
@@ -907,7 +1055,6 @@ Init_RMagick2(void)
         ENUMERATOR(ShapeAlphaChannel)
         ENUMERATOR(TransparentAlphaChannel)
         ENUMERATOR(BackgroundAlphaChannel)
-        ENUMERATOR(FlattenAlphaChannel)
 #if defined(IMAGEMAGICK_GREATER_THAN_EQUAL_6_8_9)
         ENUMERATOR(AssociateAlphaChannel)
         ENUMERATOR(DisassociateAlphaChannel)
@@ -932,7 +1079,6 @@ Init_RMagick2(void)
         ENUMERATOR(YellowChannel)
         ENUMERATOR(OpacityChannel)
         ENUMERATOR(BlackChannel)
-        ENUMERATOR(MatteChannel)
         ENUMERATOR(IndexChannel)
         ENUMERATOR(GrayChannel)
         ENUMERATOR(AllChannels)
@@ -969,9 +1115,7 @@ Init_RMagick2(void)
         ENUMERATOR(HWBColorspace)
         ENUMERATOR(HSBColorspace)
         ENUMERATOR(LabColorspace)
-        ENUMERATOR(Rec601LumaColorspace)
         ENUMERATOR(Rec601YCbCrColorspace)
-        ENUMERATOR(Rec709LumaColorspace)
         ENUMERATOR(Rec709YCbCrColorspace)
         ENUMERATOR(LogColorspace)
         ENUMERATOR(CMYColorspace)
@@ -988,6 +1132,16 @@ Init_RMagick2(void)
         ENUMERATOR(HCLpColorspace)
         ENUMERATOR(YDbDrColorspace)
         ENUMERATORV(XyYColorspace, xyYColorspace)
+#endif
+#if defined(IMAGEMAGICK_7)
+#if defined(IMAGEMAGICK_GREATER_THAN_EQUAL_7_0_8)
+        ENUMERATOR(LinearGRAYColorspace)
+#endif
+#if defined(IMAGEMAGICK_GREATER_THAN_EQUAL_7_0_10)
+        ENUMERATOR(JzazbzColorspace)
+#endif
+#elif defined(IMAGEMAGICK_GREATER_THAN_EQUAL_6_9_10)
+        ENUMERATOR(LinearGRAYColorspace)
 #endif
     END_ENUM
 
@@ -1019,7 +1173,6 @@ Init_RMagick2(void)
         ENUMERATOR(CopyCyanCompositeOp)
         ENUMERATOR(CopyGreenCompositeOp)
         ENUMERATOR(CopyMagentaCompositeOp)
-        ENUMERATORV(CopyAlphaCompositeOp, CopyOpacityCompositeOp)
         ENUMERATOR(CopyRedCompositeOp)
         ENUMERATOR(CopyYellowCompositeOp)
         ENUMERATOR(DarkenCompositeOp)
@@ -1037,9 +1190,6 @@ Init_RMagick2(void)
         ENUMERATOR(DissolveCompositeOp)
         ENUMERATOR(ExclusionCompositeOp)
         ENUMERATOR(HardLightCompositeOp)
-#if defined(IMAGEMAGICK_GREATER_THAN_EQUAL_6_8_9)
-        ENUMERATOR(HardMixCompositeOp)
-#endif
         ENUMERATOR(HueCompositeOp)
         ENUMERATOR(InCompositeOp)
         ENUMERATOR(LightenCompositeOp)
@@ -1075,6 +1225,14 @@ Init_RMagick2(void)
         ENUMERATOR(UndefinedCompositeOp)
         ENUMERATOR(VividLightCompositeOp)
         ENUMERATOR(XorCompositeOp)
+#if defined(IMAGEMAGICK_GREATER_THAN_EQUAL_6_8_9)
+        ENUMERATOR(HardMixCompositeOp)
+#endif
+#if defined(IMAGEMAGICK_7)
+        ENUMERATOR(CopyAlphaCompositeOp)
+#else
+        ENUMERATORV(CopyAlphaCompositeOp, CopyOpacityCompositeOp)
+#endif
     END_ENUM
 
     // CompressionType constants
@@ -1207,7 +1365,6 @@ Init_RMagick2(void)
         ENUMERATOR(SouthWestGravity)
         ENUMERATOR(SouthGravity)
         ENUMERATOR(SouthEastGravity)
-        ENUMERATOR(StaticGravity)
     END_ENUM
 
     // ImageType constants
@@ -1215,15 +1372,23 @@ Init_RMagick2(void)
         ENUMERATOR(UndefinedType)
         ENUMERATOR(BilevelType)
         ENUMERATOR(GrayscaleType)
-        ENUMERATORV(GrayscaleAlphaType, GrayscaleMatteType)
         ENUMERATOR(PaletteType)
-        ENUMERATORV(PaletteAlphaType, PaletteMatteType)
         ENUMERATOR(TrueColorType)
-        ENUMERATORV(TrueColorAlphaType, TrueColorMatteType)
         ENUMERATOR(ColorSeparationType)
-        ENUMERATORV(ColorSeparationAlphaType, ColorSeparationMatteType)
         ENUMERATOR(OptimizeType)
+#if defined(IMAGEMAGICK_7)
+        ENUMERATOR(GrayscaleAlphaType)
+        ENUMERATOR(PaletteAlphaType)
+        ENUMERATOR(TrueColorAlphaType)
+        ENUMERATOR(ColorSeparationAlphaType)
+        ENUMERATOR(PaletteBilevelAlphaType)
+#else
+        ENUMERATORV(GrayscaleAlphaType, GrayscaleMatteType)
+        ENUMERATORV(PaletteAlphaType, PaletteMatteType)
+        ENUMERATORV(TrueColorAlphaType, TrueColorMatteType)
+        ENUMERATORV(ColorSeparationAlphaType, ColorSeparationMatteType)
         ENUMERATORV(PaletteBilevelAlphaType, PaletteBilevelMatteType)
+#endif
     END_ENUM
 
     // InterlaceType constants
@@ -1267,18 +1432,24 @@ Init_RMagick2(void)
     END_ENUM
 
     DEF_ENUM(MetricType)
-        ENUMERATORV(UndefinedErrorMetric, UndefinedMetric)
         ENUMERATOR(AbsoluteErrorMetric)
         ENUMERATOR(MeanAbsoluteErrorMetric)
-        ENUMERATORV(MeanErrorPerPixelErrorMetric, MeanErrorPerPixelMetric)
         ENUMERATOR(MeanSquaredErrorMetric)
         ENUMERATOR(PeakAbsoluteErrorMetric)
-        ENUMERATORV(PeakSignalToNoiseRatioErrorMetric, PeakSignalToNoiseRatioMetric)
         ENUMERATOR(RootMeanSquaredErrorMetric)
         ENUMERATOR(NormalizedCrossCorrelationErrorMetric)
         ENUMERATOR(FuzzErrorMetric)
 #if defined(IMAGEMAGICK_GREATER_THAN_EQUAL_6_8_9)
         ENUMERATOR(PerceptualHashErrorMetric)
+#endif
+#if defined(IMAGEMAGICK_7)
+        ENUMERATOR(UndefinedErrorMetric)
+        ENUMERATOR(MeanErrorPerPixelErrorMetric)
+        ENUMERATOR(PeakSignalToNoiseRatioErrorMetric)
+#else
+        ENUMERATORV(UndefinedErrorMetric, UndefinedMetric)
+        ENUMERATORV(MeanErrorPerPixelErrorMetric, MeanErrorPerPixelMetric)
+        ENUMERATORV(PeakSignalToNoiseRatioErrorMetric, PeakSignalToNoiseRatioMetric)
 #endif
     END_ENUM
 
@@ -1319,12 +1490,14 @@ Init_RMagick2(void)
     DEF_ENUM(PixelInterpolateMethod)
         ENUMERATOR(UndefinedInterpolatePixel)
         ENUMERATOR(AverageInterpolatePixel)
-        ENUMERATOR(BicubicInterpolatePixel)
         ENUMERATOR(BilinearInterpolatePixel)
-        ENUMERATOR(FilterInterpolatePixel)
         ENUMERATOR(IntegerInterpolatePixel)
         ENUMERATOR(MeshInterpolatePixel)
-        ENUMERATOR(NearestNeighborInterpolatePixel)
+#if defined(IMAGEMAGICK_7)
+        ENUMERATOR(NearestInterpolatePixel)
+#else
+        ENUMERATORV(NearestInterpolatePixel, NearestNeighborInterpolatePixel)
+#endif
         ENUMERATOR(SplineInterpolatePixel)
         ENUMERATOR(Average9InterpolatePixel)
         ENUMERATOR(Average16InterpolatePixel)
@@ -1392,6 +1565,7 @@ Init_RMagick2(void)
         ENUMERATOR(PoissonNoiseQuantumOperator)
         ENUMERATOR(UniformNoiseQuantumOperator)
         ENUMERATOR(CosineQuantumOperator)
+        ENUMERATOR(SetQuantumOperator)
         ENUMERATOR(SineQuantumOperator)
         ENUMERATOR(AddModulusQuantumOperator)
         ENUMERATOR(MeanQuantumOperator)
@@ -1444,7 +1618,6 @@ Init_RMagick2(void)
         ENUMERATOR(CharPixel)
         ENUMERATOR(DoublePixel)
         ENUMERATOR(FloatPixel)
-        ENUMERATOR(IntegerPixel)
         ENUMERATOR(LongPixel)
         ENUMERATOR(QuantumPixel)
         ENUMERATOR(ShortPixel)
@@ -1482,7 +1655,6 @@ Init_RMagick2(void)
         ENUMERATOR(BackgroundVirtualPixelMethod)
         ENUMERATOR(DitherVirtualPixelMethod)
         ENUMERATOR(RandomVirtualPixelMethod)
-        ENUMERATOR(ConstantVirtualPixelMethod)
         ENUMERATOR(MaskVirtualPixelMethod)
         ENUMERATOR(BlackVirtualPixelMethod)
         ENUMERATOR(GrayVirtualPixelMethod)
@@ -1612,56 +1784,52 @@ Init_RMagick2(void)
     // namespace. The only way to use these classes is via the Magick:: namespace.
 
     // Magick::AffineMatrix
-    Class_AffineMatrix = rb_struct_define(NULL, "sx", "rx", "ry", "sy", "tx", "ty", NULL);
-    rb_define_const(Module_Magick, "AffineMatrix", Class_AffineMatrix);
+    Class_AffineMatrix = rb_struct_define_under(Module_Magick, "AffineMatrix",
+                                                "sx", "rx", "ry", "sy", "tx", "ty", NULL);
 
     // Magick::Primary
-    Class_Primary = rb_struct_define(NULL, "x", "y", "z", NULL);
+    Class_Primary = rb_struct_define_under(Module_Magick, "Primary",
+                                           "x", "y", "z", NULL);
     rb_define_method(Class_Primary, "to_s", PrimaryInfo_to_s, 0);
-    rb_define_const(Module_Magick, "Primary", Class_Primary);
 
     // Magick::Chromaticity
-    Class_Chromaticity = rb_struct_define(NULL
-                                          , "red_primary"
-                                          , "green_primary"
-                                          , "blue_primary"
-                                          , "white_point"
-                                          , NULL);
+    Class_Chromaticity = rb_struct_define_under(Module_Magick, "Chromaticity",
+                                                "red_primary", "green_primary",
+                                                "blue_primary", "white_point", NULL);
     rb_define_method(Class_Chromaticity, "to_s", ChromaticityInfo_to_s, 0);
-    rb_define_const(Module_Magick, "Chromaticity", Class_Chromaticity);
 
     // Magick::Color
-    Class_Color = rb_struct_define(NULL, "name", "compliance", "color", NULL);
+    Class_Color = rb_struct_define_under(Module_Magick, "Color",
+                                         "name", "compliance", "color", NULL);
     rb_define_method(Class_Color, "to_s", Color_to_s, 0);
-    rb_define_const(Module_Magick, "Color", Class_Color);
 
     // Magick::Point
-    Class_Point = rb_struct_define(NULL, "x", "y", NULL);
-    rb_define_const(Module_Magick, "Point", Class_Point);
+    Class_Point = rb_struct_define_under(Module_Magick, "Point",
+                                         "x", "y", NULL);
 
     // Magick::Rectangle
-    Class_Rectangle = rb_struct_define(NULL, "width", "height", "x", "y", NULL);
+    Class_Rectangle = rb_struct_define_under(Module_Magick, "Rectangle",
+                                             "width", "height", "x", "y", NULL);
     rb_define_method(Class_Rectangle, "to_s", RectangleInfo_to_s, 0);
-    rb_define_const(Module_Magick, "Rectangle", Class_Rectangle);
 
     // Magick::Segment
-    Class_Segment = rb_struct_define(NULL, "x1", "y1", "x2", "y2", NULL);
+    Class_Segment = rb_struct_define_under(Module_Magick, "Segment",
+                                           "x1", "y1", "x2", "y2", NULL);
     rb_define_method(Class_Segment, "to_s", SegmentInfo_to_s, 0);
-    rb_define_const(Module_Magick, "Segment", Class_Segment);
 
     // Magick::Font
-    Class_Font = rb_struct_define(NULL, "name", "description",
-                                  "family", "style", "stretch", "weight",
-                                  "encoding", "foundry", "format", NULL);
+    Class_Font = rb_struct_define_under(Module_Magick, "Font",
+                                        "name", "description",
+                                        "family", "style", "stretch", "weight",
+                                        "encoding", "foundry", "format", NULL);
     rb_define_method(Class_Font, "to_s", Font_to_s, 0);
-    rb_define_const(Module_Magick, "Font", Class_Font);
 
     // Magick::TypeMetric
-    Class_TypeMetric = rb_struct_define(NULL, "pixels_per_em", "ascent", "descent",
-                                        "width", "height", "max_advance", "bounds",
-                                        "underline_position", "underline_thickness", NULL);
+    Class_TypeMetric = rb_struct_define_under(Module_Magick, "TypeMetric",
+                                              "pixels_per_em", "ascent", "descent",
+                                              "width", "height", "max_advance", "bounds",
+                                              "underline_position", "underline_thickness", NULL);
     rb_define_method(Class_TypeMetric, "to_s", TypeMetric_to_s, 0);
-    rb_define_const(Module_Magick, "TypeMetric", Class_TypeMetric);
 
 
     /*-----------------------------------------------------------------------*/
@@ -1671,8 +1839,6 @@ Init_RMagick2(void)
     SetFatalErrorHandler(rm_fatal_error_handler);
     SetErrorHandler(rm_error_handler);
     SetWarningHandler(rm_warning_handler);
-
-    RB_GC_GUARD(observable);
 }
 
 
@@ -1693,7 +1859,6 @@ test_Magick_version(void)
 {
     size_t version_number;
     const char *version_str;
-    int x, n;
     ID bypass = rb_intern("RMAGICK_BYPASS_VERSION_TEST");
 
     if (RTEST(rb_const_defined(rb_cObject, bypass)) && RTEST(rb_const_get(rb_cObject, bypass)))
@@ -1704,6 +1869,8 @@ test_Magick_version(void)
     version_str = GetMagickVersion(&version_number);
     if (version_number != MagickLibVersion)
     {
+        int n, x;
+
         // Extract the string "ImageMagick X.Y.Z"
         n = 0;
         for (x = 0; version_str[x] != '\0'; x++)
@@ -1715,7 +1882,8 @@ test_Magick_version(void)
         }
 
         rb_raise(rb_eRuntimeError,
-                 "This installation of RMagick was configured with %s %s but %.*s is in use.\n" ,
+                 "This installation of RMagick was configured with %s %s but %.*s is in use.\n"
+                 "Please re-install RMagick to correct the issue.\n",
                  MagickPackageName, MagickLibVersionText, x, version_str);
     }
 
@@ -1747,7 +1915,7 @@ version_constants(void)
     rb_obj_freeze(str);
     rb_define_const(Module_Magick, "Version", str);
 
-    sprintf(long_version,
+    snprintf(long_version, sizeof(long_version),
             "This is %s ($Date: 2009/12/20 02:33:33 $) Copyright (C) 2009 by Timothy P. Hunter\n"
             "Built with %s\n"
             "Built for %s\n"