individual_files/phpCairoSurface.c

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