phpCairo/phpCairo.c

   1 /*
   2    +----------------------------------------------------------------------+
   3    | This source file is subject to version 3.0 of the PHP license,       |
   4    | that is bundled with this package in the file LICENSE, and is        |
   5    | available through the world-wide-web at the following url:           |
   6    | http://www.php.net/license/3_0.txt.                                  |
   7    | If you did not receive a copy of the PHP license and are unable to   |
   8    | obtain it through the world-wide-web, please send a note to          |
   9    | license@php.net so we can mail you a copy immediately.               |
  10    +----------------------------------------------------------------------+
  11    | Authors: Akshat Gupta <g.akshat@gmail.com>                           |
  12    +----------------------------------------------------------------------+
  13 */
  14
  15 /* $ Id: $ */
  16
  17 #include "php_phpCairo.h"
  18
  19 #if HAVE_PHPCAIRO
  20
  21 /* {{{ Class definitions */
  22
  23 /* {{{ Class CairoContext */
  24
  25 static zend_class_entry * CairoContext_ce_ptr = NULL;
  26
  27 /* {{{ Methods */
  28
  29
  30 /* {{{ proto void append_path(object p)
  31    */
  32 PHP_METHOD(CairoContext, append_path)
  33 {
  34         zend_class_entry * _this_ce;
  35
  36         zval * _this_zval = NULL;
  37         zval * p = NULL;
  38
  39
  40
  41         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo", &_this_zval, CairoContext_ce_ptr, &p) == FAILURE) {
  42                 return;
  43         }
  44
  45         _this_ce = Z_OBJCE_P(_this_zval);
  46
  47
  48         php_error(E_WARNING, "append_path: not yet implemented"); RETURN_FALSE;
  49
  50 }
  51 /* }}} append_path */
  52
  53
  54
  55 /* {{{ proto void arc(float xc, float yc, float radius, float angle1, float angle2)
  56    */
  57 PHP_METHOD(CairoContext, arc)
  58 {
  59         zend_class_entry * _this_ce;
  60
  61         zval * _this_zval = NULL;
  62         double xc = 0.0;
  63         double yc = 0.0;
  64         double radius = 0.0;
  65         double angle1 = 0.0;
  66         double angle2 = 0.0;
  67
  68
  69
  70         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oddddd", &_this_zval, CairoContext_ce_ptr, &xc, &yc, &radius, &angle1, &angle2) == FAILURE) {
  71                 return;
  72         }
  73
  74         _this_ce = Z_OBJCE_P(_this_zval);
  75
  76
  77         php_error(E_WARNING, "arc: not yet implemented"); RETURN_FALSE;
  78
  79 }
  80 /* }}} arc */
  81
  82
  83
  84 /* {{{ proto void arc_negative(float xc, float yc, float radius, float angle1, float angle2)
  85    */
  86 PHP_METHOD(CairoContext, arc_negative)
  87 {
  88         zend_class_entry * _this_ce;
  89
  90         zval * _this_zval = NULL;
  91         double xc = 0.0;
  92         double yc = 0.0;
  93         double radius = 0.0;
  94         double angle1 = 0.0;
  95         double angle2 = 0.0;
  96
  97
  98
  99         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oddddd", &_this_zval, CairoContext_ce_ptr, &xc, &yc, &radius, &angle1, &angle2) == FAILURE) {
 100                 return;
 101         }
 102
 103         _this_ce = Z_OBJCE_P(_this_zval);
 104
 105
 106         php_error(E_WARNING, "arc_negative: not yet implemented"); RETURN_FALSE;
 107
 108 }
 109 /* }}} arc_negative */
 110
 111
 112
 113 /* {{{ proto void clip()
 114    */
 115 PHP_METHOD(CairoContext, clip)
 116 {
 117         zend_class_entry * _this_ce;
 118
 119         zval * _this_zval = NULL;
 120
 121
 122
 123         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 124                 return;
 125         }
 126
 127         _this_ce = Z_OBJCE_P(_this_zval);
 128
 129
 130         php_error(E_WARNING, "clip: not yet implemented"); RETURN_FALSE;
 131
 132 }
 133 /* }}} clip */
 134
 135
 136
 137 /* {{{ proto array clip_extents()
 138    */
 139 PHP_METHOD(CairoContext, clip_extents)
 140 {
 141         zend_class_entry * _this_ce;
 142
 143         zval * _this_zval = NULL;
 144
 145
 146
 147         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 148                 return;
 149         }
 150
 151         _this_ce = Z_OBJCE_P(_this_zval);
 152
 153
 154         array_init(return_value);
 155
 156         php_error(E_WARNING, "clip_extents: not yet implemented"); RETURN_FALSE;
 157
 158         array_init(return_value);
 159 }
 160 /* }}} clip_extents */
 161
 162
 163
 164 /* {{{ proto void clip_preserve()
 165    */
 166 PHP_METHOD(CairoContext, clip_preserve)
 167 {
 168         zend_class_entry * _this_ce;
 169
 170         zval * _this_zval = NULL;
 171
 172
 173
 174         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 175                 return;
 176         }
 177
 178         _this_ce = Z_OBJCE_P(_this_zval);
 179
 180
 181         php_error(E_WARNING, "clip_preserve: not yet implemented"); RETURN_FALSE;
 182
 183 }
 184 /* }}} clip_preserve */
 185
 186
 187
 188 /* {{{ proto void close_path()
 189    */
 190 PHP_METHOD(CairoContext, close_path)
 191 {
 192         zend_class_entry * _this_ce;
 193
 194         zval * _this_zval = NULL;
 195
 196
 197
 198         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 199                 return;
 200         }
 201
 202         _this_ce = Z_OBJCE_P(_this_zval);
 203
 204
 205         php_error(E_WARNING, "close_path: not yet implemented"); RETURN_FALSE;
 206
 207 }
 208 /* }}} close_path */
 209
 210
 211
 212 /* {{{ proto object copy_clip_rectangle_list()
 213    */
 214 PHP_METHOD(CairoContext, copy_clip_rectangle_list)
 215 {
 216         zend_class_entry * _this_ce;
 217
 218         zval * _this_zval = NULL;
 219
 220
 221
 222         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 223                 return;
 224         }
 225
 226         _this_ce = Z_OBJCE_P(_this_zval);
 227
 228
 229         do {
 230                 /*using iterator in php5.0 to store the
 231                                                 list. Pass the array to an iterator during the
 232                                                 object definition and jobs done */
 233         } while (0);
 234 }
 235 /* }}} copy_clip_rectangle_list */
 236
 237
 238
 239 /* {{{ proto void copy_page()
 240    */
 241 PHP_METHOD(CairoContext, copy_page)
 242 {
 243         zend_class_entry * _this_ce;
 244
 245         zval * _this_zval = NULL;
 246
 247
 248
 249         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 250                 return;
 251         }
 252
 253         _this_ce = Z_OBJCE_P(_this_zval);
 254
 255
 256         php_error(E_WARNING, "copy_page: not yet implemented"); RETURN_FALSE;
 257
 258 }
 259 /* }}} copy_page */
 260
 261
 262
 263 /* {{{ proto object copy_path()
 264    */
 265 PHP_METHOD(CairoContext, copy_path)
 266 {
 267         zend_class_entry * _this_ce;
 268
 269         zval * _this_zval = NULL;
 270
 271
 272
 273         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 274                 return;
 275         }
 276
 277         _this_ce = Z_OBJCE_P(_this_zval);
 278
 279
 280         php_error(E_WARNING, "copy_path: not yet implemented"); RETURN_FALSE;
 281
 282         object_init(return_value)
 283 }
 284 /* }}} copy_path */
 285
 286
 287
 288 /* {{{ proto object copy_path_flat()
 289    */
 290 PHP_METHOD(CairoContext, copy_path_flat)
 291 {
 292         zend_class_entry * _this_ce;
 293
 294         zval * _this_zval = NULL;
 295
 296
 297
 298         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 299                 return;
 300         }
 301
 302         _this_ce = Z_OBJCE_P(_this_zval);
 303
 304
 305         php_error(E_WARNING, "copy_path_flat: not yet implemented"); RETURN_FALSE;
 306
 307         object_init(return_value)
 308 }
 309 /* }}} copy_path_flat */
 310
 311
 312
 313 /* {{{ proto void curve_to (float x1, float y1, float x2, float y2, float x3, float y3)
 314    */
 315 PHP_METHOD(CairoContext, curve_to)
 316 {
 317         zend_class_entry * _this_ce;
 318
 319         zval * _this_zval = NULL;
 320         double x1 = 0.0;
 321         double y1 = 0.0;
 322         double x2 = 0.0;
 323         double y2 = 0.0;
 324         double x3 = 0.0;
 325         double y3 = 0.0;
 326
 327
 328
 329         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odddddd", &_this_zval, CairoContext_ce_ptr, &x1, &y1, &x2, &y2, &x3, &y3) == FAILURE) {
 330                 return;
 331         }
 332
 333         _this_ce = Z_OBJCE_P(_this_zval);
 334
 335
 336         php_error(E_WARNING, "curve_to: not yet implemented"); RETURN_FALSE;
 337
 338 }
 339 /* }}} curve_to */
 340
 341
 342
 343 /* {{{ proto array device_to_user(float x, float y)
 344    */
 345 PHP_METHOD(CairoContext, device_to_user)
 346 {
 347         zend_class_entry * _this_ce;
 348
 349         zval * _this_zval = NULL;
 350         double x = 0.0;
 351         double y = 0.0;
 352
 353
 354
 355         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoContext_ce_ptr, &x, &y) == FAILURE) {
 356                 return;
 357         }
 358
 359         _this_ce = Z_OBJCE_P(_this_zval);
 360
 361
 362         array_init(return_value);
 363
 364         php_error(E_WARNING, "device_to_user: not yet implemented"); RETURN_FALSE;
 365
 366         array_init(return_value);
 367 }
 368 /* }}} device_to_user */
 369
 370
 371
 372 /* {{{ proto array device_to_user_distance(float x, float y)
 373    */
 374 PHP_METHOD(CairoContext, device_to_user_distance)
 375 {
 376         zend_class_entry * _this_ce;
 377
 378         zval * _this_zval = NULL;
 379         double x = 0.0;
 380         double y = 0.0;
 381
 382
 383
 384         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoContext_ce_ptr, &x, &y) == FAILURE) {
 385                 return;
 386         }
 387
 388         _this_ce = Z_OBJCE_P(_this_zval);
 389
 390
 391         array_init(return_value);
 392
 393         php_error(E_WARNING, "device_to_user_distance: not yet implemented"); RETURN_FALSE;
 394
 395         array_init(return_value);
 396 }
 397 /* }}} device_to_user_distance */
 398
 399
 400
 401 /* {{{ proto void fill()
 402    */
 403 PHP_METHOD(CairoContext, fill)
 404 {
 405         zend_class_entry * _this_ce;
 406
 407         zval * _this_zval = NULL;
 408
 409
 410
 411         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 412                 return;
 413         }
 414
 415         _this_ce = Z_OBJCE_P(_this_zval);
 416
 417
 418         php_error(E_WARNING, "fill: not yet implemented"); RETURN_FALSE;
 419
 420 }
 421 /* }}} fill */
 422
 423
 424
 425 /* {{{ proto array fill_extents()
 426    */
 427 PHP_METHOD(CairoContext, fill_extents)
 428 {
 429         zend_class_entry * _this_ce;
 430
 431         zval * _this_zval = NULL;
 432
 433
 434
 435         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 436                 return;
 437         }
 438
 439         _this_ce = Z_OBJCE_P(_this_zval);
 440
 441
 442         array_init(return_value);
 443
 444         php_error(E_WARNING, "fill_extents: not yet implemented"); RETURN_FALSE;
 445
 446         array_init(return_value);
 447 }
 448 /* }}} fill_extents */
 449
 450
 451
 452 /* {{{ proto void fill_preserve()
 453    */
 454 PHP_METHOD(CairoContext, fill_preserve)
 455 {
 456         zend_class_entry * _this_ce;
 457
 458         zval * _this_zval = NULL;
 459
 460
 461
 462         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 463                 return;
 464         }
 465
 466         _this_ce = Z_OBJCE_P(_this_zval);
 467
 468
 469         php_error(E_WARNING, "fill_preserve: not yet implemented"); RETURN_FALSE;
 470
 471 }
 472 /* }}} fill_preserve */
 473
 474
 475
 476 /* {{{ proto array font_extents()
 477    */
 478 PHP_METHOD(CairoContext, font_extents)
 479 {
 480         zend_class_entry * _this_ce;
 481
 482         zval * _this_zval = NULL;
 483
 484
 485
 486         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 487                 return;
 488         }
 489
 490         _this_ce = Z_OBJCE_P(_this_zval);
 491
 492
 493         array_init(return_value);
 494
 495         php_error(E_WARNING, "font_extents: not yet implemented"); RETURN_FALSE;
 496
 497         array_init(return_value);
 498 }
 499 /* }}} font_extents */
 500
 501
 502
 503 /* {{{ proto int get_antialias()
 504    */
 505 PHP_METHOD(CairoContext, get_antialias)
 506 {
 507         zend_class_entry * _this_ce;
 508
 509         zval * _this_zval = NULL;
 510
 511
 512
 513         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 514                 return;
 515         }
 516
 517         _this_ce = Z_OBJCE_P(_this_zval);
 518
 519
 520         php_error(E_WARNING, "get_antialias: not yet implemented"); RETURN_FALSE;
 521
 522         RETURN_LONG(0);
 523 }
 524 /* }}} get_antialias */
 525
 526
 527
 528 /* {{{ proto array get_current_point()
 529    */
 530 PHP_METHOD(CairoContext, get_current_point)
 531 {
 532         zend_class_entry * _this_ce;
 533
 534         zval * _this_zval = NULL;
 535
 536
 537
 538         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 539                 return;
 540         }
 541
 542         _this_ce = Z_OBJCE_P(_this_zval);
 543
 544
 545         array_init(return_value);
 546
 547         php_error(E_WARNING, "get_current_point: not yet implemented"); RETURN_FALSE;
 548
 549         array_init(return_value);
 550 }
 551 /* }}} get_current_point */
 552
 553
 554
 555 /* {{{ proto array get_dash()
 556    */
 557 PHP_METHOD(CairoContext, get_dash)
 558 {
 559         zend_class_entry * _this_ce;
 560
 561         zval * _this_zval = NULL;
 562
 563
 564
 565         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 566                 return;
 567         }
 568
 569         _this_ce = Z_OBJCE_P(_this_zval);
 570
 571
 572         array_init(return_value);
 573
 574         php_error(E_WARNING, "get_dash: not yet implemented"); RETURN_FALSE;
 575
 576         array_init(return_value);
 577 }
 578 /* }}} get_dash */
 579
 580
 581
 582 /* {{{ proto int get_dash_count()
 583    */
 584 PHP_METHOD(CairoContext, get_dash_count)
 585 {
 586         zend_class_entry * _this_ce;
 587
 588         zval * _this_zval = NULL;
 589
 590
 591
 592         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 593                 return;
 594         }
 595
 596         _this_ce = Z_OBJCE_P(_this_zval);
 597
 598
 599         php_error(E_WARNING, "get_dash_count: not yet implemented"); RETURN_FALSE;
 600
 601         RETURN_LONG(0);
 602 }
 603 /* }}} get_dash_count */
 604
 605
 606
 607 /* {{{ proto int get_fill_rule()
 608    */
 609 PHP_METHOD(CairoContext, get_fill_rule)
 610 {
 611         zend_class_entry * _this_ce;
 612
 613         zval * _this_zval = NULL;
 614
 615
 616
 617         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 618                 return;
 619         }
 620
 621         _this_ce = Z_OBJCE_P(_this_zval);
 622
 623
 624         php_error(E_WARNING, "get_fill_rule: not yet implemented"); RETURN_FALSE;
 625
 626         RETURN_LONG(0);
 627 }
 628 /* }}} get_fill_rule */
 629
 630
 631
 632 /* {{{ proto object get_font_face()
 633    */
 634 PHP_METHOD(CairoContext, get_font_face)
 635 {
 636         zend_class_entry * _this_ce;
 637
 638         zval * _this_zval = NULL;
 639
 640
 641
 642         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 643                 return;
 644         }
 645
 646         _this_ce = Z_OBJCE_P(_this_zval);
 647
 648
 649         php_error(E_WARNING, "get_font_face: not yet implemented"); RETURN_FALSE;
 650
 651         object_init(return_value)
 652 }
 653 /* }}} get_font_face */
 654
 655
 656
 657 /* {{{ proto object get_font_matrix()
 658    */
 659 PHP_METHOD(CairoContext, get_font_matrix)
 660 {
 661         zend_class_entry * _this_ce;
 662
 663         zval * _this_zval = NULL;
 664
 665
 666
 667         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 668                 return;
 669         }
 670
 671         _this_ce = Z_OBJCE_P(_this_zval);
 672
 673
 674         php_error(E_WARNING, "get_font_matrix: not yet implemented"); RETURN_FALSE;
 675
 676         object_init(return_value)
 677 }
 678 /* }}} get_font_matrix */
 679
 680
 681
 682 /* {{{ proto object get_font_options()
 683    */
 684 PHP_METHOD(CairoContext, get_font_options)
 685 {
 686         zend_class_entry * _this_ce;
 687
 688         zval * _this_zval = NULL;
 689
 690
 691
 692         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 693                 return;
 694         }
 695
 696         _this_ce = Z_OBJCE_P(_this_zval);
 697
 698
 699         php_error(E_WARNING, "get_font_options: not yet implemented"); RETURN_FALSE;
 700
 701         object_init(return_value)
 702 }
 703 /* }}} get_font_options */
 704
 705
 706
 707 /* {{{ proto object get_group_target()
 708    */
 709 PHP_METHOD(CairoContext, get_group_target)
 710 {
 711         zend_class_entry * _this_ce;
 712
 713         zval * _this_zval = NULL;
 714
 715
 716
 717         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 718                 return;
 719         }
 720
 721         _this_ce = Z_OBJCE_P(_this_zval);
 722
 723
 724         php_error(E_WARNING, "get_group_target: not yet implemented"); RETURN_FALSE;
 725
 726         object_init(return_value)
 727 }
 728 /* }}} get_group_target */
 729
 730
 731
 732 /* {{{ proto int get_line_cap()
 733    */
 734 PHP_METHOD(CairoContext, get_line_cap)
 735 {
 736         zend_class_entry * _this_ce;
 737
 738         zval * _this_zval = NULL;
 739
 740
 741
 742         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 743                 return;
 744         }
 745
 746         _this_ce = Z_OBJCE_P(_this_zval);
 747
 748
 749         php_error(E_WARNING, "get_line_cap: not yet implemented"); RETURN_FALSE;
 750
 751         RETURN_LONG(0);
 752 }
 753 /* }}} get_line_cap */
 754
 755
 756
 757 /* {{{ proto int get_line_join()
 758    */
 759 PHP_METHOD(CairoContext, get_line_join)
 760 {
 761         zend_class_entry * _this_ce;
 762
 763         zval * _this_zval = NULL;
 764
 765
 766
 767         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 768                 return;
 769         }
 770
 771         _this_ce = Z_OBJCE_P(_this_zval);
 772
 773
 774         php_error(E_WARNING, "get_line_join: not yet implemented"); RETURN_FALSE;
 775
 776         RETURN_LONG(0);
 777 }
 778 /* }}} get_line_join */
 779
 780
 781
 782 /* {{{ proto float get_line_width()
 783    */
 784 PHP_METHOD(CairoContext, get_line_width)
 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, CairoContext_ce_ptr) == FAILURE) {
 793                 return;
 794         }
 795
 796         _this_ce = Z_OBJCE_P(_this_zval);
 797
 798
 799         php_error(E_WARNING, "get_line_width: not yet implemented"); RETURN_FALSE;
 800
 801         RETURN_DOUBLE(0.0);
 802 }
 803 /* }}} get_line_width */
 804
 805
 806
 807 /* {{{ proto object get_matrix()
 808    */
 809 PHP_METHOD(CairoContext, get_matrix)
 810 {
 811         zend_class_entry * _this_ce;
 812
 813         zval * _this_zval = NULL;
 814
 815
 816
 817         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 818                 return;
 819         }
 820
 821         _this_ce = Z_OBJCE_P(_this_zval);
 822
 823
 824         php_error(E_WARNING, "get_matrix: not yet implemented"); RETURN_FALSE;
 825
 826         object_init(return_value)
 827 }
 828 /* }}} get_matrix */
 829
 830
 831
 832 /* {{{ proto float get_matrix_limit()
 833    */
 834 PHP_METHOD(CairoContext, get_matrix_limit)
 835 {
 836         zend_class_entry * _this_ce;
 837
 838         zval * _this_zval = NULL;
 839
 840
 841
 842         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 843                 return;
 844         }
 845
 846         _this_ce = Z_OBJCE_P(_this_zval);
 847
 848
 849         php_error(E_WARNING, "get_matrix_limit: not yet implemented"); RETURN_FALSE;
 850
 851         RETURN_DOUBLE(0.0);
 852 }
 853 /* }}} get_matrix_limit */
 854
 855
 856
 857 /* {{{ proto int get_operator()
 858    */
 859 PHP_METHOD(CairoContext, get_operator)
 860 {
 861         zend_class_entry * _this_ce;
 862
 863         zval * _this_zval = NULL;
 864
 865
 866
 867         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 868                 return;
 869         }
 870
 871         _this_ce = Z_OBJCE_P(_this_zval);
 872
 873
 874         php_error(E_WARNING, "get_operator: not yet implemented"); RETURN_FALSE;
 875
 876         RETURN_LONG(0);
 877 }
 878 /* }}} get_operator */
 879
 880
 881
 882 /* {{{ proto object get_scaled_font()
 883    */
 884 PHP_METHOD(CairoContext, get_scaled_font)
 885 {
 886         zend_class_entry * _this_ce;
 887
 888         zval * _this_zval = NULL;
 889
 890
 891
 892         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 893                 return;
 894         }
 895
 896         _this_ce = Z_OBJCE_P(_this_zval);
 897
 898
 899         php_error(E_WARNING, "get_scaled_font: not yet implemented"); RETURN_FALSE;
 900
 901         object_init(return_value)
 902 }
 903 /* }}} get_scaled_font */
 904
 905
 906
 907 /* {{{ proto object get_source()
 908    */
 909 PHP_METHOD(CairoContext, get_source)
 910 {
 911         zend_class_entry * _this_ce;
 912
 913         zval * _this_zval = NULL;
 914
 915
 916
 917         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 918                 return;
 919         }
 920
 921         _this_ce = Z_OBJCE_P(_this_zval);
 922
 923
 924         php_error(E_WARNING, "get_source: not yet implemented"); RETURN_FALSE;
 925
 926         object_init(return_value)
 927 }
 928 /* }}} get_source */
 929
 930
 931
 932 /* {{{ proto object get_target()
 933    */
 934 PHP_METHOD(CairoContext, get_target)
 935 {
 936         zend_class_entry * _this_ce;
 937
 938         zval * _this_zval = NULL;
 939
 940
 941
 942         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 943                 return;
 944         }
 945
 946         _this_ce = Z_OBJCE_P(_this_zval);
 947
 948
 949         php_error(E_WARNING, "get_target: not yet implemented"); RETURN_FALSE;
 950
 951         object_init(return_value)
 952 }
 953 /* }}} get_target */
 954
 955
 956
 957 /* {{{ proto float get_tolerance()
 958    */
 959 PHP_METHOD(CairoContext, get_tolerance)
 960 {
 961         zend_class_entry * _this_ce;
 962
 963         zval * _this_zval = NULL;
 964
 965
 966
 967         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
 968                 return;
 969         }
 970
 971         _this_ce = Z_OBJCE_P(_this_zval);
 972
 973
 974         php_error(E_WARNING, "get_tolerance: not yet implemented"); RETURN_FALSE;
 975
 976         RETURN_DOUBLE(0.0);
 977 }
 978 /* }}} get_tolerance */
 979
 980
 981
 982 /* {{{ proto array get_extents(object obj[,int num])
 983    */
 984 PHP_METHOD(CairoContext, glyph_extents)
 985 {
 986         zend_class_entry * _this_ce;
 987
 988         zval * _this_zval = NULL;
 989         zval * obj = NULL;
 990         long num = 0;
 991
 992
 993
 994         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo|l", &_this_zval, CairoContext_ce_ptr, &obj, &num) == FAILURE) {
 995                 return;
 996         }
 997
 998         _this_ce = Z_OBJCE_P(_this_zval);
 999
