Main Page | Alphabetical List | Data Structures | Directories | File List | Data Fields | Globals | Related Pages

cr-fonts.c

Go to the documentation of this file.
00001 /* -*- Mode: C; indent-tabs-mode:nil; c-basic-offset: 8-*- */
00002 
00003 /*
00004  * This file is part of The Croco Library
00005  *
00006  *
00007  * This program is free software; you can redistribute it and/or
00008  * modify it under the terms of version 2.1 of 
00009  * the GNU Lesser General Public
00010  * License as published by the Free Software Foundation.
00011  *
00012  * This program is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015  * GNU General Public License for more details.
00016  *
00017  * You should have received a copy of the 
00018  * GNU Lesser General Public License
00019  * along with this program; if not, write to the Free Software
00020  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
00021  * USA
00022  *
00023  *See COPYRIGHTS file for copyright information
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          *only non generic font families can have a name
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  *'font-size' manipulation functions definitions
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"); // Should raise an error no?
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  *'font-size-adjust' manipulation function definition
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 }

Generated on Fri Oct 29 08:29:11 2004 for Libcroco by  doxygen 1.3.9.1