rmagick 2.8.0 → 2.9.0
Sign up to get free protection for your applications and to get access to all the features.
Potentially problematic release.
This version of rmagick might be problematic. Click here for more details.
- data/ChangeLog +10 -2
- data/README.html +7 -7
- data/doc/comtasks.html +2 -2
- data/doc/constants.html +5 -5
- data/doc/draw.html +131 -20
- data/doc/ex/InitialCoords.rb +1 -1
- data/doc/ex/NewCoordSys.rb +2 -2
- data/doc/ex/OrigCoordSys.rb +1 -1
- data/doc/ex/RotateScale.rb +2 -2
- data/doc/ex/Skew.rb +2 -2
- data/doc/ex/ViewBox.rb +1 -1
- data/doc/ex/arc.rb +4 -2
- data/doc/ex/arcs02.rb +1 -1
- data/doc/ex/bounding_box.rb +3 -0
- data/doc/ex/cbezier1.rb +2 -0
- data/doc/ex/cbezier2.rb +2 -0
- data/doc/ex/cbezier3.rb +2 -0
- data/doc/ex/cbezier4.rb +2 -0
- data/doc/ex/cbezier5.rb +2 -0
- data/doc/ex/cbezier6.rb +2 -0
- data/doc/ex/channel.rb +1 -0
- data/doc/ex/circle.rb +2 -0
- data/doc/ex/cubic01.rb +1 -1
- data/doc/ex/cubic02.rb +1 -1
- data/doc/ex/ellipse.rb +2 -0
- data/doc/ex/font_styles.rb +12 -10
- data/doc/ex/get_type_metrics.rb +2 -0
- data/doc/ex/grav.rb +2 -0
- data/doc/ex/image.rb +1 -1
- data/doc/ex/line.rb +2 -0
- data/doc/ex/opacity.rb +6 -4
- data/doc/ex/path.rb +2 -0
- data/doc/ex/polaroid.rb +2 -0
- data/doc/ex/qbezierpath.rb +3 -0
- data/doc/ex/rectangle.rb +2 -0
- data/doc/ex/rotate.rb +2 -0
- data/doc/ex/roundrect.rb +2 -0
- data/doc/ex/skewx.rb +2 -0
- data/doc/ex/skewy.rb +2 -0
- data/doc/ex/stroke_dasharray.rb +2 -0
- data/doc/ex/stroke_width.rb +2 -0
- data/doc/ex/text.rb +3 -2
- data/doc/ex/text01.rb +1 -1
- data/doc/ex/text_styles.rb +1 -1
- data/doc/ex/text_undercolor.rb +2 -0
- data/doc/ex/translate.rb +3 -1
- data/doc/ilist.html +2 -2
- data/doc/image1.html +2 -2
- data/doc/image2.html +2 -2
- data/doc/image3.html +37 -6
- data/doc/imageattrs.html +2 -2
- data/doc/imusage.html +3 -3
- data/doc/index.html +3 -3
- data/doc/info.html +2 -2
- data/doc/magick.html +2 -2
- data/doc/optequiv.html +24 -2
- data/doc/rvg.html +2 -2
- data/doc/rvgclip.html +2 -2
- data/doc/rvggroup.html +2 -2
- data/doc/rvgimage.html +2 -2
- data/doc/rvgpattern.html +2 -2
- data/doc/rvgshape.html +2 -2
- data/doc/rvgstyle.html +2 -2
- data/doc/rvgtext.html +2 -2
- data/doc/rvgtspan.html +2 -2
- data/doc/rvgtut.html +2 -2
- data/doc/rvguse.html +2 -2
- data/doc/rvgxform.html +2 -2
- data/doc/struct.html +2 -2
- data/doc/usage.html +6 -4
- data/ext/RMagick/MANIFEST +6 -1
- data/ext/RMagick/extconf.rb +18 -2
- data/ext/RMagick/rmagick.c +312 -0
- data/ext/RMagick/rmagick.h +137 -61
- data/ext/RMagick/rmdraw.c +271 -377
- data/ext/RMagick/rmenum.c +1016 -0
- data/ext/RMagick/rmimage.c +172 -16
- data/ext/RMagick/rminfo.c +5 -5
- data/ext/RMagick/rmmain.c +50 -303
- data/ext/RMagick/rmmontage.c +386 -0
- data/ext/RMagick/rmpixel.c +816 -0
- data/ext/RMagick/rmstruct.c +887 -0
- data/ext/RMagick/rmutil.c +25 -2634
- data/lib/RMagick.rb +46 -2
- data/lib/rvg/misc.rb +5 -4
- data/lib/rvg/stylable.rb +7 -1
- data/rmagick.gemspec +1 -1
- metadata +7 -2
@@ -0,0 +1,1016 @@
|
|
1
|
+
/* $Id: rmenum.c,v 1.1 2008/12/27 16:49:47 rmagick Exp $ */
|
2
|
+
/*============================================================================\
|
3
|
+
| Copyright (C) 2008 by Timothy P. Hunter
|
4
|
+
| Name: rmenum.c
|
5
|
+
| Author: Tim Hunter
|
6
|
+
| Purpose: Enumeration methods
|
7
|
+
\============================================================================*/
|
8
|
+
|
9
|
+
|
10
|
+
|
11
|
+
|
12
|
+
#include "rmagick.h"
|
13
|
+
|
14
|
+
|
15
|
+
#define ENUMERATORS_CLASS_VAR "@@enumerators"
|
16
|
+
|
17
|
+
|
18
|
+
static VALUE Enum_type_values(VALUE);
|
19
|
+
static VALUE Enum_type_inspect(VALUE);
|
20
|
+
|
21
|
+
|
22
|
+
|
23
|
+
|
24
|
+
|
25
|
+
/*
|
26
|
+
* Extern: rm_define_enum_type
|
27
|
+
* Purpose: set up a subclass of Enum
|
28
|
+
*/
|
29
|
+
VALUE
|
30
|
+
rm_define_enum_type(const char *tag)
|
31
|
+
{
|
32
|
+
VALUE class;
|
33
|
+
|
34
|
+
class = rb_define_class_under(Module_Magick, tag, Class_Enum);\
|
35
|
+
|
36
|
+
rb_define_singleton_method(class, "values", Enum_type_values, 0);
|
37
|
+
rb_define_method(class, "initialize", Enum_type_initialize, 2);
|
38
|
+
rb_define_method(class, "inspect", Enum_type_inspect, 0);
|
39
|
+
return class;
|
40
|
+
}
|
41
|
+
|
42
|
+
|
43
|
+
/*
|
44
|
+
Extern: rm_enum_new (1.8)
|
45
|
+
Purpose: Construct a new Enum subclass instance
|
46
|
+
*/
|
47
|
+
VALUE
|
48
|
+
rm_enum_new(VALUE class, VALUE sym, VALUE val)
|
49
|
+
{
|
50
|
+
VALUE argv[2];
|
51
|
+
|
52
|
+
argv[0] = sym;
|
53
|
+
argv[1] = val;
|
54
|
+
return rb_obj_freeze(rb_class_new_instance(2, argv, class));
|
55
|
+
}
|
56
|
+
|
57
|
+
|
58
|
+
/*
|
59
|
+
Extern: Enum_alloc (1.8)
|
60
|
+
Purpose: Enum class alloc function
|
61
|
+
*/
|
62
|
+
VALUE
|
63
|
+
Enum_alloc(VALUE class)
|
64
|
+
{
|
65
|
+
MagickEnum *magick_enum;
|
66
|
+
volatile VALUE enumr;
|
67
|
+
|
68
|
+
enumr = Data_Make_Struct(class, MagickEnum, NULL, NULL, magick_enum);
|
69
|
+
rb_obj_freeze(enumr);
|
70
|
+
return enumr;
|
71
|
+
}
|
72
|
+
|
73
|
+
|
74
|
+
/*
|
75
|
+
Method: Enum#===
|
76
|
+
Purpose: "Case equal" operator for Enum
|
77
|
+
Returns: true or false
|
78
|
+
Notes: Yes, I know "case equal" is a misnomer.
|
79
|
+
*/
|
80
|
+
VALUE
|
81
|
+
Enum_case_eq(VALUE self, VALUE other)
|
82
|
+
{
|
83
|
+
MagickEnum *this, *that;
|
84
|
+
|
85
|
+
if (CLASS_OF(self) == CLASS_OF(other))
|
86
|
+
{
|
87
|
+
Data_Get_Struct(self, MagickEnum, this);
|
88
|
+
Data_Get_Struct(other, MagickEnum, that);
|
89
|
+
return this->val == that->val ? Qtrue : Qfalse;
|
90
|
+
}
|
91
|
+
|
92
|
+
return Qfalse;
|
93
|
+
}
|
94
|
+
|
95
|
+
|
96
|
+
/*
|
97
|
+
Method: Enum#initialize
|
98
|
+
Purpose: Initialize a new Enum instance
|
99
|
+
*/
|
100
|
+
VALUE
|
101
|
+
Enum_initialize(VALUE self, VALUE sym, VALUE val)
|
102
|
+
{
|
103
|
+
MagickEnum *magick_enum;
|
104
|
+
|
105
|
+
Data_Get_Struct(self, MagickEnum, magick_enum);
|
106
|
+
magick_enum->id = rb_to_id(sym); /* convert symbol to ID */
|
107
|
+
magick_enum->val = NUM2INT(val);
|
108
|
+
|
109
|
+
return self;
|
110
|
+
}
|
111
|
+
|
112
|
+
|
113
|
+
/*
|
114
|
+
Method: Enum#to_i
|
115
|
+
Purpose: Return the value of an enum
|
116
|
+
*/
|
117
|
+
VALUE
|
118
|
+
Enum_to_i(VALUE self)
|
119
|
+
{
|
120
|
+
MagickEnum *magick_enum;
|
121
|
+
|
122
|
+
Data_Get_Struct(self, MagickEnum, magick_enum);
|
123
|
+
return INT2NUM(magick_enum->val);
|
124
|
+
}
|
125
|
+
|
126
|
+
|
127
|
+
/*
|
128
|
+
Method: Enum#<=>
|
129
|
+
Purpose: Support Comparable module in Enum
|
130
|
+
Returns: -1, 0, 1, or nil
|
131
|
+
Notes: Enums must be instances of the same class to be equal.
|
132
|
+
*/
|
133
|
+
VALUE
|
134
|
+
Enum_spaceship(VALUE self, VALUE other)
|
135
|
+
{
|
136
|
+
MagickEnum *this, *that;
|
137
|
+
|
138
|
+
Data_Get_Struct(self, MagickEnum, this);
|
139
|
+
Data_Get_Struct(other, MagickEnum, that);
|
140
|
+
|
141
|
+
if (this->val > that->val)
|
142
|
+
{
|
143
|
+
return INT2FIX(1);
|
144
|
+
}
|
145
|
+
else if (this->val < that->val)
|
146
|
+
{
|
147
|
+
return INT2FIX(-1);
|
148
|
+
}
|
149
|
+
|
150
|
+
// Values are equal, check class.
|
151
|
+
|
152
|
+
return rb_funcall(CLASS_OF(self), rm_ID_spaceship, 1, CLASS_OF(other));
|
153
|
+
}
|
154
|
+
|
155
|
+
|
156
|
+
/*
|
157
|
+
Method: Enum#to_s
|
158
|
+
Purpose: Return the name of an enum
|
159
|
+
*/
|
160
|
+
VALUE
|
161
|
+
Enum_to_s(VALUE self)
|
162
|
+
{
|
163
|
+
MagickEnum *magick_enum;
|
164
|
+
|
165
|
+
Data_Get_Struct(self, MagickEnum, magick_enum);
|
166
|
+
return rb_str_new2(rb_id2name(magick_enum->id));
|
167
|
+
}
|
168
|
+
|
169
|
+
|
170
|
+
/*
|
171
|
+
* Method: xxx#initialize
|
172
|
+
* Purpose: initialize method for all Enum subclasses
|
173
|
+
*/
|
174
|
+
VALUE
|
175
|
+
Enum_type_initialize(VALUE self, VALUE sym, VALUE val)
|
176
|
+
{
|
177
|
+
VALUE super_argv[2];
|
178
|
+
volatile VALUE enumerators;
|
179
|
+
|
180
|
+
super_argv[0] = sym;
|
181
|
+
super_argv[1] = val;
|
182
|
+
(void) rb_call_super(2, (const VALUE *)super_argv);
|
183
|
+
|
184
|
+
if (rb_cvar_defined(CLASS_OF(self), rb_intern(ENUMERATORS_CLASS_VAR)) != Qtrue)
|
185
|
+
{
|
186
|
+
rb_cv_set(CLASS_OF(self), ENUMERATORS_CLASS_VAR, rb_ary_new());
|
187
|
+
}
|
188
|
+
|
189
|
+
enumerators = rb_cv_get(CLASS_OF(self), ENUMERATORS_CLASS_VAR);
|
190
|
+
(void) rb_ary_push(enumerators, self);
|
191
|
+
|
192
|
+
return self;
|
193
|
+
}
|
194
|
+
|
195
|
+
|
196
|
+
/*
|
197
|
+
* Method: xxx#inspect
|
198
|
+
* Purpose: Enum subclass #inspect
|
199
|
+
*/
|
200
|
+
static VALUE
|
201
|
+
Enum_type_inspect(VALUE self)
|
202
|
+
{
|
203
|
+
char str[100];
|
204
|
+
MagickEnum *magick_enum;
|
205
|
+
|
206
|
+
Data_Get_Struct(self, MagickEnum, magick_enum);
|
207
|
+
sprintf(str, "%.32s=%d", rb_id2name(magick_enum->id), magick_enum->val);
|
208
|
+
|
209
|
+
return rb_str_new2(str);
|
210
|
+
}
|
211
|
+
|
212
|
+
|
213
|
+
/*
|
214
|
+
* Method: xxx.values
|
215
|
+
* Purpose: Behaves like #each if a block is present, otherwise like #to_a.
|
216
|
+
* Notes: defined for each Enum subclass
|
217
|
+
*/
|
218
|
+
static VALUE
|
219
|
+
Enum_type_values(VALUE class)
|
220
|
+
{
|
221
|
+
volatile VALUE enumerators, copy;
|
222
|
+
volatile VALUE rv;
|
223
|
+
int x;
|
224
|
+
|
225
|
+
enumerators = rb_cv_get(class, ENUMERATORS_CLASS_VAR);
|
226
|
+
|
227
|
+
if (rb_block_given_p())
|
228
|
+
{
|
229
|
+
for (x = 0; x < RARRAY_LEN(enumerators); x++)
|
230
|
+
{
|
231
|
+
(void) rb_yield(rb_ary_entry(enumerators, x));
|
232
|
+
}
|
233
|
+
rv = class;
|
234
|
+
}
|
235
|
+
else
|
236
|
+
{
|
237
|
+
copy = rb_ary_new2(RARRAY_LEN(enumerators));
|
238
|
+
for (x = 0; x < RARRAY_LEN(enumerators); x++)
|
239
|
+
{
|
240
|
+
(void) rb_ary_push(copy, rb_ary_entry(enumerators, x));
|
241
|
+
}
|
242
|
+
rb_obj_freeze(copy);
|
243
|
+
rv = copy;
|
244
|
+
}
|
245
|
+
|
246
|
+
return rv;
|
247
|
+
}
|
248
|
+
|
249
|
+
|
250
|
+
/*
|
251
|
+
Extern: ClassType_new
|
252
|
+
Purpose: Construct a ClassType enum object for the specified value
|
253
|
+
*/
|
254
|
+
VALUE
|
255
|
+
ClassType_new(ClassType cls)
|
256
|
+
{
|
257
|
+
const char *name;
|
258
|
+
|
259
|
+
switch(cls)
|
260
|
+
{
|
261
|
+
default:
|
262
|
+
case UndefinedClass:
|
263
|
+
name = "UndefineClass";
|
264
|
+
break;
|
265
|
+
case DirectClass:
|
266
|
+
name = "DirectClass";
|
267
|
+
break;
|
268
|
+
case PseudoClass:
|
269
|
+
name = "PseudoClass";
|
270
|
+
break;
|
271
|
+
}
|
272
|
+
|
273
|
+
return rm_enum_new(Class_ClassType, ID2SYM(rb_intern(name)), INT2FIX(cls));
|
274
|
+
}
|
275
|
+
|
276
|
+
|
277
|
+
/*
|
278
|
+
Extern: ColorspaceType_new
|
279
|
+
Purpose: construct a ColorspaceType enum object for the specified value
|
280
|
+
*/
|
281
|
+
VALUE
|
282
|
+
ColorspaceType_new(ColorspaceType cs)
|
283
|
+
{
|
284
|
+
const char *name;
|
285
|
+
|
286
|
+
switch(cs)
|
287
|
+
{
|
288
|
+
default:
|
289
|
+
case UndefinedColorspace:
|
290
|
+
name = "UndefinedColorspace";
|
291
|
+
break;
|
292
|
+
case RGBColorspace:
|
293
|
+
name = "RGBColorspace";
|
294
|
+
break;
|
295
|
+
case GRAYColorspace:
|
296
|
+
name = "GRAYColorspace";
|
297
|
+
break;
|
298
|
+
case TransparentColorspace:
|
299
|
+
name = "TransparentColorspace";
|
300
|
+
break;
|
301
|
+
case OHTAColorspace:
|
302
|
+
name = "OHTAColorspace";
|
303
|
+
break;
|
304
|
+
case XYZColorspace:
|
305
|
+
name = "XYZColorspace";
|
306
|
+
break;
|
307
|
+
case YCbCrColorspace:
|
308
|
+
name = "YCbCrColorspace";
|
309
|
+
break;
|
310
|
+
case YCCColorspace:
|
311
|
+
name = "YCCColorspace";
|
312
|
+
break;
|
313
|
+
case YIQColorspace:
|
314
|
+
name = "YIQColorspace";
|
315
|
+
break;
|
316
|
+
case YPbPrColorspace:
|
317
|
+
name = "YPbPrColorspace";
|
318
|
+
break;
|
319
|
+
case YUVColorspace:
|
320
|
+
name = "YUVColorspace";
|
321
|
+
break;
|
322
|
+
case CMYKColorspace:
|
323
|
+
name = "CMYKColorspace";
|
324
|
+
break;
|
325
|
+
case sRGBColorspace:
|
326
|
+
name = "sRGBColorspace";
|
327
|
+
break;
|
328
|
+
case HSLColorspace:
|
329
|
+
name = "HSLColorspace";
|
330
|
+
break;
|
331
|
+
case HWBColorspace:
|
332
|
+
name = "HWBColorspace";
|
333
|
+
break;
|
334
|
+
case HSBColorspace:
|
335
|
+
name = "HSBColorspace";
|
336
|
+
break;
|
337
|
+
case LABColorspace:
|
338
|
+
name = "LABColorspace";
|
339
|
+
break;
|
340
|
+
case Rec601YCbCrColorspace:
|
341
|
+
name = "Rec601YCbCrColorspace";
|
342
|
+
break;
|
343
|
+
case Rec601LumaColorspace:
|
344
|
+
name = "Rec601LumaColorspace";
|
345
|
+
break;
|
346
|
+
case Rec709LumaColorspace:
|
347
|
+
name = "Rec709LumaColorspace";
|
348
|
+
break;
|
349
|
+
case Rec709YCbCrColorspace:
|
350
|
+
name = "Rec709YCbCrColorspace";
|
351
|
+
break;
|
352
|
+
case LogColorspace:
|
353
|
+
name = "LogColorspace";
|
354
|
+
break;
|
355
|
+
#if defined(HAVE_ENUM_CMYCOLORSPACE)
|
356
|
+
case CMYColorspace:
|
357
|
+
name = "CMYColorspace";
|
358
|
+
break;
|
359
|
+
#endif
|
360
|
+
}
|
361
|
+
|
362
|
+
return rm_enum_new(Class_ColorspaceType, ID2SYM(rb_intern(name)), INT2FIX(cs));
|
363
|
+
|
364
|
+
}
|
365
|
+
|
366
|
+
|
367
|
+
/*
|
368
|
+
Static: CompositeOperator_new
|
369
|
+
Purpose: return the name of a CompositeOperator enum as a string
|
370
|
+
*/
|
371
|
+
static const char *
|
372
|
+
CompositeOperator_name(CompositeOperator op)
|
373
|
+
{
|
374
|
+
switch (op)
|
375
|
+
{
|
376
|
+
ENUM_TO_NAME(UndefinedCompositeOp)
|
377
|
+
ENUM_TO_NAME(NoCompositeOp)
|
378
|
+
ENUM_TO_NAME(AddCompositeOp)
|
379
|
+
ENUM_TO_NAME(AtopCompositeOp)
|
380
|
+
ENUM_TO_NAME(BumpmapCompositeOp)
|
381
|
+
#if defined(HAVE_ENUM_CHANGEMASKCOMPOSITEOP)
|
382
|
+
ENUM_TO_NAME(ChangeMaskCompositeOp)
|
383
|
+
#endif
|
384
|
+
ENUM_TO_NAME(ClearCompositeOp)
|
385
|
+
ENUM_TO_NAME(ColorBurnCompositeOp)
|
386
|
+
ENUM_TO_NAME(BlendCompositeOp)
|
387
|
+
ENUM_TO_NAME(ColorDodgeCompositeOp)
|
388
|
+
ENUM_TO_NAME(ExclusionCompositeOp)
|
389
|
+
ENUM_TO_NAME(HardLightCompositeOp)
|
390
|
+
ENUM_TO_NAME(SoftLightCompositeOp)
|
391
|
+
ENUM_TO_NAME(ColorizeCompositeOp)
|
392
|
+
ENUM_TO_NAME(CopyBlueCompositeOp)
|
393
|
+
ENUM_TO_NAME(CopyCompositeOp)
|
394
|
+
ENUM_TO_NAME(CopyCyanCompositeOp)
|
395
|
+
ENUM_TO_NAME(CopyMagentaCompositeOp)
|
396
|
+
ENUM_TO_NAME(CopyYellowCompositeOp)
|
397
|
+
ENUM_TO_NAME(CopyBlackCompositeOp)
|
398
|
+
ENUM_TO_NAME(CopyGreenCompositeOp)
|
399
|
+
ENUM_TO_NAME(CopyOpacityCompositeOp)
|
400
|
+
ENUM_TO_NAME(CopyRedCompositeOp)
|
401
|
+
ENUM_TO_NAME(DarkenCompositeOp)
|
402
|
+
#if defined(HAVE_ENUM_DIVIDECOMPOSITEOP)
|
403
|
+
ENUM_TO_NAME(DivideCompositeOp)
|
404
|
+
#endif
|
405
|
+
ENUM_TO_NAME(DstAtopCompositeOp)
|
406
|
+
ENUM_TO_NAME(DstCompositeOp)
|
407
|
+
ENUM_TO_NAME(DstInCompositeOp)
|
408
|
+
ENUM_TO_NAME(DstOutCompositeOp)
|
409
|
+
ENUM_TO_NAME(DstOverCompositeOp)
|
410
|
+
ENUM_TO_NAME(DifferenceCompositeOp)
|
411
|
+
ENUM_TO_NAME(DisplaceCompositeOp)
|
412
|
+
ENUM_TO_NAME(DissolveCompositeOp)
|
413
|
+
ENUM_TO_NAME(HueCompositeOp)
|
414
|
+
ENUM_TO_NAME(InCompositeOp)
|
415
|
+
ENUM_TO_NAME(LightenCompositeOp)
|
416
|
+
#if defined(HAVE_ENUM_LINEARLIGHTCOMPOSITEOP)
|
417
|
+
ENUM_TO_NAME(LinearLightCompositeOp)
|
418
|
+
#endif
|
419
|
+
ENUM_TO_NAME(LuminizeCompositeOp)
|
420
|
+
ENUM_TO_NAME(MinusCompositeOp)
|
421
|
+
ENUM_TO_NAME(ModulateCompositeOp)
|
422
|
+
ENUM_TO_NAME(MultiplyCompositeOp)
|
423
|
+
ENUM_TO_NAME(OutCompositeOp)
|
424
|
+
ENUM_TO_NAME(OverCompositeOp)
|
425
|
+
ENUM_TO_NAME(OverlayCompositeOp)
|
426
|
+
ENUM_TO_NAME(PlusCompositeOp)
|
427
|
+
ENUM_TO_NAME(ReplaceCompositeOp)
|
428
|
+
ENUM_TO_NAME(SaturateCompositeOp)
|
429
|
+
ENUM_TO_NAME(ScreenCompositeOp)
|
430
|
+
ENUM_TO_NAME(SrcAtopCompositeOp)
|
431
|
+
ENUM_TO_NAME(SrcCompositeOp)
|
432
|
+
ENUM_TO_NAME(SrcInCompositeOp)
|
433
|
+
ENUM_TO_NAME(SrcOutCompositeOp)
|
434
|
+
ENUM_TO_NAME(SrcOverCompositeOp)
|
435
|
+
ENUM_TO_NAME(SubtractCompositeOp)
|
436
|
+
ENUM_TO_NAME(ThresholdCompositeOp)
|
437
|
+
ENUM_TO_NAME(XorCompositeOp)
|
438
|
+
}
|
439
|
+
|
440
|
+
return "UndefinedCompositeOp";
|
441
|
+
}
|
442
|
+
|
443
|
+
|
444
|
+
/*
|
445
|
+
External: CompositeOperator_new
|
446
|
+
Purpose: Construct a CompositeOperator enum object for the specified value
|
447
|
+
*/
|
448
|
+
VALUE
|
449
|
+
CompositeOperator_new(CompositeOperator op)
|
450
|
+
{
|
451
|
+
const char *name = CompositeOperator_name(op);
|
452
|
+
return rm_enum_new(Class_CompositeOperator, ID2SYM(rb_intern(name)), INT2FIX(op));
|
453
|
+
}
|
454
|
+
|
455
|
+
|
456
|
+
/*
|
457
|
+
Static: CompressionType_name
|
458
|
+
Purpose: Return the name of a CompressionType enum as a string
|
459
|
+
*/
|
460
|
+
static const char *
|
461
|
+
CompressionType_name(CompressionType ct)
|
462
|
+
{
|
463
|
+
switch (ct)
|
464
|
+
{
|
465
|
+
ENUM_TO_NAME(UndefinedCompression)
|
466
|
+
ENUM_TO_NAME(NoCompression)
|
467
|
+
ENUM_TO_NAME(BZipCompression)
|
468
|
+
#if defined(HAVE_ENUM_DXT1COMPRESSION)
|
469
|
+
ENUM_TO_NAME(DXT1Compression)
|
470
|
+
#endif
|
471
|
+
#if defined(HAVE_ENUM_DXT3COMPRESSION)
|
472
|
+
ENUM_TO_NAME(DXT3Compression)
|
473
|
+
#endif
|
474
|
+
#if defined(HAVE_ENUM_DXT5COMPRESSION)
|
475
|
+
ENUM_TO_NAME(DXT5Compression)
|
476
|
+
#endif
|
477
|
+
ENUM_TO_NAME(FaxCompression)
|
478
|
+
ENUM_TO_NAME(Group4Compression)
|
479
|
+
ENUM_TO_NAME(JPEGCompression)
|
480
|
+
ENUM_TO_NAME(JPEG2000Compression)
|
481
|
+
ENUM_TO_NAME(LosslessJPEGCompression)
|
482
|
+
ENUM_TO_NAME(LZWCompression)
|
483
|
+
ENUM_TO_NAME(RLECompression)
|
484
|
+
ENUM_TO_NAME(ZipCompression)
|
485
|
+
}
|
486
|
+
|
487
|
+
return "UndefinedCompression";
|
488
|
+
}
|
489
|
+
|
490
|
+
|
491
|
+
/*
|
492
|
+
* External: CompressionType_new
|
493
|
+
Purpose: Construct a CompressionType enum object for the specified value
|
494
|
+
*/
|
495
|
+
VALUE
|
496
|
+
CompressionType_new(CompressionType ct)
|
497
|
+
{
|
498
|
+
const char *name = CompressionType_name(ct);
|
499
|
+
return rm_enum_new(Class_CompressionType, ID2SYM(rb_intern(name)), INT2FIX(ct));
|
500
|
+
}
|
501
|
+
|
502
|
+
|
503
|
+
/*
|
504
|
+
Static: DisposeType_name
|
505
|
+
Purpose: Return the name of a DisposeType enum as a string
|
506
|
+
*/
|
507
|
+
static const char *
|
508
|
+
DisposeType_name(DisposeType type)
|
509
|
+
{
|
510
|
+
switch(type)
|
511
|
+
{
|
512
|
+
ENUM_TO_NAME(UndefinedDispose)
|
513
|
+
ENUM_TO_NAME(BackgroundDispose)
|
514
|
+
ENUM_TO_NAME(NoneDispose)
|
515
|
+
ENUM_TO_NAME(PreviousDispose)
|
516
|
+
}
|
517
|
+
|
518
|
+
return "UndefinedDispose";
|
519
|
+
}
|
520
|
+
|
521
|
+
|
522
|
+
/*
|
523
|
+
External: DisposeType.new
|
524
|
+
Purpose: Construct a DisposeType enum object for the specified value..new
|
525
|
+
*/
|
526
|
+
VALUE
|
527
|
+
DisposeType_new(DisposeType type)
|
528
|
+
{
|
529
|
+
const char *name = DisposeType_name(type);
|
530
|
+
return rm_enum_new(Class_DisposeType, ID2SYM(rb_intern(name)), INT2FIX(type));
|
531
|
+
}
|
532
|
+
|
533
|
+
|
534
|
+
/*
|
535
|
+
Static: FilterTypes_name
|
536
|
+
Purpose: Return the name of a FilterTypes enum as a string
|
537
|
+
*/
|
538
|
+
static const char *
|
539
|
+
FilterTypes_name(FilterTypes type)
|
540
|
+
{
|
541
|
+
switch(type)
|
542
|
+
{
|
543
|
+
ENUM_TO_NAME(UndefinedFilter)
|
544
|
+
ENUM_TO_NAME(PointFilter)
|
545
|
+
ENUM_TO_NAME(BoxFilter)
|
546
|
+
ENUM_TO_NAME(TriangleFilter)
|
547
|
+
ENUM_TO_NAME(HermiteFilter)
|
548
|
+
ENUM_TO_NAME(HanningFilter)
|
549
|
+
ENUM_TO_NAME(HammingFilter)
|
550
|
+
ENUM_TO_NAME(BlackmanFilter)
|
551
|
+
ENUM_TO_NAME(GaussianFilter)
|
552
|
+
ENUM_TO_NAME(QuadraticFilter)
|
553
|
+
ENUM_TO_NAME(CubicFilter)
|
554
|
+
ENUM_TO_NAME(CatromFilter)
|
555
|
+
ENUM_TO_NAME(MitchellFilter)
|
556
|
+
ENUM_TO_NAME(LanczosFilter)
|
557
|
+
ENUM_TO_NAME(BesselFilter)
|
558
|
+
ENUM_TO_NAME(SincFilter)
|
559
|
+
#if defined(HAVE_ENUM_KAISERFILTER)
|
560
|
+
ENUM_TO_NAME(KaiserFilter)
|
561
|
+
#endif
|
562
|
+
#if defined(HAVE_ENUM_WELSHFILTER)
|
563
|
+
ENUM_TO_NAME(WelshFilter)
|
564
|
+
#endif
|
565
|
+
#if defined(HAVE_ENUM_PARZENFILTER)
|
566
|
+
ENUM_TO_NAME(ParzenFilter)
|
567
|
+
#endif
|
568
|
+
#if defined(HAVE_ENUM_LAGRANGEFILTER)
|
569
|
+
ENUM_TO_NAME(LagrangeFilter)
|
570
|
+
#endif
|
571
|
+
#if defined(HAVE_ENUM_BOHMANFILTER)
|
572
|
+
ENUM_TO_NAME(BohmanFilter)
|
573
|
+
#endif
|
574
|
+
#if defined(HAVE_ENUM_BARTLETTFILTER)
|
575
|
+
ENUM_TO_NAME(BartlettFilter)
|
576
|
+
#endif
|
577
|
+
#if defined(HAVE_ENUM_SENTINELFILTER)
|
578
|
+
// not a real filter name - defeat gcc warning message
|
579
|
+
case SentinelFilter:
|
580
|
+
break;
|
581
|
+
#endif
|
582
|
+
}
|
583
|
+
|
584
|
+
return "UndefinedFilter";
|
585
|
+
}
|
586
|
+
|
587
|
+
|
588
|
+
/*
|
589
|
+
External: FilterTypes.new
|
590
|
+
Purpose: Construct an FilterTypes enum object for the specified value
|
591
|
+
*/
|
592
|
+
VALUE
|
593
|
+
FilterTypes_new(FilterTypes type)
|
594
|
+
{
|
595
|
+
const char *name = FilterTypes_name(type);
|
596
|
+
return rm_enum_new(Class_FilterTypes, ID2SYM(rb_intern(name)), INT2FIX(type));
|
597
|
+
}
|
598
|
+
|
599
|
+
|
600
|
+
/*
|
601
|
+
Static: EndianType_name
|
602
|
+
Purpose: Return the name of a EndianType enum as a string
|
603
|
+
*/
|
604
|
+
static const char *
|
605
|
+
EndianType_name(EndianType type)
|
606
|
+
{
|
607
|
+
switch(type)
|
608
|
+
{
|
609
|
+
ENUM_TO_NAME(UndefinedEndian)
|
610
|
+
ENUM_TO_NAME(LSBEndian)
|
611
|
+
ENUM_TO_NAME(MSBEndian)
|
612
|
+
}
|
613
|
+
return "UndefinedEndian";
|
614
|
+
}
|
615
|
+
|
616
|
+
|
617
|
+
/*
|
618
|
+
External: EndianType.new
|
619
|
+
Purpose: Construct an EndianType enum object
|
620
|
+
*/
|
621
|
+
VALUE
|
622
|
+
EndianType_new(EndianType type)
|
623
|
+
{
|
624
|
+
const char *name = EndianType_name(type);
|
625
|
+
return rm_enum_new(Class_EndianType, ID2SYM(rb_intern(name)), INT2FIX(type));
|
626
|
+
}
|
627
|
+
|
628
|
+
|
629
|
+
/*
|
630
|
+
Static: GravityType_name
|
631
|
+
Purpose: Return the name of a GravityType enum as a string
|
632
|
+
*/
|
633
|
+
static const char *
|
634
|
+
GravityType_name(GravityType type)
|
635
|
+
{
|
636
|
+
switch(type)
|
637
|
+
{
|
638
|
+
ENUM_TO_NAME(ForgetGravity)
|
639
|
+
ENUM_TO_NAME(NorthWestGravity)
|
640
|
+
ENUM_TO_NAME(NorthGravity)
|
641
|
+
ENUM_TO_NAME(NorthEastGravity)
|
642
|
+
ENUM_TO_NAME(WestGravity)
|
643
|
+
ENUM_TO_NAME(CenterGravity)
|
644
|
+
ENUM_TO_NAME(EastGravity)
|
645
|
+
ENUM_TO_NAME(SouthWestGravity)
|
646
|
+
ENUM_TO_NAME(SouthGravity)
|
647
|
+
ENUM_TO_NAME(SouthEastGravity)
|
648
|
+
ENUM_TO_NAME(StaticGravity)
|
649
|
+
}
|
650
|
+
|
651
|
+
// Defeat "duplicate case value" error.
|
652
|
+
return "UndefinedGravity";
|
653
|
+
}
|
654
|
+
|
655
|
+
|
656
|
+
/*
|
657
|
+
External: GravityType.new
|
658
|
+
Purpose: Construct an GravityType enum object for the specified value
|
659
|
+
*/
|
660
|
+
VALUE
|
661
|
+
GravityType_new(GravityType type)
|
662
|
+
{
|
663
|
+
const char *name = GravityType_name(type);
|
664
|
+
return rm_enum_new(Class_GravityType, ID2SYM(rb_intern(name)), INT2FIX(type));
|
665
|
+
}
|
666
|
+
|
667
|
+
|
668
|
+
/*
|
669
|
+
Static: ImageType_name
|
670
|
+
Purpose: Return the name of a ImageType enum as a string
|
671
|
+
*/
|
672
|
+
static const char *
|
673
|
+
ImageType_name(ImageType type)
|
674
|
+
{
|
675
|
+
switch(type)
|
676
|
+
{
|
677
|
+
ENUM_TO_NAME(UndefinedType)
|
678
|
+
ENUM_TO_NAME(BilevelType)
|
679
|
+
ENUM_TO_NAME(GrayscaleType)
|
680
|
+
ENUM_TO_NAME(GrayscaleMatteType)
|
681
|
+
ENUM_TO_NAME(PaletteType)
|
682
|
+
ENUM_TO_NAME(PaletteMatteType)
|
683
|
+
ENUM_TO_NAME(TrueColorType)
|
684
|
+
ENUM_TO_NAME(TrueColorMatteType)
|
685
|
+
ENUM_TO_NAME(ColorSeparationType)
|
686
|
+
ENUM_TO_NAME(ColorSeparationMatteType)
|
687
|
+
ENUM_TO_NAME(OptimizeType)
|
688
|
+
ENUM_TO_NAME(PaletteBilevelMatteType)
|
689
|
+
}
|
690
|
+
|
691
|
+
return "UndefinedType";
|
692
|
+
}
|
693
|
+
|
694
|
+
|
695
|
+
/*
|
696
|
+
External: ImageType.new
|
697
|
+
Purpose: Construct an ImageType enum object for the specified value
|
698
|
+
*/
|
699
|
+
VALUE
|
700
|
+
ImageType_new(ImageType type)
|
701
|
+
{
|
702
|
+
const char *name = ImageType_name(type);
|
703
|
+
return rm_enum_new(Class_ImageType, ID2SYM(rb_intern(name)), INT2FIX(type));
|
704
|
+
}
|
705
|
+
|
706
|
+
|
707
|
+
/*
|
708
|
+
Static: InterlaceType_name
|
709
|
+
Purpose: Return the name of a InterlaceType enum as a string
|
710
|
+
*/
|
711
|
+
static const char *
|
712
|
+
InterlaceType_name(InterlaceType interlace)
|
713
|
+
{
|
714
|
+
switch(interlace)
|
715
|
+
{
|
716
|
+
ENUM_TO_NAME(UndefinedInterlace)
|
717
|
+
#if defined(HAVE_ENUM_GIFINTERLACE)
|
718
|
+
ENUM_TO_NAME(GIFInterlace)
|
719
|
+
#endif
|
720
|
+
#if defined(HAVE_ENUM_JPEGINTERLACE)
|
721
|
+
ENUM_TO_NAME(JPEGInterlace)
|
722
|
+
#endif
|
723
|
+
#if defined(HAVE_ENUM_PNGINTERLACE)
|
724
|
+
ENUM_TO_NAME(PNGInterlace)
|
725
|
+
#endif
|
726
|
+
ENUM_TO_NAME(NoInterlace)
|
727
|
+
ENUM_TO_NAME(LineInterlace)
|
728
|
+
ENUM_TO_NAME(PlaneInterlace)
|
729
|
+
ENUM_TO_NAME(PartitionInterlace)
|
730
|
+
}
|
731
|
+
|
732
|
+
return "UndefinedInterlace";
|
733
|
+
}
|
734
|
+
|
735
|
+
|
736
|
+
/*
|
737
|
+
External: InterlaceType_new
|
738
|
+
Purpose: Construct an InterlaceType enum object for the specified value.
|
739
|
+
*/
|
740
|
+
VALUE
|
741
|
+
InterlaceType_new(InterlaceType interlace)
|
742
|
+
{
|
743
|
+
const char *name = InterlaceType_name(interlace);
|
744
|
+
return rm_enum_new(Class_InterlaceType, ID2SYM(rb_intern(name)), INT2FIX(interlace));
|
745
|
+
}
|
746
|
+
|
747
|
+
|
748
|
+
/*
|
749
|
+
Static: InterpolatePixelMethod_name
|
750
|
+
Purpose: Return the name of a InterpolatePixelMethod enum as a string
|
751
|
+
*/
|
752
|
+
static const char *
|
753
|
+
InterpolatePixelMethod_name(InterpolatePixelMethod interpolate)
|
754
|
+
{
|
755
|
+
switch(interpolate)
|
756
|
+
{
|
757
|
+
ENUM_TO_NAME(UndefinedInterpolatePixel)
|
758
|
+
ENUM_TO_NAME(AverageInterpolatePixel)
|
759
|
+
ENUM_TO_NAME(BicubicInterpolatePixel)
|
760
|
+
ENUM_TO_NAME(BilinearInterpolatePixel)
|
761
|
+
ENUM_TO_NAME(FilterInterpolatePixel)
|
762
|
+
ENUM_TO_NAME(IntegerInterpolatePixel)
|
763
|
+
ENUM_TO_NAME(MeshInterpolatePixel)
|
764
|
+
ENUM_TO_NAME(NearestNeighborInterpolatePixel)
|
765
|
+
#if defined(HAVE_ENUM_SPLINEINTERPOLATEPIXEL)
|
766
|
+
ENUM_TO_NAME(SplineInterpolatePixel)
|
767
|
+
#endif
|
768
|
+
}
|
769
|
+
|
770
|
+
return "UndefinedInterpolatePixel";
|
771
|
+
}
|
772
|
+
|
773
|
+
|
774
|
+
/*
|
775
|
+
External: InterpolatePixelMethod_new
|
776
|
+
Purpose: Construct an InterpolatePixelMethod enum object for the specified value.
|
777
|
+
*/
|
778
|
+
VALUE
|
779
|
+
InterpolatePixelMethod_new(InterpolatePixelMethod interpolate)
|
780
|
+
{
|
781
|
+
const char *name = InterpolatePixelMethod_name(interpolate);
|
782
|
+
return rm_enum_new(Class_InterpolatePixelMethod, ID2SYM(rb_intern(name)), INT2FIX(interpolate));
|
783
|
+
}
|
784
|
+
|
785
|
+
|
786
|
+
/*
|
787
|
+
External: MagickLayerMethod_new
|
788
|
+
Purpose: Construct an MagickLayerMethod enum object for the specified value.
|
789
|
+
*/
|
790
|
+
static const char *
|
791
|
+
LAYERMETHODTYPE_NAME(LAYERMETHODTYPE method)
|
792
|
+
{
|
793
|
+
switch(method)
|
794
|
+
{
|
795
|
+
ENUM_TO_NAME(UndefinedLayer)
|
796
|
+
ENUM_TO_NAME(CompareAnyLayer)
|
797
|
+
ENUM_TO_NAME(CompareClearLayer)
|
798
|
+
ENUM_TO_NAME(CompareOverlayLayer)
|
799
|
+
ENUM_TO_NAME(OptimizeLayer)
|
800
|
+
ENUM_TO_NAME(OptimizePlusLayer)
|
801
|
+
ENUM_TO_NAME(CoalesceLayer)
|
802
|
+
ENUM_TO_NAME(DisposeLayer)
|
803
|
+
#if defined(HAVE_ENUM_OPTIMIZETRANSLAYER)
|
804
|
+
ENUM_TO_NAME(OptimizeTransLayer)
|
805
|
+
#endif
|
806
|
+
#if defined(HAVE_ENUM_OPTIMIZEIMAGELAYER)
|
807
|
+
ENUM_TO_NAME(OptimizeImageLayer)
|
808
|
+
#endif
|
809
|
+
#if defined(HAVE_ENUM_REMOVEDUPSLAYER)
|
810
|
+
ENUM_TO_NAME(RemoveDupsLayer)
|
811
|
+
#endif
|
812
|
+
#if defined(HAVE_ENUM_REMOVEZEROLAYER)
|
813
|
+
ENUM_TO_NAME(RemoveZeroLayer)
|
814
|
+
#endif
|
815
|
+
#if defined(HAVE_ENUM_COMPOSITELAYER)
|
816
|
+
ENUM_TO_NAME(CompositeLayer)
|
817
|
+
#endif
|
818
|
+
#if defined(HAVE_ENUM_MERGELAYER)
|
819
|
+
ENUM_TO_NAME(MergeLayer)
|
820
|
+
#endif
|
821
|
+
#if defined(HAVE_ENUM_MOSAICLAYER)
|
822
|
+
ENUM_TO_NAME(MosaicLayer)
|
823
|
+
#endif
|
824
|
+
#if defined(HAVE_ENUM_FLATTENLAYER)
|
825
|
+
ENUM_TO_NAME(FlattenLayer)
|
826
|
+
#endif
|
827
|
+
#if defined(HAVE_ENUM_TRIMBOUNDSLAYER)
|
828
|
+
ENUM_TO_NAME(TrimBoundsLayer)
|
829
|
+
#endif
|
830
|
+
}
|
831
|
+
|
832
|
+
return "UndefinedLayer";
|
833
|
+
}
|
834
|
+
|
835
|
+
|
836
|
+
VALUE
|
837
|
+
LAYERMETHODTYPE_NEW(LAYERMETHODTYPE method)
|
838
|
+
{
|
839
|
+
const char *name = LAYERMETHODTYPE_NAME(method);
|
840
|
+
return rm_enum_new(CLASS_LAYERMETHODTYPE, ID2SYM(rb_intern(name)), INT2FIX(method));
|
841
|
+
}
|
842
|
+
|
843
|
+
|
844
|
+
/*
|
845
|
+
Static: OrientationType_name
|
846
|
+
Purpose: Return the name of a OrientationType enum as a string
|
847
|
+
*/
|
848
|
+
static const char *
|
849
|
+
OrientationType_name(OrientationType type)
|
850
|
+
{
|
851
|
+
switch(type)
|
852
|
+
{
|
853
|
+
ENUM_TO_NAME(UndefinedOrientation)
|
854
|
+
ENUM_TO_NAME(TopLeftOrientation)
|
855
|
+
ENUM_TO_NAME(TopRightOrientation)
|
856
|
+
ENUM_TO_NAME(BottomRightOrientation)
|
857
|
+
ENUM_TO_NAME(BottomLeftOrientation)
|
858
|
+
ENUM_TO_NAME(LeftTopOrientation)
|
859
|
+
ENUM_TO_NAME(RightTopOrientation)
|
860
|
+
ENUM_TO_NAME(RightBottomOrientation)
|
861
|
+
ENUM_TO_NAME(LeftBottomOrientation)
|
862
|
+
}
|
863
|
+
|
864
|
+
return "UndefinedOrientation";
|
865
|
+
}
|
866
|
+
|
867
|
+
|
868
|
+
/*
|
869
|
+
External: OrientationType_new
|
870
|
+
Purpose: Construct an OrientationType enum object for the specified value.
|
871
|
+
*/
|
872
|
+
VALUE
|
873
|
+
OrientationType_new(OrientationType type)
|
874
|
+
{
|
875
|
+
const char *name = OrientationType_name(type);
|
876
|
+
return rm_enum_new(Class_OrientationType, ID2SYM(rb_intern(name)), INT2FIX(type));
|
877
|
+
}
|
878
|
+
|
879
|
+
|
880
|
+
/*
|
881
|
+
Static: RenderingIntent_name
|
882
|
+
Purpose: Return the name of a RenderingIntent enum as a string
|
883
|
+
*/
|
884
|
+
static const char *
|
885
|
+
RenderingIntent_name(RenderingIntent intent)
|
886
|
+
{
|
887
|
+
switch(intent)
|
888
|
+
{
|
889
|
+
ENUM_TO_NAME(UndefinedIntent)
|
890
|
+
ENUM_TO_NAME(SaturationIntent)
|
891
|
+
ENUM_TO_NAME(PerceptualIntent)
|
892
|
+
ENUM_TO_NAME(AbsoluteIntent)
|
893
|
+
ENUM_TO_NAME(RelativeIntent)
|
894
|
+
}
|
895
|
+
|
896
|
+
return "UndefinedIntent";
|
897
|
+
}
|
898
|
+
|
899
|
+
|
900
|
+
/*
|
901
|
+
External: RenderingIntent_new
|
902
|
+
Purpose: Construct an RenderingIntent enum object for the specified value.
|
903
|
+
*/
|
904
|
+
VALUE
|
905
|
+
RenderingIntent_new(RenderingIntent intent)
|
906
|
+
{
|
907
|
+
const char *name = RenderingIntent_name(intent);
|
908
|
+
return rm_enum_new(Class_RenderingIntent, ID2SYM(rb_intern(name)), INT2FIX(intent));
|
909
|
+
}
|
910
|
+
|
911
|
+
|
912
|
+
/*
|
913
|
+
Static: ResolutionType_name
|
914
|
+
Purpose: Return the name of a ResolutionType enum as a string
|
915
|
+
*/
|
916
|
+
static const char *
|
917
|
+
ResolutionType_name(ResolutionType type)
|
918
|
+
{
|
919
|
+
switch(type)
|
920
|
+
{
|
921
|
+
ENUM_TO_NAME(UndefinedResolution)
|
922
|
+
ENUM_TO_NAME(PixelsPerInchResolution)
|
923
|
+
ENUM_TO_NAME(PixelsPerCentimeterResolution)
|
924
|
+
}
|
925
|
+
|
926
|
+
return "UndefinedResolution";
|
927
|
+
}
|
928
|
+
|
929
|
+
|
930
|
+
/*
|
931
|
+
External: ResolutionType_new
|
932
|
+
Purpose: Construct an ResolutionType enum object for the specified value.
|
933
|
+
*/
|
934
|
+
VALUE
|
935
|
+
ResolutionType_new(ResolutionType type)
|
936
|
+
{
|
937
|
+
const char *name = ResolutionType_name(type);
|
938
|
+
return rm_enum_new(Class_ResolutionType, ID2SYM(rb_intern(name)), INT2FIX(type));
|
939
|
+
}
|
940
|
+
|
941
|
+
|
942
|
+
/*
|
943
|
+
Extern: StorageType_name
|
944
|
+
Purpose: Return the string representation of a StorageType value
|
945
|
+
*/
|
946
|
+
const char *
|
947
|
+
StorageType_name(StorageType type)
|
948
|
+
{
|
949
|
+
switch (type)
|
950
|
+
{
|
951
|
+
ENUM_TO_NAME(UndefinedPixel)
|
952
|
+
ENUM_TO_NAME(CharPixel)
|
953
|
+
ENUM_TO_NAME(DoublePixel)
|
954
|
+
ENUM_TO_NAME(FloatPixel)
|
955
|
+
ENUM_TO_NAME(IntegerPixel)
|
956
|
+
ENUM_TO_NAME(LongPixel)
|
957
|
+
ENUM_TO_NAME(QuantumPixel)
|
958
|
+
ENUM_TO_NAME(ShortPixel)
|
959
|
+
}
|
960
|
+
|
961
|
+
return "UndefinedPixel";
|
962
|
+
}
|
963
|
+
|
964
|
+
|
965
|
+
/*
|
966
|
+
Static: VirtualPixelMethod_name
|
967
|
+
Purpose: Return the string representation of a VirtualPixelMethod value
|
968
|
+
*/
|
969
|
+
static const char *
|
970
|
+
VirtualPixelMethod_name(VirtualPixelMethod method)
|
971
|
+
{
|
972
|
+
switch (method)
|
973
|
+
{
|
974
|
+
ENUM_TO_NAME(UndefinedVirtualPixelMethod)
|
975
|
+
ENUM_TO_NAME(EdgeVirtualPixelMethod)
|
976
|
+
ENUM_TO_NAME(MirrorVirtualPixelMethod)
|
977
|
+
ENUM_TO_NAME(TileVirtualPixelMethod)
|
978
|
+
ENUM_TO_NAME(TransparentVirtualPixelMethod)
|
979
|
+
ENUM_TO_NAME(BackgroundVirtualPixelMethod)
|
980
|
+
ENUM_TO_NAME(DitherVirtualPixelMethod)
|
981
|
+
ENUM_TO_NAME(RandomVirtualPixelMethod)
|
982
|
+
ENUM_TO_NAME(ConstantVirtualPixelMethod)
|
983
|
+
#if defined(HAVE_ENUM_MASKVIRTUALPIXELMETHOD)
|
984
|
+
ENUM_TO_NAME(MaskVirtualPixelMethod)
|
985
|
+
#endif
|
986
|
+
#if defined(HAVE_ENUM_BLACKVIRTUALPIXELMETHOD)
|
987
|
+
ENUM_TO_NAME(BlackVirtualPixelMethod)
|
988
|
+
#endif
|
989
|
+
#if defined(HAVE_ENUM_GRAYVIRTUALPIXELMETHOD)
|
990
|
+
ENUM_TO_NAME(GrayVirtualPixelMethod)
|
991
|
+
#endif
|
992
|
+
#if defined(HAVE_ENUM_WHITEVIRTUALPIXELMETHOD)
|
993
|
+
ENUM_TO_NAME(WhiteVirtualPixelMethod)
|
994
|
+
#endif
|
995
|
+
#if defined(HAVE_ENUM_HORIZONTALTILEVIRTUALPIXELMETHOD)
|
996
|
+
ENUM_TO_NAME(HorizontalTileVirtualPixelMethod)
|
997
|
+
#endif
|
998
|
+
#if defined(HAVE_ENUM_VERTICALTILEVIRTUALPIXELMETHOD)
|
999
|
+
ENUM_TO_NAME(VerticalTileVirtualPixelMethod)
|
1000
|
+
#endif
|
1001
|
+
}
|
1002
|
+
|
1003
|
+
return "UndefinedVirtualPixelMethod";
|
1004
|
+
}
|
1005
|
+
|
1006
|
+
|
1007
|
+
/*
|
1008
|
+
Static: VirtualPixelMethod_new
|
1009
|
+
Purpose: Construct a VirtualPixelMethod enum for a specified VirtualPixelMethod value
|
1010
|
+
*/
|
1011
|
+
VALUE
|
1012
|
+
VirtualPixelMethod_new(VirtualPixelMethod style)
|
1013
|
+
{
|
1014
|
+
const char *name = VirtualPixelMethod_name(style);
|
1015
|
+
return rm_enum_new(Class_VirtualPixelMethod, ID2SYM(rb_intern(name)), INT2FIX(style));
|
1016
|
+
}
|