Class: Magick::Image::PolaroidOptions

Inherits:
Object
  • Object
show all
Defined in:
ext/RMagick/rmmain.c

Instance Method Summary collapse

Constructor Details

#initialize {|self| ... } ⇒ Magick::Image::PolaroidOptions

Initialize a PolaroidOptions object.

Yields:

  • (self)

Yield Parameters:



1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
 
# File 'ext/RMagick/rmdraw.c', line 1451

VALUE
PolaroidOptions_initialize(VALUE self)
{
    Draw *draw;
    ExceptionInfo *exception;

    // Default shadow color
    Data_Get_Struct(self, Draw, draw);

    exception = AcquireExceptionInfo();
    QueryColorCompliance("gray75", AllCompliance, &draw->shadow_color, exception);
    CHECK_EXCEPTION();
    QueryColorCompliance("#dfdfdf", AllCompliance, &draw->info->border_color, exception);
    CHECK_EXCEPTION();
    DestroyExceptionInfo(exception);

    if (rb_block_given_p())
    {
        if (rb_proc_arity(rb_block_proc()) == 0)
        {
            // Run the block in self's context
            rb_warn("passing a block without an image argument is deprecated");
            rb_obj_instance_eval(0, NULL, self);
        }
        else
        {
            rb_yield(self);
        }
    }

    return self;
}

Instance Method Details

#align=(align) ⇒ Magick::AlignType

Set the text alignment from an AlignType.

Parameters:

  • align (Magick::AlignType) —

    the text alignment

Returns:

  • (Magick::AlignType) —

    the given align



53
54
55
56
57
58
59
60
61
62
 
# File 'ext/RMagick/rmdraw.c', line 53

VALUE
Draw_align_eq(VALUE self, VALUE align)
{
    Draw *draw;

    rb_check_frozen(self);
    Data_Get_Struct(self, Draw, draw);
    VALUE_TO_ENUM(align, draw->info->align, AlignType);
    return align;
}

#border_color=(border) ⇒ Magick::Pixel, String

Set the border color.

Parameters:

Returns:



1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
 
# File 'ext/RMagick/rmdraw.c', line 1523

VALUE
PolaroidOptions_border_color_eq(VALUE self, VALUE border)
{
    Draw *draw;

    rb_check_frozen(self);
    Data_Get_Struct(self, Draw, draw);
    Color_to_PixelColor(&draw->info->border_color, border);
    return border;
}

#decorate=(decorate) ⇒ Magick::DecorationType

Set text decorate from an DecorationType.

Parameters:

  • decorate (Magick::DecorationType) —

    the decorate type

Returns:

  • (Magick::DecorationType) —

    the given decorate



71
72
73
74
75
76
77
78
79
80
 
# File 'ext/RMagick/rmdraw.c', line 71

VALUE
Draw_decorate_eq(VALUE self, VALUE decorate)
{
    Draw *draw;

    rb_check_frozen(self);
    Data_Get_Struct(self, Draw, draw);
    VALUE_TO_ENUM(decorate, draw->info->decorate, DecorationType);
    return decorate;
}

#density=(density) ⇒ String

Set density.

Parameters:

  • density (String) —

    the density

Returns:

  • (String) —

    the given density



89
90
91
92
93
94
95
96
97
98
99
 
# File 'ext/RMagick/rmdraw.c', line 89

VALUE
Draw_density_eq(VALUE self, VALUE density)
{
    Draw *draw;

    rb_check_frozen(self);
    Data_Get_Struct(self, Draw, draw);
    magick_clone_string(&draw->info->density, StringValueCStr(density));

    return density;
}

#encoding=(encoding) ⇒ String

Set text encoding.

Parameters:

  • encoding (String) —

    the encoding name

Returns:

  • (String) —

    the given encoding name



108
109
110
111
112
113
114
115
116
117
118
 
# File 'ext/RMagick/rmdraw.c', line 108

VALUE
Draw_encoding_eq(VALUE self, VALUE encoding)
{
    Draw *draw;

    rb_check_frozen(self);
    Data_Get_Struct(self, Draw, draw);
    magick_clone_string(&draw->info->encoding, StringValueCStr(encoding));

    return encoding;
}

#fill=(fill) ⇒ Magick::Pixel, String

Set fill color.

Parameters:

Returns:



127
128
129
130
131
132
133
134
135
136
 
# File 'ext/RMagick/rmdraw.c', line 127

VALUE
Draw_fill_eq(VALUE self, VALUE fill)
{
    Draw *draw;

    rb_check_frozen(self);
    Data_Get_Struct(self, Draw, draw);
    Color_to_PixelColor(&draw->info->fill, fill);
    return fill;
}

#fill_pattern=(pattern) ⇒ Magick::Image

Accept an image as a fill pattern.

Parameters:

Returns:

See Also:



148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
 
# File 'ext/RMagick/rmdraw.c', line 148

