src/cairo/CairoPattern.c

   1
   2 /* {{{ Class CairoPattern */
   3
   4 static zend_class_entry * CairoPattern_ce_ptr = NULL;
   5
   6 /* {{{ Methods */
   7
   8
   9 /* {{{ proto void contruct()
  10    */
  11 PHP_METHOD(CairoPattern, __construct)
  12 {
  13         zval * _this_zval;
  14
  15
  16
  17         if (ZEND_NUM_ARGS()>0)  {
  18                 WRONG_PARAM_COUNT;
  19         }
  20
  21
  22         php_error(E_ERROR, "Pattern Cannot be initialized"); RETURN_FALSE;
  23
  24 }
  25 /* }}} __construct */
  26
  27
  28
  29 /* {{{ proto object getMatrix()
  30    */
  31 PHP_METHOD(CairoPattern, getMatrix)
  32 {
  33
  34         zval * _this_zval = NULL;
  35         cairo_matrix_t matrix;
  36
  37         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoPattern_ce_ptr) == FAILURE) {
  38                 return;
  39         }
  40
  41         pattern_object *curr = (pattern_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
  42
  43         cairo_pattern_get_matrix(curr->pattern, &matrix);
  44         object_init_ex(return_value, CairoMatrix_ce_ptr);
  45         matrix_object *mobj = (matrix_object *)zend_objects_get_address(return_value TSRMLS_CC);
  46         mobj->matrix = matrix;
  47 }
  48 /* }}} getMatrix */
  49
  50
  51
  52 /* {{{ proto void setMatrix(object m)
  53    */
  54 PHP_METHOD(CairoPattern, setMatrix)
  55 {
  56
  57         zval * _this_zval = NULL;
  58         zval * m = NULL;
  59
  60
  61
  62         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo", &_this_zval, CairoPattern_ce_ptr, &m) == FAILURE) {
  63                 return;
  64         }
  65
  66         pattern_object *curr = (pattern_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
  67         matrix_object *mobj = (matrix_object *)zend_objects_get_address(m TSRMLS_CC);
  68         cairo_pattern_set_matrix(curr->pattern, &mobj->matrix);
  69 }
  70 /* }}} setMatrix */
  71
  72
  73 /* {{{ proto void setExtend(int extend)
  74     */
  75 PHP_METHOD(CairoPattern, setExtend)
  76 {
  77     long extend;
  78
  79     zval * _this_zval = NULL;
  80     if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &_this_zval, CairoPattern_ce_ptr, &extend) == FAILURE) {
  81                 return;
  82     }
  83     pattern_object *curr = (pattern_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
  84     cairo_pattern_set_extend(curr->pattern, extend);
  85     PHP_CAIRO_PATTERN_ERROR(curr->pattern);
  86
  87 }
  88
  89 /* }}} setExtend */
  90
  91
  92 /* {{{ proto void getExtend()
  93     */
  94 PHP_METHOD(CairoPattern, getExtend)
  95 {
  96     long extend;
  97
  98     zval * _this_zval = NULL;
  99     if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoPattern_ce_ptr) == FAILURE) {
 100         return;
 101     }
 102     pattern_object *curr = (pattern_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 103     extend = cairo_pattern_get_extend(curr->pattern);
 104         RETURN_LONG(extend);
 105 }
 106 /* }}} setExtend */
 107
 108
 109 static zend_function_entry CairoPattern_methods[] = {
 110         PHP_ME(CairoPattern, __construct, NULL, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
 111         PHP_ME(CairoPattern, getMatrix, NULL, /**/ZEND_ACC_PUBLIC)
 112         PHP_ME(CairoPattern, setMatrix, CairoPattern__set_matrix_args, /**/ZEND_ACC_PUBLIC)
 113     PHP_ME(CairoPattern, getExtend, NULL, /**/ZEND_ACC_PUBLIC)
 114         PHP_ME(CairoPattern, setExtend, CairoPattern__set_extend_args, /**/ZEND_ACC_PUBLIC)
 115         { NULL, NULL, NULL }
 116 };
 117
 118 /* }}} Methods */
 119
 120 static zend_object_handlers CairoPattern_handlers;
 121
 122 static void CairoPattern_object_dtor(void *object)
 123 {
 124         pattern_object *pattern = (pattern_object *)object;
 125     zend_hash_destroy(pattern->std.properties);
 126     FREE_HASHTABLE(pattern->std.properties);
 127     if(pattern->pattern){
 128         cairo_pattern_destroy(pattern->pattern);
 129     }
 130     efree(object);
 131 }
 132
 133 static zend_object_value CairoPattern_object_new(zend_class_entry *ce)
 134 {
 135     zend_object_value retval;
 136     pattern_object *pattern;
 137     zval *temp;
 138     pattern=emalloc(sizeof(pattern_object));
 139     memset(pattern,0,sizeof(pattern_object));
 140     pattern->std.ce = ce;
 141     ALLOC_HASHTABLE(pattern->std.properties);
 142     zend_hash_init(pattern->std.properties, 0, NULL, ZVAL_PTR_DTOR,0);
 143     zend_hash_copy(pattern->std.properties, &ce->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &temp, sizeof(zval *));
 144     retval.handle = zend_objects_store_put(pattern, NULL, (zend_objects_free_object_storage_t)CairoPattern_object_dtor, NULL TSRMLS_CC);
 145     retval.handlers = &CairoPattern_handlers;
 146     return retval;
 147 }
 148
 149
 150 static void class_init_CairoPattern(void)
 151 {
 152         zend_class_entry ce;
 153
 154         INIT_CLASS_ENTRY(ce, "CairoPattern", CairoPattern_methods);
 155         CairoPattern_ce_ptr = zend_register_internal_class(&ce);
 156         CairoPattern_ce_ptr->create_object = CairoPattern_object_new;
 157         memcpy(&CairoPattern_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 158         CairoPattern_handlers.clone_obj = NULL;
 159 }
 160
 161 /* }}} Class CairoPattern */
 162
 163 /* {{{ Class CairoGradient */
 164
 165 static zend_class_entry * CairoGradient_ce_ptr = NULL;
 166
 167 /* {{{ Methods */
 168
 169
 170 /* {{{ proto void construct()
 171    */
 172 PHP_METHOD(CairoGradient, __construct)
 173 {
 174
 175         zval * _this_zval = NULL;
 176
 177
 178
 179         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoGradient_ce_ptr) == FAILURE) {
 180                 return;
 181         }
 182
 183
 184
 185         php_error(E_ERROR, "Gradient cannot be initialized"); RETURN_FALSE;
 186
 187 }
 188 /* }}} __construct */
 189
 190
 191
 192 /* {{{ proto void addColorStopRgb(float offset, float red, float green, float blue)
 193    */
 194 PHP_METHOD(CairoGradient, addColorStopRgb)
 195 {
 196
 197         zval * _this_zval = NULL;
 198         double offset = 0.0;
 199         double red = 0.0;
 200         double green = 0.0;
 201         double blue = 0.0;
 202
 203
 204
 205         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odddd", &_this_zval, CairoGradient_ce_ptr, &offset, &red, &green, &blue) == FAILURE) {
 206                 return;
 207         }
 208
 209     pattern_object *curr = (pattern_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 210         cairo_pattern_add_color_stop_rgb(curr->pattern, offset, red, green, blue);
 211         PHP_CAIRO_PATTERN_ERROR(curr->pattern);
 212 }
 213 /* }}} addColorStopRgb */
 214
 215
 216
 217 /* {{{ proto void addColorStopRgba(float offset, float red, float green, float blue, float alpha)
 218    */
 219 PHP_METHOD(CairoGradient, addColorStopRgba)
 220 {
 221
 222         zval * _this_zval = NULL;
 223         double offset = 0.0;
 224         double red = 0.0;
 225         double green = 0.0;
 226         double blue = 0.0;
 227         double alpha = 0.0;
 228
 229
 230
 231         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oddddd", &_this_zval, CairoGradient_ce_ptr, &offset, &red, &green, &blue, &alpha) == FAILURE) {
 232                 return;
 233         }
 234
 235     pattern_object *curr = (pattern_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 236         cairo_pattern_add_color_stop_rgba(curr->pattern, offset, red, green, blue, alpha);
 237         PHP_CAIRO_PATTERN_ERROR(curr->pattern);
 238 }
 239 /* }}} addColorStopRgba */
 240
 241
 242
 243 static zend_function_entry CairoGradient_methods[] = {
 244         PHP_ME(CairoGradient, __construct, NULL, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
 245         PHP_ME(CairoGradient, addColorStopRgb, CairoGradient__add_color_stop_rgb_args, /**/ZEND_ACC_PUBLIC)
 246         PHP_ME(CairoGradient, addColorStopRgba, CairoGradient__add_color_stop_rgba_args, /**/ZEND_ACC_PUBLIC)
 247         { NULL, NULL, NULL }
 248 };
 249
 250 /* }}} Methods */
 251
 252 static zend_object_handlers CairoGradient_handlers;
 253
 254 static zend_object_value CairoGradient_object_new(zend_class_entry *ce TSRMLS_CC)
 255 {
 256     zend_object_value retval;
 257     retval = CairoPattern_object_new(ce TSRMLS_CC);
 258     retval.handlers = &CairoGradient_handlers;
 259     return retval;
 260 }
 261
 262 static void class_init_CairoGradient(void)
 263 {
 264     zend_class_entry ce;
 265     INIT_CLASS_ENTRY(ce, "CairoGradient", CairoGradient_methods);
 266     CairoGradient_ce_ptr = zend_register_internal_class_ex(&ce, CairoPattern_ce_ptr, "CairoPattern" TSRMLS_CC);
 267     CairoGradient_ce_ptr->create_object = CairoGradient_object_new;
 268     memcpy(&CairoGradient_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 269 }
 270
 271
 272 /* }}} Class CairoGradient */
 273
 274 /* {{{ Class CairoLinearGradient */
 275
 276 static zend_class_entry * CairoLinearGradient_ce_ptr = NULL;
 277
 278 /* {{{ Methods */
 279
 280
 281 /* {{{ proto void construct(float x0, float y0, float x1, float y1)
 282    */
 283 PHP_METHOD(CairoLinearGradient, __construct)
 284 {
 285         zval * _this_zval;
 286
 287         double x0 = 0.0;
 288         double y0 = 0.0;
 289         double x1 = 0.0;
 290         double y1 = 0.0;
 291
 292
 293
 294         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "dddd", &x0, &y0, &x1, &y1) == FAILURE) {
 295                 return;
 296         }
 297
 298         _this_zval = getThis();
 299     pattern_object *curr = (pattern_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 300         curr->pattern = cairo_pattern_create_linear(x0, y0, x1, y1);
 301
 302 }
 303 /* }}} __construct */
 304
 305
 306
 307 /* {{{ proto array getLinearPoints()
 308    */
 309 PHP_METHOD(CairoLinearGradient, getLinearPoints)
 310 {
 311
 312         zval * _this_zval = NULL;
 313         double x0, y0, x1, y1;
 314
 315
 316         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoLinearGradient_ce_ptr) == FAILURE) {
 317                 return;
 318         }
 319
 320     pattern_object *curr = (pattern_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 321         cairo_pattern_get_linear_points(curr->pattern, &x0, &y0, &x1, &y1);
 322
 323         array_init(return_value);
 324         add_assoc_double(return_value, "x0", x0);
 325         add_assoc_double(return_value, "y0", y0);
 326         add_assoc_double(return_value, "x1", x1);
 327         add_assoc_double(return_value, "y1", y1);
 328
 329 }
 330 /* }}} getLinearPoints */
 331
 332
 333 static zend_function_entry CairoLinearGradient_methods[] = {
 334         PHP_ME(CairoLinearGradient, __construct, CairoLinearGradient____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
 335         PHP_ME(CairoLinearGradient, getLinearPoints, NULL, /**/ZEND_ACC_PUBLIC)
 336         { NULL, NULL, NULL }
 337 };
 338
 339 /* }}} Methods */
 340
 341 static zend_object_handlers CairoLinearGradient_handlers;
 342
 343 static zend_object_value CairoLinearGradient_object_new(zend_class_entry *ce TSRMLS_CC)
 344 {
 345     zend_object_value retval;
 346     retval = CairoGradient_object_new(ce TSRMLS_CC);
 347     retval.handlers = &CairoLinearGradient_handlers;
 348     return retval;
 349 }
 350
 351 static void class_init_CairoLinearGradient(void)
 352 {
 353     zend_class_entry ce;
 354     INIT_CLASS_ENTRY(ce, "CairoLinearGradient", CairoLinearGradient_methods);
 355     CairoLinearGradient_ce_ptr = zend_register_internal_class_ex(&ce, CairoGradient_ce_ptr, "CairoGradient" TSRMLS_CC);
 356     CairoLinearGradient_ce_ptr->create_object = CairoLinearGradient_object_new;
 357     memcpy(&CairoLinearGradient_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 358 }
 359
 360
 361 /* }}} Class CairoLinearGradient */
 362
 363 /* {{{ Class CairoRadialGradient */
 364
 365 static zend_class_entry * CairoRadialGradient_ce_ptr = NULL;
 366
 367 /* {{{ Methods */
 368
 369
 370 /* {{{ proto void construct(float cx0, float cy0, float radius0, float cx1, float cy1, float radius1)
 371    */
 372 PHP_METHOD(CairoRadialGradient, __construct)
 373 {
 374
 375         zval * _this_zval = NULL;
 376         double cx0 = 0.0;
 377         double cy0 = 0.0;
 378         double radius0 = 0.0;
 379         double cx1 = 0.0;
 380         double cy1 = 0.0;
 381         double radius1 = 0.0;
 382
 383
 384
 385         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odddddd", &_this_zval, CairoRadialGradient_ce_ptr, &cx0, &cy0, &radius0, &cx1, &cy1, &radius1) == FAILURE) {
 386                 return;
 387         }
 388
 389     pattern_object *curr = (pattern_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 390         curr->pattern = cairo_pattern_create_radial(cx0, cy0, radius0, cx1, cy1, radius1);
 391
 392 }
 393 /* }}} __construct */
 394
 395
 396
 397 /* {{{ proto array getRadialCircles()
 398    */
 399 PHP_METHOD(CairoRadialGradient, getRadialCircles)
 400 {
 401
 402         zval * _this_zval = NULL;
 403         double x0, y0, r0, x1, y1, r1;
 404
 405
 406         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoRadialGradient_ce_ptr) == FAILURE) {
 407                 return;
 408         }
 409
 410     pattern_object *curr = (pattern_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 411         cairo_pattern_get_radial_circles(curr->pattern, &x0, &y0, &r0, &x1, &y1, &r1);
 412
 413         array_init(return_value);
 414         add_assoc_double(return_value, "x0", x0);
 415     add_assoc_double(return_value, "y0", y0);
 416     add_assoc_double(return_value, "r0", r0);
 417     add_assoc_double(return_value, "x1", x1);
 418     add_assoc_double(return_value, "y1", y1);
 419     add_assoc_double(return_value, "r1", r1);
 420
 421 }
 422 /* }}} getRadialCircles */
 423
 424
 425 static zend_function_entry CairoRadialGradient_methods[] = {
 426         PHP_ME(CairoRadialGradient, __construct, CairoRadialGradient____constuct_args, /**/ZEND_ACC_PUBLIC| ZEND_ACC_CTOR)
 427         PHP_ME(CairoRadialGradient, getRadialCircles, NULL, /**/ZEND_ACC_PUBLIC)
 428         { NULL, NULL, NULL }
 429 };
 430
 431 /* }}} Methods */
 432
 433 static zend_object_handlers CairoRadialGradient_handlers;
 434
 435 static zend_object_value CairoRadialGradient_object_new(zend_class_entry *ce TSRMLS_CC)
 436 {
 437     zend_object_value retval;
 438     retval = CairoGradient_object_new(ce TSRMLS_CC);
 439     retval.handlers = &CairoRadialGradient_handlers;
 440     return retval;
 441 }
 442
 443 static void class_init_CairoRadialGradient(void)
 444 {
 445     zend_class_entry ce;
 446     INIT_CLASS_ENTRY(ce, "CairoRadialGradient", CairoRadialGradient_methods);
 447     CairoRadialGradient_ce_ptr = zend_register_internal_class_ex(&ce, CairoGradient_ce_ptr, "CairoGradient" TSRMLS_CC);
 448     CairoRadialGradient_ce_ptr->create_object = CairoRadialGradient_object_new;
 449     memcpy(&CairoRadialGradient_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 450 }
 451
 452 /* }}} Class CairoRadialGradient */
 453
 454 /* {{{ Class CairoSolidPattern */
 455
 456 static zend_class_entry * CairoSolidPattern_ce_ptr = NULL;
 457
 458 /* {{{ Methods */
 459
 460
 461 /* {{{ proto void construct(float r, float g, float b [, float a])
 462    */
 463 PHP_METHOD(CairoSolidPattern, __construct)
 464 {
 465         zval * _this_zval;
 466
 467         double r = 0.0;
 468         double g = 0.0;
 469         double b = 0.0;
 470         double a = 1.0;
 471
 472
 473
 474         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ddd|d", &r, &g, &b, &a) == FAILURE) {
 475                 return;
 476         }
 477
 478         _this_zval = getThis();
 479         pattern_object *curr = (pattern_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 480         curr->pattern = cairo_pattern_create_rgba(r, g, b, a);
 481
 482 }
 483 /* }}} __construct */
 484
 485
 486
 487 /* {{{ proto array getRgba()
 488    */
 489 PHP_METHOD(CairoSolidPattern, getRgba)
 490 {
 491
 492         zval * _this_zval = NULL;
 493         double r,g,b,a;
 494
 495
 496         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoSolidPattern_ce_ptr) == FAILURE) {
 497                 return;
 498         }
 499
 500         pattern_object *curr = (pattern_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 501         cairo_pattern_get_rgba(curr->pattern, &r, &g, &b, &a);
 502
 503         array_init(return_value);
 504         add_assoc_double(return_value, "red", r);
 505         add_assoc_double(return_value, "green", g);
 506         add_assoc_double(return_value, "blue", b);
 507         add_assoc_double(return_value, "alpha", a);
 508
 509 }
 510 /* }}} getRgba */
 511
 512
 513 static zend_function_entry CairoSolidPattern_methods[] = {
 514         PHP_ME(CairoSolidPattern, __construct, CairoSolidPattern____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
 515         PHP_ME(CairoSolidPattern, getRgba, NULL, /**/ZEND_ACC_PUBLIC)
 516         { NULL, NULL, NULL }
 517 };
 518
 519 /* }}} Methods */
 520
 521 static zend_object_handlers CairoSolidPattern_handlers;
 522
 523 static zend_object_value CairoSolidPattern_object_new(zend_class_entry *ce TSRMLS_CC)
 524 {
 525         zend_object_value retval;
 526         retval = CairoPattern_object_new(ce TSRMLS_CC);
 527         retval.handlers = &CairoSolidPattern_handlers;
 528         return retval;
 529
 530 }
 531
 532 static void class_init_CairoSolidPattern(void)
 533 {
 534         zend_class_entry ce;
 535
 536         INIT_CLASS_ENTRY(ce, "CairoSolidPattern", CairoSolidPattern_methods);
 537         CairoSolidPattern_ce_ptr = zend_register_internal_class_ex(&ce, CairoPattern_ce_ptr, "CairoPattern" TSRMLS_CC);
 538         CairoSolidPattern_ce_ptr->create_object = CairoSolidPattern_object_new;
 539         memcpy(&CairoSolidPattern_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 540 }
 541
 542 /* }}} Class CairoSolidPattern */
 543
 544 /* {{{ Class CairoSurfacePattern */
 545
 546 static zend_class_entry * CairoSurfacePattern_ce_ptr = NULL;
 547
 548 /* {{{ Methods */
 549
 550
 551 /* {{{ proto void construct(object s)
 552    */
 553 PHP_METHOD(CairoSurfacePattern, __construct)
 554 {
 555         zval * _this_zval;
 556
 557         zval * s = NULL;
 558
 559
 560
 561         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &s) == FAILURE) {
 562                 return;
 563         }
 564
 565         _this_zval = getThis();
 566         pattern_object *curr = (pattern_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 567         surface_object *sobj = (surface_object *)zend_objects_get_address(s TSRMLS_CC);
 568         curr->pattern = cairo_pattern_create_for_surface(sobj->surface);
 569
 570 }
 571 /* }}} __construct */
 572
 573
 574 /* {{{ proto int getFilter()
 575    */
 576 PHP_METHOD(CairoSurfacePattern, getFilter)
 577 {
 578         int filter;
 579         zval * _this_zval = NULL;
 580
 581
 582
 583         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoSurfacePattern_ce_ptr) == FAILURE) {
 584                 return;
 585         }
 586
 587     pattern_object *curr = (pattern_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 588         filter = cairo_pattern_get_filter(curr->pattern);
 589         RETURN_LONG(filter);
 590 }
 591 /* }}} getFilter */
 592
 593
 594
 595 /* {{{ proto object getSurface()
 596    */
 597 PHP_METHOD(CairoSurfacePattern, getSurface)
 598 {
 599         zend_class_entry *surface_ce;
 600         cairo_surface_t *surface;
 601         zval * _this_zval = NULL;
 602
 603
 604
 605         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoSurfacePattern_ce_ptr) == FAILURE) {
 606                 return;
 607         }
 608
 609         pattern_object *curr = (pattern_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 610         cairo_pattern_get_surface(curr->pattern, &surface);
 611         surface_ce = get_CairoSurface_ce_ptr(surface);
 612
 613         object_init_ex(return_value,surface_ce);
 614         surface_object *sobj = (surface_object *)zend_objects_get_address(return_value TSRMLS_CC);
 615         sobj->surface = cairo_surface_reference(surface);
 616 }
 617 /* }}} getSurface */
 618
 619
 620
 621
 622 /* {{{ proto void setFilter(int filter)
 623    */
 624 PHP_METHOD(CairoSurfacePattern, setFilter)
 625 {
 626
 627         zval * _this_zval = NULL;
 628         long filter = 0;
 629
 630
 631
 632         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &_this_zval, CairoSurfacePattern_ce_ptr, &filter) == FAILURE) {
 633                 return;
 634         }
 635
 636         pattern_object *curr = (pattern_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 637
 638         cairo_pattern_set_filter(curr->pattern, filter);
 639 }
 640 /* }}} setFilter */
 641
 642
 643 static zend_function_entry CairoSurfacePattern_methods[] = {
 644         PHP_ME(CairoSurfacePattern, __construct, NULL, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
 645         PHP_ME(CairoSurfacePattern, getFilter, NULL, /**/ZEND_ACC_PUBLIC)
 646         PHP_ME(CairoSurfacePattern, getSurface, NULL, /**/ZEND_ACC_PUBLIC)
 647         PHP_ME(CairoSurfacePattern, setFilter, CairoSurfacePattern__set_filter_args, /**/ZEND_ACC_PUBLIC)
 648         { NULL, NULL, NULL }
 649 };
 650
 651 /* }}} Methods */
 652
 653 static zend_object_handlers CairoSurfacePattern_handlers;
 654
 655 static zend_object_value CairoSurfacePattern_object_new(zend_class_entry *ce TSRMLS_CC)
 656 {
 657     zend_object_value retval;
 658     retval = CairoPattern_object_new(ce TSRMLS_CC);
 659     retval.handlers = &CairoSurfacePattern_handlers;
 660     return retval;
 661 }
 662
 663 static void class_init_CairoSurfacePattern(void)
 664 {
 665     zend_class_entry ce;
 666     INIT_CLASS_ENTRY(ce, "CairoSurfacePattern", CairoSurfacePattern_methods);
 667     CairoSurfacePattern_ce_ptr = zend_register_internal_class_ex(&ce, CairoPattern_ce_ptr, "CairoPattern" TSRMLS_CC);
 668     CairoSurfacePattern_ce_ptr->create_object = CairoSurfacePattern_object_new;
 669     memcpy(&CairoSurfacePattern_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 670 }
 671
 672
 673 /* }}} Class CairoSurfacePattern */
 674
 675 /* {{{ Helper functions */
 676
 677 zend_class_entry *
 678 get_CairoPattern_ce_ptr(cairo_pattern_t *pattern)
 679 {
 680         zend_class_entry *type;
 681         if(pattern == NULL)
 682                 return NULL;
 683         switch(cairo_pattern_get_type(pattern)) {
 684                 case CAIRO_PATTERN_TYPE_SOLID:
 685                         type = CairoSolidPattern_ce_ptr;
 686                         break;
 687                 case CAIRO_PATTERN_TYPE_SURFACE:
 688                         type = CairoSurfacePattern_ce_ptr;
 689                         break;
 690                 case CAIRO_PATTERN_TYPE_LINEAR:
 691                         type = CairoLinearGradient_ce_ptr;
 692                         break;
 693                 case CAIRO_PATTERN_TYPE_RADIAL:
 694                         type = CairoRadialGradient_ce_ptr;
 695                         break;
 696                 default:
 697                         php_error(E_ERROR,"Unsupported Pattern");
 698                         return NULL;
 699         }
 700         return type;
 701 }
 702 /* }}} Helper functions */
 703