switch locale to make sure we get proper snprintf output
Creates an Eet::File object for file.
file is opened with the specified mode (defaulting to "r"). Possible values for mode are "r" for read-only access, "w" for write-only access and "r+" for read/write access.
/*
* call-seq:
* Eet::File.new(file [, mode] ) -> ef or nil
*
* Creates an Eet::File object for _file_.
*
* _file_ is opened with the specified mode (defaulting to "r").
* Possible values for _mode_ are "r" for read-only access,
* "w" for write-only access and "r+" for read/write access.
*/
static VALUE
c_init (int argc, VALUE *argv, VALUE self)
{
VALUE file = Qnil, mode = Qnil;
Eet_File **ef = NULL;
Eet_File_Mode m = EET_FILE_MODE_READ;
const char *tmp, *cfile;
Data_Get_Struct (self, Eet_File *, ef);
rb_scan_args (argc, argv, "11", &file, &mode);
cfile = StringValuePtr (file);
if (!NIL_P (mode)) {
tmp = StringValuePtr (mode);
if (!strcmp (tmp, "r+"))
m = EET_FILE_MODE_READ_WRITE;
else if (!strcmp (tmp, "w"))
m = EET_FILE_MODE_WRITE;
else if (strcmp (tmp, "r"))
rb_raise (rb_eArgError, "illegal access mode %s", tmp);
}
eet_init ();
*ef = eet_open (cfile, m);
if (!*ef) {
switch (m) {
case EET_FILE_MODE_READ_WRITE:
case EET_FILE_MODE_WRITE:
tmp = "Permission denied - %s";
break;
default:
tmp = "File not found - %s";
break;
}
rb_raise (rb_eRuntimeError, tmp, cfile);
}
return self;
}
If a block isn‘t specified, Eet::File.open is a synonym for Eet::File.new. If a block is given, it will be invoked with the Eet::File object as a parameter, and the file will be automatically closed when the block terminates. The call always returns nil in this case.
/*
* call-seq:
* Eet::File.open(file [, mode] ) -> ef or nil
* Eet::File.open(file [, mode] ) { |ef| block } -> nil
*
* If a block isn't specified, Eet::File.open is a synonym for
* Eet::File.new.
* If a block is given, it will be invoked with the
* Eet::File object as a parameter, and the file will be
* automatically closed when the block terminates. The call always
* returns +nil+ in this case.
*/
static VALUE
c_open (int argc, VALUE *argv, VALUE klass)
{
VALUE obj = rb_class_new_instance (argc, argv, klass);
if (rb_block_given_p ())
return rb_ensure (rb_yield, obj, c_close, obj);
else
return obj;
}
Returns an Array with the keys of entries in ef that match the shell glob glob. If the keys cannot be retrieved, an IOError is raised.
/*
* call-seq:
* ef[glob] -> array
*
* Returns an Array with the keys of entries in _ef_ that match the
* shell glob _glob_.
* If the keys cannot be retrieved, an +IOError+ is raised.
*/
static VALUE
c_glob (VALUE self, VALUE glob)
{
Eet_File **ef = NULL;
Data_Get_Struct (self, Eet_File *, ef);
CHECK_CLOSED (ef);
CHECK_READABLE (ef);
return get_keys (*ef, StringValuePtr (glob));
}
Deletes the entry from ef that is stored as key. If the entry cannot be deleted, an IOError is raised, otherwise ef is returned.
/*
* call-seq:
* ef.delete(key) -> ef
*
* Deletes the entry from _ef_ that is stored as _key_.
* If the entry cannot be deleted, an +IOError+ is raised,
* otherwise _ef_ is returned.
*/
static VALUE
c_delete (VALUE self, VALUE key)
{
Eet_File **ef = NULL;
char *ckey;
Data_Get_Struct (self, Eet_File *, ef);
CHECK_CLOSED (ef);
ckey = StringValuePtr (key);
CHECK_KEY (key);
if (!eet_delete (*ef, ckey))
rb_raise (rb_eIOError, "cannot delete entry - %s", ckey);
return self;
}
Returns an Array with the keys of the entries in ef. If the keys cannot be retrieved, an IOError is raised.
/*
* call-seq:
* ef.entries -> array
*
* Returns an Array with the keys of the entries in _ef_.
* If the keys cannot be retrieved, an +IOError+ is raised.
*/
static VALUE
c_entries (VALUE self)
{
Eet_File **ef = NULL;
Data_Get_Struct (self, Eet_File *, ef);
CHECK_CLOSED (ef);
CHECK_READABLE (ef);
return get_keys (*ef, "*");
}
Reads an entry from ef that is stored as key. If the data cannot be read, an IOError is raised, otherwise a String is returned that contains the data.
/*
* call-seq:
* ef.read(key) -> string
*
* Reads an entry from _ef_ that is stored as _key_.
* If the data cannot be read, an +IOError+ is raised,
* otherwise a String is returned that contains the data.
*/
static VALUE
c_read (VALUE self, VALUE key)
{
VALUE ret;
Eet_File **ef = NULL;
void *data;
char *ckey;
int size = 0;
Data_Get_Struct (self, Eet_File *, ef);
CHECK_CLOSED (ef);
ckey = StringValuePtr (key);
CHECK_KEY (key);
data = eet_read (*ef, ckey, &size);
if (!data)
rb_raise (rb_eIOError, "cannot read entry - %s", ckey);
ret = rb_str_new (data, size);
free (data);
return ret;
}
Reads an image entry from ef that is stored as key. If the data cannot be read, an IOError is raised, otherwise an Array is returned that contains the image data, the image width, the image height, a boolean that indicates whether the image has an alpha channel or not and a hash that contains the compression options that were used to store the image (see Eet::File#write_image).
/*
* call-seq:
* ef.read_image(key) -> array
*
* Reads an image entry from _ef_ that is stored as _key_.
* If the data cannot be read, an +IOError+ is raised,
* otherwise an Array is returned that contains the image data,
* the image width, the image height, a boolean that indicates
* whether the image has an alpha channel or not and a hash
* that contains the compression options that were used to store
* the image (see Eet::File#write_image).
*/
static VALUE
c_read_image (VALUE self, VALUE key)
{
VALUE ret, comp;
Eet_File **ef = NULL;
void *data;
char *ckey;
unsigned int w = 0, h = 0;
int has_alpha = 0, level = 0, quality = 0, lossy = 0;
Data_Get_Struct (self, Eet_File *, ef);
CHECK_CLOSED (ef);
ckey = StringValuePtr (key);
CHECK_KEY (key);
data = eet_data_image_read (*ef, ckey, &w, &h,
&has_alpha, &level, &quality,
&lossy);
if (!data)
rb_raise (rb_eIOError, "cannot read entry - %s", ckey);
comp = rb_hash_new ();
rb_hash_aset (comp, sym_lossy, INT2FIX (lossy));
rb_hash_aset (comp, sym_level, INT2FIX (level));
rb_hash_aset (comp, sym_quality, INT2FIX (quality));
ret = rb_ary_new3 (5, rb_str_new (data, w * h * 4),
INT2FIX (w), INT2FIX (h),
has_alpha ? Qtrue : Qfalse, comp);
free (data);
return ret;
}
Stores data in ef as key. If compress is true (which is the default), the data will be compressed. If the data cannot be written, an IOError is raised, otherwise a the number of bytes written is returned.
/*
* call-seq:
* ef.write(key, data [, compress] ) -> integer
*
* Stores _data_ in _ef_ as _key_.
* If _compress_ is true (which is the default), the data will be
* compressed.
* If the data cannot be written, an +IOError+ is raised,
* otherwise a the number of bytes written is returned.
*/
static VALUE
c_write (int argc, VALUE *argv, VALUE self)
{
VALUE key = Qnil, buf = Qnil, comp = Qnil;
Eet_File **ef = NULL;
char *ckey, *cbuf;
int n;
Data_Get_Struct (self, Eet_File *, ef);
CHECK_CLOSED (ef);
rb_scan_args (argc, argv, "21", &key, &buf, &comp);
if (NIL_P (comp))
comp = Qtrue;
ckey = StringValuePtr (key);
CHECK_KEY (key);
cbuf = StringValuePtr (buf);
n = eet_write (*ef, ckey,
cbuf, RSTRING (buf)->len,
comp == Qtrue);
if (!n)
rb_raise (rb_eIOError, "couldn't write to file");
else
return INT2FIX (n);
}
Stores image_data with width w and height h in ef as key. Pass true for alpha if the image contains an alpha channel. You can control how the image is compressed by passing comp, which is a hash whose :lossy entry is true if the image should be compressed lossily. If :lossy is true, the :quality entry (0-100, default 100) sets the compression quality. If :lossy is false, the :level entry (0-9, default 9) sets the compression level. If comp isn‘t passed, then the image is stored losslessly. If the data cannot be written, an IOError is raised, otherwise a the number of bytes written is returned.
/*
* call-seq:
* ef.write_image(key, image_data, w, h [, alpha] [, comp] ) -> integer
*
* Stores _image_data_ with width _w_ and height _h_ in _ef_ as _key_.
* Pass true for _alpha_ if the image contains an alpha channel.
* You can control how the image is compressed by passing _comp_, which
* is a hash whose :lossy entry is true if the image should be
* compressed lossily. If :lossy is true, the :quality entry
* (0-100, default 100) sets the compression quality.
* If :lossy is false, the :level entry (0-9, default 9) sets the
* compression level. If _comp_ isn't passed, then the
* image is stored losslessly.
* If the data cannot be written, an +IOError+ is raised,
* otherwise a the number of bytes written is returned.
*/
static VALUE
c_write_image (int argc, VALUE *argv, VALUE self)
{
VALUE key = Qnil, buf = Qnil, w = Qnil, h = Qnil, has_alpha = Qnil;
VALUE comp = Qnil, tmp;
Eet_File **ef = NULL;
char *ckey, *cbuf;
int n, lossy = 0, level = 9, quality = 100;
Data_Get_Struct (self, Eet_File *, ef);
CHECK_CLOSED (ef);
rb_scan_args (argc, argv, "42", &key, &buf, &w, &h, &has_alpha,
&comp);
if (NIL_P (has_alpha))
has_alpha = Qfalse;
ckey = StringValuePtr (key);
CHECK_KEY (key);
cbuf = StringValuePtr (buf);
Check_Type (w, T_FIXNUM);
Check_Type (h, T_FIXNUM);
if (!NIL_P (comp)) {
Check_Type (comp, T_HASH);
tmp = rb_hash_aref (comp, sym_lossy);
if (!NIL_P (tmp))
lossy = FIX2INT (tmp);
tmp = rb_hash_aref (comp, sym_level);
if (!NIL_P (tmp))
level = FIX2INT (tmp);
tmp = rb_hash_aref (comp, sym_quality);
if (!NIL_P (tmp))
quality = FIX2INT (tmp);
}
if (!RSTRING (buf)->len)
return INT2FIX (0);
n = eet_data_image_write (*ef, ckey, cbuf,
FIX2INT (w), FIX2INT (h),
has_alpha == Qtrue,
level, quality, lossy);
if (!n)
rb_raise (rb_eIOError, "couldn't write to file");
else
return INT2FIX (n);
}