IoObject *IoFont_drawString(IoFont *self, IoObject *locals, IoMessage *m)
{
/*doc Font drawString(aString, optionalStartIndex, optionalEndIndex)
Draws aString using the optional start and end indexes, if supplied. Returns self.
<p>
Note; Fonts are drawn as RGBA pixel maps. These blending options are recommended:
<pre>
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
</pre>
*/
IoSymbol *textString = IoMessage_locals_seqArgAt_(m, locals, 0);
int startIndex = 0;
int endIndex;
if (IoMessage_argCount(m) > 1)
{
startIndex = IoNumber_asInt(IoMessage_locals_numberArgAt_(m, locals, 1));
if (startIndex > (int)IoSeq_rawSize(textString)) startIndex = (int)IoSeq_rawSize(textString);
}
if (IoMessage_argCount(m) > 2)
{
endIndex = IoNumber_asInt(IoMessage_locals_numberArgAt_(m, locals, 2));
}
else
{
endIndex = IoSeq_rawSize(textString);
}
GLFont_drawString(DATA(self)->font, CSTRING(textString) , startIndex, endIndex);
IoFont_checkError(self, locals, m);
return self;
}
Uint64Array *IoTagDB_tagArrayForTagNames_(IoTagDB *self, IoMessage *m, IoList *tagNames)
{
TagDB *tdb = DATA(self);
Uint64Array *tags = Uint64Array_new();
int i;
for (i = 0; i < IoList_rawSize(tagNames); i ++)
{
IoSeq *tagName = IoList_rawAt_(tagNames, i);
symbolid_t keyid;
IOASSERT(ISSEQ(tagName), "tag names must be Sequences");
keyid = TagDB_idForSymbol_size_(tdb, CSTRING(tagName), IoSeq_rawSize(tagName));
Uint64Array_append_(tags, keyid);
/*
{
Datum *keyDatum = TagDB_symbolForId_(tdb, keyid);
printf("%s -> %i && ", CSTRING(tagName), (int)keyid);
printf("%i -> %s\n", (int)keyid, (char *)(keyDatum->data));
Datum_free(keyDatum);
}
*/
}
return tags;
}
IoObject *IoFont_lengthOfString(IoFont *self, IoObject *locals, IoMessage *m)
{
/*doc Font widthOfString(aString)
Returns a Number with the width that aString would render
to with the receiver's current settings.
*/
IoSymbol *text = IoMessage_locals_seqArgAt_(m, locals, 0);
int startIndex = 0;
int max = IoSeq_rawSize(text);
int endIndex = max;
if (IoMessage_argCount(m) == 2)
{
startIndex = IoNumber_asInt(IoMessage_locals_numberArgAt_(m, locals, 1));
if (startIndex > max) startIndex = max;
}
if (IoMessage_argCount(m) > 2)
{
endIndex = IoNumber_asInt(IoMessage_locals_numberArgAt_(m, locals, 2));
if (startIndex > max) endIndex = max;
}
return IONUMBER( GLFont_lengthOfString( DATA(self)->font, CSTRING(text), startIndex, endIndex) );
}
IoObject *IoTagDB_atKeyPutTags(IoTagDB *self, IoObject *locals, IoMessage *m)
{
/*doc TagDB atKeyPutTags(key, tagNameList)
Sets the tags for key to those in tagNameList. Returns self.
*/
TagDB *tdb = DATA(self);
IoSeq *key = IoMessage_locals_seqArgAt_(m, locals, 0);
IoList *tagNames = IoMessage_locals_listArgAt_(m, locals, 1);
symbolid_t keyid = TagDB_idForSymbol_size_(tdb, CSTRING(key), IoSeq_rawSize(key));
// debugging check
/*
Datum *keyDatum = TagDB_symbolForId_(tdb, keyid);
printf("%s -> %i\n", CSTRING(key), (int)keyid);
printf("%i -> %s\n", (int)keyid, (char *)(keyDatum->data));
assert(strcmp((char *)(keyDatum->data), (char *)CSTRING(key)) == 0);
Datum_free(keyDatum);
*/
{
Uint64Array *tags = IoTagDB_tagArrayForTagNames_(self, m, tagNames);
TagDB_begin(tdb);
TagDB_atKey_putTags_(tdb, keyid, tags);
TagDB_commit(tdb);
Uint64Array_free(tags);
}
return self;
}
IoObject *IoTagDB_idForSymbol(IoTagDB *self, IoObject *locals, IoMessage *m)
{
/*doc TagDB idForSymbol(aSeq)
Returns the TagDB id Number for the symbol specified by aSeq.
*/
IoSeq *key = IoMessage_locals_seqArgAt_(m, locals, 0);
return IONUMBER(TagDB_idForSymbol_size_(DATA(self), CSTRING(key), IoSeq_rawSize(key)));
}
IoObject *IoFont_stringIndexAtWidth(IoFont *self, IoObject *locals, IoMessage *m)
{
/*doc Font stringIndexAtWidth(aString, startIndex, width)
Returns the max index of the character in String (starting at startIndex)
that fits within width.
*/
IoSymbol *text = IoMessage_locals_seqArgAt_(m, locals, 0);
int startIndex;
int width;
//IOASSERT(IoMessage_argCount(m) == 2, "requires 3 arguments");
startIndex = IoNumber_asInt(IoMessage_locals_numberArgAt_(m, locals, 1));
if (startIndex > (int)IoSeq_rawSize(text)) startIndex = (int)IoSeq_rawSize(text);
width = IoNumber_asInt(IoMessage_locals_numberArgAt_(m, locals, 2));
return IONUMBER(GLFont_stringIndexAtWidth(DATA(self)->font, CSTRING(text), startIndex, width));
}
IoObject *IoRegexMatches_setString(IoRegexMatches *self, IoObject *locals, IoMessage *m)
{
/*doc RegexMatches setString(aString)
Sets the string to find matches in. Returns self.
*/
DATA(self)->string = IOREF(IoMessage_locals_symbolArgAt_(m, locals, 0));
DATA(self)->endPosition = IoSeq_rawSize(DATA(self)->string);
IoRegexMatches_rawsetPosition_(self, 0);
return self;
}
IO_METHOD(IoSeq, between)
{
/*doc Sequence between(aSequence, anotherSequence)
Returns a new Sequence containing the bytes between the
occurance of aSequence and anotherSequence in the receiver.
*/
long start = 0;
long end = 0;
IoSeq *fromSeq, *toSeq;
fromSeq = (IoSeq *)IoMessage_locals_valueArgAt_(m, locals, 0);
if (ISSEQ(fromSeq))
{
start = UArray_find_from_(DATA(self), DATA(fromSeq), 0) + IoSeq_rawSize(fromSeq);
if (start == -1)
{
start = 0;
}
}
else if (ISNIL(fromSeq))
{
start = 0;
}
else
{
IoState_error_(IOSTATE, m, "Nil or Sequence argument required for arg 0, not a %s",
IoObject_name((IoObject *)fromSeq));
}
toSeq = (IoSeq *)IoMessage_locals_valueArgAt_(m, locals, 1);
if (ISSEQ(toSeq))
{
end = UArray_find_from_(DATA(self), DATA(toSeq), start);
if (end == -1) start = UArray_size(DATA(self));
}
else if (ISNIL(toSeq))
{
end = UArray_size(DATA(self));
}
else
{
IoState_error_(IOSTATE, m, "Nil or Sequence argument required for arg 1, not a %s",
IoObject_name((IoObject *)toSeq));
}
{
UArray *ba = UArray_slice(DATA(self), start, end);
IoSeq *result = IoSeq_newWithUArray_copy_(IOSTATE, ba, 0);
return result;
}
}
IoObject *IoSHA1_appendSeq(IoSHA1 *self, IoObject *locals, IoMessage *m)
{
/*doc SHA1 appendSeq(aSequence)
Appends aSequence to the hash calculation. Returns self.
*/
IoSeq *buffer = IoMessage_locals_seqArgAt_(m, locals, 0);
IOASSERT(DATA(self)->isDone == 0, "cannot append to an already calculated sha1");
SHA1Update(&(DATA(self)->context),
(unsigned char const *)IoSeq_rawBytes(buffer),
IoSeq_rawSize(buffer));
return self;
}
IoObject *IoTagDB_removeKey(IoTagDB *self, IoObject *locals, IoMessage *m)
{
/*doc TagDB removeKey(aKey)
Removes the specified key if it is present. Returns self.
*/
TagDB *tdb = DATA(self);
IoSeq *key = IoMessage_locals_seqArgAt_(m, locals, 0);
symbolid_t keyid = TagDB_idForSymbol_size_(tdb, CSTRING(key), IoSeq_rawSize(key));
TagDB_begin(tdb);
TagDB_removeKey_(tdb, keyid);
TagDB_commit(tdb);
return self;
}
IOIMAGE_API IoObject *IoImage_filterWeightedMedian(IoImage *self, IoObject *locals, IoMessage *m)
{
/*doc Image filterWeightedMedian(filterSizeX, filterSizeY, filter)
Returns new image as a result of applying filter.
*/
int filterSizeX = IoMessage_locals_intArgAt_(m, locals, 0);
int filterSizeY = IoMessage_locals_intArgAt_(m, locals, 1);
IoObject *ioFilter = IoMessage_locals_seqArgAt_(m, locals, 2);
if(IoSeq_rawSize(ioFilter) < filterSizeX * filterSizeY)
{
IoState_error_(IOSTATE, m, "filter should be a Sequence with size >= filterSizeX * filterSizeY");
return self;
}
UArray* filter = IoSeq_rawUArray(ioFilter);
return IoImage_newWithImage_(IOSTATE, Image_applyWeightedMedianFilter(DATA(self)->image, filterSizeX, filterSizeY, filter));
}
IoObject *IoAudioDevice_asyncWrite(IoAudioDevice *self, IoObject *locals, IoMessage *m)
{
/*doc AudioDevice asyncWrite(aBuffer)
Writes aBuffer to the audio output buffer and returns immediately.
*/
IoSeq *buf = IoMessage_locals_seqArgAt_(m, locals, 0);
if (IoSeq_rawSize(buf) == 0)
{
return self;
}
AudioDevice_checkForError(DATA(self)->audioDevice);
AudioDevice_write_(DATA(self)->audioDevice, IoSeq_rawUArray(buf));
return self;
}
IoObject *IoSeq_drawAsLine(IoSeq *self, IoObject *locals, IoMessage *m)
{
IoSeq_assertIsVector(self, locals, m);
{
size_t i, size = IoSeq_rawSize(self);
float *values = (float *)IoSeq_rawBytes(self);
glBegin(GL_LINE_STRIP);
for (i = 0; i < size; i ++)
{
glVertex2f((float)i, values[i]);
}
glEnd();
}
return self;
}
IoObject *IoTagDB_tagsAtKey(IoTagDB *self, IoObject *locals, IoMessage *m)
{
/*doc TagDB tagsAtKey(key)
Returns the tags for the specified key.
*/
TagDB *tdb = DATA(self);
IoSeq *key = IoMessage_locals_seqArgAt_(m, locals, 0);
symbolid_t keyid = TagDB_idForSymbol_size_(tdb, CSTRING(key), IoSeq_rawSize(key));
IoList *tagNames = IoList_new(IOSTATE);
Uint64Array *tags = TagDB_tagsAtKey_(tdb, keyid);
int i;
//printf("IoTagDB_tagsAt self = %p\n", (void *)self);
if (!tags)
{
//printf("IoTagDB_tagsAtKey: no tags found for key\n");
return IONIL(self);
}
for (i = 0; i < Uint64Array_size(tags); i ++)
{
uint64_t tagid = Uint64Array_at_(tags, i);
Datum *name = TagDB_symbolForId_(tdb, tagid);
//printf("tagid %i = %i\n", i, (int)tagid);
//printf("name '%s'\n", (char *)name->data);
if (!name)
{
printf("IoTagDB_tagsAtKey: no datum returned for TagDB_symbolForId_\n");
}
else
{
IoList_rawAppend_(tagNames, IoSeq_newWithData_length_(IOSTATE, name->data, name->size));
Datum_free(name);
}
}
//Uint64Array_free(tags);
return tagNames;
}
void Level_finish(Level *self)
{
if (self->message)
{
IoMessage_rawSetNext_(self->message, NULL);
// Remove extra () we added in for operators, but do not need any more
if ( IoMessage_argCount(self->message) == 1 )
{
IoMessage *arg = IoMessage_rawArgAt_(self->message, 0);
if ( IoSeq_rawSize(IoMessage_name(arg)) == 0 && IoMessage_argCount(arg) == 1 && IoMessage_rawNext(arg) == NULL )
{
List_copy_(IoMessage_rawArgList(self->message), IoMessage_rawArgList(arg));
List_removeAll(IoMessage_rawArgList(arg));
}
}
}
self->type = UNUSED;
}
IoObject *IoSeq_drawFilled(IoSeq *self, IoObject *locals, IoMessage *m)
{
IoSeq_assertIsVector(self, locals, m);
{
size_t i, size = IoSeq_rawSize(self);
float *values = (float *)IoSeq_rawBytes(self);
glBegin(GL_TRIANGLE_STRIP);
for (i = 0; i < size; i ++)
{
float x = i;
float y = values[i];
glVertex2f(x, 0);
glVertex2f(x, y);
}
glEnd();
}
return self;
}
IoObject *IoRegexMatches_setEndPosition(IoRegexMatches *self, IoObject *locals, IoMessage *m)
{
/*doc RegexMatches setEndPosition(anIndex)
Sets the index in the string where the receiver should stop searching. It will be as
if the string ends at that index. If <em>index</em> is nil, the end position will be set
to the end of string.
Returns self.
<pre>
Io> "funkadelic" matchesOfRegex("\\w+") setEndPosition(4) next string
==> funk
Io> "funkadelic" matchesOfRegex("\\w+") setEndPosition(nil) next string
==> funkadelic
</pre>
*/
IoObject *arg = IoMessage_locals_valueArgAt_(m, locals, 0);
int stringLength = IoSeq_rawSize(DATA(self)->string);
int endPos = stringLength;
if (ISNIL(arg)) {
DATA(self)->endPosition = endPos;
return self;
}
if (!ISNUMBER(arg))
IoState_error_(IOSTATE, m, "The argument to setEndPosition must be either a Number or nil");
endPos = IoNumber_asInt(arg);
if (endPos < 0)
endPos = 0;
else if (endPos > stringLength)
endPos = stringLength;
DATA(self)->endPosition = endPos;
return self;
}
IO_METHOD(IoSeq, between)
{
/*doc Sequence betweenSeq(aSequence, anotherSequence)
Returns a new Sequence containing the bytes between the
occurrence of aSequence and anotherSequence in the receiver.
If aSequence is empty, this method is equivalent to beforeSeq(anotherSequence).
If anotherSequence is nil, this method is equivalent to afterSeq(aSequence).
nil is returned if no match is found.
*/
long start = 0;
long end = 0;
IoSeq *fromSeq, *toSeq;
fromSeq = (IoSeq *)IoMessage_locals_valueArgAt_(m, locals, 0);
if (ISSEQ(fromSeq))
{
if (IoSeq_rawSize(fromSeq) == 0)
{
start = 0;
}
else
{
start = UArray_find_from_(DATA(self), DATA(fromSeq), 0);
if (start == -1)
{
//start = 0;
return IONIL(self);
}
start += IoSeq_rawSize(fromSeq);
}
}
else if (ISNIL(fromSeq))
{
start = 0;
}
else
{
IoState_error_(IOSTATE, m, "Nil or Sequence argument required for arg 0, not a %s",
IoObject_name((IoObject *)fromSeq));
}
toSeq = (IoSeq *)IoMessage_locals_valueArgAt_(m, locals, 1);
if (ISSEQ(toSeq))
{
end = UArray_find_from_(DATA(self), DATA(toSeq), start);
//if (end == -1) start = UArray_size(DATA(self));
if (end == -1) return IONIL(self);
}
else if (ISNIL(toSeq))
{
end = UArray_size(DATA(self));
}
else
{
IoState_error_(IOSTATE, m, "Nil or Sequence argument required for arg 1, not a %s",
IoObject_name((IoObject *)toSeq));
}
{
UArray *ba = UArray_slice(DATA(self), start, end);
IoSeq *result = IoSeq_newWithUArray_copy_(IOSTATE, ba, 0);
return result;
}
}
