← Back to branch summary

~vaifrax/inkscape/bugfix170049

« back to all changes in this revision

Viewing changes to src/libcroco/cr-fonts.c

  • Committer: mental
  • Date: 2006-01-16 02:36:01 UTC
  • Revision ID: mental@users.sourceforge.net-20060116023601-wkr0h7edl5veyudq
moving trunk for module inkscape

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libcroco/cr-fonts.c
 
1
/* -*- Mode: C; indent-tabs-mode:nil; c-basic-offset: 8-*- */
 
2
 
 
3
/*
 
4
 * This file is part of The Croco Library
 
5
 *
 
6
 *
 
7
 * This program is free software; you can redistribute it and/or
 
8
 * modify it under the terms of version 2.1 of 
 
9
 * the GNU Lesser General Public
 
10
 * License as published by the Free Software Foundation.
 
11
 *
 
12
 * This program is distributed in the hope that it will be useful,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
 * GNU General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the 
 
18
 * GNU Lesser General Public License
 
19
 * along with this program; if not, write to the Free Software
 
20
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 
21
 * USA
 
22
 *
 
23
 *See COPYRIGHTS file for copyright information
 
24
 */
 
25
 
 
26
#include "cr-fonts.h"
 
27
#include <string.h>
 
28
 
 
29
static enum CRStatus
 
30
cr_font_family_to_string_real (CRFontFamily * a_this,
 
31
                               gboolean a_walk_list, GString ** a_string)
 
32
{
 
33
        guchar *name = NULL;
 
34
        enum CRStatus result = CR_OK;
 
35
 
 
36
        if (!*a_string) {
 
37
                *a_string = g_string_new (NULL);
 
38
                g_return_val_if_fail (*a_string,
 
39
                                      CR_INSTANCIATION_FAILED_ERROR);
 
40
        }
 
41
 
 
42
        if (!a_this) {
 
43
                g_string_append (*a_string, "NULL");
 
44
                return CR_OK;
 
45
        }
 
46
 
 
47
        switch (a_this->type) {
 
48
        case FONT_FAMILY_SANS_SERIF:
 
49
                name = (guchar *) "sans-serif";
 
50
                break;
 
51
 
 
52
        case FONT_FAMILY_SERIF:
 
53
                name = (guchar *) "sans-serif";
 
54
                break;
 
55
 
 
56
        case FONT_FAMILY_CURSIVE:
 
57
                name = (guchar *) "cursive";
 
58
                break;
 
59
 
 
60
        case FONT_FAMILY_FANTASY:
 
61
                name = (guchar *) "fantasy";
 
62
                break;
 
63
 
 
64
        case FONT_FAMILY_MONOSPACE:
 
65
                name = (guchar *) "monospace";
 
66
                break;
 
67
 
 
68
        case FONT_FAMILY_NON_GENERIC:
 
69
                name = (guchar *) a_this->name;
 
70
                break;
 
71
 
 
72
        default:
 
73
                name = (guchar *) NULL;
 
74
                break;
 
75
        }
 
76
 
 
77
        if (name) {
 
78
                if (a_this->prev) {
 
79
                        g_string_append_printf (*a_string, ", %s", name);
 
80
                } else {
 
81
                        g_string_append (*a_string, name);
 
82
                }
 
83
        }
 
84
        if (a_walk_list == TRUE && a_this->next) {
 
85
                result = cr_font_family_to_string_real (a_this->next,
 
86
                                                        TRUE, a_string);
 
87
        }
 
88
        return result;
 
89
}
 
90
 
 
91
static const gchar *
 
92
cr_predefined_absolute_font_size_to_string (enum CRPredefinedAbsoluteFontSize
 
93
                                            a_code)
 
94
{
 
95
        gchar *str = NULL;
 
96
 
 
97
        switch (a_code) {
 
98
        case FONT_SIZE_XX_SMALL:
 
99
                str = (gchar *) "xx-small";
 
100
                break;
 
101
        case FONT_SIZE_X_SMALL:
 
102
                str = (gchar *) "x-small";
 
103
                break;
 
104
        case FONT_SIZE_SMALL:
 
105
                str = (gchar *) "small";
 
106
                break;
 
107
        case FONT_SIZE_MEDIUM:
 
108
                str = (gchar *) "medium";
 
109
                break;
 
110
        case FONT_SIZE_LARGE:
 
111
                str = (gchar *) "large";
 
112
                break;
 
113
        case FONT_SIZE_X_LARGE:
 
114
                str = (gchar *) "x-large";
 
115
                break;
 
116
        case FONT_SIZE_XX_LARGE:
 
117
                str = (gchar *) "xx-large";
 
118
                break;
 
119
        default:
 
120
                str = (gchar *) "unknown absolute font size value";
 
121
        }
 
122
        return str;
 
123
}
 
