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