rmagick 4.1.0.rc2 → 4.2.1

data/ext/RMagick/rmkinfo.c

@@ -28,10 +28,7 @@ rm_kernel_info_destroy(void *kernel)
 /**
  * Create a KernelInfo object.
  *
- * No Ruby usage (internal function)
- *
- * @param class the Ruby class to use
- * @return a new KernelInfo object
+ * @return [Magick::KernelInfo] a new KernelInfo object
  */
 VALUE
 KernelInfo_alloc(VALUE class)
@@ -42,12 +39,8 @@ KernelInfo_alloc(VALUE class)
 /**
  * KernelInfo object constructor
  *
- * Ruby usage:
- *   - @verbatim KernelInfo#initialize @endverbatim
- *
- * @param self this object
- * @param kernel_string kernel info string representation to be parsed
- * @return self
+ * @param kernel_string [String] kernel info string representation to be parsed
+ * @return [Magick::KernelInfo] self
  */
 VALUE
 KernelInfo_initialize(VALUE self, VALUE kernel_string)
@@ -66,7 +59,7 @@ KernelInfo_initialize(VALUE self, VALUE kernel_string)
     {
         if (kernel != (KernelInfo *) NULL)
         {
-            (void) DestroyKernelInfo(kernel);
+            DestroyKernelInfo(kernel);
         }
         rm_raise_exception(exception);
     }
@@ -88,22 +81,17 @@ KernelInfo_initialize(VALUE self, VALUE kernel_string)
 /**
  * Adds a given amount of the 'Unity' Convolution Kernel to the given pre-scaled and normalized Kernel.
  *
- * Ruby usage:
- *   - @verbatim KernelInfo#unity_add(scale) @endverbatim
- *
- * @param self this object
- * @param scale scale to add
+ * @param scale [Numeric] scale to add
  */
-
-/* UnityAddKernelInfo() was private function until IM 6.9 */
-MagickExport void UnityAddKernelInfo(KernelInfo *kernel, const double scale);
-
 VALUE
 KernelInfo_unity_add(VALUE self, VALUE scale)
 {
     if (!FIXNUM_P(scale))
         Check_Type(scale, T_FLOAT);
 
+    /* UnityAddKernelInfo() was private function until IM 6.9 */
+    MagickExport void UnityAddKernelInfo(KernelInfo *kernel, const double scale);
+
     UnityAddKernelInfo((KernelInfo*)DATA_PTR(self), NUM2DBL(scale));
     return Qnil;
 }
@@ -113,18 +101,10 @@ KernelInfo_unity_add(VALUE self, VALUE scale)
  * Scales the given kernel list by the given amount, with or without normalization
  * of the sum of the kernel values (as per given flags).
  *
- * Ruby usage:
- *   - @verbatim KernelInfo#scale(scale, flags) @endverbatim
- *
- * @param scale scale to use
- * @param flags one of Magick::NormalizeValue, Magick::CorrelateNormalizeValue,
- *                     and/or Magick::PercentValue
- * @param self this object
+ * @param scale [Numeric] scale to use
+ * @param flags [Magick::GeometryFlags] one of Magick::NormalizeValue, Magick::CorrelateNormalizeValue,
+ *   and/or Magick::PercentValue
  */
-
-/* ScaleKernelInfo() was private function until IM 6.9 */
-MagickExport void ScaleKernelInfo(KernelInfo *kernel, const double scaling_factor,const GeometryFlags normalize_flags);
-
 VALUE
 KernelInfo_scale(VALUE self, VALUE scale, VALUE flags)
 {
@@ -138,19 +118,18 @@ KernelInfo_scale(VALUE self, VALUE scale, VALUE flags)
     else
         rb_raise(rb_eArgError, "expected Integer or Magick::GeometryFlags to specify flags");
 
+    /* ScaleKernelInfo() was private function until IM 6.9 */
+    MagickExport void ScaleKernelInfo(KernelInfo *kernel, const double scaling_factor, const GeometryFlags normalize_flags);
+
     ScaleKernelInfo((KernelInfo*)DATA_PTR(self), NUM2DBL(scale), geoflags);
     return Qnil;
 }
 
 /**
- * Takes a geometry argument string, typically provided as a "-set option:convolve:scale {geometry}" user setting,
+ * Takes a geometry argument string, typically provided as a +-set option:convolve:scale {geometry}+ user setting,
  * and modifies the kernel according to the parsed arguments of that setting.
  *
- * Ruby usage:
- *   - @verbatim KernelInfo#scale_geometry(geometry) @endverbatim
- *
- * @param geometry geometry string to parse and apply
- * @param self this object
+ * @param geometry [String] geometry string to parse and apply
  */
 VALUE
 KernelInfo_scale_geometry(VALUE self, VALUE geometry)
