src/cairo/CairoSurface.c

   1 #include "php_cairo_api.h"
   2 #include "CairoSurface.h"
   3 #include "CairoExceptionMacro.h"
   4 #include "php_cairo_ce_ptr.h"
   5
   6 /* {{{ Class CairoSurface */
   7
   8 static zend_class_entry * CairoSurface_ce_ptr = NULL;
   9 static zend_object_handlers CairoSurface_handlers;
  10
  11 static cairo_status_t
  12 _write_func(void *closure, const unsigned char *data, unsigned int length)
  13 {
  14         int written;
  15         php_stream *zs = (php_stream *)closure ;
  16         written = php_stream_write(zs, data, length);
  17         if(written == length)
  18                 return CAIRO_STATUS_SUCCESS;
  19         else {
  20                 printf("is it an error ?");
  21         }
  22 }
  23
  24 static cairo_status_t
  25 _read_func(void *closure, const unsigned char *data, unsigned int length)
  26 {
  27         int read;
  28         php_stream *zs = (php_stream *)closure;
  29         read = php_stream_read(zs, data, length);
  30         if(read == length)
  31                 return CAIRO_STATUS_SUCCESS;
  32         else {
  33                 printf("is it an error");
  34         }
  35
  36 }
  37
  38
  39 /*
  40 typedef struct _surface_object {
  41         zend_object std;
  42         cairo_surface_t *surface;
  43 } surface_object;
  44 */
  45
  46 /* {{{ Methods */
  47
  48
  49 /* {{{ proto void construct()
  50    */
  51 PHP_METHOD(CairoSurface, __construct)
  52 {
  53         zval * _this_zval;
  54
  55
  56
  57         if (ZEND_NUM_ARGS()>0)  {
  58                 WRONG_PARAM_COUNT;
  59                 php_print("wtf");
  60                 return;
  61         }
  62
  63         php_print("No direct call for this constructor");
  64
  65
  66 }
  67 /* }}} __construct */
  68
  69
  70
  71 /* {{{ proto object createSimilar(int content, int width, int height)
  72    */
  73 PHP_METHOD(CairoSurface, createSimilar)
  74 {
  75         zend_class_entry *ce;
  76         zval * _this_zval = NULL;
  77         cairo_surface_t *sur;
  78         int content;
  79         long width = 0;
  80         long height = 0;
  81
  82         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Olll", &_this_zval, CairoSurface_ce_ptr, &content, &width, &height) == FAILURE) {
  83                 return;
  84         }
  85
  86         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
  87         sur = cairo_surface_create_similar(curr->surface, content, width, height);
  88         ce = get_CairoSurface_ce_ptr(sur);
  89         object_init_ex(return_value, ce);
  90         surface_object *sobj = (surface_object *)zend_objects_get_address(return_value TSRMLS_CC);
  91         sobj->surface = sur;
  92
  93 }
  94 /* }}} createSimilar */
  95
  96
  97 /* {{{ proto void finish()
  98    */
  99 PHP_METHOD(CairoSurface, finish)
 100 {
 101
 102         zval * _this_zval = NULL;
 103
 104         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoSurface_ce_ptr) == FAILURE) {
 105                 return;
 106         }
 107
 108         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 109         cairo_surface_finish(curr->surface);
 110 }
 111 /* }}} finish */
 112
 113
 114
 115 /* {{{ proto void flush()
 116    */
 117 PHP_METHOD(CairoSurface, flush)
 118 {
 119
 120         zval * _this_zval = NULL;
 121
 122         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoSurface_ce_ptr) == FAILURE) {
 123                 return;
 124         }
 125
 126         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 127
 128         cairo_surface_flush(curr->surface);
 129
 130 }
 131 /* }}} flush */
 132
 133
 134
 135 /* {{{ proto int getContent()
 136    */
 137 PHP_METHOD(CairoSurface, getContent)
 138 {
 139
 140         zval * _this_zval = NULL;
 141         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoSurface_ce_ptr) == FAILURE) {
 142                 return;
 143         }
 144
 145         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 146
 147         RETURN_LONG(cairo_surface_get_content(curr->surface));
 148 }
 149 /* }}} getContent */
 150
 151
 152
 153 /* {{{ proto array getDeviceOffset()
 154    */
 155 PHP_METHOD(CairoSurface, getDeviceOffset)
 156 {
 157
 158         zval * _this_zval = NULL;
 159         double x_offset, y_offset;
 160
 161         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoSurface_ce_ptr) == FAILURE) {
 162                 return;
 163         }
 164
 165         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 166
 167         cairo_surface_get_device_offset(curr->surface, &x_offset, &y_offset);
 168
 169         array_init(return_value);
 170         add_assoc_double(return_value, "x", x_offset);
 171         add_assoc_double(return_value, "y", y_offset);
 172
 173 }
 174 /* }}} getDeviceOffset */
 175
 176
 177
 178 /* {{{ proto object getFontOptions()
 179    */
 180 PHP_METHOD(CairoSurface, getFontOptions)
 181 {
 182
 183         zval * _this_zval = NULL;
 184
 185         cairo_font_options_t *options = cairo_font_options_create();
 186
 187
 188         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoSurface_ce_ptr) == FAILURE) {
 189                 return;
 190         }
 191
 192         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 193
 194         cairo_surface_get_font_options(curr->surface, options);
 195         object_init_ex(return_value, CairoFontOptions_ce_ptr);
 196         fontoptions_object *fobj = (fontoptions_object *)zend_objects_get_address(return_value TSRMLS_CC);
 197         fobj->fontoptions = options;
 198
 199 }
 200 /* }}} getFontOptions */
 201
 202
 203
 204 /* {{{ proto void markDirtyRectangle([int x, int y, int width, int height])
 205    */
 206 PHP_METHOD(CairoSurface, markDirtyRectangle)
 207 {
 208
 209         zval * _this_zval = NULL;
 210         long x = 0;
 211         long y = 0;
 212         long width = -1;
 213         long height = -1;
 214
 215
 216
 217         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|llll", &_this_zval, CairoSurface_ce_ptr, &x, &y, &width, &height) == FAILURE) {
 218                 return;
 219         }
 220         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 221         cairo_surface_mark_dirty_rectangle(curr->surface, x, y, width, height);
 222
 223 }
 224 /* }}} markDirtyRectangle */
 225
 226
 227
 228 /* {{{ proto void setDeviceOffset(float x_offset, float y_offset)
 229    */
 230 PHP_METHOD(CairoSurface, setDeviceOffset)
 231 {
 232
 233         zval * _this_zval = NULL;
 234         double x_offset = 0.0;
 235         double y_offset = 0.0;
 236
 237         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoSurface_ce_ptr, &x_offset, &y_offset) == FAILURE) {
 238                 return;
 239         }
 240
 241         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 242         cairo_surface_set_device_offset(curr->surface, x_offset, y_offset);
 243
 244 }
 245 /* }}} setDeviceOffset */
 246
 247
 248
 249 /* {{{ proto void setFallbackResolution(float x_ppi, float y_ppi)
 250    */
 251 PHP_METHOD(CairoSurface, setFallbackResolution)
 252 {
 253
 254         zval * _this_zval = NULL;
 255         double x_ppi = 0.0;
 256         double y_ppi = 0.0;
 257
 258         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoSurface_ce_ptr, &x_ppi, &y_ppi) == FAILURE) {
 259                 return;
 260         }
 261
 262         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 263         cairo_surface_set_fallback_resolution(curr->surface, x_ppi, y_ppi);
 264
 265 }
 266 /* }}} setFallbackResolution */
 267
 268
 269
 270 /* {{{ proto void writeToPng(string file)
 271    */
 272 PHP_METHOD(CairoSurface, writeToPng)
 273 {
 274
 275         zval * _this_zval = NULL;
 276         const char * file = NULL;
 277         int file_len = 0;
 278         cairo_status_t status;
 279
 280         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &_this_zval, CairoSurface_ce_ptr, &file, &file_len) == FAILURE) {
 281                 return;
 282         }
 283
 284         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 285         status = cairo_surface_write_to_png(curr->surface, file);
 286
 287 }
 288 /* }}} writeToPng */
 289
 290
 291 /* {{{ proto void writeToPngStream(stream file)
 292         */
 293 PHP_METHOD(CairoSurface, writeToPngStream)
 294 {
 295         FILE *file;
 296         zval *_this_zval = NULL;
 297         cairo_status_t status;
 298         zval *zstream;
 299         php_stream *stream;
 300         int err;
 301
 302         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Or", &_this_zval, CairoSurface_ce_ptr, &zstream)) {
 303                 return;
 304         }
 305
 306         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 307         php_stream_from_zval(stream, &zstream);
 308         status = cairo_surface_write_to_png_stream(curr->surface, _write_func, stream);
 309
 310 }
 311
 312 /* }}} writeToPngStream*/
 313
 314
 315 static zend_function_entry CairoSurface_methods[] = {
 316         PHP_ME(CairoSurface, __construct, NULL, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
 317         PHP_ME(CairoSurface, createSimilar, CairoSurface__create_similar_args, /**/ZEND_ACC_PUBLIC)
 318         PHP_ME(CairoSurface, finish, NULL, /**/ZEND_ACC_PUBLIC)
 319         PHP_ME(CairoSurface, flush, NULL, /**/ZEND_ACC_PUBLIC)
 320         PHP_ME(CairoSurface, getContent, NULL, /**/ZEND_ACC_PUBLIC)
 321         PHP_ME(CairoSurface, getDeviceOffset, NULL, /**/ZEND_ACC_PUBLIC)
 322         PHP_ME(CairoSurface, getFontOptions, NULL, /**/ZEND_ACC_PUBLIC)
 323         PHP_ME(CairoSurface, markDirtyRectangle, CairoSurface__mark_dirty_rectangle_args, /**/ZEND_ACC_PUBLIC)
 324         PHP_ME(CairoSurface, setDeviceOffset, CairoSurface__set_device_offset_args, /**/ZEND_ACC_PUBLIC)
 325         PHP_ME(CairoSurface, setFallbackResolution, CairoSurface__set_fallback_resolution_args, /**/ZEND_ACC_PUBLIC)
 326         PHP_ME(CairoSurface, writeToPng, CairoSurface__write_to_png_args, /**/ZEND_ACC_PUBLIC)
 327         PHP_ME(CairoSurface, writeToPngStream, CairoSurface__write_to_png_stream_args, /**/ZEND_ACC_PUBLIC)
 328         { NULL, NULL, NULL }
 329 };
 330
 331 /* }}} Methods */
 332
 333
 334 static void CairoSurface_object_dtor(void *object)
 335 {
 336         surface_object *surface = (surface_object *)object;
 337         zend_hash_destroy(surface->std.properties);
 338         FREE_HASHTABLE(surface->std.properties);
 339         if(surface->surface){
 340                 cairo_surface_finish(surface->surface);
 341                 cairo_surface_destroy(surface->surface);
 342
 343         }
 344         efree(object);
 345 }
 346
 347 static zend_object_value CairoSurface_object_new(zend_class_entry *ce)
 348 {
 349         zend_object_value retval;
 350         surface_object *surface;
 351         zval *temp;
 352
 353         surface = emalloc(sizeof(surface_object));
 354         memset(surface,0,sizeof(surface_object));
 355
 356         surface->std.ce = ce;
 357
 358         ALLOC_HASHTABLE(surface->std.properties);
 359         zend_hash_init(surface->std.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
 360         zend_hash_copy(surface->std.properties, &ce->default_properties, (copy_ctor_func_t) zval_add_ref,(void *) &temp, sizeof(zval *));
 361         retval.handle = zend_objects_store_put(surface, NULL, (zend_objects_free_object_storage_t)CairoSurface_object_dtor, NULL TSRMLS_CC);
 362         retval.handlers = &CairoSurface_handlers;
 363         return retval;
 364 }
 365
 366 void class_init_CairoSurface(void)
 367 {
 368         zend_class_entry ce;
 369
 370         INIT_CLASS_ENTRY(ce, "CairoSurface", CairoSurface_methods);
 371         CairoSurface_ce_ptr = zend_register_internal_class(&ce);
 372         CairoSurface_ce_ptr->create_object = CairoSurface_object_new;
 373         memcpy(&CairoSurface_handlers, zend_get_std_object_handlers(),sizeof(zend_object_handlers));
 374         CairoSurface_handlers.clone_obj = NULL;
 375 }
 376
 377 /* }}} Class CairoSurface */
 378
 379 /* {{{ Class CairoImageSurface  -- done  :)*/
 380
 381 static zend_class_entry * CairoImageSurface_ce_ptr = NULL;
 382 static zend_object_handlers CairoImageSurface_handlers;
 383
 384
 385 /* {{{ Methods */
 386
 387
 388 /* {{{ proto void construct(int format, int widthm, int height)
 389    */
 390 PHP_METHOD(CairoImageSurface, __construct)
 391 {
 392         zval * _this_zval;
 393
 394         cairo_format_t format = 0;
 395         long widthm = 0;
 396         long height = 0;
 397
 398
 399
 400         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll", &format, &widthm, &height) == FAILURE) {
 401                 return;
 402         }
 403
 404         _this_zval = getThis();
 405         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 406         curr->surface = cairo_image_surface_create(format, widthm, height);
 407
 408 }
 409 /* }}} __construct */
 410
 411
 412
 413 /* {{{ proto void createFromData(string obj, int format, int width, int height [, int stride])
 414    */
 415 PHP_METHOD(CairoImageSurface, createFromData)
 416 {
 417
 418         zval * _this_zval = NULL;
 419         const char * buffer = NULL;
 420         int buffer_len = 0;
 421         long format = 0;
 422         long width = 0;
 423         long height = 0;
 424         long stride = -1;
 425
 426
 427
 428         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oslll|l", &_this_zval, CairoImageSurface_ce_ptr, &buffer, &buffer_len, &format, &width, &height, &stride) == FAILURE) {
 429                 return;
 430         }
 431
 432         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 433         cairo_surface_finish(curr->surface);
 434         cairo_surface_destroy(curr->surface);
 435
 436         if(stride < 0 ){
 437                 switch(format) {
 438                         case CAIRO_FORMAT_ARGB32:
 439                         case CAIRO_FORMAT_RGB24:
 440                                 stride = width * 4;
 441                                 break;
 442                         case CAIRO_FORMAT_RGB16_565:
 443                                 stride = width * 2;
 444                                 break;
 445                         case CAIRO_FORMAT_A8:
 446                                 stride = width;
 447                                 break;
 448                         case CAIRO_FORMAT_A1:
 449                                 stride = (width + 1) / 8;
 450                                 break;
 451                         default:
 452                                 php_error(E_WARNING, "Unknown format");
 453                                 return;
 454
 455                 }
 456         }
 457         /*
 458         if (height * stride > buffer_len) {
 459                 php_error(E_WARNING,"buffer is not long enough");
 460                 return;
 461         }
 462         */
 463         curr->surface = cairo_image_surface_create_for_data(buffer, format, width, height, stride);
 464
 465 }
 466 /* }}} createFromData */
 467
 468
 469
 470 /* {{{ proto void createFromPng(string file)
 471    */
 472 PHP_METHOD(CairoImageSurface, createFromPng)
 473 {
 474
 475         zval * _this_zval = NULL;
 476         const char * file = NULL;
 477         int file_len = 0;
 478
 479         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &_this_zval, CairoImageSurface_ce_ptr, &file, &file_len) == FAILURE) {
 480                 return;
 481         }
 482
 483         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 484
 485         curr->surface = cairo_image_surface_create_from_png(file);
 486
 487 }
 488 /* }}} createFromPng */
 489
 490
 491
 492 /* {{{ proto void createFromPngStream(stream zstream)
 493  */
 494
 495 PHP_METHOD(CairoImageSurface, createFromPngStream)
 496 {
 497         FILE *file;
 498         zval *_this_zval = NULL;
 499         cairo_status_t status;
 500         zval *zstream;
 501         php_stream *stream;
 502         int err;
 503
 504    if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Or", &_this_zval, CairoImageSurface_ce_ptr, &zstream)) {
 505                 return;
 506         }
 507
 508         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 509
 510         php_stream_from_zval(stream, &zstream);
 511         curr->surface = cairo_image_surface_create_from_png_stream( _read_func, stream);
 512
 513
 514 }
 515
 516 /* }}} createFromPngStream*/
 517
 518
 519
 520 /* {{{ proto string getData() -- not required
 521    */
 522 PHP_METHOD(CairoImageSurface, getData)
 523 {
 524
 525         zval * _this_zval = NULL;
 526         char *str;
 527
 528
 529         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoImageSurface_ce_ptr) == FAILURE) {
 530                 return;
 531         }
 532
 533         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 534
 535
 536         str = cairo_image_surface_get_data(curr->surface);
 537         RETURN_STRING(str, 0);
 538 }
 539 /* }}} getData */
 540
 541
 542
 543 /* {{{ proto int getFormat()
 544    */
 545 PHP_METHOD(CairoImageSurface, getFormat)
 546 {
 547         zval * _this_zval = NULL;
 548
 549         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoImageSurface_ce_ptr) == FAILURE) {
 550                 return;
 551         }
 552         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 553
 554         RETURN_LONG(cairo_image_surface_get_format(curr->surface));
 555 }
 556 /* }}} getFormat */
 557
 558
 559
 560 /* {{{ proto int getHeight()
 561    */
 562 PHP_METHOD(CairoImageSurface, getHeight)
 563 {
 564         zval * _this_zval = NULL;
 565
 566         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoImageSurface_ce_ptr) == FAILURE) {
 567                 return;
 568         }
 569
 570         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 571         RETURN_LONG(cairo_image_surface_get_height(curr->surface));
 572
 573 }
 574 /* }}} getHeight */
 575
 576
 577
 578 /* {{{ proto int getStride()
 579    */
 580 PHP_METHOD(CairoImageSurface, getStride)
 581 {
 582         zval * _this_zval = NULL;
 583
 584         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoImageSurface_ce_ptr) == FAILURE) {
 585                 return;
 586         }
 587
 588         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 589         RETURN_LONG(cairo_image_surface_get_stride(curr->surface));
 590
 591 }
 592 /* }}} getStride */
 593
 594
 595
 596 /* {{{ proto int getWidth()
 597    */
 598 PHP_METHOD(CairoImageSurface, getWidth)
 599 {
 600         zval * _this_zval = NULL;
 601
 602         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoImageSurface_ce_ptr) == FAILURE) {
 603                 return;
 604         }
 605
 606
 607         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 608
 609         RETURN_LONG(cairo_image_surface_get_width(curr->surface));
 610 }
 611 /* }}} getWidth */
 612
 613
 614 static zend_function_entry CairoImageSurface_methods[] = {
 615         PHP_ME(CairoImageSurface, __construct, CairoImageSurface____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
 616         PHP_ME(CairoImageSurface, createFromData, CairoImageSurface__create_from_data_args, /**/ZEND_ACC_PUBLIC)
 617         PHP_ME(CairoImageSurface, createFromPng, CairoImageSurface__create_from_png_args, /**/ZEND_ACC_PUBLIC)
 618         PHP_ME(CairoImageSurface, createFromPngStream, CairoImageSurface__create_from_png_stream_args, /**/ZEND_ACC_PUBLIC)
 619         PHP_ME(CairoImageSurface, getData, NULL, /**/ZEND_ACC_PUBLIC)
 620         PHP_ME(CairoImageSurface, getFormat, NULL, /**/ZEND_ACC_PUBLIC)
 621         PHP_ME(CairoImageSurface, getHeight, NULL, /**/ZEND_ACC_PUBLIC)
 622         PHP_ME(CairoImageSurface, getStride, NULL, /**/ZEND_ACC_PUBLIC)
 623         PHP_ME(CairoImageSurface, getWidth, NULL, /**/ZEND_ACC_PUBLIC)
 624         { NULL, NULL, NULL }
 625 };
 626
 627 /* }}} Methods */
 628
 629 static zend_object_value CairoImageSurface_object_new(zend_class_entry *ce TSRMLS_DC)
 630 {
 631         zend_object_value retval;
 632         retval = CairoSurface_object_new(ce TSRMLS_CC);
 633         retval.handlers = &CairoImageSurface_handlers;
 634         return retval;
 635 }
 636
 637
 638 void class_init_CairoImageSurface(void)
 639 {
 640         zend_class_entry ce;
 641
 642         INIT_CLASS_ENTRY(ce, "CairoImageSurface", CairoImageSurface_methods);
 643         CairoImageSurface_ce_ptr = zend_register_internal_class_ex(&ce, CairoSurface_ce_ptr, "CairoSurface" TSRMLS_CC);
 644         CairoImageSurface_ce_ptr->create_object = CairoImageSurface_object_new;
 645         memcpy(&CairoImageSurface_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 646 }
 647
 648 /* }}} Class CairoImageSurface */
 649
 650 /* {{{ Class CairoPDFSurface */
 651
 652 static zend_class_entry * CairoPDFSurface_ce_ptr = NULL;
 653 static zend_object_handlers CairoPDFSurface_handlers;
 654 /* {{{ Methods */
 655
 656
 657 /* {{{ proto void construct(string file, float wpts, float hpts)
 658    */
 659 PHP_METHOD(CairoPDFSurface, __construct)
 660 {
 661         zval * _this_zval;
 662         zval *zstream = NULL;
 663         const char * file = NULL;
 664         int file_len = 0;
 665         double wpts = 0.0;
 666         double hpts = 0.0;
 667         php_stream *stream;
 668         int argc = ZEND_NUM_ARGS();
 669         zval ***args, *obj;
 670
 671         args = (zval ***)safe_emalloc(argc, sizeof(zval *),0);
 672         if(ZEND_NUM_ARGS() == 0 ||
 673                 zend_get_parameters_array_ex(argc, args) == FAILURE) {
 674                 printf("ERROR");
 675                 efree(args);
 676                 WRONG_PARAM_COUNT;
 677         }
 678
 679         obj = *(args[1]);
 680         switch(Z_TYPE_P(obj)) {
 681                 case IS_DOUBLE:
 682                         wpts = Z_DVAL_P(obj);
 683                         break;
 684                 case IS_LONG:
 685                         wpts = Z_LVAL_P(obj);
 686                         break;
 687                 default :
 688                         printf("Error!!!");
 689                         return;
 690         }
 691
 692         obj = *(args[2]);
 693
 694         switch(Z_TYPE_P(obj)) {
 695                 case IS_DOUBLE:
 696                         hpts = Z_DVAL_P(obj);
 697                         break;
 698                 case IS_LONG:
 699                         hpts = Z_LVAL_P(obj);
 700                         break;
 701                 default :
 702                         printf("Error!!!");
 703                         return;
 704         }
 705
 706
 707         _this_zval = getThis();
 708
 709         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 710
 711         obj = *(args[0]);
 712         if(Z_TYPE_P(obj) == IS_STRING) {
 713                 file = Z_STRVAL_P(obj);
 714                 curr->surface = cairo_pdf_surface_create(file, wpts, hpts);
 715         }
 716         else if(Z_TYPE_P(obj) == IS_RESOURCE)  {
 717                 zstream = obj;
 718                 php_stream_from_zval(stream, &zstream);
 719                 curr->surface = cairo_pdf_surface_create_for_stream(_write_func, stream, wpts, hpts);
 720         }
 721         else {
 722                 printf("ERROR\n");
 723         }
 724
 725         efree(args);
 726 }
 727 /* }}} __construct */
 728
 729
 730
 731 /* {{{ proto void setSize(float wptd, float hpts)
 732    */
 733 PHP_METHOD(CairoPDFSurface, setSize)
 734 {
 735
 736         zval * _this_zval = NULL;
 737         double wpts = 0.0;
 738         double hpts = 0.0;
 739
 740
 741
 742         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoPDFSurface_ce_ptr, &wpts, &hpts) == FAILURE) {
 743                 return;
 744         }
 745
 746         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 747         cairo_pdf_surface_set_size(curr->surface, wpts, hpts);
 748
 749 }
 750 /* }}} setSize */
 751
 752
 753 static zend_function_entry CairoPDFSurface_methods[] = {
 754         PHP_ME(CairoPDFSurface, __construct, CairoPDFSurface____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
 755         PHP_ME(CairoPDFSurface, setSize, CairoPDFSurface__set_size_args, /**/ZEND_ACC_PUBLIC)
 756         { NULL, NULL, NULL }
 757 };
 758
 759 /* }}} Methods */
 760
 761 static zend_object_value CairoPDFSurface_object_new(zend_class_entry *ce TSRMLS_DC)
 762 {
 763         zend_object_value retval;
 764         retval = CairoSurface_object_new(ce TSRMLS_CC);
 765         retval.handlers = &CairoPDFSurface_handlers;
 766         return retval;
 767 }
 768
 769 void class_init_CairoPDFSurface(void)
 770 {
 771         zend_class_entry ce;
 772
 773         INIT_CLASS_ENTRY(ce, "CairoPDFSurface", CairoPDFSurface_methods);
 774         CairoPDFSurface_ce_ptr = zend_register_internal_class_ex(&ce, CairoSurface_ce_ptr, "CairoSurface" TSRMLS_CC);
 775         CairoPDFSurface_ce_ptr->create_object = CairoPDFSurface_object_new;
 776         memcpy(&CairoPDFSurface_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 777
 778 }
 779
 780 /* }}} Class CairoPDFSurface */
 781
 782 /* {{{ Class CairoPSSurface */
 783
 784 static zend_class_entry * CairoPSSurface_ce_ptr = NULL;
 785 static zend_object_handlers CairoPSSurface_handlers;
 786 /* {{{ Methods */
 787
 788
 789 /* {{{ proto void construct(string file | stream stream, float wpts, float hpts)
 790    */
 791 PHP_METHOD(CairoPSSurface, __construct)
 792 {
 793         zval * _this_zval;
 794         zval *zstream = NULL;
 795         const char * file = NULL;
 796         int file_len = 0;
 797         double wpts = 0.0;
 798         double hpts = 0.0;
 799         php_stream *stream;
 800         int argc = ZEND_NUM_ARGS();
 801         zval ***args, *obj;
 802
 803         args = (zval **)safe_emalloc(argc, sizeof(zval *),0);
 804         if(ZEND_NUM_ARGS() == 0 ||
 805                 zend_get_parameters_array_ex(argc, args) == FAILURE) {
 806                 printf("ERROR");
 807                 efree(args);
 808                 WRONG_PARAM_COUNT;
 809         }
 810
 811         obj = *(args[1]);
 812         switch(Z_TYPE_P(obj)) {
 813                 case IS_DOUBLE:
 814                         wpts = Z_DVAL_P(obj);
 815                         break;
 816                 case IS_LONG:
 817                         wpts = Z_LVAL_P(obj);
 818                         break;
 819                 default :
 820                         printf("Error!!!");
 821                         return;
 822         }
 823
 824         obj = *(args[2]);
 825
 826         switch(Z_TYPE_P(obj)) {
 827                 case IS_DOUBLE:
 828                         hpts = Z_DVAL_P(obj);
 829                         break;
 830                 case IS_LONG:
 831                         hpts = Z_LVAL_P(obj);
 832                         break;
 833                 default :
 834                         printf("Error!!!");
 835                         return;
 836         }
 837
 838
 839         _this_zval = getThis();
 840         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 841
 842         obj = *(args[0]);
 843         if(Z_TYPE_P(obj) == IS_STRING) {
 844                 file = Z_STRVAL_P(obj);
 845                 curr->surface = cairo_ps_surface_create(file, wpts, hpts);
 846         }
 847         else if(Z_TYPE_P(obj) == IS_RESOURCE)  {
 848                 zstream = obj;
 849                 php_stream_from_zval(stream, &zstream);
 850                 curr->surface = cairo_ps_surface_create_for_stream(_write_func, stream, wpts, hpts);
 851         }
 852         else {
 853                 printf("ERROR\n");
 854         }
 855
 856         efree(args);
 857
 858
 859
 860
 861 }
 862 /* }}} __construct */
 863
 864
 865
 866 /* {{{ proto void dscBeginPageSetup()
 867    */
 868 PHP_METHOD(CairoPSSurface, dscBeginPageSetup)
 869 {
 870
 871         zval * _this_zval = NULL;
 872
 873
 874
 875         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoPSSurface_ce_ptr) == FAILURE) {
 876                 return;
 877         }
 878         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 879         cairo_ps_surface_dsc_begin_page_setup(curr->surface);
 880         PHP_CAIRO_SURFACE_ERROR(curr->surface);
 881
 882
 883
 884 }
 885 /* }}} dscBeginPageSetup */
 886
 887
 888
 889 /* {{{ proto void dscBeginSetup()
 890    */
 891 PHP_METHOD(CairoPSSurface, dscBeginSetup)
 892 {
 893
 894         zval * _this_zval = NULL;
 895
 896
 897
 898         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoPSSurface_ce_ptr) == FAILURE) {
 899                 return;
 900         }
 901
 902         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 903         cairo_ps_surface_dsc_begin_setup(curr->surface);
 904         PHP_CAIRO_SURFACE_ERROR(curr->surface);
 905
 906 }
 907 /* }}} dscBeginSetup */
 908
 909
 910
 911 /* {{{ proto void dscComment()
 912    */
 913 PHP_METHOD(CairoPSSurface, dscComment)
 914 {
 915
 916         zval * _this_zval = NULL;
 917
 918
 919
 920         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoPSSurface_ce_ptr) == FAILURE) {
 921                 return;
 922         }
 923
 924         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 925         cairo_ps_surface_dsc_comment(curr->surface);
 926         PHP_CAIRO_SURFACE_ERROR(curr->surface);
 927
 928 }
 929 /* }}} dscComment */
 930
 931
 932
 933 /* {{{ proto array getLevels() -- cairo 1.6
 934    */
 935 PHP_METHOD(CairoPSSurface, getLevels)
 936 {
 937
 938         zval * _this_zval = NULL;
 939
 940
 941
 942         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoPSSurface_ce_ptr) == FAILURE) {
 943                 return;
 944         }
 945
 946         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 947
 948
 949         array_init(return_value);
 950
 951         do {
 952                 /* ONLY for CAIRO 1.6 */
 953         } while (0);
 954 }
 955 /* }}} getLevels */
 956
 957
 958
 959 /* {{{ proto string getLevelString() --cairo 1.6
 960    */
 961 PHP_METHOD(CairoPSSurface, getLevelString)
 962 {
 963
 964         zval * _this_zval = NULL;
 965
 966
 967
 968         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoPSSurface_ce_ptr) == FAILURE) {
 969                 return;
 970         }
 971
 972         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 973
 974
 975         do {
 976                 /* ONLY for CAIRO 1.6*/
 977         } while (0);
 978 }
 979 /* }}} getLevelString */
 980
 981
 982
 983 /* {{{ proto void restrictToLevel(int level) --cairo 1.6
 984    */
 985 PHP_METHOD(CairoPSSurface, restrictToLevel)
 986 {
 987
 988         zval * _this_zval = NULL;
 989         long level = 0;
 990
 991
 992
 993         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &_this_zval, CairoPSSurface_ce_ptr, &level) == FAILURE) {
 994                 return;
 995         }
 996
 997         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 998
 999