124
 
 
125
static const gchar *
 
126
cr_relative_font_size_to_string (enum CRRelativeFontSize a_code)
 
127
{
 
128
        gchar *str = NULL;
 
129
 
 
130
        switch (a_code) {
 
131
        case FONT_SIZE_LARGER:
 
132
                str = (gchar *) "larger";
 
133
                break;
 
134
        case FONT_SIZE_SMALLER:
 
135
                str = (gchar *) "smaller";
 
136
                break;
 
137
        default:
 
138
                str = (gchar *) "unknown relative font size value";
 
139
                break;
 
140
        }
 
141
        return str;
 
142
}
 
143
 
 
144
CRFontFamily *
 
145
cr_font_family_new (enum CRFontFamilyType a_type, guchar * a_name)
 
146
{
 
147
        CRFontFamily *result = NULL;
 
148
 
 
149
        result = g_try_malloc (sizeof (CRFontFamily));
 
150
 
 
151
        if (!result) {
 
152
                cr_utils_trace_info ("Out of memory");
 
153
                return NULL;
 
154
        }
 
155
 
 
156
        memset (result, 0, sizeof (CRFontFamily));
 
157
        result->type = a_type;
 
158
 
 
159
        cr_font_family_set_name (result, a_name);
 
160
 
 
161
        return result;
 
162
}
 
163
 
 
164
guchar *
 
165
cr_font_family_to_string (CRFontFamily * a_this,
 
166
                          gboolean a_walk_font_family_list)
 
167
{
 
168
        enum CRStatus status = CR_OK;
 
169
        guchar *result = NULL;
 
170
        GString *stringue = NULL;
 
171
 
 
172
        if (!a_this) {
 
173
                result = g_strdup ("NULL");
 
174
                g_return_val_if_fail (result, NULL);
 
175
                return result;
 
176
        }
 
177
        status = cr_font_family_to_string_real (a_this,
 
178
                                                a_walk_font_family_list,
 
179
                                                &stringue);
 
180
 
 
181
        if (status == CR_OK && stringue) {
 
182
                result = stringue->str;
 
183
                g_string_free (stringue, FALSE);
 
184
                stringue = NULL;
 
185
 
 
186
        } else {
 
187
                if (stringue) {
 
188
                        g_string_free (stringue, TRUE);
 
189
                        stringue = NULL;
 
190
                }
 
191
        }
 
192
 
 
193
        return result;
 
194
}
 
195
enum CRStatus
 
196
cr_font_family_set_name (CRFontFamily * a_this, guchar * a_name)
 
197
{
 
198
        g_return_val_if_fail (a_this, CR_BAD_PARAM_ERROR);
 
199
 
 
200
        /*
 
201
         *only non generic font families can have a name
 
202
         */
 
203
 
 
204
        if (a_this->type != FONT_FAMILY_NON_GENERIC) {
 
205
                return CR_BAD_PARAM_ERROR;
 
206
        }
 
207
 
 
208
        if (a_this->name) {
 
209
                g_free (a_this->name);
 
210
                a_this->name = NULL;
 
211
        }
 
212
 
 
213
        a_this->name = a_name;
 
214
        return CR_OK;
 
215
}
 
216
 
 
217
CRFontFamily *
 
218
cr_font_family_append (CRFontFamily * a_this,
 
219
                       CRFontFamily * a_family_to_append)
 
220
{
 
221
        CRFontFamily *cur_ff = NULL;
 
222
 
 
223
        g_return_val_if_fail (a_family_to_append, NULL);
 
224
 
 
225
        if (!a_this)
 
226
                return a_family_to_append;
 
227
 
 
228
        for (cur_ff = a_this; cur_ff && cur_ff->next; cur_ff = cur_ff->next) ;
 
229
 
 
230
        cur_ff->next = a_family_to_append;
 
231
        a_family_to_append->prev = cur_ff;
 
232
 
 
233
        return a_this;
 
234
 
 
235
}
 
236
 
 
237
CRFontFamily *
 
