fcfs.c 4.78 KB
Newer Older
Keith Packard's avatar
Keith Packard committed
1
/*
Keith Packard's avatar
Keith Packard committed
2
 * $RCSId: $
Keith Packard's avatar
Keith Packard committed
3
 *
4
 * Copyright © 2000 Keith Packard
Keith Packard's avatar
Keith Packard committed
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Keith Packard not be used in
 * advertising or publicity pertaining to distribution of the software without
 * specific, written prior permission.  Keith Packard makes no
 * representations about the suitability of this software for any purpose.  It
 * is provided "as is" without express or implied warranty.
 *
 * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

#include <stdlib.h>
#include "fcint.h"

FcFontSet *
FcFontSetCreate (void)
{
    FcFontSet	*s;

    s = (FcFontSet *) malloc (sizeof (FcFontSet));
    if (!s)
	return 0;
    FcMemAlloc (FC_MEM_FONTSET, sizeof (FcFontSet));
    s->nfont = 0;
    s->sfont = 0;
    s->fonts = 0;
    return s;
}

void
FcFontSetDestroy (FcFontSet *s)
{
    int	    i;

    for (i = 0; i < s->nfont; i++)
	FcPatternDestroy (s->fonts[i]);
    if (s->fonts)
    {
	FcMemFree (FC_MEM_FONTPTR, s->sfont * sizeof (FcPattern *));
	free (s->fonts);
    }
    FcMemFree (FC_MEM_FONTSET, sizeof (FcFontSet));
    free (s);
}

FcBool
FcFontSetAdd (FcFontSet *s, FcPattern *font)
{
    FcPattern	**f;
    int		sfont;
    
    if (s->nfont == s->sfont)
    {
	sfont = s->sfont + 32;
	if (s->fonts)
	    f = (FcPattern **) realloc (s->fonts, sfont * sizeof (FcPattern *));
	else
	    f = (FcPattern **) malloc (sfont * sizeof (FcPattern *));
	if (!f)
	    return FcFalse;
	if (s->sfont)
	    FcMemFree (FC_MEM_FONTPTR, s->sfont * sizeof (FcPattern *));
	FcMemAlloc (FC_MEM_FONTPTR, sfont * sizeof (FcPattern *));
	s->sfont = sfont;
	s->fonts = f;
    }
    s->fonts[s->nfont++] = font;
    return FcTrue;
}
83

84
85
86
87
static int * fcfs_pat_count;

void
FcFontSetNewBank (void)
88
{
89
90
91
92
93
94
95
    FcPatternNewBank();
}

int
FcFontSetNeededBytes (FcFontSet *s)
{
    int i, c, cum = 0;
96
97

    for (i = 0; i < s->nfont; i++)
98
99
100
101
102
103
    {
	c = FcPatternNeededBytes(s->fonts[i]);
	if (c < 0)
	    return c;
	cum += c;
    }
104

105
    if (cum > 0)
106
	return cum + sizeof(int) + FcObjectNeededBytes();
107
108
109
110
    else
	return 0;
}

111
112
113
114
115
116
117
118
119
/* Returns an overestimate of the number of bytes that
 * might later get eaten up by padding in the ALIGN macro. */
int
FcFontSetNeededBytesAlign (void)
{
    return __alignof__(int) + 
	FcPatternNeededBytesAlign () + FcObjectNeededBytesAlign ();
}

120
121
122
void *
FcFontSetDistributeBytes (FcCache * metadata, void * block_ptr)
{
123
    block_ptr = ALIGN (block_ptr, int);
124
125
126
127
128
129
130
131
132
    fcfs_pat_count = (int *)block_ptr;
    block_ptr = (int *)block_ptr + 1;
    // we don't consume any bytes for the fontset itself,
    // since we don't allocate it statically.
    block_ptr = FcPatternDistributeBytes (metadata, block_ptr);

    // for good measure, write out the object ids used for
    // this bank to the file.
    return FcObjectDistributeBytes (metadata, block_ptr);
133
134
135
}

FcBool
136
FcFontSetSerialize (int bank, FcFontSet * s)
137
138
139
{
    int i;
    FcPattern * p;
140
    *fcfs_pat_count = s->nfont;
141
142
143

    for (i = 0; i < s->nfont; i++)
    {
144
	p = FcPatternSerialize (bank, s->fonts[i]);
145
146
	if (!p) return FcFalse;
    }
147
    FcObjectSerialize();
148
149
150
151

    return FcTrue;
}

152
FcBool
153
FcFontSetUnserialize(FcCache * metadata, FcFontSet * s, void * block_ptr)
154
{
155
156
    int nfont;
    int i, n;
157

158
    block_ptr = ALIGN (block_ptr, int);
159
160
    nfont = *(int *)block_ptr;
    block_ptr = (int *)block_ptr + 1;
161

162
    if (nfont > 0 && nfont < metadata.count)
163
    {
164
	FcPattern * p = (FcPattern *)block_ptr;
165

166
167
168
169
170
171
172
173
174
175
176
177
178
	if (s->sfont < s->nfont + nfont)
	{
	    int sfont = s->nfont + nfont;
	    FcPattern ** pp;
	    pp = realloc (s->fonts, sfont * sizeof (FcPattern));
	    if (!pp)
		return FcFalse;
	    s->fonts = pp;
	    s->sfont = sfont;
	}
	n = s->nfont;
	s->nfont += nfont;

179
180
181
182
183
184
        /* The following line is a bit counterintuitive.  The usual
         * convention is that FcPatternUnserialize is responsible for
         * aligning the FcPattern.  However, the FontSet also stores
         * the FcPatterns in its own array, so we need to align here
         * too. */
        p = ALIGN(p, FcPattern);
185
186
	for (i = 0; i < nfont; i++)
	    s->fonts[n + i] = p+i;
187

188
	block_ptr = FcPatternUnserialize (metadata, block_ptr);
189
	block_ptr = FcObjectUnserialize (metadata, block_ptr);
190
	return block_ptr != 0;
191
192
    }

193
    return FcFalse;
194
}