/*
Method: Info#density=<aString>
Purpose: Set the text rendering density, e.g. "72x72"
Raise: ArgumentError
*/
VALUE
Info_density_eq(VALUE self, VALUE density_arg)
{
Info *info;
volatile VALUE density;
char *dens;
Data_Get_Struct(self, Info, info);
if (NIL_P(density_arg))
{
magick_free(info->density);
info->density = NULL;
return self;
}
density = rm_to_s(density_arg);
dens = StringValuePtr(density);
if (!IsGeometry(dens))
{
rb_raise(rb_eArgError, "invalid density geometry: %s", dens);
}
magick_clone_string(&info->density, dens);
return self;
}
VALUE
Info_extract_eq(VALUE self, VALUE extract_arg)
{
Info *info;
char *extr;
volatile VALUE extract;
Data_Get_Struct(self, Info, info);
if (NIL_P(extract_arg))
{
magick_free(info->extract);
info->extract = NULL;
return self;
}
extract = rm_to_s(extract_arg);
extr = StringValuePtr(extract);
if (!IsGeometry(extr))
{
rb_raise(rb_eArgError, "invalid extract geometry: %s", extr);
}
magick_clone_string(&info->extract, extr);
return self;
}
/*
Method: Info#size=<aString>
Info#size=<aGeometry>
Purpose: Set the size (a Geometry string, i.e. WxH{+-}x{+-}y)
Raises: ArgumentError
*/
VALUE
Info_size_eq(VALUE self, VALUE size_arg)
{
Info *info;
volatile VALUE size;
char *sz;
Data_Get_Struct(self, Info, info);
if (NIL_P(size_arg))
{
magick_free(info->size);
info->size = NULL;
return self;
}
size = rm_to_s(size_arg);
sz = StringValuePtr(size);
if (!IsGeometry(sz))
{
rb_raise(rb_eArgError, "invalid size geometry: %s", sz);
}
magick_clone_string(&info->size, sz);
return self;
}
VALUE
Info_authenticate_eq(VALUE self, VALUE passwd)
{
Info *info;
char *passwd_p = NULL;
long passwd_l = 0;
Data_Get_Struct(self, Info, info);
if (!NIL_P(passwd))
{
passwd_p = rm_str2cstr(passwd, &passwd_l);
}
if (info->authenticate)
{
magick_free(info->authenticate);
info->authenticate = NULL;
}
if (passwd_l > 0)
{
magick_clone_string(&info->authenticate, passwd_p);
}
return self;
}
/*
Method: Image::Info#texture=texture_image
Purpose: Set name of texture to tile onto the image background
*/
VALUE
Info_texture_eq(VALUE self, VALUE texture)
{
Info *info;
Image *image;
char name[MaxTextExtent];
Data_Get_Struct(self, Info, info);
// Delete any existing texture file
if (info->texture)
{
rm_delete_temp_image(info->texture);
magick_free(info->texture);
info->texture = NULL;
}
// If argument is nil we're done
if (texture == Qnil)
{
return self;
}
// Create a temp copy of the texture and store its name in the texture field
image = rm_check_destroyed(texture);
rm_write_temp_image(image, name);
magick_clone_string(&info->texture, name);
return self;
}
VALUE
Info_sampling_factor_eq(VALUE self, VALUE sampling_factor)
{
Info *info;
char *sampling_factor_p = NULL;
long sampling_factor_len = 0;
Data_Get_Struct(self, Info, info);
if (!NIL_P(sampling_factor))
{
sampling_factor_p = rm_str2cstr(sampling_factor, &sampling_factor_len);
}
if (info->sampling_factor)
{
magick_free(info->sampling_factor);
info->sampling_factor = NULL;
}
if (sampling_factor_len > 0)
{
magick_clone_string(&info->sampling_factor, sampling_factor_p);
}
return self;
}
/*
Method: Draw#draw(i)
Purpose: Execute the stored drawing primitives on the current image
image
*/
VALUE
Draw_draw(VALUE self, VALUE image_arg)
{
Draw *draw;
Image *image;
image_arg = rm_cur_image(image_arg);
image = rm_check_frozen(image_arg);
Data_Get_Struct(self, Draw, draw);
if (draw->primitives == 0)
{
rb_raise(rb_eArgError, "nothing to draw");
}
// Point the DrawInfo structure at the current set of primitives.
magick_clone_string(&(draw->info->primitive), StringValuePtr(draw->primitives));
(void) DrawImage(image, draw->info);
rm_check_image_exception(image, RetainOnError);
magick_free(draw->info->primitive);
draw->info->primitive = NULL;
return self;
}
/*
Method: Info#page=<aString> or <aGeometry>
Purpose: store the Postscript page geometry
*/
VALUE
Info_page_eq(VALUE self, VALUE page_arg)
{
Info *info;
volatile VALUE geom_str;
char *geometry;
Data_Get_Struct(self, Info, info);
if (NIL_P(page_arg))
{
magick_free(info->page);
info->page = NULL;
return self;
}
geom_str = rm_to_s(page_arg);
geometry=GetPageGeometry(StringValuePtr(geom_str));
if (*geometry == '\0')
{
magick_free(info->page);
info->page = NULL;
return self;
}
magick_clone_string(&info->page, geometry);
(void) SetImageOption(info, "page", StringValuePtr(geom_str));
return self;
}
/*
Method: Draw#encoding=
Purpose: encoding attribute writer
*/
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, StringValuePtr(encoding));
return self;
}
/*
Method: Draw#density=
Purpose: density attribute writer
*/
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, StringValuePtr(density));
return self;
}
/*
Method: Draw#font_family=
Purpose: font_family attribute writer
*/
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, StringValuePtr(family));
return self;
}
/**
* Font attribute writer.
*
* Ruby usage:
* - @verbatim Draw#font= @endverbatim
*
* @param self this object
* @param font the font
* @return font
*/
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, StringValuePtr(font));
return font;
}
VALUE
Info_font_eq(VALUE self, VALUE font_arg)
{
Info *info;
char *font;
Data_Get_Struct(self, Info, info);
if (NIL_P(font_arg) || StringValuePtr(font_arg) == NULL)
{
magick_free(info->font);
info->font = NULL;
}
else
{
font = StringValuePtr(font_arg);
magick_clone_string(&info->font, font);
}
return self;
}
/*
Method: Info#server_name=<aString>
Purpose: Set the server name
*/
VALUE
Info_server_name_eq(VALUE self, VALUE server_arg)
{
Info *info;
char *server;
Data_Get_Struct(self, Info, info);
if (NIL_P(server_arg) || StringValuePtr(server_arg) == NULL)
{
magick_free(info->server_name);
info->server_name = NULL;
}
else
{
server = StringValuePtr(server_arg);
magick_clone_string(&info->server_name, server);
}
return self;
}
/*
Method: Info#view=
Purpose: Set FlashPix viewing parameters
*/
VALUE
Info_view_eq(VALUE self, VALUE view_arg)
{
Info *info;
char *view;
Data_Get_Struct(self, Info, info);
if (NIL_P(view_arg) || StringValuePtr(view_arg) == NULL)
{
magick_free(info->view);
info->view = NULL;
}
else
{
view = StringValuePtr(view_arg);
magick_clone_string(&info->view, view);
}
return self;
}
/*
Method: Draw#annotate(img, w, h, x, y, text) <{optional parms}>
Purpose: annotates an image with text
Returns: self
Notes: Additional Draw attribute methods may be called in the
optional block, which is executed in the context of an
Draw object.
*/
VALUE Draw_annotate(
VALUE self,
VALUE image_arg,
VALUE width_arg,
VALUE height_arg,
VALUE x_arg,
VALUE y_arg,
VALUE text)
{
Draw *draw;
Image *image;
unsigned long width, height;
long x, y;
AffineMatrix keep;
char geometry_str[50];
// Save the affine matrix in case it is modified by
// Draw#rotation=
Data_Get_Struct(self, Draw, draw);
keep = draw->info->affine;
image_arg = rm_cur_image(image_arg);
image = rm_check_frozen(image_arg);
// If we have an optional parm block, run it in self's context,
// allowing the app a chance to modify the object's attributes
if (rb_block_given_p())
{
(void)rb_obj_instance_eval(0, NULL, self);
}
// Translate & store in Draw structure
#if defined(HAVE_INTERPRETIMAGEPROPERTIES)
draw->info->text = InterpretImageProperties(NULL, image, StringValuePtr(text));
#else
draw->info->text = InterpretImageAttributes(NULL, image, StringValuePtr(text));
#endif
if (!draw->info->text)
{
rb_raise(rb_eArgError, "no text");
}
// Create geometry string, copy to Draw structure, overriding
// any previously existing value.
width = NUM2ULONG(width_arg);
height = NUM2ULONG(height_arg);
x = NUM2LONG(x_arg);
y = NUM2LONG(y_arg);
if (width == 0 && height == 0)
{
sprintf(geometry_str, "%+ld%+ld", x, y);
}
// WxH is non-zero
else
{
sprintf(geometry_str, "%lux%lu%+ld%+ld", width, height, x, y);
}
magick_clone_string(&draw->info->geometry, geometry_str);
(void) AnnotateImage(image, draw->info);
magick_free(draw->info->text);
draw->info->text = NULL;
draw->info->affine = keep;
rm_check_image_exception(image, RetainOnError);
return self;
}
