src/cairo/CairoFont.c

   1 #include "php_cairo_api.h"
   2 #include "CairoFont.h"
   3 #include "CairoExceptionMacro.h"
   4 #include "php_cairo_ce_ptr.h"
   5
   6 /* {{{ Class CairoFontFace */
   7
   8 //static zend_class_entry * CairoFontFace_ce_ptr = NULL;
   9
  10 /* {{{ Methods */
  11
  12
  13 /* {{{ proto void construct()
  14    */
  15 PHP_METHOD(CairoFontFace, __construct)
  16 {
  17         zval * _this_zval;
  18
  19
  20
  21         if (ZEND_NUM_ARGS()>0)  {
  22                 WRONG_PARAM_COUNT;
  23         }
  24
  25
  26         php_error(E_WARNING,"Please use Context.get_font_face()");
  27 }
  28 /* }}} __construct */
  29
  30
  31
  32
  33
  34 static zend_function_entry CairoFontFace_methods[] = {
  35         PHP_ME(CairoFontFace, __construct, NULL, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
  36         { NULL, NULL, NULL }
  37 };
  38
  39 /* }}} Methods */
  40
  41
  42 static zend_object_handlers CairoFontFace_handlers;
  43
  44 static void CairoFontFace_object_dtor(void *object)
  45 {
  46         fontface_object *fontface = (fontface_object *)object;
  47         zend_hash_destroy(fontface->std.properties);
  48         FREE_HASHTABLE(fontface->std.properties);
  49
  50         if(fontface->fontface){
  51                 cairo_font_face_destroy(fontface->fontface);
  52         }
  53         efree(object);
  54 }
  55
  56 static zend_object_value CairoFontFace_object_new(zend_class_entry *ce)
  57 {
  58         zend_object_value retval;
  59         fontface_object *fontface;
  60         zval *temp;
  61         fontface = emalloc(sizeof(fontface_object));
  62         memset(fontface,0,sizeof(fontface_object));
  63         fontface->std.ce = ce;
  64         ALLOC_HASHTABLE(fontface->std.properties);
  65         zend_hash_init(fontface->std.properties, 0, NULL, ZVAL_PTR_DTOR,0);
  66         zend_hash_copy(fontface->std.properties, &ce->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &temp, sizeof(zval *));
  67         retval.handle = zend_objects_store_put(fontface, NULL, (zend_objects_free_object_storage_t)CairoFontFace_object_dtor, NULL TSRMLS_CC);
  68         retval.handlers = &CairoFontFace_handlers;
  69         return retval;
  70 }
  71
  72
  73 void class_init_CairoFontFace(void)
  74 {
  75         zend_class_entry ce;
  76
  77         INIT_CLASS_ENTRY(ce, "CairoFontFace", CairoFontFace_methods);
  78         CairoFontFace_ce_ptr = zend_register_internal_class(&ce);
  79         CairoFontFace_ce_ptr->create_object = CairoFontFace_object_new;
  80         memcpy(&CairoFontFace_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
  81         CairoFontFace_handlers.clone_obj = NULL;
  82 }
  83
  84 /* }}} Class CairoFontFace */
  85
  86
  87 /* {{{ Class CairoFontOptions */
  88
  89 //istatic zend_class_entry * CairoFontOptions_ce_ptr = NULL;
  90
  91 /* {{{ Methods */
  92
  93
  94 /* {{{ proto void construct()
  95    */
  96 PHP_METHOD(CairoFontOptions, __construct)
  97 {
  98         zval * _this_zval;
  99
 100
 101
 102         if (ZEND_NUM_ARGS()>0)  {
 103                 WRONG_PARAM_COUNT;
 104         }
 105         _this_zval = getThis();
 106         fontoptions_object *curr = (fontoptions_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 107         curr->fontoptions = cairo_font_options_create();
 108
 109 }
 110 /* }}} __construct */
 111
 112
 113
 114 /* {{{ proto int getAntialias()
 115    */
 116 PHP_METHOD(CairoFontOptions, getAntialias)
 117 {
 118
 119         zval * _this_zval = NULL;
 120
 121
 122         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoFontOptions_ce_ptr) == FAILURE) {
 123                 return;
 124         }
 125
 126         fontoptions_object *curr = (fontoptions_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 127         RETURN_LONG(cairo_font_options_get_antialias(curr->fontoptions));
 128
 129 }
 130 /* }}} getAntialias */
 131
 132
 133
 134 /* {{{ proto int getHintMetrics()
 135    */
 136 PHP_METHOD(CairoFontOptions, getHintMetrics)
 137 {
 138
 139         zval * _this_zval = NULL;
 140
 141
 142         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoFontOptions_ce_ptr) == FAILURE) {
 143                 return;
 144         }
 145
 146
 147         fontoptions_object *curr = (fontoptions_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 148
 149         RETURN_LONG(cairo_font_options_get_hint_metrics(curr->fontoptions));
 150 }
 151 /* }}} getHintMetrics */
 152
 153
 154
 155 /* {{{ proto int getHintStyle()
 156    */
 157 PHP_METHOD(CairoFontOptions, getHintStyle)
 158 {
 159
 160         zval * _this_zval = NULL;
 161
 162
 163         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoFontOptions_ce_ptr) == FAILURE) {
 164                 return;
 165         }
 166
 167         fontoptions_object *curr = (fontoptions_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 168
 169         RETURN_LONG(cairo_font_options_get_hint_style(curr->fontoptions));
 170 }
 171 /* }}} getHintStyle */
 172
 173
 174
 175 /* {{{ proto int getSubpixelOrder()
 176    */
 177 PHP_METHOD(CairoFontOptions, getSubpixelOrder)
 178 {
 179
 180         zval * _this_zval = NULL;
 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         fontoptions_object *curr = (fontoptions_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 188
 189         RETURN_LONG(cairo_font_options_get_subpixel_order(curr->fontoptions));
 190 }
 191 /* }}} getSubpixelOrder */
 192
 193
 194
 195 /* {{{ proto void setAntialias([int aa])
 196    */
 197 PHP_METHOD(CairoFontOptions, setAntialias)
 198 {
 199
 200         zval * _this_zval = NULL;
 201         cairo_antialias_t aa = CAIRO_ANTIALIAS_DEFAULT;
 202
 203
 204
 205         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|l", &_this_zval, CairoFontOptions_ce_ptr, &aa) == FAILURE) {
 206                 return;
 207         }
 208
 209         fontoptions_object *curr = (fontoptions_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 210         cairo_font_options_set_antialias(curr->fontoptions, aa);
 211         PHP_CAIRO_FONTOPTIONS_ERROR(curr->fontoptions);
 212
 213 }
 214 /* }}} setAntialias */
 215
 216
 217
 218 /* {{{ proto void setHintMetrics([int hm])
 219    */
 220 PHP_METHOD(CairoFontOptions, setHintMetrics)
 221 {
 222
 223         zval * _this_zval = NULL;
 224         cairo_hint_metrics_t hm = CAIRO_HINT_METRICS_DEFAULT;
 225
 226
 227
 228         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|l", &_this_zval, CairoFontOptions_ce_ptr, &hm) == FAILURE) {
 229                 return;
 230         }
 231
 232
 233         fontoptions_object *curr = (fontoptions_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 234         cairo_font_options_set_hint_metrics(curr->fontoptions, hm);
 235         PHP_CAIRO_FONTOPTIONS_ERROR(curr->fontoptions);
 236
 237 }
 238 /* }}} setHintMetrics */
 239
 240
 241
 242 /* {{{ proto void setHintStyle([int hs])
 243    */
 244 PHP_METHOD(CairoFontOptions, setHintStyle)
 245 {
 246
 247         zval * _this_zval = NULL;
 248         cairo_hint_style_t hs = CAIRO_HINT_STYLE_DEFAULT;
 249
 250
 251
 252         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|l", &_this_zval, CairoFontOptions_ce_ptr, &hs) == FAILURE) {
 253                 return;
 254         }
 255
 256         fontoptions_object *curr = (fontoptions_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 257         cairo_font_options_set_hint_style(curr->fontoptions, hs);
 258         PHP_CAIRO_FONTOPTIONS_ERROR(curr->fontoptions);
 259
 260 }
 261 /* }}} setHintStyle */
 262
 263
 264
 265 /* {{{ proto void setSubpixelOrder([int so])
 266    */
 267 PHP_METHOD(CairoFontOptions, setSubpixelOrder)
 268 {
 269
 270         zval * _this_zval = NULL;
 271         cairo_subpixel_order_t so = CAIRO_SUBPIXEL_ORDER_DEFAULT;
 272
 273
 274
 275         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|l", &_this_zval, CairoFontOptions_ce_ptr, &so) == FAILURE) {
 276                 return;
 277         }
 278
 279         fontoptions_object *curr = (fontoptions_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 280         cairo_font_options_set_subpixel_order(curr->fontoptions, so);
 281         PHP_CAIRO_FONTOPTIONS_ERROR(curr->fontoptions);
 282
 283 }
 284 /* }}} setSubpixelOrder */
 285
 286
 287 static zend_function_entry CairoFontOptions_methods[] = {
 288         PHP_ME(CairoFontOptions, __construct, NULL, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
 289         PHP_ME(CairoFontOptions, getAntialias, NULL, /**/ZEND_ACC_PUBLIC)
 290         PHP_ME(CairoFontOptions, getHintMetrics, NULL, /**/ZEND_ACC_PUBLIC)
 291         PHP_ME(CairoFontOptions, getHintStyle, NULL, /**/ZEND_ACC_PUBLIC)
 292         PHP_ME(CairoFontOptions, getSubpixelOrder, NULL, /**/ZEND_ACC_PUBLIC)
 293         PHP_ME(CairoFontOptions, setAntialias, CairoFontOptions__set_antialias_args, /**/ZEND_ACC_PUBLIC)
 294         PHP_ME(CairoFontOptions, setHintMetrics, CairoFontOptions__set_hint_metrics_args, /**/ZEND_ACC_PUBLIC)
 295         PHP_ME(CairoFontOptions, setHintStyle, CairoFontOptions__set_hint_style_args, /**/ZEND_ACC_PUBLIC)
 296         PHP_ME(CairoFontOptions, setSubpixelOrder, CairoFontOptions__set_subpixel_order_args, /**/ZEND_ACC_PUBLIC)
 297         { NULL, NULL, NULL }
 298 };
 299
 300 /* }}} Methods */
 301
 302
 303 static zend_object_handlers CairoFontOptions_handlers;
 304
 305 static void CairoFontOptions_object_dtor(void *object)
 306 {
 307         fontoptions_object *fontoptions = (fontoptions_object *)object;
 308         zend_hash_destroy(fontoptions->std.properties);
 309         FREE_HASHTABLE(fontoptions->std.properties);
 310
 311         if(fontoptions->fontoptions){
 312                 cairo_font_options_destroy(fontoptions->fontoptions);
 313         }
 314         efree(object);
 315 }
 316
 317 static zend_object_value CairoFontOptions_object_new(zend_class_entry *ce)
 318 {
 319         zend_object_value retval;
 320         fontoptions_object *fontoptions;
 321         zval *temp;
 322         fontoptions = emalloc(sizeof(fontoptions_object));
 323         memset(fontoptions,0,sizeof(fontoptions_object));
 324         fontoptions->std.ce = ce;
 325         ALLOC_HASHTABLE(fontoptions->std.properties);
 326         zend_hash_init(fontoptions->std.properties, 0, NULL, ZVAL_PTR_DTOR,0);
 327         zend_hash_copy(fontoptions->std.properties, &ce->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &temp, sizeof(zval *));
 328         retval.handle = zend_objects_store_put(fontoptions, NULL, (zend_objects_free_object_storage_t)CairoFontOptions_object_dtor, NULL TSRMLS_CC);
 329         retval.handlers = &CairoFontOptions_handlers;
 330         return retval;
 331 }
 332
 333
 334 void class_init_CairoFontOptions(void)
 335 {
 336         zend_class_entry ce;
 337
 338         INIT_CLASS_ENTRY(ce, "CairoFontOptions", CairoFontOptions_methods);
 339         CairoFontOptions_ce_ptr = zend_register_internal_class(&ce);
 340         CairoFontOptions_ce_ptr->create_object = CairoFontOptions_object_new;
 341         memcpy(&CairoFontOptions_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 342         CairoFontOptions_handlers.clone_obj = NULL;
 343 }
 344
 345 /* }}} Class CairoFontOptions */
 346
 347
 348 /* {{{ Class CairoScaledFont */
 349
 350 //static zend_class_entry * CairoScaledFont_ce_ptr = NULL;
 351
 352 /* {{{ Methods */
 353
 354
 355 /* {{{ proto void construct(object ff, object mx1, object mx2, object fo)
 356    */
 357 PHP_METHOD(CairoScaledFont, __construct)
 358 {
 359         zval * _this_zval;
 360
 361         zval * ff = NULL;
 362         zval * mx1 = NULL;
 363         zval * mx2 = NULL;
 364         zval * fo = NULL;
 365
 366
 367
 368         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "oooo", &ff, &mx1, &mx2, &fo) == FAILURE) {
 369                 return;
 370         }
 371
 372         _this_zval = getThis();
 373         scaledfont_object *curr = (scaledfont_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 374         fontface_object *ffobj = (fontface_object *)zend_objects_get_address(ff TSRMLS_CC);
 375         matrix_object *mobj1 = (matrix_object *)zend_objects_get_address(mx1 TSRMLS_CC);
 376         matrix_object *mobj2 = (matrix_object *)zend_objects_get_address(mx2 TSRMLS_CC);
 377         fontoptions_object *foobj = (fontoptions_object *)zend_objects_get_address(fo TSRMLS_CC);
 378         curr->scaledfont = cairo_scaled_font_create(ffobj->fontface, &mobj1->matrix, &mobj2->matrix, foobj->fontoptions);
 379
 380 }
 381 /* }}} __construct */
 382
 383
 384
 385 /* {{{ proto array extents()
 386    */
 387 PHP_METHOD(CairoScaledFont, extents)
 388 {
 389
 390         zval * _this_zval = NULL;
 391
 392         cairo_font_extents_t e;
 393
 394         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoScaledFont_ce_ptr) == FAILURE) {
 395                 return;
 396         }
 397
 398         scaledfont_object *curr = (scaledfont_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 399         cairo_scaled_font_extents(curr->scaledfont, &e);
 400
 401         PHP_CAIRO_SCALEDFONT_ERROR(curr->scaledfont);
 402         array_init(return_value);
 403         add_assoc_double(return_value, "ascent", e.ascent);
 404         add_assoc_double(return_value, "descent", e.descent);
 405         add_assoc_double(return_value, "height", e.height);
 406         add_assoc_double(return_value, "max_x_advance", e.max_x_advance);
 407         add_assoc_double(return_value, "max_y_advance", e.max_y_advance);
 408
 409 }
 410 /* }}} extents */
 411
 412
 413
 414 /* {{{ proto object getFontFace()
 415    */
 416 PHP_METHOD(CairoScaledFont, getFontFace)
 417 {
 418
 419         zval * _this_zval = NULL;
 420
 421
 422
 423         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &_this_zval, CairoScaledFont_ce_ptr) == FAILURE) {
 424                 return;
 425         }
 426
 427         scaledfont_object *curr = (scaledfont_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 428
 429         object_init_ex(return_value, CairoFontFace_ce_ptr);
 430         fontface_object *ffobj = (fontface_object *)zend_objects_get_address(return_value);
 431         ffobj->fontface = cairo_font_face_reference(cairo_scaled_font_get_font_face(curr->scaledfont));
 432
 433 }
 434 /* }}} getFontFace */
 435
 436
 437
 438 /* {{{ proto array textExtents(string str)
 439    */
 440 PHP_METHOD(CairoScaledFont, textExtents)
 441 {
 442
 443         zval * _this_zval = NULL;
 444         const char * str = NULL;
 445         int str_len = 0;
 446         cairo_text_extents_t extents;
 447
 448
 449
 450         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &_this_zval, CairoScaledFont_ce_ptr, &str, &str_len) == FAILURE) {
 451                 return;
 452         }
 453
 454         scaledfont_object *curr = (scaledfont_object *)zend_objects_get_address(_this_zval TSRMLS_CC);
 455
 456         cairo_scaled_font_text_extents(curr->scaledfont, str, &extents);
 457         PHP_CAIRO_SCALEDFONT_ERROR(curr->scaledfont);
 458
 459         array_init(return_value);
 460         add_assoc_double(return_value, "x_bearing", extents.x_bearing);
 461         add_assoc_double(return_value, "y_bearing", extents.y_bearing);
 462         add_assoc_double(return_value, "width", extents.width);
 463         add_assoc_double(return_value, "height", extents.height);
 464         add_assoc_double(return_value, "x_advance", extents.x_advance);
 465         add_assoc_double(return_value, "y_advance", extents.y_advance);
 466
 467 }
 468 /* }}} textExtents */
 469
 470
 471 static zend_function_entry CairoScaledFont_methods[] = {
 472         PHP_ME(CairoScaledFont, __construct, CairoScaledFont____construct_args, /**/ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
 473         PHP_ME(CairoScaledFont, extents, NULL, /**/ZEND_ACC_PUBLIC)
 474         PHP_ME(CairoScaledFont, getFontFace, NULL, /**/ZEND_ACC_PUBLIC)
 475         PHP_ME(CairoScaledFont, textExtents, CairoScaledFont__text_extents_args, /**/ZEND_ACC_PUBLIC)
 476         { NULL, NULL, NULL }
 477 };
 478
 479 /* }}} Methods */
 480
 481
 482 static zend_object_handlers CairoScaledFont_handlers;
 483
 484 static void CairoScaledFont_object_dtor(void *object)
 485 {
 486         scaledfont_object *scaledfont = (scaledfont_object *)object;
 487         zend_hash_destroy(scaledfont->std.properties);
 488         FREE_HASHTABLE(scaledfont->std.properties);
 489
 490         if(scaledfont->scaledfont){
 491                 cairo_scaled_font_destroy(scaledfont->scaledfont);
 492         }
 493         efree(object);
 494 }
 495
 496 static zend_object_value CairoScaledFont_object_new(zend_class_entry *ce)
 497 {
 498         zend_object_value retval;
 499         scaledfont_object *scaledfont;
 500         zval *temp;
 501         scaledfont = emalloc(sizeof(scaledfont_object));
 502         memset(scaledfont,0,sizeof(scaledfont_object));
 503         scaledfont->std.ce = ce;
 504         ALLOC_HASHTABLE(scaledfont->std.properties);
 505         zend_hash_init(scaledfont->std.properties, 0, NULL, ZVAL_PTR_DTOR,0);
 506         zend_hash_copy(scaledfont->std.properties, &ce->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &temp, sizeof(zval *));
 507         retval.handle = zend_objects_store_put(scaledfont, NULL, (zend_objects_free_object_storage_t)CairoScaledFont_object_dtor, NULL TSRMLS_CC);
 508         retval.handlers = &CairoScaledFont_handlers;
 509         return retval;
 510 }
 511
 512
 513 void class_init_CairoScaledFont(void)
 514 {
 515         zend_class_entry ce;
 516
 517         INIT_CLASS_ENTRY(ce, "CairoScaledFont", CairoScaledFont_methods);
 518         CairoScaledFont_ce_ptr = zend_register_internal_class(&ce);
 519         CairoScaledFont_ce_ptr->create_object = CairoScaledFont_object_new;
 520         memcpy(&CairoScaledFont_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 521         CairoScaledFont_handlers.clone_obj = NULL;
 522 }
 523
 524 /* }}} Class CairoScaledFont */