VALUE
Draw_fill_pattern_eq(VALUE self, VALUE pattern)
{
    Draw *draw;

    rb_check_frozen(self);
    Data_Get_Struct(self, Draw, draw);

    if (draw->info->fill_pattern != NULL)
    {
        // Do not trace destruction
        DestroyImage(draw->info->fill_pattern);
        draw->info->fill_pattern = NULL;
    }

    if (!NIL_P(pattern))
    {
        Image *image;

        pattern = rm_cur_image(pattern);
        image = rm_check_destroyed(pattern);
        // Do not trace creation
        draw->info->fill_pattern = rm_clone_image(image);
    }

    return pattern;
}

#font=(font) ⇒ String

Set the font name.

Parameters:

  • font (String) —

    the font name

Returns:

  • (String) —

    the given font name



183
184
185
186
187
188
189
190
191
192
193
 
# File 'ext/RMagick/rmdraw.c', line 183

VALUE
Draw_font_eq(VALUE self, VALUE font)
{
    Draw *draw;

    rb_check_frozen(self);
    Data_Get_Struct(self, Draw, draw);
    magick_clone_string(&draw->info->font, StringValueCStr(font));

    return font;
}

#font_family=(family) ⇒ String

Set the font family name.

Parameters:

  • family (String) —

    the font family name

Returns:

  • (String) —

    the given family name



202
203
204
205
206
207
208
209
210
211
212
 
# File 'ext/RMagick/rmdraw.c', line 202

VALUE
Draw_font_family_eq(VALUE self, VALUE family)
{
    Draw *draw;

    rb_check_frozen(self);
    Data_Get_Struct(self, Draw, draw);
    magick_clone_string(&draw->info->family, StringValueCStr(family));

    return family;
}

#font_stretch=(stretch) ⇒ Magick::StretchType

Set the stretch as spacing between text characters.

Parameters:

  • stretch (Magick::StretchType) —

    the stretch type

Returns:

  • (Magick::StretchType) —

    the given stretch type



221
222
223
224
225
226
227
228
229
230
 
# File 'ext/RMagick/rmdraw.c', line 221

VALUE
Draw_font_stretch_eq(VALUE self, VALUE stretch)
{
    Draw *draw;

    rb_check_frozen(self);
    Data_Get_Struct(self, Draw, draw);
    VALUE_TO_ENUM(stretch, draw->info->stretch, StretchType);
    return stretch;
}

#font_style=(style) ⇒ Magick::StyleType

Set font style.

Parameters:

  • style (Magick::StyleType) —

    the font style

Returns:

  • (Magick::StyleType) —

    the given font style



239
240
241
242
243
244
245
246
247
248
 
# File 'ext/RMagick/rmdraw.c', line 239

VALUE
Draw_font_style_eq(VALUE self, VALUE style)
{
    Draw *draw;

    rb_check_frozen(self);
    Data_Get_Struct(self, Draw, draw);
    VALUE_TO_ENUM(style, draw->info->style, StyleType);
    return style;
}

#font_weight=(weight) ⇒ Magick::WeightType, Numeric

Note:

The font weight can be one of the font weight constants or a number between 100 and 900

Set font weight.

Parameters:

  • weight (Magick::WeightType, Numeric) —

    the font weight

Returns:

  • (Magick::WeightType, Numeric) —

    the given font weight



258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
 
# File 'ext/RMagick/rmdraw.c', line 258

VALUE
Draw_font_weight_eq(VALUE self, VALUE weight)
{
    Draw *draw;
    size_t w;

    rb_check_frozen(self);
    Data_Get_Struct(self, Draw, draw);

    if (FIXNUM_P(weight))
    {
        w = FIX2INT(weight);
        if (w < 100 || w > 900)
        {
            rb_raise(rb_eArgError, "invalid font weight (%"RMIuSIZE" given)", w);
        }
        draw->info->weight = w;
    }
    else
    {
        VALUE_TO_ENUM(weight, w, WeightType);
        switch (w)
        {
            case AnyWeight:
                draw->info->weight = 0;
                break;
            case NormalWeight:
                draw->info->weight = 400;
                break;
            case BoldWeight:
                draw->info->weight = 700;
                break;
            case BolderWeight:
                if (draw->info->weight <= 800)
                    draw->info->weight += 100;
                break;
            case LighterWeight:
                if (draw->info->weight >= 100)
                    draw->info->weight -= 100;
                break;
            default:
                rb_raise(rb_eArgError, "unknown font weight");
                break;
        }
    }

    return weight;
}

#gravity=(grav) ⇒ Magick::GravityType

Set gravity to draw text. Gravity affects text placement in bounding area according to rules:

  • NorthWestGravity - text bottom-left corner placed at top-left

  • NorthGravity - text bottom-center placed at top-center

  • NorthEastGravity - text bottom-right corner placed at top-right

  • WestGravity - text left-center placed at left-center

  • CenterGravity - text center placed at center

  • EastGravity - text right-center placed at right-center

  • SouthWestGravity - text top-left placed at bottom-left

  • SouthGravity - text top-center placed at bottom-center

  • SouthEastGravity - text top-right placed at bottom-right

