individual_files/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 #include "phpCairoSurface.c"
  19 #include "phpCairoContext.c"
  20 #if HAVE_PHPCAIRO
  21
  22 /* {{{ Class definitions */
  23
  24
  25 /* {{{ Class CairoFontFace */
  26
  27 static zend_class_entry * CairoFontFace_ce_ptr = NULL;
  28
  29 /* {{{ Methods */
  30
  31
  32 /* {{{ proto void construct()
  33    */
  34 PHP_METHOD(CairoFontFace, __construct)
  35 {
  36         zend_class_entry * _this_ce;
  37         zval * _this_zval;
  38
  39
  40
  41         if (ZEND_NUM_ARGS()>0)  {
  42                 WRONG_PARAM_COUNT;
  43         }
  44
  45
  46         do {
  47                 /* not allowede to create an object directly*/
  48         } while (0);
  49 }
  50 /* }}} __construct */
  51
  52
  53
  54 /* {{{ proto void destruct()
  55    */
  56 PHP_METHOD(CairoFontFace, __destruct)
  57 {
  58         zend_class_entry * _this_ce;
  59
  60         zval * _this_zval = NULL;
  61
  62
  63
  64         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoFontFace_ce_ptr) == FAILURE) {
  65                 return;
  66         }
  67
  68         _this_ce = Z_OBJCE_P(_this_zval);
  69
  70
  71         php_error(E_WARNING, "__destruct: not yet implemented"); RETURN_FALSE;
  72
  73 }
  74 /* }}} __destruct */
  75
  76
  77 static zend_function_entry CairoFontFace_methods[] = {
  78         PHP_ME(CairoFontFace, __construct, NULL, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
  79         PHP_ME(CairoFontFace, __destruct, NULL, /**/ZEND_ACC_PUBLIC)
  80         { NULL, NULL, NULL }
  81 };
  82
  83 /* }}} Methods */
  84
  85 static void class_init_CairoFontFace(void)
  86 {
  87         zend_class_entry ce;
  88
  89         INIT_CLASS_ENTRY(ce, "CairoFontFace", CairoFontFace_methods);
  90         CairoFontFace_ce_ptr = zend_register_internal_class(&ce);
  91 }
  92
  93 /* }}} Class CairoFontFace */
  94
  95 /* {{{ Class CairoFontOptions */
  96
  97 static zend_class_entry * CairoFontOptions_ce_ptr = NULL;
  98
  99 /* {{{ Methods */
 100
 101
 102 /* {{{ proto void construct()
 103    */
 104 PHP_METHOD(CairoFontOptions, __construct)
 105 {
 106         zend_class_entry * _this_ce;
 107         zval * _this_zval;
 108
 109
 110
 111         if (ZEND_NUM_ARGS()>0)  {
 112                 WRONG_PARAM_COUNT;
 113         }
 114
 115
 116         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
 117
 118 }
 119 /* }}} __construct */
 120
 121
 122
 123 /* {{{ proto int get_antialias()
 124    */
 125 PHP_METHOD(CairoFontOptions, get_antialias)
 126 {
 127         zend_class_entry * _this_ce;
 128
 129         zval * _this_zval = NULL;
 130
 131
 132
 133         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoFontOptions_ce_ptr) == FAILURE) {
 134                 return;
 135         }
 136
 137         _this_ce = Z_OBJCE_P(_this_zval);
 138
 139
 140         php_error(E_WARNING, "get_antialias: not yet implemented"); RETURN_FALSE;
 141
 142         RETURN_LONG(0);
 143 }
 144 /* }}} get_antialias */
 145
 146
 147
 148 /* {{{ proto int get_hint_metrics()
 149    */
 150 PHP_METHOD(CairoFontOptions, get_hint_metrics)
 151 {
 152         zend_class_entry * _this_ce;
 153
 154         zval * _this_zval = NULL;
 155
 156
 157
 158         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoFontOptions_ce_ptr) == FAILURE) {
 159                 return;
 160         }
 161
 162         _this_ce = Z_OBJCE_P(_this_zval);
 163
 164
 165         php_error(E_WARNING, "get_hint_metrics: not yet implemented"); RETURN_FALSE;
 166
 167         RETURN_LONG(0);
 168 }
 169 /* }}} get_hint_metrics */
 170
 171
 172
 173 /* {{{ proto int get_hint_style()
 174    */
 175 PHP_METHOD(CairoFontOptions, get_hint_style)
 176 {
 177         zend_class_entry * _this_ce;
 178
 179         zval * _this_zval = NULL;
 180
 181
 182
 183         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoFontOptions_ce_ptr) == FAILURE) {
 184                 return;
 185         }
 186
 187         _this_ce = Z_OBJCE_P(_this_zval);
 188
 189
 190         php_error(E_WARNING, "get_hint_style: not yet implemented"); RETURN_FALSE;
 191
 192         RETURN_LONG(0);
 193 }
 194 /* }}} get_hint_style */
 195
 196
 197
 198 /* {{{ proto int get_subpixel_order()
 199    */
 200 PHP_METHOD(CairoFontOptions, get_subpixel_order)
 201 {
 202         zend_class_entry * _this_ce;
 203
 204         zval * _this_zval = NULL;
 205
 206
 207
 208         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoFontOptions_ce_ptr) == FAILURE) {
 209                 return;
 210         }
 211
 212         _this_ce = Z_OBJCE_P(_this_zval);
 213
 214
 215         php_error(E_WARNING, "get_subpixel_order: not yet implemented"); RETURN_FALSE;
 216
 217         RETURN_LONG(0);
 218 }
 219 /* }}} get_subpixel_order */
 220
 221
 222
 223 /* {{{ proto void set_antialias([int aa])
 224    */
 225 PHP_METHOD(CairoFontOptions, set_antialias)
 226 {
 227         zend_class_entry * _this_ce;
 228
 229         zval * _this_zval = NULL;
 230         long aa = 0;
 231
 232
 233
 234         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|l", &_this_zval, CairoFontOptions_ce_ptr, &aa) == FAILURE) {
 235                 return;
 236         }
 237
 238         _this_ce = Z_OBJCE_P(_this_zval);
 239
 240
 241         php_error(E_WARNING, "set_antialias: not yet implemented"); RETURN_FALSE;
 242
 243 }
 244 /* }}} set_antialias */
 245
 246
 247
 248 /* {{{ proto void set_hint_metrics([int hm])
 249    */
 250 PHP_METHOD(CairoFontOptions, set_hint_metrics)
 251 {
 252         zend_class_entry * _this_ce;
 253
 254         zval * _this_zval = NULL;
 255         long hm = 0;
 256
 257
 258
 259         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|l", &_this_zval, CairoFontOptions_ce_ptr, &hm) == FAILURE) {
 260                 return;
 261         }
 262
 263         _this_ce = Z_OBJCE_P(_this_zval);
 264
 265
 266         php_error(E_WARNING, "set_hint_metrics: not yet implemented"); RETURN_FALSE;
 267
 268 }
 269 /* }}} set_hint_metrics */
 270
 271
 272
 273 /* {{{ proto void set_hint_style([int hs])
 274    */
 275 PHP_METHOD(CairoFontOptions, set_hint_style)
 276 {
 277         zend_class_entry * _this_ce;
 278
 279         zval * _this_zval = NULL;
 280         long hs = 0;
 281
 282
 283
 284         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|l", &_this_zval, CairoFontOptions_ce_ptr, &hs) == FAILURE) {
 285                 return;
 286         }
 287
 288         _this_ce = Z_OBJCE_P(_this_zval);
 289
 290
 291         php_error(E_WARNING, "set_hint_style: not yet implemented"); RETURN_FALSE;
 292
 293 }
 294 /* }}} set_hint_style */
 295
 296
 297
 298 /* {{{ proto void set_subpixel_order([int so])
 299    */
 300 PHP_METHOD(CairoFontOptions, set_subpixel_order)
 301 {
 302         zend_class_entry * _this_ce;
 303
 304         zval * _this_zval = NULL;
 305         long so = 0;
 306
 307
 308
 309         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|l", &_this_zval, CairoFontOptions_ce_ptr, &so) == FAILURE) {
 310                 return;
 311         }
 312
 313         _this_ce = Z_OBJCE_P(_this_zval);
 314
 315
 316         php_error(E_WARNING, "set_subpixel_order: not yet implemented"); RETURN_FALSE;
 317
 318 }
 319 /* }}} set_subpixel_order */
 320
 321
 322 static zend_function_entry CairoFontOptions_methods[] = {
 323         PHP_ME(CairoFontOptions, __construct, NULL, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
 324         PHP_ME(CairoFontOptions, get_antialias, NULL, /**/ZEND_ACC_PUBLIC)
 325         PHP_ME(CairoFontOptions, get_hint_metrics, NULL, /**/ZEND_ACC_PUBLIC)
 326         PHP_ME(CairoFontOptions, get_hint_style, NULL, /**/ZEND_ACC_PUBLIC)
 327         PHP_ME(CairoFontOptions, get_subpixel_order, NULL, /**/ZEND_ACC_PUBLIC)
 328         PHP_ME(CairoFontOptions, set_antialias, CairoFontOptions__set_antialias_args, /**/ZEND_ACC_PUBLIC)
 329         PHP_ME(CairoFontOptions, set_hint_metrics, CairoFontOptions__set_hint_metrics_args, /**/ZEND_ACC_PUBLIC)
 330         PHP_ME(CairoFontOptions, set_hint_style, CairoFontOptions__set_hint_style_args, /**/ZEND_ACC_PUBLIC)
 331         PHP_ME(CairoFontOptions, set_subpixel_order, CairoFontOptions__set_subpixel_order_args, /**/ZEND_ACC_PUBLIC)
 332         { NULL, NULL, NULL }
 333 };
 334
 335 /* }}} Methods */
 336
 337 static void class_init_CairoFontOptions(void)
 338 {
 339         zend_class_entry ce;
 340
 341         INIT_CLASS_ENTRY(ce, "CairoFontOptions", CairoFontOptions_methods);
 342         CairoFontOptions_ce_ptr = zend_register_internal_class(&ce);
 343 }
 344
 345 /* }}} Class CairoFontOptions */
 346
 347 /* {{{ Class CairoMatrix */
 348
 349 static zend_class_entry * CairoMatrix_ce_ptr = NULL;
 350
 351 /* {{{ Methods */
 352
 353
 354 /* {{{ proto void construct([float xx, float yx, float xy, float yy, float x0, float y0])
 355    */
 356 PHP_METHOD(CairoMatrix, __construct)
 357 {
 358         zend_class_entry * _this_ce;
 359         zval * _this_zval;
 360
 361         double xx = 0.0;
 362         double yx = 0.0;
 363         double xy = 0.0;
 364         double yy = 0.0;
 365         double x0 = 0.0;
 366         double y0 = 0.0;
 367
 368
 369
 370         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|dddddd", &xx, &yx, &xy, &yy, &x0, &y0) == FAILURE) {
 371                 return;
 372         }
 373
 374         _this_zval = getThis();
 375         _this_ce = Z_OBJCE_P(_this_zval);
 376
 377
 378         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
 379
 380 }
 381 /* }}} __construct */
 382
 383
 384
 385 /* {{{ proto object inti_rotate(float radians)
 386    */
 387 PHP_METHOD(CairoMatrix, init_rotate)
 388 {
 389         zend_class_entry * _this_ce;
 390
 391         zval * _this_zval = NULL;
 392         double radians = 0.0;
 393
 394
 395
 396         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Od", &_this_zval, CairoMatrix_ce_ptr, &radians) == FAILURE) {
 397                 return;
 398         }
 399
 400         _this_ce = Z_OBJCE_P(_this_zval);
 401
 402
 403         php_error(E_WARNING, "init_rotate: not yet implemented"); RETURN_FALSE;
 404
 405         object_init(return_value);
 406 }
 407 /* }}} init_rotate */
 408
 409
 410
 411 /* {{{ proto void invert()
 412    */
 413 PHP_METHOD(CairoMatrix, invert)
 414 {
 415         zend_class_entry * _this_ce;
 416
 417         zval * _this_zval = NULL;
 418
 419
 420
 421         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoMatrix_ce_ptr) == FAILURE) {
 422                 return;
 423         }
 424
 425         _this_ce = Z_OBJCE_P(_this_zval);
 426
 427
 428         php_error(E_WARNING, "invert: not yet implemented"); RETURN_FALSE;
 429
 430 }
 431 /* }}} invert */
 432
 433
 434
 435 /* {{{ proto object multiply(object o2)
 436    */
 437 PHP_METHOD(CairoMatrix, multiply)
 438 {
 439         zend_class_entry * _this_ce;
 440
 441         zval * _this_zval = NULL;
 442         zval * o2 = NULL;
 443
 444
 445
 446         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo", &_this_zval, CairoMatrix_ce_ptr, &o2) == FAILURE) {
 447                 return;
 448         }
 449
 450         _this_ce = Z_OBJCE_P(_this_zval);
 451
 452
 453         php_error(E_WARNING, "multiply: not yet implemented"); RETURN_FALSE;
 454
 455         object_init(return_value);
 456 }
 457 /* }}} multiply */
 458
 459
 460
 461 /* {{{ proto void rotate(float radians)
 462    */
 463 PHP_METHOD(CairoMatrix, rotate)
 464 {
 465         zend_class_entry * _this_ce;
 466
 467         zval * _this_zval = NULL;
 468         double radians = 0.0;
 469
 470
 471
 472         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Od", &_this_zval, CairoMatrix_ce_ptr, &radians) == FAILURE) {
 473                 return;
 474         }
 475
 476         _this_ce = Z_OBJCE_P(_this_zval);
 477
 478
 479         php_error(E_WARNING, "rotate: not yet implemented"); RETURN_FALSE;
 480
 481 }
 482 /* }}} rotate */
 483
 484
 485
 486 /* {{{ proto void scale(float sx, float xy)
 487    */
 488 PHP_METHOD(CairoMatrix, scale)
 489 {
 490         zend_class_entry * _this_ce;
 491
 492         zval * _this_zval = NULL;
 493         double sx = 0.0;
 494         double xy = 0.0;
 495
 496
 497
 498         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoMatrix_ce_ptr, &sx, &xy) == FAILURE) {
 499                 return;
 500         }
 501
 502         _this_ce = Z_OBJCE_P(_this_zval);
 503
 504
 505         php_error(E_WARNING, "scale: not yet implemented"); RETURN_FALSE;
 506
 507 }
 508 /* }}} scale */
 509
 510
 511
 512 /* {{{ proto array transform_distance(float dx, float dy)
 513    */
 514 PHP_METHOD(CairoMatrix, transform_distance)
 515 {
 516         zend_class_entry * _this_ce;
 517
 518         zval * _this_zval = NULL;
 519         double dx = 0.0;
 520         double dy = 0.0;
 521
 522
 523
 524         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoMatrix_ce_ptr, &dx, &dy) == FAILURE) {
 525                 return;
 526         }
 527
 528         _this_ce = Z_OBJCE_P(_this_zval);
 529
 530
 531         array_init(return_value);
 532
 533         php_error(E_WARNING, "transform_distance: not yet implemented"); RETURN_FALSE;
 534
 535         array_init(return_value);
 536 }
 537 /* }}} transform_distance */
 538
 539
 540
 541 /* {{{ proto array transform_point(float x, float y)
 542    */
 543 PHP_METHOD(CairoMatrix, transform_point)
 544 {
 545         zend_class_entry * _this_ce;
 546
 547         zval * _this_zval = NULL;
 548         double x = 0.0;
 549         double y = 0.0;
 550
 551
 552
 553         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoMatrix_ce_ptr, &x, &y) == FAILURE) {
 554                 return;
 555         }
 556
 557         _this_ce = Z_OBJCE_P(_this_zval);
 558
 559
 560         array_init(return_value);
 561
 562         php_error(E_WARNING, "transform_point: not yet implemented"); RETURN_FALSE;
 563
 564         array_init(return_value);
 565 }
 566 /* }}} transform_point */
 567
 568
 569
 570 /* {{{ proto void translate(float tx, float ty)
 571    */
 572 PHP_METHOD(CairoMatrix, translate)
 573 {
 574         zend_class_entry * _this_ce;
 575
 576         zval * _this_zval = NULL;
 577         double tx = 0.0;
 578         double ty = 0.0;
 579
 580
 581
 582         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odd", &_this_zval, CairoMatrix_ce_ptr, &tx, &ty) == FAILURE) {
 583                 return;
 584         }
 585
 586         _this_ce = Z_OBJCE_P(_this_zval);
 587
 588
 589         php_error(E_WARNING, "translate: not yet implemented"); RETURN_FALSE;
 590
 591 }
 592 /* }}} translate */
 593
 594
 595 static zend_function_entry CairoMatrix_methods[] = {
 596         PHP_ME(CairoMatrix, __construct, CairoMatrix____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
 597         PHP_ME(CairoMatrix, init_rotate, CairoMatrix__init_rotate_args, /**/ZEND_ACC_PRIVATE)
 598         PHP_ME(CairoMatrix, invert, NULL, /**/ZEND_ACC_PUBLIC)
 599         PHP_ME(CairoMatrix, multiply, CairoMatrix__multiply_args, /**/ZEND_ACC_PUBLIC)
 600         PHP_ME(CairoMatrix, rotate, CairoMatrix__rotate_args, /**/ZEND_ACC_PUBLIC)
 601         PHP_ME(CairoMatrix, scale, CairoMatrix__scale_args, /**/ZEND_ACC_PUBLIC)
 602         PHP_ME(CairoMatrix, transform_distance, CairoMatrix__transform_distance_args, /**/ZEND_ACC_PUBLIC)
 603         PHP_ME(CairoMatrix, transform_point, CairoMatrix__transform_point_args, /**/ZEND_ACC_PUBLIC)
 604         PHP_ME(CairoMatrix, translate, CairoMatrix__translate_args, /**/ZEND_ACC_PUBLIC)
 605         { NULL, NULL, NULL }
 606 };
 607
 608 /* }}} Methods */
 609
 610 static void class_init_CairoMatrix(void)
 611 {
 612         zend_class_entry ce;
 613
 614         INIT_CLASS_ENTRY(ce, "CairoMatrix", CairoMatrix_methods);
 615         CairoMatrix_ce_ptr = zend_register_internal_class(&ce);
 616 }
 617
 618 /* }}} Class CairoMatrix */
 619
 620 /* {{{ Class CairoPath */
 621
 622 static zend_class_entry * CairoPath_ce_ptr = NULL;
 623
 624 /* {{{ Methods */
 625
 626
 627 /* {{{ proto void construct()
 628    */
 629 PHP_METHOD(CairoPath, __construct)
 630 {
 631         zend_class_entry * _this_ce;
 632         zval * _this_zval;
 633
 634
 635
 636         if (ZEND_NUM_ARGS()>0)  {
 637                 WRONG_PARAM_COUNT;
 638         }
 639
 640
 641         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
 642
 643 }
 644 /* }}} __construct */
 645
 646
 647
 648 /* {{{ proto string str()
 649    */
 650 PHP_METHOD(CairoPath, str)
 651 {
 652         zend_class_entry * _this_ce;
 653
 654         zval * _this_zval = NULL;
 655
 656
 657
 658         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoPath_ce_ptr) == FAILURE) {
 659                 return;
 660         }
 661
 662         _this_ce = Z_OBJCE_P(_this_zval);
 663
 664
 665         php_error(E_WARNING, "str: not yet implemented"); RETURN_FALSE;
 666
 667         RETURN_STRINGL("", 0, 1);
 668 }
 669 /* }}} str */
 670
 671
 672 static zend_function_entry CairoPath_methods[] = {
 673         PHP_ME(CairoPath, __construct, NULL, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
 674         PHP_ME(CairoPath, str, NULL, /**/ZEND_ACC_PUBLIC)
 675         { NULL, NULL, NULL }
 676 };
 677
 678 /* }}} Methods */
 679
 680 static void class_init_CairoPath(void)
 681 {
 682         zend_class_entry ce;
 683
 684         INIT_CLASS_ENTRY(ce, "CairoPath", CairoPath_methods);
 685         CairoPath_ce_ptr = zend_register_internal_class(&ce);
 686 }
 687
 688 /* }}} Class CairoPath */
 689
 690 /* {{{ Class CairoPattern */
 691
 692 static zend_class_entry * CairoPattern_ce_ptr = NULL;
 693
 694 /* {{{ Methods */
 695
 696
 697 /* {{{ proto void contruct()
 698    */
 699 PHP_METHOD(CairoPattern, __construct)
 700 {
 701         zend_class_entry * _this_ce;
 702         zval * _this_zval;
 703
 704
 705
 706         if (ZEND_NUM_ARGS()>0)  {
 707                 WRONG_PARAM_COUNT;
 708         }
 709
 710
 711         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
 712
 713 }
 714 /* }}} __construct */
 715
 716
 717
 718 /* {{{ proto object get_matrix()
 719    */
 720 PHP_METHOD(CairoPattern, get_matrix)
 721 {
 722         zend_class_entry * _this_ce;
 723
 724         zval * _this_zval = NULL;
 725
 726
 727
 728         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoPattern_ce_ptr) == FAILURE) {
 729                 return;
 730         }
 731
 732         _this_ce = Z_OBJCE_P(_this_zval);
 733
 734
 735         php_error(E_WARNING, "get_matrix: not yet implemented"); RETURN_FALSE;
 736
 737         object_init(return_value);
 738 }
 739 /* }}} get_matrix */
 740
 741
 742
 743 /* {{{ proto void set_matrix(object m)
 744    */
 745 PHP_METHOD(CairoPattern, set_matrix)
 746 {
 747         zend_class_entry * _this_ce;
 748
 749         zval * _this_zval = NULL;
 750         zval * m = NULL;
 751
 752
 753
 754         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo", &_this_zval, CairoPattern_ce_ptr, &m) == FAILURE) {
 755                 return;
 756         }
 757
 758         _this_ce = Z_OBJCE_P(_this_zval);
 759
 760
 761         php_error(E_WARNING, "set_matrix: not yet implemented"); RETURN_FALSE;
 762
 763 }
 764 /* }}} set_matrix */
 765
 766
 767 static zend_function_entry CairoPattern_methods[] = {
 768         PHP_ME(CairoPattern, __construct, NULL, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
 769         PHP_ME(CairoPattern, get_matrix, NULL, /**/ZEND_ACC_PUBLIC)
 770         PHP_ME(CairoPattern, set_matrix, CairoPattern__set_matrix_args, /**/ZEND_ACC_PUBLIC)
 771         { NULL, NULL, NULL }
 772 };
 773
 774 /* }}} Methods */
 775
 776 static void class_init_CairoPattern(void)
 777 {
 778         zend_class_entry ce;
 779
 780         INIT_CLASS_ENTRY(ce, "CairoPattern", CairoPattern_methods);
 781         CairoPattern_ce_ptr = zend_register_internal_class(&ce);
 782 }
 783
 784 /* }}} Class CairoPattern */
 785
 786 /* {{{ Class CairoGradient */
 787
 788 static zend_class_entry * CairoGradient_ce_ptr = NULL;
 789
 790 /* {{{ Methods */
 791
 792
 793 /* {{{ proto void construct()
 794    */
 795 PHP_METHOD(CairoGradient, __contruct)
 796 {
 797         zend_class_entry * _this_ce;
 798
 799         zval * _this_zval = NULL;
 800
 801
 802
 803         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoGradient_ce_ptr) == FAILURE) {
 804                 return;
 805         }
 806
 807         _this_ce = Z_OBJCE_P(_this_zval);
 808
 809
 810         php_error(E_WARNING, "__contruct: not yet implemented"); RETURN_FALSE;
 811
 812 }
 813 /* }}} __contruct */
 814
 815
 816
 817 /* {{{ proto void add_color_stop_rgb(float offset, float red, float green, float blue)
 818    */
 819 PHP_METHOD(CairoGradient, add_color_stop_rgb)
 820 {
 821         zend_class_entry * _this_ce;
 822
 823         zval * _this_zval = NULL;
 824         double offset = 0.0;
 825         double red = 0.0;
 826         double green = 0.0;
 827         double blue = 0.0;
 828
 829
 830
 831         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odddd", &_this_zval, CairoGradient_ce_ptr, &offset, &red, &green, &blue) == FAILURE) {
 832                 return;
 833         }
 834
 835         _this_ce = Z_OBJCE_P(_this_zval);
 836
 837
 838         php_error(E_WARNING, "add_color_stop_rgb: not yet implemented"); RETURN_FALSE;
 839
 840 }
 841 /* }}} add_color_stop_rgb */
 842
 843
 844
 845 /* {{{ proto void add_color_stop_rgba(float offset, float red, float green, float blue, float alpha)
 846    */
 847 PHP_METHOD(CairoGradient, add_color_stop_rgba)
 848 {
 849         zend_class_entry * _this_ce;
 850
 851         zval * _this_zval = NULL;
 852         double offset = 0.0;
 853         double red = 0.0;
 854         double green = 0.0;
 855         double blue = 0.0;
 856         double alpha = 0.0;
 857
 858
 859
 860         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oddddd", &_this_zval, CairoGradient_ce_ptr, &offset, &red, &green, &blue, &alpha) == FAILURE) {
 861                 return;
 862         }
 863
 864         _this_ce = Z_OBJCE_P(_this_zval);
 865
 866
 867         php_error(E_WARNING, "add_color_stop_rgba: not yet implemented"); RETURN_FALSE;
 868
 869 }
 870 /* }}} add_color_stop_rgba */
 871
 872
 873 static zend_function_entry CairoGradient_methods[] = {
 874         PHP_ME(CairoGradient, __contruct, NULL, /**/ZEND_ACC_PUBLIC)
 875         PHP_ME(CairoGradient, add_color_stop_rgb, CairoGradient__add_color_stop_rgb_args, /**/ZEND_ACC_PUBLIC)
 876         PHP_ME(CairoGradient, add_color_stop_rgba, CairoGradient__add_color_stop_rgba_args, /**/ZEND_ACC_PUBLIC)
 877         { NULL, NULL, NULL }
 878 };
 879
 880 /* }}} Methods */
 881
 882 static void class_init_CairoGradient(void)
 883 {
 884         zend_class_entry ce;
 885
 886         INIT_CLASS_ENTRY(ce, "CairoGradient", CairoGradient_methods);
 887         CairoGradient_ce_ptr = zend_register_internal_class_ex(&ce, NULL, "CairoPattern" TSRMLS_CC);
 888 }
 889
 890 /* }}} Class CairoGradient */
 891
 892 /* {{{ Class CairoLinearGradient */
 893
 894 static zend_class_entry * CairoLinearGradient_ce_ptr = NULL;
 895
 896 /* {{{ Methods */
 897
 898
 899 /* {{{ proto void construct(float x0, float y0, float x1, float y1)
 900    */
 901 PHP_METHOD(CairoLinearGradient, __construct)
 902 {
 903         zend_class_entry * _this_ce;
 904         zval * _this_zval;
 905
 906         double x0 = 0.0;
 907         double y0 = 0.0;
 908         double x1 = 0.0;
 909         double y1 = 0.0;
 910
 911
 912
 913         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "dddd", &x0, &y0, &x1, &y1) == FAILURE) {
 914                 return;
 915         }
 916
 917         _this_zval = getThis();
 918         _this_ce = Z_OBJCE_P(_this_zval);
 919
 920
 921         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
 922
 923 }
 924 /* }}} __construct */
 925
 926
 927
 928 /* {{{ proto array get_linear_points()
 929    */
 930 PHP_METHOD(CairoLinearGradient, get_linear_points)
 931 {
 932         zend_class_entry * _this_ce;
 933
 934         zval * _this_zval = NULL;
 935
 936
 937
 938         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoLinearGradient_ce_ptr) == FAILURE) {
 939                 return;
 940         }
 941
 942         _this_ce = Z_OBJCE_P(_this_zval);
 943
 944
 945         array_init(return_value);
 946
 947         php_error(E_WARNING, "get_linear_points: not yet implemented"); RETURN_FALSE;
 948
 949         array_init(return_value);
 950 }
 951 /* }}} get_linear_points */
 952
 953
 954 static zend_function_entry CairoLinearGradient_methods[] = {
 955         PHP_ME(CairoLinearGradient, __construct, CairoLinearGradient____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
 956         PHP_ME(CairoLinearGradient, get_linear_points, NULL, /**/ZEND_ACC_PUBLIC)
 957         { NULL, NULL, NULL }
 958 };
 959
 960 /* }}} Methods */
 961
 962 static void class_init_CairoLinearGradient(void)
 963 {
 964         zend_class_entry ce;
 965
 966         INIT_CLASS_ENTRY(ce, "CairoLinearGradient", CairoLinearGradient_methods);
 967         CairoLinearGradient_ce_ptr = zend_register_internal_class_ex(&ce, NULL, "CairoGradient" TSRMLS_CC);
 968 }
 969
 970 /* }}} Class CairoLinearGradient */
 971
 972 /* {{{ Class CairoRadialGradient */
 973
 974 static zend_class_entry * CairoRadialGradient_ce_ptr = NULL;
 975
 976 /* {{{ Methods */
 977
 978
 979 /* {{{ proto void construct(float cx0, float cy0, float radius0, float cx1, float cy1, float radius1)
 980    */
 981 PHP_METHOD(CairoRadialGradient, __constuct)
 982 {
 983         zend_class_entry * _this_ce;
 984
 985         zval * _this_zval = NULL;
 986         double cx0 = 0.0;
 987         double cy0 = 0.0;
 988         double radius0 = 0.0;
 989         double cx1 = 0.0;
 990         double cy1 = 0.0;
 991         double radius1 = 0.0;
 992
 993
 994
 995         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Odddddd", &_this_zval, CairoRadialGradient_ce_ptr, &cx0, &cy0, &radius0, &cx1, &cy1, &radius1) == FAILURE) {
 996                 return;
 997         }
 998
 999         _this_ce = Z_OBJCE_P(_this_zval);
1000
1001
1002         php_error(E_WARNING, "__constuct: not yet implemented"); RETURN_FALSE;
1003
1004 }
1005 /* }}} __constuct */
1006
1007
1008
1009 /* {{{ proto array get_radial_circles()
1010    */
1011 PHP_METHOD(CairoRadialGradient, get_radial_circles)
1012 {
1013         zend_class_entry * _this_ce;
1014
1015         zval * _this_zval = NULL;
1016
1017
1018
1019         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoRadialGradient_ce_ptr) == FAILURE) {
1020                 return;
1021         }
1022
1023         _this_ce = Z_OBJCE_P(_this_zval);
1024
1025
1026         array_init(return_value);
1027
1028         php_error(E_WARNING, "get_radial_circles: not yet implemented"); RETURN_FALSE;
1029
1030         array_init(return_value);
1031 }
1032 /* }}} get_radial_circles */
1033
1034
1035 static zend_function_entry CairoRadialGradient_methods[] = {
1036         PHP_ME(CairoRadialGradient, __constuct, CairoRadialGradient____constuct_args, /**/ZEND_ACC_PUBLIC)
1037         PHP_ME(CairoRadialGradient, get_radial_circles, NULL, /**/ZEND_ACC_PUBLIC)
1038         { NULL, NULL, NULL }
1039 };
1040
1041 /* }}} Methods */
1042
1043 static void class_init_CairoRadialGradient(void)
1044 {
1045         zend_class_entry ce;
1046
1047         INIT_CLASS_ENTRY(ce, "CairoRadialGradient", CairoRadialGradient_methods);
1048         CairoRadialGradient_ce_ptr = zend_register_internal_class_ex(&ce, NULL, "CairoGradient" TSRMLS_CC);
1049 }
1050
1051 /* }}} Class CairoRadialGradient */
1052
1053 /* {{{ Class CairoSolidPattern */
1054
1055 static zend_class_entry * CairoSolidPattern_ce_ptr = NULL;
1056
1057 /* {{{ Methods */
1058
1059
1060 /* {{{ proto void construct(float r, float g, float b [, float a])
1061    */
1062 PHP_METHOD(CairoSolidPattern, __construct)
1063 {
1064         zend_class_entry * _this_ce;
1065         zval * _this_zval;
1066
1067         double r = 0.0;
1068         double g = 0.0;
1069         double b = 0.0;
1070         double a = 0.0;
1071
1072
1073
1074         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ddd|d", &r, &g, &b, &a) == FAILURE) {
1075                 return;
1076         }
1077
1078         _this_zval = getThis();
1079         _this_ce = Z_OBJCE_P(_this_zval);
1080
1081
1082         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
1083
1084 }
1085 /* }}} __construct */
1086
1087
1088
1089 /* {{{ proto array get_rgba()
1090    */
1091 PHP_METHOD(CairoSolidPattern, get_rgba)
1092 {
1093         zend_class_entry * _this_ce;
1094
1095         zval * _this_zval = NULL;
1096
1097
1098
1099         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoSolidPattern_ce_ptr) == FAILURE) {
1100                 return;
1101         }
1102
1103         _this_ce = Z_OBJCE_P(_this_zval);
1104
1105
1106         array_init(return_value);
1107
1108         php_error(E_WARNING, "get_rgba: not yet implemented"); RETURN_FALSE;
1109
1110         array_init(return_value);
1111 }
1112 /* }}} get_rgba */
1113
1114
1115 static zend_function_entry CairoSolidPattern_methods[] = {
1116         PHP_ME(CairoSolidPattern, __construct, CairoSolidPattern____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
1117         PHP_ME(CairoSolidPattern, get_rgba, NULL, /**/ZEND_ACC_PUBLIC)
1118         { NULL, NULL, NULL }
1119 };
1120
1121 /* }}} Methods */
1122
1123 static void class_init_CairoSolidPattern(void)
1124 {
1125         zend_class_entry ce;
1126
1127         INIT_CLASS_ENTRY(ce, "CairoSolidPattern", CairoSolidPattern_methods);
1128         CairoSolidPattern_ce_ptr = zend_register_internal_class_ex(&ce, NULL, "CairoPattern" TSRMLS_CC);
1129 }
1130
1131 /* }}} Class CairoSolidPattern */
1132
1133 /* {{{ Class CairoSurfacePattern */
1134
1135 static zend_class_entry * CairoSurfacePattern_ce_ptr = NULL;
1136
1137 /* {{{ Methods */
1138
1139
1140 /* {{{ proto void construct(object s)
1141    */
1142 PHP_METHOD(CairoSurfacePattern, __construct)
1143 {
1144         zend_class_entry * _this_ce;
1145         zval * _this_zval;
1146
1147         zval * s = NULL;
1148
1149
1150
1151         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &s) == FAILURE) {
1152                 return;
1153         }
1154
1155         _this_zval = getThis();
1156         _this_ce = Z_OBJCE_P(_this_zval);
1157
1158
1159         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
1160
1161 }
1162 /* }}} __construct */
1163
1164
1165
1166 /* {{{ proto int get_extend()
1167    */
1168 PHP_METHOD(CairoSurfacePattern, get_extend)
1169 {
1170         zend_class_entry * _this_ce;
1171
1172         zval * _this_zval = NULL;
1173
1174
1175
1176         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoSurfacePattern_ce_ptr) == FAILURE) {
1177                 return;
1178         }
1179
1180         _this_ce = Z_OBJCE_P(_this_zval);
1181
1182
1183         php_error(E_WARNING, "get_extend: not yet implemented"); RETURN_FALSE;
1184
1185         RETURN_LONG(0);
1186 }
1187 /* }}} get_extend */
1188
1189
1190
1191 /* {{{ proto int get_filter()
1192    */
1193 PHP_METHOD(CairoSurfacePattern, get_filter)
1194 {
1195         zend_class_entry * _this_ce;
1196
1197         zval * _this_zval = NULL;
1198
1199
1200
1201         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoSurfacePattern_ce_ptr) == FAILURE) {
1202                 return;
1203         }
1204
1205         _this_ce = Z_OBJCE_P(_this_zval);
1206
1207
1208         php_error(E_WARNING, "get_filter: not yet implemented"); RETURN_FALSE;
1209
1210         RETURN_LONG(0);
1211 }
1212 /* }}} get_filter */
1213
1214
1215
1216 /* {{{ proto object get_surface()
1217    */
1218 PHP_METHOD(CairoSurfacePattern, get_surface)
1219 {
1220         zend_class_entry * _this_ce;
1221
1222         zval * _this_zval = NULL;
1223
1224
1225
1226         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoSurfacePattern_ce_ptr) == FAILURE) {
1227                 return;
1228         }
1229
1230         _this_ce = Z_OBJCE_P(_this_zval);
1231
1232
1233         php_error(E_WARNING, "get_surface: not yet implemented"); RETURN_FALSE;
1234
1235         object_init(return_value);
1236 }
1237 /* }}} get_surface */
1238
1239
1240
1241 /* {{{ proto void set_extend(int extend)
1242    */
1243 PHP_METHOD(CairoSurfacePattern, set_extend)
1244 {
1245         zend_class_entry * _this_ce;
1246
1247         zval * _this_zval = NULL;
1248         long extend = 0;
1249
1250
1251
1252         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &_this_zval, CairoSurfacePattern_ce_ptr, &extend) == FAILURE) {
1253                 return;
1254         }
1255
1256         _this_ce = Z_OBJCE_P(_this_zval);
1257
1258
1259         php_error(E_WARNING, "set_extend: not yet implemented"); RETURN_FALSE;
1260
1261 }
1262 /* }}} set_extend */
1263
1264
1265
1266 /* {{{ proto void set_filter(int filter)
1267    */
1268 PHP_METHOD(CairoSurfacePattern, set_filter)
1269 {
1270         zend_class_entry * _this_ce;
1271
1272         zval * _this_zval = NULL;
1273         long filter = 0;
1274
1275
1276
1277         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &_this_zval, CairoSurfacePattern_ce_ptr, &filter) == FAILURE) {
1278                 return;
1279         }
1280
1281         _this_ce = Z_OBJCE_P(_this_zval);
1282
1283
1284         php_error(E_WARNING, "set_filter: not yet implemented"); RETURN_FALSE;
1285
1286 }
1287 /* }}} set_filter */
1288
1289
1290 static zend_function_entry CairoSurfacePattern_methods[] = {
1291         PHP_ME(CairoSurfacePattern, __construct, NULL, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
1292         PHP_ME(CairoSurfacePattern, get_extend, NULL, /**/ZEND_ACC_PUBLIC)
1293         PHP_ME(CairoSurfacePattern, get_filter, NULL, /**/ZEND_ACC_PUBLIC)
1294         PHP_ME(CairoSurfacePattern, get_surface, NULL, /**/ZEND_ACC_PUBLIC)
1295         PHP_ME(CairoSurfacePattern, set_extend, CairoSurfacePattern__set_extend_args, /**/ZEND_ACC_PUBLIC)
1296         PHP_ME(CairoSurfacePattern, set_filter, CairoSurfacePattern__set_filter_args, /**/ZEND_ACC_PUBLIC)
1297         { NULL, NULL, NULL }
1298 };
1299
1300 /* }}} Methods */
1301
1302 static void class_init_CairoSurfacePattern(void)
1303 {
1304         zend_class_entry ce;
1305
1306         INIT_CLASS_ENTRY(ce, "CairoSurfacePattern", CairoSurfacePattern_methods);
1307         CairoSurfacePattern_ce_ptr = zend_register_internal_class_ex(&ce, NULL, "CairoPattern" TSRMLS_CC);
1308 }
1309
1310 /* }}} Class CairoSurfacePattern */
1311
1312 /* {{{ Class CairoScaledFont */
1313
1314 static zend_class_entry * CairoScaledFont_ce_ptr = NULL;
1315
1316 /* {{{ Methods */
1317
1318
1319 /* {{{ proto void construct(object ff, object mx1, object mx2, object fo)
1320    */
1321 PHP_METHOD(CairoScaledFont, __construct)
1322 {
1323         zend_class_entry * _this_ce;
1324         zval * _this_zval;
1325
1326         zval * ff = NULL;
1327         zval * mx1 = NULL;
1328         zval * mx2 = NULL;
1329         zval * fo = NULL;
1330
1331
1332
1333         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "oooo", &ff, &mx1, &mx2, &fo) == FAILURE) {
1334                 return;
1335         }
1336
1337         _this_zval = getThis();
1338         _this_ce = Z_OBJCE_P(_this_zval);
1339
1340
1341         php_error(E_WARNING, "__construct: not yet implemented"); RETURN_FALSE;
1342
1343 }
1344 /* }}} __construct */
1345
1346
1347
1348 /* {{{ proto array extents()
1349    */
1350 PHP_METHOD(CairoScaledFont, extents)
1351 {
1352         zend_class_entry * _this_ce;
1353
1354         zval * _this_zval = NULL;
1355
1356
1357
1358         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoScaledFont_ce_ptr) == FAILURE) {
1359                 return;
1360         }
1361
1362         _this_ce = Z_OBJCE_P(_this_zval);
1363
1364
1365         array_init(return_value);
1366
1367         php_error(E_WARNING, "extents: not yet implemented"); RETURN_FALSE;
1368
1369         array_init(return_value);
1370 }
1371 /* }}} extents */
1372
1373
1374
1375 /* {{{ proto object get_font_face()
1376    */
1377 PHP_METHOD(CairoScaledFont, get_font_face)
1378 {
1379         zend_class_entry * _this_ce;
1380
1381         zval * _this_zval = NULL;
1382
1383
1384
1385         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoScaledFont_ce_ptr) == FAILURE) {
1386                 return;
1387         }
1388
1389         _this_ce = Z_OBJCE_P(_this_zval);
1390
1391
1392         php_error(E_WARNING, "get_font_face: not yet implemented"); RETURN_FALSE;
1393
1394         object_init(return_value);
1395 }
1396 /* }}} get_font_face */
1397
1398
1399
1400 /* {{{ proto array text_extents(string str)
1401    */
1402 PHP_METHOD(CairoScaledFont, text_extents)
1403 {
1404         zend_class_entry * _this_ce;
1405
1406         zval * _this_zval = NULL;
1407         const char * str = NULL;
1408         int str_len = 0;
1409
1410
1411
1412         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &_this_zval, CairoScaledFont_ce_ptr, &str, &str_len) == FAILURE) {
1413                 return;
1414         }
1415
1416         _this_ce = Z_OBJCE_P(_this_zval);
1417
1418
1419         array_init(return_value);
1420
1421         php_error(E_WARNING, "text_extents: not yet implemented"); RETURN_FALSE;
1422
1423         array_init(return_value);
1424 }
1425 /* }}} text_extents */
1426
1427
1428 static zend_function_entry CairoScaledFont_methods[] = {
1429         PHP_ME(CairoScaledFont, __construct, CairoScaledFont____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
1430         PHP_ME(CairoScaledFont, extents, NULL, /**/ZEND_ACC_PUBLIC)
1431         PHP_ME(CairoScaledFont, get_font_face, NULL, /**/ZEND_ACC_PUBLIC)
1432         PHP_ME(CairoScaledFont, text_extents, CairoScaledFont__text_extents_args, /**/ZEND_ACC_PUBLIC)
1433         { NULL, NULL, NULL }
1434 };
1435
1436 /* }}} Methods */
1437
1438 static void class_init_CairoScaledFont(void)
1439 {
1440         zend_class_entry ce;
1441
1442         INIT_CLASS_ENTRY(ce, "CairoScaledFont", CairoScaledFont_methods);
1443         CairoScaledFont_ce_ptr = zend_register_internal_class(&ce);
1444 }
1445
1446 /* }}} Class CairoScaledFont */
1447
1448
1449 /* {{{ Class CairoException */
1450
1451 static zend_class_entry * CairoException_ce_ptr = NULL;
1452
1453 /* {{{ Methods */
1454
1455 static zend_function_entry CairoException_methods[] = {
1456         { NULL, NULL, NULL }
1457 };
1458
1459 /* }}} Methods */
1460
1461 static void class_init_CairoException(void)
1462 {
1463         zend_class_entry ce;
1464
1465         INIT_CLASS_ENTRY(ce, "CairoException", CairoException_methods);
1466         CairoException_ce_ptr = zend_register_internal_class_ex(&ce, NULL, "Exception" TSRMLS_CC);
1467 }
1468
1469 /* }}} Class CairoException */
1470
1471 /* }}} Class definitions*/
1472
1473 /* {{{ phpCairo_functions[] */
1474 function_entry phpCairo_functions[] = {
1475         PHP_FE(cairo_version       , cairo_version_arg_info)
1476         PHP_FE(cairo_version_string, cairo_version_string_arg_info)
1477         { NULL, NULL, NULL }
1478 };
1479 /* }}} */
1480
1481
1482 /* {{{ phpCairo_module_entry
1483  */
1484 zend_module_entry phpCairo_module_entry = {
1485         STANDARD_MODULE_HEADER,
1486         "phpCairo",
1487         phpCairo_functions,
1488         PHP_MINIT(phpCairo),     /* Replace with NULL if there is nothing to do at php startup   */
1489         PHP_MSHUTDOWN(phpCairo), /* Replace with NULL if there is nothing to do at php shutdown  */
1490         PHP_RINIT(phpCairo),     /* Replace with NULL if there is nothing to do at request start */
1491         PHP_RSHUTDOWN(phpCairo), /* Replace with NULL if there is nothing to do at request end   */
1492         PHP_MINFO(phpCairo),
1493         "0.0.1",
1494         STANDARD_MODULE_PROPERTIES
1495 };
1496 /* }}} */
1497
1498 #ifdef COMPILE_DL_PHPCAIRO
1499 ZEND_GET_MODULE(phpCairo)
1500 #endif
1501
1502
1503 /* {{{ PHP_MINIT_FUNCTION */
1504 PHP_MINIT_FUNCTION(phpCairo)
1505 {
1506         class_init_CairoContext();
1507         class_init_CairoFontFace();
1508         class_init_CairoFontOptions();
1509         class_init_CairoMatrix();
1510         class_init_CairoPath();
1511         class_init_CairoPattern();
1512         class_init_CairoGradient();
1513         class_init_CairoLinearGradient();
1514         class_init_CairoRadialGradient();
1515         class_init_CairoSolidPattern();
1516         class_init_CairoSurfacePattern();
1517         class_init_CairoScaledFont();
1518         class_init_CairoSurface();
1519         class_init_CairoImageSurface();
1520         class_init_CairoPDFSurface();
1521         class_init_CairoPSSurface();
1522         class_init_CairoQuartzSurface();
1523         class_init_CairoSVGSurface();
1524         class_init_CairoWin32Surface();
1525         class_init_CairoXlibSurface();
1526         class_init_CairoException();
1527
1528         /* add your stuff here */
1529
1530         return SUCCESS;
1531 }
1532 /* }}} */
1533
1534
1535 /* {{{ PHP_MSHUTDOWN_FUNCTION */
1536 PHP_MSHUTDOWN_FUNCTION(phpCairo)
1537 {
1538
1539         /* add your stuff here */
1540
1541         return SUCCESS;
1542 }
1543 /* }}} */
1544
1545
1546 /* {{{ PHP_RINIT_FUNCTION */
1547 PHP_RINIT_FUNCTION(phpCairo)
1548 {
1549         /* add your stuff here */
1550
1551         return SUCCESS;
1552 }
1553 /* }}} */
1554
1555
1556 /* {{{ PHP_RSHUTDOWN_FUNCTION */
1557 PHP_RSHUTDOWN_FUNCTION(phpCairo)
1558 {
1559         /* add your stuff here */
1560
1561         return SUCCESS;
1562 }
1563 /* }}} */
1564
1565
1566 /* {{{ PHP_MINFO_FUNCTION */
1567 PHP_MINFO_FUNCTION(phpCairo)
1568 {
1569         php_info_print_box_start(0);
1570         php_printf("<p>PHP bindings for Cairo Graphic Library</p>\n");
1571         php_printf("<p>Version 0.0.1devel (2008-05-22)</p>\n");
1572         php_printf("<p><b>Authors:</b></p>\n");
1573         php_printf("<p>Akshat Gupta &lt;g.akshat@gmail.com&gt; (lead)</p>\n");
1574         php_info_print_box_end();
1575         /* add your stuff here */
1576
1577 }
1578 /* }}} */
1579
1580
1581 /* {{{ proto int cairo_version()
1582    */
1583 PHP_FUNCTION(cairo_version)
1584 {
1585
1586
1587
1588         if (ZEND_NUM_ARGS()>0)  {
1589                 WRONG_PARAM_COUNT;
1590         }
1591
1592
1593         php_error(E_WARNING, "cairo_version: not yet implemented"); RETURN_FALSE;
1594
1595         RETURN_LONG(0);
1596 }
1597 /* }}} cairo_version */
1598
1599
1600 /* {{{ proto string cairo_version_string()
1601    */
1602 PHP_FUNCTION(cairo_version_string)
1603 {
1604
1605
1606
1607         if (ZEND_NUM_ARGS()>0)  {
1608                 WRONG_PARAM_COUNT;
1609         }
1610
1611
1612         php_error(E_WARNING, "cairo_version_string: not yet implemented"); RETURN_FALSE;
1613
1614         RETURN_STRINGL("", 0, 1);
1615 }
1616 /* }}} cairo_version_string */
1617
1618 #endif /* HAVE_PHPCAIRO */
1619
1620
1621 /*
1622  * Local variables:
1623  * tab-width: 4
1624  * c-basic-offset: 4
1625  * End:
1626  * vim600: noet sw=4 ts=4 fdm=marker
1627  * vim<600: noet sw=4 ts=4
1628  */