@@ -163,11 +142,7 @@ KernelInfo_scale_geometry(VALUE self, VALUE geometry)
 /**
  * Creates a new clone of the object so that its can be modified without effecting the original.
  *
- * Ruby usage:
- *   - @verbatim KernelInfo#clone @endverbatim
- *
- * @param self this object
- * @return new KernelInfo instance
+ * @return [Magick::KernelInfo] new KernelInfo object
  */
 VALUE
 KernelInfo_clone(VALUE self)
@@ -181,50 +156,9 @@ KernelInfo_clone(VALUE self)
  * kernels used for special purposes such as gaussian blurring, skeleton
  * pruning, and edge distance determination.
  *
- * Ruby usage:
- *   - @verbatim KernelInfo.builtin(kernel, geometry = nil) @endverbatim
- *
- * @parms kernel one of Magick::KernelInfoType enums:
- *                      Magick::UndefinedKernel
- *                      Magick::UnityKernel
- *                      Magick::GaussianKernel
- *                      Magick::DoGKernel
- *                      Magick::LoGKernel
- *                      Magick::BlurKernel
- *                      Magick::CometKernel
- *                      Magick::LaplacianKernel
- *                      Magick::SobelKernel
- *                      Magick::FreiChenKernel
- *                      Magick::RobertsKernel
- *                      Magick::PrewittKernel
- *                      Magick::CompassKernel
- *                      Magick::KirschKernel
- *                      Magick::DiamondKernel
- *                      Magick::SquareKernel
- *                      Magick::RectangleKernel
- *                      Magick::OctagonKernel
- *                      Magick::DiskKernel
- *                      Magick::PlusKernel
- *                      Magick::CrossKernel
- *                      Magick::RingKernel
- *                      Magick::PeaksKernel
- *                      Magick::EdgesKernel
- *                      Magick::CornersKernel
- *                      Magick::DiagonalsKernel
- *                      Magick::LineEndsKernel
- *                      Magick::LineJunctionsKernel
- *                      Magick::RidgesKernel
- *                      Magick::ConvexHullKernel
- *                      Magick::ThinSEKernel
- *                      Magick::SkeletonKernel
- *                      Magick::ChebyshevKernel
- *                      Magick::ManhattanKernel
- *                      Magick::OctagonalKernel
- *                      Magick::EuclideanKernel
- *                      Magick::UserDefinedKernel
- *                      Magick::BinomialKernel
- * @param geometry geometry to pass to default kernel
- * @return KernelInfo instance
+ * @param what [Magick::KernelInfoType] kernel one of Magick::KernelInfoType enums
+ * @param geometry [String] geometry to pass to default kernel
+ * @return [Magick::KernelInfo] a new KernelInfo object
  */
 VALUE
 KernelInfo_builtin(VALUE self, VALUE what, VALUE geometry)
@@ -247,7 +181,7 @@ KernelInfo_builtin(VALUE self, VALUE what, VALUE geometry)
     {
         if (kernel != (KernelInfo *) NULL)
         {
-            (void) DestroyKernelInfo(kernel);
+            DestroyKernelInfo(kernel);
         }
         rm_raise_exception(exception);
     }

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                                                 */
@@ -218,67 +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_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, 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_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_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);
@@ -536,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);
@@ -587,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                                                   */
@@ -615,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);
 
@@ -630,16 +742,24 @@ Init_RMagick2(void)
     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)
+    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
@@ -671,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                                             */
@@ -705,52 +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, 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                                              */
@@ -780,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);
 
 
     /*-----------------------------------------------------------------------*/
@@ -965,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
 
@@ -1607,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);
 
 
     /*-----------------------------------------------------------------------*/
@@ -1666,8 +1839,6 @@ Init_RMagick2(void)
     SetFatalErrorHandler(rm_fatal_error_handler);
     SetErrorHandler(rm_error_handler);
     SetWarningHandler(rm_warning_handler);
-
-    RB_GC_GUARD(observable);
 }
 
 
@@ -1688,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)))
@@ -1699,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++)
@@ -1710,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);
     }
 
@@ -1742,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"