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         printf("uuu%suu%d",file,curr->surface);
 275         status = cairo_surface_write_to_png(curr->surface, file);
 276
 277 }
 278 /* }}} write_to_png */
 279
 280
 281 static zend_function_entry CairoSurface_methods[] = {
 282         PHP_ME(CairoSurface, __construct, NULL, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
 283         PHP_ME(CairoSurface, create_similar, CairoSurface__create_similar_args, /**/ZEND_ACC_PUBLIC)
 284         PHP_ME(CairoSurface, finish, NULL, /**/ZEND_ACC_PUBLIC)
 285         PHP_ME(CairoSurface, flush, NULL, /**/ZEND_ACC_PUBLIC)
 286         PHP_ME(CairoSurface, get_content, NULL, /**/ZEND_ACC_PUBLIC)
 287         PHP_ME(CairoSurface, get_device_offset, NULL, /**/ZEND_ACC_PUBLIC)
 288         PHP_ME(CairoSurface, get_font_options, NULL, /**/ZEND_ACC_PUBLIC)
 289         PHP_ME(CairoSurface, mark_dirty_rectangle, CairoSurface__mark_dirty_rectangle_args, /**/ZEND_ACC_PUBLIC)
 290         PHP_ME(CairoSurface, set_device_offset, CairoSurface__set_device_offset_args, /**/ZEND_ACC_PUBLIC)
 291         PHP_ME(CairoSurface, set_fallback_resolution, CairoSurface__set_fallback_resolution_args, /**/ZEND_ACC_PUBLIC)
 292         PHP_ME(CairoSurface, write_to_png, CairoSurface__write_to_png_args, /**/ZEND_ACC_PUBLIC)
 293         { NULL, NULL, NULL }
 294 };
 295
 296 /* }}} Methods */
 297
 298
 299 static void CairoSurface_object_dtor(void *object)
 300 {
 301         surface_object *surface = (surface_object *)object;
 302         zend_hash_destroy(surface->std.properties);
 303         FREE_HASHTABLE(surface->std.properties);
 304         if(surface->surface){
 305                 cairo_surface_finish(surface->surface);
 306                 cairo_surface_destroy(surface->surface);
 307
 308         }
 309         efree(object);
 310 }
 311
 312 static zend_object_value CairoSurface_object_new(zend_class_entry *ce)
 313 {
 314         zend_object_value retval;
 315         surface_object *surface;
 316         zval *temp;
 317
 318         surface = emalloc(sizeof(surface_object));
 319         printf("%d",surface);
 320         memset(surface,0,sizeof(surface_object));
 321
 322         surface->std.ce=ce;
 323
 324         ALLOC_HASHTABLE(surface->std.properties);
 325         zend_hash_init(surface->std.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
 326         zend_hash_copy(surface->std.properties, &ce->default_properties, (copy_ctor_func_t) zval_add_ref,(void *) &temp, sizeof(zval *));
 327         retval.handle=zend_objects_store_put(surface, NULL, (zend_objects_free_object_storage_t)CairoSurface_object_dtor, NULL TSRMLS_CC);
 328         retval.handlers = &CairoSurface_handlers;
 329         return retval;
 330 }
 331
 332 static void class_init_CairoSurface(void)
 333 {
 334         zend_class_entry ce;
 335
 336         INIT_CLASS_ENTRY(ce, "CairoSurface", CairoSurface_methods);
 337         CairoSurface_ce_ptr = zend_register_internal_class(&ce);
 338         CairoSurface_ce_ptr->create_object = CairoSurface_object_new;
 339         memcpy(&CairoSurface_handlers, zend_get_std_object_handlers(),sizeof(zend_object_handlers));
 340         CairoSurface_handlers.clone_obj = NULL;
 341 }
 342
 343 /* }}} Class CairoSurface */
 344
 345 /* {{{ Class CairoImageSurface  -- allmost done (-stream) */
 346
 347 static zend_class_entry * CairoImageSurface_ce_ptr = NULL;
 348 static zend_object_handlers CairoImageSurface_handlers;
 349 /* {{{ Methods */
 350
 351
 352 /* {{{ proto void construct(int format, int widthm, int height)
 353    */
 354 PHP_METHOD(CairoImageSurface, __construct)
 355 {
 356         zend_class_entry * _this_ce;
 357         zval * _this_zval;
 358
 359         cairo_format_t format = 0;
 360         long widthm = 0;
 361         long height = 0;
 362
 363
 364
 365         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll", &format, &widthm, &height) == FAILURE) {
 366                 return;
 367         }
 368
 369         _this_zval = getThis();
 370         _this_ce = Z_OBJCE_P(_this_zval);
 371         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 372         printf("yy%d", curr);
 373         curr->surface = cairo_image_surface_create(format, widthm, height);
 374         printf("surface %d",curr->surface);
 375
 376 }
 377 /* }}} __construct */
 378
 379
 380
 381 /* {{{ proto object create_from_data(object obj, int format, int width, int height [, int stride])
 382    */
 383 PHP_METHOD(CairoImageSurface, create_from_data)
 384 {
 385         zend_class_entry * _this_ce;
 386
 387         zval * _this_zval = NULL;
 388         const char * buffer = NULL;
 389         int buffer_len = 0;
 390         long format = 0;
 391         long width = 0;
 392         long height = 0;
 393         long stride = -1;
 394
 395
 396
 397         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) {
 398                 return;
 399         }
 400
 401         _this_ce = Z_OBJCE_P(_this_zval);
 402         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 403
 404         object_init(return_value);
 405         surface_object *sobj = (surface_object *)zend_objects_get_address(return_value TSRMLS_CC);
 406         if(stride < 0 ){
 407                 switch(format) {
 408                         case CAIRO_FORMAT_ARGB32:
 409                         case CAIRO_FORMAT_RGB24:
 410                                 stride = width * 4;
 411                                 break;
 412                         case CAIRO_FORMAT_RGB16_565:
 413                                 stride = width * 2;
 414                                 break;
 415                         case CAIRO_FORMAT_A8:
 416                                 stride = width;
 417                                 break;
 418                         case CAIRO_FORMAT_A1:
 419                                 stride = (width + 1) / 8;
 420                                 break;
 421                         default:
 422                                 //php_error(CairoError, "Unknown format");
 423                                 return;
 424
 425                 }
 426         }
 427         if (height * stride > buffer_len) {
 428                 php_error(E_ERROR,"buffer is not long enough");
 429                 return;
 430         }
 431         sobj->surface = cairo_image_surface_create_for_data(buffer, format, width, height, stride);
 432 }
 433 /* }}} create_from_data */
 434
 435
 436
 437 /* {{{ proto object create_from_png(string file)
 438    */
 439 PHP_METHOD(CairoImageSurface, create_from_png)
 440 {
 441         zend_class_entry * _this_ce;
 442
 443         zval * _this_zval = NULL;
 444         const char * file = NULL;
 445         int file_len = 0;
 446
 447         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &_this_zval, CairoImageSurface_ce_ptr, &file, &file_len) == FAILURE) {
 448                 return;
 449         }
 450
 451         _this_ce = Z_OBJCE_P(_this_zval);
 452         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 453
 454         object_init(return_value);
 455         surface_object *sobj = (surface_object *)zend_objects_get_address(return_value TSRMLS_CC);
 456         sobj->surface = cairo_image_surface_create_from_png(file);
 457
 458 }
 459 /* }}} create_from_png */
 460
 461
 462
 463 /* {{{ proto string get_data() -- not required
 464    */
 465 PHP_METHOD(CairoImageSurface, get_data)
 466 {
 467         zend_class_entry * _this_ce;
 468
 469         zval * _this_zval = NULL;
 470
 471
 472
 473         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoImageSurface_ce_ptr) == FAILURE) {
 474                 return;
 475         }
 476
 477         _this_ce = Z_OBJCE_P(_this_zval);
 478         php_error(E_WARNING,"Not Implemented .. not required");
 479
 480         RETURN_STRINGL("", 0, 1);
 481 }
 482 /* }}} get_data */
 483
 484
 485
 486 /* {{{ proto int get_format()
 487    */
 488 PHP_METHOD(CairoImageSurface, get_format)
 489 {
 490         zend_class_entry * _this_ce;
 491         long x;
 492         zval * _this_zval = NULL;
 493
 494         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoImageSurface_ce_ptr) == FAILURE) {
 495                 return;
 496         }
 497         _this_ce = Z_OBJCE_P(_this_zval);
 498         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 499
 500         x = cairo_image_surface_get_format(curr->surface);
 501         RETURN_LONG(x);
 502 }
 503 /* }}} get_format */
 504
 505
 506
 507 /* {{{ proto int get_height()
 508    */
 509 PHP_METHOD(CairoImageSurface, get_height)
 510 {
 511         zend_class_entry * _this_ce;
 512         zval * _this_zval = NULL;
 513         long x;
 514
 515         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoImageSurface_ce_ptr) == FAILURE) {
 516                 return;
 517         }
 518
 519         _this_ce = Z_OBJCE_P(_this_zval);
 520         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 521         x = cairo_image_surface_get_height(curr->surface);
 522
 523         RETURN_LONG(x);
 524 }
 525 /* }}} get_height */
 526
 527
 528
 529 /* {{{ proto int get_stride()
 530    */
 531 PHP_METHOD(CairoImageSurface, get_stride)
 532 {
 533         zend_class_entry * _this_ce;
 534         zval * _this_zval = NULL;
 535         long x;
 536
 537         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoImageSurface_ce_ptr) == FAILURE) {
 538                 return;
 539         }
 540
 541         _this_ce = Z_OBJCE_P(_this_zval);
 542         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 543         x = cairo_image_surface_get_stride(curr->surface);
 544
 545         RETURN_LONG(x);
 546 }
 547 /* }}} get_stride */
 548
 549
 550
 551 /* {{{ proto int get_width()
 552    */
 553 PHP_METHOD(CairoImageSurface, get_width)
 554 {
 555         zend_class_entry * _this_ce;
 556         zval * _this_zval = NULL;
 557         long x;
 558
 559         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoImageSurface_ce_ptr) == FAILURE) {
 560                 return;
 561         }
 562
 563         _this_ce = Z_OBJCE_P(_this_zval);
 564
 565         surface_object *curr = (surface_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 566
 567         x = cairo_image_surface_get_width(curr->surface);
 568         RETURN_LONG(x);
 569 }
 570 /* }}} get_width */
 571
 572
 573 static zend_function_entry CairoImageSurface_methods[] = {
 574         PHP_ME(CairoImageSurface, __construct, CairoImageSurface____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
 575         PHP_ME(CairoImageSurface, create_from_data, CairoImageSurface__create_from_data_args, /**/ZEND_ACC_PRIVATE)
 576         PHP_ME(CairoImageSurface, create_from_png, CairoImageSurface__create_from_png_args, /**/ZEND_ACC_PRIVATE)
 577         PHP_ME(CairoImageSurface, get_data, NULL, /**/ZEND_ACC_PUBLIC)
 578         PHP_ME(CairoImageSurface, get_format, NULL, /**/ZEND_ACC_PUBLIC)
 579         PHP_ME(CairoImageSurface, get_height, NULL, /**/ZEND_ACC_PUBLIC)
 580         PHP_ME(CairoImageSurface, get_stride, NULL, /**/ZEND_ACC_PUBLIC)
 581         PHP_ME(CairoImageSurface, get_width, NULL, /**/ZEND_ACC_PUBLIC)
 582         { NULL, NULL, NULL }
 583 };
 584
 585 /* }}} Methods */
 586
 587 static zend_object_value CairoImageSurface_object_new(zend_class_entry *ce TSRMLS_DC)
 588 {
 589     zend_object_value retval;
 590         retval=CairoSurface_object_new(ce TSRMLS_CC);
 591         retval.handlers = &CairoImageSurface_handlers;
 592         return retval;
 593 }
 594
 595
 596 static void class_init_CairoImageSurface(void)
 597 {
 598         zend_class_entry ce;
 599
 600         INIT_CLASS_ENTRY(ce, "CairoImageSurface", CairoImageSurface_methods);
 601         CairoImageSurface_ce_ptr = zend_register_internal_class_ex(&ce, CairoSurface_ce_ptr, "CairoSurface" TSRMLS_CC);
 602         CairoImageSurface_ce_ptr->create_object = CairoImageSurface_object_new;
 603         memcpy(&CairoImageSurface_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 604 }
 605
 606 /* }}} Class CairoImageSurface */
 607
 608 /* {{{ Class CairoPDFSurface */
 609
 610 static zend_class_entry * CairoPDFSurface_ce_ptr = NULL;
 611 static zend_object_handlers CairoPDFSurface_handlers;
 612 /* {{{ Methods */
 613
 614
 615 /* {{{ proto void construct(string file, float wpts, float hpts)
 616    */
 617 PHP_METHOD(CairoPDFSurface, __construct)
 618 {
 619         zend_class_entry * _this_ce;
 620         zval * _this_zval;
 621
 622         const char * file = NULL;
 623         int file_len = 0;
 624         double wpts = 0.0;
 625         double hpts = 0.0;
 626
 627
 628
 629         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sdd", &file, &file_len, &wpts, &hpts) == FAILURE) {
 630                 return;
 631         }
 632
 633         _this_zval = getThis();
 634         _this_ce = Z_OBJCE_P(_this_zval);
 635
 636
 637         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
 638
 639 }
 640 /* }}} __construct */
 641
 642
 643
 644 /* {{{ proto void set_size(float wptd, float hpts)
 645    */
 646 PHP_METHOD(CairoPDFSurface, set_size)
 647 {
 648         zend_class_entry * _this_ce;
 649
 650         zval * _this_zval = NULL;
 651         double wptd = 0.0;
 652         double hpts = 0.0;
 653
 654
 655
 656         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoPDFSurface_ce_ptr, &wptd, &hpts) == FAILURE) {
 657                 return;
 658         }
 659
 660         _this_ce = Z_OBJCE_P(_this_zval);
 661
 662
 663         php_error(E_WARNING, "set_size: not yet implemented"); RETURN_FALSE;
 664
 665 }
 666 /* }}} set_size */
 667
 668
 669 static zend_function_entry CairoPDFSurface_methods[] = {
 670         PHP_ME(CairoPDFSurface, __construct, CairoPDFSurface____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
 671         PHP_ME(CairoPDFSurface, set_size, CairoPDFSurface__set_size_args, /**/ZEND_ACC_PUBLIC)
 672         { NULL, NULL, NULL }
 673 };
 674
 675 /* }}} Methods */
 676
 677 static zend_object_value CairoPDFSurface_object_new(zend_class_entry *ce TSRMLS_DC)
 678 {
 679     zend_object_value retval;
 680         retval=CairoSurface_object_new(ce TSRMLS_CC);
 681         retval.handlers = &CairoPDFSurface_handlers;
 682         return retval;
 683 }
 684
 685 static void class_init_CairoPDFSurface(void)
 686 {
 687         zend_class_entry ce;
 688
 689         INIT_CLASS_ENTRY(ce, "CairoPDFSurface", CairoPDFSurface_methods);
 690         CairoPDFSurface_ce_ptr = zend_register_internal_class_ex(&ce, CairoSurface_ce_ptr, "CairoSurface" TSRMLS_CC);
 691         CairoPDFSurface_ce_ptr->create_object = CairoPDFSurface_object_new;
 692         memcpy(&CairoPDFSurface_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 693
 694 }
 695
 696 /* }}} Class CairoPDFSurface */
 697
 698 /* {{{ Class CairoPSSurface */
 699
 700 static zend_class_entry * CairoPSSurface_ce_ptr = NULL;
 701 static zend_object_handlers CairoPSSurface_handlers;
 702 /* {{{ Methods */
 703
 704
 705 /* {{{ proto void construct(string file, float wpts, float hpts)
 706    */
 707 PHP_METHOD(CairoPSSurface, __construct)
 708 {
 709         zend_class_entry * _this_ce;
 710         zval * _this_zval;
 711
 712         const char * file = NULL;
 713         int file_len = 0;
 714         double wpts = 0.0;
 715         double hpts = 0.0;
 716
 717
 718
 719         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sdd", &file, &file_len, &wpts, &hpts) == FAILURE) {
 720                 return;
 721         }
 722
 723         _this_zval = getThis();
 724         _this_ce = Z_OBJCE_P(_this_zval);
 725
 726
 727         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
 728
 729 }
 730 /* }}} __construct */
 731
 732
 733
 734 /* {{{ proto void dsc_begin_page_setup()
 735    */
 736 PHP_METHOD(CairoPSSurface, dsc_begin_page_setup)
 737 {
 738         zend_class_entry * _this_ce;
 739
 740         zval * _this_zval = NULL;
 741
 742
 743
 744         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoPSSurface_ce_ptr) == FAILURE) {
 745                 return;
 746         }
 747
 748         _this_ce = Z_OBJCE_P(_this_zval);
 749
 750
 751         php_error(E_WARNING, "dsc_begin_page_setup: not yet implemented"); RETURN_FALSE;
 752
 753 }
 754 /* }}} dsc_begin_page_setup */
 755
 756
 757
 758 /* {{{ proto void dsc_begin_setup()
 759    */
 760 PHP_METHOD(CairoPSSurface, dsc_begin_setup)
 761 {
 762         zend_class_entry * _this_ce;
 763
 764         zval * _this_zval = NULL;
 765
 766
 767
 768         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoPSSurface_ce_ptr) == FAILURE) {
 769                 return;
 770         }
 771
 772         _this_ce = Z_OBJCE_P(_this_zval);
 773
 774
 775         php_error(E_WARNING, "dsc_begin_setup: not yet implemented"); RETURN_FALSE;
 776
 777 }
 778 /* }}} dsc_begin_setup */
 779
 780
 781
 782 /* {{{ proto void dsc_comment()
 783    */
 784 PHP_METHOD(CairoPSSurface, dsc_comment)
 785 {
 786         zend_class_entry * _this_ce;
 787
 788         zval * _this_zval = NULL;
 789
 790
 791
 792         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoPSSurface_ce_ptr) == FAILURE) {
 793                 return;
 794         }
 795
 796         _this_ce = Z_OBJCE_P(_this_zval);
 797
 798
 799         php_error(E_WARNING, "dsc_comment: not yet implemented"); RETURN_FALSE;
 800
 801 }
 802 /* }}} dsc_comment */
 803
 804
 805
 806 /* {{{ proto array get_levels()
 807    */
 808 PHP_METHOD(CairoPSSurface, get_levels)
 809 {
 810         zend_class_entry * _this_ce;
 811
 812         zval * _this_zval = NULL;
 813
 814
 815
 816         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoPSSurface_ce_ptr) == FAILURE) {
 817                 return;
 818         }
 819
 820         _this_ce = Z_OBJCE_P(_this_zval);
 821
 822
 823         array_init(return_value);
 824
 825         do {
 826                 /* ONLY for CAIRO 1.6 */
 827         } while (0);
 828 }
 829 /* }}} get_levels */
 830
 831
 832
 833 /* {{{ proto string get_level_string()
 834    */
 835 PHP_METHOD(CairoPSSurface, get_level_string)
 836 {
 837         zend_class_entry * _this_ce;
 838
 839         zval * _this_zval = NULL;
 840
 841
 842
 843         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoPSSurface_ce_ptr) == FAILURE) {
 844                 return;
 845         }
 846
 847         _this_ce = Z_OBJCE_P(_this_zval);
 848
 849
 850         do {
 851                 /* ONLY for CAIRO 1.6*/
 852         } while (0);
 853 }
 854 /* }}} get_level_string */
 855
 856
 857
 858 /* {{{ proto void restrict_to_level(int level)
 859    */
 860 PHP_METHOD(CairoPSSurface, restrict_to_level)
 861 {
 862         zend_class_entry * _this_ce;
 863
 864         zval * _this_zval = NULL;
 865         long level = 0;
 866
 867
 868
 869         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &_this_zval, CairoPSSurface_ce_ptr, &level) == FAILURE) {
 870                 return;
 871         }
 872
 873         _this_ce = Z_OBJCE_P(_this_zval);
 874
 875
 876         do {
 877                 /* ONLY for CAIRO 1.6 */
 878         } while (0);
 879 }
 880 /* }}} restrict_to_level */
 881
 882
 883
 884 /* {{{ proto void set_eps()
 885    */
 886 PHP_METHOD(CairoPSSurface, set_eps)
 887 {
 888         zend_class_entry * _this_ce;
 889
 890         zval * _this_zval = NULL;
 891
 892
 893
 894         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoPSSurface_ce_ptr) == FAILURE) {
 895                 return;
 896         }
 897
 898         _this_ce = Z_OBJCE_P(_this_zval);
 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
 927
 928         php_error(E_WARNING, "set_size: not yet implemented"); RETURN_FALSE;
 929
 930 }
 931 /* }}} set_size */
 932
 933
 934 static zend_function_entry CairoPSSurface_methods[] = {
 935         PHP_ME(CairoPSSurface, __construct, CairoPSSurface____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
 936         PHP_ME(CairoPSSurface, dsc_begin_page_setup, NULL, /**/ZEND_ACC_PUBLIC)
 937         PHP_ME(CairoPSSurface, dsc_begin_setup, NULL, /**/ZEND_ACC_PUBLIC)
 938         PHP_ME(CairoPSSurface, dsc_comment, NULL, /**/ZEND_ACC_PUBLIC)
 939         PHP_ME(CairoPSSurface, get_levels, NULL, /**/ZEND_ACC_PUBLIC)
 940         PHP_ME(CairoPSSurface, get_level_string, NULL, /**/ZEND_ACC_PUBLIC)
 941         PHP_ME(CairoPSSurface, restrict_to_level, CairoPSSurface__restrict_to_level_args, /**/ZEND_ACC_PUBLIC)
 942         PHP_ME(CairoPSSurface, set_eps, NULL, /**/ZEND_ACC_PUBLIC)
 943         PHP_ME(CairoPSSurface, set_size, CairoPSSurface__set_size_args, /**/ZEND_ACC_PUBLIC)
 944         { NULL, NULL, NULL }
 945 };
 946
 947 /* }}} Methods */
 948
 949 static zend_object_value CairoPSSurface_object_new(zend_class_entry *ce TSRMLS_DC)
 950 {
 951     zend_object_value retval;
 952         retval=CairoSurface_object_new(ce TSRMLS_CC);
 953         retval.handlers = &CairoPSSurface_handlers;
 954         return retval;
 955 }
 956
 957 static void class_init_CairoPSSurface(void)
 958 {
 959         zend_class_entry ce;
 960
 961         INIT_CLASS_ENTRY(ce, "CairoPSSurface", CairoPSSurface_methods);
 962         CairoPSSurface_ce_ptr = zend_register_internal_class_ex(&ce, CairoSurface_ce_ptr, "CairoSurface" TSRMLS_CC);
 963         CairoPSSurface_ce_ptr->create_object = CairoPSSurface_object_new;
 964         memcpy(&CairoPSSurface_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 965 }
 966
 967 /* }}} Class CairoPSSurface */
 968
 969 /* {{{ Class CairoQuartzSurface */
 970
 971 static zend_class_entry * CairoQuartzSurface_ce_ptr = NULL;
 972 static zend_object_handlers CairoQuartzSurface_handlers;
 973 /* {{{ Methods */
 974
 975
 976 /* {{{ proto void construct(float wpixels, float hpixels [, int format])
 977    */
 978 PHP_METHOD(CairoQuartzSurface, __construct)
 979 {
 980         zend_class_entry * _this_ce;
 981         zval * _this_zval;
 982
 983         double wpixels = 0.0;
 984         double hpixels = 0.0;
 985         long format = 0;
 986
 987
 988
 989         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "dd|l", &wpixels, &hpixels, &format) == FAILURE) {
 990                 return;
 991         }
 992
 993         _this_zval = getThis();
 994         _this_ce = Z_OBJCE_P(_this_zval);
 995
 996
 997         php_error(E_WARNING, "__construct: not yet implemented"); 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
1059
1060         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
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 */
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
1120
1121         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
1122
1123 }
1124 /* }}} __construct */
1125
1126
1127 static zend_function_entry CairoWin32Surface_methods[] = {
1128         PHP_ME(CairoWin32Surface, __construct, NULL, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
1129         { NULL, NULL, NULL }
1130 };
1131
1132 /* }}} Methods */
1133
1134 static zend_object_value CairoWin32Surface_object_new(zend_class_entry *ce TSRMLS_DC)
1135 {
1136     zend_object_value retval;
1137         retval=CairoSurface_object_new(ce TSRMLS_CC);
1138         retval.handlers = &CairoWin32Surface_handlers;
1139         return retval;
1140 }
1141
1142 static void class_init_CairoWin32Surface(void)
1143 {
1144         zend_class_entry ce;
1145
1146         INIT_CLASS_ENTRY(ce, "CairoWin32Surface", CairoWin32Surface_methods);
1147         CairoWin32Surface_ce_ptr = zend_register_internal_class_ex(&ce, CairoSurface_ce_ptr, "CairoSurface" TSRMLS_CC);
1148         CairoWin32Surface_ce_ptr->create_object = CairoWin32Surface_object_new;
1149         memcpy(&CairoWin32Surface_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
1150
1151 }
1152
1153 /* }}} Class CairoWin32Surface */
1154
1155 /* {{{ Class CairoXlibSurface */
1156
1157 static zend_class_entry * CairoXlibSurface_ce_ptr = NULL;
1158 static zend_object_handlers CairoXlibSurface_handlers;
1159 /* {{{ Methods */
1160
1161
1162 /* {{{ proto void construct()
1163    */
1164 PHP_METHOD(CairoXlibSurface, __construct)
1165 {
1166         zend_class_entry * _this_ce;
1167         zval * _this_zval;
1168
1169
1170
1171         if (ZEND_NUM_ARGS()>0)  {
1172                 WRONG_PARAM_COUNT;
1173         }
1174
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
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
1199
1200         php_error(E_WARNING, "get_depth: not yet implemented"); RETURN_FALSE;
1201
1202         RETURN_LONG(0);
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
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
1224
1225         php_error(E_WARNING, "get_height: not yet implemented"); RETURN_FALSE;
1226
1227         RETURN_LONG(0);
1228 }
1229 /* }}} get_height */
1230
1231
1232
1233 /* {{{ proto int get_width()
1234    */
1235 PHP_METHOD(CairoXlibSurface, get_width)
1236 {
1237         zend_class_entry * _this_ce;
1238
1239         zval * _this_zval = NULL;
1240
1241
1242
1243         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoXlibSurface_ce_ptr) == FAILURE) {
1244                 return;
1245         }
1246
1247         _this_ce = Z_OBJCE_P(_this_zval);
1248
1249
1250         php_error(E_WARNING, "get_width: not yet implemented"); RETURN_FALSE;
1251
1252         RETURN_LONG(0);
1253 }
1254 /* }}} get_width */
1255
1256
1257 static zend_function_entry CairoXlibSurface_methods[] = {
1258         PHP_ME(CairoXlibSurface, __construct, NULL, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
1259         PHP_ME(CairoXlibSurface, get_depth, NULL, /**/ZEND_ACC_PUBLIC)
1260         PHP_ME(CairoXlibSurface, get_height, NULL, /**/ZEND_ACC_PUBLIC)
1261         PHP_ME(CairoXlibSurface, get_width, NULL, /**/ZEND_ACC_PUBLIC)
1262         { NULL, NULL, NULL }
1263 };
1264
1265 /* }}} Methods */
1266
1267 static zend_object_value CairoXlibSurface_object_new(zend_class_entry *ce TSRMLS_DC)
1268 {
1269         zend_object_value retval;
1270         retval=CairoSurface_object_new(ce TSRMLS_CC);
1271         retval.handlers = &CairoXlibSurface_handlers;
1272         return retval;
1273 }
1274
1275 static void class_init_CairoXlibSurface(void)
1276 {
1277         zend_class_entry ce;
1278
1279         INIT_CLASS_ENTRY(ce, "CairoXlibSurface", CairoXlibSurface_methods);
1280         CairoXlibSurface_ce_ptr = zend_register_internal_class_ex(&ce, CairoSurface_ce_ptr, "CairoSurface" TSRMLS_CC);
1281         CairoXlibSurface_ce_ptr->create_object = CairoXlibSurface_object_new;
1282         memcpy(&CairoXlibSurface_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
1283
1284 }
1285
1286 /* }}} Class CairoXlibSurface */