238
cr_font_family_prepend (CRFontFamily * a_this,
 
239
                        CRFontFamily * a_family_to_prepend)
 
240
{
 
241
        g_return_val_if_fail (a_this && a_family_to_prepend, NULL);
 
242
 
 
243
        if (!a_this)
 
244
                return a_family_to_prepend;
 
245
 
 
246
        a_family_to_prepend->next = a_this;
 
247
        a_this->prev = a_family_to_prepend;
 
248
 
 
249
        return CR_OK;
 
250
}
 
251
 
 
252
enum CRStatus
 
253
cr_font_family_destroy (CRFontFamily * a_this)
 
254
{
 
255
        CRFontFamily *cur_ff = NULL;
 
256
 
 
257
        g_return_val_if_fail (a_this, CR_BAD_PARAM_ERROR);
 
258
 
 
259
        for (cur_ff = a_this; cur_ff && cur_ff->next; cur_ff = cur_ff->next) ;
 
260
 
 
261
        for (; cur_ff; cur_ff = cur_ff->prev) {
 
262
                if (a_this->name) {
 
263
                        g_free (a_this->name);
 
264
                        a_this->name = NULL;
 
265
                }
 
266
 
 
267
                if (cur_ff->next) {
 
268
                        g_free (cur_ff->next);
 
269
 
 
270
                }
 
271
 
 
272
                if (cur_ff->prev == NULL) {
 
273
                        g_free (a_this);
 
274
                }
 
275
        }
 
276
 
 
277
        return CR_OK;
 
278
}
 
279
 
 
280
/***************************************************
 
281
 *'font-size' manipulation functions definitions
 
282
 ***************************************************/
 
283
 
 
284
CRFontSize *
 
285
cr_font_size_new (void)
 
286
{
 
287
        CRFontSize *result = NULL;
 
288
 
 
289
        result = g_try_malloc (sizeof (CRFontSize));
 
290
        if (!result) {
 
291
                cr_utils_trace_info ("Out of memory");
 
292
                return NULL;
 
293
        }
 
294
        memset (result, 0, sizeof (CRFontSize));
 
295
 
 
296
        return result;
 
297
}
 
298
 
 
299
enum CRStatus
 
300
cr_font_size_clear (CRFontSize * a_this)
 
301
{
 
302
        g_return_val_if_fail (a_this, CR_BAD_PARAM_ERROR);
 
303
 
 
304
        switch (a_this->type) {
 
305
        case PREDEFINED_ABSOLUTE_FONT_SIZE:
 
306
        case RELATIVE_FONT_SIZE:
 
307
        case INHERITED_FONT_SIZE:
 
308
                memset (a_this, 0, sizeof (CRFontSize));
 
309
                break;
 
310
 
 
311
        case ABSOLUTE_FONT_SIZE:
 
312
                memset (a_this, 0, sizeof (CRFontSize));
 
313
                break;
 
314
 
 
315
        default:
 
316
                return CR_UNKNOWN_TYPE_ERROR;
 
317
        }
 
318
 
 
319
        return CR_OK;
 
320
}
 
321
 
 
322
enum CRStatus
 
323
cr_font_size_copy (CRFontSize * a_dst, CRFontSize * a_src)
 
324
{
 
325
        g_return_val_if_fail (a_dst && a_src, CR_BAD_PARAM_ERROR);
 
326
 
 
327
        switch (a_src->type) {
 
328
        case PREDEFINED_ABSOLUTE_FONT_SIZE:
 
329
        case RELATIVE_FONT_SIZE:
 
330
        case INHERITED_FONT_SIZE:
 
331
                cr_font_size_clear (a_dst);
 
332
                memcpy (a_dst, a_src, sizeof (CRFontSize));
 
333
                break;
 
334
 
 
335
        case ABSOLUTE_FONT_SIZE:
 
336
                cr_font_size_clear (a_dst);
 
337
                cr_num_copy (&a_dst->value.absolute,
 
338
                             &a_src->value.absolute);
 
339
                a_dst->type = a_src->type;
 
340
                break;
 
341
 
 
342
        default:
 
343
                return CR_UNKNOWN_TYPE_ERROR;
 
344
        }
 
345
        return CR_OK;
 
346
}
 
347
 
 
348
enum CRStatus 
 
349
cr_font_size_set_predefined_absolute_font_size (CRFontSize *a_this, 
 
350
                                                enum CRPredefinedAbsoluteFontSize a_predefined)
 