1000
1001         array_init(return_value);
1002
1003         do {
1004                 /*This might be a prob*/
1005         } while (0);
1006 }
1007 /* }}} glyph_extents */
1008
1009
1010
1011 /* {{{ proto void glyph_pat(object obh[,int num])
1012    */
1013 PHP_METHOD(CairoContext, glyph_path)
1014 {
1015         zend_class_entry * _this_ce;
1016
1017         zval * _this_zval = NULL;
1018         zval * obh = NULL;
1019         long num = 0;
1020
1021
1022
1023         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo|l", &_this_zval, CairoContext_ce_ptr, &obh, &num) == FAILURE) {
1024                 return;
1025         }
1026
1027         _this_ce = Z_OBJCE_P(_this_zval);
1028
1029
1030         php_error(E_WARNING, "glyph_path: not yet implemented"); RETURN_FALSE;
1031
1032 }
1033 /* }}} glyph_path */
1034
1035
1036
1037 /* {{{ proto bool has_current_point()
1038    */
1039 PHP_METHOD(CairoContext, has_current_point)
1040 {
1041         zend_class_entry * _this_ce;
1042
1043         zval * _this_zval = NULL;
1044
1045
1046
1047         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
1048                 return;
1049         }
1050
1051         _this_ce = Z_OBJCE_P(_this_zval);
1052
1053
1054         do {
1055                 /* ONLY for CAIRO 1.6 */
1056         } while (0);
1057 }
1058 /* }}} has_current_point */
1059
1060
1061
1062 /* {{{ proto void identity_matrix()
1063    */
1064 PHP_METHOD(CairoContext, identity_matrix)
1065 {
1066         zend_class_entry * _this_ce;
1067
1068         zval * _this_zval = NULL;
1069
1070
1071
1072         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
1073                 return;
1074         }
1075
1076         _this_ce = Z_OBJCE_P(_this_zval);
1077
1078
1079         php_error(E_WARNING, "identity_matrix: not yet implemented"); RETURN_FALSE;
1080
1081 }
1082 /* }}} identity_matrix */
1083
1084
1085
1086 /* {{{ proto bool in_fill(float x, float y)
1087    */
1088 PHP_METHOD(CairoContext, in_fill)
1089 {
1090         zend_class_entry * _this_ce;
1091
1092         zval * _this_zval = NULL;
1093         double x = 0.0;
1094         double y = 0.0;
1095
1096
1097
1098         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoContext_ce_ptr, &x, &y) == FAILURE) {
1099                 return;
1100         }
1101
1102         _this_ce = Z_OBJCE_P(_this_zval);
1103
1104
1105         php_error(E_WARNING, "in_fill: not yet implemented"); RETURN_FALSE;
1106
1107         RETURN_FALSE;
1108 }
1109 /* }}} in_fill */
1110
1111
1112
1113 /* {{{ proto bool in_stroke(float x, float y)
1114    */
1115 PHP_METHOD(CairoContext, in_stroke)
1116 {
1117         zend_class_entry * _this_ce;
1118
1119         zval * _this_zval = NULL;
1120         double x = 0.0;
1121         double y = 0.0;
1122
1123
1124
1125         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoContext_ce_ptr, &x, &y) == FAILURE) {
1126                 return;
1127         }
1128
1129         _this_ce = Z_OBJCE_P(_this_zval);
1130
1131
1132         php_error(E_WARNING, "in_stroke: not yet implemented"); RETURN_FALSE;
1133
1134         RETURN_FALSE;
1135 }
1136 /* }}} in_stroke */
1137
1138
1139
1140 /* {{{ proto void line_to(float x, float y)
1141    */
1142 PHP_METHOD(CairoContext, line_to)
1143 {
1144         zend_class_entry * _this_ce;
1145
1146         zval * _this_zval = NULL;
1147         double x = 0.0;
1148         double y = 0.0;
1149
1150
1151
1152         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoContext_ce_ptr, &x, &y) == FAILURE) {
1153                 return;
1154         }
1155
1156         _this_ce = Z_OBJCE_P(_this_zval);
1157
1158
1159         php_error(E_WARNING, "line_to: not yet implemented"); RETURN_FALSE;
1160
1161 }
1162 /* }}} line_to */
1163
1164
1165
1166 /* {{{ proto void mask(object p)
1167    */
1168 PHP_METHOD(CairoContext, mask)
1169 {
1170         zend_class_entry * _this_ce;
1171
1172         zval * _this_zval = NULL;
1173         zval * p = NULL;
1174
1175
1176
1177         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo", &_this_zval, CairoContext_ce_ptr, &p) == FAILURE) {
1178                 return;
1179         }
1180
1181         _this_ce = Z_OBJCE_P(_this_zval);
1182
1183
1184         php_error(E_WARNING, "mask: not yet implemented"); RETURN_FALSE;
1185
1186 }
1187 /* }}} mask */
1188
1189
1190
1191 /* {{{ proto void mask_surface(object s[,float surface_x, float surface_y])
1192    */
1193 PHP_METHOD(CairoContext, mask_surface)
1194 {
1195         zend_class_entry * _this_ce;
1196
1197         zval * _this_zval = NULL;
1198         zval * s = NULL;
1199         double surface_x = 0.0;
1200         double surface_y = 0.0;
1201
1202
1203
1204         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo|dd", &_this_zval, CairoContext_ce_ptr, &s, &surface_x, &surface_y) == FAILURE) {
1205                 return;
1206         }
1207
1208         _this_ce = Z_OBJCE_P(_this_zval);
1209
1210
1211         php_error(E_WARNING, "mask_surface: not yet implemented"); RETURN_FALSE;
1212
1213 }
1214 /* }}} mask_surface */
1215
1216
1217
1218 /* {{{ proto void move_to(float x, float y)
1219    */
1220 PHP_METHOD(CairoContext, move_to)
1221 {
1222         zend_class_entry * _this_ce;
1223
1224         zval * _this_zval = NULL;
1225         double x = 0.0;
1226         double y = 0.0;
1227
1228
1229
1230         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoContext_ce_ptr, &x, &y) == FAILURE) {
1231                 return;
1232         }
1233
1234         _this_ce = Z_OBJCE_P(_this_zval);
1235
1236
1237         php_error(E_WARNING, "move_to: not yet implemented"); RETURN_FALSE;
1238
1239 }
1240 /* }}} move_to */
1241
1242
1243
1244 /* {{{ proto void new_path()
1245    */
1246 PHP_METHOD(CairoContext, new_path)
1247 {
1248         zend_class_entry * _this_ce;
1249
1250         zval * _this_zval = NULL;
1251
1252
1253
1254         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
1255                 return;
1256         }
1257
1258         _this_ce = Z_OBJCE_P(_this_zval);
1259
1260
1261         php_error(E_WARNING, "new_path: not yet implemented"); RETURN_FALSE;
1262
1263 }
1264 /* }}} new_path */
1265
1266
1267
1268 /* {{{ proto void new_sub_path()
1269    */
1270 PHP_METHOD(CairoContext, new_sub_path)
1271 {
1272         zend_class_entry * _this_ce;
1273
1274         zval * _this_zval = NULL;
1275
1276
1277
1278         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
1279                 return;
1280         }
1281
1282         _this_ce = Z_OBJCE_P(_this_zval);
1283
1284
1285         php_error(E_WARNING, "new_sub_path: not yet implemented"); RETURN_FALSE;
1286
1287 }
1288 /* }}} new_sub_path */
1289
1290
1291
1292 /* {{{ proto void paint()
1293    */
1294 PHP_METHOD(CairoContext, paint)
1295 {
1296         zend_class_entry * _this_ce;
1297
1298         zval * _this_zval = NULL;
1299
1300
1301
1302         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
1303                 return;
1304         }
1305
1306         _this_ce = Z_OBJCE_P(_this_zval);
1307
1308
1309         php_error(E_WARNING, "paint: not yet implemented"); RETURN_FALSE;
1310
1311 }
1312 /* }}} paint */
1313
1314
1315
1316 /* {{{ proto void paint_with_alpha(float alpha)
1317    */
1318 PHP_METHOD(CairoContext, paint_with_alpha)
1319 {
1320         zend_class_entry * _this_ce;
1321
1322         zval * _this_zval = NULL;
1323         double alpha = 0.0;
1324
1325
1326
1327         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Od", &_this_zval, CairoContext_ce_ptr, &alpha) == FAILURE) {
1328                 return;
1329         }
1330
1331         _this_ce = Z_OBJCE_P(_this_zval);
1332
1333
1334         php_error(E_WARNING, "paint_with_alpha: not yet implemented"); RETURN_FALSE;
1335
1336 }
1337 /* }}} paint_with_alpha */
1338
1339
1340
1341 /* {{{ proto array path_extents([object path])
1342    */
1343 PHP_METHOD(CairoContext, path_extents)
1344 {
1345         zend_class_entry * _this_ce;
1346
1347         zval * _this_zval = NULL;
1348         zval * path = NULL;
1349
1350
1351
1352         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|o", &_this_zval, CairoContext_ce_ptr, &path) == FAILURE) {
1353                 return;
1354         }
1355
1356         _this_ce = Z_OBJCE_P(_this_zval);
1357
1358
1359         array_init(return_value);
1360
1361         do {
1362                 /* ONLY for CAIRO 1.6 */
1363         } while (0);
1364 }
1365 /* }}} path_extents */
1366
1367
1368
1369 /* {{{ proto object pop_group()
1370    */
1371 PHP_METHOD(CairoContext, pop_group)
1372 {
1373         zend_class_entry * _this_ce;
1374
1375         zval * _this_zval = NULL;
1376
1377
1378
1379         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
1380                 return;
1381         }
1382
1383         _this_ce = Z_OBJCE_P(_this_zval);
1384
1385
1386         php_error(E_WARNING, "pop_group: not yet implemented"); RETURN_FALSE;
1387
1388         object_init(return_value)
1389 }
1390 /* }}} pop_group */
1391
1392
1393
1394 /* {{{ proto void pop_group_to_source()
1395    */
1396 PHP_METHOD(CairoContext, pop_group_to_source)
1397 {
1398         zend_class_entry * _this_ce;
1399
1400         zval * _this_zval = NULL;
1401
1402
1403
1404         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
1405                 return;
1406         }
1407
1408         _this_ce = Z_OBJCE_P(_this_zval);
1409
1410
1411         php_error(E_WARNING, "pop_group_to_source: not yet implemented"); RETURN_FALSE;
1412
1413 }
1414 /* }}} pop_group_to_source */
1415
1416
1417
1418 /* {{{ proto void push_group()
1419    */
1420 PHP_METHOD(CairoContext, push_group)
1421 {
1422         zend_class_entry * _this_ce;
1423
1424         zval * _this_zval = NULL;
1425
1426
1427
1428         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
1429                 return;
1430         }
1431
1432         _this_ce = Z_OBJCE_P(_this_zval);
1433
1434
1435         php_error(E_WARNING, "push_group: not yet implemented"); RETURN_FALSE;
1436
1437 }
1438 /* }}} push_group */
1439
1440
1441
1442 /* {{{ proto void push_group_with_content(int content)
1443    */
1444 PHP_METHOD(CairoContext, push_group_with_content)
1445 {
1446         zend_class_entry * _this_ce;
1447
1448         zval * _this_zval = NULL;
1449         long content = 0;
1450
1451
1452
1453         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &_this_zval, CairoContext_ce_ptr, &content) == FAILURE) {
1454                 return;
1455         }
1456
1457         _this_ce = Z_OBJCE_P(_this_zval);
1458
1459
1460         php_error(E_WARNING, "push_group_with_content: not yet implemented"); RETURN_FALSE;
1461
1462 }
1463 /* }}} push_group_with_content */
1464
1465
1466
1467 /* {{{ proto void rectangle(float x, float y, float width, float height)
1468    */
1469 PHP_METHOD(CairoContext, rectangle)
1470 {
1471         zend_class_entry * _this_ce;
1472
1473         zval * _this_zval = NULL;
1474         double x = 0.0;
1475         double y = 0.0;
1476         double width = 0.0;
1477         double height = 0.0;
1478
1479
1480
1481         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odddd", &_this_zval, CairoContext_ce_ptr, &x, &y, &width, &height) == FAILURE) {
1482                 return;
1483         }
1484
1485         _this_ce = Z_OBJCE_P(_this_zval);
1486
1487
1488         php_error(E_WARNING, "rectangle: not yet implemented"); RETURN_FALSE;
1489
1490 }
1491 /* }}} rectangle */
1492
1493
1494
1495 /* {{{ proto void rel_curve_to(float x1, float y1, float x2, float y2, float x3, float y3)
1496    */
1497 PHP_METHOD(CairoContext, rel_curve_to)
1498 {
1499         zend_class_entry * _this_ce;
1500
1501         zval * _this_zval = NULL;
1502         double x1 = 0.0;
1503         double y1 = 0.0;
1504         double x2 = 0.0;
1505         double y2 = 0.0;
1506         double x3 = 0.0;
1507         double y3 = 0.0;
1508
1509
1510
1511         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odddddd", &_this_zval, CairoContext_ce_ptr, &x1, &y1, &x2, &y2, &x3, &y3) == FAILURE) {
1512                 return;
1513         }
1514
1515         _this_ce = Z_OBJCE_P(_this_zval);
1516
1517
1518         php_error(E_WARNING, "rel_curve_to: not yet implemented"); RETURN_FALSE;
1519
1520 }
1521 /* }}} rel_curve_to */
1522
1523
1524
1525 /* {{{ proto void rel_line_to(float x, float y)
1526    */
1527 PHP_METHOD(CairoContext, rel_line_to)
1528 {
1529         zend_class_entry * _this_ce;
1530
1531         zval * _this_zval = NULL;
1532         double x = 0.0;
1533         double y = 0.0;
1534
1535
1536
1537         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoContext_ce_ptr, &x, &y) == FAILURE) {
1538                 return;
1539         }
1540
1541         _this_ce = Z_OBJCE_P(_this_zval);
1542
1543
1544         php_error(E_WARNING, "rel_line_to: not yet implemented"); RETURN_FALSE;
1545
1546 }
1547 /* }}} rel_line_to */
1548
1549
1550
1551 /* {{{ proto void rel_move_to(float x, float y)
1552    */
1553 PHP_METHOD(CairoContext, rel_move_to)
1554 {
1555         zend_class_entry * _this_ce;
1556
1557         zval * _this_zval = NULL;
1558         double x = 0.0;
1559         double y = 0.0;
1560
1561
1562
1563         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoContext_ce_ptr, &x, &y) == FAILURE) {
1564                 return;
1565         }
1566
1567         _this_ce = Z_OBJCE_P(_this_zval);
1568
1569
1570         php_error(E_WARNING, "rel_move_to: not yet implemented"); RETURN_FALSE;
1571
1572 }
1573 /* }}} rel_move_to */
1574
1575
1576
1577 /* {{{ proto void reset_clip()
1578    */
1579 PHP_METHOD(CairoContext, reset_clip)
1580 {
1581         zend_class_entry * _this_ce;
1582
1583         zval * _this_zval = NULL;
1584
1585
1586
1587         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
1588                 return;
1589         }
1590
1591         _this_ce = Z_OBJCE_P(_this_zval);
1592
1593
1594         php_error(E_WARNING, "reset_clip: not yet implemented"); RETURN_FALSE;
1595
1596 }
1597 /* }}} reset_clip */
1598
1599
1600
1601 /* {{{ proto void restore()
1602    */
1603 PHP_METHOD(CairoContext, restore)
1604 {
1605         zend_class_entry * _this_ce;
1606
1607         zval * _this_zval = NULL;
1608
1609
1610
1611         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
1612                 return;
1613         }
1614
1615         _this_ce = Z_OBJCE_P(_this_zval);
1616
1617
1618         php_error(E_WARNING, "restore: not yet implemented"); RETURN_FALSE;
1619
1620 }
1621 /* }}} restore */
1622
1623
1624
1625 /* {{{ proto void rotate(float angle)
1626    */
1627 PHP_METHOD(CairoContext, rotate)
1628 {
1629         zend_class_entry * _this_ce;
1630
1631         zval * _this_zval = NULL;
1632         double angle = 0.0;
1633
1634
1635
1636         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Od", &_this_zval, CairoContext_ce_ptr, &angle) == FAILURE) {
1637                 return;
1638         }
1639
1640         _this_ce = Z_OBJCE_P(_this_zval);
1641
1642
1643         php_error(E_WARNING, "rotate: not yet implemented"); RETURN_FALSE;
1644
1645 }
1646 /* }}} rotate */
1647
1648
1649
1650 /* {{{ proto void save()
1651    */
1652 PHP_METHOD(CairoContext, save)
1653 {
1654         zend_class_entry * _this_ce;
1655
1656         zval * _this_zval = NULL;
1657
1658
1659
1660         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
1661                 return;
1662         }
1663
1664         _this_ce = Z_OBJCE_P(_this_zval);
1665
1666
1667         php_error(E_WARNING, "save: not yet implemented"); RETURN_FALSE;
1668
1669 }
1670 /* }}} save */
1671
1672
1673
1674 /* {{{ proto void scale(float x, float y)
1675    */
1676 PHP_METHOD(CairoContext, scale)
1677 {
1678         zend_class_entry * _this_ce;
1679
1680         zval * _this_zval = NULL;
1681         double x = 0.0;
1682         double y = 0.0;
1683
1684
1685
1686         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoContext_ce_ptr, &x, &y) == FAILURE) {
1687                 return;
1688         }
1689
1690         _this_ce = Z_OBJCE_P(_this_zval);
1691
1692
1693         php_error(E_WARNING, "scale: not yet implemented"); RETURN_FALSE;
1694
1695 }
1696 /* }}} scale */
1697
1698
1699
1700 /* {{{ proto void select_font_face(object obj[, int slant, int weight])
1701    */
1702 PHP_METHOD(CairoContext, select_font_face)
1703 {
1704         zend_class_entry * _this_ce;
1705
1706         zval * _this_zval = NULL;
1707         zval * obj = NULL;
1708         long slant = 0;
1709         long weight = 0;
1710
1711
1712
1713         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo|ll", &_this_zval, CairoContext_ce_ptr, &obj, &slant, &weight) == FAILURE) {
1714                 return;
1715         }
1716
1717         _this_ce = Z_OBJCE_P(_this_zval);
1718
1719
1720         php_error(E_WARNING, "select_font_face: not yet implemented"); RETURN_FALSE;
1721
1722 }
1723 /* }}} select_font_face */
1724
1725
1726
1727 /* {{{ proto void set_antialias([int antialias])
1728    */
1729 PHP_METHOD(CairoContext, set_antialias)
1730 {
1731         zend_class_entry * _this_ce;
1732
1733         zval * _this_zval = NULL;
1734         long antialias = 0;
1735
1736
1737
1738         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|l", &_this_zval, CairoContext_ce_ptr, &antialias) == FAILURE) {
1739                 return;
1740         }
1741
1742         _this_ce = Z_OBJCE_P(_this_zval);
1743
1744
1745         php_error(E_WARNING, "set_antialias: not yet implemented"); RETURN_FALSE;
1746
1747 }
1748 /* }}} set_antialias */
1749
1750
1751
1752 /* {{{ proto void set_dash(object dashes [,float offset])
1753    */
1754 PHP_METHOD(CairoContext, set_dash)
1755 {
1756         zend_class_entry * _this_ce;
1757
1758         zval * _this_zval = NULL;
1759         zval * dashes = NULL;
1760         double offset = 0.0;
1761
1762
1763
1764         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo|d", &_this_zval, CairoContext_ce_ptr, &dashes, &offset) == FAILURE) {
1765                 return;
1766         }
1767
1768         _this_ce = Z_OBJCE_P(_this_zval);
1769
1770
1771         php_error(E_WARNING, "set_dash: not yet implemented"); RETURN_FALSE;
1772
1773 }
1774 /* }}} set_dash */
1775
1776
1777
1778 /* {{{ proto void set_fill_rule(int fill_rule)
1779    */
1780 PHP_METHOD(CairoContext, set_fill_rule)
1781 {
1782         zend_class_entry * _this_ce;
1783
1784         zval * _this_zval = NULL;
1785         long fill_rule = 0;
1786
1787
1788
1789         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &_this_zval, CairoContext_ce_ptr, &fill_rule) == FAILURE) {
1790                 return;
1791         }
1792
1793         _this_ce = Z_OBJCE_P(_this_zval);
1794
1795
1796         php_error(E_WARNING, "set_fill_rule: not yet implemented"); RETURN_FALSE;
1797
1798 }
1799 /* }}} set_fill_rule */
1800
1801
1802
1803 /* {{{ proto void set_font_face([object obj])
1804    */
1805 PHP_METHOD(CairoContext, set_font_face)
1806 {
1807         zend_class_entry * _this_ce;
1808
1809         zval * _this_zval = NULL;
1810         zval * obj = NULL;
1811
1812
1813
1814         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|o", &_this_zval, CairoContext_ce_ptr, &obj) == FAILURE) {
1815                 return;
1816         }
1817
1818         _this_ce = Z_OBJCE_P(_this_zval);
1819
1820
1821         php_error(E_WARNING, "set_font_face: not yet implemented"); RETURN_FALSE;
1822
1823 }
1824 /* }}} set_font_face */
1825
1826
1827
1828 /* {{{ proto void set_font_matrix(object matrix)
1829    */
1830 PHP_METHOD(CairoContext, set_font_matrix)
1831 {
1832         zend_class_entry * _this_ce;
1833
1834         zval * _this_zval = NULL;
1835         zval * matrix = NULL;
1836
1837
1838
1839         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo", &_this_zval, CairoContext_ce_ptr, &matrix) == FAILURE) {
1840                 return;
1841         }
1842
1843         _this_ce = Z_OBJCE_P(_this_zval);
1844
1845
1846         php_error(E_WARNING, "set_font_matrix: not yet implemented"); RETURN_FALSE;
1847
1848 }
1849 /* }}} set_font_matrix */
1850
1851
1852
1853 /* {{{ proto void set_font_options(object options)
1854    */
1855 PHP_METHOD(CairoContext, set_font_options)
1856 {
1857         zend_class_entry * _this_ce;
1858
1859         zval * _this_zval = NULL;
1860         zval * options = NULL;
1861
1862
1863
1864         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo", &_this_zval, CairoContext_ce_ptr, &options) == FAILURE) {
1865                 return;
1866         }
1867
1868         _this_ce = Z_OBJCE_P(_this_zval);
1869
1870
1871         php_error(E_WARNING, "set_font_options: not yet implemented"); RETURN_FALSE;
1872
1873 }
1874 /* }}} set_font_options */
1875
1876
1877
1878 /* {{{ proto void set_font_size(float size)
1879    */
1880 PHP_METHOD(CairoContext, set_font_size)
1881 {
1882         zend_class_entry * _this_ce;
1883
1884         zval * _this_zval = NULL;
1885         double size = 0.0;
1886
1887
1888
1889         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Od", &_this_zval, CairoContext_ce_ptr, &size) == FAILURE) {
1890                 return;
1891         }
1892
1893         _this_ce = Z_OBJCE_P(_this_zval);
1894
1895
1896         php_error(E_WARNING, "set_font_size: not yet implemented"); RETURN_FALSE;
1897
1898 }
1899 /* }}} set_font_size */
1900
1901
1902
1903 /* {{{ proto void set_line_cap(int line_cap)
1904    */
1905 PHP_METHOD(CairoContext, set_line_cap)
1906 {
1907         zend_class_entry * _this_ce;
1908
1909         zval * _this_zval = NULL;
1910         long line_cap = 0;
1911
1912
1913
1914         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &_this_zval, CairoContext_ce_ptr, &line_cap) == FAILURE) {
1915                 return;
1916         }
1917
1918         _this_ce = Z_OBJCE_P(_this_zval);
1919
1920
1921         php_error(E_WARNING, "set_line_cap: not yet implemented"); RETURN_FALSE;
1922
1923 }
1924 /* }}} set_line_cap */
1925
1926
1927
1928 /* {{{ proto void set_line_join(int line_join)
1929    */
1930 PHP_METHOD(CairoContext, set_line_join)
1931 {
1932         zend_class_entry * _this_ce;
1933
1934         zval * _this_zval = NULL;
1935         long line_join = 0;
1936
1937
1938
1939         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &_this_zval, CairoContext_ce_ptr, &line_join) == FAILURE) {
1940                 return;
1941         }
1942
1943         _this_ce = Z_OBJCE_P(_this_zval);
1944
1945
1946         php_error(E_WARNING, "set_line_join: not yet implemented"); RETURN_FALSE;
1947
1948 }
1949 /* }}} set_line_join */
1950
1951
1952
1953 /* {{{ proto void set_line_width(float width)
1954    */
1955 PHP_METHOD(CairoContext, set_line_width)
1956 {
1957         zend_class_entry * _this_ce;
1958
1959         zval * _this_zval = NULL;
1960         double width = 0.0;
1961
1962
1963
1964         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Od", &_this_zval, CairoContext_ce_ptr, &width) == FAILURE) {
1965                 return;
1966         }
1967
1968         _this_ce = Z_OBJCE_P(_this_zval);
1969
1970
1971         php_error(E_WARNING, "set_line_width: not yet implemented"); RETURN_FALSE;
1972
1973 }
1974 /* }}} set_line_width */
1975
1976
1977
1978 /* {{{ proto void set_matrix(object matix)
1979    */
1980 PHP_METHOD(CairoContext, set_matrix)
1981 {
1982         zend_class_entry * _this_ce;
1983
1984         zval * _this_zval = NULL;
1985         zval * matix = NULL;
1986
1987
1988
1989         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo", &_this_zval, CairoContext_ce_ptr, &matix) == FAILURE) {
1990                 return;
1991         }
1992
1993         _this_ce = Z_OBJCE_P(_this_zval);
1994
1995
1996         php_error(E_WARNING, "set_matrix: not yet implemented"); RETURN_FALSE;
1997
1998 }
1999 /* }}} set_matrix */
2000
2001
2002
2003 /* {{{ proto void set_miter_limit(float limit)
2004    */
2005 PHP_METHOD(CairoContext, set_miter_limit)
2006 {
2007         zend_class_entry * _this_ce;
2008
2009         zval * _this_zval = NULL;
2010         double limit = 0.0;
2011
2012
2013
2014         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Od", &_this_zval, CairoContext_ce_ptr, &limit) == FAILURE) {
2015                 return;
2016         }
2017
2018         _this_ce = Z_OBJCE_P(_this_zval);
2019
2020
2021         php_error(E_WARNING, "set_miter_limit: not yet implemented"); RETURN_FALSE;
2022
2023 }
2024 /* }}} set_miter_limit */
2025
2026
2027
2028 /* {{{ proto void set_operator(int op)
2029    */
2030 PHP_METHOD(CairoContext, set_operator)
2031 {
2032         zend_class_entry * _this_ce;
2033
2034         zval * _this_zval = NULL;
2035         long op = 0;
2036
2037
2038
2039         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &_this_zval, CairoContext_ce_ptr, &op) == FAILURE) {
2040                 return;
2041         }
2042
2043         _this_ce = Z_OBJCE_P(_this_zval);
2044
2045
2046         php_error(E_WARNING, "set_operator: not yet implemented"); RETURN_FALSE;
2047
2048 }
2049 /* }}} set_operator */
2050
2051
2052
2053 /* {{{ proto void set_source(object p)
2054    */
2055 PHP_METHOD(CairoContext, set_source)
2056 {
2057         zend_class_entry * _this_ce;
2058
2059         zval * _this_zval = NULL;
2060         zval * p = NULL;
2061
2062
2063
2064         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo", &_this_zval, CairoContext_ce_ptr, &p) == FAILURE) {
2065                 return;
2066         }
2067
2068         _this_ce = Z_OBJCE_P(_this_zval);
2069
2070
2071         php_error(E_WARNING, "set_source: not yet implemented"); RETURN_FALSE;
2072
2073 }
2074 /* }}} set_source */
2075
2076
2077
2078 /* {{{ proto void set_source_rgb(float red, float green, float blue)
2079    */
2080 PHP_METHOD(CairoContext, set_source_rgb)
2081 {
2082         zend_class_entry * _this_ce;
2083
2084         zval * _this_zval = NULL;
2085         double red = 0.0;
2086         double green = 0.0;
2087         double blue = 0.0;
2088
2089
2090
2091         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oddd", &_this_zval, CairoContext_ce_ptr, &red, &green, &blue) == FAILURE) {
2092                 return;
2093         }
2094
2095         _this_ce = Z_OBJCE_P(_this_zval);
2096
2097
2098         php_error(E_WARNING, "set_source_rgb: not yet implemented"); RETURN_FALSE;
2099
2100 }
2101 /* }}} set_source_rgb */
2102
2103
2104
2105 /* {{{ proto void set_source_rgba(float red, float green, float blue [,float alpha])
2106    */
2107 PHP_METHOD(CairoContext, set_source_rgba)
2108 {
2109         zend_class_entry * _this_ce;
2110
2111         zval * _this_zval = NULL;
2112         double red = 0.0;
2113         double green = 0.0;
2114         double blue = 0.0;
2115         double alpha = 0.0;
2116
2117
2118
2119         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oddd|d", &_this_zval, CairoContext_ce_ptr, &red, &green, &blue, &alpha) == FAILURE) {
2120                 return;
2121         }
2122
2123         _this_ce = Z_OBJCE_P(_this_zval);
2124
2125
2126         php_error(E_WARNING, "set_source_rgba: not yet implemented"); RETURN_FALSE;
2127
2128 }
2129 /* }}} set_source_rgba */
2130
2131
2132
2133 /* {{{ proto void set_source_surface(object surface [,float x, float y])
2134    */
2135 PHP_METHOD(CairoContext, set_source_surface)
2136 {
2137         zend_class_entry * _this_ce;
2138
2139         zval * _this_zval = NULL;
2140         zval * surface = NULL;
2141         double x = 0.0;
2142         double y = 0.0;
2143
2144
2145
2146         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo|dd", &_this_zval, CairoContext_ce_ptr, &surface, &x, &y) == FAILURE) {
2147                 return;
2148         }
2149
2150         _this_ce = Z_OBJCE_P(_this_zval);
2151
2152
2153         php_error(E_WARNING, "set_source_surface: not yet implemented"); RETURN_FALSE;
2154
2155 }
2156 /* }}} set_source_surface */
2157
2158
2159
2160 /* {{{ proto void set_tolerance(float tolerance)
2161    */
2162 PHP_METHOD(CairoContext, set_tolerance)
2163 {
2164         zend_class_entry * _this_ce;
2165
2166         zval * _this_zval = NULL;
2167         double tolerance = 0.0;
2168
2169
2170
2171         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Od", &_this_zval, CairoContext_ce_ptr, &tolerance) == FAILURE) {
2172                 return;
2173         }
2174
2175         _this_ce = Z_OBJCE_P(_this_zval);
2176
2177
2178         php_error(E_WARNING, "set_tolerance: not yet implemented"); RETURN_FALSE;
2179
2180 }
2181 /* }}} set_tolerance */
2182
2183
2184
2185 /* {{{ proto void show_glyphs(object glyphs [,int num_glyphs])
2186    */
2187 PHP_METHOD(CairoContext, show_glyphs)
2188 {
2189         zend_class_entry * _this_ce;
2190
2191         zval * _this_zval = NULL;
2192         zval * glyphs = NULL;
2193         long num_glyphs = 0;
2194
2195
2196
2197         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo|l", &_this_zval, CairoContext_ce_ptr, &glyphs, &num_glyphs) == FAILURE) {
2198                 return;
2199         }
2200
2201         _this_ce = Z_OBJCE_P(_this_zval);
2202
2203
2204         php_error(E_WARNING, "show_glyphs: not yet implemented"); RETURN_FALSE;
2205
2206 }
2207 /* }}} show_glyphs */
2208
2209
2210
2211 /* {{{ proto void show_page()
2212    */
2213 PHP_METHOD(CairoContext, show_page)
2214 {
2215         zend_class_entry * _this_ce;
2216
2217         zval * _this_zval = NULL;
2218
2219
2220
2221         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
2222                 return;
2223         }
2224
2225         _this_ce = Z_OBJCE_P(_this_zval);
2226
2227
2228         php_error(E_WARNING, "show_page: not yet implemented"); RETURN_FALSE;
2229
2230 }
2231 /* }}} show_page */
2232
2233
2234
2235 /* {{{ proto void show_text(object obj)
2236    */
2237 PHP_METHOD(CairoContext, show_text)
2238 {
2239         zend_class_entry * _this_ce;
2240
2241         zval * _this_zval = NULL;
2242         zval * obj = NULL;
2243
2244
2245
2246         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo", &_this_zval, CairoContext_ce_ptr, &obj) == FAILURE) {
2247                 return;
2248         }
2249
2250         _this_ce = Z_OBJCE_P(_this_zval);
2251
2252
2253         php_error(E_WARNING, "show_text: not yet implemented"); RETURN_FALSE;
2254
2255 }
2256 /* }}} show_text */
2257
2258
2259
2260 /* {{{ proto void stroke()
2261    */
2262 PHP_METHOD(CairoContext, stroke)
2263 {
2264         zend_class_entry * _this_ce;
2265
2266         zval * _this_zval = NULL;
2267
2268
2269
2270         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
2271                 return;
2272         }
2273
2274         _this_ce = Z_OBJCE_P(_this_zval);
2275
2276
2277         php_error(E_WARNING, "stroke: not yet implemented"); RETURN_FALSE;
2278
2279 }
2280 /* }}} stroke */
2281
2282
2283
2284 /* {{{ proto array stroke_extents()
2285    */
2286 PHP_METHOD(CairoContext, stroke_extents)
2287 {
2288         zend_class_entry * _this_ce;
2289
2290         zval * _this_zval = NULL;
2291
2292
2293
2294         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
2295                 return;
2296         }
2297
2298         _this_ce = Z_OBJCE_P(_this_zval);
2299
2300
2301         array_init(return_value);
2302
2303         php_error(E_WARNING, "stroke_extents: not yet implemented"); RETURN_FALSE;
2304
2305         array_init(return_value);
2306 }
2307 /* }}} stroke_extents */
2308
2309
2310
2311 /* {{{ proto void stroke_preserve()
2312    */
2313 PHP_METHOD(CairoContext, stroke_preserve)
2314 {
2315         zend_class_entry * _this_ce;
2316
2317         zval * _this_zval = NULL;
2318
2319
2320
2321         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoContext_ce_ptr) == FAILURE) {
2322                 return;
2323         }
2324
2325         _this_ce = Z_OBJCE_P(_this_zval);
2326
2327
2328         php_error(E_WARNING, "stroke_preserve: not yet implemented"); RETURN_FALSE;
2329
2330 }
2331 /* }}} stroke_preserve */
2332
2333
2334
2335 /* {{{ proto array text_extents(object extents)
2336    */
2337 PHP_METHOD(CairoContext, text_extents)
2338 {
2339         zend_class_entry * _this_ce;
2340
2341         zval * _this_zval = NULL;
2342         zval * extents = NULL;
2343
2344
2345
2346         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo", &_this_zval, CairoContext_ce_ptr, &extents) == FAILURE) {
2347                 return;
2348         }
2349
2350         _this_ce = Z_OBJCE_P(_this_zval);
2351
2352
2353         array_init(return_value);
2354
2355         php_error(E_WARNING, "text_extents: not yet implemented"); RETURN_FALSE;
2356
2357         array_init(return_value);
2358 }
2359 /* }}} text_extents */
2360
2361
2362
2363 /* {{{ proto void text_path(object obj)
2364    */
2365 PHP_METHOD(CairoContext, text_path)
2366 {
2367         zend_class_entry * _this_ce;
2368
2369         zval * _this_zval = NULL;
2370         zval * obj = NULL;
2371
2372
2373
2374         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo", &_this_zval, CairoContext_ce_ptr, &obj) == FAILURE) {
2375                 return;
2376         }
2377
2378         _this_ce = Z_OBJCE_P(_this_zval);
2379
2380
2381         php_error(E_WARNING, "text_path: not yet implemented"); RETURN_FALSE;
2382
2383 }
2384 /* }}} text_path */
2385
2386
2387
2388 /* {{{ proto void transform(object matrix)
2389    */
2390 PHP_METHOD(CairoContext, transform)
2391 {
2392         zend_class_entry * _this_ce;
2393
2394         zval * _this_zval = NULL;
2395         zval * matrix = NULL;
2396
2397
2398
2399         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo", &_this_zval, CairoContext_ce_ptr, &matrix) == FAILURE) {
2400                 return;
2401         }
2402
2403         _this_ce = Z_OBJCE_P(_this_zval);
2404
2405
2406         php_error(E_WARNING, "transform: not yet implemented"); RETURN_FALSE;
2407
2408 }
2409 /* }}} transform */
2410
2411
2412
2413 /* {{{ proto void translate(float tx, float ty)
2414    */
2415 PHP_METHOD(CairoContext, translate)
2416 {
2417         zend_class_entry * _this_ce;
2418
2419         zval * _this_zval = NULL;
2420         double tx = 0.0;
2421         double ty = 0.0;
2422
2423
2424
2425         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoContext_ce_ptr, &tx, &ty) == FAILURE) {
2426                 return;
2427         }
2428
2429         _this_ce = Z_OBJCE_P(_this_zval);
2430
2431
2432         php_error(E_WARNING, "translate: not yet implemented"); RETURN_FALSE;
2433
2434 }
2435 /* }}} translate */
2436
2437
2438
2439 /* {{{ proto array user_to_device(float x, float y)
2440    */
2441 PHP_METHOD(CairoContext, user_to_device)
2442 {
2443         zend_class_entry * _this_ce;
2444
2445         zval * _this_zval = NULL;
2446         double x = 0.0;
2447         double y = 0.0;
2448
2449
2450
2451         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoContext_ce_ptr, &x, &y) == FAILURE) {
2452                 return;
2453         }
2454
2455         _this_ce = Z_OBJCE_P(_this_zval);
2456
2457
2458         array_init(return_value);
2459
2460         php_error(E_WARNING, "user_to_device: not yet implemented"); RETURN_FALSE;
2461
2462         array_init(return_value);
2463 }
2464 /* }}} user_to_device */
2465
2466
2467
2468 /* {{{ proto array user_to_device_distance(float dx, float dy)
2469    */
2470 PHP_METHOD(CairoContext, user_to_device_distance)
2471 {
2472         zend_class_entry * _this_ce;
2473
2474         zval * _this_zval = NULL;
2475         double dx = 0.0;
2476         double dy = 0.0;
2477
2478
2479
2480         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoContext_ce_ptr, &dx, &dy) == FAILURE) {
2481                 return;
2482         }
2483
2484         _this_ce = Z_OBJCE_P(_this_zval);
2485
2486
2487         array_init(return_value);
2488
2489         php_error(E_WARNING, "user_to_device_distance: not yet implemented"); RETURN_FALSE;
2490
2491         array_init(return_value);
2492 }
2493 /* }}} user_to_device_distance */
2494
2495
2496 static zend_function_entry CairoContext_methods[] = {
2497         PHP_ME(CairoContext, append_path, CairoContext__append_path_args, /**/ZEND_ACC_PUBLIC)
2498         PHP_ME(CairoContext, arc, CairoContext__arc_args, /**/ZEND_ACC_PUBLIC)
2499         PHP_ME(CairoContext, arc_negative, CairoContext__arc_negative_args, /**/ZEND_ACC_PUBLIC)
2500         PHP_ME(CairoContext, clip, NULL, /**/ZEND_ACC_PUBLIC)
2501         PHP_ME(CairoContext, clip_extents, NULL, /**/ZEND_ACC_PUBLIC)
2502         PHP_ME(CairoContext, clip_preserve, NULL, /**/ZEND_ACC_PUBLIC)
2503         PHP_ME(CairoContext, close_path, NULL, /**/ZEND_ACC_PUBLIC)
2504         PHP_ME(CairoContext, copy_clip_rectangle_list, NULL, /**/ZEND_ACC_PUBLIC)
2505         PHP_ME(CairoContext, copy_page, NULL, /**/ZEND_ACC_PUBLIC)
2506         PHP_ME(CairoContext, copy_path, NULL, /**/ZEND_ACC_PUBLIC)
2507         PHP_ME(CairoContext, copy_path_flat, NULL, /**/ZEND_ACC_PUBLIC)
2508         PHP_ME(CairoContext, curve_to, CairoContext__curve_to_args, /**/ZEND_ACC_PUBLIC)
2509         PHP_ME(CairoContext, device_to_user, CairoContext__device_to_user_args, /**/ZEND_ACC_PUBLIC)
2510         PHP_ME(CairoContext, device_to_user_distance, CairoContext__device_to_user_distance_args, /**/ZEND_ACC_PUBLIC)
2511         PHP_ME(CairoContext, fill, NULL, /**/ZEND_ACC_PUBLIC)
2512         PHP_ME(CairoContext, fill_extents, NULL, /**/ZEND_ACC_PUBLIC)
2513         PHP_ME(CairoContext, fill_preserve, NULL, /**/ZEND_ACC_PUBLIC)
2514         PHP_ME(CairoContext, font_extents, NULL, /**/ZEND_ACC_PUBLIC)
2515         PHP_ME(CairoContext, get_antialias, NULL, /**/ZEND_ACC_PUBLIC)
2516         PHP_ME(CairoContext, get_current_point, NULL, /**/ZEND_ACC_PUBLIC)
2517         PHP_ME(CairoContext, get_dash, NULL, /**/ZEND_ACC_PUBLIC)
2518         PHP_ME(CairoContext, get_dash_count, NULL, /**/ZEND_ACC_PUBLIC)
2519         PHP_ME(CairoContext, get_fill_rule, NULL, /**/ZEND_ACC_PUBLIC)
2520         PHP_ME(CairoContext, get_font_face, NULL, /**/ZEND_ACC_PUBLIC)
2521         PHP_ME(CairoContext, get_font_matrix, NULL, /**/ZEND_ACC_PUBLIC)
2522         PHP_ME(CairoContext, get_font_options, NULL, /**/ZEND_ACC_PUBLIC)
2523         PHP_ME(CairoContext, get_group_target, NULL, /**/ZEND_ACC_PUBLIC)
2524         PHP_ME(CairoContext, get_line_cap, NULL, /**/ZEND_ACC_PUBLIC)
2525         PHP_ME(CairoContext, get_line_join, NULL, /**/ZEND_ACC_PUBLIC)
2526         PHP_ME(CairoContext, get_line_width, NULL, /**/ZEND_ACC_PUBLIC)
2527         PHP_ME(CairoContext, get_matrix, NULL, /**/ZEND_ACC_PUBLIC)
2528         PHP_ME(CairoContext, get_matrix_limit, NULL, /**/ZEND_ACC_PUBLIC)
2529         PHP_ME(CairoContext, get_operator, NULL, /**/ZEND_ACC_PUBLIC)
2530         PHP_ME(CairoContext, get_scaled_font, NULL, /**/ZEND_ACC_PUBLIC)
2531         PHP_ME(CairoContext, get_source, NULL, /**/ZEND_ACC_PUBLIC)
2532         PHP_ME(CairoContext, get_target, NULL, /**/ZEND_ACC_PUBLIC)
2533         PHP_ME(CairoContext, get_tolerance, NULL, /**/ZEND_ACC_PUBLIC)
2534         PHP_ME(CairoContext, glyph_extents, CairoContext__glyph_extents_args, /**/ZEND_ACC_PUBLIC)
2535         PHP_ME(CairoContext, glyph_path, CairoContext__glyph_path_args, /**/ZEND_ACC_PUBLIC)
2536         PHP_ME(CairoContext, has_current_point, NULL, /**/ZEND_ACC_PUBLIC)
2537         PHP_ME(CairoContext, identity_matrix, NULL, /**/ZEND_ACC_PUBLIC)
2538         PHP_ME(CairoContext, in_fill, CairoContext__in_fill_args, /**/ZEND_ACC_PUBLIC)
2539         PHP_ME(CairoContext, in_stroke, CairoContext__in_stroke_args, /**/ZEND_ACC_PUBLIC)
2540         PHP_ME(CairoContext, line_to, CairoContext__line_to_args, /**/ZEND_ACC_PUBLIC)
2541         PHP_ME(CairoContext, mask, CairoContext__mask_args, /**/ZEND_ACC_PUBLIC)
2542         PHP_ME(CairoContext, mask_surface, CairoContext__mask_surface_args, /**/ZEND_ACC_PUBLIC)
2543         PHP_ME(CairoContext, move_to, CairoContext__move_to_args, /**/ZEND_ACC_PUBLIC)
2544         PHP_ME(CairoContext, new_path, NULL, /**/ZEND_ACC_PUBLIC)
2545         PHP_ME(CairoContext, new_sub_path, NULL, /**/ZEND_ACC_PUBLIC)
2546         PHP_ME(CairoContext, paint, NULL, /**/ZEND_ACC_PUBLIC)
2547         PHP_ME(CairoContext, paint_with_alpha, CairoContext__paint_with_alpha_args, /**/ZEND_ACC_PUBLIC)
2548         PHP_ME(CairoContext, path_extents, CairoContext__path_extents_args, /**/ZEND_ACC_PUBLIC)
2549         PHP_ME(CairoContext, pop_group, NULL, /**/ZEND_ACC_PUBLIC)
2550         PHP_ME(CairoContext, pop_group_to_source, NULL, /**/ZEND_ACC_PUBLIC)
2551         PHP_ME(CairoContext, push_group, NULL, /**/ZEND_ACC_PUBLIC)
2552         PHP_ME(CairoContext, push_group_with_content, CairoContext__push_group_with_content_args, /**/ZEND_ACC_PUBLIC)
2553         PHP_ME(CairoContext, rectangle, CairoContext__rectangle_args, /**/ZEND_ACC_PUBLIC)
2554         PHP_ME(CairoContext, rel_curve_to, CairoContext__rel_curve_to_args, /**/ZEND_ACC_PUBLIC)
2555         PHP_ME(CairoContext, rel_line_to, CairoContext__rel_line_to_args, /**/ZEND_ACC_PUBLIC)
2556         PHP_ME(CairoContext, rel_move_to, CairoContext__rel_move_to_args, /**/ZEND_ACC_PUBLIC)
2557         PHP_ME(CairoContext, reset_clip, NULL, /**/ZEND_ACC_PUBLIC)
2558         PHP_ME(CairoContext, restore, NULL, /**/ZEND_ACC_PUBLIC)
2559         PHP_ME(CairoContext, rotate, CairoContext__rotate_args, /**/ZEND_ACC_PUBLIC)
2560         PHP_ME(CairoContext, save, NULL, /**/ZEND_ACC_PUBLIC)
2561         PHP_ME(CairoContext, scale, CairoContext__scale_args, /**/ZEND_ACC_PUBLIC)
2562         PHP_ME(CairoContext, select_font_face, CairoContext__select_font_face_args, /**/ZEND_ACC_PUBLIC)
2563         PHP_ME(CairoContext, set_antialias, CairoContext__set_antialias_args, /**/ZEND_ACC_PUBLIC)
2564         PHP_ME(CairoContext, set_dash, CairoContext__set_dash_args, /**/ZEND_ACC_PUBLIC)
2565         PHP_ME(CairoContext, set_fill_rule, CairoContext__set_fill_rule_args, /**/ZEND_ACC_PUBLIC)
2566         PHP_ME(CairoContext, set_font_face, CairoContext__set_font_face_args, /**/ZEND_ACC_PUBLIC)
2567         PHP_ME(CairoContext, set_font_matrix, CairoContext__set_font_matrix_args, /**/ZEND_ACC_PUBLIC)
2568         PHP_ME(CairoContext, set_font_options, CairoContext__set_font_options_args, /**/ZEND_ACC_PUBLIC)
2569         PHP_ME(CairoContext, set_font_size, CairoContext__set_font_size_args, /**/ZEND_ACC_PUBLIC)
2570         PHP_ME(CairoContext, set_line_cap, CairoContext__set_line_cap_args, /**/ZEND_ACC_PUBLIC)
2571         PHP_ME(CairoContext, set_line_join, CairoContext__set_line_join_args, /**/ZEND_ACC_PUBLIC)
2572         PHP_ME(CairoContext, set_line_width, CairoContext__set_line_width_args, /**/ZEND_ACC_PUBLIC)
2573         PHP_ME(CairoContext, set_matrix, CairoContext__set_matrix_args, /**/ZEND_ACC_PUBLIC)
2574         PHP_ME(CairoContext, set_miter_limit, CairoContext__set_miter_limit_args, /**/ZEND_ACC_PUBLIC)
2575         PHP_ME(CairoContext, set_operator, CairoContext__set_operator_args, /**/ZEND_ACC_PUBLIC)
2576         PHP_ME(CairoContext, set_source, CairoContext__set_source_args, /**/ZEND_ACC_PUBLIC)
2577         PHP_ME(CairoContext, set_source_rgb, CairoContext__set_source_rgb_args, /**/ZEND_ACC_PUBLIC)
2578         PHP_ME(CairoContext, set_source_rgba, CairoContext__set_source_rgba_args, /**/ZEND_ACC_PUBLIC)
2579         PHP_ME(CairoContext, set_source_surface, CairoContext__set_source_surface_args, /**/ZEND_ACC_PUBLIC)
2580         PHP_ME(CairoContext, set_tolerance, CairoContext__set_tolerance_args, /**/ZEND_ACC_PUBLIC)
2581         PHP_ME(CairoContext, show_glyphs, CairoContext__show_glyphs_args, /**/ZEND_ACC_PUBLIC)
2582         PHP_ME(CairoContext, show_page, NULL, /**/ZEND_ACC_PUBLIC)
2583         PHP_ME(CairoContext, show_text, CairoContext__show_text_args, /**/ZEND_ACC_PUBLIC)
2584         PHP_ME(CairoContext, stroke, NULL, /**/ZEND_ACC_PUBLIC)
2585         PHP_ME(CairoContext, stroke_extents, NULL, /**/ZEND_ACC_PUBLIC)
2586         PHP_ME(CairoContext, stroke_preserve, NULL, /**/ZEND_ACC_PUBLIC)
2587         PHP_ME(CairoContext, text_extents, CairoContext__text_extents_args, /**/ZEND_ACC_PUBLIC)
2588         PHP_ME(CairoContext, text_path, CairoContext__text_path_args, /**/ZEND_ACC_PUBLIC)
2589         PHP_ME(CairoContext, transform, CairoContext__transform_args, /**/ZEND_ACC_PUBLIC)
2590         PHP_ME(CairoContext, translate, CairoContext__translate_args, /**/ZEND_ACC_PUBLIC)
2591         PHP_ME(CairoContext, user_to_device, CairoContext__user_to_device_args, /**/ZEND_ACC_PUBLIC)
2592         PHP_ME(CairoContext, user_to_device_distance, CairoContext__user_to_device_distance_args, /**/ZEND_ACC_PUBLIC)
2593         { NULL, NULL, NULL }
2594 };
2595
2596 /* }}} Methods */
2597
2598 static void class_init_CairoContext(void)
2599 {
2600         zend_class_entry ce;
2601
2602         INIT_CLASS_ENTRY(ce, "CairoContext", CairoContext_methods);
2603         CairoContext_ce_ptr = zend_register_internal_class(&ce);
2604 }
2605
2606 /* }}} Class CairoContext */
2607
2608 /* {{{ Class CairoFontFace */
2609
2610 static zend_class_entry * CairoFontFace_ce_ptr = NULL;
2611
2612 /* {{{ Methods */
2613
2614
2615 /* {{{ proto void construct()
2616    */
2617 PHP_METHOD(CairoFontFace, __construct)
2618 {
2619         zend_class_entry * _this_ce;
2620         zval * _this_zval;
2621
2622
2623
2624         if (ZEND_NUM_ARGS()>0)  {
2625                 WRONG_PARAM_COUNT;
2626         }
2627
2628
2629         do {
2630                 /* not allowede to create an object directly*/
2631         } while (0);
2632 }
2633 /* }}} __construct */
2634
2635
2636
2637 /* {{{ proto void destruct()
2638    */
2639 PHP_METHOD(CairoFontFace, __destruct)
2640 {
2641         zend_class_entry * _this_ce;
2642
2643         zval * _this_zval = NULL;
2644
2645
2646
2647         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoFontFace_ce_ptr) == FAILURE) {
2648                 return;
2649         }
2650
2651         _this_ce = Z_OBJCE_P(_this_zval);
2652
2653
2654         php_error(E_WARNING, "__destruct: not yet implemented"); RETURN_FALSE;
2655
2656 }
2657 /* }}} __destruct */
2658
2659
2660 static zend_function_entry CairoFontFace_methods[] = {
2661         PHP_ME(CairoFontFace, __construct, NULL, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
2662         PHP_ME(CairoFontFace, __destruct, NULL, /**/ZEND_ACC_PUBLIC)
2663         { NULL, NULL, NULL }
2664 };
2665
2666 /* }}} Methods */
2667
2668 static void class_init_CairoFontFace(void)
2669 {
2670         zend_class_entry ce;
2671
2672         INIT_CLASS_ENTRY(ce, "CairoFontFace", CairoFontFace_methods);
2673         CairoFontFace_ce_ptr = zend_register_internal_class(&ce);
2674 }
2675
2676 /* }}} Class CairoFontFace */
2677
2678 /* {{{ Class CairoFontOptions */
2679
2680 static zend_class_entry * CairoFontOptions_ce_ptr = NULL;
2681
2682 /* {{{ Methods */
2683
2684
2685 /* {{{ proto void construct()
2686    */
2687 PHP_METHOD(CairoFontOptions, __construct)
2688 {
2689         zend_class_entry * _this_ce;
2690         zval * _this_zval;
2691
2692
2693
2694         if (ZEND_NUM_ARGS()>0)  {
2695                 WRONG_PARAM_COUNT;
2696         }
2697
2698
2699         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
2700
2701 }
2702 /* }}} __construct */
2703
2704
2705
2706 /* {{{ proto int get_antialias()
2707    */
2708 PHP_METHOD(CairoFontOptions, get_antialias)
2709 {
2710         zend_class_entry * _this_ce;
2711
2712         zval * _this_zval = NULL;
2713
2714
2715
2716         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoFontOptions_ce_ptr) == FAILURE) {
2717                 return;
2718         }
2719
2720         _this_ce = Z_OBJCE_P(_this_zval);
2721
2722
2723         php_error(E_WARNING, "get_antialias: not yet implemented"); RETURN_FALSE;
2724
2725         RETURN_LONG(0);
2726 }
2727 /* }}} get_antialias */
2728
2729
2730
2731 /* {{{ proto int get_hint_metrics()
2732    */
2733 PHP_METHOD(CairoFontOptions, get_hint_metrics)
2734 {
2735         zend_class_entry * _this_ce;
2736
2737         zval * _this_zval = NULL;
2738
2739
2740
2741         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoFontOptions_ce_ptr) == FAILURE) {
2742                 return;
2743         }
2744
2745         _this_ce = Z_OBJCE_P(_this_zval);
2746
2747
2748         php_error(E_WARNING, "get_hint_metrics: not yet implemented"); RETURN_FALSE;
2749
2750         RETURN_LONG(0);
2751 }
2752 /* }}} get_hint_metrics */
2753
2754
2755
2756 /* {{{ proto int get_hint_style()
2757    */
2758 PHP_METHOD(CairoFontOptions, get_hint_style)
2759 {
2760         zend_class_entry * _this_ce;
2761
2762         zval * _this_zval = NULL;
2763
2764
2765
2766         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoFontOptions_ce_ptr) == FAILURE) {
2767                 return;
2768         }
2769
2770         _this_ce = Z_OBJCE_P(_this_zval);
2771
2772
2773         php_error(E_WARNING, "get_hint_style: not yet implemented"); RETURN_FALSE;
2774
2775         RETURN_LONG(0);
2776 }
2777 /* }}} get_hint_style */
2778
2779
2780
2781 /* {{{ proto int get_subpixel_order()
2782    */
2783 PHP_METHOD(CairoFontOptions, get_subpixel_order)
2784 {
2785         zend_class_entry * _this_ce;
2786
2787         zval * _this_zval = NULL;
2788
2789
2790
2791         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoFontOptions_ce_ptr) == FAILURE) {
2792                 return;
2793         }
2794
2795         _this_ce = Z_OBJCE_P(_this_zval);
2796
2797
2798         php_error(E_WARNING, "get_subpixel_order: not yet implemented"); RETURN_FALSE;
2799
2800         RETURN_LONG(0);
2801 }
2802 /* }}} get_subpixel_order */
2803
2804
2805
2806 /* {{{ proto void set_antialias([int aa])
2807    */
2808 PHP_METHOD(CairoFontOptions, set_antialias)
2809 {
2810         zend_class_entry * _this_ce;
2811
2812         zval * _this_zval = NULL;
2813         long aa = 0;
2814
2815
2816
2817         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|l", &_this_zval, CairoFontOptions_ce_ptr, &aa) == FAILURE) {
2818                 return;
2819         }
2820
2821         _this_ce = Z_OBJCE_P(_this_zval);
2822
2823
2824         php_error(E_WARNING, "set_antialias: not yet implemented"); RETURN_FALSE;
2825
2826 }
2827 /* }}} set_antialias */
2828
2829
2830
2831 /* {{{ proto void set_hint_metrics([int hm])
2832    */
2833 PHP_METHOD(CairoFontOptions, set_hint_metrics)
2834 {
2835         zend_class_entry * _this_ce;
2836
2837         zval * _this_zval = NULL;
2838         long hm = 0;
2839
2840
2841
2842         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|l", &_this_zval, CairoFontOptions_ce_ptr, &hm) == FAILURE) {
2843                 return;
2844         }
2845
2846         _this_ce = Z_OBJCE_P(_this_zval);
2847
2848
2849         php_error(E_WARNING, "set_hint_metrics: not yet implemented"); RETURN_FALSE;
2850
2851 }
2852 /* }}} set_hint_metrics */
2853
2854
2855
2856 /* {{{ proto void set_hint_style([int hs])
2857    */
2858 PHP_METHOD(CairoFontOptions, set_hint_style)
2859 {
2860         zend_class_entry * _this_ce;
2861
2862         zval * _this_zval = NULL;
2863         long hs = 0;
2864
2865
2866
2867         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|l", &_this_zval, CairoFontOptions_ce_ptr, &hs) == FAILURE) {
2868                 return;
2869         }
2870
2871         _this_ce = Z_OBJCE_P(_this_zval);
2872
2873
2874         php_error(E_WARNING, "set_hint_style: not yet implemented"); RETURN_FALSE;
2875
2876 }
2877 /* }}} set_hint_style */
2878
2879
2880
2881 /* {{{ proto void set_subpixel_order([int so])
2882    */
2883 PHP_METHOD(CairoFontOptions, set_subpixel_order)
2884 {
2885         zend_class_entry * _this_ce;
2886
2887         zval * _this_zval = NULL;
2888         long so = 0;
2889
2890
2891
2892         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|l", &_this_zval, CairoFontOptions_ce_ptr, &so) == FAILURE) {
2893                 return;
2894         }
2895
2896         _this_ce = Z_OBJCE_P(_this_zval);
2897
2898
2899         php_error(E_WARNING, "set_subpixel_order: not yet implemented"); RETURN_FALSE;
2900
2901 }
2902 /* }}} set_subpixel_order */
2903
2904
2905 static zend_function_entry CairoFontOptions_methods[] = {
2906         PHP_ME(CairoFontOptions, __construct, NULL, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
2907         PHP_ME(CairoFontOptions, get_antialias, NULL, /**/ZEND_ACC_PUBLIC)
2908         PHP_ME(CairoFontOptions, get_hint_metrics, NULL, /**/ZEND_ACC_PUBLIC)
2909         PHP_ME(CairoFontOptions, get_hint_style, NULL, /**/ZEND_ACC_PUBLIC)
2910         PHP_ME(CairoFontOptions, get_subpixel_order, NULL, /**/ZEND_ACC_PUBLIC)
2911         PHP_ME(CairoFontOptions, set_antialias, CairoFontOptions__set_antialias_args, /**/ZEND_ACC_PUBLIC)
2912         PHP_ME(CairoFontOptions, set_hint_metrics, CairoFontOptions__set_hint_metrics_args, /**/ZEND_ACC_PUBLIC)
2913         PHP_ME(CairoFontOptions, set_hint_style, CairoFontOptions__set_hint_style_args, /**/ZEND_ACC_PUBLIC)
2914         PHP_ME(CairoFontOptions, set_subpixel_order, CairoFontOptions__set_subpixel_order_args, /**/ZEND_ACC_PUBLIC)
2915         { NULL, NULL, NULL }
2916 };
2917
2918 /* }}} Methods */
2919
2920 static void class_init_CairoFontOptions(void)
2921 {
2922         zend_class_entry ce;
2923
2924         INIT_CLASS_ENTRY(ce, "CairoFontOptions", CairoFontOptions_methods);
2925         CairoFontOptions_ce_ptr = zend_register_internal_class(&ce);
2926 }
2927
2928 /* }}} Class CairoFontOptions */
2929
2930 /* {{{ Class CairoMatrix */
2931
2932 static zend_class_entry * CairoMatrix_ce_ptr = NULL;
2933
2934 /* {{{ Methods */
2935
2936
2937 /* {{{ proto void construct([float xx, float yx, float xy, float yy, float x0, float y0])
2938    */
2939 PHP_METHOD(CairoMatrix, __construct)
2940 {
2941         zend_class_entry * _this_ce;
2942         zval * _this_zval;
2943
2944         double xx = 0.0;
2945         double yx = 0.0;
2946         double xy = 0.0;
2947         double yy = 0.0;
2948         double x0 = 0.0;
2949         double y0 = 0.0;
2950
2951
2952
2953         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|dddddd", &xx, &yx, &xy, &yy, &x0, &y0) == FAILURE) {
2954                 return;
2955         }
2956
2957         _this_zval = getThis();
2958         _this_ce = Z_OBJCE_P(_this_zval);
2959
2960
2961         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
2962
2963 }
2964 /* }}} __construct */
2965
2966
2967
2968 /* {{{ proto object inti_rotate(float radians)
2969    */
2970 PHP_METHOD(CairoMatrix, init_rotate)
2971 {
2972         zend_class_entry * _this_ce;
2973
2974         zval * _this_zval = NULL;
2975         double radians = 0.0;
2976
2977
2978
2979         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Od", &_this_zval, CairoMatrix_ce_ptr, &radians) == FAILURE) {
2980                 return;
2981         }
2982
2983         _this_ce = Z_OBJCE_P(_this_zval);
2984
2985
2986         php_error(E_WARNING, "init_rotate: not yet implemented"); RETURN_FALSE;
2987
2988         object_init(return_value)
2989 }
2990 /* }}} init_rotate */
2991
2992
2993
2994 /* {{{ proto void invert()
2995    */
2996 PHP_METHOD(CairoMatrix, invert)
2997 {
2998         zend_class_entry * _this_ce;
2999
3000         zval * _this_zval = NULL;
3001
3002
3003
3004         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoMatrix_ce_ptr) == FAILURE) {
3005                 return;
3006         }
3007
3008         _this_ce = Z_OBJCE_P(_this_zval);
3009
3010
3011         php_error(E_WARNING, "invert: not yet implemented"); RETURN_FALSE;
3012
3013 }
3014 /* }}} invert */
3015
3016
3017
3018 /* {{{ proto object multiply(object o2)
3019    */
3020 PHP_METHOD(CairoMatrix, multiply)
3021 {
3022         zend_class_entry * _this_ce;
3023
3024         zval * _this_zval = NULL;
3025         zval * o2 = NULL;
3026
3027
3028
3029         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo", &_this_zval, CairoMatrix_ce_ptr, &o2) == FAILURE) {
3030                 return;
3031         }
3032
3033         _this_ce = Z_OBJCE_P(_this_zval);
3034
3035
3036         php_error(E_WARNING, "multiply: not yet implemented"); RETURN_FALSE;
3037
3038         object_init(return_value)
3039 }
3040 /* }}} multiply */
3041
3042
3043
3044 /* {{{ proto void rotate(float radians)
3045    */
3046 PHP_METHOD(CairoMatrix, rotate)
3047 {
3048         zend_class_entry * _this_ce;
3049
3050         zval * _this_zval = NULL;
3051         double radians = 0.0;
3052
3053
3054
3055         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Od", &_this_zval, CairoMatrix_ce_ptr, &radians) == FAILURE) {
3056                 return;
3057         }
3058
3059         _this_ce = Z_OBJCE_P(_this_zval);
3060
3061
3062         php_error(E_WARNING, "rotate: not yet implemented"); RETURN_FALSE;
3063
3064 }
3065 /* }}} rotate */
3066
3067
3068
3069 /* {{{ proto void scale(float sx, float xy)
3070    */
3071 PHP_METHOD(CairoMatrix, scale)
3072 {
3073         zend_class_entry * _this_ce;
3074
3075         zval * _this_zval = NULL;
3076         double sx = 0.0;
3077         double xy = 0.0;
3078
3079
3080
3081         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoMatrix_ce_ptr, &sx, &xy) == FAILURE) {
3082                 return;
3083         }
3084
3085         _this_ce = Z_OBJCE_P(_this_zval);
3086
3087
3088         php_error(E_WARNING, "scale: not yet implemented"); RETURN_FALSE;
3089
3090 }
3091 /* }}} scale */
3092
3093
3094
3095 /* {{{ proto array transform_distance(float dx, float dy)
3096    */
3097 PHP_METHOD(CairoMatrix, transform_distance)
3098 {
3099         zend_class_entry * _this_ce;
3100
3101         zval * _this_zval = NULL;
3102         double dx = 0.0;
3103         double dy = 0.0;
3104
3105
3106
3107         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoMatrix_ce_ptr, &dx, &dy) == FAILURE) {
3108                 return;
3109         }
3110
3111         _this_ce = Z_OBJCE_P(_this_zval);
3112
3113
3114         array_init(return_value);
3115
3116         php_error(E_WARNING, "transform_distance: not yet implemented"); RETURN_FALSE;
3117
3118         array_init(return_value);
3119 }
3120 /* }}} transform_distance */
3121
3122
3123
3124 /* {{{ proto array transform_point(float x, float y)
3125    */
3126 PHP_METHOD(CairoMatrix, transform_point)
3127 {
3128         zend_class_entry * _this_ce;
3129
3130         zval * _this_zval = NULL;
3131         double x = 0.0;
3132         double y = 0.0;
3133
3134
3135
3136         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoMatrix_ce_ptr, &x, &y) == FAILURE) {
3137                 return;
3138         }
3139
3140         _this_ce = Z_OBJCE_P(_this_zval);
3141
3142
3143         array_init(return_value);
3144
3145         php_error(E_WARNING, "transform_point: not yet implemented"); RETURN_FALSE;
3146
3147         array_init(return_value);
3148 }
3149 /* }}} transform_point */
3150
3151
3152
3153 /* {{{ proto void translate(float tx, float ty)
3154    */
3155 PHP_METHOD(CairoMatrix, translate)
3156 {
3157         zend_class_entry * _this_ce;
3158
3159         zval * _this_zval = NULL;
3160         double tx = 0.0;
3161         double ty = 0.0;
3162
3163
3164
3165         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoMatrix_ce_ptr, &tx, &ty) == FAILURE) {
3166                 return;
3167         }
3168
3169         _this_ce = Z_OBJCE_P(_this_zval);
3170
3171
3172         php_error(E_WARNING, "translate: not yet implemented"); RETURN_FALSE;
3173
3174 }
3175 /* }}} translate */
3176
3177
3178 static zend_function_entry CairoMatrix_methods[] = {
3179         PHP_ME(CairoMatrix, __construct, CairoMatrix____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
3180         PHP_ME(CairoMatrix, init_rotate, CairoMatrix__init_rotate_args, /**/ZEND_ACC_PRIVATE)
3181         PHP_ME(CairoMatrix, invert, NULL, /**/ZEND_ACC_PUBLIC)
3182         PHP_ME(CairoMatrix, multiply, CairoMatrix__multiply_args, /**/ZEND_ACC_PUBLIC)
3183         PHP_ME(CairoMatrix, rotate, CairoMatrix__rotate_args, /**/ZEND_ACC_PUBLIC)
3184         PHP_ME(CairoMatrix, scale, CairoMatrix__scale_args, /**/ZEND_ACC_PUBLIC)
3185         PHP_ME(CairoMatrix, transform_distance, CairoMatrix__transform_distance_args, /**/ZEND_ACC_PUBLIC)
3186         PHP_ME(CairoMatrix, transform_point, CairoMatrix__transform_point_args, /**/ZEND_ACC_PUBLIC)
3187         PHP_ME(CairoMatrix, translate, CairoMatrix__translate_args, /**/ZEND_ACC_PUBLIC)
3188         { NULL, NULL, NULL }
3189 };
3190
3191 /* }}} Methods */
3192
3193 static void class_init_CairoMatrix(void)
3194 {
3195         zend_class_entry ce;
3196
3197         INIT_CLASS_ENTRY(ce, "CairoMatrix", CairoMatrix_methods);
3198         CairoMatrix_ce_ptr = zend_register_internal_class(&ce);
3199 }
3200
3201 /* }}} Class CairoMatrix */
3202
3203 /* {{{ Class CairoPattern */
3204
3205 static zend_class_entry * CairoPattern_ce_ptr = NULL;
3206
3207 /* {{{ Methods */
3208
3209
3210 /* {{{ proto void contruct()
3211    */
3212 PHP_METHOD(CairoPattern, __construct)
3213 {
3214         zend_class_entry * _this_ce;
3215         zval * _this_zval;
3216
3217
3218
3219         if (ZEND_NUM_ARGS()>0)  {
3220                 WRONG_PARAM_COUNT;
3221         }
3222
3223
3224         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
3225
3226 }
3227 /* }}} __construct */
3228
3229
3230
3231 /* {{{ proto object get_matrix()
3232    */
3233 PHP_METHOD(CairoPattern, get_matrix)
3234 {
3235         zend_class_entry * _this_ce;
3236
3237         zval * _this_zval = NULL;
3238
3239
3240
3241         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoPattern_ce_ptr) == FAILURE) {
3242                 return;
3243         }
3244
3245         _this_ce = Z_OBJCE_P(_this_zval);
3246
3247
3248         php_error(E_WARNING, "get_matrix: not yet implemented"); RETURN_FALSE;
3249
3250         object_init(return_value)
3251 }
3252 /* }}} get_matrix */
3253
3254
3255
3256 /* {{{ proto void set_matrix(object m)
3257    */
3258 PHP_METHOD(CairoPattern, set_matrix)
3259 {
3260         zend_class_entry * _this_ce;
3261
3262         zval * _this_zval = NULL;
3263         zval * m = NULL;
3264
3265
3266
3267         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo", &_this_zval, CairoPattern_ce_ptr, &m) == FAILURE) {
3268                 return;
3269         }
3270
3271         _this_ce = Z_OBJCE_P(_this_zval);
3272
3273
3274         php_error(E_WARNING, "set_matrix: not yet implemented"); RETURN_FALSE;
3275
3276 }
3277 /* }}} set_matrix */
3278
3279
3280 static zend_function_entry CairoPattern_methods[] = {
3281         PHP_ME(CairoPattern, __construct, NULL, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
3282         PHP_ME(CairoPattern, get_matrix, NULL, /**/ZEND_ACC_PUBLIC)
3283         PHP_ME(CairoPattern, set_matrix, CairoPattern__set_matrix_args, /**/ZEND_ACC_PUBLIC)
3284         { NULL, NULL, NULL }
3285 };
3286
3287 /* }}} Methods */
3288
3289 static void class_init_CairoPattern(void)
3290 {
3291         zend_class_entry ce;
3292
3293         INIT_CLASS_ENTRY(ce, "CairoPattern", CairoPattern_methods);
3294         CairoPattern_ce_ptr = zend_register_internal_class(&ce);
3295 }
3296
3297 /* }}} Class CairoPattern */
3298
3299 /* {{{ Class CairoGradient */
3300
3301 static zend_class_entry * CairoGradient_ce_ptr = NULL;
3302
3303 /* {{{ Methods */
3304
3305
3306 /* {{{ proto void construct()
3307    */
3308 PHP_METHOD(CairoGradient, __contruct)
3309 {
3310         zend_class_entry * _this_ce;
3311
3312         zval * _this_zval = NULL;
3313
3314
3315
3316         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoGradient_ce_ptr) == FAILURE) {
3317                 return;
3318         }
3319
3320         _this_ce = Z_OBJCE_P(_this_zval);
3321
3322
3323         php_error(E_WARNING, "__contruct: not yet implemented"); RETURN_FALSE;
3324
3325 }
3326 /* }}} __contruct */
3327
3328
3329
3330 /* {{{ proto void add_color_stop_rgb(float offset, float red, float green, float blue)
3331    */
3332 PHP_METHOD(CairoGradient, add_color_stop_rgb)
3333 {
3334         zend_class_entry * _this_ce;
3335
3336         zval * _this_zval = NULL;
3337         double offset = 0.0;
3338         double red = 0.0;
3339         double green = 0.0;
3340         double blue = 0.0;
3341
3342
3343
3344         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odddd", &_this_zval, CairoGradient_ce_ptr, &offset, &red, &green, &blue) == FAILURE) {
3345                 return;
3346         }
3347
3348         _this_ce = Z_OBJCE_P(_this_zval);
3349
3350
3351         php_error(E_WARNING, "add_color_stop_rgb: not yet implemented"); RETURN_FALSE;
3352
3353 }
3354 /* }}} add_color_stop_rgb */
3355
3356
3357
3358 /* {{{ proto void add_color_stop_rgba(float offset, float red, float green, float blue, float alpha)
3359    */
3360 PHP_METHOD(CairoGradient, add_color_stop_rgba)
3361 {
3362         zend_class_entry * _this_ce;
3363
3364         zval * _this_zval = NULL;
3365         double offset = 0.0;
3366         double red = 0.0;
3367         double green = 0.0;
3368         double blue = 0.0;
3369         double alpha = 0.0;
3370
3371
3372
3373         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oddddd", &_this_zval, CairoGradient_ce_ptr, &offset, &red, &green, &blue, &alpha) == FAILURE) {
3374                 return;
3375         }
3376
3377         _this_ce = Z_OBJCE_P(_this_zval);
3378
3379
3380         php_error(E_WARNING, "add_color_stop_rgba: not yet implemented"); RETURN_FALSE;
3381
3382 }
3383 /* }}} add_color_stop_rgba */
3384
3385
3386 static zend_function_entry CairoGradient_methods[] = {
3387         PHP_ME(CairoGradient, __contruct, NULL, /**/ZEND_ACC_PUBLIC)
3388         PHP_ME(CairoGradient, add_color_stop_rgb, CairoGradient__add_color_stop_rgb_args, /**/ZEND_ACC_PUBLIC)
3389         PHP_ME(CairoGradient, add_color_stop_rgba, CairoGradient__add_color_stop_rgba_args, /**/ZEND_ACC_PUBLIC)
3390         { NULL, NULL, NULL }
3391 };
3392
3393 /* }}} Methods */
3394
3395 static void class_init_CairoGradient(void)
3396 {
3397         zend_class_entry ce;
3398
3399         INIT_CLASS_ENTRY(ce, "CairoGradient", CairoGradient_methods);
3400         CairoGradient_ce_ptr = zend_register_internal_class_ex(&ce, NULL, "CairoPattern" TSRMLS_CC);
3401 }
3402
3403 /* }}} Class CairoGradient */
3404
3405 /* {{{ Class CairoLinearGradient */
3406
3407 static zend_class_entry * CairoLinearGradient_ce_ptr = NULL;
3408
3409 /* {{{ Methods */
3410
3411
3412 /* {{{ proto void construct(float x0, float y0, float x1, float y1)
3413    */
3414 PHP_METHOD(CairoLinearGradient, __construct)
3415 {
3416         zend_class_entry * _this_ce;
3417         zval * _this_zval;
3418
3419         double x0 = 0.0;
3420         double y0 = 0.0;
3421         double x1 = 0.0;
3422         double y1 = 0.0;
3423
3424
3425
3426         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "dddd", &x0, &y0, &x1, &y1) == FAILURE) {
3427                 return;
3428         }
3429
3430         _this_zval = getThis();
3431         _this_ce = Z_OBJCE_P(_this_zval);
3432
3433
3434         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
3435
3436 }
3437 /* }}} __construct */
3438
3439
3440
3441 /* {{{ proto array get_linear_points()
3442    */
3443 PHP_METHOD(CairoLinearGradient, get_linear_points)
3444 {
3445         zend_class_entry * _this_ce;
3446
3447         zval * _this_zval = NULL;
3448
3449
3450
3451         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoLinearGradient_ce_ptr) == FAILURE) {
3452                 return;
3453         }
3454
3455         _this_ce = Z_OBJCE_P(_this_zval);
3456
3457
3458         array_init(return_value);
3459
3460         php_error(E_WARNING, "get_linear_points: not yet implemented"); RETURN_FALSE;
3461
3462         array_init(return_value);
3463 }
3464 /* }}} get_linear_points */
3465
3466
3467 static zend_function_entry CairoLinearGradient_methods[] = {
3468         PHP_ME(CairoLinearGradient, __construct, CairoLinearGradient____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
3469         PHP_ME(CairoLinearGradient, get_linear_points, NULL, /**/ZEND_ACC_PUBLIC)
3470         { NULL, NULL, NULL }
3471 };
3472
3473 /* }}} Methods */
3474
3475 static void class_init_CairoLinearGradient(void)
3476 {
3477         zend_class_entry ce;
3478
3479         INIT_CLASS_ENTRY(ce, "CairoLinearGradient", CairoLinearGradient_methods);
3480         CairoLinearGradient_ce_ptr = zend_register_internal_class_ex(&ce, NULL, "CairoGradient" TSRMLS_CC);
3481 }
3482
3483 /* }}} Class CairoLinearGradient */
3484
3485 /* {{{ Class CairoRadialGradient */
3486
3487 static zend_class_entry * CairoRadialGradient_ce_ptr = NULL;
3488
3489 /* {{{ Methods */
3490
3491
3492 /* {{{ proto void construct(float cx0, float cy0, float radius0, float cx1, float cy1, float radius1)
3493    */
3494 PHP_METHOD(CairoRadialGradient, __constuct)
3495 {
3496         zend_class_entry * _this_ce;
3497
3498         zval * _this_zval = NULL;
3499         double cx0 = 0.0;
3500         double cy0 = 0.0;
3501         double radius0 = 0.0;
3502         double cx1 = 0.0;
3503         double cy1 = 0.0;
3504         double radius1 = 0.0;
3505
3506
3507
3508         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odddddd", &_this_zval, CairoRadialGradient_ce_ptr, &cx0, &cy0, &radius0, &cx1, &cy1, &radius1) == FAILURE) {
3509                 return;
3510         }
3511
3512         _this_ce = Z_OBJCE_P(_this_zval);
3513
3514
3515         php_error(E_WARNING, "__constuct: not yet implemented"); RETURN_FALSE;
3516
3517 }
3518 /* }}} __constuct */
3519
3520
3521
3522 /* {{{ proto array get_radial_circles()
3523    */
3524 PHP_METHOD(CairoRadialGradient, get_radial_circles)
3525 {
3526         zend_class_entry * _this_ce;
3527
3528         zval * _this_zval = NULL;
3529
3530
3531
3532         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoRadialGradient_ce_ptr) == FAILURE) {
3533                 return;
3534         }
3535
3536         _this_ce = Z_OBJCE_P(_this_zval);
3537
3538
3539         array_init(return_value);
3540
3541         php_error(E_WARNING, "get_radial_circles: not yet implemented"); RETURN_FALSE;
3542
3543         array_init(return_value);
3544 }
3545 /* }}} get_radial_circles */
3546
3547
3548 static zend_function_entry CairoRadialGradient_methods[] = {
3549         PHP_ME(CairoRadialGradient, __constuct, CairoRadialGradient____constuct_args, /**/ZEND_ACC_PUBLIC)
3550         PHP_ME(CairoRadialGradient, get_radial_circles, NULL, /**/ZEND_ACC_PUBLIC)
3551         { NULL, NULL, NULL }
3552 };
3553
3554 /* }}} Methods */
3555
3556 static void class_init_CairoRadialGradient(void)
3557 {
3558         zend_class_entry ce;
3559
3560         INIT_CLASS_ENTRY(ce, "CairoRadialGradient", CairoRadialGradient_methods);
3561         CairoRadialGradient_ce_ptr = zend_register_internal_class_ex(&ce, NULL, "CairoGradient" TSRMLS_CC);
3562 }
3563
3564 /* }}} Class CairoRadialGradient */
3565
3566 /* {{{ Class CairoSolidPattern */
3567
3568 static zend_class_entry * CairoSolidPattern_ce_ptr = NULL;
3569
3570 /* {{{ Methods */
3571
3572
3573 /* {{{ proto void construct(float r, float g, float b [, float a])
3574    */
3575 PHP_METHOD(CairoSolidPattern, __construct)
3576 {
3577         zend_class_entry * _this_ce;
3578         zval * _this_zval;
3579
3580         double r = 0.0;
3581         double g = 0.0;
3582         double b = 0.0;
3583         double a = 0.0;
3584
3585
3586
3587         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ddd|d", &r, &g, &b, &a) == FAILURE) {
3588                 return;
3589         }
3590
3591         _this_zval = getThis();
3592         _this_ce = Z_OBJCE_P(_this_zval);
3593
3594
3595         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
3596
3597 }
3598 /* }}} __construct */
3599
3600
3601
3602 /* {{{ proto array get_rgba()
3603    */
3604 PHP_METHOD(CairoSolidPattern, get_rgba)
3605 {
3606         zend_class_entry * _this_ce;
3607
3608         zval * _this_zval = NULL;
3609
3610
3611
3612         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoSolidPattern_ce_ptr) == FAILURE) {
3613                 return;
3614         }
3615
3616         _this_ce = Z_OBJCE_P(_this_zval);
3617
3618
3619         array_init(return_value);
3620
3621         php_error(E_WARNING, "get_rgba: not yet implemented"); RETURN_FALSE;
3622
3623         array_init(return_value);
3624 }
3625 /* }}} get_rgba */
3626
3627
3628 static zend_function_entry CairoSolidPattern_methods[] = {
3629         PHP_ME(CairoSolidPattern, __construct, CairoSolidPattern____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
3630         PHP_ME(CairoSolidPattern, get_rgba, NULL, /**/ZEND_ACC_PUBLIC)
3631         { NULL, NULL, NULL }
3632 };
3633
3634 /* }}} Methods */
3635
3636 static void class_init_CairoSolidPattern(void)
3637 {
3638         zend_class_entry ce;
3639
3640         INIT_CLASS_ENTRY(ce, "CairoSolidPattern", CairoSolidPattern_methods);
3641         CairoSolidPattern_ce_ptr = zend_register_internal_class_ex(&ce, NULL, "CairoPattern" TSRMLS_CC);
3642 }
3643
3644 /* }}} Class CairoSolidPattern */
3645
3646 /* {{{ Class CairoSurfacePattern */
3647
3648 static zend_class_entry * CairoSurfacePattern_ce_ptr = NULL;
3649
3650 /* {{{ Methods */
3651
3652
3653 /* {{{ proto void construct(object s)
3654    */
3655 PHP_METHOD(CairoSurfacePattern, __construct)
3656 {
3657         zend_class_entry * _this_ce;
3658         zval * _this_zval;
3659
3660         zval * s = NULL;
3661
3662
3663
3664         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &s) == FAILURE) {
3665                 return;
3666         }
3667
3668         _this_zval = getThis();
3669         _this_ce = Z_OBJCE_P(_this_zval);
3670
3671
3672         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
3673
3674 }
3675 /* }}} __construct */
3676
3677
3678
3679 /* {{{ proto int get_extend()
3680    */
3681 PHP_METHOD(CairoSurfacePattern, get_extend)
3682 {
3683         zend_class_entry * _this_ce;
3684
3685         zval * _this_zval = NULL;
3686
3687
3688
3689         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoSurfacePattern_ce_ptr) == FAILURE) {
3690                 return;
3691         }
3692
3693         _this_ce = Z_OBJCE_P(_this_zval);
3694
3695
3696         php_error(E_WARNING, "get_extend: not yet implemented"); RETURN_FALSE;
3697
3698         RETURN_LONG(0);
3699 }
3700 /* }}} get_extend */
3701
3702
3703
3704 /* {{{ proto int get_filter()
3705    */
3706 PHP_METHOD(CairoSurfacePattern, get_filter)
3707 {
3708         zend_class_entry * _this_ce;
3709
3710         zval * _this_zval = NULL;
3711
3712
3713
3714         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoSurfacePattern_ce_ptr) == FAILURE) {
3715                 return;
3716         }
3717
3718         _this_ce = Z_OBJCE_P(_this_zval);
3719
3720
3721         php_error(E_WARNING, "get_filter: not yet implemented"); RETURN_FALSE;
3722
3723         RETURN_LONG(0);
3724 }
3725 /* }}} get_filter */
3726
3727
3728
3729 /* {{{ proto object get_surface()
3730    */
3731 PHP_METHOD(CairoSurfacePattern, get_surface)
3732 {
3733         zend_class_entry * _this_ce;
3734
3735         zval * _this_zval = NULL;
3736
3737
3738
3739         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoSurfacePattern_ce_ptr) == FAILURE) {
3740                 return;
3741         }
3742
3743         _this_ce = Z_OBJCE_P(_this_zval);
3744
3745
3746         php_error(E_WARNING, "get_surface: not yet implemented"); RETURN_FALSE;
3747
3748         object_init(return_value)
3749 }
3750 /* }}} get_surface */
3751
3752
3753
3754 /* {{{ proto void set_extend(int extend)
3755    */
3756 PHP_METHOD(CairoSurfacePattern, set_extend)
3757 {
3758         zend_class_entry * _this_ce;
3759
3760         zval * _this_zval = NULL;
3761         long extend = 0;
3762
3763
3764
3765         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &_this_zval, CairoSurfacePattern_ce_ptr, &extend) == FAILURE) {
3766                 return;
3767         }
3768
3769         _this_ce = Z_OBJCE_P(_this_zval);
3770
3771
3772         php_error(E_WARNING, "set_extend: not yet implemented"); RETURN_FALSE;
3773
3774 }
3775 /* }}} set_extend */
3776
3777
3778
3779 /* {{{ proto void set_filter(int filter)
3780    */
3781 PHP_METHOD(CairoSurfacePattern, set_filter)
3782 {
3783         zend_class_entry * _this_ce;
3784
3785         zval * _this_zval = NULL;
3786         long filter = 0;
3787
3788
3789
3790         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &_this_zval, CairoSurfacePattern_ce_ptr, &filter) == FAILURE) {
3791                 return;
3792         }
3793
3794         _this_ce = Z_OBJCE_P(_this_zval);
3795
3796
3797         php_error(E_WARNING, "set_filter: not yet implemented"); RETURN_FALSE;
3798
3799 }
3800 /* }}} set_filter */
3801
3802
3803 static zend_function_entry CairoSurfacePattern_methods[] = {
3804         PHP_ME(CairoSurfacePattern, __construct, NULL, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
3805         PHP_ME(CairoSurfacePattern, get_extend, NULL, /**/ZEND_ACC_PUBLIC)
3806         PHP_ME(CairoSurfacePattern, get_filter, NULL, /**/ZEND_ACC_PUBLIC)
3807         PHP_ME(CairoSurfacePattern, get_surface, NULL, /**/ZEND_ACC_PUBLIC)
3808         PHP_ME(CairoSurfacePattern, set_extend, CairoSurfacePattern__set_extend_args, /**/ZEND_ACC_PUBLIC)
3809         PHP_ME(CairoSurfacePattern, set_filter, CairoSurfacePattern__set_filter_args, /**/ZEND_ACC_PUBLIC)
3810         { NULL, NULL, NULL }
3811 };
3812
3813 /* }}} Methods */
3814
3815 static void class_init_CairoSurfacePattern(void)
3816 {
3817         zend_class_entry ce;
3818
3819         INIT_CLASS_ENTRY(ce, "CairoSurfacePattern", CairoSurfacePattern_methods);
3820         CairoSurfacePattern_ce_ptr = zend_register_internal_class_ex(&ce, NULL, "CairoPattern" TSRMLS_CC);
3821 }
3822
3823 /* }}} Class CairoSurfacePattern */
3824
3825 /* {{{ Class CairoScaledFont */
3826
3827 static zend_class_entry * CairoScaledFont_ce_ptr = NULL;
3828
3829 /* {{{ Methods */
3830
3831
3832 /* {{{ proto void construct(object ff, object mx1, object mx2, object fo)
3833    */
3834 PHP_METHOD(CairoScaledFont, __construct)
3835 {
3836         zend_class_entry * _this_ce;
3837         zval * _this_zval;
3838
3839         zval * ff = NULL;
3840         zval * mx1 = NULL;
3841         zval * mx2 = NULL;
3842         zval * fo = NULL;
3843
3844
3845
3846         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "oooo", &ff, &mx1, &mx2, &fo) == FAILURE) {
3847                 return;
3848         }
3849
3850         _this_zval = getThis();
3851         _this_ce = Z_OBJCE_P(_this_zval);
3852
3853
3854         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
3855
3856 }
3857 /* }}} __construct */
3858
3859
3860
3861 /* {{{ proto array extents()
3862    */
3863 PHP_METHOD(CairoScaledFont, extents)
3864 {
3865         zend_class_entry * _this_ce;
3866
3867         zval * _this_zval = NULL;
3868
3869
3870
3871         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoScaledFont_ce_ptr) == FAILURE) {
3872                 return;
3873         }
3874
3875         _this_ce = Z_OBJCE_P(_this_zval);
3876
3877
3878         array_init(return_value);
3879
3880         php_error(E_WARNING, "extents: not yet implemented"); RETURN_FALSE;
3881
3882         array_init(return_value);
3883 }
3884 /* }}} extents */
3885
3886
3887
3888 /* {{{ proto object get_font_face()
3889    */
3890 PHP_METHOD(CairoScaledFont, get_font_face)
3891 {
3892         zend_class_entry * _this_ce;
3893
3894         zval * _this_zval = NULL;
3895
3896
3897
3898         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoScaledFont_ce_ptr) == FAILURE) {
3899                 return;
3900         }
3901
3902         _this_ce = Z_OBJCE_P(_this_zval);
3903
3904
3905         php_error(E_WARNING, "get_font_face: not yet implemented"); RETURN_FALSE;
3906
3907         object_init(return_value)
3908 }
3909 /* }}} get_font_face */
3910
3911
3912
3913 /* {{{ proto array text_extents(string str)
3914    */
3915 PHP_METHOD(CairoScaledFont, text_extents)
3916 {
3917         zend_class_entry * _this_ce;
3918
3919         zval * _this_zval = NULL;
3920         const char * str = NULL;
3921         int str_len = 0;
3922
3923
3924
3925         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &_this_zval, CairoScaledFont_ce_ptr, &str, &str_len) == FAILURE) {
3926                 return;
3927         }
3928
3929         _this_ce = Z_OBJCE_P(_this_zval);
3930
3931
3932         array_init(return_value);
3933
3934         php_error(E_WARNING, "text_extents: not yet implemented"); RETURN_FALSE;
3935
3936         array_init(return_value);
3937 }
3938 /* }}} text_extents */
3939
3940
3941 static zend_function_entry CairoScaledFont_methods[] = {
3942         PHP_ME(CairoScaledFont, __construct, CairoScaledFont____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
3943         PHP_ME(CairoScaledFont, extents, NULL, /**/ZEND_ACC_PUBLIC)
3944         PHP_ME(CairoScaledFont, get_font_face, NULL, /**/ZEND_ACC_PUBLIC)
3945         PHP_ME(CairoScaledFont, text_extents, CairoScaledFont__text_extents_args, /**/ZEND_ACC_PUBLIC)
3946         { NULL, NULL, NULL }
3947 };
3948
3949 /* }}} Methods */
3950
3951 static void class_init_CairoScaledFont(void)
3952 {
3953         zend_class_entry ce;
3954
3955         INIT_CLASS_ENTRY(ce, "CairoScaledFont", CairoScaledFont_methods);
3956         CairoScaledFont_ce_ptr = zend_register_internal_class(&ce);
3957 }
3958
3959 /* }}} Class CairoScaledFont */
3960
3961 /* {{{ Class CairoSurface */
3962
3963 static zend_class_entry * CairoSurface_ce_ptr = NULL;
3964
3965 /* {{{ Methods */
3966
3967
3968 /* {{{ proto void construct()
3969    */
3970 PHP_METHOD(CairoSurface, __construct)
3971 {
3972         zend_class_entry * _this_ce;
3973         zval * _this_zval;
3974
3975
3976
3977         if (ZEND_NUM_ARGS()>0)  {
3978                 WRONG_PARAM_COUNT;
3979         }
3980
3981
3982         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
3983
3984 }
3985 /* }}} __construct */
3986
3987
3988
3989 /* {{{ proto object create_similar(int content, int width, int height)
3990    */
3991 PHP_METHOD(CairoSurface, create_similar)
3992 {
3993         zend_class_entry * _this_ce;
3994
3995         zval * _this_zval = NULL;
3996         long content = 0;
3997         long width = 0;
3998         long height = 0;
3999
4000
4001
4002         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Olll", &_this_zval, CairoSurface_ce_ptr, &content, &width, &height) == FAILURE) {
4003                 return;
4004         }
4005
4006         _this_ce = Z_OBJCE_P(_this_zval);
4007
4008
4009         php_error(E_WARNING, "create_similar: not yet implemented"); RETURN_FALSE;
4010
4011         object_init(return_value)
4012 }
4013 /* }}} create_similar */
4014
4015
4016
4017 /* {{{ proto void finish()
4018    */
4019 PHP_METHOD(CairoSurface, finish)
4020 {
4021         zend_class_entry * _this_ce;
4022
4023         zval * _this_zval = NULL;
4024
4025
4026
4027         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoSurface_ce_ptr) == FAILURE) {
4028                 return;
4029         }
4030
4031         _this_ce = Z_OBJCE_P(_this_zval);
4032
4033
4034         php_error(E_WARNING, "finish: not yet implemented"); RETURN_FALSE;
4035
4036 }
4037 /* }}} finish */
4038
4039
4040
4041 /* {{{ proto void flush()
4042    */
4043 PHP_METHOD(CairoSurface, flush)
4044 {
4045         zend_class_entry * _this_ce;
4046
4047         zval * _this_zval = NULL;
4048
4049
4050
4051         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoSurface_ce_ptr) == FAILURE) {
4052                 return;
4053         }
4054
4055         _this_ce = Z_OBJCE_P(_this_zval);
4056
4057
4058         php_error(E_WARNING, "flush: not yet implemented"); RETURN_FALSE;
4059
4060 }
4061 /* }}} flush */
4062
4063
4064
4065 /* {{{ proto int get_content()
4066    */
4067 PHP_METHOD(CairoSurface, get_content)
4068 {
4069         zend_class_entry * _this_ce;
4070
4071         zval * _this_zval = NULL;
4072
4073
4074
4075         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoSurface_ce_ptr) == FAILURE) {
4076                 return;
4077         }
4078
4079         _this_ce = Z_OBJCE_P(_this_zval);
4080
4081
4082         php_error(E_WARNING, "get_content: not yet implemented"); RETURN_FALSE;
4083
4084         RETURN_LONG(0);
4085 }
4086 /* }}} get_content */
4087
4088
4089
4090 /* {{{ proto array get_device_offset()
4091    */
4092 PHP_METHOD(CairoSurface, get_device_offset)
4093 {
4094         zend_class_entry * _this_ce;
4095
4096         zval * _this_zval = NULL;
4097
4098
4099
4100         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoSurface_ce_ptr) == FAILURE) {
4101                 return;
4102         }
4103
4104         _this_ce = Z_OBJCE_P(_this_zval);
4105
4106
4107         array_init(return_value);
4108
4109         php_error(E_WARNING, "get_device_offset: not yet implemented"); RETURN_FALSE;
4110
4111         array_init(return_value);
4112 }
4113 /* }}} get_device_offset */
4114
4115
4116
4117 /* {{{ proto object get_font_options()
4118    */
4119 PHP_METHOD(CairoSurface, get_font_options)
4120 {
4121         zend_class_entry * _this_ce;
4122
4123         zval * _this_zval = NULL;
4124
4125
4126
4127         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoSurface_ce_ptr) == FAILURE) {
4128                 return;
4129         }
4130
4131         _this_ce = Z_OBJCE_P(_this_zval);
4132
4133
4134         php_error(E_WARNING, "get_font_options: not yet implemented"); RETURN_FALSE;
4135
4136         object_init(return_value)
4137 }
4138 /* }}} get_font_options */
4139
4140
4141
4142 /* {{{ proto void mark_dirty_rectangle([int x, int y, int width, int height])
4143    */
4144 PHP_METHOD(CairoSurface, mark_dirty_rectangle)
4145 {
4146         zend_class_entry * _this_ce;
4147
4148         zval * _this_zval = NULL;
4149         long x = 0;
4150         long y = 0;
4151         long width = 0;
4152         long height = 0;
4153
4154
4155
4156         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|llll", &_this_zval, CairoSurface_ce_ptr, &x, &y, &width, &height) == FAILURE) {
4157                 return;
4158         }
4159
4160         _this_ce = Z_OBJCE_P(_this_zval);
4161
4162
4163         php_error(E_WARNING, "mark_dirty_rectangle: not yet implemented"); RETURN_FALSE;
4164
4165 }
4166 /* }}} mark_dirty_rectangle */
4167
4168
4169
4170 /* {{{ proto void set_device_offset(float x_offset, float y_offset)
4171    */
4172 PHP_METHOD(CairoSurface, set_device_offset)
4173 {
4174         zend_class_entry * _this_ce;
4175
4176         zval * _this_zval = NULL;
4177         double x_offset = 0.0;
4178         double y_offset = 0.0;
4179
4180
4181
4182         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoSurface_ce_ptr, &x_offset, &y_offset) == FAILURE) {
4183                 return;
4184         }
4185
4186         _this_ce = Z_OBJCE_P(_this_zval);
4187
4188
4189         php_error(E_WARNING, "set_device_offset: not yet implemented"); RETURN_FALSE;
4190
4191 }
4192 /* }}} set_device_offset */
4193
4194
4195
4196 /* {{{ proto void set_fallback_resolution(float x_ppi, float y_ppi)
4197    */
4198 PHP_METHOD(CairoSurface, set_fallback_resolution)
4199 {
4200         zend_class_entry * _this_ce;
4201
4202         zval * _this_zval = NULL;
4203         double x_ppi = 0.0;
4204         double y_ppi = 0.0;
4205
4206
4207
4208         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoSurface_ce_ptr, &x_ppi, &y_ppi) == FAILURE) {
4209                 return;
4210         }
4211
4212         _this_ce = Z_OBJCE_P(_this_zval);
4213
4214
4215         php_error(E_WARNING, "set_fallback_resolution: not yet implemented"); RETURN_FALSE;
4216
4217 }
4218 /* }}} set_fallback_resolution */
4219
4220
4221
4222 /* {{{ proto void write_to_png(string file)
4223    */
4224 PHP_METHOD(CairoSurface, write_to_png)
4225 {
4226         zend_class_entry * _this_ce;
4227
4228         zval * _this_zval = NULL;
4229         const char * file = NULL;
4230         int file_len = 0;
4231
4232
4233
4234         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &_this_zval, CairoSurface_ce_ptr, &file, &file_len) == FAILURE) {
4235                 return;
4236         }
4237
4238         _this_ce = Z_OBJCE_P(_this_zval);
4239
4240
4241         php_error(E_WARNING, "write_to_png: not yet implemented"); RETURN_FALSE;
4242
4243 }
4244 /* }}} write_to_png */
4245
4246
4247 static zend_function_entry CairoSurface_methods[] = {
4248         PHP_ME(CairoSurface, __construct, NULL, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
4249         PHP_ME(CairoSurface, create_similar, CairoSurface__create_similar_args, /**/ZEND_ACC_PUBLIC)
4250         PHP_ME(CairoSurface, finish, NULL, /**/ZEND_ACC_PUBLIC)
4251         PHP_ME(CairoSurface, flush, NULL, /**/ZEND_ACC_PUBLIC)
4252         PHP_ME(CairoSurface, get_content, NULL, /**/ZEND_ACC_PUBLIC)
4253         PHP_ME(CairoSurface, get_device_offset, NULL, /**/ZEND_ACC_PUBLIC)
4254         PHP_ME(CairoSurface, get_font_options, NULL, /**/ZEND_ACC_PUBLIC)
4255         PHP_ME(CairoSurface, mark_dirty_rectangle, CairoSurface__mark_dirty_rectangle_args, /**/ZEND_ACC_PUBLIC)
4256         PHP_ME(CairoSurface, set_device_offset, CairoSurface__set_device_offset_args, /**/ZEND_ACC_PUBLIC)
4257         PHP_ME(CairoSurface, set_fallback_resolution, CairoSurface__set_fallback_resolution_args, /**/ZEND_ACC_PUBLIC)
4258         PHP_ME(CairoSurface, write_to_png, CairoSurface__write_to_png_args, /**/ZEND_ACC_PUBLIC)
4259         { NULL, NULL, NULL }
4260 };
4261
4262 /* }}} Methods */
4263
4264 static void class_init_CairoSurface(void)
4265 {
4266         zend_class_entry ce;
4267
4268         INIT_CLASS_ENTRY(ce, "CairoSurface", CairoSurface_methods);
4269         CairoSurface_ce_ptr = zend_register_internal_class(&ce);
4270 }
4271
4272 /* }}} Class CairoSurface */
4273
4274 /* {{{ Class CairoImageSurface */
4275
4276 static zend_class_entry * CairoImageSurface_ce_ptr = NULL;
4277
4278 /* {{{ Methods */
4279
4280
4281 /* {{{ proto void construct(int format, int widthm, int height)
4282    */
4283 PHP_METHOD(CairoImageSurface, __construct)
4284 {
4285         zend_class_entry * _this_ce;
4286         zval * _this_zval;
4287
4288         long format = 0;
4289         long widthm = 0;
4290         long height = 0;
4291
4292
4293
4294         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll", &format, &widthm, &height) == FAILURE) {
4295                 return;
4296         }
4297
4298         _this_zval = getThis();
4299         _this_ce = Z_OBJCE_P(_this_zval);
4300
4301
4302         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
4303
4304 }
4305 /* }}} __construct */
4306
4307
4308
4309 /* {{{ proto object create_from_data(object obj, int format, int width, int height [, int stride])
4310    */
4311 PHP_METHOD(CairoImageSurface, create_from_data)
4312 {
4313         zend_class_entry * _this_ce;
4314
4315         zval * _this_zval = NULL;
4316         zval * obj = NULL;
4317         long format = 0;
4318         long width = 0;
4319         long height = 0;
4320         long stride = 0;
4321
4322
4323
4324         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oolll|l", &_this_zval, CairoImageSurface_ce_ptr, &obj, &format, &width, &height, &stride) == FAILURE) {
4325                 return;
4326         }
4327
4328         _this_ce = Z_OBJCE_P(_this_zval);
4329
4330
4331         php_error(E_WARNING, "create_from_data: not yet implemented"); RETURN_FALSE;
4332
4333         object_init(return_value)
4334 }
4335 /* }}} create_from_data */
4336
4337
4338
4339 /* {{{ proto object create_from_png(string file)
4340    */
4341 PHP_METHOD(CairoImageSurface, create_from_png)
4342 {
4343         zend_class_entry * _this_ce;
4344
4345         zval * _this_zval = NULL;
4346         const char * file = NULL;
4347         int file_len = 0;
4348
4349
4350
4351         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &_this_zval, CairoImageSurface_ce_ptr, &file, &file_len) == FAILURE) {
4352                 return;
4353         }
4354
4355         _this_ce = Z_OBJCE_P(_this_zval);
4356
4357
4358         php_error(E_WARNING, "create_from_png: not yet implemented"); RETURN_FALSE;
4359
4360         object_init(return_value)
4361 }
4362 /* }}} create_from_png */
4363
4364
4365
4366 /* {{{ proto string get_data()
4367    */
4368 PHP_METHOD(CairoImageSurface, get_data)
4369 {
4370         zend_class_entry * _this_ce;
4371
4372         zval * _this_zval = NULL;
4373
4374
4375
4376         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoImageSurface_ce_ptr) == FAILURE) {
4377                 return;
4378         }
4379
4380         _this_ce = Z_OBJCE_P(_this_zval);
4381
4382
4383         php_error(E_WARNING, "get_data: not yet implemented"); RETURN_FALSE;
4384
4385         RETURN_STRINGL("", 0, 1);
4386 }
4387 /* }}} get_data */
4388
4389
4390
4391 /* {{{ proto int get_format()
4392    */
4393 PHP_METHOD(CairoImageSurface, get_format)
4394 {
4395         zend_class_entry * _this_ce;
4396
4397         zval * _this_zval = NULL;
4398
4399
4400
4401         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoImageSurface_ce_ptr) == FAILURE) {
4402                 return;
4403         }
4404
4405         _this_ce = Z_OBJCE_P(_this_zval);
4406
4407
4408         php_error(E_WARNING, "get_format: not yet implemented"); RETURN_FALSE;
4409
4410         RETURN_LONG(0);
4411 }
4412 /* }}} get_format */
4413
4414
4415
4416 /* {{{ proto int get_height()
4417    */
4418 PHP_METHOD(CairoImageSurface, get_height)
4419 {
4420         zend_class_entry * _this_ce;
4421
4422         zval * _this_zval = NULL;
4423
4424
4425
4426         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoImageSurface_ce_ptr) == FAILURE) {
4427                 return;
4428         }
4429
4430         _this_ce = Z_OBJCE_P(_this_zval);
4431
4432
4433         php_error(E_WARNING, "get_height: not yet implemented"); RETURN_FALSE;
4434
4435         RETURN_LONG(0);
4436 }
4437 /* }}} get_height */
4438
4439
4440
4441 /* {{{ proto int get_stride()
4442    */
4443 PHP_METHOD(CairoImageSurface, get_stride)
4444 {
4445         zend_class_entry * _this_ce;
4446
4447         zval * _this_zval = NULL;
4448
4449
4450
4451         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoImageSurface_ce_ptr) == FAILURE) {
4452                 return;
4453         }
4454
4455         _this_ce = Z_OBJCE_P(_this_zval);
4456
4457
4458         php_error(E_WARNING, "get_stride: not yet implemented"); RETURN_FALSE;
4459
4460         RETURN_LONG(0);
4461 }
4462 /* }}} get_stride */
4463
4464
4465
4466 /* {{{ proto int get_width()
4467    */
4468 PHP_METHOD(CairoImageSurface, get_width)
4469 {
4470         zend_class_entry * _this_ce;
4471
4472         zval * _this_zval = NULL;
4473
4474
4475
4476         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoImageSurface_ce_ptr) == FAILURE) {
4477                 return;
4478         }
4479
4480         _this_ce = Z_OBJCE_P(_this_zval);
4481
4482
4483         php_error(E_WARNING, "get_width: not yet implemented"); RETURN_FALSE;
4484
4485         RETURN_LONG(0);
4486 }
4487 /* }}} get_width */
4488
4489
4490 static zend_function_entry CairoImageSurface_methods[] = {
4491         PHP_ME(CairoImageSurface, __construct, CairoImageSurface____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
4492         PHP_ME(CairoImageSurface, create_from_data, CairoImageSurface__create_from_data_args, /**/ZEND_ACC_PRIVATE)
4493         PHP_ME(CairoImageSurface, create_from_png, CairoImageSurface__create_from_png_args, /**/ZEND_ACC_PRIVATE)
4494         PHP_ME(CairoImageSurface, get_data, NULL, /**/ZEND_ACC_PUBLIC)
4495         PHP_ME(CairoImageSurface, get_format, NULL, /**/ZEND_ACC_PUBLIC)
4496         PHP_ME(CairoImageSurface, get_height, NULL, /**/ZEND_ACC_PUBLIC)
4497         PHP_ME(CairoImageSurface, get_stride, NULL, /**/ZEND_ACC_PUBLIC)
4498         PHP_ME(CairoImageSurface, get_width, NULL, /**/ZEND_ACC_PUBLIC)
4499         { NULL, NULL, NULL }
4500 };
4501
4502 /* }}} Methods */
4503
4504 static void class_init_CairoImageSurface(void)
4505 {
4506         zend_class_entry ce;
4507
4508         INIT_CLASS_ENTRY(ce, "CairoImageSurface", CairoImageSurface_methods);
4509         CairoImageSurface_ce_ptr = zend_register_internal_class_ex(&ce, NULL, "CairoSurface" TSRMLS_CC);
4510 }
4511
4512 /* }}} Class CairoImageSurface */
4513
4514 /* {{{ Class CairoPDFSurface */
4515
4516 static zend_class_entry * CairoPDFSurface_ce_ptr = NULL;
4517
4518 /* {{{ Methods */
4519
4520
4521 /* {{{ proto void construct(string file, float wpts, float hpts)
4522    */
4523 PHP_METHOD(CairoPDFSurface, __construct)
4524 {
4525         zend_class_entry * _this_ce;
4526         zval * _this_zval;
4527
4528         const char * file = NULL;
4529         int file_len = 0;
4530         double wpts = 0.0;
4531         double hpts = 0.0;
4532
4533
4534
4535         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sdd", &file, &file_len, &wpts, &hpts) == FAILURE) {
4536                 return;
4537         }
4538
4539         _this_zval = getThis();
4540         _this_ce = Z_OBJCE_P(_this_zval);
4541
4542
4543         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
4544
4545 }
4546 /* }}} __construct */
4547
4548
4549
4550 /* {{{ proto void set_size(float wptd, float hpts)
4551    */
4552 PHP_METHOD(CairoPDFSurface, set_size)
4553 {
4554         zend_class_entry * _this_ce;
4555
4556         zval * _this_zval = NULL;
4557         double wptd = 0.0;
4558         double hpts = 0.0;
4559
4560
4561
4562         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoPDFSurface_ce_ptr, &wptd, &hpts) == FAILURE) {
4563                 return;
4564         }
4565
4566         _this_ce = Z_OBJCE_P(_this_zval);
4567
4568
4569         php_error(E_WARNING, "set_size: not yet implemented"); RETURN_FALSE;
4570
4571 }
4572 /* }}} set_size */
4573
4574
4575 static zend_function_entry CairoPDFSurface_methods[] = {
4576         PHP_ME(CairoPDFSurface, __construct, CairoPDFSurface____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
4577         PHP_ME(CairoPDFSurface, set_size, CairoPDFSurface__set_size_args, /**/ZEND_ACC_PUBLIC)
4578         { NULL, NULL, NULL }
4579 };
4580
4581 /* }}} Methods */
4582
4583 static void class_init_CairoPDFSurface(void)
4584 {
4585         zend_class_entry ce;
4586
4587         INIT_CLASS_ENTRY(ce, "CairoPDFSurface", CairoPDFSurface_methods);
4588         CairoPDFSurface_ce_ptr = zend_register_internal_class_ex(&ce, NULL, "CairoSurface" TSRMLS_CC);
4589 }
4590
4591 /* }}} Class CairoPDFSurface */
4592
4593 /* {{{ Class CairoPSSurface */
4594
4595 static zend_class_entry * CairoPSSurface_ce_ptr = NULL;
4596
4597 /* {{{ Methods */
4598
4599
4600 /* {{{ proto void construct(string file, float wpts, float hpts)
4601    */
4602 PHP_METHOD(CairoPSSurface, __construct)
4603 {
4604         zend_class_entry * _this_ce;
4605         zval * _this_zval;
4606
4607         const char * file = NULL;
4608         int file_len = 0;
4609         double wpts = 0.0;
4610         double hpts = 0.0;
4611
4612
4613
4614         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sdd", &file, &file_len, &wpts, &hpts) == FAILURE) {
4615                 return;
4616         }
4617
4618         _this_zval = getThis();
4619         _this_ce = Z_OBJCE_P(_this_zval);
4620
4621
4622         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
4623
4624 }
4625 /* }}} __construct */
4626
4627
4628
4629 /* {{{ proto void dsc_begin_page_setup()
4630    */
4631 PHP_METHOD(CairoPSSurface, dsc_begin_page_setup)
4632 {
4633         zend_class_entry * _this_ce;
4634
4635         zval * _this_zval = NULL;
4636
4637
4638
4639         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoPSSurface_ce_ptr) == FAILURE) {
4640                 return;
4641         }
4642
4643         _this_ce = Z_OBJCE_P(_this_zval);
4644
4645
4646         php_error(E_WARNING, "dsc_begin_page_setup: not yet implemented"); RETURN_FALSE;
4647
4648 }
4649 /* }}} dsc_begin_page_setup */
4650
4651
4652
4653 /* {{{ proto void dsc_begin_setup()
4654    */
4655 PHP_METHOD(CairoPSSurface, dsc_begin_setup)
4656 {
4657         zend_class_entry * _this_ce;
4658
4659         zval * _this_zval = NULL;
4660
4661
4662
4663         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoPSSurface_ce_ptr) == FAILURE) {
4664                 return;
4665         }
4666
4667         _this_ce = Z_OBJCE_P(_this_zval);
4668
4669
4670         php_error(E_WARNING, "dsc_begin_setup: not yet implemented"); RETURN_FALSE;
4671
4672 }
4673 /* }}} dsc_begin_setup */
4674
4675
4676
4677 /* {{{ proto void dsc_comment()
4678    */
4679 PHP_METHOD(CairoPSSurface, dsc_comment)
4680 {
4681         zend_class_entry * _this_ce;
4682
4683         zval * _this_zval = NULL;
4684
4685
4686
4687         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoPSSurface_ce_ptr) == FAILURE) {
4688                 return;
4689         }
4690
4691         _this_ce = Z_OBJCE_P(_this_zval);
4692
4693
4694         php_error(E_WARNING, "dsc_comment: not yet implemented"); RETURN_FALSE;
4695
4696 }
4697 /* }}} dsc_comment */
4698
4699
4700
4701 /* {{{ proto array get_levels()
4702    */
4703 PHP_METHOD(CairoPSSurface, get_levels)
4704 {
4705         zend_class_entry * _this_ce;
4706
4707         zval * _this_zval = NULL;
4708
4709
4710
4711         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoPSSurface_ce_ptr) == FAILURE) {
4712                 return;
4713         }
4714
4715         _this_ce = Z_OBJCE_P(_this_zval);
4716
4717
4718         array_init(return_value);
4719
4720         do {
4721                 /* ONLY for CAIRO 1.6
4722         } while (0);
4723 }
4724 /* }}} get_levels */
4725
4726
4727
4728 /* {{{ proto string get_level_string()
4729    */
4730 PHP_METHOD(CairoPSSurface, get_level_string)
4731 {
4732         zend_class_entry * _this_ce;
4733
4734         zval * _this_zval = NULL;
4735
4736
4737
4738         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoPSSurface_ce_ptr) == FAILURE) {
4739                 return;
4740         }
4741
4742         _this_ce = Z_OBJCE_P(_this_zval);
4743
4744
4745         do {
4746                 /* ONLY for CAIRO 1.6*/
4747         } while (0);
4748 }
4749 /* }}} get_level_string */
4750
4751
4752
4753 /* {{{ proto void restrict_to_level(int level)
4754    */
4755 PHP_METHOD(CairoPSSurface, restrict_to_level)
4756 {
4757         zend_class_entry * _this_ce;
4758
4759         zval * _this_zval = NULL;
4760         long level = 0;
4761
4762
4763
4764         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &_this_zval, CairoPSSurface_ce_ptr, &level) == FAILURE) {
4765                 return;
4766         }
4767
4768         _this_ce = Z_OBJCE_P(_this_zval);
4769
4770
4771         do {
4772                 /* ONLY for CAIRO 1.6 */
4773         } while (0);
4774 }
4775 /* }}} restrict_to_level */
4776
4777
4778
4779 /* {{{ proto void set_eps()
4780    */
4781 PHP_METHOD(CairoPSSurface, set_eps)
4782 {
4783         zend_class_entry * _this_ce;
4784
4785         zval * _this_zval = NULL;
4786
4787
4788
4789         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoPSSurface_ce_ptr) == FAILURE) {
4790                 return;
4791         }
4792
4793         _this_ce = Z_OBJCE_P(_this_zval);
4794
4795
4796         do {
4797                 /* ONLY for CAIRO 1.6 */
4798         } while (0);
4799 }
4800 /* }}} set_eps */
4801
4802
4803
4804 /* {{{ proto void set_size(float wpts, float hpts)
4805    */
4806 PHP_METHOD(CairoPSSurface, set_size)
4807 {
4808         zend_class_entry * _this_ce;
4809
4810         zval * _this_zval = NULL;
4811         double wpts = 0.0;
4812         double hpts = 0.0;
4813
4814
4815
4816         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoPSSurface_ce_ptr, &wpts, &hpts) == FAILURE) {
4817                 return;
4818         }
4819
4820         _this_ce = Z_OBJCE_P(_this_zval);
4821
4822
4823         php_error(E_WARNING, "set_size: not yet implemented"); RETURN_FALSE;
4824
4825 }
4826 /* }}} set_size */
4827
4828
4829 static zend_function_entry CairoPSSurface_methods[] = {
4830         PHP_ME(CairoPSSurface, __construct, CairoPSSurface____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
4831         PHP_ME(CairoPSSurface, dsc_begin_page_setup, NULL, /**/ZEND_ACC_PUBLIC)
4832         PHP_ME(CairoPSSurface, dsc_begin_setup, NULL, /**/ZEND_ACC_PUBLIC)
4833         PHP_ME(CairoPSSurface, dsc_comment, NULL, /**/ZEND_ACC_PUBLIC)
4834         PHP_ME(CairoPSSurface, get_levels, NULL, /**/ZEND_ACC_PUBLIC)
4835         PHP_ME(CairoPSSurface, get_level_string, NULL, /**/ZEND_ACC_PUBLIC)
4836         PHP_ME(CairoPSSurface, restrict_to_level, CairoPSSurface__restrict_to_level_args, /**/ZEND_ACC_PUBLIC)
4837         PHP_ME(CairoPSSurface, set_eps, NULL, /**/ZEND_ACC_PUBLIC)
4838         PHP_ME(CairoPSSurface, set_size, CairoPSSurface__set_size_args, /**/ZEND_ACC_PUBLIC)
4839         { NULL, NULL, NULL }
4840 };
4841
4842 /* }}} Methods */
4843
4844 static void class_init_CairoPSSurface(void)
4845 {
4846         zend_class_entry ce;
4847
4848         INIT_CLASS_ENTRY(ce, "CairoPSSurface", CairoPSSurface_methods);
4849         CairoPSSurface_ce_ptr = zend_register_internal_class_ex(&ce, NULL, "CairoSurface" TSRMLS_CC);
4850 }
4851
4852 /* }}} Class CairoPSSurface */
4853
4854 /* {{{ Class CairoQuartzSurface */
4855
4856 static zend_class_entry * CairoQuartzSurface_ce_ptr = NULL;
4857
4858 /* {{{ Methods */
4859
4860
4861 /* {{{ proto void construct(float wpixels, float hpixels [, int format])
4862    */
4863 PHP_METHOD(CairoQuartzSurface, __construct)
4864 {
4865         zend_class_entry * _this_ce;
4866         zval * _this_zval;
4867
4868         double wpixels = 0.0;
4869         double hpixels = 0.0;
4870         long format = 0;
4871
4872
4873
4874         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "dd|l", &wpixels, &hpixels, &format) == FAILURE) {
4875                 return;
4876         }
4877
4878         _this_zval = getThis();
4879         _this_ce = Z_OBJCE_P(_this_zval);
4880
4881
4882         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
4883
4884 }
4885 /* }}} __construct */
4886
4887
4888 static zend_function_entry CairoQuartzSurface_methods[] = {
4889         PHP_ME(CairoQuartzSurface, __construct, CairoQuartzSurface____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
4890         { NULL, NULL, NULL }
4891 };
4892
4893 /* }}} Methods */
4894
4895 static void class_init_CairoQuartzSurface(void)
4896 {
4897         zend_class_entry ce;
4898
4899         INIT_CLASS_ENTRY(ce, "CairoQuartzSurface", CairoQuartzSurface_methods);
4900         CairoQuartzSurface_ce_ptr = zend_register_internal_class_ex(&ce, NULL, "CairoSurface" TSRMLS_CC);
4901 }
4902
4903 /* }}} Class CairoQuartzSurface */
4904
4905 /* {{{ Class CairoSVGSurface */
4906
4907 static zend_class_entry * CairoSVGSurface_ce_ptr = NULL;
4908
4909 /* {{{ Methods */
4910
4911
4912 /* {{{ proto void construct(string file, float wpts, float hpts)
4913    */
4914 PHP_METHOD(CairoSVGSurface, __construct)
4915 {
4916         zend_class_entry * _this_ce;
4917         zval * _this_zval;
4918
4919         const char * file = NULL;
4920         int file_len = 0;
4921         double wpts = 0.0;
4922         double hpts = 0.0;
4923
4924
4925
4926         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sdd", &file, &file_len, &wpts, &hpts) == FAILURE) {
4927                 return;
4928         }
4929
4930         _this_zval = getThis();
4931         _this_ce = Z_OBJCE_P(_this_zval);
4932
4933
4934         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
4935
4936 }
4937 /* }}} __construct */
4938
4939
4940 static zend_function_entry CairoSVGSurface_methods[] = {
4941         PHP_ME(CairoSVGSurface, __construct, CairoSVGSurface____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
4942         { NULL, NULL, NULL }
4943 };
4944
4945 /* }}} Methods */
4946
4947 static void class_init_CairoSVGSurface(void)
4948 {
4949         zend_class_entry ce;
4950
4951         INIT_CLASS_ENTRY(ce, "CairoSVGSurface", CairoSVGSurface_methods);
4952         CairoSVGSurface_ce_ptr = zend_register_internal_class_ex(&ce, NULL, "CairoSurface" TSRMLS_CC);
4953 }
4954
4955 /* }}} Class CairoSVGSurface */
4956
4957 /* {{{ Class CairoWin32Surface */
4958
4959 static zend_class_entry * CairoWin32Surface_ce_ptr = NULL;
4960
4961 /* {{{ Methods */
4962
4963
4964 /* {{{ proto void construct(int hdc)
4965    */
4966 PHP_METHOD(CairoWin32Surface, __construct)
4967 {
4968         zend_class_entry * _this_ce;
4969         zval * _this_zval;
4970
4971         long hdc = 0;
4972
4973
4974
4975         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &hdc) == FAILURE) {
4976                 return;
4977         }
4978
4979         _this_zval = getThis();
4980         _this_ce = Z_OBJCE_P(_this_zval);
4981
4982
4983         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
4984
4985 }
4986 /* }}} __construct */
4987
4988
4989 static zend_function_entry CairoWin32Surface_methods[] = {
4990         PHP_ME(CairoWin32Surface, __construct, NULL, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
4991         { NULL, NULL, NULL }
4992 };
4993
4994 /* }}} Methods */
4995
4996 static void class_init_CairoWin32Surface(void)
4997 {
4998         zend_class_entry ce;
4999
5000         INIT_CLASS_ENTRY(ce, "CairoWin32Surface", CairoWin32Surface_methods);
5001         CairoWin32Surface_ce_ptr = zend_register_internal_class_ex(&ce, NULL, "CairoSurface" TSRMLS_CC);
5002 }
5003
5004 /* }}} Class CairoWin32Surface */
5005
5006 /* {{{ Class CairoXlibSurface */
5007
5008 static zend_class_entry * CairoXlibSurface_ce_ptr = NULL;
5009
5010 /* {{{ Methods */
5011
5012
5013 /* {{{ proto void construct()
5014    */
5015 PHP_METHOD(CairoXlibSurface, __construct)
5016 {
5017         zend_class_entry * _this_ce;
5018         zval * _this_zval;
5019
5020
5021
5022         if (ZEND_NUM_ARGS()>0)  {
5023                 WRONG_PARAM_COUNT;
5024         }
5025
5026
5027         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
5028
5029 }
5030 /* }}} __construct */
5031
5032
5033
5034 /* {{{ proto int get_depth()
5035    */
5036 PHP_METHOD(CairoXlibSurface, get_depth)
5037 {
5038         zend_class_entry * _this_ce;
5039
5040         zval * _this_zval = NULL;
5041
5042
5043
5044         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoXlibSurface_ce_ptr) == FAILURE) {
5045                 return;
5046         }
5047
5048         _this_ce = Z_OBJCE_P(_this_zval);
5049
5050
5051         php_error(E_WARNING, "get_depth: not yet implemented"); RETURN_FALSE;
5052
5053         RETURN_LONG(0);
5054 }
5055 /* }}} get_depth */
5056
5057
5058
5059 /* {{{ proto int get_height()
5060    */
5061 PHP_METHOD(CairoXlibSurface, get_height)
5062 {
5063         zend_class_entry * _this_ce;
5064
5065         zval * _this_zval = NULL;
5066
5067
5068
5069         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoXlibSurface_ce_ptr) == FAILURE) {
5070                 return;
5071         }
5072
5073         _this_ce = Z_OBJCE_P(_this_zval);
5074
5075
5076         php_error(E_WARNING, "get_height: not yet implemented"); RETURN_FALSE;
5077
5078         RETURN_LONG(0);
5079 }
5080 /* }}} get_height */
5081
5082
5083
5084 /* {{{ proto int get_width()
5085    */
5086 PHP_METHOD(CairoXlibSurface, get_width)
5087 {
5088         zend_class_entry * _this_ce;
5089
5090         zval * _this_zval = NULL;
5091
5092
5093
5094         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoXlibSurface_ce_ptr) == FAILURE) {
5095                 return;
5096         }
5097
5098         _this_ce = Z_OBJCE_P(_this_zval);
5099
5100
5101         php_error(E_WARNING, "get_width: not yet implemented"); RETURN_FALSE;
5102
5103         RETURN_LONG(0);
5104 }
5105 /* }}} get_width */
5106
5107
5108 static zend_function_entry CairoXlibSurface_methods[] = {
5109         PHP_ME(CairoXlibSurface, __construct, NULL, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
5110         PHP_ME(CairoXlibSurface, get_depth, NULL, /**/ZEND_ACC_PUBLIC)
5111         PHP_ME(CairoXlibSurface, get_height, NULL, /**/ZEND_ACC_PUBLIC)
5112         PHP_ME(CairoXlibSurface, get_width, NULL, /**/ZEND_ACC_PUBLIC)
5113         { NULL, NULL, NULL }
5114 };
5115
5116 /* }}} Methods */
5117
5118 static void class_init_CairoXlibSurface(void)
5119 {
5120         zend_class_entry ce;
5121
5122         INIT_CLASS_ENTRY(ce, "CairoXlibSurface", CairoXlibSurface_methods);
5123         CairoXlibSurface_ce_ptr = zend_register_internal_class_ex(&ce, NULL, "CairoSurface" TSRMLS_CC);
5124 }
5125
5126 /* }}} Class CairoXlibSurface */
5127
5128 /* {{{ Class CairoException */
5129
5130 static zend_class_entry * CairoException_ce_ptr = NULL;
5131
5132 /* {{{ Methods */
5133
5134 static zend_function_entry CairoException_methods[] = {
5135         { NULL, NULL, NULL }
5136 };
5137
5138 /* }}} Methods */
5139
5140 static void class_init_CairoException(void)
5141 {
5142         zend_class_entry ce;
5143
5144         INIT_CLASS_ENTRY(ce, "CairoException", CairoException_methods);
5145         CairoException_ce_ptr = zend_register_internal_class_ex(&ce, NULL, "Exception" TSRMLS_CC);
5146 }
5147
5148 /* }}} Class CairoException */
5149
5150 /* }}} Class definitions*/
5151
5152 /* {{{ phpCairo_functions[] */
5153 function_entry phpCairo_functions[] = {
5154         PHP_FE(cairo_version       , cairo_version_arg_info)
5155         PHP_FE(cairo_version_string, cairo_version_string_arg_info)
5156         { NULL, NULL, NULL }
5157 };
5158 /* }}} */
5159
5160
5161 /* {{{ phpCairo_module_entry
5162  */
5163 zend_module_entry phpCairo_module_entry = {
5164         STANDARD_MODULE_HEADER,
5165         "phpCairo",
5166         phpCairo_functions,
5167         PHP_MINIT(phpCairo),     /* Replace with NULL if there is nothing to do at php startup   */
5168         PHP_MSHUTDOWN(phpCairo), /* Replace with NULL if there is nothing to do at php shutdown  */
5169         PHP_RINIT(phpCairo),     /* Replace with NULL if there is nothing to do at request start */
5170         PHP_RSHUTDOWN(phpCairo), /* Replace with NULL if there is nothing to do at request end   */
5171         PHP_MINFO(phpCairo),
5172         "0.0.1",
5173         STANDARD_MODULE_PROPERTIES
5174 };
5175 /* }}} */
5176
5177 #ifdef COMPILE_DL_PHPCAIRO
5178 ZEND_GET_MODULE(phpCairo)
5179 #endif
5180
5181
5182 /* {{{ PHP_MINIT_FUNCTION */
5183 PHP_MINIT_FUNCTION(phpCairo)
5184 {
5185         class_init_CairoContext();
5186         class_init_CairoFontFace();
5187         class_init_CairoFontOptions();
5188         class_init_CairoMatrix();
5189         class_init_CairoPattern();
5190         class_init_CairoGradient();
5191         class_init_CairoLinearGradient();
5192         class_init_CairoRadialGradient();
5193         class_init_CairoSolidPattern();
5194         class_init_CairoSurfacePattern();
5195         class_init_CairoScaledFont();
5196         class_init_CairoSurface();
5197         class_init_CairoImageSurface();
5198         class_init_CairoPDFSurface();
5199         class_init_CairoPSSurface();
5200         class_init_CairoQuartzSurface();
5201         class_init_CairoSVGSurface();
5202         class_init_CairoWin32Surface();
5203         class_init_CairoXlibSurface();
5204         class_init_CairoException();
5205
5206         /* add your stuff here */
5207
5208         return SUCCESS;
5209 }
5210 /* }}} */
5211
5212
5213 /* {{{ PHP_MSHUTDOWN_FUNCTION */
5214 PHP_MSHUTDOWN_FUNCTION(phpCairo)
5215 {
5216
5217         /* add your stuff here */
5218
5219         return SUCCESS;
5220 }
5221 /* }}} */
5222
5223
5224 /* {{{ PHP_RINIT_FUNCTION */
5225 PHP_RINIT_FUNCTION(phpCairo)
5226 {
5227         /* add your stuff here */
5228
5229         return SUCCESS;
5230 }
5231 /* }}} */
5232
5233
5234 /* {{{ PHP_RSHUTDOWN_FUNCTION */
5235 PHP_RSHUTDOWN_FUNCTION(phpCairo)
5236 {
5237         /* add your stuff here */
5238
5239         return SUCCESS;
5240 }
5241 /* }}} */
5242
5243
5244 /* {{{ PHP_MINFO_FUNCTION */
5245 PHP_MINFO_FUNCTION(phpCairo)
5246 {
5247         php_info_print_box_start(0);
5248         php_printf("<p>PHP bindings for Cairo Graphic Library</p>\n");
5249         php_printf("<p>Version 0.0.1devel (2008-05-06)</p>\n");
5250         php_printf("<p><b>Authors:</b></p>\n");
5251         php_printf("<p>Akshat Gupta &lt;g.akshat@gmail.com&gt; (lead)</p>\n");
5252         php_info_print_box_end();
5253         /* add your stuff here */
5254
5255 }
5256 /* }}} */
5257
5258
5259 /* {{{ proto int cairo_version()
5260    */
5261 PHP_FUNCTION(cairo_version)
5262 {
5263
5264
5265
5266         if (ZEND_NUM_ARGS()>0)  {
5267                 WRONG_PARAM_COUNT;
5268         }
5269
5270
5271         php_error(E_WARNING, "cairo_version: not yet implemented"); RETURN_FALSE;
5272
5273         RETURN_LONG(0);
5274 }
5275 /* }}} cairo_version */
5276
5277
5278 /* {{{ proto string cairo_version_string()
5279    */
5280 PHP_FUNCTION(cairo_version_string)
5281 {
5282
5283
5284
5285         if (ZEND_NUM_ARGS()>0)  {
5286                 WRONG_PARAM_COUNT;
5287         }
5288
5289
5290         php_error(E_WARNING, "cairo_version_string: not yet implemented"); RETURN_FALSE;
5291
5292         RETURN_STRINGL("", 0, 1);
5293 }
5294 /* }}} cairo_version_string */
5295
5296 #endif /* HAVE_PHPCAIRO */
5297
5298
5299 /*
5300  * Local variables:
5301  * tab-width: 4
5302  * c-basic-offset: 4
5303  * End:
5304  * vim600: noet sw=4 ts=4 fdm=marker
5305  * vim<600: noet sw=4 ts=4
5306  */