00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #include "cr-fonts.h"
00027 #include <string.h>
00028
00029 static enum CRStatus
00030 cr_font_family_to_string_real (CRFontFamily * a_this,
00031 gboolean a_walk_list, GString ** a_string)
00032 {
00033 guchar *name = NULL;
00034 enum CRStatus result = CR_OK;
00035
00036 if (!*a_string) {
00037 *a_string = g_string_new (NULL);
00038 g_return_val_if_fail (*a_string,
00039 CR_INSTANCIATION_FAILED_ERROR);
00040 }
00041
00042 if (!a_this) {
00043 g_string_append (*a_string, "NULL");
00044 return CR_OK;
00045 }
00046
00047 switch (a_this->type) {
00048 case FONT_FAMILY_SANS_SERIF:
00049 name = (guchar *) "sans-serif";
00050 break;
00051
00052 case FONT_FAMILY_SERIF:
00053 name = (guchar *) "sans-serif";
00054 break;
00055
00056 case FONT_FAMILY_CURSIVE:
00057 name = (guchar *) "cursive";
00058 break;
00059
00060 case FONT_FAMILY_FANTASY:
00061 name = (guchar *) "fantasy";
00062 break;
00063
00064 case FONT_FAMILY_MONOSPACE:
00065 name = (guchar *) "monospace";
00066 break;
00067
00068 case FONT_FAMILY_NON_GENERIC:
00069 name = (guchar *) a_this->name;
00070 break;
00071
00072 default:
00073 name = (guchar *) NULL;
00074 break;
00075 }
00076
00077 if (name) {
00078 if (a_this->prev) {
00079 g_string_append_printf (*a_string, ", %s", name);
00080 } else {
00081 g_string_append (*a_string, name);
00082 }
00083 }
00084 if (a_walk_list == TRUE && a_this->next) {
00085 result = cr_font_family_to_string_real (a_this->next,
00086 TRUE, a_string);
00087 }
00088 return result;
00089 }
00090
00091 static const gchar *
00092 cr_predefined_absolute_font_size_to_string (enum CRPredefinedAbsoluteFontSize
00093 a_code)
00094 {
00095 gchar *str = NULL;
00096
00097 switch (a_code) {
00098 case FONT_SIZE_XX_SMALL:
00099 str = (gchar *) "xx-small";
00100 break;
00101 case FONT_SIZE_X_SMALL:
00102 str = (gchar *) "x-small";
00103 break;
00104 case FONT_SIZE_SMALL:
00105 str = (gchar *) "small";
00106 break;
00107 case FONT_SIZE_MEDIUM:
00108 str = (gchar *) "medium";
00109 break;
00110 case FONT_SIZE_LARGE:
00111 str = (gchar *) "large";
00112 break;
00113 case FONT_SIZE_X_LARGE:
00114 str = (gchar *) "x-large";
00115 break;
00116 case FONT_SIZE_XX_LARGE:
00117 str = (gchar *) "xx-large";
00118 break;
00119 default:
00120 str = (gchar *) "unknown absolute font size value";
00121 }
00122 return str;
00123 }
00124
00125 static const gchar *
00126 cr_relative_font_size_to_string (enum CRRelativeFontSize a_code)
00127 {
00128 gchar *str = NULL;
00129
00130 switch (a_code) {
00131 case FONT_SIZE_LARGER:
00132 str = (gchar *) "larger";
00133 break;
00134 case FONT_SIZE_SMALLER:
00135 str = (gchar *) "smaller";
00136 break;
00137 default:
00138 str = (gchar *) "unknown relative font size value";
00139 break;
00140 }
00141 return str;
00142 }
00143
00144 CRFontFamily *
00145 cr_font_family_new (enum CRFontFamilyType a_type, guchar * a_name)
00146 {
00147 CRFontFamily *result = NULL;
00148
00149 result = g_try_malloc (sizeof (CRFontFamily));
00150
00151 if (!result) {
00152 cr_utils_trace_info ("Out of memory");
00153 return NULL;
00154 }
00155
00156 memset (result, 0, sizeof (CRFontFamily));
00157 result->type = a_type;
00158
00159 cr_font_family_set_name (result, a_name);
00160
00161 return result;
00162 }
00163
00164 guchar *
00165 cr_font_family_to_string (CRFontFamily * a_this,
00166 gboolean a_walk_font_family_list)
00167 {
00168 enum CRStatus status = CR_OK;
00169 guchar *result = NULL;
00170 GString *stringue = NULL;
00171
00172 if (!a_this) {
00173 result = g_strdup ("NULL");
00174 g_return_val_if_fail (result, NULL);
00175 return result;
00176 }
00177 status = cr_font_family_to_string_real (a_this,
00178 a_walk_font_family_list,
00179 &stringue);
00180
00181 if (status == CR_OK && stringue) {
00182 result = stringue->str;
00183 g_string_free (stringue, FALSE);
00184 stringue = NULL;
00185
00186 } else {
00187 if (stringue) {
00188 g_string_free (stringue, TRUE);
00189 stringue = NULL;
00190 }
00191 }
00192
00193 return result;
00194 }
00195 enum CRStatus
00196 cr_font_family_set_name (CRFontFamily * a_this, guchar * a_name)
00197 {
00198 g_return_val_if_fail (a_this, CR_BAD_PARAM_ERROR);
00199
00200
00201
00202
00203
00204 if (a_this->type != FONT_FAMILY_NON_GENERIC) {
00205 return CR_BAD_PARAM_ERROR;
00206 }
00207
00208 if (a_this->name) {
00209 g_free (a_this->name);
00210 a_this->name = NULL;
00211 }
00212
00213 a_this->name = a_name;
00214 return CR_OK;
00215 }
00216
00217 CRFontFamily *
00218 cr_font_family_append (CRFontFamily * a_this,
00219 CRFontFamily * a_family_to_append)
00220 {
00221 CRFontFamily *cur_ff = NULL;
00222
00223 g_return_val_if_fail (a_family_to_append, NULL);
00224
00225 if (!a_this)
00226 return a_family_to_append;
00227
00228 for (cur_ff = a_this; cur_ff && cur_ff->next; cur_ff = cur_ff->next) ;
00229
00230 cur_ff->next = a_family_to_append;
00231 a_family_to_append->prev = cur_ff;
00232
00233 return a_this;
00234
00235 }
00236
00237 CRFontFamily *
00238 cr_font_family_prepend (CRFontFamily * a_this,
00239 CRFontFamily * a_family_to_prepend)
00240 {
00241 g_return_val_if_fail (a_this && a_family_to_prepend, NULL);
00242
00243 if (!a_this)
00244 return a_family_to_prepend;
00245
00246 a_family_to_prepend->next = a_this;
00247 a_this->prev = a_family_to_prepend;
00248
00249 return CR_OK;
00250 }
00251
00252 enum CRStatus
00253 cr_font_family_destroy (CRFontFamily * a_this)
00254 {
00255 CRFontFamily *cur_ff = NULL;
00256
00257 g_return_val_if_fail (a_this, CR_BAD_PARAM_ERROR);
00258
00259 for (cur_ff = a_this; cur_ff && cur_ff->next; cur_ff = cur_ff->next) ;
00260
00261 for (; cur_ff; cur_ff = cur_ff->prev) {
00262 if (a_this->name) {
00263 g_free (a_this->name);
00264 a_this->name = NULL;
00265 }
00266
00267 if (cur_ff->next) {
00268 g_free (cur_ff->next);
00269
00270 }
00271
00272 if (cur_ff->prev == NULL) {
00273 g_free (a_this);
00274 }
00275 }
00276
00277 return CR_OK;
00278 }
00279
00280
00281
00282
00283
00284 CRFontSize *
00285 cr_font_size_new (void)
00286 {
00287 CRFontSize *result = NULL;
00288
00289 result = g_try_malloc (sizeof (CRFontSize));
00290 if (!result) {
00291 cr_utils_trace_info ("Out of memory");
00292 return NULL;
00293 }
00294 memset (result, 0, sizeof (CRFontSize));
00295
00296 return result;
00297 }
00298
00299 enum CRStatus
00300 cr_font_size_clear (CRFontSize * a_this)
00301 {
00302 g_return_val_if_fail (a_this, CR_BAD_PARAM_ERROR);
00303
00304 switch (a_this->type) {
00305 case PREDEFINED_ABSOLUTE_FONT_SIZE:
00306 case RELATIVE_FONT_SIZE:
00307 case INHERITED_FONT_SIZE:
00308 memset (a_this, 0, sizeof (CRFontSize));
00309 break;
00310
00311 case ABSOLUTE_FONT_SIZE:
00312 memset (a_this, 0, sizeof (CRFontSize));
00313 break;
00314
00315 default:
00316 return CR_UNKNOWN_TYPE_ERROR;
00317 }
00318
00319 return CR_OK;
00320 }
00321
00322 enum CRStatus
00323 cr_font_size_copy (CRFontSize * a_dst, CRFontSize * a_src)
00324 {
00325 g_return_val_if_fail (a_dst && a_src, CR_BAD_PARAM_ERROR);
00326
00327 switch (a_src->type) {
00328 case PREDEFINED_ABSOLUTE_FONT_SIZE:
00329 case RELATIVE_FONT_SIZE:
00330 case INHERITED_FONT_SIZE:
00331 cr_font_size_clear (a_dst);
00332 memcpy (a_dst, a_src, sizeof (CRFontSize));
00333 break;
00334
00335 case ABSOLUTE_FONT_SIZE:
00336 cr_font_size_clear (a_dst);
00337 cr_num_copy (&a_dst->value.absolute,
00338 &a_src->value.absolute);
00339 a_dst->type = a_src->type;
00340 break;
00341
00342 default:
00343 return CR_UNKNOWN_TYPE_ERROR;
00344 }
00345 return CR_OK;
00346 }
00347
00348 enum CRStatus
00349 cr_font_size_set_predefined_absolute_font_size (CRFontSize *a_this,
00350 enum CRPredefinedAbsoluteFontSize a_predefined)
00351 {
00352 g_return_val_if_fail (a_this, CR_BAD_PARAM_ERROR) ;
00353 g_return_val_if_fail (a_predefined >= PREDEFINED_ABSOLUTE_FONT_SIZE
00354 && a_predefined < NB_FONT_SIZE_TYPE,
00355 CR_BAD_PARAM_ERROR) ;
00356
00357 a_this->type = PREDEFINED_ABSOLUTE_FONT_SIZE ;
00358 a_this->value.predefined = a_predefined ;
00359
00360 return CR_OK ;
00361 }
00362
00363 enum CRStatus
00364 cr_font_size_set_relative_font_size (CRFontSize *a_this,
00365 enum CRRelativeFontSize a_relative)
00366 {
00367 g_return_val_if_fail (a_this, CR_BAD_PARAM_ERROR) ;
00368 g_return_val_if_fail (a_relative >= FONT_SIZE_LARGER
00369 && a_relative < NB_RELATIVE_FONT_SIZE,
00370 CR_BAD_PARAM_ERROR) ;
00371
00372 a_this->type = RELATIVE_FONT_SIZE ;
00373 a_this->value.relative = a_relative ;
00374 return CR_OK ;
00375 }
00376
00377 enum CRStatus
00378 cr_font_size_set_absolute_font_size (CRFontSize *a_this,
00379 enum CRNumType a_num_type,
00380 gdouble a_value)
00381 {
00382 g_return_val_if_fail (a_this, CR_BAD_PARAM_ERROR) ;
00383 g_return_val_if_fail (a_num_type >= NUM_AUTO
00384 && a_num_type < NB_NUM_TYPE,
00385 CR_BAD_PARAM_ERROR) ;
00386
00387 a_this->type = ABSOLUTE_FONT_SIZE ;
00388 cr_num_set (&a_this->value.absolute,
00389 a_value, a_num_type) ;
00390 return CR_OK ;
00391 }
00392
00393 enum CRStatus
00394 cr_font_size_set_to_inherit (CRFontSize *a_this)
00395 {
00396 g_return_val_if_fail (a_this, CR_BAD_PARAM_ERROR) ;
00397
00398 cr_font_size_clear (a_this) ;
00399 a_this->type = INHERITED_FONT_SIZE ;
00400
00401 return CR_OK ;
00402 }
00403
00404 gboolean
00405 cr_font_size_is_set_to_inherit (CRFontSize *a_this)
00406 {
00407 g_return_val_if_fail (a_this, FALSE) ;
00408
00409 return a_this->type == INHERITED_FONT_SIZE ;
00410 }
00411
00412 gchar *
00413 cr_font_size_to_string (CRFontSize * a_this)
00414 {
00415 gchar *str = NULL;
00416
00417 if (!a_this) {
00418 str = g_strdup ("NULL");
00419 g_return_val_if_fail (str, NULL);
00420 return str;
00421 }
00422 switch (a_this->type) {
00423 case PREDEFINED_ABSOLUTE_FONT_SIZE:
00424 str = g_strdup (cr_predefined_absolute_font_size_to_string
00425 (a_this->value.predefined));
00426 break;
00427 case ABSOLUTE_FONT_SIZE:
00428 str = cr_num_to_string (&a_this->value.absolute);
00429 break;
00430 case RELATIVE_FONT_SIZE:
00431 str = g_strdup (cr_relative_font_size_to_string
00432 (a_this->value.relative));
00433 break;
00434 case INHERITED_FONT_SIZE:
00435 str = g_strdup ("inherit");
00436 break;
00437 default:
00438 break;
00439 }
00440 return str;
00441 }
00442
00443 void
00444 cr_font_size_get_smaller_predefined_font_size (enum CRPredefinedAbsoluteFontSize a_font_size,
00445 enum CRPredefinedAbsoluteFontSize *a_smaller_size)
00446 {
00447 enum CRPredefinedAbsoluteFontSize result = FONT_SIZE_MEDIUM ;
00448
00449 g_return_if_fail (a_smaller_size) ;
00450 g_return_if_fail (a_font_size < NB_PREDEFINED_ABSOLUTE_FONT_SIZES
00451 && a_font_size >= FONT_SIZE_XX_SMALL) ;
00452
00453 switch (a_font_size) {
00454 case FONT_SIZE_XX_SMALL:
00455 result = FONT_SIZE_XX_SMALL ;
00456 break ;
00457 case FONT_SIZE_X_SMALL:
00458 result = FONT_SIZE_XX_SMALL ;
00459 break ;
00460 case FONT_SIZE_SMALL:
00461 result = FONT_SIZE_X_SMALL;
00462 break ;
00463 case FONT_SIZE_MEDIUM:
00464 result = FONT_SIZE_SMALL;
00465 break ;
00466 case FONT_SIZE_LARGE:
00467 result = FONT_SIZE_MEDIUM;
00468 break ;
00469 case FONT_SIZE_X_LARGE:
00470 result = FONT_SIZE_LARGE;
00471 break ;
00472 case FONT_SIZE_XX_LARGE:
00473 result = FONT_SIZE_XX_LARGE;
00474 break ;
00475 case FONT_SIZE_INHERIT:
00476 cr_utils_trace_info ("can't return a smaller size for FONT_SIZE_INHERIT") ;
00477 result = FONT_SIZE_MEDIUM ;
00478 break ;
00479 default:
00480 cr_utils_trace_info ("Unknown FONT_SIZE") ;
00481 result = FONT_SIZE_MEDIUM ;
00482 break ;
00483 }
00484 *a_smaller_size = result ;
00485 }
00486
00487
00488 void
00489 cr_font_size_get_larger_predefined_font_size (enum CRPredefinedAbsoluteFontSize a_font_size,
00490 enum CRPredefinedAbsoluteFontSize *a_larger_size)
00491 {
00492 enum CRPredefinedAbsoluteFontSize result = FONT_SIZE_MEDIUM ;
00493
00494 g_return_if_fail (a_larger_size) ;
00495 g_return_if_fail (a_font_size >= FONT_SIZE_XX_SMALL
00496 && a_font_size < NB_PREDEFINED_ABSOLUTE_FONT_SIZES) ;
00497
00498 switch (a_font_size) {
00499 case FONT_SIZE_XX_SMALL:
00500 result = FONT_SIZE_X_SMALL ;
00501 break ;
00502 case FONT_SIZE_X_SMALL:
00503 result = FONT_SIZE_SMALL ;
00504 break ;
00505 case FONT_SIZE_SMALL:
00506 result = FONT_SIZE_MEDIUM;
00507 break ;
00508 case FONT_SIZE_MEDIUM:
00509 result = FONT_SIZE_LARGE;
00510 break ;
00511 case FONT_SIZE_LARGE:
00512 result = FONT_SIZE_X_LARGE;
00513 break ;
00514 case FONT_SIZE_X_LARGE:
00515 result = FONT_SIZE_XX_LARGE ;
00516 break ;
00517 case FONT_SIZE_XX_LARGE:
00518 result = FONT_SIZE_XX_LARGE;
00519 break ;
00520 case FONT_SIZE_INHERIT:
00521 cr_utils_trace_info ("can't return a bigger size for FONT_SIZE_INHERIT") ;
00522 result = FONT_SIZE_MEDIUM ;
00523 break ;
00524 default:
00525 cr_utils_trace_info ("Unknown FONT_SIZE") ;
00526 result = FONT_SIZE_MEDIUM ;
00527 break ;
00528 }
00529 *a_larger_size = result ;
00530 }
00531
00532 gboolean
00533 cr_font_size_is_predefined_absolute_font_size (enum CRPredefinedAbsoluteFontSize a_font_size)
00534 {
00535 if (a_font_size >= FONT_SIZE_XX_SMALL
00536 && a_font_size < NB_PREDEFINED_ABSOLUTE_FONT_SIZES) {
00537 return TRUE ;
00538 } else {
00539 return FALSE ;
00540 }
00541 }
00542
00543 gchar *
00544 cr_font_size_adjust_to_string (CRFontSizeAdjust * a_this)
00545 {
00546 gchar *str = NULL;
00547
00548 if (!a_this) {
00549 str = g_strdup ("NULL");
00550 g_return_val_if_fail (str, NULL);
00551 return str;
00552 }
00553
00554 switch (a_this->type) {
00555 case FONT_SIZE_ADJUST_NONE:
00556 str = g_strdup ("none");
00557 break;
00558 case FONT_SIZE_ADJUST_NUMBER:
00559 if (a_this->num)
00560 str = cr_num_to_string (a_this->num);
00561 else
00562 str = g_strdup ("unknow font-size-adjust property value");
00563 break;
00564 case FONT_SIZE_ADJUST_INHERIT:
00565 str = g_strdup ("inherit");
00566 }
00567 return str;
00568 }
00569
00570 const gchar *
00571 cr_font_style_to_string (enum CRFontStyle a_code)
00572 {
00573 gchar *str = NULL;
00574
00575 switch (a_code) {
00576 case FONT_STYLE_NORMAL:
00577 str = (gchar *) "normal";
00578 break;
00579 case FONT_STYLE_ITALIC:
00580 str = (gchar *) "italic";
00581 break;
00582 case FONT_STYLE_OBLIQUE:
00583 str = (gchar *) "oblique";
00584 break;
00585 case FONT_STYLE_INHERIT:
00586 str = (gchar *) "inherit";
00587 break;
00588 default:
00589 str = (gchar *) "unknown font style value";
00590 break;
00591 }
00592 return str;
00593 }
00594
00595 const gchar *
00596 cr_font_variant_to_string (enum CRFontVariant a_code)
00597 {
00598 gchar *str = NULL;
00599
00600 switch (a_code) {
00601 case FONT_VARIANT_NORMAL:
00602 str = (gchar *) "normal";
00603 break;
00604 case FONT_VARIANT_SMALL_CAPS:
00605 str = (gchar *) "small-caps";
00606 break;
00607 case FONT_VARIANT_INHERIT:
00608 str = (gchar *) "inherit";
00609 break;
00610 }
00611 return str;
00612 }
00613
00614 enum CRFontWeight
00615 cr_font_weight_get_bolder (enum CRFontWeight a_weight)
00616 {
00617 if (a_weight >= NB_FONT_WEIGHTS) {
00618 return FONT_WEIGHT_900 ;
00619 } else if (a_weight < FONT_WEIGHT_NORMAL) {
00620 return FONT_WEIGHT_NORMAL ;
00621 } else if (a_weight == FONT_WEIGHT_BOLDER
00622 || a_weight == FONT_WEIGHT_BOLDER) {
00623 cr_utils_trace_info ("FONT_WEIGHT_BOLDER or FONT_WEIGHT_LIGHTER should not appear here") ;
00624 return FONT_WEIGHT_NORMAL ;
00625 } else {
00626 return a_weight << 1 ;
00627 }
00628 }
00629
00630 const gchar *
00631 cr_font_weight_to_string (enum CRFontWeight a_code)
00632 {
00633 gchar *str = NULL;
00634
00635 switch (a_code) {
00636 case FONT_WEIGHT_NORMAL:
00637 str = (gchar *) "normal";
00638 break;
00639 case FONT_WEIGHT_BOLD:
00640 str = (gchar *) "bold";
00641 break;
00642 case FONT_WEIGHT_BOLDER:
00643 str = (gchar *) "bolder";
00644 break;
00645 case FONT_WEIGHT_LIGHTER:
00646 str = (gchar *) "lighter";
00647 break;
00648 case FONT_WEIGHT_100:
00649 str = (gchar *) "100";
00650 break;
00651 case FONT_WEIGHT_200:
00652 str = (gchar *) "200";
00653 break;
00654 case FONT_WEIGHT_300:
00655 str = (gchar *) "300";
00656 break;
00657 case FONT_WEIGHT_400:
00658 str = (gchar *) "400";
00659 break;
00660 case FONT_WEIGHT_500:
00661 str = (gchar *) "500";
00662 break;
00663 case FONT_WEIGHT_600:
00664 str = (gchar *) "600";
00665 break;
00666 case FONT_WEIGHT_700:
00667 str = (gchar *) "700";
00668 break;
00669 case FONT_WEIGHT_800:
00670 str = (gchar *) "800";
00671 break;
00672 case FONT_WEIGHT_900:
00673 str = (gchar *) "900";
00674 break;
00675 case FONT_WEIGHT_INHERIT:
00676 str = (gchar *) "inherit";
00677 break;
00678 default:
00679 str = (gchar *) "unknown font-weight property value";
00680 break;
00681 }
00682 return str;
00683 }
00684
00685 const gchar *
00686 cr_font_stretch_to_string (enum CRFontStretch a_code)
00687 {
00688 gchar *str = NULL;
00689
00690 switch (a_code) {
00691 case FONT_STRETCH_NORMAL:
00692 str = (gchar *) "normal";
00693 break;
00694 case FONT_STRETCH_WIDER:
00695 str = (gchar *) "wider";
00696 break;
00697 case FONT_STRETCH_NARROWER:
00698 str = (gchar *) "narrower";
00699 break;
00700 case FONT_STRETCH_ULTRA_CONDENSED:
00701 str = (gchar *) "ultra-condensed";
00702 break;
00703 case FONT_STRETCH_EXTRA_CONDENSED:
00704 str = (gchar *) "extra-condensed";
00705 break;
00706 case FONT_STRETCH_CONDENSED:
00707 str = (gchar *) "condensed";
00708 break;
00709 case FONT_STRETCH_SEMI_CONDENSED:
00710 str = (gchar *) "semi-condensed";
00711 break;
00712 case FONT_STRETCH_SEMI_EXPANDED:
00713 str = (gchar *) "semi-expanded";
00714 break;
00715 case FONT_STRETCH_EXPANDED:
00716 str = (gchar *) "expanded";
00717 break;
00718 case FONT_STRETCH_EXTRA_EXPANDED:
00719 str = (gchar *) "extra-expaned";
00720 break;
00721 case FONT_STRETCH_ULTRA_EXPANDED:
00722 str = (gchar *) "ultra-expanded";
00723 break;
00724 case FONT_STRETCH_INHERIT:
00725 str = (gchar *) "inherit";
00726 break;
00727 }
00728 return str;
00729 }
00730
00731 void
00732 cr_font_size_destroy (CRFontSize * a_font_size)
00733 {
00734 g_return_if_fail (a_font_size);
00735
00736 g_free (a_font_size) ;
00737 }
00738
00739
00740
00741
00742
00743 CRFontSizeAdjust *
00744 cr_font_size_adjust_new (void)
00745 {
00746 CRFontSizeAdjust *result = NULL;
00747
00748 result = g_try_malloc (sizeof (CRFontSizeAdjust));
00749 if (!result) {
00750 cr_utils_trace_info ("Out of memory");
00751 return NULL;
00752 }
00753 memset (result, 0, sizeof (CRFontSizeAdjust));
00754
00755 return result;
00756 }
00757
00758 void
00759 cr_font_size_adjust_destroy (CRFontSizeAdjust * a_this)
00760 {
00761 g_return_if_fail (a_this);
00762
00763 if (a_this->type == FONT_SIZE_ADJUST_NUMBER && a_this->num) {
00764 cr_num_destroy (a_this->num);
00765 a_this->num = NULL;
00766 }
00767 }