Subversion Repositories Scribus

Rev

Rev 5979 | Rev 8860 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
5979 avox 1
/*
2
 For general Scribus (>=1.3.2) copyright and licensing information please refer
3
 to the COPYING file provided with the program. Following this notice may exist
4
 a copyright and/or license notice that predates the release of Scribus 1.3.2
5
 for which a new license (GPL+exception) is in place.
6
 */
7
#ifndef SCFACE_PS_H
8
#define SCFACE_PS_H
9
 
10
#include <qstring.h>
11
#include <qstrlist.h>
12
#include <qstringlist.h>
13
#include <qdict.h>
14
#include <qfont.h>
15
#include <qmap.h>
16
 
17
#include <ft2build.h>
18
#include FT_FREETYPE_H
19
#include FT_OUTLINE_H
20
#include FT_GLYPH_H
21
 
22
#include "scribusapi.h"
23
#include "fpointarray.h"
24
#include "scconfig.h"
25
 
26
 
27
/*
28
        Class ScFace_postscript
29
        Subclass of ScFace, for PostScript fonts that could possibly have a .afm file
30
        associated with them for metrics information.
31
*/
32
 
33
class ScFace_postscript : public FtFace
34
{
35
        public:
36
                ScFace_postscript(QString fam, QString sty, QString alt, QString scname, QString psname, QString path, int face) :
37
                FtFace(fam,sty,alt,scname,psname,path,face)
38
                {
39
                        isFixedPitch = false;
40
                        typeCode = ScFace::TYPE1;
41
                }
42
 
6307 avox 43
                virtual void load()  const // routine by Franz Schmid - modified by Alastair M. Robinson
5979 avox 44
                {
6307 avox 45
                        FtFace::load();
5979 avox 46
                        bool error;
47
                        FT_Face face = ftFace();
48
                        if (!face)
49
                        {
6307 avox 50
                                const_cast<ScFace_postscript*>(this)->usable = false;
5979 avox 51
                                qDebug(QObject::tr("Font %1 is broken (no Face), discarding it").arg(fontFile));
52
                                return;
53
                        }
54
                        QString afnm = fontFile.left(fontFile.length()-3);
55
                        QFile afm(afnm+"afm");
56
                        if(!(afm.exists()))
57
                        {
58
                                afm.setName(afnm+"Afm");
59
                        }
60
                        if(!(afm.exists()))
61
                        {
62
                                afm.setName(afnm+"AFM");
63
                        }
64
                        if(!(afm.exists()))
65
                        {
66
                                afm.setName(afnm+"pfm");
67
                        }
68
                        if(!(afm.exists()))
69
                        {
70
                                afm.setName(afnm+"Pfm");
71
                        }
72
                        if(!(afm.exists())) {
73
                                afm.setName(afnm+"PFM");
74
                        }
75
                        if (afm.exists())
76
                                error = FT_Attach_File(face, afm.name());
77
//                      Ascent = tmp.setNum(face->ascender);
78
//                      Descender = tmp.setNum(face->descender);
79
//                      CapHeight = Ascent;
80
//                      ItalicAngle = "0";
81
//                      StdVW = "1";
82
//                      FontBBox = tmp.setNum(face->bbox.xMin)+" "+tmp2.setNum(face->bbox.yMin)+" "+tmp3.setNum(face->bbox.xMax)+" "+tmp4.setNum(face->bbox.yMax);
83
/*
84
 setBestEncoding(face);
85
                        gindex = 0;
86
                        charcode = FT_Get_First_Char( face, &gindex );
87
                        int goodGlyph = 0;
88
                        int invalidGlyph = 0;
89
                        while ( gindex != 0 )
90
                        {
91
                                error = FT_Load_Glyph( face, gindex, FT_LOAD_NO_SCALE | FT_LOAD_NO_BITMAP );
92
                                if (error)
93
                                {
94
                                        ++invalidGlyph;
95
                                        sDebug(QObject::tr("Font %1 has broken glyph %2 (charcode %3)").arg(fontPath()).arg(gindex).arg(charcode));
96
                                        charcode = FT_Get_Next_Char( face, charcode, &gindex );
97
                                        continue;
98
                                }
99
                                ++goodGlyph;
100
                                double ww = face->glyph->metrics.horiAdvance / uniEM;
101
                                if (face->glyph->format == FT_GLYPH_FORMAT_PLOTTER)
102
                                        isStroked = true;
103
                                error = false;
104
                                outlines = traceChar(face, charcode, 10, &x, &y, &error);
105
                                if (!error)
106
                                {
107
                                        CharWidth.insert(charcode, ww);
108
                                        GRec.Outlines = outlines.copy();
109
                                        GRec.x = x;
110
                                        GRec.y = y;
111
                                        GlyphArray.insert(charcode, GRec);
112
                                }
113
                                charcode = FT_Get_Next_Char( face, charcode, &gindex );
114
                        }
115
 */
116
                }
117
};
118
 
