src/cairo/CairoSurface.c

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