// _proto creates the first-ever instance of the prototype IoObject *IoCInvokeStructureInstance_proto(void *state) { // First we allocate a new IoObject IoCInvokeStructureInstance *self = IoObject_new(state); // Then tag it IoObject_tag_(self, IoCInvokeStructureInstance_newTag(state)); IoObject_setDataPointer_(self, calloc(1, sizeof(IoCInvokeStructureInstanceData))); // then register this proto generator IoState_registerProtoWithFunc_(state, self, IoCInvokeStructureInstance_proto); // and finally, define the table of methods this proto supports // we just have one method here, returnSelf, then terminate the array // with NULLs { IoMethodTable methodTable[] = { {"setValue", IoCInvokeStructureInstance_setValue}, {"setLibrary", IoCInvokeStructureInstance_setLibrary}, {"getValue", IoCInvokeStructureInstance_getValue}, {NULL, NULL}, }; IoObject_addMethodTable_(self, methodTable); } return self; }
IoMap *IoMap_proto(void *state) { IoMethodTable methodTable[] = { {"empty", IoMap_empty}, {"at", IoMap_at}, {"atPut", IoMap_atPut}, {"atIfAbsentPut", IoMap_atIfAbsentPut}, {"size", IoMap_size}, {"keys", IoMap_keys}, {"values", IoMap_values}, {"foreach", IoMap_foreach}, {"hasKey", IoMap_hasKey}, {"hasValue", IoMap_hasValue}, {"removeAt", IoMap_removeAt}, {NULL, NULL}, }; IoObject *self = IoObject_new(state); IoObject_tag_(self, IoMap_newTag(state)); IoObject_setDataPointer_(self, PHash_new()); IoState_registerProtoWithFunc_((IoState *)state, self, IoMap_proto); IoObject_addMethodTable_(self, methodTable); return self; }
IoYajlGen *IoYajlGen_proto(void *state) { IoYajlGen *self = IoObject_new(state); IoObject_tag_(self, IoYajlGen_newTag(state)); yajl_gen_config config = { 0, "" }; IoObject_setDataPointer_(self, yajl_gen_alloc(&config, NULL)); IoState_registerProtoWithFunc_(state, self, IoYajlGen_proto); { IoMethodTable methodTable[] = { {"pushNull", IoYajlGen_pushNull}, {"pushString", IoYajlGen_pushString}, {"pushInteger", IoYajlGen_pushInteger}, {"pushDouble", IoYajlGen_pushDouble}, {"pushNumberString", IoYajlGen_pushNumberString}, {"pushBool", IoYajlGen_pushBool}, {"openMap", IoYajlGen_openMap}, {"closeMap", IoYajlGen_closeMap}, {"openArray", IoYajlGen_openArray}, {"closeArray", IoYajlGen_closeArray}, {"generate", IoYajlGen_generate}, {NULL, NULL}, }; IoObject_addMethodTable_(self, methodTable); } return self; }
IoODEJointGroup *IoODEJointGroup_proto(void *state) { IoObject *self = IoObject_new(state); IoObject_tag_(self, IoODEJointGroup_newTag(state)); IoObject_setDataPointer_(self, calloc(1, sizeof(IoODEJointGroupData))); JOINTGROUPID = 0; WORLD = 0L; DATA(self)->joints = 0L; IoState_registerProtoWithFunc_(state, self, IoODEJointGroup_proto); { IoMethodTable methodTable[] = { {"jointGroupId", IoODEJointGroup_jointGroupId}, {"world", IoODEJointGroup_world}, {"empty", IoODEJointGroup_empty}, {"joints", IoODEJointGroup_joints}, {"createContact", IoODEJointGroup_createContact}, {NULL, NULL}, }; IoObject_addMethodTable_(self, methodTable); } return self; }
IoCFFIPointer *IoCFFIPointer_proto(void *state) { IoObject *self = IoCFFIDataType_new(state); IoObject_tag_(self, IoCFFIPointer_newTag(state)); IoObject_setSlot_to_(self, IOSYMBOL("pointers"), IoMap_new(state)); IoObject_setDataPointer_(self, calloc(1, sizeof(IoCFFIPointerData))); memset(DATA(self), 0, sizeof(IoCFFIPointerData)); DATA(self)->valuePointer = &(DATA(self)->ptr); IoState_registerProtoWithFunc_(state, self, IoCFFIPointer_proto); { IoMethodTable methodTable[] = { {"address", IoCFFIPointer_address}, {"asBuffer", IoCFFIPointer_asBuffer}, {"at", IoCFFIPointer_at}, {"atPut", IoCFFIPointer_atPut}, {"castTo", IoCFFIPointer_castTo}, {"value", IoCFFIPointer_value}, {"setValue", IoCFFIPointer_setValue}, {"toType", IoCFFIPointer_toType}, {NULL, NULL}, }; IoObject_addMethodTable_(self, methodTable); } return self; }
IoEvDNSRequest *IoEvDNSRequest_proto(void *state) { IoObject *self = IoObject_new(state); IoObject_tag_(self, IoEvDNSRequest_newTag(state)); IoObject_setDataPointer_(self, 0x0); IoState_registerProtoWithFunc_((IoState *)state, self, IoEvDNSRequest_proto); { IoMethodTable methodTable[] = { {"resolveIPv4", IoEvDNSRequest_resolveIPv4}, /* {"resolveIPv6", IoEvDNSRequest_resolveIPv6}, {"resolveReverseIPv4", IoEvDNSRequest_resolveReverseIPv4}, {"resolveReverseIPv6", IoEvDNSRequest_resolveReverseIPv6}, */ {NULL, NULL}, }; IoObject_addMethodTable_(self, methodTable); } return self; }
IoCairoSurfacePattern *IoCairoSurfacePattern_proto(void *state) { IoObject *self = IoObject_new(state); IoObject_tag_(self, IoCairoSurfacePattern_newTag(state)); IoState_registerProtoWithFunc_(state, self, IoCairoSurfacePattern_proto); IoCairoPattern_addMethods(self); { IoMethodTable methodTable[] = { {"create", IoCairoSurfacePattern_create}, {"getSurface", IoCairoSurfacePattern_getSurface}, {"setExtend", IoCairoSurfacePattern_setExtend}, {"getExtend", IoCairoSurfacePattern_getExtend}, {"setFilter", IoCairoSurfacePattern_setFilter}, {"getFilter", IoCairoSurfacePattern_getFilter}, {NULL, NULL}, }; IoObject_addMethodTable_(self, methodTable); } return self; }
IoCertificate *IoCertificate_proto(void *state) { IoObject *self = IoObject_new(state); IoObject_tag_(self, IoCertificate_newTag(state)); IoState_registerProtoWithFunc_((IoState *)state, self, IoCertificate_proto); IoObject_setSlot_to_(self, IOSYMBOL("PEMType"), IONUMBER(X509_FILETYPE_PEM)); IoObject_setSlot_to_(self, IOSYMBOL("ASN1Type"), IONUMBER(X509_FILETYPE_ASN1)); { IoMethodTable methodTable[] = { {"version", IoCertificate_version}, {"serialNumber", IoCertificate_serialNumber}, {"notBefore", IoCertificate_notBefore}, {"notAfter", IoCertificate_notAfter}, {"extensions", IoCertificate_extensions}, {"attributes", IoCertificate_attributes}, {"issuerName", IoCertificate_issuerName}, {"subjectName", IoCertificate_subjectName}, {NULL, NULL} }; IoObject_addMethodTable_(self, methodTable); } IoObject_setDataPointer_(self, calloc(1, sizeof(Certificate))); return self; }
IoAppleSensors *IoAppleSensors_proto(void *state) { IoAppleSensors *self = IoObject_new(state); IoObject_tag_(self, IoAppleSensors_newTag(state)); //IoObject_setDataPointer_(self, calloc(1, sizeof(IoAppleSensorsData))); IoState_registerProtoWithId_(state, self, protoId); { IoMethodTable methodTable[] = { {"getLeftLightSensor", IoAppleSensors_getLeftLightSensor}, {"getRightLightSensor", IoAppleSensors_getRightLightSensor}, {"getDisplayBrightness", IoAppleSensors_getDisplayBrightness}, {"setDisplayBrightness", IoAppleSensors_setDisplayBrightness}, {"getKeyboardBrightness", IoAppleSensors_getKeyboardBrightness}, {"setKeyboardBrightness", IoAppleSensors_setKeyboardBrightness}, {"getCPUTemperature", IoAppleSensors_getCPUTemperature}, {"getGPUTemperature", IoAppleSensors_getGPUTemperature}, {"getPalmTemperature", IoAppleSensors_getPalmTemperature}, {"getBatteryTemperature", IoAppleSensors_getBatteryTemperature}, {"getPowerTemperature", IoAppleSensors_getPowerTemperature}, {"getPCHTemperature", IoAppleSensors_getPCHTemperature}, {"getRAMTemperature", IoAppleSensors_getRAMTemperature}, //{"smsDetect", IoAppleSensors_smsDetect}, {"smsVector", IoAppleSensors_smsVector}, {NULL, NULL}, }; IoObject_addMethodTable_(self, methodTable); } return self; }
IoCFFIArray *IoCFFIArray_proto(void *state) { IoObject *self = IoCFFIDataType_new(state); IoObject_tag_(self, IoCFFIArray_newTag(state)); IoObject_setDataPointer_(self, io_calloc(1, sizeof(IoCFFIArrayData))); memset(DATA(self), 0, sizeof(IoCFFIArrayData)); DATA(self)->needToFreeBuffer = 0; IoState_registerProtoWithFunc_(state, self, IoCFFIArray_proto); { IoMethodTable methodTable[] = { {"address", IoCFFIArray_address}, {"asBuffer", IoCFFIArray_asBuffer}, {"at", IoCFFIArray_at}, {"atPut", IoCFFIArray_atPut}, {"setValue", IoCFFIArray_setValue}, {"size", IoCFFIArray_size}, {"with", IoCFFIArray_with}, {NULL, NULL}, }; IoObject_addMethodTable_(self, methodTable); } return self; }
IoODEHinge *IoODEHinge_proto(void *state) { IoObject *self = IoObject_new(state); IoObject_tag_(self, IoODEHinge_newTag(state)); IoODEJoint_protoCommon(self); IoState_registerProtoWithId_(state, self, protoId); { IoMethodTable methodTable[] = { ODE_COMMON_JOINT_METHODS #define PARAM(X, _N, _SETN) \ {#_N, IoODEHinge_##_N}, \ {#_SETN, IoODEHinge_##_SETN}, PARAMS #undef PARAM {"anchor", IoODEHinge_anchor}, {"setAnchor", IoODEHinge_setAnchor}, {"anchor2", IoODEHinge_anchor2}, {"axis", IoODEHinge_axis}, {"setAxis", IoODEHinge_setAxis}, {"angle", IoODEHinge_angle}, {"angleRate", IoODEHinge_angleRate}, {"addTorque", IoODEHinge_addTorque}, {NULL, NULL}, }; IoObject_addMethodTable_(self, methodTable); } return self; }
IoMP3Decoder *IoMP3Decoder_proto(void *state) { IoObject *self = IoObject_new(state); IoObject_tag_(self, IoMP3Decoder_newTag(state)); IoObject_setDataPointer_(self, calloc(1, sizeof(IoMP3DecoderData))); //DATA(self)->outSound = 0x0; DATA(self)->willProcessMessage = IoMessage_newWithName_label_(state, IOSYMBOL("willProcess"), IOSYMBOL("[MP3Decoder]")); DATA(self)->didProcessMessage = IoMessage_newWithName_label_(state, IOSYMBOL("didProcess"), IOSYMBOL("[MP3Decoder]")); DATA(self)->inputBuffer = IoSeq_new(state); DATA(self)->outputBuffer = IoSeq_new(state); DATA(self)->tmpInputBa = UArray_new(); IoState_registerProtoWithFunc_(state, self, IoMP3Decoder_proto); { IoMethodTable methodTable[] = { {"start", IoMP3Decoder_start}, {"stop", IoMP3Decoder_stop}, {"inputBuffer", IoMP3Decoder_inputBuffer}, {"outputBuffer", IoMP3Decoder_outputBuffer}, {NULL, NULL}, }; IoObject_addMethodTable_(self, methodTable); } return self; }
IoAsyncRequest *IoAsyncRequest_proto(void *state) { IoAsyncRequest *self = IoObject_new(state); IoObject_tag_(self, IoAsyncRequest_newTag(state)); IoObject_setDataPointer_(self, calloc(1, sizeof(struct aiocb))); IoState_registerProtoWithFunc_(state, self, IoAsyncRequest_proto); { IoMethodTable methodTable[] = { {"setDescriptor", IoAsyncRequest_setDescriptor}, {"descriptor", IoAsyncRequest_descriptor}, {"numberOfBytes", IoAsyncRequest_numberOfBytes}, {"read", IoAsyncRequest_read}, {"write", IoAsyncRequest_write}, {"isDone", IoAsyncRequest_isDone}, {"error", IoAsyncRequest_error}, {"cancel", IoAsyncRequest_cancel}, {"sync", IoAsyncRequest_sync}, {"copyBufferTo", IoAsyncRequest_copyBufferTo}, {NULL, NULL}, }; IoObject_addMethodTable_(self, methodTable); } return self; }
IoODEBox *IoODEBox_proto(void *state) { IoObject *self = IoObject_new(state); IoObject_tag_(self, IoODEBox_newTag(state)); IoObject_setDataPointer_(self, calloc(1, sizeof(IoODEBoxData))); GEOMID = 0; IoState_registerProtoWithId_(state, self, protoId); { IoMethodTable methodTable[] = { {"geomId", IoODEBox_geomId}, {"lengths", IoODEBox_lengths}, {"setLengths", IoODEBox_setLengths}, {"pointDepth", IoODEBox_pointDepth}, {"body", IoODEBox_body}, {"setBody", IoODEBox_setBody}, {"collide", IoODEGeom_collide}, {NULL, NULL}, }; IoObject_addMethodTable_(self, methodTable); } return self; }
IoMP3Encoder *IoMP3Encoder_proto(void *state) { IoObject *self = IoObject_new(state); IoObject_tag_(self, IoMP3Encoder_newTag(state)); self->data = calloc(1, sizeof(IoMP3EncoderData)); DATA(self)->outBuffer = IoBuffer_new(state); DATA(self)->encoder = MP3Encoder_new(); MP3Encoder_setExternalOutputUArray_(DATA(self)->encoder, IoBuffer_rawUArray(DATA(self)->outBuffer)); IoState_registerProtoWithFunc_(state, self, IoMP3Encoder_proto); { IoMethodTable methodTable[] = { {"encode", IoMP3Encoder_encode}, {"end", IoMP3Encoder_end}, {"outBuffer", IoMP3Encoder_outBuffer}, {"setBitRate", IoMP3Encoder_setBitRate}, {"setSampleRate", IoMP3Encoder_setSampleRate}, {"setQuality", IoMP3Encoder_setQuality}, {"setCompressionRatio", IoMP3Encoder_setCompressionRatio}, {NULL, NULL}, }; IoObject_addMethodTable_(self, methodTable); } return self; }
IoTagDB *IoTagDB_proto(void *state) { IoObject *self = IoObject_new(state); IoObject_tag_(self, IoTagDB_newTag(state)); IoState_registerProtoWithFunc_(state, self, IoTagDB_proto); { IoMethodTable methodTable[] = { {"setPath", IoTagDB_setPath}, {"open", IoTagDB_open}, {"close", IoTagDB_close}, {"atKeyPutTags", IoTagDB_atKeyPutTags}, {"tagsAtKey", IoTagDB_tagsAtKey}, {"removeKey", IoTagDB_removeKey}, {"keysForTags", IoTagDB_keysForTags}, {"size", IoTagDB_size}, {"symbolForId", IoTagDB_symbolForId}, {"idForSymbol", IoTagDB_idForSymbol}, {"keyAtIndex", IoTagDB_keyAtIndex}, {"delete", IoTagDB_delete}, {"allUniqueTagIds", IoTagDB_allUniqueTagIds}, {NULL, NULL}, }; IoObject_addMethodTable_(self, methodTable); } IoObject_setDataPointer_(self, TagDB_new()); return self; }
IoAudioDevice *IoAudioDevice_proto(void *state) { IoObject *self = IoObject_new(state); IoObject_tag_(self, IoAudioDevice_newTag(state)); IoObject_setDataPointer_(self, calloc(1, sizeof(IoAudioDeviceData))); DATA(self)->writeBuffer = IoSeq_new(state); DATA(self)->readBuffer = IoSeq_new(state); DATA(self)->audioDevice = AudioDevice_new(); IoState_registerProtoWithFunc_(state, self, IoAudioDevice_proto); { IoMethodTable methodTable[] = { {"open", IoAudioDevice_open}, {"openForReadingAndWriting", IoAudioDevice_openForReadingAndWriting}, {"close", IoAudioDevice_close}, {"asyncWrite", IoAudioDevice_asyncWrite}, {"asyncRead", IoAudioDevice_read}, {"error", IoAudioDevice_error}, {"isActive", IoAudioDevice_isActive}, {"streamTime", IoAudioDevice_streamTime}, {"needsData", IoAudioDevice_needsData}, {"writeBufferIsEmpty", IoAudioDevice_writeBufferIsEmpty}, {NULL, NULL}, }; IoObject_addMethodTable_(self, methodTable); } return self; }
IoSkipDB *IoSkipDB_rawClone(IoSkipDB *proto) { IoObject *self = IoObject_rawClonePrimitive(proto); IoObject_tag_(self, IoObject_tag(proto)); IoObject_setDataPointer_(self, NULL); return self; }
IoDirectory *IoDirectory_proto(void *state) { IoObject *self = IoObject_new(state); IoObject_tag_(self, IoDirectory_newTag(state)); IoObject_setDataPointer_(self, io_calloc(1, sizeof(IoDirectoryData))); DATA(self)->path = IOSYMBOL("."); IoState_registerProtoWithFunc_((IoState *)state, self, IoDirectory_proto); { IoMethodTable methodTable[] = { {"setPath", IoDirectory_setPath}, {"path", IoDirectory_path}, {"name", IoDirectory_name}, {"exists", IoDirectory_exists}, {"items", IoDirectory_items}, {"at", IoDirectory_at}, {"size", IoDirectory_size}, {"create", IoDirectory_create}, {"createSubdirectory", IoDirectory_createSubdirectory}, {"currentWorkingDirectory", IoDirectory_currentWorkingDirectory}, {"setCurrentWorkingDirectory", IoDirectory_setCurrentWorkingDirectory}, {NULL, NULL}, }; IoObject_addMethodTable_(self, methodTable); } return self; }
IoGLScissor *IoGLScissor_proto(void *state) { IoObject *self = IoObject_new(state); IoObject_tag_(self, IoGLScissor_newTag(state)); IoObject_setDataPointer_(self, calloc(1, sizeof(IoGLScissorData))); DATA(self)->rect = IoBox_new(state); DATA(self)->tmpRect = IoBox_new(state); IoState_registerProtoWithFunc_(state, self, IoGLScissor_proto); { IoMethodTable methodTable[] = { {"sync", IoGLScissor_sync}, {"set", IoGLScissor_set}, {"on", IoGLScissor_on}, {"off", IoGLScissor_off}, {"isOn", IoGLScissor_isOn}, {"push", IoGLScissor_push}, {"pop", IoGLScissor_pop}, {"isVisible", IoGLScissor_isVisible}, {"rect", IoGLScissor_rect}, {"setRect", IoGLScissor_setScreenRect}, {"setViewRect", IoGLScissor_setViewRect}, {"unionWithViewRect", IoGLScissor_unionWithViewRect}, {"unionWithScreenRect", IoGLScissor_unionWithScreenRect}, {NULL, NULL}, }; IoObject_addMethodTable_(self, methodTable); } return self; }
IoList *IoList_rawClone(IoList *proto) { IoObject *self = IoObject_rawClonePrimitive(proto); IoObject_tag_(self, IoObject_tag(proto)); IoObject_setDataPointer_(self, List_clone(DATA(proto))); return self; }
IoFont *IoFont_proto( void *state ) { IoObject *self = IoObject_new(state); IoObject_tag_(self, IoFont_newTag(state)); IoObject_setDataPointer_(self, calloc(1, sizeof(IoFontData))); DATA(self)->path = IOSYMBOL("."); DATA(self)->font = GLFont_new(); DATA(self)->isProto = 1; IoState_registerProtoWithId_(state, self, protoId); { IoMethodTable methodTable[] = { {"open", IoFont_open}, {"setPath", IoFont_setPath}, {"path", IoFont_path}, {"setPixelSize", IoFont_setPixelSize}, {"pixelSize", IoFont_pixelSize}, {"drawString", IoFont_drawString}, {"widthOfString", IoFont_lengthOfString}, {"widthOfCharacter", IoFont_lengthOfCharacter}, {"pixelHeight", IoFont_fontHeight}, {"isTextured", IoFont_isTextured}, {"error", IoFont_error}, {"stringIndexAtWidth", IoFont_stringIndexAtWidth}, {NULL, NULL}, }; IoObject_addMethodTable_(self, methodTable); } GLFont_init(); return self; }
IoObject *IoDynLib_proto(void *state) { IoMethodTable methodTable[] = { {"setPath", IoDynLib_setPath}, {"path", IoDynLib_path}, {"setInitFuncName", IoDynLib_setInitFuncName}, {"initFuncName", IoDynLib_initFuncName}, {"setFreeFuncName", IoDynLib_setFreeFuncName}, {"freeFuncName", IoDynLib_freeFuncName}, {"open", IoDynLib_open}, {"close", IoDynLib_close}, {"isOpen", IoDynLib_isOpen}, {"call", IoDynLib_call}, {"voidCall", IoDynLib_voidCall}, {"callPluginInit", IoDynLib_callPluginInitFunc}, //{"returnsString", IoDynLib_returnsString}, {NULL, NULL}, }; IoObject *self = IoObject_new(state); IoObject_tag_(self, IoDynLib_newTag(state)); IoObject_setDataPointer_(self, DynLib_new()); DynLib_setInitArg_(DATA(self), state); DynLib_setFreeArg_(DATA(self), state); IoState_registerProtoWithId_((IoState *)state, self, protoId); IoObject_addMethodTable_(self, methodTable); return self; }
IoTokyoCabinetPrefixCursor *IoTokyoCabinetPrefixCursor_proto(void *state) { IoMethodTable methodTable[] = { {"close", IoTokyoCabinetPrefixCursor_close}, {"first", IoTokyoCabinetPrefixCursor_first}, {"last", IoTokyoCabinetPrefixCursor_last}, {"previous", IoTokyoCabinetPrefixCursor_previous}, {"next", IoTokyoCabinetPrefixCursor_next}, {"jump", IoTokyoCabinetPrefixCursor_jump}, {"key", IoTokyoCabinetPrefixCursor_key}, {"value", IoTokyoCabinetPrefixCursor_value}, {"put", IoTokyoCabinetPrefixCursor_put}, {"remove", IoTokyoCabinetPrefixCursor_remove}, {NULL, NULL}, }; IoObject *self = IoObject_new(state); IoObject_tag_(self, IoTokyoCabinetPrefixCursor_newTag(state)); IoObject_setDataPointer_(self, NULL); IoState_registerProtoWithId_((IoState *)state, self, protoId); IoObject_addMethodTable_(self, methodTable); return self; }
IoODEMass *IoODEMass_proto(void *state) { IoObject *self = IoObject_new(state); IoObject_tag_(self, IoODEMass_newTag(state)); IoObject_setDataPointer_(self, calloc(1, sizeof(IoODEMassData))); IoState_registerProtoWithFunc_(state, self, IoODEMass_proto); { IoMethodTable methodTable[] = { {"reset", IoODEMass_reset}, {"mass", IoODEMass_mass}, {"setMass", IoODEMass_setMass}, {"centerOfGravity", IoODEMass_centerOfGravity}, {"setCenterOfGravity", IoODEMass_setCenterOfGravity}, {"inertiaTensor", IoODEMass_inertiaTensor}, {"parameters", IoODEMass_parameters}, {"setParameters", IoODEMass_setParameters}, {"setSphereDensity", IoODEMass_setSphereDensity}, {"setSphereMass", IoODEMass_setSphereMass}, {"setCappedCylinderDensity", IoODEMass_setCappedCylinderDensity}, {"setCappedCylinderMass", IoODEMass_setCappedCylinderMass}, {"setBoxDensity", IoODEMass_setBoxDensity}, {"setBoxMass", IoODEMass_setBoxMass}, {NULL, NULL}, }; IoObject_addMethodTable_(self, methodTable); } return self; }
IoTokyoCabinetPrefixCursor *IoTokyoCabinetPrefixCursor_rawClone(IoTokyoCabinetPrefixCursor *proto) { IoObject *self = IoObject_rawClonePrimitive(proto); IoObject_tag_(self, IoObject_tag(proto)); IoObject_setDataPointer_(self, tcbdbnew()); return self; }
IoCall *IoCall_proto(void *vState) { IoState *state = (IoState *)vState; IoMethodTable methodTable[] = { {"sender", IoCall_sender}, {"message", IoCall_message}, {"slotContext", IoCall_slotContext}, {"target", IoCall_target}, {"activated", IoCall_activated}, {"coroutine", IoCall_coroutine}, {"evalArgAt", IoCall_evalArgAt}, {"argAt", IoCall_argAt}, {"stopStatus", IoCall_stopStatus}, {"setStopStatus", IoCall_setStopStatus}, {NULL, NULL}, }; IoObject *self = IoObject_new(state); IoObject_setDataPointer_(self, io_calloc(1, sizeof(IoCallData))); IoObject_tag_(self, IoCall_newTag(state)); IoCall_initSlots(self); IoState_registerProtoWithFunc_((IoState *)state, self, IoCall_proto); IoObject_addMethodTable_(self, methodTable); return self; }
IoClutterColor *IoClutterColor_proto(void *state) { IoObject *self = IoObject_new(state); IoObject_tag_(self, IoClutterColor_newTag(state)); IoObject_setDataPointer_(self, calloc(1, sizeof(IoClutterColorData))); IoState_registerProtoWithFunc_(state, self, IoClutterColor_proto); { IoMethodTable methodTable[] = { {"==", IoClutterColor_equals}, {"!=", IoClutterColor_notEquals}, {"with", IoClutterColor_fromString}, {"asString", IoClutterColor_asString}, {"withHLS", IoClutterColor_fromHLS}, {"toHLS", IoClutterColor_toHLS}, {"withPixel", IoClutterColor_fromPixel}, {"toPixel", IoClutterColor_toPixel}, {"+", IoClutterColor_add}, {"-", IoClutterColor_subtract}, {"addInPlace", IoClutterColor_addInPlace}, {"subtractInPlace", IoClutterColor_subtractInPlace}, {"lighten", IoClutterColor_lighten}, {"darken", IoClutterColor_darken}, {"shade", IoClutterColor_shade}, {NULL, NULL} }; IoObject_addMethodTable_(self, methodTable); } return self; }
IoClutterEvent *IoClutterEvent_proto(void *state) { IoObject *self = IoObject_new(state); IoObject_tag_(self, IoClutterEvent_newTag(state)); IoState_registerProtoWithFunc_(state, self, IoClutterEvent_proto); { IoMethodTable methodTable[] = { {"eventType", IoClutterEvent_eventType}, {"coords", IoClutterEvent_getCoords}, {"state", IoClutterEvent_getState}, {"time", IoClutterEvent_getTime}, {"source", IoClutterEvent_getSource}, //{"stage", IoClutterEvent_getStage}, {"flags", IoClutterEvent_getFlags}, {"peek", IoClutterEvent_peek}, {"put", IoClutterEvent_put}, {"putBack", IoClutterEvent_putBack}, {"hasPending", IoClutterEvent_hasPending}, {"button", IoClutterEvent_getButton}, {"clickCount", IoClutterEvent_getClickCount}, {"keySymbol", IoClutterEvent_getKeySymbol}, {"keyCode", IoClutterEvent_getKeyCode}, {"keyUnicode", IoClutterEvent_getKeyUnicode}, {"relatedActor", IoClutterEvent_getRelatedActor}, {"scrollDirecton", IoClutterEvent_getScrollDirection}, {"device", IoClutterEvent_getDevice}, {NULL, NULL} }; IoObject_addMethodTable_(self, methodTable); } return self; }
IoObject *IoMemcached_proto(void *state) { IoMemcached *self = IoObject_new(state); IoObject_tag_(self, IoMemcached_newTag(state)); IoObject_setDataPointer_(self, calloc(1, sizeof(IoMemcachedData))); IoState_registerProtoWithFunc_(state, self, IoMemcached_proto); { IoMethodTable methodTable[] = { {"addServer", IoMemcached_addServer}, {"set", IoMemcached_set}, {"add", IoMemcached_add}, {"replace", IoMemcached_replace}, {"append", IoMemcached_append}, {"prepend", IoMemcached_prepend}, {"get", IoMemcached_get}, {"getMulti", IoMemcached_getMulti}, {"delete", IoMemcached_delete}, {"flushAll", IoMemcached_flushAll}, {"incr", IoMemcached_incr}, {"decr", IoMemcached_decr}, {"stats", IoMemcached_stats}, {NULL, NULL}, }; IoObject_addMethodTable_(self, methodTable); } return self; }