351
{
 
352
        g_return_val_if_fail (a_this, CR_BAD_PARAM_ERROR) ;
 
353
        g_return_val_if_fail ((unsigned)a_predefined < NB_FONT_SIZE_TYPE,
 
354
                              CR_BAD_PARAM_ERROR) ;
 
355
 
 
356
        a_this->type = PREDEFINED_ABSOLUTE_FONT_SIZE ;
 
357
        a_this->value.predefined = a_predefined ;
 
358
 
 
359
        return CR_OK ;
 
360
}
 
361
 
 
362
enum CRStatus 
 
363
cr_font_size_set_relative_font_size (CRFontSize *a_this,
 
364
                                     enum CRRelativeFontSize a_relative)
 
365
{
 
366
        g_return_val_if_fail (a_this, CR_BAD_PARAM_ERROR) ;
 
367
        g_return_val_if_fail ((unsigned)a_relative < NB_RELATIVE_FONT_SIZE,
 
368
                              CR_BAD_PARAM_ERROR) ;
 
369
        
 
370
        a_this->type = RELATIVE_FONT_SIZE ;
 
371
        a_this->value.relative = a_relative ;
 
372
        return CR_OK ;
 
373
}
 
374
 
 
375
enum CRStatus 
 
376
cr_font_size_set_absolute_font_size (CRFontSize *a_this,
 
377
                                     enum CRNumType a_num_type,
 
378
                                     gdouble a_value)
 
379
{
 
380
        g_return_val_if_fail (a_this, CR_BAD_PARAM_ERROR) ;
 
381
        g_return_val_if_fail ((unsigned)a_num_type < NB_NUM_TYPE,
 
382
                              CR_BAD_PARAM_ERROR) ;
 
383
 
 
384
        a_this->type = ABSOLUTE_FONT_SIZE ;
 
385
        cr_num_set (&a_this->value.absolute,
 
386
                    a_value, a_num_type) ;        
 
387
        return CR_OK ;
 
388
}
 
389
 
 
390
enum CRStatus
 
391
cr_font_size_set_to_inherit (CRFontSize *a_this)
 
392
{
 
393
        g_return_val_if_fail (a_this, CR_BAD_PARAM_ERROR) ;
 
394
 
 
395
        cr_font_size_clear (a_this) ;
 
396
        a_this->type = INHERITED_FONT_SIZE ;
 
397
 
 
398
        return CR_OK ;
 
399
}
 
400
 
 
401
gboolean
 
402
cr_font_size_is_set_to_inherit (CRFontSize *a_this)
 
403
{
 
404
        g_return_val_if_fail (a_this, FALSE) ;
 
405
 
 
406
        return a_this->type == INHERITED_FONT_SIZE ;
 
407
}
 
408
 
 
409
gchar *
 
410
cr_font_size_to_string (CRFontSize * a_this)
 
411
{
 
412
        gchar *str = NULL;
 
413
 
 
414
        if (!a_this) {
 
415
                str = g_strdup ("NULL");
 
416
                g_return_val_if_fail (str, NULL);
 
417
                return str;
 
418
        }
 
419
        switch (a_this->type) {
 
420
        case PREDEFINED_ABSOLUTE_FONT_SIZE:
 
421
                str = g_strdup (cr_predefined_absolute_font_size_to_string
 
422
                                (a_this->value.predefined));
 
423
                break;
 
424
        case ABSOLUTE_FONT_SIZE:
 
425
                str = cr_num_to_string (&a_this->value.absolute);
 
426
                break;
 
427
        case RELATIVE_FONT_SIZE:
 
428
                str = g_strdup (cr_relative_font_size_to_string
 
429
                                (a_this->value.relative));
 
430
                break;
 
431
        case INHERITED_FONT_SIZE:
 
432
                str = g_strdup ("inherit");
 
433
                break;
 
434
        default:
 
435
                break;
 
436
        }
 
437
        return str;
 
438
}
 
439
 
 
440
void 
 
441
cr_font_size_get_smaller_predefined_font_size (enum CRPredefinedAbsoluteFontSize a_font_size,
 
442
                                               enum CRPredefinedAbsoluteFontSize *a_smaller_size)
 
