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