addons/OpenGL/source/IoGLUT.c

   1
   2 //metadoc GLUT copyright Steve Dekorte 2002
   3 //metadoc GLUT license BSD revised
   4 //metadoc GLUT category Graphics
   5
   6 #include "IoGLUT.h"
   7
   8 #include "List.h"
   9 #include "IoState.h"
  10 #include "IoNumber.h"
  11 #include "IoCFunction.h"
  12 #include "IoSeq.h"
  13 #include "IoList.h"
  14 #include "List.h"
  15 #include "IoDirectory.h"
  16 #include <time.h>
  17
  18 #define DATA(self) ((IoGLUTData *)IoObject_dataPointer(self))
  19
  20 void IoGlutTimerFunc(int vv);
  21
  22 static IoGLUT *proto = NULL;
  23
  24
  25 IoTag *IoGLUT_newTag(void *state)
  26 {
  27         IoTag *tag = IoTag_newWithName_("GLUT");
  28         IoTag_state_(tag, state);
  29         IoTag_cloneFunc_(tag, (IoTagCloneFunc *)IoGLUT_rawClone);
  30         IoTag_freeFunc_(tag, (IoTagFreeFunc *)IoGLUT_free);
  31         IoTag_markFunc_(tag, (IoTagMarkFunc *)IoGLUT_mark);
  32         return tag;
  33 }
  34
  35 #define GLUTMESSAGE(name) \
  36 IoMessage_newWithName_label_(state, IOSYMBOL(name), IOSYMBOL("[GLUT]"))
  37
  38 IoGLUT *IoGLUT_proto(void *state)
  39 {
  40         IoObject *self = IoObject_new(state);
  41         /*printf("state = %p proto = %p self = %p\n", state, proto, self); */
  42
  43         proto = self;
  44         IoObject_tag_(self, IoGLUT_newTag(state));
  45         IoObject_setDataPointer_(self, calloc(1, sizeof(IoGLUTData)));
  46
  47         DATA(self)->coroutine = IoCoroutine_new(state);
  48         //printf("GLUT coro = %p\n", DATA(self)->coroutine);
  49
  50         DATA(self)->eventTarget = NULL;
  51         DATA(self)->entryMessage      = GLUTMESSAGE("entry");
  52         DATA(self)->displayMessage    = GLUTMESSAGE("display");
  53         DATA(self)->keyboardMessage   = GLUTMESSAGE("keyboard");
  54         DATA(self)->keyboardUpMessage = GLUTMESSAGE("keyboardUp");
  55         DATA(self)->joystickMessage   = GLUTMESSAGE("joystick");
  56         DATA(self)->motionMessage     = GLUTMESSAGE("motion");
  57         DATA(self)->menuMessage       = GLUTMESSAGE("menu");
  58         DATA(self)->mouseMessage      = GLUTMESSAGE("mouse");
  59         DATA(self)->passiveMotionMessage = GLUTMESSAGE("passiveMotion");
  60         DATA(self)->reshapeMessage = GLUTMESSAGE("reshape");
  61         DATA(self)->specialMessage = GLUTMESSAGE("special");
  62         DATA(self)->specialUpMessage = GLUTMESSAGE("specialUp");
  63         DATA(self)->timerMessage   = GLUTMESSAGE("timer");
  64
  65         DATA(self)->acceptsDropMessage = GLUTMESSAGE("acceptsDrop");
  66         DATA(self)->dragMessage   = GLUTMESSAGE("drag");
  67         DATA(self)->dropMessage   = GLUTMESSAGE("drop");
  68         DATA(self)->copyMessage   = GLUTMESSAGE("copy");
  69         DATA(self)->pasteMessage  = GLUTMESSAGE("paste");
  70         DATA(self)->deleteMessage = GLUTMESSAGE("delete");
  71         DATA(self)->nanoSleepPeriod = 1000000000/2;
  72
  73
  74
  75
  76         //printf("GLUT coro = %p\n", (void *)DATA(self)->coroutine);
  77         IoState_retain_(state, self);
  78         IoState_retain_(state, DATA(self)->coroutine);
  79         IoState_retain_(state, DATA(self)->displayMessage);
  80         IoState_retain_(state, DATA(self)->reshapeMessage);
  81         IoState_retain_(state, DATA(self)->timerMessage);
  82
  83
  84
  85         DATA(self)->j = IoSeq_newFloatArrayOfSize_(state, 0);
  86         DATA(self)->lastJ = UArray_new();
  87         UArray_setItemType_(DATA(self)->lastJ, CTYPE_float32_t);
  88
  89         IoState_registerProtoWithFunc_(state, self, IoGLUT_proto);
  90
  91
  92         //-----------------------------
  93
  94         IoState_retain_(state, DATA(self)->j);
  95
  96         IoState_retain_(state, DATA(self)->coroutine);
  97         IoState_retain_(state, DATA(self)->entryMessage);
  98         IoState_retain_(state, DATA(self)->displayMessage);
  99         IoState_retain_(state, DATA(self)->keyboardMessage);
 100         IoState_retain_(state, DATA(self)->keyboardUpMessage);
 101         IoState_retain_(state, DATA(self)->joystickMessage);
 102         IoState_retain_(state, DATA(self)->menuMessage);
 103         IoState_retain_(state, DATA(self)->mouseMessage);
 104         IoState_retain_(state, DATA(self)->motionMessage);
 105         IoState_retain_(state, DATA(self)->passiveMotionMessage);
 106         IoState_retain_(state, DATA(self)->reshapeMessage);
 107         IoState_retain_(state, DATA(self)->specialMessage);
 108         IoState_retain_(state, DATA(self)->specialUpMessage);
 109         IoState_retain_(state, DATA(self)->timerMessage);
 110
 111         IoState_retain_(state, DATA(self)->acceptsDropMessage);
 112         IoState_retain_(state, DATA(self)->dragMessage);
 113         IoState_retain_(state, DATA(self)->dropMessage);
 114         IoState_retain_(state, DATA(self)->copyMessage);
 115         IoState_retain_(state, DATA(self)->pasteMessage);
 116         IoState_retain_(state, DATA(self)->deleteMessage);
 117
 118         IoGLUT_protoInit(self);
 119         return self;
 120 }
 121
 122 IoGLUT *IoGLUT_new(void *state)
 123 {
 124         return IoState_protoWithInitFunction_(state, IoGLUT_proto);
 125 }
 126
 127 void IoGLUT_free(IoGLUT *self)
 128 {
 129         /* add code to shut down GLUT */
 130         free(IoObject_dataPointer(self));
 131 }
 132
 133 void IoGLUT_mark(IoGLUT *self)
 134 {
 135         //printf("IoGLUT_mark\n");
 136
 137         if (DATA(self)->eventTarget)
 138         {
 139                 IoObject_shouldMark(DATA(self)->eventTarget);
 140         }
 141
 142         IoObject_shouldMark(DATA(self)->j);
 143
 144         IoObject_shouldMark(DATA(self)->coroutine);
 145         IoObject_shouldMark(DATA(self)->entryMessage);
 146         IoObject_shouldMark(DATA(self)->displayMessage);
 147         IoObject_shouldMark(DATA(self)->keyboardMessage);
 148         IoObject_shouldMark(DATA(self)->keyboardUpMessage);
 149         IoObject_shouldMark(DATA(self)->joystickMessage);
 150         IoObject_shouldMark(DATA(self)->menuMessage);
 151         IoObject_shouldMark(DATA(self)->mouseMessage);
 152         IoObject_shouldMark(DATA(self)->motionMessage);
 153         IoObject_shouldMark(DATA(self)->passiveMotionMessage);
 154         IoObject_shouldMark(DATA(self)->reshapeMessage);
 155         IoObject_shouldMark(DATA(self)->specialMessage);
 156         IoObject_shouldMark(DATA(self)->specialUpMessage);
 157         IoObject_shouldMark(DATA(self)->timerMessage);
 158
 159         IoObject_shouldMark(DATA(self)->acceptsDropMessage);
 160         IoObject_shouldMark(DATA(self)->dragMessage);
 161         IoObject_shouldMark(DATA(self)->dropMessage);
 162         IoObject_shouldMark(DATA(self)->copyMessage);
 163         IoObject_shouldMark(DATA(self)->pasteMessage);
 164         IoObject_shouldMark(DATA(self)->deleteMessage);
 165 }
 166
 167 /* ----------------------------------------------------------- */
 168
 169 IoObject *IoGLUT_rawClone(IoGLUT *self)
 170 {
 171         return IoState_protoWithInitFunction_(IOSTATE, IoGLUT_proto);
 172 }
 173
 174 /* ----------------------------------------------------------- */
 175
 176 IoObject *IoGLUT_glutInitDisplayMode(IoGLUT *self, IoObject *locals, IoMessage *m)
 177 {
 178         int mode = IoMessage_locals_intArgAt_(m, locals, 0);
 179         glutInitDisplayMode(mode);
 180         return self;
 181 }
 182
 183 IoObject *IoGLUT_glutInitWindowSize(IoGLUT *self, IoObject *locals, IoMessage *m)
 184 {
 185         int w  = IoMessage_locals_intArgAt_(m, locals, 0);
 186         int h = IoMessage_locals_intArgAt_(m, locals, 1);
 187         //printf("glutInitWindowSize(%i, %i)\n", w, h);
 188         glutInitWindowSize(w, h);
 189         return self;
 190 }
 191
 192 IoObject *IoGLUT_glutInitWindowPosition(IoGLUT *self, IoObject *locals, IoMessage *m)
 193 {
 194         int x = IoMessage_locals_intArgAt_(m, locals, 0);
 195         int y = IoMessage_locals_intArgAt_(m, locals, 1);
 196         //printf("glutInitWindowPosition(%i, %i)\n", x, y);
 197         glutInitWindowPosition(x, y);
 198         return self;
 199 }
 200
 201 void IoGlutIdleFunc(void)
 202 {
 203         //IoState_yield(IoObject_state(proto));
 204 }
 205
 206 IoObject *IoGLUT_glutInit(IoGLUT *self, IoObject *locals, IoMessage *m)
 207 {
 208         IoState *state = IOSTATE;
 209         int argc = state->mainArgs->argc;
 210         UArray *ba = IoDirectory_CurrentWorkingDirectoryAsUArray();
 211         glutInit(&argc, (char **)(state->mainArgs->argv));
 212         IoDirectory_SetCurrentWorkingDirectory(UArray_asCString(ba));
 213         UArray_free(ba);
 214
 215         //glutIdleFunc(IoGlutIdleFunc);
 216         //glutTimerFunc((unsigned int)10, IoGlutTimerFunc, -1);
 217         return self;
 218 }
 219
 220 IoObject *IoGLUT_glutInitDisplayString(IoGLUT *self, IoObject *locals, IoMessage *m)
 221 {
 222         IoSymbol *s = IoMessage_locals_symbolArgAt_(m, locals, 0);
 223         glutInitDisplayString(IoSeq_asCString(s));
 224         return self;
 225 }
 226
 227 IoObject *IoGLUT_glutCreateWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 228 {
 229         IoSymbol *s = IoMessage_locals_symbolArgAt_(m, locals, 0);
 230         int windowId = glutCreateWindow(IoSeq_asCString(s));
 231         return IONUMBER(windowId);
 232 }
 233
 234 IoObject *IoGLUT_glutCreateSubWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 235 {
 236         int win = IoMessage_locals_intArgAt_(m, locals, 0);
 237         int x = IoMessage_locals_intArgAt_(m, locals, 1);
 238         int y = IoMessage_locals_intArgAt_(m, locals, 2);
 239         int w = IoMessage_locals_intArgAt_(m, locals, 3);
 240         int h = IoMessage_locals_intArgAt_(m, locals, 4);
 241         return IONUMBER(glutCreateSubWindow(win, x, y, w, h));
 242 }
 243
 244 IoObject *IoGLUT_glutSetWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 245 {
 246         int win = IoMessage_locals_intArgAt_(m, locals, 0);
 247         glutSetWindow(win);
 248         return self;
 249 }
 250
 251 IoObject *IoGLUT_glutGetWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 252 {
 253         return IONUMBER(glutGetWindow());
 254 }
 255
 256 IoObject *IoGLUT_glutGet(IoGLUT *self, IoObject *locals, IoMessage *m)
 257 {
 258         GLenum n = IoMessage_locals_intArgAt_(m, locals, 0);
 259         return IONUMBER(glutGet(n));
 260 }
 261
 262 IoObject *IoGLUT_glutDestroyWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 263 {
 264         int win = IoMessage_locals_intArgAt_(m, locals, 0);
 265         glutDestroyWindow(win);
 266         return self;
 267 }
 268
 269 IoObject *IoGLUT_glutPositionWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 270 {
 271         int x = IoMessage_locals_intArgAt_(m, locals, 0);
 272         int y = IoMessage_locals_intArgAt_(m, locals, 1);
 273         glutPositionWindow(x, y);
 274         return self;
 275 }
 276
 277 IoObject *IoGLUT_glutReshapeWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 278 {
 279         int w = IoMessage_locals_intArgAt_(m, locals, 0);
 280         int h = IoMessage_locals_intArgAt_(m, locals, 1);
 281         glutReshapeWindow(w, h);
 282         return self;
 283 }
 284
 285 IoObject *IoGLUT_glutPopWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 286 {
 287         glutPopWindow(); return self;
 288 }
 289
 290 IoObject *IoGLUT_glutPushWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 291 {
 292         glutPushWindow();
 293         return self;
 294 }
 295
 296 IoObject *IoGLUT_glutShowWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 297 {
 298         glutShowWindow();
 299         return self;
 300 }
 301
 302 IoObject *IoGLUT_glutHideWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 303 {
 304         glutHideWindow();
 305         return self;
 306 }
 307
 308 IoObject *IoGLUT_glutIconifyWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 309 {
 310         glutIconifyWindow();
 311         return self;
 312 }
 313
 314 IoObject *IoGLUT_glutSetWindowTitle(IoGLUT *self, IoObject *locals, IoMessage *m)
 315 {
 316         IoSymbol *s = IoMessage_locals_symbolArgAt_(m, locals, 0);
 317         glutSetWindowTitle(CSTRING(s));
 318         return self;
 319 }
 320
 321 IoObject *IoGLUT_glutSetIconTitle(IoGLUT *self, IoObject *locals, IoMessage *m)
 322 {
 323         IoSymbol *s = IoMessage_locals_symbolArgAt_(m, locals, 0);
 324         glutSetIconTitle(CSTRING(s));
 325         return self;
 326 }
 327
 328 IoObject *IoGLUT_glutEventTarget_(IoGLUT *self, IoObject *locals, IoMessage *m)
 329 {
 330         DATA(proto)->eventTarget = IOREF(IoMessage_locals_valueArgAt_(m, locals, 0));
 331         return self;
 332 }
 333
 334 // events
 335
 336 void IoGlutDisplayFunc(void)
 337 {
 338         //printf("IoGlutDisplayFunc\n");
 339         IoState_pushRetainPool(IoObject_state(proto));
 340
 341         IoGLUT_tryCallback(proto, DATA(proto)->displayMessage);
 342
 343         IoState_popRetainPool(IoObject_state(proto));
 344 }
 345
 346 IoObject *IoGLUT_glutDisplayFunc(IoGLUT *self, IoObject *locals, IoMessage *m)
 347 {
 348         glutDisplayFunc(IoGlutDisplayFunc);
 349         return self;
 350 }
 351
 352 void IoGlutKeyboardFunc(unsigned char key, int xv, int yv)
 353 {
 354         IoState_pushRetainPool(IoObject_state(proto));
 355         IoMessage_setCachedArg_toInt_(DATA(proto)->keyboardMessage, 0, (int)key);
 356         IoMessage_setCachedArg_toInt_(DATA(proto)->keyboardMessage, 1, xv);
 357         IoMessage_setCachedArg_toInt_(DATA(proto)->keyboardMessage, 2, yv);
 358
 359         IoGLUT_tryCallback(proto, DATA(proto)->keyboardMessage);
 360
 361         IoState_popRetainPool(IoObject_state(proto));
 362 }
 363
 364 IoObject *IoGLUT_glutKeyboardFunc(IoGLUT *self, IoObject *locals, IoMessage *m)
 365 {
 366         glutKeyboardFunc(IoGlutKeyboardFunc);
 367         return self;
 368 }
 369
 370 void IoGlutSpecialFunc(int key, int xv, int yv)
 371 {
 372         IoState_pushRetainPool(IoObject_state(proto));
 373         IoMessage_setCachedArg_toInt_(DATA(proto)->specialMessage, 0, (int)key);
 374         IoMessage_setCachedArg_toInt_(DATA(proto)->specialMessage, 1, xv);
 375         IoMessage_setCachedArg_toInt_(DATA(proto)->specialMessage, 2, yv);
 376
 377         IoGLUT_tryCallback(proto, DATA(proto)->specialMessage);
 378
 379         IoState_popRetainPool(IoObject_state(proto));
 380 }
 381
 382 IoObject *IoGLUT_glutSpecialFunc(IoGLUT *self, IoObject *locals, IoMessage *m)
 383 {
 384         glutSpecialFunc(IoGlutSpecialFunc);
 385         return self;
 386 }
 387
 388 void IoGlutKeyboardUpFunc(unsigned char key, int xv, int yv)
 389 {
 390         IoState_pushRetainPool(IoObject_state(proto));
 391         IoMessage_setCachedArg_toInt_(DATA(proto)->keyboardUpMessage, 0, (int)key);
 392         IoMessage_setCachedArg_toInt_(DATA(proto)->keyboardUpMessage, 1, xv);
 393         IoMessage_setCachedArg_toInt_(DATA(proto)->keyboardUpMessage, 2, yv);
 394
 395         IoGLUT_tryCallback(proto, DATA(proto)->keyboardUpMessage);
 396
 397         IoState_popRetainPool(IoObject_state(proto));
 398 }
 399
 400 IoObject *IoGLUT_glutKeyboardUpFunc(IoGLUT *self, IoObject *locals, IoMessage *m)
 401 {
 402 #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13)
 403         glutKeyboardUpFunc(IoGlutKeyboardUpFunc);
 404         return self;
 405 #endif
 406 }
 407
 408 void IoGlutSpecialUpFunc(int key, int xv, int yv)
 409 {
 410         IoState_pushRetainPool(IoObject_state(proto));
 411         IoMessage_setCachedArg_toInt_(DATA(proto)->specialUpMessage, 0, (int)key);
 412         IoMessage_setCachedArg_toInt_(DATA(proto)->specialUpMessage, 1, xv);
 413         IoMessage_setCachedArg_toInt_(DATA(proto)->specialUpMessage, 2, yv);
 414
 415         IoGLUT_tryCallback(proto, DATA(proto)->specialUpMessage);
 416
 417         IoState_popRetainPool(IoObject_state(proto));
 418 }
 419
 420 IoObject *IoGLUT_glutSpecialUpFunc(IoGLUT *self, IoObject *locals, IoMessage *m)
 421 {
 422 #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13)
 423         glutSpecialUpFunc(IoGlutSpecialUpFunc);
 424         return self;
 425 #endif
 426 }
 427
 428 IoObject *IoGLUT_glutGetModifiers(IoGLUT *self, IoObject *locals, IoMessage *m)
 429 {
 430         return IONUMBER(glutGetModifiers());
 431 }
 432
 433 void IoGlutEntryFunc(int state)
 434 {
 435         IoState_pushRetainPool(IoObject_state(proto));
 436         IoMessage_setCachedArg_toInt_(DATA(proto)->entryMessage, 0, state);
 437
 438         IoGLUT_tryCallback(proto, DATA(proto)->entryMessage);
 439
 440         IoState_popRetainPool(IoObject_state(proto));
 441 }
 442
 443 IoObject *IoGLUT_glutEntryFunc(IoGLUT *self, IoObject *locals, IoMessage *m)
 444 {
 445         glutEntryFunc(IoGlutEntryFunc); return self;
 446 }
 447
 448 void IoGlutMotionFunc(int xv, int yv)
 449 {
 450         IoState_pushRetainPool(IoObject_state(proto));
 451
 452         {
 453                 IoMessage_setCachedArg_toInt_(DATA(proto)->motionMessage, 0, xv);
 454                 IoMessage_setCachedArg_toInt_(DATA(proto)->motionMessage, 1, yv);
 455
 456                 IoGLUT_tryCallback(proto, DATA(proto)->motionMessage);
 457         }
 458
 459         IoState_popRetainPool(IoObject_state(proto));
 460 }
 461
 462 IoObject *IoGLUT_glutMotionFunc(IoGLUT *self, IoObject *locals, IoMessage *m)
 463 {
 464         glutMotionFunc(IoGlutMotionFunc);
 465         return self;
 466 }
 467
 468 void IoGlutPassiveMotionFunc(int xv, int yv)
 469 {
 470         IoState_pushRetainPool(IoObject_state(proto));
 471
 472         {
 473                 IoMessage_setCachedArg_toInt_(DATA(proto)->passiveMotionMessage, 0, xv);
 474                 IoMessage_setCachedArg_toInt_(DATA(proto)->passiveMotionMessage, 1, yv);
 475
 476                 IoGLUT_tryCallback(proto, DATA(proto)->passiveMotionMessage);
 477         }
 478
 479         IoState_popRetainPool(IoObject_state(proto));
 480 }
 481
 482 IoObject *IoGLUT_glutPassiveMotionFunc(IoGLUT *self, IoObject *locals, IoMessage *m)
 483 {
 484         glutPassiveMotionFunc(IoGlutPassiveMotionFunc);
 485         return self;
 486 }
 487
 488 void IoGlutMouseFunc(int button, int state, int xv, int yv)
 489 {
 490         IoState_pushRetainPool(IoObject_state(proto));
 491
 492         {
 493                 IoMessage_setCachedArg_toInt_(DATA(proto)->mouseMessage, 0, button);
 494                 IoMessage_setCachedArg_toInt_(DATA(proto)->mouseMessage, 1, state);
 495                 IoMessage_setCachedArg_toInt_(DATA(proto)->mouseMessage, 2, xv);
 496                 IoMessage_setCachedArg_toInt_(DATA(proto)->mouseMessage, 3, yv);
 497
 498                 IoGLUT_tryCallback(proto, DATA(proto)->mouseMessage);
 499         }
 500
 501         IoState_popRetainPool(IoObject_state(proto));
 502 }
 503
 504 IoObject *IoGLUT_glutMouseFunc(IoGLUT *self, IoObject *locals, IoMessage *m)
 505 {
 506         glutMouseFunc(IoGlutMouseFunc);
 507         return self;
 508 }
 509
 510 void IoGlutReshapeFunc(int width, int height)
 511 {
 512         //printf("IoGlutReshapeFunc\n");
 513         IoState_pushRetainPool(IoObject_state(proto));
 514         {
 515                 IoMessage_setCachedArg_toInt_(DATA(proto)->reshapeMessage, 0, width?width:1);
 516                 IoMessage_setCachedArg_toInt_(DATA(proto)->reshapeMessage, 1, height?height:1);
 517
 518                 IoGLUT_tryCallback(proto, DATA(proto)->reshapeMessage);
 519         }
 520
 521         IoState_popRetainPool(IoObject_state(proto));
 522 }
 523
 524 IoObject *IoGLUT_glutReshapeFunc(IoGLUT *self, IoObject *locals, IoMessage *m)
 525 {
 526         glutReshapeFunc(IoGlutReshapeFunc);
 527         return self;
 528 }
 529
 530 void IoGlutTimerFunc(int vv)
 531 {
 532         IoState *state = IoObject_state(proto);
 533
 534         //printf("IoGlutTimerFunc\n");
 535
 536         IoState_pushRetainPool(state);
 537
 538         if (vv == -1)
 539         {
 540                 //IoState_yield(IoObject_state(proto));
 541                 glutTimerFunc((unsigned int)100, IoGlutTimerFunc, -1);
 542         }
 543         else
 544         {
 545                 IoObject *m = DATA(proto)->timerMessage;
 546                 IoMessage_setCachedArg_toInt_(m, 0, vv);
 547                 IoGLUT_tryCallback(proto, m);
 548         }
 549         IoState_popRetainPool(state);
 550 }
 551
 552 IoObject *IoGLUT_glutTimerFunc(IoGLUT *self, IoObject *locals, IoMessage *m)
 553 {
 554         unsigned int msecs = IoMessage_locals_longArgAt_(m, locals, 0);
 555         int v = IoMessage_locals_intArgAt_(m, locals, 1);
 556         //printf("IoGLUT_glutTimerFunc msecs %i v %i\n", msecs, v);
 557         glutTimerFunc((unsigned int)msecs, IoGlutTimerFunc, v);
 558         return self;
 559 }
 560
 561 IoObject *IoGLUT_tryCallback(IoGLUT *self, IoMessage *m)
 562 {
 563         IoState *state = IoObject_state(proto);
 564         IoObject *tryCoro = DATA(self)->coroutine;
 565         IoObject *t = DATA(proto)->eventTarget;
 566         IoObject *result = state->ioNil;
 567
 568         //printf("IoGLUT_tryCallback(self, %p)\n", (void *)m);
 569
 570         if (t)
 571         {
 572                 //result = IoState_tryToPerform(state, t, t, m);
 573
 574
 575                 //IoCoroutine_try(tryCoro, t, t, m);
 576                 IoMessage_locals_performOn_(m, t, t);
 577
 578                 if (IoCoroutine_rawException(tryCoro) != state->ioNil)
 579                 {
 580                         IoState_exception_(state, tryCoro);
 581                 }
 582
 583                 IoCoroutine_clearStack(tryCoro);
 584                 return IoCoroutine_rawResult(tryCoro);
 585         }
 586
 587         return result;
 588 }
 589
 590 #ifdef GLUT_KEY_REPEAT_ON
 591 IoObject *IoGLUT_glutIgnoreKeyRepeat(IoGLUT *self, IoObject *locals, IoMessage *m)
 592 {
 593         int v = IoMessage_locals_intArgAt_(m, locals, 0);
 594         glutIgnoreKeyRepeat(v);
 595         return self;
 596 }
 597 #endif
 598
 599 IoObject *IoGLUT_glutMainLoop(IoGLUT *self, IoObject *locals, IoMessage *m)
 600 {
 601         glutMainLoop();
 602         return self;
 603 }
 604
 605 IoObject *IoGLUT_glutPostRedisplay(IoGLUT *self, IoObject *locals, IoMessage *m)
 606 {
 607         glutPostRedisplay();
 608         return self;
 609 }
 610
 611 IoObject *IoGLUT_glutSwapBuffers(IoGLUT *self, IoObject *locals, IoMessage *m)
 612 {
 613         glutSwapBuffers();
 614         return self;
 615 }
 616
 617 IoObject *IoGLUT_glutSolidCone(IoGLUT *self, IoObject *locals, IoMessage *m)
 618 {
 619         GLdouble radius = IoMessage_locals_doubleArgAt_(m, locals, 0);
 620         GLdouble height = IoMessage_locals_intArgAt_(m, locals, 1);
 621         GLint slices = IoMessage_locals_intArgAt_(m, locals, 2);
 622         GLint stacks = IoMessage_locals_intArgAt_(m, locals, 3);
 623         glutSolidCone(radius, height, slices, stacks);
 624         return self;
 625 }
 626
 627 IoObject *IoGLUT_glutWireCone(IoGLUT *self, IoObject *locals, IoMessage *m)
 628 {
 629         GLdouble radius = IoMessage_locals_doubleArgAt_(m, locals, 0);
 630         GLdouble height = IoMessage_locals_intArgAt_(m, locals, 1);
 631         GLint slices = IoMessage_locals_intArgAt_(m, locals, 2);
 632         GLint stacks = IoMessage_locals_intArgAt_(m, locals, 3);
 633         glutWireCone(radius, height, slices, stacks);
 634         return self;
 635 }
 636
 637 IoObject *IoGLUT_glutSolidSphere(IoGLUT *self, IoObject *locals, IoMessage *m)
 638 {
 639         GLdouble radius = IoMessage_locals_doubleArgAt_(m, locals, 0);
 640         GLint slices = IoMessage_locals_intArgAt_(m, locals, 1);
 641         GLint stacks = IoMessage_locals_intArgAt_(m, locals, 2);
 642         glutSolidSphere(radius, slices, stacks);
 643         return self;
 644 }
 645
 646 IoObject *IoGLUT_glutWireSphere(IoGLUT *self, IoObject *locals, IoMessage *m)
 647 {
 648         GLdouble radius = IoMessage_locals_doubleArgAt_(m, locals, 0);
 649         GLint slices = IoMessage_locals_intArgAt_(m, locals, 1);
 650         GLint stacks = IoMessage_locals_intArgAt_(m, locals, 2);
 651         glutWireSphere(radius, slices, stacks);
 652         return self;
 653 }
 654
 655 IoObject *IoGLUT_glutSolidTorus(IoGLUT *self, IoObject *locals, IoMessage *m)
 656 {
 657         GLdouble innerRadius = IoMessage_locals_doubleArgAt_(m, locals, 0);
 658         GLdouble outerRadius = IoMessage_locals_doubleArgAt_(m, locals, 1);
 659         GLint nsides = IoMessage_locals_intArgAt_(m, locals, 2);
 660         GLint rings = IoMessage_locals_intArgAt_(m, locals, 3);
 661         glutSolidTorus(innerRadius, outerRadius, nsides, rings);
 662         return self;
 663 }
 664
 665 IoObject *IoGLUT_glutWireTorus(IoGLUT *self, IoObject *locals, IoMessage *m)
 666 {
 667         GLdouble innerRadius = IoMessage_locals_doubleArgAt_(m, locals, 0);
 668         GLdouble outerRadius = IoMessage_locals_doubleArgAt_(m, locals, 1);
 669         GLint nsides = IoMessage_locals_intArgAt_(m, locals, 2);
 670         GLint rings = IoMessage_locals_intArgAt_(m, locals, 3);
 671         glutWireTorus(innerRadius, outerRadius, nsides, rings);
 672         return self;
 673 }
 674
 675 IoObject *IoGLUT_glutSolidDodecahedron(IoGLUT *self, IoObject *locals, IoMessage *m)
 676 {
 677         glutSolidDodecahedron();
 678         return self;
 679 }
 680
 681 IoObject *IoGLUT_glutWireDodecahedron(IoGLUT *self, IoObject *locals, IoMessage *m)
 682 {
 683         glutWireDodecahedron();
 684         return self;
 685 }
 686
 687 IoObject *IoGLUT_glutSolidOctahedron(IoGLUT *self, IoObject *locals, IoMessage *m)
 688 {
 689         glutSolidOctahedron();
 690         return self;
 691 }
 692
 693 IoObject *IoGLUT_glutWireOctahedron(IoGLUT *self, IoObject *locals, IoMessage *m)
 694 {
 695         glutWireOctahedron();
 696         return self;
 697 }
 698
 699 IoObject *IoGLUT_glutSolidTetrahedron(IoGLUT *self, IoObject *locals, IoMessage *m)
 700 {
 701         glutSolidTetrahedron();
 702         return self;
 703 }
 704
 705 IoObject *IoGLUT_glutWireTetrahedron(IoGLUT *self, IoObject *locals, IoMessage *m)
 706 {
 707         glutWireTetrahedron();
 708         return self;
 709 }
 710
 711 IoObject *IoGLUT_glutSolidIcosahedron(IoGLUT *self, IoObject *locals, IoMessage *m)
 712 {
 713         glutSolidIcosahedron();
 714         return self;
 715 }
 716
 717 IoObject *IoGLUT_glutWireIcosahedron(IoGLUT *self, IoObject *locals, IoMessage *m)
 718 {
 719         glutWireIcosahedron();
 720         return self;
 721 }
 722
 723 IoObject *IoGLUT_glutSolidTeapot(IoGLUT *self, IoObject *locals, IoMessage *m)
 724 {
 725         GLdouble r = IoMessage_locals_doubleArgAt_(m, locals, 0);
 726         glutSolidTeapot(r);
 727         return self;
 728 }
 729
 730 IoObject *IoGLUT_glutWireTeapot(IoGLUT *self, IoObject *locals, IoMessage *m)
 731 {
 732         GLdouble r = IoMessage_locals_doubleArgAt_(m, locals, 0);
 733         glutWireTeapot(r);
 734         return self;
 735 }
 736
 737 IoObject *IoGLUT_glutSolidCube(IoGLUT *self, IoObject *locals, IoMessage *m)
 738 {
 739         GLdouble radius = IoMessage_locals_doubleArgAt_(m, locals, 0);
 740         glutSolidCube(radius);
 741         return self;
 742 }
 743
 744 IoObject *IoGLUT_glutWireCube(IoGLUT *self, IoObject *locals, IoMessage *m)
 745 {
 746         GLdouble radius = IoMessage_locals_doubleArgAt_(m, locals, 0);
 747         glutWireCube(radius);
 748         return self;
 749 }
 750
 751 IoObject *IoGLUT_glutStrokeCharacter(IoGLUT *self, IoObject *locals, IoMessage *m)
 752 {
 753         int fontNum = IoMessage_locals_intArgAt_(m, locals, 0);
 754         char c = IoMessage_locals_intArgAt_(m, locals, 1);
 755         void *font = GLUT_STROKE_ROMAN;
 756         if (fontNum) font = GLUT_STROKE_MONO_ROMAN;
 757         glutStrokeCharacter(font, c);
 758         return self;
 759 }
 760
 761 IoObject *IoGLUT_glutStrokeString(IoGLUT *self, IoObject *locals, IoMessage *m)
 762 {
 763         int fontNum = IoMessage_locals_intArgAt_(m, locals, 0);
 764         IoSymbol *string = IoMessage_locals_seqArgAt_(m, locals, 1);
 765         char *s = CSTRING(string);
 766         void *font = GLUT_STROKE_ROMAN;
 767         if (fontNum) font = GLUT_STROKE_MONO_ROMAN;
 768
 769         while (*s)
 770         {
 771                 glutStrokeCharacter(font, *s);
 772                 s++;
 773         }
 774
 775         return self;
 776 }
 777
 778 /* --- GLUT game mode ----------------------------------------------------- */
 779
 780 IoObject *IoGLUT_glutFullScreen(IoGLUT *self, IoObject *locals, IoMessage *m)
 781 {
 782         glutFullScreen();
 783         return self;
 784 }
 785
 786 #ifdef GLUT_GAME_MODE_ACTIVE
 787
 788 IoObject *IoGLUT_glutEnterGameMode(IoGLUT *self, IoObject *locals, IoMessage *m)
 789 {
 790         glutEnterGameMode();
 791         return self;
 792 }
 793
 794 IoObject *IoGLUT_glutLeaveGameMode(IoGLUT *self, IoObject *locals, IoMessage *m)
 795 {
 796         glutLeaveGameMode();
 797         return self;
 798 }
 799
 800 IoObject *IoGLUT_glutWarpPointer(IoGLUT *self, IoObject *locals, IoMessage *m)
 801 {
 802         int x = IoMessage_locals_intArgAt_(m, locals, 0);
 803         int y = IoMessage_locals_intArgAt_(m, locals, 1);
 804         glutWarpPointer(x, y);
 805         return self;
 806 }
 807
 808 IoObject *IoGLUT_glutGameModeString(IoGLUT *self, IoObject *locals, IoMessage *m)
 809 {
 810         IoSymbol *s = IoMessage_locals_symbolArgAt_(m, locals, 0);
 811         glutGameModeString(IoSeq_asCString(s));
 812         return self;
 813 }
 814
 815 #endif
 816
 817 IoObject *IoGLUT_glutSetCursor(IoGLUT *self, IoObject *locals, IoMessage *m)
 818 {
 819         int x = IoMessage_locals_intArgAt_(m, locals, 0);
 820         glutSetCursor(x);
 821         return self;
 822 }
 823
 824 // Menus --------------------------------------------------------------------
 825
 826 void IoGlutMenuFunc(int menuId)
 827 {
 828         IoState_pushRetainPool(IoObject_state(proto));
 829
 830         {
 831                 IoMessage_setCachedArg_toInt_(DATA(proto)->menuMessage, 0, menuId);
 832                 IoGLUT_tryCallback(proto, DATA(proto)->menuMessage);
 833         }
 834
 835         IoState_popRetainPool(IoObject_state(proto));
 836 }
 837
 838 IoObject *IoGLUT_glutCreateMenu(IoGLUT *self, IoObject *locals, IoMessage *m)
 839 {
 840         int menuId = glutCreateMenu(IoGlutMenuFunc);
 841         return IONUMBER(menuId);
 842 }
 843
 844 IoObject *IoGLUT_glutSetMenu(IoGLUT *self, IoObject *locals, IoMessage *m)
 845 {
 846         int menuId = IoMessage_locals_intArgAt_(m, locals, 0);
 847         glutSetMenu(menuId);
 848         return self;
 849 }
 850
 851 IoObject *IoGLUT_glutGetMenu(IoGLUT *self, IoObject *locals, IoMessage *m)
 852 {
 853         return IONUMBER(glutGetMenu());
 854 }
 855
 856 IoObject *IoGLUT_glutDestroyMenu(IoGLUT *self, IoObject *locals, IoMessage *m)
 857 {
 858         int menuId = IoMessage_locals_intArgAt_(m, locals, 0);
 859         glutDestroyMenu(menuId);
 860         return self;
 861 }
 862
 863 IoObject *IoGLUT_glutAddMenuEntry(IoGLUT *self, IoObject *locals, IoMessage *m)
 864 {
 865         IoSymbol *name = IoMessage_locals_symbolArgAt_(m, locals, 0);
 866         int entryId = IoMessage_locals_intArgAt_(m, locals, 1);
 867         glutAddMenuEntry(CSTRING(name), entryId);
 868         return self;
 869 }
 870
 871 IoObject *IoGLUT_glutAddSubMenu(IoGLUT *self, IoObject *locals, IoMessage *m)
 872 {
 873         IoSymbol *name = IoMessage_locals_symbolArgAt_(m, locals, 0);
 874         int entryId = IoMessage_locals_intArgAt_(m, locals, 1);
 875         glutAddSubMenu(CSTRING(name), entryId);
 876         return self;
 877 }
 878
 879 IoObject *IoGLUT_glutChangeToMenuEntry(IoGLUT *self, IoObject *locals, IoMessage *m)
 880 {
 881         int entryId = IoMessage_locals_intArgAt_(m, locals, 0);
 882         IoSymbol *name = IoMessage_locals_symbolArgAt_(m, locals, 1);
 883         int value = IoMessage_locals_intArgAt_(m, locals, 2);
 884         glutChangeToMenuEntry(entryId, CSTRING(name), value);
 885         return self;
 886 }
 887
 888 // GLUT_MENU_NUM_ITEMS
 889
 890 IoObject *IoGLUT_glutChangeToSubMenu(IoGLUT *self, IoObject *locals, IoMessage *m)
 891 {
 892         int entryId = IoMessage_locals_intArgAt_(m, locals, 0);
 893         IoSymbol *name = IoMessage_locals_symbolArgAt_(m, locals, 1);
 894         int value = IoMessage_locals_intArgAt_(m, locals, 2);
 895         glutChangeToSubMenu(entryId, CSTRING(name), value);
 896         return self;
 897 }
 898
 899 IoObject *IoGLUT_glutRemoveMenuItem(IoGLUT *self, IoObject *locals, IoMessage *m)
 900 {
 901         int entry = IoMessage_locals_intArgAt_(m, locals, 0);
 902         glutRemoveMenuItem(entry);
 903         return self;
 904 }
 905
 906 IoObject *IoGLUT_glutAttachMenu(IoGLUT *self, IoObject *locals, IoMessage *m)
 907 {
 908         int button = IoMessage_locals_intArgAt_(m, locals, 0);
 909         glutAttachMenu(button);
 910         return self;
 911 }
 912
 913 IoObject *IoGLUT_glutDetachMenu(IoGLUT *self, IoObject *locals, IoMessage *m)
 914 {
 915         int button = IoMessage_locals_intArgAt_(m, locals, 0);
 916         glutAttachMenu(button);
 917         return self;
 918 }
 919
 920 // Joystick --------------------------------------------------------------------
 921
 922 void IoGlutJoystickFunc(unsigned int buttonMask, int x, int y, int z)
 923 {
 924         UArray *j = IoSeq_rawUArray(DATA(proto)->j);
 925         UArray *lastJ = DATA(proto)->lastJ;
 926         vec3f v = (vec3f){x, y, z};
 927
 928         IoSeq_setVec3f_(DATA(proto)->j, v);
 929         UArray_subtract_(lastJ, j);
 930
 931         if (DATA(proto)->lastJoystickButton != buttonMask || UArray_sumAsDouble(lastJ) != 0.0) // only send callback if a change occurs
 932         {
 933                 //printf("sum %f\n", (float)Vector_sum(lastJ));
 934                 //printf("b %i %i\n", (int)buttonMask, (int)DATA(proto)->lastJoystickButton);
 935                 IoState_pushRetainPool(IoObject_state(proto));
 936
 937                 {
 938                         IoMessage_setCachedArg_toInt_(DATA(proto)->joystickMessage, 0, (int)buttonMask);
 939                         IoMessage_setCachedArg_to_(DATA(proto)->joystickMessage, 1, DATA(proto)->j);
 940                         IoGLUT_tryCallback(proto, DATA(proto)->joystickMessage);
 941                 }
 942
 943                 DATA(proto)->lastJoystickButton = buttonMask;
 944
 945                 IoState_popRetainPool(IoObject_state(proto));
 946         }
 947
 948         UArray_copy_(lastJ, j);
 949 }
 950
 951 /*
 952 IoObject *IoGLUT_glutInitJoystick(IoGLUT *self, IoObject *locals, IoMessage *m)
 953 {
 954         IoSymbol *deviceName = IoMessage_locals_symbolArgAt_(m, locals, 0);
 955         // deviceName something like /dev/input/js0
 956         glutInitJoystick(IoGlutJoystickFunc, CSTRING(deviceName));
 957         return self;
 958 }
 959 */
 960 IoObject *IoGLUT_glutJoystickFunc(IoGLUT *self, IoObject *locals, IoMessage *m)
 961 {
 962         int pollInterval = IoMessage_locals_intArgAt_(m, locals, 0);
 963         glutJoystickFunc(IoGlutJoystickFunc, pollInterval);
 964         return self;
 965 }
 966
 967
 968 /* -------------------------------------------------------------------*/
 969
 970 /* can use NULL tag since the methods don't access DATA(self) - they use DATA(proto) instead */
 971 #define IOCFUNCTION_GLUT(func) IOCFUNCTION(func, NULL)
 972
 973 #include "IoGLUTconst.h"
 974 #include "IoGLUTfunc.h"
 975
 976 void IoGLUT_protoInit(IoGLUT *self)
 977 {
 978         IoObject_setSlot_to_(self,IOSYMBOL("clone"), IOCFUNCTION_GLUT(IoObject_self));
 979
 980         /* GLUT Constants */
 981         {
 982                 t_ioGLUT_constTable *curpos=ioGLUT_constTable;
 983                 while (curpos->name)
 984                 {
 985                         IoObject_setSlot_to_(self,
 986                                                                  IOSYMBOL(curpos->name),
 987                                                                  IONUMBER(curpos->value));
 988                         curpos++;
 989                 }
 990         }
 991
 992         /* GLUT Functions */
 993         {
 994                 t_ioGLUT_funcTable *curpos=ioGLUT_funcTable;
 995
 996                 while (curpos->name)
 997                 {
 998                         IoCFunction *f = IoCFunction_newWithFunctionPointer_tag_name_(IOSTATE, curpos->func, NULL, curpos->name);
 999                         IoObject_setSlot_to_(self, IOSYMBOL(curpos->name), f);
1000                         curpos++;
1001                 }
1002         }
1003 }
1004
1005 // --- Extra In --------------------------------------------------------------
1006
1007 int IoGlutAcceptsDropFunc(
1008                                                   int x,
1009                                                   int y,
1010                                                   const char *type,
1011                                                   const unsigned char *data,
1012                                                   int dataLength)
1013 {
1014         int result = 0;
1015         IoState *state = IoObject_state(proto);
1016         IoState_pushRetainPool(state);
1017
1018         {
1019                 IoMessage *m = DATA(proto)->acceptsDropMessage;
1020                 IoSymbol *typeString = IoState_symbolWithCString_(state, (char *)type);
1021                 IoSeq *dataBuffer = IoSeq_newWithData_length_(state, (unsigned char *)data, dataLength);
1022
1023                 IoMessage_setCachedArg_toInt_(m, 0, x);
1024                 IoMessage_setCachedArg_toInt_(m, 1, y);
1025                 IoMessage_setCachedArg_to_(m, 2, typeString);
1026                 IoMessage_setCachedArg_to_(m, 3, dataBuffer);
1027
1028                 if (DATA(proto)->eventTarget)
1029                 {
1030                         IoObject *r = IoGLUT_tryCallback(proto, m);
1031 ;
1032                         if (r && ISNUMBER(r))
1033                         {
1034                                 result = CNUMBER(r);
1035                         }
1036                 }
1037         }
1038
1039         IoState_popRetainPool(state);
1040         return result;
1041 }
1042
1043 void IoGlutDropFunc(
1044                                 int x,
1045                                 int y,
1046                                 const char *type,
1047                                 const unsigned char *data,
1048                                 int dataLength)
1049 {
1050         IoState *state = IoObject_state(proto);
1051         IoState_pushRetainPool(state);
1052
1053         {
1054                 IoMessage *m = DATA(proto)->dropMessage;
1055                 IoSymbol *typeString = IoState_symbolWithCString_(state, (char *)type);
1056                 IoSeq *dataBuffer = IoSeq_newWithData_length_(state, (unsigned char *)data, dataLength);
1057
1058                 IoMessage_setCachedArg_toInt_(m, 0, x);
1059                 IoMessage_setCachedArg_toInt_(m, 1, y);
1060                 IoMessage_setCachedArg_to_(m, 2, typeString);
1061                 IoMessage_setCachedArg_to_(m, 3, dataBuffer);
1062
1063                 IoGLUT_tryCallback(proto, m);
1064         }
1065
1066         IoState_popRetainPool(state);
1067 }
1068
1069 void IoGlutPasteFunc(
1070                                          const char *type,
1071                                          const unsigned char *data,
1072                                          int dataLength)
1073 {
1074         IoState *state = IoObject_state(proto);
1075         IoState_pushRetainPool(state);
1076
1077         {
1078                 IoMessage *m = DATA(proto)->pasteMessage;
1079                 IoSymbol *typeString = IoState_symbolWithCString_(state, (char *)type);
1080                 IoSeq *dataBuffer = IoSeq_newWithData_length_(state, (unsigned char *)data, dataLength);
1081
1082                 IoMessage_setCachedArg_to_(m, 0, typeString);
1083                 IoMessage_setCachedArg_to_(m, 1, dataBuffer);
1084
1085                 IoGLUT_tryCallback(proto, m);
1086         }
1087
1088         IoState_popRetainPool(IoObject_state(proto));
1089 }
1090
1091 void IoGlutDeleteFunc(void)
1092 {
1093         IoState *state = IoObject_state(proto);
1094         IoState_pushRetainPool(state);
1095         IoGLUT_tryCallback(proto, DATA(proto)->deleteMessage);
1096         IoState_popRetainPool(state);
1097 }
1098
1099
1100 // --- Extra Out --------------------------------------------------------------
1101
1102 void IoGLUT_setDragCallback_(IoGLUT *self, DragCallback *func)
1103 {
1104         DATA(self)->dragCallback = func;
1105 }
1106
1107 IoObject *IoGLUT_drag(IoGLUT *self, IoObject *locals, IoMessage *m)
1108 {
1109         int x = IoMessage_locals_intArgAt_(m, locals, 0);
1110         int y = IoMessage_locals_intArgAt_(m, locals, 1);
1111         IoSymbol *type = IoMessage_locals_symbolArgAt_(m, locals, 2);
1112         IoSeq *buffer = IoMessage_locals_mutableSeqArgAt_(m, locals, 3);
1113
1114         if (DATA(self)->dragCallback)
1115         {
1116                 (DATA(self)->dragCallback)(DATA(self)->callbackContext,
1117                                                                    x,
1118                                                                    y,
1119                                                                    CSTRING(type),
1120                                                                    IoSeq_rawBytes(buffer),
1121                                                                    IoSeq_rawSize(buffer));
1122         }
1123
1124         return IONIL(self);
1125 }
1126
1127 void IoGLUT_setCopyCallback_(IoGLUT *self, CopyCallback *func)
1128 {
1129         DATA(self)->copyCallback = func;
1130 }
1131
1132 IoObject *IoGLUT_copy(IoGLUT *self, IoObject *locals, IoMessage *m)
1133 {
1134         IoSymbol *type = IoMessage_locals_symbolArgAt_(m, locals, 0);
1135         IoSeq *buffer = IoMessage_locals_mutableSeqArgAt_(m, locals, 1);
1136
1137         if (DATA(self)->copyCallback)
1138         {
1139                 (DATA(self)->copyCallback)(DATA(self)->callbackContext,
1140                                                                    CSTRING(type),
1141                                                                    IoSeq_rawBytes(buffer),
1142                                                                    IoSeq_rawSize(buffer));
1143         }
1144
1145         return IONIL(self);
1146 }
1147