443
{
 
444
        enum CRPredefinedAbsoluteFontSize result = FONT_SIZE_MEDIUM ;
 
445
 
 
446
        g_return_if_fail (a_smaller_size) ;
 
447
        g_return_if_fail ((unsigned)a_font_size < NB_PREDEFINED_ABSOLUTE_FONT_SIZES) ;
 
448
 
 
449
        switch (a_font_size) {
 
450
        case FONT_SIZE_XX_SMALL:
 
451
                result =  FONT_SIZE_XX_SMALL ;
 
452
                break ;
 
453
        case FONT_SIZE_X_SMALL:
 
454
                result =  FONT_SIZE_XX_SMALL ;
 
455
                break ;
 
456
        case FONT_SIZE_SMALL:
 
457
                result =  FONT_SIZE_X_SMALL;
 
458
                break ;
 
459
        case FONT_SIZE_MEDIUM:
 
460
                result =  FONT_SIZE_SMALL;
 
461
                break ;
 
462
        case FONT_SIZE_LARGE:
 
463
                result =  FONT_SIZE_MEDIUM;
 
464
                break ;
 
465
        case FONT_SIZE_X_LARGE:
 
466
                result =  FONT_SIZE_LARGE;
 
467
                break ;
 
468
        case FONT_SIZE_XX_LARGE:
 
469
                result =  FONT_SIZE_XX_LARGE;
 
470
                break ;
 
471
        case FONT_SIZE_INHERIT:
 
472
                cr_utils_trace_info ("can't return a smaller size for FONT_SIZE_INHERIT") ;                
 
473
                result =  FONT_SIZE_MEDIUM ;
 
474
                break ;
 
475
        default:
 
476
                cr_utils_trace_info ("Unknown FONT_SIZE") ;
 
477
                result = FONT_SIZE_MEDIUM ;
 
478
                break ;
 
479
        }
 
480
        *a_smaller_size = result ;
 
481
}
 
482
 
 
483
 
 
484
void 
 
485
cr_font_size_get_larger_predefined_font_size (enum CRPredefinedAbsoluteFontSize a_font_size,
 
486
                                              enum CRPredefinedAbsoluteFontSize *a_larger_size)
 
487
{
 
488
        enum CRPredefinedAbsoluteFontSize result = FONT_SIZE_MEDIUM ;
 
489
        
 
490
        g_return_if_fail (a_larger_size) ;
 
491
        g_return_if_fail ((unsigned)a_font_size < NB_PREDEFINED_ABSOLUTE_FONT_SIZES) ;
 
492
 
 
493
        switch (a_font_size) {
 
494
        case FONT_SIZE_XX_SMALL:
 
495
                result =  FONT_SIZE_X_SMALL ;
 
496
                break ;
 
497
        case FONT_SIZE_X_SMALL:
 
498
                result =  FONT_SIZE_SMALL ;
 
499
                break ;
 
500
        case FONT_SIZE_SMALL:
 
501
                result =  FONT_SIZE_MEDIUM;
 
502
                break ;
 
503
        case FONT_SIZE_MEDIUM:
 
504
                result =  FONT_SIZE_LARGE;
 
505
                break ;
 
506
        case FONT_SIZE_LARGE:
 
507
                result =  FONT_SIZE_X_LARGE;
 
508
                break ;
 
509
        case FONT_SIZE_X_LARGE:
 
510
                result =  FONT_SIZE_XX_LARGE ;
 
511
                break ;
 
512
        case FONT_SIZE_XX_LARGE:
 
513
                result =  FONT_SIZE_XX_LARGE;
 
514
                break ;
 
515
        case FONT_SIZE_INHERIT:
 
516
                cr_utils_trace_info ("can't return a bigger size for FONT_SIZE_INHERIT") ;                
 
517
                result =  FONT_SIZE_MEDIUM ;
 
518
                break ;
 
519
        default:
 
520
                cr_utils_trace_info ("Unknown FONT_SIZE") ;
 
521
                result = FONT_SIZE_MEDIUM ;
 
522
                break ;
 
523
        }
 
524
        *a_larger_size = result ;
 
525
}
 
526
 
 
527
gboolean
 
528
cr_font_size_is_predefined_absolute_font_size (enum CRPredefinedAbsoluteFontSize a_font_size)
 
529
{
 
530
        if ((unsigned)a_font_size < NB_PREDEFINED_ABSOLUTE_FONT_SIZES) {
 
531
                return TRUE ;
 
532
        } else {
 
533
                return FALSE ;
 
534
        }
 
535
}
 