Parameters:

  • grav (Magick::GravityType) —

    this gravity type

Returns:

  • (Magick::GravityType) —

    the given gravity type



325
326
327
328
329
330
331
332
333
334
335
 
# File 'ext/RMagick/rmdraw.c', line 325

VALUE
Draw_gravity_eq(VALUE self, VALUE grav)
{
    Draw *draw;

    rb_check_frozen(self);
    Data_Get_Struct(self, Draw, draw);
    VALUE_TO_ENUM(grav, draw->info->gravity, GravityType);

    return grav;
}

#pointsize=(pointsize) ⇒ Float

Set point size to draw text.

Parameters:

  • pointsize (Float) —

    the pointsize

Returns:

  • (Float) —

    the given pointsize



636
637
638
639
640
641
642
643
644
645
 
# File 'ext/RMagick/rmdraw.c', line 636

VALUE
Draw_pointsize_eq(VALUE self, VALUE pointsize)
{
    Draw *draw;

    rb_check_frozen(self);
    Data_Get_Struct(self, Draw, draw);
    draw->info->pointsize = NUM2DBL(pointsize);
    return pointsize;
}

#shadow_color=(shadow) ⇒ Magick::Pixel, String

Set the shadow color attribute.

Parameters:

Returns:



1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
 
# File 'ext/RMagick/rmdraw.c', line 1505

VALUE
PolaroidOptions_shadow_color_eq(VALUE self, VALUE shadow)
{
    Draw *draw;

    rb_check_frozen(self);
    Data_Get_Struct(self, Draw, draw);
    Color_to_PixelColor(&draw->shadow_color, shadow);
    return shadow;
}

#stroke=(stroke) ⇒ Magick::Pixel, String

Set stroke.

Parameters:

Returns:



692
693
694
695
696
697
698
699
700
701
 
# File 'ext/RMagick/rmdraw.c', line 692

VALUE
Draw_stroke_eq(VALUE self, VALUE stroke)
{
    Draw *draw;

    rb_check_frozen(self);
    Data_Get_Struct(self, Draw, draw);
    Color_to_PixelColor(&draw->info->stroke, stroke);
    return stroke;
}

#stroke_pattern=(pattern) ⇒ Magick::Image

Accept an image as a stroke pattern.

Parameters:

Returns:

See Also:

  • #fill_pattern


712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
 
# File 'ext/RMagick/rmdraw.c', line 712

VALUE
Draw_stroke_pattern_eq(VALUE self, VALUE pattern)
{
    Draw *draw;

    rb_check_frozen(self);
    Data_Get_Struct(self, Draw, draw);

    if (draw->info->stroke_pattern != NULL)
    {
        // Do not trace destruction
        DestroyImage(draw->info->stroke_pattern);
        draw->info->stroke_pattern = NULL;
    }

    if (!NIL_P(pattern))
    {
        Image *image;

        // DestroyDrawInfo destroys the clone
        pattern = rm_cur_image(pattern);
        image = rm_check_destroyed(pattern);
        // Do not trace creation
        draw->info->stroke_pattern = rm_clone_image(image);
    }

    return pattern;
}

#stroke_width=(stroke_width) ⇒ Float

Set stroke width.

Parameters:

  • stroke_width (Float) —

    the stroke width

Returns:

  • (Float) —

    the given stroke width



748
749
750
751
752
753
754
755
756
757
 
# File 'ext/RMagick/rmdraw.c', line 748

VALUE
Draw_stroke_width_eq(VALUE self, VALUE stroke_width)
{
    Draw *draw;

    rb_check_frozen(self);
    Data_Get_Struct(self, Draw, draw);
    draw->info->stroke_width = NUM2DBL(stroke_width);
    return stroke_width;
}

#text_antialias=(text_antialias) ⇒ Boolean

Set whether to enable text antialias.

Parameters:

  • text_antialias (Boolean) —

    true if enable text antialias

Returns:

  • (Boolean) —

    the given value



766
767
768
769
770
771
772
773
774
775
 
# File 'ext/RMagick/rmdraw.c', line 766

VALUE
Draw_text_antialias_eq(VALUE self, VALUE text_antialias)
{
    Draw *draw;

    rb_check_frozen(self);
    Data_Get_Struct(self, Draw, draw);
    draw->info->text_antialias = (MagickBooleanType) RTEST(text_antialias);
    return text_antialias;
}

#undercolor=(undercolor) ⇒ Magick::Pixel, String

Set undercolor.

Parameters:

Returns:



797
798
799
800
801
802
803
804
805
806
 
# File 'ext/RMagick/rmdraw.c', line 797

VALUE
Draw_undercolor_eq(VALUE self, VALUE undercolor)
{
    Draw *draw;

    rb_check_frozen(self);
    Data_Get_Struct(self, Draw, draw);
    Color_to_PixelColor(&draw->info->undercolor, undercolor);
    return undercolor;
}