1000         do {
1001                 /* ONLY for CAIRO 1.6 */
1002         } while (0);
1003 }
1004 /* }}} restrictToLevel */
1005
1006
1007
1008 /* {{{ proto void setEps() --cairo 1.6
1009    */
1010 PHP_METHOD(CairoPSSurface, setEps)
1011 {
1012
1013         zval * _this_zval = NULL;
1014
1015
1016
1017         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoPSSurface_ce_ptr) == FAILURE) {
1018                 return;
1019         }
1020
1021         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
1022
1023
1024         do {
1025                 /* ONLY for CAIRO 1.6 */
1026         } while (0);
1027 }
1028 /* }}} setEps */
1029
1030
1031
1032 /* {{{ proto void setSize(float wpts, float hpts)
1033    */
1034 PHP_METHOD(CairoPSSurface, setSize)
1035 {
1036
1037         zval * _this_zval = NULL;
1038         double wpts = 0.0;
1039         double hpts = 0.0;
1040
1041
1042
1043         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoPSSurface_ce_ptr, &wpts, &hpts) == FAILURE) {
1044                 return;
1045         }
1046
1047         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
1048         cairo_ps_surface_set_size(curr->surface, wpts, hpts);
1049
1050 }
1051 /* }}} setSize */
1052
1053
1054 static zend_function_entry CairoPSSurface_methods[] = {
1055         PHP_ME(CairoPSSurface, __construct, CairoPSSurface____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
1056         PHP_ME(CairoPSSurface, dscBeginPageSetup, NULL, /**/ZEND_ACC_PUBLIC)
1057         PHP_ME(CairoPSSurface, dscBeginSetup, NULL, /**/ZEND_ACC_PUBLIC)
1058         PHP_ME(CairoPSSurface, dscComment, NULL, /**/ZEND_ACC_PUBLIC)
1059         PHP_ME(CairoPSSurface, getLevels, NULL, /**/ZEND_ACC_PUBLIC)
1060         PHP_ME(CairoPSSurface, getLevelString, NULL, /**/ZEND_ACC_PUBLIC)
1061         PHP_ME(CairoPSSurface, restrictToLevel, CairoPSSurface__restrict_to_level_args, /**/ZEND_ACC_PUBLIC)
1062         PHP_ME(CairoPSSurface, setEps, NULL, /**/ZEND_ACC_PUBLIC)
1063         PHP_ME(CairoPSSurface, setSize, CairoPSSurface__set_size_args, /**/ZEND_ACC_PUBLIC)
1064         { NULL, NULL, NULL }
1065 };
1066
1067 /* }}} Methods */
1068
1069 static zend_object_value CairoPSSurface_object_new(zend_class_entry *ce TSRMLS_DC)
1070 {
1071         zend_object_value retval;
1072         retval = CairoSurface_object_new(ce TSRMLS_CC);
1073         retval.handlers = &CairoPSSurface_handlers;
1074         return retval;
1075 }
1076
1077 void class_init_CairoPSSurface(void)
1078 {
1079         zend_class_entry ce;
1080
1081         INIT_CLASS_ENTRY(ce, "CairoPSSurface", CairoPSSurface_methods);
1082         CairoPSSurface_ce_ptr = zend_register_internal_class_ex(&ce, CairoSurface_ce_ptr, "CairoSurface" TSRMLS_CC);
1083         CairoPSSurface_ce_ptr->create_object = CairoPSSurface_object_new;
1084         memcpy(&CairoPSSurface_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
1085 }
1086
1087 /* }}} Class CairoPSSurface */
1088
1089 /* {{{ Class CairoQuartzSurface */
1090
1091 static zend_class_entry * CairoQuartzSurface_ce_ptr = NULL;
1092 static zend_object_handlers CairoQuartzSurface_handlers;
1093 /* {{{ Methods */
1094
1095
1096 /* {{{ proto void construct(float wpixels, float hpixels [, int format])
1097    */
1098 PHP_METHOD(CairoQuartzSurface, __construct)
1099 {
1100         zval * _this_zval;
1101
1102         double wpixels = 0.0;
1103         double hpixels = 0.0;
1104         long format = 0;
1105
1106
1107
1108         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "dd|l", &wpixels, &hpixels, &format) == FAILURE) {
1109                 return;
1110         }
1111
1112         _this_zval = getThis();
1113         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
1114
1115
1116         php_error(E_WARNING, "CANNOT BE CALLED"); RETURN_FALSE;
1117
1118 }
1119 /* }}} __construct */
1120
1121
1122 static zend_function_entry CairoQuartzSurface_methods[] = {
1123         PHP_ME(CairoQuartzSurface, __construct, CairoQuartzSurface____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
1124         { NULL, NULL, NULL }
1125 };
1126
1127 /* }}} Methods */
1128
1129 static zend_object_value CairoQuartzSurface_object_new(zend_class_entry *ce TSRMLS_DC)
1130 {
1131         zend_object_value retval;
1132         retval = CairoSurface_object_new(ce TSRMLS_CC);
1133         retval.handlers = &CairoQuartzSurface_handlers;
1134         return retval;
1135 }
1136
1137 void class_init_CairoQuartzSurface(void)
1138 {
1139         zend_class_entry ce;
1140
1141         INIT_CLASS_ENTRY(ce, "CairoQuartzSurface", CairoQuartzSurface_methods);
1142         CairoQuartzSurface_ce_ptr = zend_register_internal_class_ex(&ce, CairoSurface_ce_ptr, "CairoSurface" TSRMLS_CC);
1143         CairoQuartzSurface_ce_ptr->create_object = CairoQuartzSurface_object_new;
1144         memcpy(&CairoQuartzSurface_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
1145
1146 }
1147
1148 /* }}} Class CairoQuartzSurface */
1149
1150 /* {{{ Class CairoSVGSurface */
1151
1152 static zend_class_entry * CairoSVGSurface_ce_ptr = NULL;
1153 static zend_object_handlers CairoSVGSurface_handlers;
1154
1155
1156 /* {{{ Methods */
1157
1158
1159 /* {{{ proto void construct(string file, float wpts, float hpts)
1160    */
1161 PHP_METHOD(CairoSVGSurface, __construct)
1162 {
1163         zval * _this_zval;
1164         zval *zstream = NULL;
1165         const char * file = NULL;
1166         int file_len = 0;
1167         double wpts = 0.0;
1168         double hpts = 0.0;
1169         php_stream *stream;
1170         int argc = ZEND_NUM_ARGS();
1171         zval ***args, *obj;
1172
1173         args = (zval **)safe_emalloc(argc, sizeof(zval *),0);
1174         if(ZEND_NUM_ARGS() == 0 ||
1175                 zend_get_parameters_array_ex(argc, args) == FAILURE) {
1176                 printf("ERROR");
1177                 efree(args);
1178                 WRONG_PARAM_COUNT;
1179         }
1180
1181         obj = *(args[1]);
1182         switch(Z_TYPE_P(obj)) {
1183                 case IS_DOUBLE:
1184                         wpts = Z_DVAL_P(obj);
1185                         break;
1186                 case IS_LONG:
1187                         wpts = Z_LVAL_P(obj);
1188                         break;
1189                 default :
1190                         printf("error!!!");
1191                         return;
1192         }
1193
1194         obj = *(args[2]);
1195
1196         switch(Z_TYPE_P(obj)) {
1197                 case IS_DOUBLE:
1198                         hpts = Z_DVAL_P(obj);
1199                         break;
1200                 case IS_LONG:
1201                         hpts = Z_LVAL_P(obj);
1202                         break;
1203                 default :
1204                         printf("Error!!!");
1205                         return;
1206         }
1207
1208
1209         _this_zval = getThis();
1210         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
1211
1212         obj = *(args[0]);
1213         if(Z_TYPE_P(obj) == IS_STRING) {
1214                 file = Z_STRVAL_P(obj);
1215                 curr->surface = cairo_svg_surface_create(file, wpts, hpts);
1216         }
1217         else if(Z_TYPE_P(obj) == IS_RESOURCE)  {
1218                 zstream = obj;
1219                 php_stream_from_zval(stream, &zstream);
1220                 curr->surface = cairo_svg_surface_create_for_stream(_write_func, stream, wpts, hpts);
1221         }
1222         else {
1223                 printf("ERROR\n");
1224         }
1225
1226         efree(args);
1227
1228
1229 }
1230 /* }}} __construct */
1231
1232
1233 static zend_function_entry CairoSVGSurface_methods[] = {
1234         PHP_ME(CairoSVGSurface, __construct, CairoSVGSurface____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
1235         { NULL, NULL, NULL }
1236 };
1237
1238 /* }}} Methods */
1239
1240 static zend_object_value CairoSVGSurface_object_new(zend_class_entry *ce TSRMLS_DC)
1241 {
1242         zend_object_value retval;
1243         retval = CairoSurface_object_new(ce TSRMLS_CC);
1244         retval.handlers = &CairoSVGSurface_handlers;
1245         return retval;
1246 }
1247
1248 void class_init_CairoSVGSurface(void)
1249 {
1250         zend_class_entry ce;
1251
1252         INIT_CLASS_ENTRY(ce, "CairoSVGSurface", CairoSVGSurface_methods);
1253         CairoSVGSurface_ce_ptr = zend_register_internal_class_ex(&ce, CairoSurface_ce_ptr, "CairoSurface" TSRMLS_CC);
1254         CairoSVGSurface_ce_ptr->create_object = CairoSVGSurface_object_new;
1255         memcpy(&CairoSVGSurface_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
1256
1257 }
1258
1259 /* }}} Class CairoSVGSurface */
1260
1261 /* {{{ Class CairoWin32Surface*/
1262
1263 static zend_class_entry * CairoWin32Surface_ce_ptr = NULL;
1264 static zend_object_handlers CairoWin32Surface_handlers;
1265
1266 /* {{{ Methods */
1267
1268
1269 /* {{{ proto void construct(int hdc)
1270    */
1271 PHP_METHOD(CairoWin32Surface, __construct)
1272 {
1273         zval * _this_zval;
1274
1275         long hdc = 0;
1276
1277
1278
1279         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &hdc) == FAILURE) {
1280                 return;
1281         }
1282
1283         _this_zval = getThis();
1284         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
1285         curr->surface = cairo_win32_surface_create(hdc, NULL);
1286 }
1287 /* }}} __construct */
1288
1289
1290 static zend_function_entry CairoWin32Surface_methods[] = {
1291         PHP_ME(CairoWin32Surface, __construct, NULL, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
1292         { NULL, NULL, NULL }
1293 };
1294
1295 /* }}} Methods */
1296
1297 static zend_object_value CairoWin32Surface_object_new(zend_class_entry *ce TSRMLS_DC)
1298 {
1299         zend_object_value retval;
1300         retval = CairoSurface_object_new(ce TSRMLS_CC);
1301         retval.handlers = &CairoWin32Surface_handlers;
1302         return retval;
1303 }
1304
1305 void class_init_CairoWin32Surface(void)
1306 {
1307         zend_class_entry ce;
1308
1309         INIT_CLASS_ENTRY(ce, "CairoWin32Surface", CairoWin32Surface_methods);
1310         CairoWin32Surface_ce_ptr = zend_register_internal_class_ex(&ce, CairoSurface_ce_ptr, "CairoSurface" TSRMLS_CC);
1311         CairoWin32Surface_ce_ptr->create_object = CairoWin32Surface_object_new;
1312         memcpy(&CairoWin32Surface_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
1313
1314 }
1315
1316 /* }}} Class CairoWin32Surface */
1317
1318 /* {{{ Class CairoXlibSurface */
1319
1320 static zend_class_entry * CairoXlibSurface_ce_ptr = NULL;
1321 static zend_object_handlers CairoXlibSurface_handlers;
1322 /* {{{ Methods */
1323
1324
1325 /* {{{ proto void construct()
1326    */
1327 PHP_METHOD(CairoXlibSurface, __construct)
1328 {
1329         zval * _this_zval;
1330
1331
1332
1333         if (ZEND_NUM_ARGS()>0)  {
1334                 WRONG_PARAM_COUNT;
1335         }
1336
1337         _this_zval = getThis();
1338         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
1339
1340         php_error(E_WARNING, "Cannot Be Initialized"); RETURN_FALSE;
1341
1342 }
1343 /* }}} __construct */
1344
1345
1346
1347 /* {{{ proto int getDepth()
1348    */
1349 PHP_METHOD(CairoXlibSurface, getDepth)
1350 {
1351
1352         zval * _this_zval = NULL;
1353
1354
1355         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoXlibSurface_ce_ptr) == FAILURE) {
1356                 return;
1357         }
1358
1359         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
1360
1361         RETURN_LONG(cairo_xlib_surface_get_depth(curr->surface));
1362
1363 }
1364 /* }}} getDepth */
1365
1366
1367
1368 /* {{{ proto int getHeight()
1369    */
1370 PHP_METHOD(CairoXlibSurface, getHeight)
1371 {
1372
1373         zval * _this_zval = NULL;
1374
1375
1376         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoXlibSurface_ce_ptr) == FAILURE) {
1377                 return;
1378         }
1379
1380         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
1381         RETURN_LONG(cairo_xlib_surface_get_height(curr->surface));
1382
1383 }
1384 /* }}} getHeight */
1385
1386
1387
1388 /* {{{ proto int getWidth()
1389    */
1390 PHP_METHOD(CairoXlibSurface, getWidth)
1391 {
1392
1393         zval * _this_zval = NULL;
1394
1395
1396         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoXlibSurface_ce_ptr) == FAILURE) {
1397                 return;
1398         }
1399
1400         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
1401         RETURN_LONG(cairo_xlib_surface_get_width(curr->surface));
1402
1403 }
1404 /* }}} getWidth */
1405
1406
1407 static zend_function_entry CairoXlibSurface_methods[] = {
1408         PHP_ME(CairoXlibSurface, __construct, NULL, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
1409         PHP_ME(CairoXlibSurface, getDepth, NULL, /**/ZEND_ACC_PUBLIC)
1410         PHP_ME(CairoXlibSurface, getHeight, NULL, /**/ZEND_ACC_PUBLIC)
1411         PHP_ME(CairoXlibSurface, getWidth, NULL, /**/ZEND_ACC_PUBLIC)
1412         { NULL, NULL, NULL }
1413 };
1414
1415 /* }}} Methods */
1416
1417 static zend_object_value CairoXlibSurface_object_new(zend_class_entry *ce TSRMLS_DC)
1418 {
1419         zend_object_value retval;
1420         retval = CairoSurface_object_new(ce TSRMLS_CC);
1421         retval.handlers = &CairoXlibSurface_handlers;
1422         return retval;
1423 }
1424
1425 void class_init_CairoXlibSurface(void)
1426 {
1427         zend_class_entry ce;
1428
1429         INIT_CLASS_ENTRY(ce, "CairoXlibSurface", CairoXlibSurface_methods);
1430         CairoXlibSurface_ce_ptr = zend_register_internal_class_ex(&ce, CairoSurface_ce_ptr, "CairoSurface" TSRMLS_CC);
1431         CairoXlibSurface_ce_ptr->create_object = CairoXlibSurface_object_new;
1432         memcpy(&CairoXlibSurface_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
1433
1434 }
1435
1436 /* }}} Class CairoXlibSurface */
1437
1438 /* {{{ Helper Functions */
1439 zend_class_entry *
1440 get_CairoSurface_ce_ptr(cairo_surface_t *surface)
1441 {
1442         zend_class_entry *type;
1443         if(surface == NULL)
1444                 return;
1445
1446         switch(cairo_surface_get_type(surface)) {
1447                 case CAIRO_SURFACE_TYPE_IMAGE:
1448                         type = CairoImageSurface_ce_ptr;
1449                         break;
1450                 case CAIRO_SURFACE_TYPE_PDF:
1451                         type = CairoPDFSurface_ce_ptr;
1452                         break;
1453                 case CAIRO_SURFACE_TYPE_PS:
1454                         type = CairoPSSurface_ce_ptr;
1455                         break;
1456                 case CAIRO_SURFACE_TYPE_SVG:
1457                         type = CairoSVGSurface_ce_ptr;
1458                         break;
1459                 case CAIRO_SURFACE_TYPE_WIN32:
1460                         type = CairoWin32Surface_ce_ptr;
1461                         break;
1462                 case CAIRO_SURFACE_TYPE_XLIB:
1463                         type = CairoXlibSurface_ce_ptr;
1464                         break;
1465                 case CAIRO_SURFACE_TYPE_QUARTZ:
1466                         type = CairoQuartzSurface_ce_ptr;
1467                         break;
1468                 default:
1469                         php_error(E_WARNING,"Unsupported Surface Type");
1470                         return NULL;
1471         }
1472         return type;
1473 }
1474
1475 /* }}} Helper Function*/
1476
1477