536
 
 
537
gchar *
 
538
cr_font_size_adjust_to_string (CRFontSizeAdjust * a_this)
 
539
{
 
540
        gchar *str = NULL;
 
541
 
 
542
        if (!a_this) {
 
543
                str = g_strdup ("NULL");
 
544
                g_return_val_if_fail (str, NULL);
 
545
                return str;
 
546
        }
 
547
 
 
548
        switch (a_this->type) {
 
549
        case FONT_SIZE_ADJUST_NONE:
 
550
                str = g_strdup ("none");
 
551
                break;
 
552
        case FONT_SIZE_ADJUST_NUMBER:
 
553
                if (a_this->num)
 
554
                        str = cr_num_to_string (a_this->num);
 
555
                else
 
556
                        str = g_strdup ("unknow font-size-adjust property value"); // Should raise an error no?
 
557
                break;
 
558
        case FONT_SIZE_ADJUST_INHERIT:
 
559
                str = g_strdup ("inherit");
 
560
        }
 
561
        return str;
 
562
}
 
563
 
 
564
const gchar *
 
565
cr_font_style_to_string (enum CRFontStyle a_code)
 
566
{
 
567
        gchar *str = NULL;
 
568
 
 
569
        switch (a_code) {
 
570
        case FONT_STYLE_NORMAL:
 
571
                str = (gchar *) "normal";
 
572
                break;
 
573
        case FONT_STYLE_ITALIC:
 
574
                str = (gchar *) "italic";
 
575
                break;
 
576
        case FONT_STYLE_OBLIQUE:
 
577
                str = (gchar *) "oblique";
 
578
                break;
 
579
        case FONT_STYLE_INHERIT:
 
580
                str = (gchar *) "inherit";
 
581
                break;
 
582
        default:
 
583
                str = (gchar *) "unknown font style value";
 
584
                break;
 
585
        }
 
586
        return str;
 
587
}
 
588
 
 
589
const gchar *
 
590
cr_font_variant_to_string (enum CRFontVariant a_code)
 
591
{
 
592
        gchar *str = NULL;
 
593
 
 
594
        switch (a_code) {
 
595
        case FONT_VARIANT_NORMAL:
 
596
                str = (gchar *) "normal";
 
597
                break;
 
598
        case FONT_VARIANT_SMALL_CAPS:
 
599
                str = (gchar *) "small-caps";
 
600
                break;
 
601
        case FONT_VARIANT_INHERIT:
 
602
                str = (gchar *) "inherit";
 
603
                break;
 
604
        }
 
605
        return str;
 
606
}
 
607
 
 
608
enum CRFontWeight
 
609
cr_font_weight_get_bolder (enum CRFontWeight a_weight)
 
610
{
 
611
        if (a_weight >= NB_FONT_WEIGHTS) {
 
612
                return FONT_WEIGHT_900 ;
 
613
        } else if (a_weight < FONT_WEIGHT_NORMAL) {
 
614
                return FONT_WEIGHT_NORMAL ;
 
615
        } else if (a_weight == FONT_WEIGHT_BOLDER
 
616
                   || a_weight == FONT_WEIGHT_BOLDER) {
 
617
                cr_utils_trace_info ("FONT_WEIGHT_BOLDER or FONT_WEIGHT_LIGHTER should not appear here") ;
 
618
                return FONT_WEIGHT_NORMAL ;
 
619
        } else {
 
620
                return a_weight << 1 ;
 
621
        }
 
622
}
 
623
 
 
624
const gchar *
 
625
cr_font_weight_to_string (enum CRFontWeight a_code)
 
