|
sl@0
|
1 |
/*
|
|
sl@0
|
2 |
* Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
|
|
sl@0
|
3 |
* All rights reserved.
|
|
sl@0
|
4 |
* This component and the accompanying materials are made available
|
|
sl@0
|
5 |
* under the terms of "Eclipse Public License v1.0"
|
|
sl@0
|
6 |
* which accompanies this distribution, and is available
|
|
sl@0
|
7 |
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
|
|
sl@0
|
8 |
*
|
|
sl@0
|
9 |
* Initial Contributors:
|
|
sl@0
|
10 |
* Nokia Corporation - initial contribution.
|
|
sl@0
|
11 |
*
|
|
sl@0
|
12 |
* Contributors:
|
|
sl@0
|
13 |
*
|
|
sl@0
|
14 |
* Description:
|
|
sl@0
|
15 |
* Header FNTREADR.CPP
|
|
sl@0
|
16 |
*
|
|
sl@0
|
17 |
*/
|
|
sl@0
|
18 |
|
|
sl@0
|
19 |
|
|
sl@0
|
20 |
#include "FNTREADR.H"
|
|
sl@0
|
21 |
|
|
sl@0
|
22 |
const int KMarkFirstCharacterInTypeface = -1;
|
|
sl@0
|
23 |
const int KBytesAddedForMetricIndex = 2;
|
|
sl@0
|
24 |
const int KBytesForIndexForFillCharacters = 2;
|
|
sl@0
|
25 |
const int KReportRateFrequencyInPercent = 10;
|
|
sl@0
|
26 |
|
|
sl@0
|
27 |
// class CroppedValues
|
|
sl@0
|
28 |
|
|
sl@0
|
29 |
class CroppedValues
|
|
sl@0
|
30 |
{
|
|
sl@0
|
31 |
public:
|
|
sl@0
|
32 |
CroppedValues();
|
|
sl@0
|
33 |
public:
|
|
sl@0
|
34 |
int iTopCrop;
|
|
sl@0
|
35 |
int iBottomCrop;
|
|
sl@0
|
36 |
int iLeftCrop;
|
|
sl@0
|
37 |
int iRightCrop;
|
|
sl@0
|
38 |
};
|
|
sl@0
|
39 |
|
|
sl@0
|
40 |
CroppedValues::CroppedValues()
|
|
sl@0
|
41 |
: iTopCrop(0), iBottomCrop(0), iLeftCrop(0), iRightCrop(0)
|
|
sl@0
|
42 |
{}
|
|
sl@0
|
43 |
|
|
sl@0
|
44 |
// class FontReader
|
|
sl@0
|
45 |
|
|
sl@0
|
46 |
FontReader::FontReader()
|
|
sl@0
|
47 |
: Reader(),
|
|
sl@0
|
48 |
iFontStore(),
|
|
sl@0
|
49 |
iFontStoreFile(NULL),
|
|
sl@0
|
50 |
iCharacterMetrics(NULL),
|
|
sl@0
|
51 |
iCodeSection(NULL),
|
|
sl@0
|
52 |
iFontBitmap(NULL),
|
|
sl@0
|
53 |
iTypeface(NULL),
|
|
sl@0
|
54 |
iReadFileFormat(ESymbianGDFFormat),
|
|
sl@0
|
55 |
iBitmapWidth(0),
|
|
sl@0
|
56 |
iBitmapHeight(0),
|
|
sl@0
|
57 |
iDefaultXMoveInPixels(KUndefinedInteger),
|
|
sl@0
|
58 |
iDefaultYMoveInPixels(KUndefinedInteger)
|
|
sl@0
|
59 |
{
|
|
sl@0
|
60 |
}
|
|
sl@0
|
61 |
|
|
sl@0
|
62 |
boolean FontReader::Read(const String& aFilename)
|
|
sl@0
|
63 |
{
|
|
sl@0
|
64 |
iFileName = aFilename;
|
|
sl@0
|
65 |
boolean state = Open(iFileName.Text());
|
|
sl@0
|
66 |
|
|
sl@0
|
67 |
while (!_EOF() && state)
|
|
sl@0
|
68 |
{
|
|
sl@0
|
69 |
if (IdentComp(IdentBDFFileHeader) || IdentComp(IdentBDFComment))
|
|
sl@0
|
70 |
{
|
|
sl@0
|
71 |
state = ReadBDFFontBitmap();
|
|
sl@0
|
72 |
iReadFileFormat = EBDFFormat;
|
|
sl@0
|
73 |
}
|
|
sl@0
|
74 |
else if (IdentComp(IdentTypeface))
|
|
sl@0
|
75 |
state = ReadTypeface();
|
|
sl@0
|
76 |
else if (IdentComp(IdentFontStoreFile))
|
|
sl@0
|
77 |
state = ReadFontStoreFile();
|
|
sl@0
|
78 |
else
|
|
sl@0
|
79 |
{
|
|
sl@0
|
80 |
Error("Resource identifier expected");
|
|
sl@0
|
81 |
state = efalse;
|
|
sl@0
|
82 |
}
|
|
sl@0
|
83 |
if (state)
|
|
sl@0
|
84 |
state = NewLine();
|
|
sl@0
|
85 |
}
|
|
sl@0
|
86 |
return state;
|
|
sl@0
|
87 |
}
|
|
sl@0
|
88 |
|
|
sl@0
|
89 |
boolean FontReader::ReadMetricFromBDFCharacter(CharacterMetrics* aCharacterMetrics, CroppedValues* aCropped= NULL)
|
|
sl@0
|
90 |
{
|
|
sl@0
|
91 |
int xMoveInPixels = 0;
|
|
sl@0
|
92 |
int yMoveInPixels = 0;
|
|
sl@0
|
93 |
int bitmapXOffset = 0;
|
|
sl@0
|
94 |
int bitmapYOffset = 0;
|
|
sl@0
|
95 |
|
|
sl@0
|
96 |
boolean state = true;
|
|
sl@0
|
97 |
|
|
sl@0
|
98 |
if (iDefaultXMoveInPixels != KUndefinedInteger)
|
|
sl@0
|
99 |
xMoveInPixels = iDefaultXMoveInPixels;
|
|
sl@0
|
100 |
if (iDefaultYMoveInPixels != KUndefinedInteger)
|
|
sl@0
|
101 |
yMoveInPixels = iDefaultYMoveInPixels;
|
|
sl@0
|
102 |
|
|
sl@0
|
103 |
while (!IdentComp(IdentBDFEndChar) && !_EOF() && state)
|
|
sl@0
|
104 |
{
|
|
sl@0
|
105 |
iLexAnal->ReadNextLine(); // Skip to next line
|
|
sl@0
|
106 |
if (iLex->iType == ELexIdent)
|
|
sl@0
|
107 |
{
|
|
sl@0
|
108 |
if (IdentComp(IdentBDFCursorMove))
|
|
sl@0
|
109 |
{
|
|
sl@0
|
110 |
state = Number(xMoveInPixels);
|
|
sl@0
|
111 |
if (state)
|
|
sl@0
|
112 |
state = Number(yMoveInPixels);
|
|
sl@0
|
113 |
}
|
|
sl@0
|
114 |
else if (IdentComp(IdentBDFBitmapSizeAndDisplacement))
|
|
sl@0
|
115 |
{
|
|
sl@0
|
116 |
state = Number(iBitmapWidth);
|
|
sl@0
|
117 |
if (state)
|
|
sl@0
|
118 |
{
|
|
sl@0
|
119 |
state = Number(iBitmapHeight);
|
|
sl@0
|
120 |
state = Number(bitmapXOffset);
|
|
sl@0
|
121 |
state = Number(bitmapYOffset);
|
|
sl@0
|
122 |
}
|
|
sl@0
|
123 |
}
|
|
sl@0
|
124 |
else if (IdentComp(IdentBDFStartBitmap) && state)
|
|
sl@0
|
125 |
{
|
|
sl@0
|
126 |
int line = 0;
|
|
sl@0
|
127 |
for (line = 0; line < iBitmapHeight; line++)
|
|
sl@0
|
128 |
{
|
|
sl@0
|
129 |
iLexAnal->ReadNextLine(); // Skip to next line
|
|
sl@0
|
130 |
int bits = 0;
|
|
sl@0
|
131 |
int bitOffset = 0;
|
|
sl@0
|
132 |
int byteValue = 0;
|
|
sl@0
|
133 |
for (bits = 0; bits < iBitmapWidth; bits++)
|
|
sl@0
|
134 |
{
|
|
sl@0
|
135 |
if (bitOffset == 0)
|
|
sl@0
|
136 |
{
|
|
sl@0
|
137 |
Lexical lex;
|
|
sl@0
|
138 |
strncpy(lex.iText, &iLexAnal->iLine[bits >> 2], 2);
|
|
sl@0
|
139 |
lex.iText[2] = '\0';
|
|
sl@0
|
140 |
byteValue = lex.CovertStringToHex();
|
|
sl@0
|
141 |
bitOffset = 8;
|
|
sl@0
|
142 |
}
|
|
sl@0
|
143 |
|
|
sl@0
|
144 |
bitOffset--;
|
|
sl@0
|
145 |
int bitValue = (byteValue >> bitOffset) & 1;
|
|
sl@0
|
146 |
iBitArray[bits][line] = bitValue;
|
|
sl@0
|
147 |
}
|
|
sl@0
|
148 |
}
|
|
sl@0
|
149 |
}
|
|
sl@0
|
150 |
}
|
|
sl@0
|
151 |
else
|
|
sl@0
|
152 |
{
|
|
sl@0
|
153 |
Error("Fontbitmap identifier expected");
|
|
sl@0
|
154 |
state = efalse;
|
|
sl@0
|
155 |
}
|
|
sl@0
|
156 |
}
|
|
sl@0
|
157 |
|
|
sl@0
|
158 |
if (state)
|
|
sl@0
|
159 |
state = NewLine();
|
|
sl@0
|
160 |
//
|
|
sl@0
|
161 |
// Make sure that bitmap is fully cropped
|
|
sl@0
|
162 |
//
|
|
sl@0
|
163 |
int leftCrop = 0;
|
|
sl@0
|
164 |
int rightCrop = 0;
|
|
sl@0
|
165 |
int topCrop = 0;
|
|
sl@0
|
166 |
int bottomCrop = 0;
|
|
sl@0
|
167 |
|
|
sl@0
|
168 |
int line = 0;
|
|
sl@0
|
169 |
while (BitmapLineEmpty(line) && line < iBitmapHeight)
|
|
sl@0
|
170 |
{
|
|
sl@0
|
171 |
topCrop++;;
|
|
sl@0
|
172 |
line++;
|
|
sl@0
|
173 |
}
|
|
sl@0
|
174 |
line = iBitmapHeight - 1;
|
|
sl@0
|
175 |
while (BitmapLineEmpty(line) && line > topCrop)
|
|
sl@0
|
176 |
{
|
|
sl@0
|
177 |
bottomCrop++;
|
|
sl@0
|
178 |
line--;
|
|
sl@0
|
179 |
}
|
|
sl@0
|
180 |
int column = iBitmapWidth - 1;
|
|
sl@0
|
181 |
while (BitmapColumnEmpty(column) && column >= 0)
|
|
sl@0
|
182 |
{
|
|
sl@0
|
183 |
rightCrop++;
|
|
sl@0
|
184 |
column--;
|
|
sl@0
|
185 |
}
|
|
sl@0
|
186 |
column = 0;
|
|
sl@0
|
187 |
while (BitmapColumnEmpty(column) && column < iBitmapWidth - 1 - rightCrop)
|
|
sl@0
|
188 |
{
|
|
sl@0
|
189 |
leftCrop++;
|
|
sl@0
|
190 |
column++;
|
|
sl@0
|
191 |
}
|
|
sl@0
|
192 |
|
|
sl@0
|
193 |
int croppedBitmapHeight = iBitmapHeight - topCrop - bottomCrop;
|
|
sl@0
|
194 |
int croppedBitmapWidth = iBitmapWidth - leftCrop - rightCrop;
|
|
sl@0
|
195 |
int croppedLeftAdjust = bitmapXOffset + leftCrop;
|
|
sl@0
|
196 |
int croppedRightAdjust = (xMoveInPixels - croppedLeftAdjust - croppedBitmapWidth);
|
|
sl@0
|
197 |
int croppedAscent = croppedBitmapHeight + bitmapYOffset + bottomCrop;
|
|
sl@0
|
198 |
|
|
sl@0
|
199 |
if(state)
|
|
sl@0
|
200 |
{
|
|
sl@0
|
201 |
aCharacterMetrics->iAscentInPixels = (chardim) croppedAscent;
|
|
sl@0
|
202 |
aCharacterMetrics->iHeightInPixels = (chardim) croppedBitmapHeight;
|
|
sl@0
|
203 |
aCharacterMetrics->iLeftAdjustInPixels = (chardim) croppedLeftAdjust;
|
|
sl@0
|
204 |
aCharacterMetrics->iMoveInPixels = (chardim) xMoveInPixels;
|
|
sl@0
|
205 |
aCharacterMetrics->iRightAdjustInPixels = (chardim) croppedRightAdjust;
|
|
sl@0
|
206 |
if (aCropped)
|
|
sl@0
|
207 |
{
|
|
sl@0
|
208 |
aCropped->iBottomCrop = bottomCrop;
|
|
sl@0
|
209 |
aCropped->iLeftCrop = leftCrop;
|
|
sl@0
|
210 |
aCropped->iRightCrop = rightCrop;
|
|
sl@0
|
211 |
aCropped->iTopCrop = topCrop;
|
|
sl@0
|
212 |
}
|
|
sl@0
|
213 |
}
|
|
sl@0
|
214 |
return state;
|
|
sl@0
|
215 |
}
|
|
sl@0
|
216 |
|
|
sl@0
|
217 |
boolean FontReader::ReadBDFCharacter(int /*aCode*/)
|
|
sl@0
|
218 |
{
|
|
sl@0
|
219 |
boolean state = etrue;
|
|
sl@0
|
220 |
ObjectList<String*> character;
|
|
sl@0
|
221 |
iCharacterMetrics = new CharacterMetrics;
|
|
sl@0
|
222 |
CroppedValues* croppedValues = new CroppedValues;
|
|
sl@0
|
223 |
|
|
sl@0
|
224 |
state = ReadMetricFromBDFCharacter(iCharacterMetrics, croppedValues);
|
|
sl@0
|
225 |
|
|
sl@0
|
226 |
if (state)
|
|
sl@0
|
227 |
{
|
|
sl@0
|
228 |
BitmapOffset* offset = new BitmapOffset((uint16)iCodeSection->iCharactersBitmap.iByteList.Length());
|
|
sl@0
|
229 |
|
|
sl@0
|
230 |
|
|
sl@0
|
231 |
iCodeSection->iCharactersBitmap.iByteList.NewByte();
|
|
sl@0
|
232 |
iCodeSection->iCharacters.iBitmapOffsetList.Add(offset);
|
|
sl@0
|
233 |
|
|
sl@0
|
234 |
int index = iFontBitmap->iCharacterMetrics->Index(*iCharacterMetrics);
|
|
sl@0
|
235 |
if (index == -1)
|
|
sl@0
|
236 |
{
|
|
sl@0
|
237 |
Error("Internal Compiler Error");
|
|
sl@0
|
238 |
state = 0;
|
|
sl@0
|
239 |
}
|
|
sl@0
|
240 |
delete iCharacterMetrics;
|
|
sl@0
|
241 |
|
|
sl@0
|
242 |
if (state)
|
|
sl@0
|
243 |
{
|
|
sl@0
|
244 |
iCodeSection->iCharactersBitmap.AddIndex(index);
|
|
sl@0
|
245 |
|
|
sl@0
|
246 |
int line = croppedValues->iTopCrop;
|
|
sl@0
|
247 |
boolean repeatLines;
|
|
sl@0
|
248 |
int countLines = 0;
|
|
sl@0
|
249 |
const int bottomCrop = croppedValues->iBottomCrop;
|
|
sl@0
|
250 |
while (line < (iBitmapHeight - bottomCrop))
|
|
sl@0
|
251 |
{
|
|
sl@0
|
252 |
if ((line + 1) == (iBitmapHeight - bottomCrop))
|
|
sl@0
|
253 |
{
|
|
sl@0
|
254 |
repeatLines = efalse;
|
|
sl@0
|
255 |
countLines = 1;
|
|
sl@0
|
256 |
}
|
|
sl@0
|
257 |
else if (!CompareBitmapLines(line, line + 1))
|
|
sl@0
|
258 |
{
|
|
sl@0
|
259 |
repeatLines = efalse;
|
|
sl@0
|
260 |
for (countLines = 2; ((line + countLines) < (iBitmapHeight - bottomCrop)) && (countLines < KMaxNumberRepeatedLines); countLines++)
|
|
sl@0
|
261 |
{
|
|
sl@0
|
262 |
if (CompareBitmapLines(line + countLines - 1, line + countLines))
|
|
sl@0
|
263 |
break;
|
|
sl@0
|
264 |
}
|
|
sl@0
|
265 |
}
|
|
sl@0
|
266 |
else
|
|
sl@0
|
267 |
{
|
|
sl@0
|
268 |
repeatLines = etrue;
|
|
sl@0
|
269 |
for (countLines = 2; ((line + countLines) < (iBitmapHeight - bottomCrop)) && (countLines < KMaxNumberRepeatedLines); countLines++)
|
|
sl@0
|
270 |
{
|
|
sl@0
|
271 |
if (!CompareBitmapLines(line, line + countLines))
|
|
sl@0
|
272 |
break;
|
|
sl@0
|
273 |
}
|
|
sl@0
|
274 |
}
|
|
sl@0
|
275 |
char bit;
|
|
sl@0
|
276 |
if (repeatLines)
|
|
sl@0
|
277 |
bit = 0;
|
|
sl@0
|
278 |
else
|
|
sl@0
|
279 |
bit = 1;
|
|
sl@0
|
280 |
iCodeSection->iCharactersBitmap.iByteList.AddBit(bit);
|
|
sl@0
|
281 |
for (int digit = 0; digit < 4; digit++)
|
|
sl@0
|
282 |
{
|
|
sl@0
|
283 |
bit = char(countLines >> digit);
|
|
sl@0
|
284 |
iCodeSection->iCharactersBitmap.iByteList.AddBit(bit);
|
|
sl@0
|
285 |
}
|
|
sl@0
|
286 |
int lineFromTop;
|
|
sl@0
|
287 |
for (lineFromTop = line; lineFromTop < (line + countLines); lineFromTop++)
|
|
sl@0
|
288 |
{
|
|
sl@0
|
289 |
if ((!repeatLines) || (lineFromTop == line))
|
|
sl@0
|
290 |
{
|
|
sl@0
|
291 |
int column;
|
|
sl@0
|
292 |
for (column = croppedValues->iLeftCrop;
|
|
sl@0
|
293 |
column < iBitmapWidth - croppedValues->iRightCrop; column++)
|
|
sl@0
|
294 |
{
|
|
sl@0
|
295 |
if (iBitArray[column][lineFromTop] == 1)
|
|
sl@0
|
296 |
bit = 1;
|
|
sl@0
|
297 |
else
|
|
sl@0
|
298 |
bit = 0;
|
|
sl@0
|
299 |
iCodeSection->iCharactersBitmap.iByteList.AddBit(bit);
|
|
sl@0
|
300 |
}
|
|
sl@0
|
301 |
}
|
|
sl@0
|
302 |
}
|
|
sl@0
|
303 |
line = line+countLines;
|
|
sl@0
|
304 |
}
|
|
sl@0
|
305 |
}
|
|
sl@0
|
306 |
}
|
|
sl@0
|
307 |
delete croppedValues;
|
|
sl@0
|
308 |
return state;
|
|
sl@0
|
309 |
}
|
|
sl@0
|
310 |
|
|
sl@0
|
311 |
boolean FontReader::ReadBDFChars(const int aNumberOfGlyphsInFile, const int aMaxConsecutiveFillChars)
|
|
sl@0
|
312 |
{
|
|
sl@0
|
313 |
boolean state = etrue;
|
|
sl@0
|
314 |
boolean newCodeSection = etrue;
|
|
sl@0
|
315 |
int currentEncodingValue = 0; // each glyph has an unique encoding value
|
|
sl@0
|
316 |
int lastEncodingValue = KMarkFirstCharacterInTypeface;
|
|
sl@0
|
317 |
const int maxCharacterBitmapsize =
|
|
sl@0
|
318 |
((KMaxBitmapWidth * KMaxBitmapHeight) / KNumberOfBitsInByte) + KBytesAddedForMetricIndex + KBytesForIndexForFillCharacters;
|
|
sl@0
|
319 |
|
|
sl@0
|
320 |
iCodeSection = NULL;
|
|
sl@0
|
321 |
for (int numberGlyphsRead = 0; state && numberGlyphsRead < aNumberOfGlyphsInFile && !_EOF(); numberGlyphsRead++)
|
|
sl@0
|
322 |
{
|
|
sl@0
|
323 |
if (state && iCodeSection && iCodeSection->iCharactersBitmap.iByteList.Length() + maxCharacterBitmapsize >= KMaxSizeCodeSectionBitmap)
|
|
sl@0
|
324 |
{
|
|
sl@0
|
325 |
newCodeSection = etrue;
|
|
sl@0
|
326 |
}
|
|
sl@0
|
327 |
|
|
sl@0
|
328 |
state = IdentComp(IdentBDFCharLabel);
|
|
sl@0
|
329 |
if (!state)
|
|
sl@0
|
330 |
ErrorIdentifierExpected(IdentBDFCharLabel);
|
|
sl@0
|
331 |
if (state)
|
|
sl@0
|
332 |
iLexAnal->ReadNextLine(); // Skip to next line
|
|
sl@0
|
333 |
|
|
sl@0
|
334 |
if (IdentComp(IdentBDFChar))
|
|
sl@0
|
335 |
{
|
|
sl@0
|
336 |
state = Number(currentEncodingValue);
|
|
sl@0
|
337 |
}
|
|
sl@0
|
338 |
else
|
|
sl@0
|
339 |
{
|
|
sl@0
|
340 |
state = efalse;
|
|
sl@0
|
341 |
ErrorIdentifierExpected(IdentBDFChar);
|
|
sl@0
|
342 |
}
|
|
sl@0
|
343 |
|
|
sl@0
|
344 |
if (KLowestPermittedCharacterEncoding > currentEncodingValue ||
|
|
sl@0
|
345 |
KHighestPermittedCharacterEncoding < currentEncodingValue)
|
|
sl@0
|
346 |
{
|
|
sl@0
|
347 |
while (!IdentComp(IdentBDFEndChar) && !_EOF() && state)
|
|
sl@0
|
348 |
// Skip fill character.
|
|
sl@0
|
349 |
{
|
|
sl@0
|
350 |
iLexAnal->ReadNextLine(); // Skip to next line
|
|
sl@0
|
351 |
}
|
|
sl@0
|
352 |
iLexAnal->ReadNextLine();
|
|
sl@0
|
353 |
continue;
|
|
sl@0
|
354 |
}
|
|
sl@0
|
355 |
|
|
sl@0
|
356 |
if (!iCodeSection || state && (currentEncodingValue > (lastEncodingValue + 1 + aMaxConsecutiveFillChars)))
|
|
sl@0
|
357 |
{
|
|
sl@0
|
358 |
// First character skip to new code section
|
|
sl@0
|
359 |
newCodeSection = etrue;
|
|
sl@0
|
360 |
}
|
|
sl@0
|
361 |
else if (state && !newCodeSection && (currentEncodingValue > lastEncodingValue + 1))
|
|
sl@0
|
362 |
{
|
|
sl@0
|
363 |
WriteFillCharacters(currentEncodingValue - (lastEncodingValue + 1));
|
|
sl@0
|
364 |
}
|
|
sl@0
|
365 |
else if (state && currentEncodingValue <= lastEncodingValue)
|
|
sl@0
|
366 |
{
|
|
sl@0
|
367 |
Error("CodeSection out of sequence");
|
|
sl@0
|
368 |
state = efalse;
|
|
sl@0
|
369 |
}
|
|
sl@0
|
370 |
|
|
sl@0
|
371 |
if (state && newCodeSection)
|
|
sl@0
|
372 |
{
|
|
sl@0
|
373 |
if (iCodeSection)
|
|
sl@0
|
374 |
{
|
|
sl@0
|
375 |
iCodeSection->iEnd = (uint16) lastEncodingValue;
|
|
sl@0
|
376 |
iFontBitmap->iCodeSectionList.Add(iCodeSection);
|
|
sl@0
|
377 |
PrintoutCodeSection(iCodeSection);
|
|
sl@0
|
378 |
}
|
|
sl@0
|
379 |
iCodeSection = new BitmapCodeSection;
|
|
sl@0
|
380 |
iCodeSection->iStart = (uint16) currentEncodingValue;
|
|
sl@0
|
381 |
}
|
|
sl@0
|
382 |
|
|
sl@0
|
383 |
if (state)
|
|
sl@0
|
384 |
state = ReadBDFCharacter(currentEncodingValue);
|
|
sl@0
|
385 |
|
|
sl@0
|
386 |
newCodeSection = efalse;
|
|
sl@0
|
387 |
lastEncodingValue = currentEncodingValue;
|
|
sl@0
|
388 |
}
|
|
sl@0
|
389 |
|
|
sl@0
|
390 |
if (state)
|
|
sl@0
|
391 |
{
|
|
sl@0
|
392 |
iCodeSection->iEnd = (uint16) lastEncodingValue;
|
|
sl@0
|
393 |
iFontBitmap->iCodeSectionList.Add(iCodeSection);
|
|
sl@0
|
394 |
PrintoutCodeSection(iCodeSection);
|
|
sl@0
|
395 |
}
|
|
sl@0
|
396 |
|
|
sl@0
|
397 |
return state;
|
|
sl@0
|
398 |
}
|
|
sl@0
|
399 |
|
|
sl@0
|
400 |
void FontReader::PrintoutCodeSection(const BitmapCodeSection* aCodeSection) const
|
|
sl@0
|
401 |
{
|
|
sl@0
|
402 |
cout << hex << "Codesection 0x" << aCodeSection->iStart << ": 0x" << aCodeSection->iEnd << " read" << endl;
|
|
sl@0
|
403 |
cout.flush();
|
|
sl@0
|
404 |
}
|
|
sl@0
|
405 |
|
|
sl@0
|
406 |
boolean FontReader::ReadBDFFontBitmap()
|
|
sl@0
|
407 |
{
|
|
sl@0
|
408 |
boolean state = etrue;
|
|
sl@0
|
409 |
String label;
|
|
sl@0
|
410 |
iFontBitmap = new FontBitmap;
|
|
sl@0
|
411 |
int pointSize;
|
|
sl@0
|
412 |
int xresolution; // in dots per inch
|
|
sl@0
|
413 |
int yresolution; // in dots per inch
|
|
sl@0
|
414 |
int widthBoundingBox = 0; // In pixels
|
|
sl@0
|
415 |
int heightBoundingBox = 0; // in pixels
|
|
sl@0
|
416 |
int boundingBoxXOffset = 0; // From origin (cursor position at baseline)
|
|
sl@0
|
417 |
int boundingBoxYOffset = 0; // From origin (cursor position at baseline)
|
|
sl@0
|
418 |
int numberChars = 0;
|
|
sl@0
|
419 |
String fontLabel;
|
|
sl@0
|
420 |
int maxNormalCharWidth = KUndefinedInteger;
|
|
sl@0
|
421 |
uid fontUid = KNullUid;
|
|
sl@0
|
422 |
int posture = PostureUpright;
|
|
sl@0
|
423 |
int strokeWeight = StrokeWeightNormal;
|
|
sl@0
|
424 |
int defaultXMoveInPixels = KUndefinedInteger;
|
|
sl@0
|
425 |
int defaultYMoveInPixels = KUndefinedInteger;
|
|
sl@0
|
426 |
int writingDirection = 0;
|
|
sl@0
|
427 |
int maxConsecutiveFillChars = 0; // Max permitted "fill" characters with zero size to prevent
|
|
sl@0
|
428 |
// break between code sections.
|
|
sl@0
|
429 |
int fontAscent = 0;
|
|
sl@0
|
430 |
int fontDescent = 0;
|
|
sl@0
|
431 |
|
|
sl@0
|
432 |
while (!IdentComp(IdentBDFNumChars) && !_EOF() && state)
|
|
sl@0
|
433 |
{
|
|
sl@0
|
434 |
iLexAnal->ReadNextLine(); // Skip to next line
|
|
sl@0
|
435 |
if (iLex->iType == ELexIdent)
|
|
sl@0
|
436 |
{
|
|
sl@0
|
437 |
if (IdentComp(IdentBDFFontBitmap))
|
|
sl@0
|
438 |
{
|
|
sl@0
|
439 |
state = IdentCopy(fontLabel);
|
|
sl@0
|
440 |
}
|
|
sl@0
|
441 |
if (IdentComp(IdentBDFPointSize))
|
|
sl@0
|
442 |
{
|
|
sl@0
|
443 |
state = Number(pointSize);
|
|
sl@0
|
444 |
if (state)
|
|
sl@0
|
445 |
state = Number(xresolution);
|
|
sl@0
|
446 |
if (state)
|
|
sl@0
|
447 |
state = Number(yresolution);
|
|
sl@0
|
448 |
}
|
|
sl@0
|
449 |
else if (IdentComp(IdentBDFFontDesignBox))
|
|
sl@0
|
450 |
{
|
|
sl@0
|
451 |
state = Number(widthBoundingBox);
|
|
sl@0
|
452 |
if (state)
|
|
sl@0
|
453 |
state = Number(heightBoundingBox);
|
|
sl@0
|
454 |
if (state)
|
|
sl@0
|
455 |
state = Number(boundingBoxXOffset);
|
|
sl@0
|
456 |
if (state)
|
|
sl@0
|
457 |
state = Number(boundingBoxYOffset);
|
|
sl@0
|
458 |
}
|
|
sl@0
|
459 |
else if (IdentComp(IdentBDFWritingDirection))
|
|
sl@0
|
460 |
{
|
|
sl@0
|
461 |
Number(writingDirection);
|
|
sl@0
|
462 |
if (writingDirection != 0)
|
|
sl@0
|
463 |
cout << "Warning: Only left to right writing direction supported by EPOC32";
|
|
sl@0
|
464 |
}
|
|
sl@0
|
465 |
else if (IdentComp(IdentBDFCursorMove))
|
|
sl@0
|
466 |
{
|
|
sl@0
|
467 |
state = Number(defaultXMoveInPixels);
|
|
sl@0
|
468 |
if (state)
|
|
sl@0
|
469 |
state = Number(defaultYMoveInPixels);
|
|
sl@0
|
470 |
}
|
|
sl@0
|
471 |
else if (IdentComp(IdentBDFStartProperties)) // Adding additional properties
|
|
sl@0
|
472 |
{
|
|
sl@0
|
473 |
int numberOfProperties;
|
|
sl@0
|
474 |
state = Number(numberOfProperties);
|
|
sl@0
|
475 |
if (state)
|
|
sl@0
|
476 |
state = NewLine();
|
|
sl@0
|
477 |
{for (int properties = 0; properties < numberOfProperties && !_EOF() && state; properties++)
|
|
sl@0
|
478 |
{
|
|
sl@0
|
479 |
if (IdentComp(IdentBDFPropertyUid) || IdentComp(IdentUid))
|
|
sl@0
|
480 |
state = Number(fontUid);
|
|
sl@0
|
481 |
else if (IdentComp(IdentBDFPropertyBold) || IdentComp(IdentBold))
|
|
sl@0
|
482 |
state = Number(strokeWeight);
|
|
sl@0
|
483 |
else if (IdentComp(IdentBDFPropertyItalic) || IdentComp(IdentItalic))
|
|
sl@0
|
484 |
state = Number(posture);
|
|
sl@0
|
485 |
else if (IdentComp(IdentBDFPropertyFontAscent))
|
|
sl@0
|
486 |
state = Number(fontAscent);
|
|
sl@0
|
487 |
else if (IdentComp(IdentBDFPropertyFontDescent))
|
|
sl@0
|
488 |
state = Number(fontDescent);
|
|
sl@0
|
489 |
else if (IdentComp(IdentBDFPropertyMaxNormalCharWidth) || IdentComp(IdentMaxNormalCharWidth))
|
|
sl@0
|
490 |
state = Number(maxNormalCharWidth);
|
|
sl@0
|
491 |
else if (IdentComp(IdentBDFPropertyMaxConsecutiveFillChars) || IdentComp(IdentMaxConsecutiveFillChars))
|
|
sl@0
|
492 |
state = Number(maxConsecutiveFillChars);
|
|
sl@0
|
493 |
|
|
sl@0
|
494 |
iLexAnal->ReadNextLine(); // Skip to next line
|
|
sl@0
|
495 |
}
|
|
sl@0
|
496 |
}
|
|
sl@0
|
497 |
if (state)
|
|
sl@0
|
498 |
{
|
|
sl@0
|
499 |
state = IdentComp(IdentBDFEndProperties);
|
|
sl@0
|
500 |
if (!state)
|
|
sl@0
|
501 |
ErrorIdentifierExpected(IdentBDFEndProperties);
|
|
sl@0
|
502 |
}
|
|
sl@0
|
503 |
}
|
|
sl@0
|
504 |
|
|
sl@0
|
505 |
}
|
|
sl@0
|
506 |
else
|
|
sl@0
|
507 |
{
|
|
sl@0
|
508 |
Error("Identifier expected");
|
|
sl@0
|
509 |
state = efalse;
|
|
sl@0
|
510 |
}
|
|
sl@0
|
511 |
}
|
|
sl@0
|
512 |
//
|
|
sl@0
|
513 |
// Check that maximum size of bitmap glyph not exceeded.
|
|
sl@0
|
514 |
//
|
|
sl@0
|
515 |
if (widthBoundingBox>KMaxBitmapWidth || widthBoundingBox>KMaxBitmapWidth)
|
|
sl@0
|
516 |
{
|
|
sl@0
|
517 |
state = efalse;
|
|
sl@0
|
518 |
cout << "Error: A font bounding box dimension exceeds maximum permitted in EPOC32";
|
|
sl@0
|
519 |
}
|
|
sl@0
|
520 |
|
|
sl@0
|
521 |
// Check that have everthing that we need and set some bitmap properties.
|
|
sl@0
|
522 |
|
|
sl@0
|
523 |
iFontBitmap->iMaxCharWidthInPixels = (chardim) widthBoundingBox;
|
|
sl@0
|
524 |
if (fontAscent + fontDescent)
|
|
sl@0
|
525 |
{
|
|
sl@0
|
526 |
iFontBitmap->iCellHeightInPixels =( chardim) (fontAscent+fontDescent);
|
|
sl@0
|
527 |
iFontBitmap->iAscentInPixels = (chardim) (fontAscent);
|
|
sl@0
|
528 |
}
|
|
sl@0
|
529 |
else
|
|
sl@0
|
530 |
{ // Old file so use the old calculation
|
|
sl@0
|
531 |
iFontBitmap->iCellHeightInPixels =( chardim) heightBoundingBox;
|
|
sl@0
|
532 |
iFontBitmap->iAscentInPixels = (chardim) (heightBoundingBox + boundingBoxYOffset);
|
|
sl@0
|
533 |
}
|
|
sl@0
|
534 |
iFontBitmap->iPosture = (boolean) posture;
|
|
sl@0
|
535 |
iFontBitmap->iStrokeWeight =( boolean) strokeWeight;
|
|
sl@0
|
536 |
iFontBitmap->iLabel = fontLabel;
|
|
sl@0
|
537 |
|
|
sl@0
|
538 |
iDefaultXMoveInPixels = defaultXMoveInPixels;
|
|
sl@0
|
539 |
iDefaultYMoveInPixels = defaultYMoveInPixels;
|
|
sl@0
|
540 |
|
|
sl@0
|
541 |
if (fontUid != KNullUid)
|
|
sl@0
|
542 |
iFontBitmap->iUid = fontUid;
|
|
sl@0
|
543 |
else
|
|
sl@0
|
544 |
{
|
|
sl@0
|
545 |
cerr << "Warning: No font bitmap UID specified in properties\n";
|
|
sl@0
|
546 |
iFontBitmap->iUid = rand();
|
|
sl@0
|
547 |
}
|
|
sl@0
|
548 |
|
|
sl@0
|
549 |
if (maxNormalCharWidth != KUndefinedInteger)
|
|
sl@0
|
550 |
iFontBitmap->iMaxNormalCharWidthInPixels = (chardim) maxNormalCharWidth;
|
|
sl@0
|
551 |
else
|
|
sl@0
|
552 |
{
|
|
sl@0
|
553 |
cerr << "Warning: No Maximum Normal Character Width specified in properties\n";
|
|
sl@0
|
554 |
iFontBitmap->iMaxNormalCharWidthInPixels = iFontBitmap->iMaxCharWidthInPixels;
|
|
sl@0
|
555 |
}
|
|
sl@0
|
556 |
|
|
sl@0
|
557 |
if (state)
|
|
sl@0
|
558 |
state = Number(numberChars);
|
|
sl@0
|
559 |
if (state)
|
|
sl@0
|
560 |
state = NewLine();
|
|
sl@0
|
561 |
else
|
|
sl@0
|
562 |
return state;
|
|
sl@0
|
563 |
|
|
sl@0
|
564 |
// store position of Lex here and then set it back for the reading of the BDF chars!
|
|
sl@0
|
565 |
int saveLineNo = iLexAnal->iLineNo;
|
|
sl@0
|
566 |
|
|
sl@0
|
567 |
ParseMetricsFromBDF(numberChars, maxConsecutiveFillChars);
|
|
sl@0
|
568 |
// now reset the lexical
|
|
sl@0
|
569 |
state = Open(iFileName.Text());
|
|
sl@0
|
570 |
do
|
|
sl@0
|
571 |
{
|
|
sl@0
|
572 |
iLexAnal->Read();
|
|
sl@0
|
573 |
}
|
|
sl@0
|
574 |
while(saveLineNo > iLexAnal->iLineNo);
|
|
sl@0
|
575 |
|
|
sl@0
|
576 |
ReadBDFChars(numberChars, maxConsecutiveFillChars);
|
|
sl@0
|
577 |
|
|
sl@0
|
578 |
if (state)
|
|
sl@0
|
579 |
{
|
|
sl@0
|
580 |
state = IdentComp(IdentBDFEndFontBitmap);
|
|
sl@0
|
581 |
if (!state)
|
|
sl@0
|
582 |
Error("ENDFONT identifier expected");
|
|
sl@0
|
583 |
}
|
|
sl@0
|
584 |
|
|
sl@0
|
585 |
int globalMove = KUndefinedInteger;
|
|
sl@0
|
586 |
int monospaced= etrue;
|
|
sl@0
|
587 |
if (state)
|
|
sl@0
|
588 |
{
|
|
sl@0
|
589 |
for (int i = 0; i <iFontBitmap->iCodeSectionList.Size(); i++)
|
|
sl@0
|
590 |
{
|
|
sl@0
|
591 |
const int end = iFontBitmap->iCharacterMetrics->iCharacterMetricsList.Size();
|
|
sl@0
|
592 |
for (int j = 0; j< end; j++)
|
|
sl@0
|
593 |
{
|
|
sl@0
|
594 |
int move = iFontBitmap->iCharacterMetrics->iCharacterMetricsList[j]->Metric()->iMoveInPixels;
|
|
sl@0
|
595 |
if (globalMove == KUndefinedInteger)
|
|
sl@0
|
596 |
globalMove = move;
|
|
sl@0
|
597 |
if (move > iFontBitmap->iMaxCharWidthInPixels)
|
|
sl@0
|
598 |
iFontBitmap->iMaxCharWidthInPixels = (chardim) move;
|
|
sl@0
|
599 |
if (globalMove!= move)
|
|
sl@0
|
600 |
monospaced = efalse;
|
|
sl@0
|
601 |
}
|
|
sl@0
|
602 |
}
|
|
sl@0
|
603 |
}
|
|
sl@0
|
604 |
if (monospaced)
|
|
sl@0
|
605 |
iFontBitmap->iIsProportional = efalse;
|
|
sl@0
|
606 |
else
|
|
sl@0
|
607 |
iFontBitmap->iIsProportional = etrue;
|
|
sl@0
|
608 |
|
|
sl@0
|
609 |
if (state)
|
|
sl@0
|
610 |
{
|
|
sl@0
|
611 |
iFontStore.AddFontBitmap(iFontBitmap);
|
|
sl@0
|
612 |
cout << "FONT read\n";
|
|
sl@0
|
613 |
}
|
|
sl@0
|
614 |
else
|
|
sl@0
|
615 |
delete iFontBitmap;
|
|
sl@0
|
616 |
return state;
|
|
sl@0
|
617 |
}
|
|
sl@0
|
618 |
|
|
sl@0
|
619 |
boolean FontReader::ReadTypeface()
|
|
sl@0
|
620 |
{
|
|
sl@0
|
621 |
boolean state = etrue;
|
|
sl@0
|
622 |
iTypeface = new FntTypeface;
|
|
sl@0
|
623 |
String label;
|
|
sl@0
|
624 |
int num;
|
|
sl@0
|
625 |
state = IdentCopy(iTypeface->iLabel);
|
|
sl@0
|
626 |
if (state)
|
|
sl@0
|
627 |
state = NewLine();
|
|
sl@0
|
628 |
while (!IdentComp(IdentEndTypeface) && !_EOF() && state)
|
|
sl@0
|
629 |
{
|
|
sl@0
|
630 |
if (IdentComp(IdentName))
|
|
sl@0
|
631 |
{
|
|
sl@0
|
632 |
state = StringCopy(iTypeface->iName);
|
|
sl@0
|
633 |
while ((iLex->iType != ELexNL) && !_EOF() && state)
|
|
sl@0
|
634 |
{
|
|
sl@0
|
635 |
if (IdentComp(IdentTypefaceProportional))
|
|
sl@0
|
636 |
iTypeface->iFlags = (boolean) (iTypeface->iFlags | Proportional);
|
|
sl@0
|
637 |
else if (IdentComp(IdentSerif))
|
|
sl@0
|
638 |
iTypeface->iFlags = (boolean) (iTypeface->iFlags | Serif);
|
|
sl@0
|
639 |
else if (IdentComp(IdentSymbol))
|
|
sl@0
|
640 |
iTypeface->iFlags = (boolean) (iTypeface->iFlags | Symbol);
|
|
sl@0
|
641 |
else
|
|
sl@0
|
642 |
{
|
|
sl@0
|
643 |
Error("Typeface identifier or newline expected");
|
|
sl@0
|
644 |
state = efalse;
|
|
sl@0
|
645 |
}
|
|
sl@0
|
646 |
}
|
|
sl@0
|
647 |
}
|
|
sl@0
|
648 |
else if (IdentComp(IdentFontBitmaps))
|
|
sl@0
|
649 |
{
|
|
sl@0
|
650 |
state = NewLine();
|
|
sl@0
|
651 |
while (!IdentComp(IdentEndFontBitmaps) && !_EOF() && state)
|
|
sl@0
|
652 |
{
|
|
sl@0
|
653 |
TypefaceFontBitmap* typefacefontbitmap = NULL;
|
|
sl@0
|
654 |
if (iLex->iType == ELexIdent)
|
|
sl@0
|
655 |
{
|
|
sl@0
|
656 |
state = IdentCopy(label);
|
|
sl@0
|
657 |
FontBitmap* fontbitmap = (FontBitmap*) iFontStore.FindFontBitmap(label);
|
|
sl@0
|
658 |
if (fontbitmap)
|
|
sl@0
|
659 |
{
|
|
sl@0
|
660 |
typefacefontbitmap = new TypefaceFontBitmap(fontbitmap);
|
|
sl@0
|
661 |
state = etrue;
|
|
sl@0
|
662 |
}
|
|
sl@0
|
663 |
else
|
|
sl@0
|
664 |
{
|
|
sl@0
|
665 |
Error("Fontbitmap not found");
|
|
sl@0
|
666 |
state = efalse;
|
|
sl@0
|
667 |
}
|
|
sl@0
|
668 |
}
|
|
sl@0
|
669 |
else
|
|
sl@0
|
670 |
{
|
|
sl@0
|
671 |
uid fontbitmapuid;
|
|
sl@0
|
672 |
state = Number(fontbitmapuid);
|
|
sl@0
|
673 |
if (state)
|
|
sl@0
|
674 |
typefacefontbitmap = new TypefaceFontBitmap(fontbitmapuid);
|
|
sl@0
|
675 |
}
|
|
sl@0
|
676 |
if (state)
|
|
sl@0
|
677 |
{
|
|
sl@0
|
678 |
while ((iLex->iType != ELexNL) && !_EOF() && state)
|
|
sl@0
|
679 |
{
|
|
sl@0
|
680 |
if (IdentComp(IdentWidthFactor))
|
|
sl@0
|
681 |
{
|
|
sl@0
|
682 |
state = Number(num);
|
|
sl@0
|
683 |
typefacefontbitmap->iWidthFactor = (char) num;
|
|
sl@0
|
684 |
}
|
|
sl@0
|
685 |
else if (IdentComp(IdentHeightFactor))
|
|
sl@0
|
686 |
{
|
|
sl@0
|
687 |
state = Number(num);
|
|
sl@0
|
688 |
typefacefontbitmap->iHeightFactor =( char) num;
|
|
sl@0
|
689 |
}
|
|
sl@0
|
690 |
else
|
|
sl@0
|
691 |
{
|
|
sl@0
|
692 |
Error("Typefacefontbitmap identifier or newline expected");
|
|
sl@0
|
693 |
state = efalse;
|
|
sl@0
|
694 |
}
|
|
sl@0
|
695 |
}
|
|
sl@0
|
696 |
if (state)
|
|
sl@0
|
697 |
iTypeface->iTypefaceFontBitmapList.Add(typefacefontbitmap);
|
|
sl@0
|
698 |
else
|
|
sl@0
|
699 |
delete typefacefontbitmap;
|
|
sl@0
|
700 |
}
|
|
sl@0
|
701 |
if (state)
|
|
sl@0
|
702 |
state = NewLine();
|
|
sl@0
|
703 |
}
|
|
sl@0
|
704 |
}
|
|
sl@0
|
705 |
else
|
|
sl@0
|
706 |
{
|
|
sl@0
|
707 |
Error("Typeface identifier expected");
|
|
sl@0
|
708 |
state = efalse;
|
|
sl@0
|
709 |
}
|
|
sl@0
|
710 |
if (state)
|
|
sl@0
|
711 |
state = NewLine();
|
|
sl@0
|
712 |
}
|
|
sl@0
|
713 |
if (state)
|
|
sl@0
|
714 |
{
|
|
sl@0
|
715 |
iFontStore.AddTypeface(iTypeface);
|
|
sl@0
|
716 |
cout << "Typeface read\n";
|
|
sl@0
|
717 |
}
|
|
sl@0
|
718 |
else
|
|
sl@0
|
719 |
delete iTypeface;
|
|
sl@0
|
720 |
return state;
|
|
sl@0
|
721 |
}
|
|
sl@0
|
722 |
|
|
sl@0
|
723 |
boolean FontReader::ReadFontStoreFile()
|
|
sl@0
|
724 |
{
|
|
sl@0
|
725 |
boolean state = etrue;
|
|
sl@0
|
726 |
int num;
|
|
sl@0
|
727 |
if (iFontStoreFile)
|
|
sl@0
|
728 |
{
|
|
sl@0
|
729 |
state = efalse;
|
|
sl@0
|
730 |
Error("Fontstorefile already read");
|
|
sl@0
|
731 |
}
|
|
sl@0
|
732 |
else
|
|
sl@0
|
733 |
{
|
|
sl@0
|
734 |
iFontStoreFile = new FontStoreFile;
|
|
sl@0
|
735 |
String label;
|
|
sl@0
|
736 |
Record* typeface;
|
|
sl@0
|
737 |
state = NewLine();
|
|
sl@0
|
738 |
while (!IdentComp(IdentEndFontStoreFile) && !_EOF() && state)
|
|
sl@0
|
739 |
{
|
|
sl@0
|
740 |
if (IdentComp(IdentCollectionUid))
|
|
sl@0
|
741 |
{
|
|
sl@0
|
742 |
state = Number(iFontStoreFile->iCollectionUid);
|
|
sl@0
|
743 |
}
|
|
sl@0
|
744 |
else if (IdentComp(IdentKPixelAspectRatio))
|
|
sl@0
|
745 |
{
|
|
sl@0
|
746 |
state = Number(num);
|
|
sl@0
|
747 |
if (state)
|
|
sl@0
|
748 |
iFontStoreFile->iKPixelAspectRatio = num;
|
|
sl@0
|
749 |
}
|
|
sl@0
|
750 |
else if (IdentComp(IdentCopyrightInfo))
|
|
sl@0
|
751 |
{
|
|
sl@0
|
752 |
state = NewLine();
|
|
sl@0
|
753 |
while (!IdentComp(IdentEndCopyrightInfo) && !_EOF() && state)
|
|
sl@0
|
754 |
{
|
|
sl@0
|
755 |
String* string = new String;
|
|
sl@0
|
756 |
state = StringCopy(*string);
|
|
sl@0
|
757 |
if (state)
|
|
sl@0
|
758 |
iFontStoreFile->iCopyrightInfo.Add(string);
|
|
sl@0
|
759 |
else
|
|
sl@0
|
760 |
delete string;
|
|
sl@0
|
761 |
state = NewLine();
|
|
sl@0
|
762 |
}
|
|
sl@0
|
763 |
}
|
|
sl@0
|
764 |
else if (IdentComp(IdentTypefaces))
|
|
sl@0
|
765 |
{
|
|
sl@0
|
766 |
state = NewLine();
|
|
sl@0
|
767 |
while (!IdentComp(IdentEndTypefaces) && !_EOF() && state)
|
|
sl@0
|
768 |
{
|
|
sl@0
|
769 |
state =IdentCopy(label);
|
|
sl@0
|
770 |
if (state)
|
|
sl@0
|
771 |
{
|
|
sl@0
|
772 |
typeface = iFontStore.FindTypeface(label);
|
|
sl@0
|
773 |
if (typeface)
|
|
sl@0
|
774 |
{
|
|
sl@0
|
775 |
iFontStoreFile->AddTypeface((FntTypeface*) typeface);
|
|
sl@0
|
776 |
}
|
|
sl@0
|
777 |
else
|
|
sl@0
|
778 |
{
|
|
sl@0
|
779 |
Error("Typeface not found");
|
|
sl@0
|
780 |
state = efalse;
|
|
sl@0
|
781 |
}
|
|
sl@0
|
782 |
}
|
|
sl@0
|
783 |
if (state)
|
|
sl@0
|
784 |
state = NewLine();
|
|
sl@0
|
785 |
}
|
|
sl@0
|
786 |
}
|
|
sl@0
|
787 |
else if (IdentComp(IdentExtraFontBitmaps))
|
|
sl@0
|
788 |
{
|
|
sl@0
|
789 |
state = NewLine();
|
|
sl@0
|
790 |
while (!IdentComp(IdentEndExtraFontBitmaps) && !_EOF() && state)
|
|
sl@0
|
791 |
{
|
|
sl@0
|
792 |
state = IdentCopy(label);
|
|
sl@0
|
793 |
FontBitmap* fontbitmap = (FontBitmap*) iFontStore.FindFontBitmap(label);
|
|
sl@0
|
794 |
if (fontbitmap)
|
|
sl@0
|
795 |
{
|
|
sl@0
|
796 |
iFontStoreFile->AddFontBitmap((FontBitmap*) fontbitmap);
|
|
sl@0
|
797 |
}
|
|
sl@0
|
798 |
else
|
|
sl@0
|
799 |
{
|
|
sl@0
|
800 |
Error("Fontbitmap not found");
|
|
sl@0
|
801 |
state = efalse;
|
|
sl@0
|
802 |
}
|
|
sl@0
|
803 |
if (state)
|
|
sl@0
|
804 |
state = NewLine();
|
|
sl@0
|
805 |
}
|
|
sl@0
|
806 |
}
|
|
sl@0
|
807 |
else
|
|
sl@0
|
808 |
{
|
|
sl@0
|
809 |
Error("Fontstorefile identifier expected");
|
|
sl@0
|
810 |
state = efalse;
|
|
sl@0
|
811 |
}
|
|
sl@0
|
812 |
if (state)
|
|
sl@0
|
813 |
state = NewLine();
|
|
sl@0
|
814 |
}
|
|
sl@0
|
815 |
if (state)
|
|
sl@0
|
816 |
{
|
|
sl@0
|
817 |
iFontStore.AddFontStoreFile(iFontStoreFile);
|
|
sl@0
|
818 |
cout << "Fontstorefile read\n";
|
|
sl@0
|
819 |
}
|
|
sl@0
|
820 |
else
|
|
sl@0
|
821 |
delete iFontStoreFile;
|
|
sl@0
|
822 |
}
|
|
sl@0
|
823 |
return state;
|
|
sl@0
|
824 |
}
|
|
sl@0
|
825 |
|
|
sl@0
|
826 |
int FontReader::Store(const String& aFilename)
|
|
sl@0
|
827 |
{
|
|
sl@0
|
828 |
boolean state = etrue;
|
|
sl@0
|
829 |
if (!iFontStoreFile)
|
|
sl@0
|
830 |
{
|
|
sl@0
|
831 |
state = efalse;
|
|
sl@0
|
832 |
Error("No fontstore file record");
|
|
sl@0
|
833 |
}
|
|
sl@0
|
834 |
else
|
|
sl@0
|
835 |
state = iFontStore.Store(aFilename);
|
|
sl@0
|
836 |
return state;
|
|
sl@0
|
837 |
}
|
|
sl@0
|
838 |
|
|
sl@0
|
839 |
boolean FontReader::CharLine(String& aCharLine)
|
|
sl@0
|
840 |
{
|
|
sl@0
|
841 |
boolean state = etrue;
|
|
sl@0
|
842 |
while (state && (iLex->iType != ELexNL))
|
|
sl@0
|
843 |
{
|
|
sl@0
|
844 |
char ch;
|
|
sl@0
|
845 |
state = Operator(ch);
|
|
sl@0
|
846 |
if (state)
|
|
sl@0
|
847 |
{
|
|
sl@0
|
848 |
if ((ch == '.') || (ch == '*'))
|
|
sl@0
|
849 |
aCharLine += ch;
|
|
sl@0
|
850 |
else
|
|
sl@0
|
851 |
{
|
|
sl@0
|
852 |
state = efalse;
|
|
sl@0
|
853 |
Error("Operator '.' or '*' expected");
|
|
sl@0
|
854 |
}
|
|
sl@0
|
855 |
}
|
|
sl@0
|
856 |
}
|
|
sl@0
|
857 |
return state;
|
|
sl@0
|
858 |
}
|
|
sl@0
|
859 |
|
|
sl@0
|
860 |
void FontReader::ErrorIdentifierExpected(const String& aIdentifier)
|
|
sl@0
|
861 |
{
|
|
sl@0
|
862 |
cerr << "Error: Identifier Expected " << aIdentifier;
|
|
sl@0
|
863 |
iLexAnal->Report();
|
|
sl@0
|
864 |
while ((iLex->iType != ELexNL) && (iLex->iType != ELexEOF))
|
|
sl@0
|
865 |
iLexAnal->Read();
|
|
sl@0
|
866 |
}
|
|
sl@0
|
867 |
|
|
sl@0
|
868 |
boolean FontReader::CompareBitmapLines(int aLine1, int aLine2)
|
|
sl@0
|
869 |
{
|
|
sl@0
|
870 |
|
|
sl@0
|
871 |
int column = 0;
|
|
sl@0
|
872 |
boolean identical = etrue;
|
|
sl@0
|
873 |
for (column=0; column < iBitmapWidth; column++)
|
|
sl@0
|
874 |
{
|
|
sl@0
|
875 |
if (iBitArray[column][aLine1] != iBitArray[column][aLine2])
|
|
sl@0
|
876 |
{
|
|
sl@0
|
877 |
identical = efalse;
|
|
sl@0
|
878 |
break;
|
|
sl@0
|
879 |
}
|
|
sl@0
|
880 |
}
|
|
sl@0
|
881 |
|
|
sl@0
|
882 |
return identical;
|
|
sl@0
|
883 |
}
|
|
sl@0
|
884 |
|
|
sl@0
|
885 |
boolean FontReader::BitmapLineEmpty(int aLine)
|
|
sl@0
|
886 |
{
|
|
sl@0
|
887 |
|
|
sl@0
|
888 |
int column = 0;
|
|
sl@0
|
889 |
boolean empty = etrue;
|
|
sl@0
|
890 |
for (column = 0; column < iBitmapWidth; column++)
|
|
sl@0
|
891 |
{
|
|
sl@0
|
892 |
if (iBitArray[column][aLine] != 0)
|
|
sl@0
|
893 |
{
|
|
sl@0
|
894 |
empty = efalse;
|
|
sl@0
|
895 |
break;
|
|
sl@0
|
896 |
}
|
|
sl@0
|
897 |
}
|
|
sl@0
|
898 |
|
|
sl@0
|
899 |
return empty;
|
|
sl@0
|
900 |
}
|
|
sl@0
|
901 |
|
|
sl@0
|
902 |
boolean FontReader::BitmapColumnEmpty(int aColumn)
|
|
sl@0
|
903 |
{
|
|
sl@0
|
904 |
|
|
sl@0
|
905 |
int line = 0;
|
|
sl@0
|
906 |
boolean empty = etrue;
|
|
sl@0
|
907 |
for (line = 0; line < iBitmapHeight; line++)
|
|
sl@0
|
908 |
{
|
|
sl@0
|
909 |
if (iBitArray[aColumn][line] != 0)
|
|
sl@0
|
910 |
{
|
|
sl@0
|
911 |
empty = efalse;
|
|
sl@0
|
912 |
break;
|
|
sl@0
|
913 |
}
|
|
sl@0
|
914 |
}
|
|
sl@0
|
915 |
|
|
sl@0
|
916 |
return empty;
|
|
sl@0
|
917 |
}
|
|
sl@0
|
918 |
|
|
sl@0
|
919 |
void FontReader::WriteFillCharacters(int aNumberConsecutive)
|
|
sl@0
|
920 |
{
|
|
sl@0
|
921 |
for (int counter = 0; counter < aNumberConsecutive; counter++)
|
|
sl@0
|
922 |
{
|
|
sl@0
|
923 |
BitmapOffset* offset = new BitmapOffset(KFillCharacterOffset);
|
|
sl@0
|
924 |
iCodeSection->iCharacters.iBitmapOffsetList.Add(offset);
|
|
sl@0
|
925 |
}
|
|
sl@0
|
926 |
}
|
|
sl@0
|
927 |
|
|
sl@0
|
928 |
boolean FontReader::ParseMetricsFromBDF(int aNumberCharsInFile, int aMaxConsecutiveFillChars)
|
|
sl@0
|
929 |
{
|
|
sl@0
|
930 |
boolean state = etrue;
|
|
sl@0
|
931 |
int character = 0;
|
|
sl@0
|
932 |
int numberCharactersRead;
|
|
sl@0
|
933 |
int lastCharacter = KMarkFirstCharacterInTypeface;
|
|
sl@0
|
934 |
int reportRate = ((aNumberCharsInFile - 1) / KReportRateFrequencyInPercent) + 1;
|
|
sl@0
|
935 |
|
|
sl@0
|
936 |
CharacterMetrics* metric = 0;
|
|
sl@0
|
937 |
|
|
sl@0
|
938 |
cout << "Analysing character metrics...\n";
|
|
sl@0
|
939 |
cout.flush();
|
|
sl@0
|
940 |
|
|
sl@0
|
941 |
for (numberCharactersRead = 0; numberCharactersRead < aNumberCharsInFile && !_EOF() && state; numberCharactersRead++)
|
|
sl@0
|
942 |
{
|
|
sl@0
|
943 |
state = IdentComp(IdentBDFCharLabel);
|
|
sl@0
|
944 |
if (!state)
|
|
sl@0
|
945 |
ErrorIdentifierExpected(IdentBDFCharLabel);
|
|
sl@0
|
946 |
if (state)
|
|
sl@0
|
947 |
iLexAnal->ReadNextLine(); // Skip to next line
|
|
sl@0
|
948 |
|
|
sl@0
|
949 |
if (IdentComp(IdentBDFChar))
|
|
sl@0
|
950 |
{
|
|
sl@0
|
951 |
state = Number(character);
|
|
sl@0
|
952 |
}
|
|
sl@0
|
953 |
else
|
|
sl@0
|
954 |
{
|
|
sl@0
|
955 |
state = efalse;
|
|
sl@0
|
956 |
ErrorIdentifierExpected(IdentBDFChar);
|
|
sl@0
|
957 |
}
|
|
sl@0
|
958 |
|
|
sl@0
|
959 |
if (character < KLowestPermittedCharacterEncoding || character > KHighestPermittedCharacterEncoding)
|
|
sl@0
|
960 |
{
|
|
sl@0
|
961 |
while (!IdentComp(IdentBDFEndChar) && !_EOF() && state)
|
|
sl@0
|
962 |
// Skip fill character.
|
|
sl@0
|
963 |
{
|
|
sl@0
|
964 |
iLexAnal->ReadNextLine(); // Skip to next line
|
|
sl@0
|
965 |
}
|
|
sl@0
|
966 |
iLexAnal->ReadNextLine();
|
|
sl@0
|
967 |
continue;
|
|
sl@0
|
968 |
}
|
|
sl@0
|
969 |
|
|
sl@0
|
970 |
if (character<lastCharacter)
|
|
sl@0
|
971 |
{
|
|
sl@0
|
972 |
Error("CodeSection out of sequence");
|
|
sl@0
|
973 |
state = efalse;
|
|
sl@0
|
974 |
}
|
|
sl@0
|
975 |
|
|
sl@0
|
976 |
if ((character > lastCharacter + 1)
|
|
sl@0
|
977 |
&& (character <= lastCharacter + 1 + aMaxConsecutiveFillChars) && state)
|
|
sl@0
|
978 |
{
|
|
sl@0
|
979 |
// Would result in fill characters being used if not at end of code section!
|
|
sl@0
|
980 |
metric = new CharacterMetrics;
|
|
sl@0
|
981 |
metric->iLeftAdjustInPixels = (chardim)0;
|
|
sl@0
|
982 |
metric->iMoveInPixels = (chardim)0;
|
|
sl@0
|
983 |
metric->iRightAdjustInPixels = (chardim)0;
|
|
sl@0
|
984 |
metric->iAscentInPixels = (chardim)0;
|
|
sl@0
|
985 |
metric->iHeightInPixels = (chardim)0;
|
|
sl@0
|
986 |
iFontBitmap->iCharacterMetrics->AddOrIncrementMetric(*metric);
|
|
sl@0
|
987 |
delete metric;
|
|
sl@0
|
988 |
metric = 0;
|
|
sl@0
|
989 |
}
|
|
sl@0
|
990 |
|
|
sl@0
|
991 |
if (state)
|
|
sl@0
|
992 |
{
|
|
sl@0
|
993 |
metric = new CharacterMetrics;
|
|
sl@0
|
994 |
state = ReadMetricFromBDFCharacter(metric);
|
|
sl@0
|
995 |
iFontBitmap->iCharacterMetrics->AddOrIncrementMetric(*metric);
|
|
sl@0
|
996 |
delete metric;
|
|
sl@0
|
997 |
metric = 0;
|
|
sl@0
|
998 |
}
|
|
sl@0
|
999 |
|
|
sl@0
|
1000 |
lastCharacter = character;
|
|
sl@0
|
1001 |
if(numberCharactersRead == ((numberCharactersRead / reportRate) * reportRate))
|
|
sl@0
|
1002 |
{
|
|
sl@0
|
1003 |
cout << "Done " << (numberCharactersRead * 100 / aNumberCharsInFile) << "% \n";
|
|
sl@0
|
1004 |
cout.flush();
|
|
sl@0
|
1005 |
}
|
|
sl@0
|
1006 |
}
|
|
sl@0
|
1007 |
|
|
sl@0
|
1008 |
if (state)
|
|
sl@0
|
1009 |
{
|
|
sl@0
|
1010 |
iFontBitmap->iCharacterMetrics->SortMetricsByFrequency();
|
|
sl@0
|
1011 |
}
|
|
sl@0
|
1012 |
return state;
|
|
sl@0
|
1013 |
}
|