addons/Cairo/source/IoCairoContext.c

   1 /*#io
   2 CairoContext ioDoc(
   3         docCopyright("Daniel Rosengren", 2007)
   4         docLicense("BSD revised")
   5         docCategory("Graphics")
   6 */
   7
   8 #include "IoCairoContext.h"
   9 #include "IoCairoSurface.h"
  10 #include "IoCairoPattern.h"
  11 #include "IoCairoMatrix.h"
  12 #include "IoCairoPath.h"
  13 #include "IoCairoRectangle.h"
  14
  15 #include "IoCairoFontFace.h"
  16 #include "IoCairoScaledFont.h"
  17 #include "IoCairoFontExtents.h"
  18 #include "IoCairoFontOptions.h"
  19 #include "IoCairoTextExtents.h"
  20 #include "IoCairoExtents.h"
  21 #include "IoCairoGlyph.h"
  22
  23 #include "IoNumber.h"
  24 #include "IoList.h"
  25 #include "tools.h"
  26
  27 #define CONTEXT(self) ((cairo_t *)IoObject_dataPointer(self))
  28 #define CHECK_STATUS(self) checkStatus_(IOSTATE, m, cairo_status(CONTEXT(self)))
  29
  30
  31 static IoTag *IoCairoContext_newTag(void *state)
  32 {
  33         IoTag *tag = IoTag_newWithName_("CairoContext");
  34         IoTag_state_(tag, state);
  35         IoTag_cloneFunc_(tag, (IoTagCloneFunc *)IoCairoContext_rawClone);
  36         IoTag_freeFunc_(tag, (IoTagFreeFunc *)IoCairoContext_free);
  37         return tag;
  38 }
  39
  40 IoCairoContext *IoCairoContext_proto(void *state)
  41 {
  42         IoObject *self = IoObject_new(state);
  43         IoObject_tag_(self, IoCairoContext_newTag(state));
  44
  45         IoState_registerProtoWithFunc_(state, self, IoCairoContext_proto);
  46
  47         {
  48                 IoMethodTable methodTable[] = {
  49                         {"create", IoCairoContext_create},
  50
  51                         {"save", IoCairoContext_save},
  52                         {"restore", IoCairoContext_restore},
  53
  54                         {"getTarget", IoCairoContext_getTarget},
  55
  56                         /* Groups */
  57
  58                         {"pushGroup", IoCairoContext_pushGroup},
  59                         {"pushGroupWithContent", IoCairoContext_pushGroupWithContent},
  60                         {"popGroup", IoCairoContext_popGroup},
  61                         {"popGroupToSource", IoCairoContext_popGroupToSource},
  62                         {"getGroupTarget", IoCairoContext_getGroupTarget},
  63
  64                         /* Source */
  65
  66                         {"setSource", IoCairoContext_setSource},
  67                         {"setSourceRGB", IoCairoContext_setSourceRGB},
  68                         {"setSourceRGBA", IoCairoContext_setSourceRGBA},
  69                         {"setSourceSurface", IoCairoContext_setSourceSurface},
  70                         {"getSource", IoCairoContext_getSource},
  71
  72                         /* Options / Properties */
  73
  74                         {"setAntialias", IoCairoContext_setAntialias},
  75                         {"getAntialias", IoCairoContext_getAntialias},
  76
  77                         {"setDash", IoCairoContext_setDash},
  78                         {"getDash", IoCairoContext_getDash},
  79                         {"getDashCount", IoCairoContext_getDashCount},
  80
  81                         {"setFillRule", IoCairoContext_setFillRule},
  82                         {"getFillRule", IoCairoContext_getFillRule},
  83
  84                         {"setLineCap", IoCairoContext_setLineCap},
  85                         {"getLineCap", IoCairoContext_getLineCap},
  86
  87                         {"setLineJoin", IoCairoContext_setLineJoin},
  88                         {"getLineJoin", IoCairoContext_getLineJoin},
  89
  90                         {"setLineWidth", IoCairoContext_setLineWidth},
  91                         {"getLineWidth", IoCairoContext_getLineWidth},
  92
  93                         {"setMiterLimit", IoCairoContext_setMiterLimit},
  94                         {"getMiterLimit", IoCairoContext_getMiterLimit},
  95
  96                         {"setOperator", IoCairoContext_setOperator},
  97                         {"getOperator", IoCairoContext_getOperator},
  98
  99                         {"setTolerance", IoCairoContext_setTolerance},
 100                         {"getTolerance", IoCairoContext_getTolerance},
 101
 102                         /* Paths */
 103
 104                         {"newPath", IoCairoContext_newPath},
 105                         {"newSubPath", IoCairoContext_newSubPath},
 106                         {"closePath", IoCairoContext_closePath},
 107                         {"appendPath", IoCairoContext_appendPath},
 108                         {"copyPath", IoCairoContext_copyPath},
 109                         {"copyPathFlat", IoCairoContext_copyPathFlat},
 110                         {"getCurrentPoint", IoCairoContext_getCurrentPoint},
 111
 112                         {"moveTo", IoCairoContext_moveTo},
 113                         {"lineTo", IoCairoContext_lineTo},
 114                         {"curveTo", IoCairoContext_curveTo},
 115                         {"relMoveTo", IoCairoContext_relMoveTo},
 116                         {"relCurveTo", IoCairoContext_relCurveTo},
 117                         {"relLineTo", IoCairoContext_relLineTo},
 118
 119                         {"rectangle", IoCairoContext_rectangle},
 120                         {"arc", IoCairoContext_arc},
 121                         {"arcNegative", IoCairoContext_arcNegative},
 122
 123                         {"textPath", IoCairoContext_textPath},
 124                         {"glyphPath", IoCairoContext_glyphPath},
 125
 126                         /* Clipping */
 127
 128                         {"clip", IoCairoContext_clip},
 129                         {"clipPreserve", IoCairoContext_clipPreserve},
 130                         {"clipExtents", IoCairoContext_clipExtents},
 131                         {"resetClip", IoCairoContext_resetClip},
 132                         {"copyClipRectangleList", IoCairoContext_copyClipRectangleList},
 133
 134                         /* Drawing */
 135
 136                         {"fill", IoCairoContext_fill},
 137                         {"fillPreserve", IoCairoContext_fillPreserve},
 138                         {"fillExtents", IoCairoContext_fillExtents},
 139                         {"inFill", IoCairoContext_inFill},
 140
 141                         {"mask", IoCairoContext_mask},
 142                         {"maskSurface", IoCairoContext_maskSurface},
 143
 144                         {"paint", IoCairoContext_paint},
 145                         {"paintWithAlpha", IoCairoContext_paintWithAlpha},
 146
 147                         {"stroke", IoCairoContext_stroke},
 148                         {"strokePreserve", IoCairoContext_strokePreserve},
 149                         {"strokeExtents", IoCairoContext_strokeExtents},
 150                         {"inStroke", IoCairoContext_inStroke},
 151
 152                         /* Transformations */
 153
 154                         {"translate", IoCairoContext_translate},
 155                         {"scale", IoCairoContext_scale},
 156                         {"rotate", IoCairoContext_rotate},
 157                         {"transform", IoCairoContext_transform},
 158
 159                         {"setMatrix", IoCairoContext_setMatrix},
 160                         {"getMatrix", IoCairoContext_getMatrix},
 161                         {"identityMatrix", IoCairoContext_identityMatrix},
 162
 163                         {"userToDevice", IoCairoContext_userToDevice},
 164                         {"userToDeviceDistance", IoCairoContext_userToDeviceDistance},
 165                         {"deviceToUser", IoCairoContext_deviceToUser},
 166                         {"deviceToUserDistance", IoCairoContext_deviceToUserDistance},
 167
 168                         /* Text */
 169
 170                         {"selectFontFace", IoCairoContext_selectFontFace},
 171                         {"setFontFace", IoCairoContext_setFontFace},
 172                         {"getFontFace", IoCairoContext_getFontFace},
 173
 174                         {"setFontSize", IoCairoContext_setFontSize},
 175
 176                         {"fontExtents", IoCairoContext_fontExtents},
 177                         {"textExtents", IoCairoContext_textExtents},
 178                         {"glyphExtents", IoCairoContext_glyphExtents},
 179
 180                         {"showText", IoCairoContext_showText},
 181                         {"showGlyphs", IoCairoContext_showGlyphs},
 182
 183                         {"setScaledFont", IoCairoContext_setScaledFont},
 184                         {"getScaledFont", IoCairoContext_getScaledFont},
 185
 186                         {"setFontOptions", IoCairoContext_setFontOptions},
 187                         {"getFontOptions", IoCairoContext_getFontOptions},
 188
 189                         /* Pages */
 190
 191                         {"copyPage", IoCairoContext_copyPage},
 192                         {"showPage", IoCairoContext_showPage},
 193
 194                         {NULL, NULL},
 195                 };
 196                 IoObject_addMethodTable_(self, methodTable);
 197         }
 198         return self;
 199 }
 200
 201 IoCairoContext *IoCairoContext_rawClone(IoCairoContext *proto)
 202 {
 203         IoObject *self = IoObject_rawClonePrimitive(proto);
 204         if (CONTEXT(proto)) {
 205                 IoObject_setDataPointer_(self, cairo_reference(CONTEXT(proto)));
 206         }
 207         return self;
 208 }
 209
 210 IoCairoContext *IoCairoContext_newWithSurface_(void *state, IoCairoImageSurface *surface)
 211 {
 212         IoCairoContext *self = IOCLONE(IoState_protoWithInitFunction_(state, IoCairoContext_proto));
 213         cairo_t *rawContext = cairo_create(IoCairoSurface_rawSurface(surface));
 214         checkStatus_(state, 0, cairo_status(rawContext));
 215         IoObject_setDataPointer_(self, rawContext);
 216         return self;
 217 }
 218
 219 void IoCairoContext_free(IoCairoContext *self)
 220 {
 221         if (CONTEXT(self))
 222                 cairo_destroy(CONTEXT(self));
 223 }
 224
 225 cairo_t *IoCairoContext_getRawContext(IoCairoContext *self)
 226 {
 227         return CONTEXT(self);
 228 }
 229
 230
 231 /* ------------------------------------------------------------------------------------------------*/
 232
 233 IoObject *IoCairoContext_create(IoCairoContext *self, IoObject *locals, IoMessage *m)
 234 {
 235         return IoCairoContext_newWithSurface_(IOSTATE, IoMessage_locals_valueArgAt_(m, locals, 0));
 236 }
 237
 238
 239 IoObject *IoCairoContext_save(IoCairoContext *self, IoObject *locals, IoMessage *m)
 240 {
 241         cairo_save(CONTEXT(self));
 242         CHECK_STATUS(self);
 243         return self;
 244 }
 245
 246 IoObject *IoCairoContext_restore(IoCairoContext *self, IoObject *locals, IoMessage *m)
 247 {
 248         cairo_restore(CONTEXT(self));
 249         CHECK_STATUS(self);
 250         return self;
 251 }
 252
 253 IoObject *IoCairoContext_getTarget(IoCairoContext *self, IoObject *locals, IoMessage *m)
 254 {
 255         cairo_surface_t *target = cairo_get_target(CONTEXT(self));
 256         return IoCairoSurface_newWithRawSurface_(IOSTATE, m, cairo_surface_reference(target));
 257 }
 258
 259
 260 /* ------------------------------------------------------------------------------------------------*/
 261 /* Source */
 262
 263 IoObject *IoCairoContext_setSource(IoCairoContext *self, IoObject *locals, IoMessage *m)
 264 {
 265         IoCairoPattern *pattern = IoMessage_locals_valueArgAt_(m, locals, 0);
 266         cairo_set_source(CONTEXT(self), IoCairoPattern_rawPattern(pattern));
 267         CHECK_STATUS(self);
 268         return self;
 269 }
 270
 271 IoObject *IoCairoContext_setSourceRGB(IoCairoContext *self, IoObject *locals, IoMessage *m)
 272 {
 273         double r = IoMessage_locals_doubleArgAt_(m, locals, 0);
 274         double g = IoMessage_locals_doubleArgAt_(m, locals, 1);
 275         double b = IoMessage_locals_doubleArgAt_(m, locals, 2);
 276
 277         cairo_set_source_rgb(CONTEXT(self), r, g, b);
 278         CHECK_STATUS(self);
 279         return self;
 280 }
 281
 282 IoObject *IoCairoContext_setSourceRGBA(IoCairoContext *self, IoObject *locals, IoMessage *m)
 283 {
 284         double r = IoMessage_locals_doubleArgAt_(m, locals, 0);
 285         double g = IoMessage_locals_doubleArgAt_(m, locals, 1);
 286         double b = IoMessage_locals_doubleArgAt_(m, locals, 2);
 287         double a = IoMessage_locals_doubleArgAt_(m, locals, 3);
 288
 289         cairo_set_source_rgba(CONTEXT(self), r, g, b, a);
 290         CHECK_STATUS(self);
 291         return self;
 292 }
 293
 294 IoObject *IoCairoContext_setSourceSurface(IoCairoContext *self, IoObject *locals, IoMessage *m)
 295 {
 296         IoCairoSurface *surface = IoMessage_locals_valueArgAt_(m, locals, 0);
 297         double x = IoMessage_locals_doubleArgAt_(m, locals, 1);
 298         double y = IoMessage_locals_doubleArgAt_(m, locals, 2);
 299
 300         cairo_set_source_surface(CONTEXT(self), IoCairoSurface_rawSurface(surface), x, y);
 301         CHECK_STATUS(self);
 302         return self;
 303 }
 304
 305 IoObject *IoCairoContext_getSource(IoCairoContext *self, IoObject *locals, IoMessage *m)
 306 {
 307         cairo_pattern_t *pattern = cairo_get_source(CONTEXT(self));
 308         return IoCairoPattern_newWithRawPattern_(IOSTATE, m, cairo_pattern_reference(pattern));
 309 }
 310
 311
 312 /* ------------------------------------------------------------------------------------------------*/
 313 /* Groups */
 314
 315 IoObject *IoCairoContext_pushGroup(IoCairoContext *self, IoObject *locals, IoMessage *m)
 316 {
 317         cairo_push_group(CONTEXT(self));
 318         CHECK_STATUS(self);
 319         return self;
 320 }
 321
 322 IoObject *IoCairoContext_pushGroupWithContent(IoCairoContext *self, IoObject *locals, IoMessage *m)
 323 {
 324         cairo_push_group_with_content(CONTEXT(self), IoMessage_locals_intArgAt_(m, locals, 0));
 325         CHECK_STATUS(self);
 326         return self;
 327 }
 328
 329 IoObject *IoCairoContext_popGroup(IoCairoContext *self, IoObject *locals, IoMessage *m)
 330 {
 331         cairo_pattern_t *pattern = cairo_pop_group(CONTEXT(self));
 332         return IoCairoPattern_newWithRawPattern_(IOSTATE, m, cairo_pattern_reference(pattern));
 333 }
 334
 335 IoObject *IoCairoContext_popGroupToSource(IoCairoContext *self, IoObject *locals, IoMessage *m)
 336 {
 337         cairo_pop_group_to_source(CONTEXT(self));
 338         CHECK_STATUS(self);
 339         return self;
 340 }
 341
 342 IoObject *IoCairoContext_getGroupTarget(IoCairoContext *self, IoObject *locals, IoMessage *m)
 343 {
 344         cairo_surface_t *target = cairo_get_group_target(CONTEXT(self));
 345         return IoCairoSurface_newWithRawSurface_(IOSTATE, m, cairo_surface_reference(target));
 346 }
 347
 348
 349 /* ------------------------------------------------------------------------------------------------*/
 350 /* Options/Properties */
 351
 352 IoObject *IoCairoContext_setAntialias(IoCairoContext *self, IoObject *locals, IoMessage *m)
 353 {
 354         cairo_set_antialias(CONTEXT(self), IoMessage_locals_intArgAt_(m, locals, 0));
 355         CHECK_STATUS(self);
 356         return self;
 357 }
 358
 359 IoObject *IoCairoContext_getAntialias(IoCairoContext *self, IoObject *locals, IoMessage *m)
 360 {
 361         return IONUMBER(cairo_get_antialias(CONTEXT(self)));
 362 }
 363
 364
 365 IoObject *IoCairoContext_setDash(IoCairoContext *self, IoObject *locals, IoMessage *m)
 366 {
 367         IoList *dashList = IoMessage_locals_valueArgAt_(m, locals, 0);
 368         double offset = IoMessage_locals_doubleArgAt_(m, locals, 1);
 369         List *list = 0;
 370         int dashCount = 0;
 371         double *dashes = 0;
 372
 373         if (!ISNIL(dashList)) {
 374                 list = IoList_rawList(dashList);
 375                 dashCount = List_size(list);
 376         }
 377
 378         if (dashCount > 0)
 379         {
 380                 dashes = malloc(sizeof(double) * dashCount);
 381                 LIST_FOREACH(list, i, number,
 382                         dashes[i] = IoNumber_asDouble(number);
 383                 );
 384         }
 385
 386         cairo_set_dash(CONTEXT(self), dashes, dashCount, offset);
 387         if (dashes)
 388                 free(dashes);
 389
 390         CHECK_STATUS(self);
 391         return self;
 392 }
 393
 394 IoObject *IoCairoContext_getDash(IoCairoContext *self, IoObject *locals, IoMessage *m)
 395 {
 396         IoList *list = IoList_new(IOSTATE);
 397         IoList *dashList = IoList_new(IOSTATE);
 398         int dashCount = cairo_get_dash_count(CONTEXT(self));
 399         double *dashes = 0;
 400         double offset = 0;
 401         int i;
 402
 403         IoList_rawAppend_(list, dashList);
 404
 405         if (dashCount == 0)
 406         {
 407                 IoList_rawAppend_(list, IONUMBER(0));
 408                 return list;
 409         }
 410
 411         dashes = malloc(sizeof(double) * dashCount);
 412         cairo_get_dash(CONTEXT(self), dashes, &offset);
 413         for (i = 0; i < dashCount; i++)
 414                 IoList_rawAppend_(dashList, IONUMBER(dashes[i]));
 415         free(dashes);
 416
 417         CHECK_STATUS(self);
 418         IoList_rawAppend_(list, IONUMBER(offset));
 419         return list;
 420 }
 421
 422 IoObject *IoCairoContext_getDashCount(IoCairoContext *self, IoObject *locals, IoMessage *m)
 423 {
 424         return IONUMBER(cairo_get_dash_count(CONTEXT(self)));
 425 }
 426
 427
 428 IoObject *IoCairoContext_setFillRule(IoCairoContext *self, IoObject *locals, IoMessage *m)
 429 {
 430         cairo_set_fill_rule(CONTEXT(self), IoMessage_locals_intArgAt_(m, locals, 0));
 431         CHECK_STATUS(self);
 432         return self;
 433 }
 434
 435 IoObject *IoCairoContext_getFillRule(IoCairoContext *self, IoObject *locals, IoMessage *m)
 436 {
 437         return IONUMBER(cairo_get_fill_rule(CONTEXT(self)));
 438 }
 439
 440
 441 IoObject *IoCairoContext_setLineCap(IoCairoContext *self, IoObject *locals, IoMessage *m)
 442 {
 443         cairo_set_line_cap(CONTEXT(self), IoMessage_locals_intArgAt_(m, locals, 0));
 444         CHECK_STATUS(self);
 445         return self;
 446 }
 447
 448 IoObject *IoCairoContext_getLineCap(IoCairoContext *self, IoObject *locals, IoMessage *m)
 449 {
 450         return IONUMBER(cairo_get_line_cap(CONTEXT(self)));
 451 }
 452
 453
 454 IoObject *IoCairoContext_setLineJoin(IoCairoContext *self, IoObject *locals, IoMessage *m)
 455 {
 456         cairo_set_line_join(CONTEXT(self), IoMessage_locals_intArgAt_(m, locals, 0));
 457         CHECK_STATUS(self);
 458         return self;
 459 }
 460
 461 IoObject *IoCairoContext_getLineJoin(IoCairoContext *self, IoObject *locals, IoMessage *m)
 462 {
 463         return IONUMBER(cairo_get_line_join(CONTEXT(self)));
 464 }
 465
 466
 467 IoObject *IoCairoContext_setLineWidth(IoCairoContext *self, IoObject *locals, IoMessage *m)
 468 {
 469         cairo_set_line_width(CONTEXT(self), IoMessage_locals_doubleArgAt_(m, locals, 0));
 470         CHECK_STATUS(self);
 471         return self;
 472 }
 473
 474 IoObject *IoCairoContext_getLineWidth(IoCairoContext *self, IoObject *locals, IoMessage *m)
 475 {
 476         return IONUMBER(cairo_get_line_width(CONTEXT(self)));
 477 }
 478
 479
 480 IoObject *IoCairoContext_setMiterLimit(IoCairoContext *self, IoObject *locals, IoMessage *m)
 481 {
 482         cairo_set_miter_limit(CONTEXT(self), IoMessage_locals_doubleArgAt_(m, locals, 0));
 483         CHECK_STATUS(self);
 484         return self;
 485 }
 486
 487 IoObject *IoCairoContext_getMiterLimit(IoCairoContext *self, IoObject *locals, IoMessage *m)
 488 {
 489         return IONUMBER(cairo_get_miter_limit(CONTEXT(self)));
 490 }
 491
 492
 493 IoObject *IoCairoContext_setOperator(IoCairoContext *self, IoObject *locals, IoMessage *m)
 494 {
 495         cairo_set_operator(CONTEXT(self), IoMessage_locals_intArgAt_(m, locals, 0));
 496         CHECK_STATUS(self);
 497         return self;
 498 }
 499
 500 IoObject *IoCairoContext_getOperator(IoCairoContext *self, IoObject *locals, IoMessage *m)
 501 {
 502         return IONUMBER(cairo_get_operator(CONTEXT(self)));
 503 }
 504
 505
 506 IoObject *IoCairoContext_setTolerance(IoCairoContext *self, IoObject *locals, IoMessage *m)
 507 {
 508         cairo_set_tolerance(CONTEXT(self), IoMessage_locals_doubleArgAt_(m, locals, 0));
 509         CHECK_STATUS(self);
 510         return self;
 511 }
 512
 513 IoObject *IoCairoContext_getTolerance(IoCairoContext *self, IoObject *locals, IoMessage *m)
 514 {
 515         return IONUMBER(cairo_get_tolerance(CONTEXT(self)));
 516 }
 517
 518
 519 /* ------------------------------------------------------------------------------------------------*/
 520 /* Paths */
 521
 522 IoObject *IoCairoContext_newPath(IoCairoContext *self, IoObject *locals, IoMessage *m)
 523 {
 524         cairo_new_path(CONTEXT(self));
 525         CHECK_STATUS(self);
 526         return self;
 527 }
 528
 529 IoObject *IoCairoContext_newSubPath(IoCairoContext *self, IoObject *locals, IoMessage *m)
 530 {
 531         cairo_new_sub_path(CONTEXT(self));
 532         CHECK_STATUS(self);
 533         return self;
 534 }
 535
 536 IoObject *IoCairoContext_closePath(IoCairoContext *self, IoObject *locals, IoMessage *m)
 537 {
 538         cairo_close_path(CONTEXT(self));
 539         CHECK_STATUS(self);
 540         return self;
 541 }
 542
 543 IoObject *IoCairoContext_appendPath(IoCairoContext *self, IoObject *locals, IoMessage *m)
 544 {
 545         IoCairoPath *path = IoMessage_locals_cairoPathArgAt_(m, locals, 0);
 546         cairo_append_path(CONTEXT(self), IoCairoPath_rawPath(path));
 547         CHECK_STATUS(self);
 548         return self;
 549 }
 550
 551 IoObject *IoCairoContext_copyPath(IoCairoContext *self, IoObject *locals, IoMessage *m)
 552 {
 553         return IoCairoPath_newWithRawPath_(IOSTATE, cairo_copy_path(CONTEXT(self)));
 554 }
 555
 556 IoObject *IoCairoContext_copyPathFlat(IoCairoContext *self, IoObject *locals, IoMessage *m)
 557 {
 558         return IoCairoPath_newWithRawPath_(IOSTATE, cairo_copy_path_flat(CONTEXT(self)));
 559 }
 560
 561 IoObject *IoCairoContext_getCurrentPoint(IoCairoContext *self, IoObject *locals, IoMessage *m)
 562 {
 563         double x = 0, y = 0;
 564         cairo_get_current_point(CONTEXT(self), &x, &y);
 565         return IoSeq_newWithX_y_(IOSTATE, x, y);
 566 }
 567
 568
 569 IoObject *IoCairoContext_moveTo(IoCairoContext *self, IoObject *locals, IoMessage *m)
 570 {
 571         double x = IoMessage_locals_doubleArgAt_(m, locals, 0);
 572         double y = IoMessage_locals_doubleArgAt_(m, locals, 1);
 573
 574         cairo_move_to(CONTEXT(self), x, y);
 575         CHECK_STATUS(self);
 576         return self;
 577 }
 578
 579 IoObject *IoCairoContext_lineTo(IoCairoContext *self, IoObject *locals, IoMessage *m)
 580 {
 581         double x = IoMessage_locals_doubleArgAt_(m, locals, 0);
 582         double y = IoMessage_locals_doubleArgAt_(m, locals, 1);
 583
 584         cairo_line_to(CONTEXT(self), x, y);
 585         CHECK_STATUS(self);
 586         return self;
 587 }
 588
 589 IoObject *IoCairoContext_curveTo(IoCairoContext *self, IoObject *locals, IoMessage *m)
 590 {
 591         double x1 = IoMessage_locals_doubleArgAt_(m, locals, 0);
 592         double y1 = IoMessage_locals_doubleArgAt_(m, locals, 1);
 593         double x2 = IoMessage_locals_doubleArgAt_(m, locals, 2);
 594         double y2 = IoMessage_locals_doubleArgAt_(m, locals, 3);
 595         double x3 = IoMessage_locals_doubleArgAt_(m, locals, 4);
 596         double y3 = IoMessage_locals_doubleArgAt_(m, locals, 5);
 597
 598         cairo_curve_to(CONTEXT(self), x1, y1, x2, y2, x3, y3);
 599         CHECK_STATUS(self);
 600         return self;
 601 }
 602
 603 IoObject *IoCairoContext_relMoveTo(IoCairoContext *self, IoObject *locals, IoMessage *m)
 604 {
 605         double dx = IoMessage_locals_doubleArgAt_(m, locals, 0);
 606         double dy = IoMessage_locals_doubleArgAt_(m, locals, 1);
 607
 608         cairo_rel_move_to(CONTEXT(self), dx, dy);
 609         CHECK_STATUS(self);
 610         return self;
 611 }
 612
 613 IoObject *IoCairoContext_relLineTo(IoCairoContext *self, IoObject *locals, IoMessage *m)
 614 {
 615         double dx = IoMessage_locals_doubleArgAt_(m, locals, 0);
 616         double dy = IoMessage_locals_doubleArgAt_(m, locals, 1);
 617
 618         cairo_rel_line_to(CONTEXT(self), dx, dy);
 619         CHECK_STATUS(self);
 620         return self;
 621 }
 622
 623 IoObject *IoCairoContext_relCurveTo(IoCairoContext *self, IoObject *locals, IoMessage *m)
 624 {
 625         double dx1 = IoMessage_locals_doubleArgAt_(m, locals, 0);
 626         double dy1 = IoMessage_locals_doubleArgAt_(m, locals, 1);
 627         double dx2 = IoMessage_locals_doubleArgAt_(m, locals, 2);
 628         double dy2 = IoMessage_locals_doubleArgAt_(m, locals, 3);
 629         double dx3 = IoMessage_locals_doubleArgAt_(m, locals, 4);
 630         double dy3 = IoMessage_locals_doubleArgAt_(m, locals, 5);
 631
 632         cairo_rel_curve_to(CONTEXT(self), dx1, dy1, dx2, dy2, dx3, dy3);
 633         CHECK_STATUS(self);
 634         return self;
 635 }
 636
 637
 638 IoObject *IoCairoContext_arc(IoCairoContext *self, IoObject *locals, IoMessage *m)
 639 {
 640         double xc = IoMessage_locals_doubleArgAt_(m, locals, 0);
 641         double yc = IoMessage_locals_doubleArgAt_(m, locals, 1);
 642         double radius = IoMessage_locals_doubleArgAt_(m, locals, 2);
 643         double angle1 = IoMessage_locals_doubleArgAt_(m, locals, 3);
 644         double angle2 = IoMessage_locals_doubleArgAt_(m, locals, 4);
 645
 646         cairo_arc(CONTEXT(self), xc, yc, radius, angle1, angle2);
 647         CHECK_STATUS(self);
 648         return self;
 649 }
 650
 651 IoObject *IoCairoContext_arcNegative(IoCairoContext *self, IoObject *locals, IoMessage *m)
 652 {
 653         double xc = IoMessage_locals_doubleArgAt_(m, locals, 0);
 654         double yc = IoMessage_locals_doubleArgAt_(m, locals, 1);
 655         double radius = IoMessage_locals_doubleArgAt_(m, locals, 2);
 656         double angle1 = IoMessage_locals_doubleArgAt_(m, locals, 3);
 657         double angle2 = IoMessage_locals_doubleArgAt_(m, locals, 4);
 658
 659         cairo_arc_negative(CONTEXT(self), xc, yc, radius, angle1, angle2);
 660         CHECK_STATUS(self);
 661         return self;
 662 }
 663
 664 IoObject *IoCairoContext_rectangle(IoCairoContext *self, IoObject *locals, IoMessage *m)
 665 {
 666         double x = IoMessage_locals_doubleArgAt_(m, locals, 0);
 667         double y = IoMessage_locals_doubleArgAt_(m, locals, 1);
 668         double w = IoMessage_locals_doubleArgAt_(m, locals, 2);
 669         double h = IoMessage_locals_doubleArgAt_(m, locals, 3);
 670
 671         cairo_rectangle(CONTEXT(self), x, y, w, h);
 672         CHECK_STATUS(self);
 673         return self;
 674 }
 675
 676 IoObject *IoCairoContext_textPath(IoCairoContext *self, IoObject *locals, IoMessage *m)
 677 {
 678         cairo_text_path(CONTEXT(self), IoMessage_locals_UTF8ArgAt_(m, locals, 0));
 679         CHECK_STATUS(self);
 680         return self;
 681 }
 682
 683 IoObject *IoCairoContext_glyphPath(IoCairoContext *self, IoObject *locals, IoMessage *m)
 684 {
 685         IoList *glyphList = IoMessage_locals_listArgAt_(m, locals, 0);
 686         int glyphCount = 0;
 687         cairo_glyph_t *glyphs = rawGlyphsFromList_count_(glyphList, &glyphCount);
 688
 689         if (!glyphs)
 690                 return self;
 691
 692         cairo_glyph_path(CONTEXT(self), glyphs, glyphCount);
 693         free(glyphs);
 694         CHECK_STATUS(self);
 695         return self;
 696 }
 697
 698
 699 /* ------------------------------------------------------------------------------------------------*/
 700 /* Clipping */
 701
 702 IoObject *IoCairoContext_clip(IoCairoContext *self, IoObject *locals, IoMessage *m)
 703 {
 704         cairo_clip(CONTEXT(self));
 705         CHECK_STATUS(self);
 706         return self;
 707 }
 708
 709 IoObject *IoCairoContext_clipPreserve(IoCairoContext *self, IoObject *locals, IoMessage *m)
 710 {
 711         cairo_clip_preserve(CONTEXT(self));
 712         CHECK_STATUS(self);
 713         return self;
 714 }
 715
 716 IoObject *IoCairoContext_clipExtents(IoCairoContext *self, IoObject *locals, IoMessage *m)
 717 {
 718         double x1, y1, x2, y2;
 719         cairo_clip_extents(CONTEXT(self), &x1, &y1, &x2, &y2);
 720         return IoCairoExtents_newSet(IOSTATE, x1, y1, x2, y2);
 721 }
 722
 723 IoObject *IoCairoContext_resetClip(IoCairoContext *self, IoObject *locals, IoMessage *m)
 724 {
 725         cairo_reset_clip(CONTEXT(self));
 726         CHECK_STATUS(self);
 727         return self;
 728 }
 729
 730 IoObject *IoCairoContext_copyClipRectangleList(IoCairoContext *self, IoObject *locals, IoMessage *m)
 731 {
 732         IoList *list = IoList_new(IOSTATE);
 733         cairo_rectangle_list_t *rectList = cairo_copy_clip_rectangle_list(CONTEXT(self));
 734         cairo_rectangle_t *rect = 0;
 735         int i;
 736
 737         if (rectList->status != CAIRO_STATUS_SUCCESS)
 738                 IoState_error_(IOSTATE, m, "%s: cairo: %s", __func__, cairo_status_to_string(rectList->status));
 739
 740         rect = rectList->rectangles;
 741         for (i = 0; i < rectList->num_rectangles; i++)
 742         {
 743                 IoList_rawAppend_(list, IoCairoRectangle_newWithRawRectangle_(IOSTATE, rect));
 744                 rect++;
 745         }
 746         cairo_rectangle_list_destroy(rectList);
 747         return list;
 748 }
 749
 750
 751 /* ------------------------------------------------------------------------------------------------*/
 752 /* Drawing */
 753
 754
 755 IoObject *IoCairoContext_fill(IoCairoContext *self, IoObject *locals, IoMessage *m)
 756 {
 757         cairo_fill(CONTEXT(self));
 758         CHECK_STATUS(self);
 759         return self;
 760 }
 761
 762 IoObject *IoCairoContext_fillPreserve(IoCairoContext *self, IoObject *locals, IoMessage *m)
 763 {
 764         cairo_fill_preserve(CONTEXT(self));
 765         CHECK_STATUS(self);
 766         return self;
 767 }
 768
 769 IoObject *IoCairoContext_fillExtents(IoCairoContext *self, IoObject *locals, IoMessage *m)
 770 {
 771         double x1, y1, x2, y2;
 772         cairo_fill_extents(CONTEXT(self), &x1, &y1, &x2, &y2);
 773         return IoCairoExtents_newSet(IOSTATE, x1, y1, x2, y2);
 774 }
 775
 776 IoObject *IoCairoContext_inFill(IoCairoContext *self, IoObject *locals, IoMessage *m)
 777 {
 778         double x = IoMessage_locals_doubleArgAt_(m, locals, 0);
 779         double y = IoMessage_locals_doubleArgAt_(m, locals, 1);
 780   return IOBOOL(self, cairo_in_fill(CONTEXT(self), x, y));
 781 }
 782
 783
 784 IoObject *IoCairoContext_stroke(IoCairoContext *self, IoObject *locals, IoMessage *m)
 785 {
 786         cairo_stroke(CONTEXT(self));
 787         CHECK_STATUS(self);
 788         return self;
 789 }
 790
 791 IoObject *IoCairoContext_strokePreserve(IoCairoContext *self, IoObject *locals, IoMessage *m)
 792 {
 793         cairo_stroke_preserve(CONTEXT(self));
 794         CHECK_STATUS(self);
 795         return self;
 796 }
 797
 798 IoObject *IoCairoContext_strokeExtents(IoCairoContext *self, IoObject *locals, IoMessage *m)
 799 {
 800         double x1, y1, x2, y2;
 801         cairo_stroke_extents(CONTEXT(self), &x1, &y1, &x2, &y2);
 802         return IoCairoExtents_newSet(IOSTATE, x1, y1, x2, y2);
 803 }
 804
 805 IoObject *IoCairoContext_inStroke(IoCairoContext *self, IoObject *locals, IoMessage *m)
 806 {
 807         double x = IoMessage_locals_doubleArgAt_(m, locals, 0);
 808         double y = IoMessage_locals_doubleArgAt_(m, locals, 1);
 809   return IOBOOL(self, cairo_in_stroke(CONTEXT(self), x, y));
 810 }
 811
 812
 813 IoObject *IoCairoContext_mask(IoCairoContext *self, IoObject *locals, IoMessage *m)
 814 {
 815         IoObject *pattern = IoMessage_locals_valueArgAt_(m, locals, 0);
 816         cairo_mask(CONTEXT(self), IoCairoPattern_rawPattern(pattern));
 817         CHECK_STATUS(self);
 818         return self;
 819 }
 820
 821 IoObject *IoCairoContext_maskSurface(IoCairoContext *self, IoObject *locals, IoMessage *m)
 822 {
 823         IoCairoSurface *surface = IoMessage_locals_valueArgAt_(m, locals, 0);
 824         double x = IoMessage_locals_doubleArgAt_(m, locals, 1);
 825         double y = IoMessage_locals_doubleArgAt_(m, locals, 2);
 826
 827         cairo_mask_surface(CONTEXT(self), IoCairoSurface_rawSurface(surface), x, y);
 828         CHECK_STATUS(self);
 829         return self;
 830 }
 831
 832
 833 IoObject *IoCairoContext_paint(IoCairoContext *self, IoObject *locals, IoMessage *m)
 834 {
 835         cairo_paint(CONTEXT(self));
 836         CHECK_STATUS(self);
 837         return self;
 838 }
 839
 840 IoObject *IoCairoContext_paintWithAlpha(IoCairoContext *self, IoObject *locals, IoMessage *m)
 841 {
 842         cairo_paint_with_alpha(CONTEXT(self), IoMessage_locals_doubleArgAt_(m, locals, 0));
 843         CHECK_STATUS(self);
 844         return self;
 845 }
 846
 847
 848 /* ------------------------------------------------------------------------------------------------*/
 849 /* Transformations */
 850
 851 IoObject *IoCairoContext_translate(IoCairoContext *self, IoObject *locals, IoMessage *m)
 852 {
 853         double tx = IoMessage_locals_doubleArgAt_(m, locals, 0);
 854         double ty = IoMessage_locals_doubleArgAt_(m, locals, 1);
 855
 856         cairo_translate(CONTEXT(self), tx, ty);
 857         CHECK_STATUS(self);
 858         return self;
 859 }
 860
 861 IoObject *IoCairoContext_scale(IoCairoContext *self, IoObject *locals, IoMessage *m)
 862 {
 863         double sx = IoMessage_locals_doubleArgAt_(m, locals, 0);
 864         double sy = IoMessage_locals_doubleArgAt_(m, locals, 1);
 865
 866         cairo_scale(CONTEXT(self), sx, sy);
 867         CHECK_STATUS(self);
 868         return self;
 869 }
 870
 871 IoObject *IoCairoContext_rotate(IoCairoContext *self, IoObject *locals, IoMessage *m)
 872 {
 873         cairo_rotate(CONTEXT(self), IoMessage_locals_doubleArgAt_(m, locals, 0));
 874         CHECK_STATUS(self);
 875         return self;
 876 }
 877
 878 IoObject *IoCairoContext_transform(IoCairoContext *self, IoObject *locals, IoMessage *m)
 879 {
 880         IoCairoMatrix *matrix = IoMessage_locals_cairoMatrixArgAt_(m, locals, 0);
 881         cairo_transform(CONTEXT(self), IoCairoMatrix_rawMatrix(matrix));
 882         CHECK_STATUS(self);
 883         return self;
 884 }
 885
 886
 887 IoObject *IoCairoContext_setMatrix(IoCairoContext *self, IoObject *locals, IoMessage *m)
 888 {
 889         IoCairoMatrix *matrix = IoMessage_locals_cairoMatrixArgAt_(m, locals, 0);
 890         cairo_set_matrix(CONTEXT(self), IoCairoMatrix_rawMatrix(matrix));
 891         CHECK_STATUS(self);
 892         return self;
 893 }
 894
 895 IoObject *IoCairoContext_getMatrix(IoCairoContext *self, IoObject *locals, IoMessage *m)
 896 {
 897         cairo_matrix_t matrix;
 898         cairo_get_matrix(CONTEXT(self), &matrix);
 899         return IoCairoMatrix_newWithRawMatrix_(IOSTATE, &matrix);
 900 }
 901
 902 IoObject *IoCairoContext_identityMatrix(IoCairoContext *self, IoObject *locals, IoMessage *m)
 903 {
 904         cairo_identity_matrix(CONTEXT(self));
 905         CHECK_STATUS(self);
 906         return self;
 907 }
 908
 909
 910 IoObject *IoCairoContext_userToDevice(IoCairoContext *self, IoObject *locals, IoMessage *m)
 911 {
 912         double x = IoMessage_locals_doubleArgAt_(m, locals, 0);
 913         double y = IoMessage_locals_doubleArgAt_(m, locals, 1);
 914
 915         cairo_user_to_device(CONTEXT(self), &x, &y);
 916         CHECK_STATUS(self);
 917         return IoSeq_newWithX_y_(IOSTATE, x, y);
 918 }
 919
 920 IoObject *IoCairoContext_userToDeviceDistance(IoCairoContext *self, IoObject *locals, IoMessage *m)
 921 {
 922         double x = IoMessage_locals_doubleArgAt_(m, locals, 0);
 923         double y = IoMessage_locals_doubleArgAt_(m, locals, 1);
 924
 925         cairo_user_to_device_distance(CONTEXT(self), &x, &y);
 926         return IoSeq_newWithX_y_(IOSTATE, x, y);
 927 }
 928
 929 IoObject *IoCairoContext_deviceToUser(IoCairoContext *self, IoObject *locals, IoMessage *m)
 930 {
 931         double x = IoMessage_locals_doubleArgAt_(m, locals, 0);
 932         double y = IoMessage_locals_doubleArgAt_(m, locals, 1);
 933
 934         cairo_device_to_user(CONTEXT(self), &x, &y);
 935         return IoSeq_newWithX_y_(IOSTATE, x, y);
 936 }
 937
 938 IoObject *IoCairoContext_deviceToUserDistance(IoCairoContext *self, IoObject *locals, IoMessage *m)
 939 {
 940         double x = IoMessage_locals_doubleArgAt_(m, locals, 0);
 941         double y = IoMessage_locals_doubleArgAt_(m, locals, 1);
 942
 943         cairo_device_to_user_distance(CONTEXT(self), &x, &y);
 944         CHECK_STATUS(self);
 945         return IoSeq_newWithX_y_(IOSTATE, x, y);
 946 }
 947
 948
 949 /* ------------------------------------------------------------------------------------------------*/
 950 /* Text */
 951
 952 IoObject *IoCairoContext_setFontSize(IoCairoContext *self, IoObject *locals, IoMessage *m)
 953 {
 954         cairo_set_font_size(CONTEXT(self), IoMessage_locals_doubleArgAt_(m, locals, 0));
 955         CHECK_STATUS(self);
 956         return self;
 957 }
 958
 959
 960 IoObject *IoCairoContext_fontExtents(IoCairoContext *self, IoObject *locals, IoMessage *m)
 961 {
 962         cairo_font_extents_t extents;
 963         cairo_font_extents(CONTEXT(self), &extents);
 964         CHECK_STATUS(self);
 965         return IoCairoFontExtents_newWithRawFontExtents(IOSTATE, &extents);
 966 }
 967
 968 IoObject *IoCairoContext_textExtents(IoCairoContext *self, IoObject *locals, IoMessage *m)
 969 {
 970         const char *text = IoMessage_locals_UTF8ArgAt_(m, locals, 0);
 971         cairo_text_extents_t extents;
 972
 973         cairo_text_extents(CONTEXT(self), text, &extents);
 974         CHECK_STATUS(self);
 975         return IoCairoTextExtents_newWithRawTextExtents(IOSTATE, &extents);
 976 }
 977
 978 IoObject *IoCairoContext_glyphExtents(IoCairoContext *self, IoObject *locals, IoMessage *m)
 979 {
 980         IoList *glyphList = IoMessage_locals_listArgAt_(m, locals, 0);
 981         int glyphCount = 0;
 982         cairo_glyph_t *glyphs = rawGlyphsFromList_count_(glyphList, &glyphCount);
 983         cairo_text_extents_t extents;
 984
 985         if (!glyphs)
 986                 return IONIL(self);
 987
 988         cairo_glyph_extents(CONTEXT(self), glyphs, glyphCount, &extents);
 989         free(glyphs);
 990         CHECK_STATUS(self);
 991         return IoCairoTextExtents_newWithRawTextExtents(IOSTATE, &extents);
 992 }
 993
 994
 995 IoObject *IoCairoContext_showText(IoCairoContext *self, IoObject *locals, IoMessage *m)
 996 {
 997         cairo_show_text(CONTEXT(self), IoMessage_locals_UTF8ArgAt_(m, locals, 0));
 998         CHECK_STATUS(self);
 999         return self;
1000 }
1001
1002 IoObject *IoCairoContext_showGlyphs(IoCairoContext *self, IoObject *locals, IoMessage *m)
1003 {
1004         IoList *glyphList = IoMessage_locals_listArgAt_(m, locals, 0);
1005         int glyphCount = 0;
1006         cairo_glyph_t *glyphs = rawGlyphsFromList_count_(glyphList, &glyphCount);
1007
1008         if (!glyphs)
1009                 return self;
1010
1011         cairo_show_glyphs(CONTEXT(self), glyphs, glyphCount);
1012         free(glyphs);
1013         CHECK_STATUS(self);
1014         return self;
1015 }
1016
1017
1018 IoObject *IoCairoContext_selectFontFace(IoCairoContext *self, IoObject *locals, IoMessage *m)
1019 {
1020         char *family = CSTRING(IoMessage_locals_symbolArgAt_(m, locals, 0));
1021         cairo_font_slant_t slant = IoMessage_locals_intArgAt_(m, locals, 1);
1022         cairo_font_weight_t weight = IoMessage_locals_intArgAt_(m, locals, 2);
1023
1024         cairo_select_font_face(CONTEXT(self), family, slant, weight);
1025         CHECK_STATUS(self);
1026         return self;
1027 }
1028
1029 IoObject *IoCairoContext_setFontFace(IoCairoContext *self, IoObject *locals, IoMessage *m)
1030 {
1031         IoCairoFontFace *face = IoMessage_locals_cairoFontFaceArgAt_(m, locals, 0);
1032         cairo_set_font_face(CONTEXT(self), IoCairoFontFace_rawFontFace(face));
1033         CHECK_STATUS(self);
1034         return self;
1035 }
1036
1037 IoObject *IoCairoContext_getFontFace(IoCairoContext *self, IoObject *locals, IoMessage *m)
1038 {
1039         cairo_font_face_t *face = cairo_get_font_face(CONTEXT(self));
1040         return IoCairoFontFace_newWithRawFontFace_(self, cairo_font_face_reference(face));
1041 }
1042
1043
1044 IoObject *IoCairoContext_setScaledFont(IoCairoContext *self, IoObject *locals, IoMessage *m)
1045 {
1046         IoCairoScaledFont *font = IoMessage_locals_cairoScaledFontArgAt_(m, locals, 0);
1047         cairo_set_scaled_font(CONTEXT(self), IoCairoScaledFont_rawScaledFont(font));
1048         CHECK_STATUS(self);
1049         return self;
1050 }
1051
1052 IoObject *IoCairoContext_getScaledFont(IoCairoContext *self, IoObject *locals, IoMessage *m)
1053 {
1054         cairo_scaled_font_t *font = cairo_get_scaled_font(CONTEXT(self));
1055         return IoCairoScaledFont_newWithRawScaledFont_(IOSTATE, m, cairo_scaled_font_reference(font));
1056 }
1057
1058
1059 IoObject *IoCairoContext_setFontOptions(IoCairoContext *self, IoObject *locals, IoMessage *m)
1060 {
1061         IoCairoFontOptions *options = IoMessage_locals_cairoFontOptionsArgAt_(m, locals, 0);
1062         cairo_set_font_options(CONTEXT(self), IoCairoFontOptions_rawFontOptions(options));
1063         CHECK_STATUS(self);
1064         return self;
1065 }
1066
1067 IoObject *IoCairoContext_getFontOptions(IoCairoContext *self, IoObject *locals, IoMessage *m)
1068 {
1069         cairo_font_options_t *options = cairo_font_options_create();
1070         cairo_get_font_options(CONTEXT(self), options);
1071         return IoCairoFontOptions_newWithRawFontOptions_(IOSTATE, m, options);
1072 }
1073
1074
1075 /* ------------------------------------------------------------------------------------------------*/
1076 /* Pages */
1077
1078 IoObject *IoCairoContext_copyPage(IoCairoContext *self, IoObject *locals, IoMessage *m)
1079 {
1080         cairo_copy_page(CONTEXT(self));
1081         CHECK_STATUS(self);
1082         return self;
1083 }
1084
1085 IoObject *IoCairoContext_showPage(IoCairoContext *self, IoObject *locals, IoMessage *m)
1086 {
1087         cairo_show_page(CONTEXT(self));
1088         CHECK_STATUS(self);
1089         return self;
1090 }
1091