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