119
/*
120
        Class ScFace_pfb
121
        Subclass of ScFace, specifically for Adobe type 1 .pfb fonts.
122
        Implements: RealName() and EmbedFont().
123
*/
124
 
125
class ScFace_pfb : public ScFace_postscript
126
{
127
        public:
128
                ScFace_pfb(QString fam, QString sty, QString alt, QString scname, QString psname, QString path, int face) :
129
                ScFace_postscript(fam,sty,alt,scname,psname,path,face)
130
                {
131
                        formatCode = ScFace::PFB;
132
                }
133
 
6307 avox 134
                virtual bool EmbedFont(QString &str) const
5979 avox 135
                {
136
                        QByteArray bb;
137
                        RawData(bb);
138
                        QString tmp2 = "";
139
                        if ((bb.size() > 2) &&  (bb[0] == char(0x80)) && (static_cast<int>(bb[1]) == 1))
140
                        {
141
                                QString tmp3="";
142
                                QString tmp4 = "";
143
                                uint posi,cxxc=0;
144
                                for (posi = 6; posi < bb.size(); ++posi)
145
                                {
146
                                        if ((bb[posi] == char(0x80)) && (posi+1 < bb.size()) && (static_cast<int>(bb[posi+1]) == 2))
147
                                                break;
148
                                        str += bb[posi];
149
                                }
150
                                uint ulen;
151
                                if (posi+6 < bb.size())
152
                                {
153
                                        ulen = bb[posi+2] & 0xff;
154
                                        ulen |= (bb[posi+3] << 8) & 0xff00;
155
                                        ulen |= (bb[posi+4] << 16) & 0xff0000;
156
                                        ulen |= (bb[posi+5] << 24) & 0xff000000;
157
                                        posi += 6;
158
                                        if (posi + ulen > bb.size())
159
                                                ulen = bb.size() - posi - 1;
160
                                        char linebuf[80];
161
                                        cxxc=0;
162
                                        for (uint j = 0; j < ulen; ++j)
163
                                        {
164
                                                unsigned char u=bb[posi];
165
                                                linebuf[cxxc]=((u >> 4) & 15) + '0';
166
                                                if(u>0x9f) linebuf[cxxc]+='a'-':';
167
                                                ++cxxc;
168
                                                u&=15; linebuf[cxxc]=u + '0';
169
                                                if(u>0x9) linebuf[cxxc]+='a'-':';
170
                                                ++posi;
171
                                                ++cxxc;
172
                                                if (cxxc > 72)
173
                                                {
174
                                                        linebuf[cxxc++]='\n';
175
                                                        linebuf[cxxc++]=0;
176
                                                        str += linebuf;
177
                                                        cxxc = 0;
178
                                                }
179
                                        }
180
                                        linebuf[cxxc]=0;
181
                                        str += linebuf;
182
                                        str += "\n";
183
                                }
184
                                posi += 6;
185
                                for (uint j = posi; j < bb.size(); ++j)
186
                                {
187
                                        if ((bb[j] == static_cast<char>(0x80)) && (j+1 < bb.size()) && (static_cast<int>(bb[j+1]) == 3))
188
                                                break;
189
                                        if(bb[j]=='\r')
190
                                                str+="\n";
191
                                        else
192
                                                str += bb[j];
193
                                }
194
                                str += "\n";
195
                                cxxc = 0;
196
                                return true;
197
                        }
198
                        else
199
                        {
200
                                qDebug(QObject::tr("Font %1 cannot be read, no embedding").arg(fontFile));
201
                                return false;
202
                        }
203
                }
204
};
205
 
206
/*
207
        Class ScFace_pfa
208
        Subclass of ScFace, specifically for Adobe type 1 and type 3 .pfa fonts.
209
        Implements: RealName() and EmbedFont().
210
*/
211
 
212
class ScFace_pfa : public ScFace_postscript
213
{
214
        public:
215
                ScFace_pfa(QString fam, QString sty, QString alt, QString scname, QString psname, QString path, int face) :
216
                ScFace_postscript(fam,sty,alt,scname,psname,path,face)
217
                {
218
                        formatCode = ScFace::PFA;
219
                }
6307 avox 220
                virtual bool EmbedFont(QString &str) const
5979 avox 221
                {
222
                        QByteArray bb;
223
                        RawData(bb);
224
                        if (bb.size() > 2 && bb[0] == '%' && bb[1] == '!')
225
                        {
226
                                // this is ok since bb will not contain '\0'
227
                                str.append(bb);
228
                                return true;
229
                        }
6307 avox 230
                        qDebug(QObject::tr("Font %1 cannot be read, no embedding").arg(fontFile));
5979 avox 231
                        return false;
232
                }
233
};
234
 
235
 
236
#endif