magickwand 0.1.0 → 0.2.0

data/Rakefile

@@ -2,7 +2,7 @@ require "rake/extensiontask"
 
 spec = Gem::Specification.new do |s|
   s.name = "magickwand"
-  s.version = "0.1.0"
+  s.version = "0.2.0"
   s.platform = Gem::Platform::RUBY
   s.extensions = FileList["ext/magickwand/extconf.rb"]
   s.authors = ["Tim Hunter"]

data/ext/magickwand/drawing.c

@@ -0,0 +1,1850 @@
+
+/*
+ *  drawing.c
+ *  $Id: drawing.c 285 2009-08-14 23:09:24Z rmagick $
+ *  Copyright (C) 2009 Timothy Paul Hunter
+ */
+
+#include "magickwand.h"
+
+
+static void drawing_destroy(void *);
+static VALUE polyshape(int, VALUE *, VALUE, void (*)(DrawingWand *, const unsigned long, const PointInfo *));
+
+
+static VALUE drawing_allocate(VALUE klass)
+{
+    Drawing *drawing;
+    return Data_Make_Struct(klass, Drawing, NULL, drawing_destroy, drawing);
+}
+
+
+
+
+static void drawing_destroy(void *p)
+{
+    Drawing *drawing = (Drawing *)p;
+
+    if (drawing->wand)
+    {
+        drawing->wand = DestroyDrawingWand(drawing->wand);
+    }
+}
+
+
+
+
+/*
+ *  drawing = MagickWand::Drawing.new
+ */
+static VALUE drawing_initialize(VALUE obj)
+{
+    Drawing *drawing;
+
+    Data_Get_Struct(obj, Drawing, drawing);
+    drawing->wand = NewDrawingWand();
+    return obj;
+}
+
+
+
+
+/*
+ *  Construct a new Drawing object
+ */
+VALUE mwr_drawing_new(void)
+{
+    VALUE obj;
+    Drawing *drawing;
+
+    obj = Data_Make_Struct(mwr_cDrawing, Drawing, NULL, drawing_destroy, drawing);
+    drawing->wand = NewDrawingWand();
+    return obj;
+}
+
+
+
+
+/*
+ *  drawing2 = drawing.dup
+ *  drawing2 = drawing.clone
+ */
+static VALUE drawing_initialize_copy(VALUE obj, VALUE obj2)
+{
+    Drawing *drawing, *drawing2;
+
+    if (obj == obj2)
+    {
+        return obj;
+    }
+
+    Data_Get_Struct(obj, Drawing, drawing);
+    Data_Get_Struct(obj2, Drawing, drawing2);
+
+    drawing->wand = CloneDrawingWand(drawing2->wand);
+    return obj;
+}
+
+
+
+
+static VALUE drawing_inspect(VALUE obj)
+{
+    Drawing *drawing;
+    volatile VALUE string;
+    char *text, *start, *end;
+    size_t len;
+
+    Data_Get_Struct(obj, Drawing, drawing);
+
+    text = DrawGetVectorGraphics(drawing->wand);
+
+    // The drawing primitives are contained in the <vector-graphics> element.
+    // Delete everything else.
+    if (text)
+    {
+        start = strstr(text, "<vector-graphics>");
+        if (start)
+        {
+            end = strstr(start, "</vector-graphics>");
+            if (end)
+            {
+                start += 17;
+                len = end - start;
+                if (start[len-1] == '\n')
+                {
+                    len -= 1;
+                }
+                string = rb_str_new(start, len);
+            }
+            else
+            {
+                goto no_graphics;
+            }
+        }
+        else
+        {
+            goto no_graphics;
+        }
+
+        RelinquishMagickMemory(text);
+    }
+    else
+    {
+        goto no_graphics;
+    }
+
+    return string;
+
+no_graphics:
+    return rb_call_super(0, NULL);
+
+}
+
+
+
+
+/*
+ *  drawing.affine(sx, sy, rx, ry, tx, ty)
+ */
+static VALUE drawing_affine(VALUE obj, VALUE sx, VALUE sy, VALUE rx, VALUE ry, VALUE tx, VALUE ty)
+{
+    Drawing *drawing;
+    AffineMatrix affine;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+
+    affine.sx = NUM2DBL(sx);
+    affine.sy = NUM2DBL(sy);
+    affine.rx = NUM2DBL(rx);
+    affine.ry = NUM2DBL(ry);
+    affine.tx = NUM2DBL(tx);
+    affine.ty = NUM2DBL(ty);
+
+    DrawAffine(drawing->wand, &affine);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  drawing.annotation text, :x=>0, y=>0
+ */
+static VALUE drawing_annotation(int argc, VALUE *argv, VALUE obj)
+{
+    Drawing *drawing;
+    VALUE str, options, v;
+    double x, y;
+    unsigned char *text;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+
+    (void)rb_scan_args(argc, argv, "11", &str, &options);
+    text = (unsigned char *)StringValuePtr(str);
+
+    x = mwr_get_option(options, "x", &v) ? NUM2DBL(v) : 0.0;
+    y = mwr_get_option(options, "y", &v) ? NUM2DBL(v) : 0.0;
+    DrawAnnotation(drawing->wand, x, y, text);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+/*
+ *  drawing.arc(width, height, start, end, :x=>0, :y=>0)
+ */
+static VALUE drawing_arc(int argc, VALUE *argv, VALUE obj)
+{
+    Drawing *drawing;
+    double sx, sy, ex, ey, sd, ed;
+    VALUE width, height, start, end, options, v;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+
+    (void)rb_scan_args(argc, argv, "41", &width, &height, &start, &end, &options);
+    sx = mwr_get_option(options, "x", &v) ? NUM2DBL(v) : 0.0;
+    sy = mwr_get_option(options, "y", &v) ? NUM2DBL(v) : 0.0;
+    ex = sx + NUM2DBL(width);
+    ey = sy + NUM2DBL(height);
+    sd = NUM2DBL(start);
+    ed = NUM2DBL(end);
+
+    DrawArc(drawing->wand, sx, sy, ex, ey, sd, ed);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  drawing.bezier(x1, y1, ..., xN, yN)
+ */
+static VALUE drawing_bezier(int argc, VALUE *argv, VALUE obj)
+{
+    return polyshape(argc, argv, obj, DrawBezier);
+}
+
+
+
+
+/*
+ *  drawing.circle r, :x=>0, :y=>0
+ */
+static VALUE drawing_circle(int argc, VALUE *argv, VALUE obj)
+{
+    Drawing *drawing;
+    VALUE r, v, options;
+    double x, y;
+    double radius;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+
+    (void)rb_scan_args(argc, argv, "11", &r, &options);
+    radius = NUM2DBL(r);
+    if (radius <= 0.0)
+    {
+        rb_raise(rb_eArgError, "radius must be positive (got %g)", radius);
+    }
+
+    x = mwr_get_option(options, "x", &v) ? NUM2DBL(v) : 0.0;
+    y = mwr_get_option(options, "y", &v) ? NUM2DBL(v) : 0.0;
+    DrawCircle(drawing->wand, x, y, x+radius, y);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+static VALUE draw_color(int argc, VALUE *argv, VALUE obj,
+    void (*f)(DrawingWand *, const double, const double, const PaintMethod))
+{
+    Drawing *drawing;
+    VALUE v, x, y, options;
+    double px, py;
+    PaintMethod paint_method;
+    PixelWand *pixelwand;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+
+    (void)rb_scan_args(argc, argv, "21", &x, &y, &options);
+    px = NUM2DBL(x);
+    py = NUM2DBL(y);
+
+    (void) mwr_get_option(options, "method", &v);
+    paint_method = mwr_string_to_paintmethod(v, PointMethod, RaiseUndefinedOption);
+    if (paint_method == FillToBorderMethod)
+    {
+#if defined(HAVE_DRAWSETBORDERCOLOR)
+        (void) mwr_get_option(options, "bordercolor", &v);
+        pixelwand = NewPixelWand();
+        PixelSetColor(pixelwand, StringValuePtr(v));
+        DrawSetBorderColor(drawing->wand, pixelwand);
+        DestroyPixelWand(pixelwand);
+#else
+        rb_warning("MagickWand: The :bordercolor option is not supported by this release of ImageMagick");
+        pixelwand = pixelwand;
+#endif
+    }
+
+    (*f)(drawing->wand, px, py, paint_method);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  drawing.color(x, y, :method=>"point", :bordercolor=>"#dfdfdfdfdfdf")
+ */
+static VALUE drawing_color(int argc, VALUE *argv, VALUE obj)
+{
+    return draw_color(argc, argv, obj, DrawColor);
+}
+
+
+
+
+/*
+ *  drawing.composite(wand, :x=>0, :y=>0, :width=>0, :height=>0, :compose=>"over")
+ */
+static VALUE drawing_composite(int argc, VALUE *argv, VALUE obj)
+{
+    Drawing *drawing;
+    Wand *composite_wand;
+    VALUE v, options, compose_obj;
+    double x, y, width, height;
+    CompositeOperator compose;
+
+    rb_check_frozen(obj);
+
+    (void)rb_scan_args(argc, argv, "11", &compose_obj, &options);
+    x = mwr_get_option(options, "x", &v) ? NUM2DBL(v) : 0.0;
+    y = mwr_get_option(options, "y", &v) ? NUM2DBL(v) : 0.0;
+    width = mwr_get_option(options, "width", &v) ? NUM2DBL(v) : 0.0;
+    height = mwr_get_option(options, "height", &v) ? NUM2DBL(v) : 0.0;
+    (void) mwr_get_option(options, "compose", &v);
+    compose = mwr_string_to_composetype(v, OverCompositeOp, RaiseUndefinedOption);
+
+    Data_Get_Struct(obj, Drawing, drawing);
+    Data_Get_Struct(compose_obj, Wand, composite_wand);
+
+    DrawComposite(drawing->wand, compose, x, y, width, height, composite_wand->magickwand);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  drawing.ellipse(rx, ry, :start=>0, :end=>360, :x=>0, :y=>0)
+ *  :x and :y are the origin.
+ */
+static VALUE drawing_ellipse(int argc, VALUE *argv, VALUE obj)
+{
+    Drawing *drawing;
+    VALUE x_rad, y_rad, options, v;
+    double rx, ry, cx, cy;
+    double start, end;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+
+    (void)rb_scan_args(argc, argv, "21", &x_rad, &y_rad, &options);
+    rx = NUM2DBL(x_rad);
+    ry = NUM2DBL(y_rad);
+    cx = mwr_get_option(options, "x", &v) ? NUM2DBL(v) : 0.0;
+    cy = mwr_get_option(options, "y", &v) ? NUM2DBL(v) : 0.0;
+    start = mwr_get_option(options, "start", &v) ? NUM2DBL(v) : 0.0;
+    end = mwr_get_option(options, "end", &v) ? NUM2DBL(v) : 360.0;
+
+    DrawEllipse(drawing->wand, cx, cy, rx, ry, start, end);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  drawing.line(x1, y1, x2, y2)
+ */
+static VALUE drawing_line(VALUE obj, VALUE x1, VALUE y1, VALUE x2, VALUE y2)
+{
+    Drawing *drawing;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+
+    DrawLine(drawing->wand, NUM2DBL(x1), NUM2DBL(y1), NUM2DBL(x2), NUM2DBL(y2));
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  drawing.matte(x, y, :method=>"point", :bordermatte=>"#dfdfdfdfdfdf")
+ */
+static VALUE drawing_matte(int argc, VALUE *argv, VALUE obj)
+{
+    return draw_color(argc, argv, obj, DrawMatte);
+}
+
+
+
+
+/*
+ *  drawing.close_path()
+ */
+static VALUE drawing_path_close(VALUE obj)
+{
+    Drawing *drawing;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawPathClose(drawing->wand);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+static VALUE path_curve_to(VALUE obj, VALUE x1, VALUE y1,
+    VALUE x2, VALUE y2, VALUE x, VALUE y,
+    void (*f)(DrawingWand *, const double, const double, const double,
+              const double, const double, const double))
+{
+    Drawing *drawing;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+    (*f)(drawing->wand, NUM2DBL(x1), NUM2DBL(y1), NUM2DBL(x2), NUM2DBL(y2), NUM2DBL(x), NUM2DBL(y));
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+/*
+ *  path.curve_to_absolute(x1, y1, x2, y2, x, y)
+ */
+static VALUE drawing_path_curve_to_absolute(VALUE obj, VALUE x1, VALUE y1,
+    VALUE x2, VALUE y2, VALUE x, VALUE y)
+{
+    return path_curve_to(obj, x1, y1, x2, y2, x, y, DrawPathCurveToAbsolute);
+}
+
+
+
+
+/*
+ *  path.curve_to_relative(x1, y1, x2, y2, x, y)
+ */
+static VALUE drawing_path_curve_to_relative(VALUE obj, VALUE x1, VALUE y1,
+    VALUE x2, VALUE y2, VALUE x, VALUE y)
+{
+    return path_curve_to(obj, x1, y1, x2, y2, x, y, DrawPathCurveToRelative);
+}
+
+
+
+
+static VALUE path_curve_to_quadratic_bezier(VALUE obj,
+    VALUE x1, VALUE y1, VALUE x, VALUE y,
+    void (*f)(DrawingWand *, const double, const double, const double, const double))
+{
+    Drawing *drawing;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+    (*f)(drawing->wand, NUM2DBL(x1), NUM2DBL(y1), NUM2DBL(x), NUM2DBL(y));
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  path.curve_to_quadratic_bezier_absolute(x1, y1, x, y)
+ */
+static VALUE drawing_path_curve_to_quadratic_bezier_absolute(VALUE obj,
+    VALUE x1, VALUE y1, VALUE x, VALUE y)
+{
+    return path_curve_to_quadratic_bezier(obj, x1, y1, x, y, DrawPathCurveToQuadraticBezierAbsolute);
+}
+
+
+
+
+/*
+ *  path.curve_to_quadratic_bezier_relative(x1, y1, x, y)
+ */
+static VALUE drawing_path_curve_to_quadratic_bezier_relative(VALUE obj,
+    VALUE x1, VALUE y1, VALUE x, VALUE y)
+{
+    return path_curve_to_quadratic_bezier(obj, x1, y1, x, y, DrawPathCurveToQuadraticBezierRelative);
+}
+
+
+
+
+static VALUE path_curve_to_quadratic_bezier_smooth(VALUE obj, VALUE x, VALUE y,
+    void (*f)(DrawingWand *, const double, const double))
+{
+    Drawing *drawing;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+    (*f)(drawing->wand, NUM2DBL(x), NUM2DBL(y));
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  path.curve_to_quadratic_bezier_smooth_absolute(x, y)
+ */
+static VALUE drawing_path_curve_to_quadratic_bezier_smooth_absolute(VALUE obj, VALUE x, VALUE y)
+{
+    return path_curve_to_quadratic_bezier_smooth(obj, x, y, DrawPathCurveToQuadraticBezierSmoothAbsolute);
+}
+
+
+
+
+/*
+ *  path.curve_to_quadratic_bezier_smooth_relative(x, y)
+ */
+static VALUE drawing_path_curve_to_quadratic_bezier_smooth_relative(VALUE obj, VALUE x, VALUE y)
+{
+    return path_curve_to_quadratic_bezier_smooth(obj, x, y, DrawPathCurveToQuadraticBezierSmoothRelative);
+}
+
+
+
+
+static VALUE path_curve_to_smooth(VALUE obj, VALUE x2, VALUE y2, VALUE x, VALUE y,
+    void (*f)(DrawingWand *, const double, const double, const double, const double))
+{
+    Drawing *drawing;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+    (*f)(drawing->wand, NUM2DBL(x2), NUM2DBL(y2), NUM2DBL(x), NUM2DBL(y));
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  path.curve_to_smooth_absolute(x2, y2, x, y)
+ */
+static VALUE drawing_path_curve_to_smooth_absolute(VALUE obj, VALUE x2, VALUE y2, VALUE x, VALUE y)
+{
+    return path_curve_to_smooth(obj, x2, y2, x, y, DrawPathCurveToSmoothAbsolute);
+}
+
+
+
+
+/*
+ *  path.curve_to_smooth_relative(x2, y2, x, y)
+ */
+static VALUE drawing_path_curve_to_smooth_relative(VALUE obj, VALUE x2, VALUE y2, VALUE x, VALUE y)
+{
+    return path_curve_to_smooth(obj, x2, y2, x, y, DrawPathCurveToSmoothRelative);
+}
+
+
+
+
+static VALUE path_elliptic_arc(VALUE obj, VALUE rx, VALUE ry,
+    VALUE x_axis_rotation, VALUE large_arc_flag, VALUE sweep_flag, VALUE x, VALUE y,
+    void (*f)(DrawingWand *, const double, const double, const double,
+              MagickBooleanType, MagickBooleanType, const double, const double))
+{
+    Drawing *drawing;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+    (*f)(drawing->wand, NUM2DBL(rx), NUM2DBL(ry), NUM2DBL(x_axis_rotation),
+         RTEST(large_arc_flag), RTEST(sweep_flag), NUM2DBL(x), NUM2DBL(y));
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  path.elliptic_arc_absolute(rx, ry, x_axis_rotation, large_arc_flag, sweep_flag, x, y)
+ */
+static VALUE drawing_path_elliptic_arc_absolute(VALUE obj, VALUE rx, VALUE ry,
+    VALUE x_axis_rotation, VALUE large_arc_flag, VALUE sweep_flag, VALUE x, VALUE y)
+{
+    return path_elliptic_arc(obj, rx, ry, x_axis_rotation, large_arc_flag, sweep_flag, x, y,
+                             DrawPathEllipticArcAbsolute);
+}
+
+
+
+
+/*
+ *  path.elliptic_arc_relative(rx, ry, x_axis_rotation, large_arc_flag, sweep_flag, x, y)
+ */
+static VALUE drawing_path_elliptic_arc_relative(VALUE obj, VALUE rx, VALUE ry,
+    VALUE x_axis_rotation, VALUE large_arc_flag, VALUE sweep_flag, VALUE x, VALUE y)
+{
+    return path_elliptic_arc(obj, rx, ry, x_axis_rotation, large_arc_flag, sweep_flag, x, y,
+                             DrawPathEllipticArcRelative);
+}
+
+
+
+
+static VALUE path_line_to(VALUE obj, VALUE x, VALUE y,
+    void (*f)(DrawingWand *, const double, const double))
+{
+    Drawing *drawing;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+    (*f)(drawing->wand, NUM2DBL(x), NUM2DBL(y));
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  path.line_to_relative(x, y)
+ */
+static VALUE drawing_path_line_to_relative(VALUE obj, VALUE x, VALUE y)
+{
+    return path_line_to(obj, x, y, DrawPathLineToRelative);
+}
+
+
+
+
+/*
+ *  path.line_to_absolute(x, y)
+ */
+static VALUE drawing_path_line_to_absolute(VALUE obj, VALUE x, VALUE y)
+{
+    return path_line_to(obj, x, y, DrawPathLineToAbsolute);
+}
+
+
+
+
+static VALUE path_line_to_direction(VALUE obj, VALUE coord,
+    void (*f)(DrawingWand *, const double))
+{
+    Drawing *drawing;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+    (*f)(drawing->wand, NUM2DBL(coord));
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  path.line_to_horizontal_absolute(x)
+ */
+static VALUE drawing_path_line_to_horizontal_absolute(VALUE obj, VALUE x)
+{
+    return path_line_to_direction(obj, x, DrawPathLineToHorizontalAbsolute);
+}
+
+
+
+
+/*
+ *  path.line_to_horizontal_relative(x)
+ */
+static VALUE drawing_path_line_to_horizontal_relative(VALUE obj, VALUE x)
+{
+    return path_line_to_direction(obj, x, DrawPathLineToHorizontalRelative);
+}
+
+
+
+
+/*
+ *  path.line_to_vertical_absolute(y)
+ */
+static VALUE drawing_path_line_to_vertical_absolute(VALUE obj, VALUE y)
+{
+    return path_line_to_direction(obj, y, DrawPathLineToVerticalAbsolute);
+}
+
+
+
+
+/*
+ *  path.line_to_vertical_relative(y)
+ */
+static VALUE drawing_path_line_to_vertical_relative(VALUE obj, VALUE y)
+{
+    return path_line_to_direction(obj, y, DrawPathLineToVerticalRelative);
+}
+
+
+
+
+/*
+ *  path.move_to_absolute(x, y)
+ */
+static VALUE drawing_path_move_to_absolute(VALUE obj, VALUE x, VALUE y)
+{
+    return path_line_to(obj, x, y, DrawPathMoveToAbsolute);
+}
+
+
+
+
+/*
+ *  path.move_to_relative(x, y)
+ */
+static VALUE drawing_path_move_to_relative(VALUE obj, VALUE x, VALUE y)
+{
+    return path_line_to(obj, x, y, DrawPathMoveToRelative);
+}
+
+
+
+
+/*
+ *  private:
+ *  self.finish_path()
+ */
+static VALUE drawing_path_finish(VALUE obj)
+{
+    Drawing *drawing;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawPathFinish(drawing->wand);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  private:
+ *  self.start_path()
+ */
+static VALUE drawing_path_start(VALUE obj)
+{
+    Drawing *drawing;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawPathStart(drawing->wand);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+static VALUE polyshape(int argc, VALUE *argv, VALUE obj,
+    void (*f)(DrawingWand *, const unsigned long, const PointInfo *))
+{
+    Drawing *drawing;
+    int x;
+    unsigned long number_coordinates, n;
+    PointInfo *coordinates;
+
+    rb_check_frozen(obj);
+
+    if (argc % 2 != 0)
+    {
+        rb_raise(rb_eArgError, "coordinates must be x,y pairs (%d arguments given)", argc);
+    }
+
+    number_coordinates = argc / 2;
+    // Can't fail! Ruby will stop if there's not enough memory...
+    coordinates = (PointInfo *)AcquireQuantumMemory(number_coordinates, sizeof(PointInfo));
+
+    x = 0;
+    for (n = 0; n < number_coordinates; n++)
+    {
+        coordinates[n].x = NUM2DBL(argv[x++]);
+        coordinates[n].y = NUM2DBL(argv[x++]);
+    }
+
+    Data_Get_Struct(obj, Drawing, drawing);
+    (*f)(drawing->wand, number_coordinates, coordinates);
+    RelinquishMagickMemory((void *)coordinates);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+
+}
+
+
+
+
+/*
+ *  drawing.polygon(x1, y1, ..., xN, yN)
+ */
+static VALUE drawing_polygon(int argc, VALUE *argv, VALUE obj)
+{
+    return polyshape(argc, argv, obj, DrawPolygon);
+}
+
+
+
+
+/*
+ *  drawing.polyline(x1, y1, ..., xN, yN)
+ */
+static VALUE drawing_polyline(int argc, VALUE *argv, VALUE obj)
+{
+    return polyshape(argc, argv, obj, DrawPolyline);
+}
+
+
+
+
+/*
+ *  drawing.pop()
+ *  drawing.pop("graphics-context")
+ *  drawing.pop("defs")
+ *  drawing.pop("clip_path")
+ *  drawing.pop("pattern")
+ */
+static VALUE drawing_pop(int argc, VALUE *argv, VALUE obj)
+{
+    Drawing *drawing;
+    VALUE thing;
+    char *what;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+
+    (void)rb_scan_args(argc, argv, "01", &thing);
+    if (thing == Qnil)
+    {
+        PopDrawingWand(drawing->wand);
+    }
+    else
+    {
+        what = StringValuePtr(thing);
+        if (strcmp(what, "graphics_context") == 0)
+        {
+            PopDrawingWand(drawing->wand);
+        }
+        else if (strcmp(what, "defs") == 0)
+        {
+            DrawPopDefs(drawing->wand);
+        }
+        else if (strcmp(what, "clip_path") == 0)
+        {
+            DrawPopClipPath(drawing->wand);
+        }
+        else if (strcmp(what, "pattern") == 0)
+        {
+            DrawPopPattern(drawing->wand);
+        }
+        else
+        {
+            rb_raise(rb_eArgError, "don't know how to pop `%s'", what);
+        }
+    }
+
+    mwr_check_drawingwand_error(drawing->wand);
+
+    return obj;
+}
+
+
+
+
+/*
+ *  drawing.push()
+ *  drawing.push("graphics-context")
+ *  drawing.push("defs")
+ *  drawing.push("clip_path", name)
+ *  drawing.push("pattern", name, :x=>0, :y=>0, :width=>0, :height=>0)
+ */
+static VALUE drawing_push(int argc, VALUE *argv, VALUE obj)
+{
+    Drawing *drawing;
+    VALUE thing, arg2, v, options;
+    char *what, *name = NULL;
+    double x, y, width, height;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+
+    (void)rb_scan_args(argc, argv, "03", &thing, &arg2, &options);
+    if (thing == Qnil)
+    {
+        PushDrawingWand(drawing->wand);
+    }
+    else
+    {
+        what = StringValuePtr(thing);
+        if (strcmp(what, "graphics_context") == 0)
+        {
+            PushDrawingWand(drawing->wand);
+        }
+        else if (strcmp(what, "defs") == 0)
+        {
+            DrawPushDefs(drawing->wand);
+        }
+        else if (strcmp(what, "clip_path") == 0)
+        {
+            name = StringValuePtr(arg2);
+            DrawPushClipPath(drawing->wand, name);
+        }
+        else if (strcmp(what, "pattern") == 0)
+        {
+            name = StringValuePtr(arg2);
+            x = mwr_get_option(options, "x", &v) ? NUM2DBL(v) : 0.0;
+            y = mwr_get_option(options, "y", &v) ? NUM2DBL(v) : 0.0;
+            width = mwr_get_option(options, "width", &v) ? NUM2DBL(v) : 0.0;
+            height = mwr_get_option(options, "height", &v) ? NUM2DBL(v) : 0.0;
+            DrawPushPattern(drawing->wand, name, x, y, width, height);
+        }
+        else
+        {
+            rb_raise(rb_eArgError, "don't know how to push `%s'", what);
+        }
+    }
+
+    mwr_check_drawingwand_error(drawing->wand);
+
+    return obj;
+}
+
+
+
+
+/*
+ *  drawing.rectangle(width, height, :x=>0, :y=>0, :rx=>0, :ry=>rx)
+ */
+static VALUE drawing_rectangle(int argc, VALUE *argv, VALUE obj)
+{
+    Drawing *drawing;
+    VALUE v, w, h, options;
+    double x1,  y1, x2, y2, rx, ry;
+    double width, height;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+
+    (void)rb_scan_args(argc, argv, "21", &w, &h, &options);
+    width = NUM2DBL(w);
+    height = NUM2DBL(h);
+    x1 = mwr_get_option(options, "x", &v) ? NUM2DBL(v) : 0.0;
+    y1 = mwr_get_option(options, "y", &v) ? NUM2DBL(v) : 0.0;
+    x2 = x1 + width;
+    y2 = y1 + height;
+
+    rx = mwr_get_option(options, "rx", &v) ? NUM2DBL(v) : 0.0;
+    ry = mwr_get_option(options, "ry", &v) ? NUM2DBL(v) : rx;
+
+    if (rx == 0.0 && ry != 0.0)
+    {
+        rb_raise(rb_eArgError, "When y corner radius is non-0 the x corner radius must also be non-0 (:ry=>%g)", ry);
+    }
+
+    if (rx == 0.0 && ry == 0.0)
+    {
+        DrawRectangle(drawing->wand, x1, y1, x2, y2);
+    }
+    else
+    {
+        DrawRoundRectangle(drawing->wand, x1, y1, x2, y2, rx, ry);
+    }
+    mwr_check_drawingwand_error(drawing->wand);
+
+    return obj;
+}
+
+
+
+
+/*
+ *  drawing.rotate(angle, x=0, y=0)
+ */
+static VALUE drawing_rotate(int argc, VALUE *argv, VALUE obj)
+{
+    Drawing *drawing;
+    VALUE angle, x, y;
+    double degrees, cx = 0.0, cy = 0.0;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+
+    (void)rb_scan_args(argc, argv, "12", &angle, &x, &y);
+    degrees = NUM2DBL(angle);
+    cx = !NIL_P(x) ? NUM2DBL(x) : 0.0;
+    cy = !NIL_P(y) ? NUM2DBL(y) : 0.0;
+
+    if (cx != 0.0 || cy != 0.0)
+    {
+        DrawTranslate(drawing->wand, cx, cy);
+        mwr_check_drawingwand_error(drawing->wand);
+    }
+    DrawRotate(drawing->wand, degrees);
+    mwr_check_drawingwand_error(drawing->wand);
+    if (cx != 0.0 || cy != 0.0)
+    {
+        DrawTranslate(drawing->wand, -cx, -cy);
+        mwr_check_drawingwand_error(drawing->wand);
+    }
+
+    return obj;
+}
+
+
+
+/*
+ *  drawing.scale(sx[, sy=sx])
+ */
+static VALUE drawing_scale(int argc, VALUE *argv, VALUE obj)
+{
+    Drawing *drawing;
+    VALUE x, y;
+    double sx, sy;
+
+    rb_check_frozen(obj);
+
+    (void)rb_scan_args(argc, argv, "11", &x, &y);
+    sx = NUM2DBL(x);
+    sy = (y == Qnil) ? sx : NUM2DBL(y);
+
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawScale(drawing->wand, sx, sy);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  :align => string
+ *  set text alignment
+ */
+static VALUE drawing_set_align(VALUE obj, VALUE align)
+{
+    Drawing *drawing;
+    AlignType type;
+
+    rb_check_frozen(obj);
+    type = mwr_string_to_aligntype(align, LeftAlign, RaiseUndefinedOption);
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawSetTextAlignment(drawing->wand, type);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+
+/*
+ *  :antialias => boolean
+ *  turn text antialias on or off
+ */
+static VALUE drawing_set_antialias(VALUE obj, VALUE antialias)
+{
+    Drawing *drawing;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawSetTextAntialias(drawing->wand, RTEST(antialias) ? MagickTrue : MagickFalse);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  :decoration => string
+ */
+static VALUE drawing_set_decoration(VALUE obj, VALUE decoration)
+{
+    Drawing *drawing;
+    DecorationType type;
+
+    rb_check_frozen(obj);
+    type = mwr_string_to_decorationtype(decoration, NoDecoration, RaiseUndefinedOption);
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawSetTextDecoration(drawing->wand, type);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  :encoding => string
+ */
+static VALUE drawing_set_encoding(VALUE obj, VALUE encoding)
+{
+    Drawing *drawing;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawSetTextEncoding(drawing->wand, StringValuePtr(encoding));
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+/*
+ *  :family => string
+ */
+static VALUE drawing_set_family(VALUE obj, VALUE family)
+{
+    Drawing *drawing;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawSetFontFamily(drawing->wand, StringValuePtr(family));
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  :fill => string
+ */
+static VALUE drawing_set_fill(VALUE obj, VALUE fill)
+{
+    Drawing *drawing;
+    PixelWand *pixelwand;
+
+    rb_check_frozen(obj);
+    pixelwand = NewPixelWand();
+
+    PixelSetColor(pixelwand, StringValuePtr(fill));
+    mwr_check_pixelwand_error(pixelwand);
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawSetFillColor(drawing->wand, pixelwand);
+    pixelwand = DestroyPixelWand(pixelwand);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  :fill_opacity => float
+ */
+static VALUE drawing_set_fill_opacity(VALUE obj, VALUE fill_opacity)
+{
+    Drawing *drawing;
+    double opacity;
+
+    rb_check_frozen(obj);
+    opacity = NUM2DBL(fill_opacity);
+    if (opacity < 0.0)
+    {
+        opacity = 0.0;
+    }
+    else if (opacity > 1.0)
+    {
+        opacity = 1.0;
+    }
+
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawSetFillOpacity(drawing->wand, opacity);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  :font => string
+ */
+static VALUE drawing_set_font(VALUE obj, VALUE font)
+{
+    Drawing *drawing;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawSetFont(drawing->wand, StringValuePtr(font));
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  :gravity => string
+ */
+static VALUE drawing_set_gravity(VALUE obj, VALUE gravity)
+{
+    Drawing *drawing;
+    GravityType type;
+
+    rb_check_frozen(obj);
+    type = mwr_string_to_gravitytype(gravity, NorthWestGravity, RaiseUndefinedOption);
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawSetGravity(drawing->wand, type);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  :interword_spacing => float
+ */
+static VALUE drawing_set_interword_spacing(VALUE obj, VALUE interword_spacing)
+{
+    Drawing *drawing;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawSetTextInterwordSpacing(drawing->wand, NUM2DBL(interword_spacing));
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  :kerning => float
+ */
+static VALUE drawing_set_kerning(VALUE obj, VALUE kerning)
+{
+    Drawing *drawing;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawSetTextKerning(drawing->wand, NUM2DBL(kerning));
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  :pointsize => float
+ */
+static VALUE drawing_set_pointsize(VALUE obj, VALUE pointsize)
+{
+    Drawing *drawing;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawSetFontSize(drawing->wand, NUM2DBL(pointsize));
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  :stretch => string
+ */
+static VALUE drawing_set_stretch(VALUE obj, VALUE stretch)
+{
+    Drawing *drawing;
+    StretchType type;
+
+    rb_check_frozen(obj);
+    type = mwr_string_to_stretchtype(stretch, AnyStretch, RaiseUndefinedOption);
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawSetFontStretch(drawing->wand, type);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+/*
+ *  :stroke => string
+ */
+static VALUE drawing_set_stroke(VALUE obj, VALUE stroke)
+{
+    Drawing *drawing;
+    PixelWand *pixelwand;
+
+    rb_check_frozen(obj);
+    pixelwand = NewPixelWand();
+
+    PixelSetColor(pixelwand, StringValuePtr(stroke));
+    mwr_check_pixelwand_error(pixelwand);
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawSetStrokeColor(drawing->wand, pixelwand);
+    pixelwand = DestroyPixelWand(pixelwand);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  :stroke_opacity => float
+ */
+static VALUE drawing_set_stroke_opacity(VALUE obj, VALUE stroke_opacity)
+{
+    Drawing *drawing;
+    double opacity;
+
+    rb_check_frozen(obj);
+    opacity = NUM2DBL(stroke_opacity);
+    if (opacity < 0.0)
+    {
+        opacity = 0.0;
+    }
+    else if (opacity > 1.0)
+    {
+        opacity = 1.0;
+    }
+
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawSetStrokeOpacity(drawing->wand, opacity);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  :stroke_width => float
+ */
+static VALUE drawing_set_stroke_width(VALUE obj, VALUE stroke_width)
+{
+    Drawing *drawing;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawSetStrokeWidth(drawing->wand, NUM2DBL(stroke_width));
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  :style => string
+ */
+static VALUE drawing_set_style(VALUE obj, VALUE style)
+{
+    Drawing *drawing;
+    StyleType type;
+
+    rb_check_frozen(obj);
+    type = mwr_string_to_styletype(style, NormalStyle, RaiseUndefinedOption);
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawSetFontStyle(drawing->wand, type);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  :undercolor => string
+ */
+static VALUE drawing_set_undercolor(VALUE obj, VALUE undercolor)
+{
+    Drawing *drawing;
+    PixelWand *pixelwand;
+
+    rb_check_frozen(obj);
+    pixelwand = NewPixelWand();
+
+    PixelSetColor(pixelwand, StringValuePtr(undercolor));
+    mwr_check_pixelwand_error(pixelwand);
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawSetTextUnderColor(drawing->wand, pixelwand);
+    pixelwand = DestroyPixelWand(pixelwand);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  :weight => fixnum
+ */
+static VALUE drawing_set_weight(VALUE obj, VALUE weight)
+{
+    Drawing *drawing;
+    unsigned long w;
+
+    rb_check_frozen(obj);
+    if (TYPE(weight) == T_STRING)
+    {
+        w = mwr_string_to_weight(weight, 0, RaiseUndefinedOption);
+    }
+    else
+    {
+        w = FIX2ULONG(weight);
+    }
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawSetFontWeight(drawing->wand, w);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  drawing.skew(x, y=0.0)
+ */
+static VALUE drawing_skew(int argc, VALUE *argv, VALUE obj)
+{
+    Drawing *drawing;
+    VALUE x, y;
+    double rx, ry;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+
+    (void)rb_scan_args(argc, argv, "11", &x, &y);
+    rx = NUM2DBL(x);
+    ry = y != Qnil ? NUM2DBL(y) : 0.0;
+
+    if (rx != 0.0)
+    {
+        DrawSkewX(drawing->wand, rx);
+        mwr_check_drawingwand_error(drawing->wand);
+    }
+    if (ry != 0.0)
+    {
+        DrawSkewY(drawing->wand, ry);
+        mwr_check_drawingwand_error(drawing->wand);
+    }
+
+    return obj;
+}
+
+
+
+
+/*
+ *  drawing.translate(tx, ty=0.0)
+ */
+static VALUE drawing_translate(int argc, VALUE *argv, VALUE obj)
+{
+    Drawing *drawing;
+    VALUE x, y;
+    double tx, ty;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+
+    (void)rb_scan_args(argc, argv, "11", &x, &y);
+    tx = NUM2DBL(x);
+    ty = (y != Qnil) ? NUM2DBL(y) : 0.0;
+
+    DrawTranslate(drawing->wand, tx, ty);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  drawing.with(:clip_path=>"string")
+ */
+static VALUE drawing_with_clip_path(VALUE obj, VALUE clip_path)
+{
+    Drawing *drawing;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+
+    DrawSetClipPath(drawing->wand, StringValuePtr(clip_path));
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+static VALUE with_fill_rule(VALUE obj, VALUE fill_rule,
+    void (*f)(DrawingWand *, const FillRule))
+{
+    Drawing *drawing;
+    FillRule rule;
+
+    rb_check_frozen(obj);
+    rule = mwr_string_to_fillrule(fill_rule, NonZeroRule, RaiseUndefinedOption);
+    Data_Get_Struct(obj, Drawing, drawing);
+    (*f)(drawing->wand, rule);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  drawing.with(:clip_rule=>"rule")
+ */
+static VALUE drawing_with_clip_rule(VALUE obj, VALUE fill_rule)
+{
+    return with_fill_rule(obj, fill_rule, DrawSetClipRule);
+}
+
+
+
+
+/*
+ *  drawing.with(:fill_rule=>"rule")
+ */
+static VALUE drawing_with_fill_rule(VALUE obj, VALUE fill_rule)
+{
+    return with_fill_rule(obj, fill_rule, DrawSetFillRule);
+}
+
+
+
+
+/*
+ *  drawing.with(:clip_units=>"units")
+ */
+static VALUE drawing_with_clip_units(VALUE obj, VALUE units)
+{
+    Drawing *drawing;
+    ClipPathUnits clip_units;
+
+    rb_check_frozen(obj);
+    clip_units = mwr_string_to_clip_units(units, UserSpaceOnUse, RaiseUndefinedOption);
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawSetClipUnits(drawing->wand, clip_units);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  drawing.with(:dash_array=>[n1,n2,n3...]
+ */
+static VALUE drawing_with_dash_array(int argc, VALUE *argv, VALUE obj)
+{
+    Drawing *drawing;
+    unsigned long n, nelements;
+    double *dash_array;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+
+    if (argc == 0 || (argc == 1 && argv[0] == Qnil))
+    {
+        DrawSetStrokeDashArray(drawing->wand, 0, NULL);
+    }
+    else
+    {
+        nelements = argc;
+        dash_array = ALLOC_N(double, argc);
+        for (n = 0; n < nelements; n++)
+        {
+            dash_array[n] = NUM2DBL(argv[n]);
+        }
+        DrawSetStrokeDashArray(drawing->wand, nelements, dash_array);
+        xfree(dash_array);
+    }
+
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  drawing.with(:dash_offset=>d)
+ */
+static VALUE drawing_with_dash_offset(VALUE obj, VALUE offset)
+{
+    Drawing *drawing;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+
+    DrawSetStrokeDashOffset(drawing->wand, NUM2DBL(offset));
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  drawing.with(:line_cap=>"cap")
+ */
+static VALUE drawing_with_line_cap(VALUE obj, VALUE cap)
+{
+    Drawing *drawing;
+    LineCap linecap;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+
+    linecap = mwr_string_to_line_cap(cap, ButtCap, RaiseUndefinedOption);
+    DrawSetStrokeLineCap(drawing->wand, linecap);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+
+/*
+ *  drawing.with(:line_join=>"join")
+ */
+static VALUE drawing_with_line_join(VALUE obj, VALUE join)
+{
+    Drawing *drawing;
+    LineJoin linejoin;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+
+    linejoin = mwr_string_to_line_join(join, MiterJoin, RaiseUndefinedOption);
+    DrawSetStrokeLineJoin(drawing->wand, linejoin);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  drawing.with(:miter_limit=>i)
+ */
+static VALUE drawing_with_miter_limit(VALUE obj, VALUE limit)
+{
+    Drawing *drawing;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawSetStrokeMiterLimit(drawing->wand, NUM2ULONG(limit));
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+/*
+ *  ImageMagick expects the pattern name to start with '#'
+ */
+static VALUE set_pattern_URL(VALUE obj, VALUE pattern,
+    MagickBooleanType (*f)(DrawingWand *, const char *))
+{
+    Drawing *drawing;
+    volatile VALUE url;
+
+    rb_check_frozen(obj);
+    url = rb_str_plus(rb_str_new2("#"), pattern);
+    Data_Get_Struct(obj, Drawing, drawing);
+    (*f)(drawing->wand, StringValuePtr(url));
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  drawing.with(:fill_pattern=>"pattern")
+ */
+static VALUE drawing_with_fill_pattern(VALUE obj, VALUE pattern)
+{
+    return set_pattern_URL(obj, pattern, DrawSetFillPatternURL);
+}
+
+
+
+
+/*
+ *  drawing.with(:stroke_pattern=>"pattern")
+ */
+static VALUE drawing_with_stroke_pattern(VALUE obj, VALUE pattern)
+{
+    return set_pattern_URL(obj, pattern, DrawSetStrokePatternURL);
+}
+
+
+
+
+/*
+ *  drawing.with(:stroke_antialias=>boolean)
+ */
+static VALUE drawing_with_stroke_antialias(VALUE obj, VALUE antialias)
+{
+    Drawing *drawing;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Drawing, drawing);
+    DrawSetStrokeAntialias(drawing->wand, RTEST(antialias) ? MagickTrue : MagickFalse);
+    mwr_check_drawingwand_error(drawing->wand);
+    return obj;
+}
+
+
+
+
+/*
+ *  MagickWand::Drawing class
+ */
+void mwr_init_Drawing(void)
+{
+    mwr_cDrawing = rb_define_class_under(mwr_mMagickWand, "Drawing", rb_cObject);
+    rb_define_alloc_func(mwr_cDrawing, drawing_allocate);
+
+
+    // Methods in Object that must be overridden per class
+    rb_define_method(mwr_cDrawing, "initialize", drawing_initialize, 0);
+    rb_define_method(mwr_cDrawing, "initialize_copy", drawing_initialize_copy, 1);
+    rb_define_method(mwr_cDrawing, "inspect", drawing_inspect, 0);
+
+
+    // Private property setters are called during 'annotate' option processing.
+    rb_define_private_method(mwr_cDrawing, "set_align", drawing_set_align, 1);
+    rb_define_private_method(mwr_cDrawing, "set_antialias", drawing_set_antialias, 1);
+    rb_define_private_method(mwr_cDrawing, "set_decoration", drawing_set_decoration, 1);
+    rb_define_private_method(mwr_cDrawing, "set_encoding", drawing_set_encoding, 1);
+    rb_define_private_method(mwr_cDrawing, "set_family", drawing_set_family, 1);
+    rb_define_private_method(mwr_cDrawing, "set_fill", drawing_set_fill, 1);
+    rb_define_private_method(mwr_cDrawing, "set_fill_opacity", drawing_set_fill_opacity, 1);
+    rb_define_private_method(mwr_cDrawing, "set_font", drawing_set_font, 1);
+    rb_define_private_method(mwr_cDrawing, "set_gravity", drawing_set_gravity, 1);
+    rb_define_private_method(mwr_cDrawing, "set_interword_spacing", drawing_set_interword_spacing, 1);
+    rb_define_private_method(mwr_cDrawing, "set_kerning", drawing_set_kerning, 1);
+    rb_define_private_method(mwr_cDrawing, "set_pointsize", drawing_set_pointsize, 1);
+    rb_define_private_method(mwr_cDrawing, "set_stretch", drawing_set_stretch, 1);
+    rb_define_private_method(mwr_cDrawing, "set_stroke", drawing_set_stroke, 1);
+    rb_define_private_method(mwr_cDrawing, "set_stroke_opacity", drawing_set_stroke_opacity, 1);
+    rb_define_private_method(mwr_cDrawing, "set_stroke_width", drawing_set_stroke_width, 1);
+    rb_define_private_method(mwr_cDrawing, "set_style", drawing_set_style, 1);
+    rb_define_private_method(mwr_cDrawing, "set_undercolor", drawing_set_undercolor, 1);
+    rb_define_private_method(mwr_cDrawing, "set_weight", drawing_set_weight, 1);
+
+    rb_define_private_method(mwr_cDrawing, "finish_path", drawing_path_finish, 0);
+    rb_define_private_method(mwr_cDrawing, "pop", drawing_pop, -1);
+    rb_define_private_method(mwr_cDrawing, "push", drawing_push, -1);
+    rb_define_private_method(mwr_cDrawing, "start_path", drawing_path_start, 0);
+
+    // Private style and transform primitive methods called from 'with'
+    rb_define_private_method(mwr_cDrawing, "with_align", drawing_set_align, 1);
+    rb_define_private_method(mwr_cDrawing, "with_antialias", drawing_set_antialias, 1);
+    rb_define_private_method(mwr_cDrawing, "with_clip_path", drawing_with_clip_path, 1);
+    rb_define_private_method(mwr_cDrawing, "with_clip_rule", drawing_with_clip_rule, 1);
+    rb_define_private_method(mwr_cDrawing, "with_clip_units", drawing_with_clip_units, 1);
+    rb_define_private_method(mwr_cDrawing, "with_decoration", drawing_set_decoration, 1);
+    rb_define_private_method(mwr_cDrawing, "with_encoding", drawing_set_encoding, 1);
+    rb_define_private_method(mwr_cDrawing, "with_family", drawing_set_family, 1);
+    rb_define_private_method(mwr_cDrawing, "with_fill", drawing_set_fill, 1);
+    rb_define_private_method(mwr_cDrawing, "with_fill_opacity", drawing_set_fill_opacity, 1);
+    rb_define_private_method(mwr_cDrawing, "with_fill_pattern", drawing_with_fill_pattern, 1);
+    rb_define_private_method(mwr_cDrawing, "with_fill_rule", drawing_with_fill_rule, 1);
+    rb_define_private_method(mwr_cDrawing, "with_font", drawing_set_font, 1);
+    rb_define_private_method(mwr_cDrawing, "with_gravity", drawing_set_gravity, 1);
+    rb_define_private_method(mwr_cDrawing, "with_interword_spacing", drawing_set_interword_spacing, 1);
+    rb_define_private_method(mwr_cDrawing, "with_kerning", drawing_set_kerning, 1);
+    rb_define_private_method(mwr_cDrawing, "with_pointsize", drawing_set_pointsize, 1);
+    rb_define_private_method(mwr_cDrawing, "with_stretch", drawing_set_stretch, 1);
+    rb_define_private_method(mwr_cDrawing, "with_stroke", drawing_set_stroke, 1);
+    rb_define_private_method(mwr_cDrawing, "with_stroke_antialias", drawing_with_stroke_antialias, 1);
+    rb_define_private_method(mwr_cDrawing, "with_dash_array", drawing_with_dash_array, -1);
+    rb_define_private_method(mwr_cDrawing, "with_dash_offset", drawing_with_dash_offset, 1);
+    rb_define_private_method(mwr_cDrawing, "with_line_cap", drawing_with_line_cap, 1);
+    rb_define_private_method(mwr_cDrawing, "with_line_join", drawing_with_line_join, 1);
+    rb_define_private_method(mwr_cDrawing, "with_miter_limit", drawing_with_miter_limit, 1);
+    rb_define_private_method(mwr_cDrawing, "with_stroke_opacity", drawing_set_stroke_opacity, 1);
+    rb_define_private_method(mwr_cDrawing, "with_stroke_pattern", drawing_with_stroke_pattern, 1);
+    rb_define_private_method(mwr_cDrawing, "with_stroke_width", drawing_set_stroke_width, 1);
+    rb_define_private_method(mwr_cDrawing, "with_style", drawing_set_style, 1);
+    rb_define_private_method(mwr_cDrawing, "with_undercolor", drawing_set_undercolor, 1);
+    rb_define_private_method(mwr_cDrawing, "with_text_antialias", drawing_set_antialias, 1);
+    rb_define_private_method(mwr_cDrawing, "with_weight", drawing_set_weight, 1);
+
+    // Drawing primitive methods
+    rb_define_method(mwr_cDrawing, "affine", drawing_affine, 6);
+    rb_define_method(mwr_cDrawing, "annotation", drawing_annotation, -1);
+    rb_define_method(mwr_cDrawing, "arc", drawing_arc, -1);
+    rb_define_method(mwr_cDrawing, "bezier", drawing_bezier, -1);
+    rb_define_method(mwr_cDrawing, "circle", drawing_circle, -1);
+    rb_define_method(mwr_cDrawing, "close_path", drawing_path_close, 0);
+    rb_define_method(mwr_cDrawing, "color", drawing_color, -1);
+    rb_define_method(mwr_cDrawing, "composite", drawing_composite, -1);
+    rb_define_method(mwr_cDrawing, "curve_to_absolute", drawing_path_curve_to_absolute, 6);
+    rb_define_method(mwr_cDrawing, "curve_to_relative", drawing_path_curve_to_relative, 6);
+    rb_define_method(mwr_cDrawing, "curve_to_quadratic_bezier_absolute", drawing_path_curve_to_quadratic_bezier_absolute, 4);
+    rb_define_method(mwr_cDrawing, "curve_to_quadratic_bezier_relative", drawing_path_curve_to_quadratic_bezier_relative, 4);
+    rb_define_method(mwr_cDrawing, "curve_to_quadratic_bezier_smooth_absolute", drawing_path_curve_to_quadratic_bezier_smooth_absolute, 2);
+    rb_define_method(mwr_cDrawing, "curve_to_quadratic_bezier_smooth_relative", drawing_path_curve_to_quadratic_bezier_smooth_relative, 2);
+    rb_define_method(mwr_cDrawing, "curve_to_smooth_absolute", drawing_path_curve_to_smooth_absolute, 4);
+    rb_define_method(mwr_cDrawing, "curve_to_smooth_relative", drawing_path_curve_to_smooth_relative, 4);
+    rb_define_method(mwr_cDrawing, "elliptic_arc_absolute", drawing_path_elliptic_arc_absolute, 7);
+    rb_define_method(mwr_cDrawing, "elliptic_arc_relative", drawing_path_elliptic_arc_relative, 7);
+    rb_define_method(mwr_cDrawing, "ellipse", drawing_ellipse, -1);
+    rb_define_method(mwr_cDrawing, "line", drawing_line, 4);
+    rb_define_method(mwr_cDrawing, "line_to_absolute", drawing_path_line_to_absolute, 2);
+    rb_define_method(mwr_cDrawing, "line_to_horizontal_absolute", drawing_path_line_to_horizontal_absolute, 1);
+    rb_define_method(mwr_cDrawing, "line_to_horizontal_relative", drawing_path_line_to_horizontal_relative, 1);
+    rb_define_method(mwr_cDrawing, "line_to_relative", drawing_path_line_to_relative, 2);
+    rb_define_method(mwr_cDrawing, "line_to_vertical_absolute", drawing_path_line_to_vertical_absolute, 1);
+    rb_define_method(mwr_cDrawing, "line_to_vertical_relative", drawing_path_line_to_vertical_relative, 1);
+    rb_define_method(mwr_cDrawing, "matte", drawing_matte, -1);
+    rb_define_method(mwr_cDrawing, "move_to_absolute", drawing_path_move_to_absolute, 2);
+    rb_define_method(mwr_cDrawing, "move_to_relative", drawing_path_move_to_relative, 2);
+    rb_define_method(mwr_cDrawing, "polygon", drawing_polygon, -1);
+    rb_define_method(mwr_cDrawing, "polyline", drawing_polyline, -1);
+    rb_define_method(mwr_cDrawing, "rectangle", drawing_rectangle, -1);
+    rb_define_method(mwr_cDrawing, "rotate", drawing_rotate, -1);
+    rb_define_method(mwr_cDrawing, "scale", drawing_scale, -1);
+    rb_define_method(mwr_cDrawing, "skew", drawing_skew, -1);
+    rb_define_method(mwr_cDrawing, "translate", drawing_translate, -1);
+}