626
{
 
627
        gchar *str = NULL;
 
628
 
 
629
        switch (a_code) {
 
630
        case FONT_WEIGHT_NORMAL:
 
631
                str = (gchar *) "normal";
 
632
                break;
 
633
        case FONT_WEIGHT_BOLD:
 
634
                str = (gchar *) "bold";
 
635
                break;
 
636
        case FONT_WEIGHT_BOLDER:
 
637
                str = (gchar *) "bolder";
 
638
                break;
 
639
        case FONT_WEIGHT_LIGHTER:
 
640
                str = (gchar *) "lighter";
 
641
                break;
 
642
        case FONT_WEIGHT_100:
 
643
                str = (gchar *) "100";
 
644
                break;
 
645
        case FONT_WEIGHT_200:
 
646
                str = (gchar *) "200";
 
647
                break;
 
648
        case FONT_WEIGHT_300:
 
649
                str = (gchar *) "300";
 
650
                break;
 
651
        case FONT_WEIGHT_400:
 
652
                str = (gchar *) "400";
 
653
                break;
 
654
        case FONT_WEIGHT_500:
 
655
                str = (gchar *) "500";
 
656
                break;
 
657
        case FONT_WEIGHT_600:
 
658
                str = (gchar *) "600";
 
659
                break;
 
660
        case FONT_WEIGHT_700:
 
661
                str = (gchar *) "700";
 
662
                break;
 
663
        case FONT_WEIGHT_800:
 
664
                str = (gchar *) "800";
 
665
                break;
 
666
        case FONT_WEIGHT_900:
 
667
                str = (gchar *) "900";
 
668
                break;
 
669
        case FONT_WEIGHT_INHERIT:
 
670
                str = (gchar *) "inherit";
 
671
                break;
 
672
        default:
 
673
                str = (gchar *) "unknown font-weight property value";
 
674
                break;
 
675
        }
 
676
        return str;
 
677
}
 
678
 
 
679
const gchar *
 
680
cr_font_stretch_to_string (enum CRFontStretch a_code)
 
681
{
 
682
        gchar *str = NULL;
 
683
 
 
684
        switch (a_code) {
 
685
        case FONT_STRETCH_NORMAL:
 
686
                str = (gchar *) "normal";
 
687
                break;
 
688
        case FONT_STRETCH_WIDER:
 
689
                str = (gchar *) "wider";
 
690
                break;
 
691
        case FONT_STRETCH_NARROWER:
 
692
                str = (gchar *) "narrower";
 
693
                break;
 
694
        case FONT_STRETCH_ULTRA_CONDENSED:
 
695
                str = (gchar *) "ultra-condensed";
 
696
                break;
 
697
        case FONT_STRETCH_EXTRA_CONDENSED:
 
698
                str = (gchar *) "extra-condensed";
 
699
                break;
 
700
        case FONT_STRETCH_CONDENSED:
 
701
                str = (gchar *) "condensed";
 
702
                break;
 
703
        case FONT_STRETCH_SEMI_CONDENSED:
 
704
                str = (gchar *) "semi-condensed";
 
705
                break;
 
706
        case FONT_STRETCH_SEMI_EXPANDED:
 
707
                str = (gchar *) "semi-expanded";
 
708
                break;
 
709
        case FONT_STRETCH_EXPANDED:
 
710
                str = (gchar *) "expanded";
 
711
                break;
 
712
        case FONT_STRETCH_EXTRA_EXPANDED:
 
713
                str = (gchar *) "extra-expaned";
 
714
                break;
 
715
        case FONT_STRETCH_ULTRA_EXPANDED:
 
716
                str = (gchar *) "ultra-expanded";
 
717
                break;
 
718
        case FONT_STRETCH_INHERIT:
 
719
                str = (gchar *) "inherit";
 
720
                break;
 
721
        }
 
722
        return str;
 
723
}
 
724
 
 
725
void
 
726
cr_font_size_destroy (CRFontSize * a_font_size)
 
727
{
 
728
        g_return_if_fail (a_font_size);
 
729
 
 
730
        g_free (a_font_size) ;
 
731
}
 
732
 
 
733
/*******************************************************
 
734
 *'font-size-adjust' manipulation function definition
 
735
 *******************************************************/
 
736
 
 
737
CRFontSizeAdjust *
 
738
cr_font_size_adjust_new (void)
 
739
{
 
740
        CRFontSizeAdjust *result = NULL;
 
741
 
 
742
        result = g_try_malloc (sizeof (CRFontSizeAdjust));
 
743
        if (!result) {
 
744
                cr_utils_trace_info ("Out of memory");
 
745
                return NULL;
 
746
        }
 
747
        memset (result, 0, sizeof (CRFontSizeAdjust));
 
748
 
 
749
        return result;
 
750
}
 
751
 
 
752
void
 
753
cr_font_size_adjust_destroy (CRFontSizeAdjust * a_this)
 
754
{
 
755
        g_return_if_fail (a_this);
 
756
 
 
757
        if (a_this->type == FONT_SIZE_ADJUST_NUMBER && a_this->num) {
 
758
                cr_num_destroy (a_this->num);
 
759
                a_this->num = NULL;
 
760
        }
 
761
}