Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
4430 cbradney 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
*/
3133 fschmid 7
/***************************************************************************
8
                          pdflib.cpp  -  description
9
                             -------------------
10
    begin                : Sat Jan 19 2002
11
    copyright            : (C) 2002 by Franz Schmid
12
    email                : Franz.Schmid@altmuehlnet.de
13
 ***************************************************************************/
14
 
15
/***************************************************************************
16
 *                                                                         *
17
 *   This program is free software; you can redistribute it and/or modify  *
18
 *   it under the terms of the GNU General Public License as published by  *
19
 *   the Free Software Foundation; either version 2 of the License, or     *
20
 *   (at your option) any later version.                                   *
21
 *                                                                         *
22
 ***************************************************************************/
23
 
24
#include "pdflib.h"
25
#include "pdflib.moc"
26
 
27
#include "scconfig.h"
28
 
4229 craig 29
#include <string>
3133 fschmid 30
#include <qstring.h>
31
#include <qrect.h>
32
#include <qimage.h>
33
#include <qregexp.h>
34
#include <qdatetime.h>
35
#include <qfileinfo.h>
36
#include <qtextstream.h>
7329 fschmid 37
#include <qtextcodec.h>
3133 fschmid 38
#include <qdir.h>
39
#include <cstdlib>
40
#include <cmath>
41
#ifdef HAVE_UNISTD_H
42
#include <unistd.h>
43
#endif
44
#include "rc4.h"
45
 
4028 cbradney 46
#include "commonstrings.h"
3670 cbradney 47
#include "page.h"
3133 fschmid 48
#include "pageitem.h"
49
#include "bookmwin.h"
50
#include "scribus.h"
4028 cbradney 51
#include "scribusapp.h"
3699 cbradney 52
#include "scribusdoc.h"
4028 cbradney 53
#include "multiprogressdialog.h"
3133 fschmid 54
#include "bookpalette.h"
55
#include "scfontmetrics.h"
56
#include "util.h"
57
#include "prefsmanager.h"
3252 craig 58
#include "prefscontext.h"
3133 fschmid 59
#include "pdfoptions.h"
4007 fschmid 60
#include "sccolor.h"
3133 fschmid 61
 
62
using namespace std;
63
 
64
#ifdef HAVE_CMS
65
extern bool CMSuse;
66
#endif
67
#ifdef HAVE_TIFF
68
        #include <tiffio.h>
69
#endif
70
 
4264 craig 71
PDFlib::PDFlib(ScribusDoc & docu)
72
        : QObject(&docu),
4223 craig 73
        doc(docu),
74
        ActPageP(0),
4264 craig 75
        Options(doc.PDF_Options),
4223 craig 76
        Bvie(0),
77
        ObjCounter(7),
78
        ResNam("RE"),
79
        ResCount(0),
80
        NDnam("LI"),
81
        NDnum(0),
82
        KeyGen(32),
83
        OwnerKey(32),
84
        UserKey(32),
85
        FileID(16),
86
        EncryKey(5),
87
        Encrypt(0),
88
        KeyLen(5),
89
        colorsToUse(),
90
        spotNam("Spot"),
91
        spotCount(0),
4225 craig 92
        progressDialog(0),
4223 craig 93
        abortExport(false),
94
        usingGUI(ScQApp->usingGUI())
3133 fschmid 95
{
96
        Catalog.Outlines = 2;
97
        Catalog.PageTree = 3;
98
        Catalog.Dest = 4;
99
        PageTree.Count = 0;
100
        Outlines.First = 0;
101
        Outlines.Last = 0;
102
        Outlines.Count = 0;
103
        Seite.ObjNum = 0;
104
        Seite.Thumb = 0;
105
#ifdef HAVE_LIBZ
106
        CompAvail = true;
107
#else
108
        CompAvail = false;
109
#endif
110
        int kg_array[] = {0x28, 0xbf, 0x4e, 0x5e, 0x4e, 0x75, 0x8a, 0x41, 0x64, 0x00, 0x4e, 0x56, 0xff, 0xfa,
111
                          0x01, 0x08, 0x2e, 0x2e, 0x00, 0xb6, 0xd0, 0x68, 0x3e, 0x80, 0x2f, 0x0c, 0xa9, 0xfe,
112
                          0x64, 0x53, 0x69, 0x7a};
113
        for (int a = 0; a < 32; ++a)
114
                KeyGen[a] = kg_array[a];
4028 cbradney 115
        if (usingGUI)
116
        {
7121 fschmid 117
                progressDialog = new MultiProgressDialog( tr("Saving PDF"), CommonStrings::tr_Cancel, ScMW, "pdfexportprogress");
4224 craig 118
                Q_CHECK_PTR(progressDialog);
119
                QStringList barNames, barTexts;
120
                barNames << "EMP" << "EP" << "ECPI";
4307 cbradney 121
                barTexts << tr("Exporting Master Pages:") << tr("Exporting Pages:") << tr("Exporting Items on Current Page:");
4224 craig 122
                progressDialog->addExtraProgressBars(barNames, barTexts);
123
                connect(progressDialog->buttonCancel, SIGNAL(clicked()), this, SLOT(cancelRequested()));
4028 cbradney 124
        }
3133 fschmid 125
}
126
 
4224 craig 127
PDFlib::~PDFlib()
128
{
129
        delete progressDialog;
130
}
131
 
4229 craig 132
static inline QString FToStr(double c)
133
{
134
        return QString::number(c, 'f', 5);
135
};
136
 
4264 craig 137
bool PDFlib::doExport(const QString& fn, const QString& nam, int Components,
138
                                          const std::vector<int> & pageNs, const QMap<int,QPixmap> & thumbs)
3133 fschmid 139
{
140
        QPixmap pm;
141
        bool ret = false;
4028 cbradney 142
        int pc_exportpages=0;
143
        int pc_exportmasterpages=0;
4224 craig 144
        if (usingGUI)
145
                progressDialog->show();
4264 craig 146
        if (PDF_Begin_Doc(fn, PrefsManager::instance()->appPrefs.AvailFonts, doc.UsedFonts, ScMW->bookmarkPalette->BView))
3133 fschmid 147
        {
148
                QMap<int, int> pageNsMpa;
149
                for (uint a = 0; a < pageNs.size(); ++a)
150
                {
4264 craig 151
                        pageNsMpa.insert(doc.MasterNames[doc.Pages->at(pageNs[a]-1)->MPageNam], 0);
3133 fschmid 152
                }
4028 cbradney 153
                if (usingGUI)
3133 fschmid 154
                {
4028 cbradney 155
                        progressDialog->setOverallTotalSteps(pageNsMpa.count()+pageNs.size());
156
                        progressDialog->setTotalSteps("EMP", pageNsMpa.count());
157
                        progressDialog->setTotalSteps("EP", pageNs.size());
158
                        progressDialog->setOverallProgress(0);
159
                        progressDialog->setProgress("EMP", 0);
160
                        progressDialog->setProgress("EP", 0);
161
                }
4264 craig 162
                for (uint ap = 0; ap < doc.MasterPages.count() && !abortExport; ++ap)
4028 cbradney 163
                {
4264 craig 164
                        if (doc.MasterItems.count() != 0)
3133 fschmid 165
                        {
166
                                if (pageNsMpa.contains(ap))
167
                                {
4028 cbradney 168
                                        ScQApp->processEvents();
4264 craig 169
                                        PDF_TemplatePage(doc.MasterPages.at(ap));
4028 cbradney 170
                                        ++pc_exportmasterpages;
3133 fschmid 171
                                }
172
                        }
4546 subik 173
 
174
                        if (usingGUI)
175
                        {
4028 cbradney 176
                                progressDialog->setProgress("EMP", pc_exportmasterpages);
177
                                progressDialog->setOverallProgress(pc_exportmasterpages+pc_exportpages);
178
                        }
3133 fschmid 179
                }
4028 cbradney 180
                for (uint a = 0; a < pageNs.size() && !abortExport; ++a)
3133 fschmid 181
                {
4264 craig 182
                        if (doc.PDF_Options.Thumbnails)
3133 fschmid 183
                                pm = thumbs[pageNs[a]];
4028 cbradney 184
                        ScQApp->processEvents();
185
                        if (abortExport) break;
4264 craig 186
                        PDF_Begin_Page(doc.Pages->at(pageNs[a]-1), pm);
4028 cbradney 187
                        ScQApp->processEvents();
188
                        if (abortExport) break;
4649 fschmid 189
                        PDF_ProcessPage(doc.Pages->at(pageNs[a]-1), pageNs[a]-1, doc.PDF_Options.doClip);
4028 cbradney 190
                        ScQApp->processEvents();
191
                        if (abortExport) break;
3133 fschmid 192
                        PDF_End_Page();
4028 cbradney 193
                        pc_exportpages++;
194
                        if (usingGUI)
195
                        {
196
                                progressDialog->setProgress("EP", pc_exportpages);
197
                                progressDialog->setOverallProgress(pc_exportmasterpages+pc_exportpages);
198
                        }
3133 fschmid 199
                }
4028 cbradney 200
                ret = true;//Even when aborting we return true. Dont want that "couldnt write msg"
201
                if (!abortExport)
202
                {
4264 craig 203
                        if (doc.PDF_Options.Version == PDFOptions::PDFVersion_X3)
204
                                PDF_End_Doc(ScMW->PrinterProfiles[doc.PDF_Options.PrintProf], nam, Components);
4028 cbradney 205
                        else
206
                                PDF_End_Doc();
207
                }
3133 fschmid 208
                else
4028 cbradney 209
                        closeAndCleanup();
3133 fschmid 210
        }
4029 cbradney 211
        if (usingGUI)
212
                progressDialog->close();
3133 fschmid 213
        return ret;
214
}
215
 
216
void PDFlib::StartObj(int nr)
217
{
4229 craig 218
        XRef.append(bytesWritten());
219
        PutDoc(QString::number(nr)+ " 0 obj\n");
3133 fschmid 220
}
221
 
4229 craig 222
// Encode a string for inclusion in a
223
// PDF (literal) .
224
QString PDFlib::PDFEncode(const QString & in)
3133 fschmid 225
{
4229 craig 226
        QString tmp("");
3133 fschmid 227
        for (uint d = 0; d < in.length(); ++d)
228
        {
4229 craig 229
                QChar cc(in.at(d));
4230 craig 230
                if ((cc == '(') || (cc == ')') || (cc == '\\'))
231
                        tmp += '\\';
3133 fschmid 232
                tmp += cc;
233
        }
234
        return tmp;
235
}
236
 
7329 fschmid 237
QByteArray PDFlib::EncodeUTF16(const QString &in)
238
{
239
        QString tmp("");
240
        for (uint d = 0; d < in.length(); ++d)
241
        {
242
                QChar cc(in.at(d));
243
                if ((cc == '(') || (cc == ')') || (cc == '\\'))
244
                        tmp += '\\';
245
                tmp += cc;
246
        }
7333 fschmid 247
        QTextCodec *codec = QTextCodec::codecForName("ISO-10646-UCS-2");
248
        QCString cres = codec->fromUnicode( tmp );
249
        uchar sw;
250
        for(uint d = 0; d < cres.size()-1; d += 2)
251
        {
252
                sw = cres[d];
253
                cres[d] = cres[d+1];
254
                cres[d+1] = sw;
255
        }
256
        return cres;
7329 fschmid 257
}
258
 
4229 craig 259
QString PDFlib::EncStream(const QString & in, int ObjNum)
3133 fschmid 260
{
4229 craig 261
        if (in.length() < 1)
262
                return QString("");
4264 craig 263
        else if (!Options.Encrypt)
4229 craig 264
                return in;
265
        rc4_context_t rc4;
3133 fschmid 266
        int dlen = 0;
4229 craig 267
        QString tmp(in);
268
        QByteArray us(tmp.length());
269
        QByteArray ou(tmp.length());
270
        for (uint a = 0; a < tmp.length(); ++a)
271
                us[a] = uchar(QChar(tmp.at(a)));
272
        QByteArray data(10);
273
        if (KeyLen > 5)
274
                data.resize(21);
275
        for (int cd = 0; cd < KeyLen; ++cd)
3133 fschmid 276
        {
4229 craig 277
                data[cd] = EncryKey[cd];
278
                dlen++;
3133 fschmid 279
        }
4229 craig 280
        data[dlen++] = ObjNum;
281
        data[dlen++] = ObjNum >> 8;
282
        data[dlen++] = ObjNum >> 16;
283
        data[dlen++] = 0;
284
        data[dlen++] = 0;
285
        QByteArray step1(16);
286
        step1 = ComputeMD5Sum(&data);
287
        rc4_init(&rc4, reinterpret_cast<uchar*>(step1.data()), QMIN(KeyLen+5, 16));
288
        rc4_encrypt(&rc4, reinterpret_cast<uchar*>(us.data()), reinterpret_cast<uchar*>(ou.data()), tmp.length());
289
        QString uk = "";
290
        for (uint cl = 0; cl < tmp.length(); ++cl)
291
                uk += QChar(ou[cl]);
292
        return uk;
3133 fschmid 293
}
294
 
4229 craig 295
QString PDFlib::EncString(const QString & in, int ObjNum)
3133 fschmid 296
{
4264 craig 297
        if (!Options.Encrypt)
4229 craig 298
                return in;
299
        rc4_context_t rc4;
3133 fschmid 300
        QString tmp;
301
        int dlen = 0;
4229 craig 302
        if (in.length() < 3)
303
                return "<>";
304
        tmp = in.mid(1, in.length()-2);
305
        QByteArray us(tmp.length());
306
        QByteArray ou(tmp.length());
307
        for (uint a = 0; a < tmp.length(); ++a)
308
                us[a] = static_cast<uchar>(QChar(tmp.at(a)));
309
        QByteArray data(10);
310
        if (KeyLen > 5)
311
                data.resize(21);
312
        for (int cd = 0; cd < KeyLen; ++cd)
3133 fschmid 313
        {
4229 craig 314
                data[cd] = EncryKey[cd];
315
                dlen++;
3133 fschmid 316
        }
4229 craig 317
        data[dlen++] = ObjNum;
318
        data[dlen++] = ObjNum >> 8;
319
        data[dlen++] = ObjNum >> 16;
320
        data[dlen++] = 0;
321
        data[dlen++] = 0;
322
        QByteArray step1(16);
323
        step1 = ComputeMD5Sum(&data);
324
        rc4_init(&rc4, reinterpret_cast<uchar*>(step1.data()), QMIN(KeyLen+5, 16));
325
        rc4_encrypt(&rc4, reinterpret_cast<uchar*>(us.data()), reinterpret_cast<uchar*>(ou.data()), tmp.length());
326
        QString uk = "";
327
        for (uint cl = 0; cl < tmp.length(); ++cl)
328
                uk += QChar(ou[cl]);
329
        tmp = "<"+String2Hex(&uk, false)+">";
3133 fschmid 330
        return tmp;
331
}
332
 
7329 fschmid 333
QString PDFlib::EncStringUTF16(const QString & in, int ObjNum)
334
{
335
        if (!Options.Encrypt)
336
        {
8350 fschmid 337
                if (in.length() < 3)
338
                        return "<>";
7329 fschmid 339
                QString tmp = in.mid(1, in.length()-2);
340
                QByteArray us = EncodeUTF16(tmp);
341
                QString uk = "";
342
                for (uint cl = 0; cl < us.size(); ++cl)
343
                        uk += QChar(us[cl]);
344
                return "<"+String2Hex(&uk, false)+">";
345
        }
346
        rc4_context_t rc4;
347
        QString tmp;
348
        int dlen = 0;
349
        if (in.length() < 3)
350
                return "<>";
351
        tmp = in.mid(1, in.length()-2);
352
        QByteArray us = EncodeUTF16(tmp);
353
        QByteArray ou(us.size());
354
        QByteArray data(10);
355
        if (KeyLen > 5)
356
                data.resize(21);
357
        for (int cd = 0; cd < KeyLen; ++cd)
358
        {
359
                data[cd] = EncryKey[cd];
360
                dlen++;
361
        }
362
        data[dlen++] = ObjNum;
363
        data[dlen++] = ObjNum >> 8;
364
        data[dlen++] = ObjNum >> 16;
365
        data[dlen++] = 0;
366
        data[dlen++] = 0;
367
        QByteArray step1(16);
368
        step1 = ComputeMD5Sum(&data);
369
        rc4_init(&rc4, reinterpret_cast<uchar*>(step1.data()), QMIN(KeyLen+5, 16));
370
        rc4_encrypt(&rc4, reinterpret_cast<uchar*>(us.data()), reinterpret_cast<uchar*>(ou.data()), ou.size());
371
        QString uk = "";
372
        for (uint cl = 0; cl < ou.size(); ++cl)
373
                uk += QChar(ou[cl]);
374
        tmp = "<"+String2Hex(&uk, false)+">";
375
        return tmp;
376
}
377
 
4229 craig 378
QString PDFlib::FitKey(const QString & pass)
3133 fschmid 379
{
4229 craig 380
        QString pw(pass);
3133 fschmid 381
        if (pw.length() < 32)
382
        {
383
                uint l = pw.length();
384
                for (uint a = 0; a < 32 - l; ++a)
385
                        pw += QChar(KeyGen[a]);
386
        }
387
        else
388
                pw = pw.left(32);
389
        return pw;
390
}
391
 
4229 craig 392
void PDFlib::CalcOwnerKey(const QString & Owner, const QString & User)
3133 fschmid 393
{
4229 craig 394
        rc4_context_t rc4;
395
        QString pw(FitKey(User));
396
        QString pw2(FitKey(Owner.isEmpty() ? User : Owner));
3133 fschmid 397
        QByteArray step1(16);
398
        step1 = ComputeMD5(pw2);
399
        if (KeyLen > 5)
400
        {
401
                for (int kl = 0; kl < 50; ++kl)
402
                        step1 = ComputeMD5Sum(&step1);
403
        }
404
        QByteArray us(32);
405
        QByteArray enk(16);
406
        if (KeyLen > 5)
407
        {
408
                for (uint a2 = 0; a2 < 32; ++a2)
409
                        OwnerKey[a2] = static_cast<uchar>(QChar(pw.at(a2)));
410
                for (int rl = 0; rl < 20; rl++)
411
                {
4229 craig 412
                        for (int j = 0; j < 16; j ++)
413
                                enk[j] = step1[j] ^ rl;
3133 fschmid 414
                        rc4_init(&rc4, reinterpret_cast<uchar*>(enk.data()), 16);
4229 craig 415
                        rc4_encrypt(&rc4, reinterpret_cast<uchar*>(OwnerKey.data()),
3133 fschmid 416
                                         reinterpret_cast<uchar*>(OwnerKey.data()), 32);
417
                }
418
        }
419
        else
420
        {
421
                for (uint a = 0; a < 32; ++a)
422
                        us[a] = static_cast<uchar>(QChar(pw.at(a)));
423
                rc4_init(&rc4, reinterpret_cast<uchar*>(step1.data()), 5);
4546 subik 424
                rc4_encrypt(&rc4, reinterpret_cast<uchar*>(us.data()),
3133 fschmid 425
                                        reinterpret_cast<uchar*>(OwnerKey.data()), 32);
426
        }
427
}
428
 
4229 craig 429
void PDFlib::CalcUserKey(const QString & User, int Permission)
3133 fschmid 430
{
431
        rc4_context_t   rc4;
4229 craig 432
        QString pw(FitKey(User));
3133 fschmid 433
        QByteArray step1(16);
434
        QByteArray perm(4);
435
        uint perm_value = static_cast<uint>(Permission);
436
        perm[0] = perm_value;
437
        perm[1] = perm_value >> 8;
438
        perm[2] = perm_value >> 16;
439
        perm[3] = perm_value >> 24;
440
        for (uint a = 0; a < 32; ++a)
441
                pw += QChar(OwnerKey[a]);
442
        for (uint a1 = 0; a1 < 4; ++a1)
443
                pw += QChar(perm[a1]);
444
        for (uint a3 = 0; a3 < 16; ++a3)
445
                pw += QChar(FileID[a3]);
446
        step1 = ComputeMD5(pw);
447
        if (KeyLen > 5)
448
        {
449
                for (int kl = 0; kl < 50; ++kl)
450
                        step1 = ComputeMD5Sum(&step1);
451
                EncryKey.resize(16);
452
        }
453
        for (int a2 = 0; a2 < KeyLen; ++a2)
454
                EncryKey[a2] = step1[a2];
455
        if (KeyLen > 5)
456
        {
4229 craig 457
                QString pr2("");
3133 fschmid 458
                for (int kl3 = 0; kl3 < 32; ++kl3)
459
                        pr2 += QChar(KeyGen[kl3]);
460
                for (uint a4 = 0; a4 < 16; ++a4)
461
                        pr2 += QChar(FileID[a4]);
462
                step1 = ComputeMD5(pr2);
463
                QByteArray enk(16);
464
                for (uint a3 = 0; a3 < 16; ++a3)
465
                        UserKey[a3] = step1[a3];
466
                for (int rl = 0; rl < 20; rl++)
467
                {
4229 craig 468
                        for (int j = 0; j < 16; j ++)
469
                                enk[j] = EncryKey[j] ^ rl;
3133 fschmid 470
                        rc4_init(&rc4, reinterpret_cast<uchar*>(enk.data()), 16);
4229 craig 471
                        rc4_encrypt(&rc4, reinterpret_cast<uchar*>(UserKey.data()), reinterpret_cast<uchar*>(UserKey.data()), 16);
3133 fschmid 472
                }
473
        }
474
        else
475
        {
476
                rc4_init(&rc4, reinterpret_cast<uchar*>(step1.data()), 5);
4229 craig 477
                rc4_encrypt(&rc4, reinterpret_cast<uchar*>(KeyGen.data()), reinterpret_cast<uchar*>(UserKey.data()), 32);
3133 fschmid 478
        }
479
}
480
 
3829 cbradney 481
QByteArray PDFlib::ComputeMD5(const QString& in)
3133 fschmid 482
{
3829 cbradney 483
        uint inlen=in.length();
484
        QByteArray TBytes(inlen);
485
        for (uint a = 0; a < inlen; ++a)
3133 fschmid 486
                TBytes[a] = static_cast<uchar>(QChar(in.at(a)));
487
        return ComputeMD5Sum(&TBytes);
488
}
489
 
4264 craig 490
bool PDFlib::PDF_Begin_Doc(const QString& fn, SCFonts &AllFonts, QMap<QString,int> DocFonts, BookMView* vi)
3133 fschmid 491
{
4229 craig 492
        Spool.setName(fn);
3133 fschmid 493
        if (!Spool.open(IO_WriteOnly))
494
                return false;
4229 craig 495
        outStream.setDevice(&Spool);
3133 fschmid 496
        QString tmp;
497
        QString ok = "";
498
        QString uk = "";
499
        QFileInfo fd;
500
        QString fext;
501
        int a;
502
        Bvie = vi;
503
        BookMinUse = false;
11098 jghali 504
        UsedFontsF.clear();
3133 fschmid 505
        UsedFontsP.clear();
4264 craig 506
        if ((Options.Version == 15) && (Options.useLayers))
3133 fschmid 507
                ObjCounter = 10;
508
        else
509
                ObjCounter = 9;
4264 craig 510
        switch (Options.Version)
3133 fschmid 511
        {
512
                case 12:
513
                case 13:
4229 craig 514
                        PutDoc("%PDF-1.3\n");
3133 fschmid 515
                        break;
516
                case 14:
517
                        PutDoc("%PDF-1.4\n");
518
                        break;
519
                case 15:
520
                        PutDoc("%PDF-1.5\n");
521
                        break;
522
        }
4264 craig 523
        if (Options.Version == 12)
3133 fschmid 524
                ObjCounter++;
4229 craig 525
        PutDoc("%\xc7\xec\x8f\xa2\n");
3133 fschmid 526
        StartObj(1);
527
        PutDoc("<<\n/Type /Catalog\n/Outlines 3 0 R\n/Pages 4 0 R\n/Dests 5 0 R\n/AcroForm 6 0 R\n/Names 7 0 R\n/Threads 8 0 R\n");
4264 craig 528
        if ((Options.Version == 15) && (Options.useLayers))
3133 fschmid 529
                PutDoc("/OCProperties 9 0 R\n");
4264 craig 530
        if (Options.Version == 12)
4229 craig 531
                PutDoc("/OutputIntents [ "+QString::number(ObjCounter-1)+" 0 R ]\n");
4197 fschmid 532
        PutDoc("/PageLayout ");
4264 craig 533
        switch (Options.PageLayout)
3133 fschmid 534
        {
4197 fschmid 535
                case PDFOptions::SinglePage:
536
                        PutDoc("/SinglePage\n");
537
                        break;
538
                case PDFOptions::OneColumn:
539
                        PutDoc("/OneColumn\n");
540
                        break;
541
                case PDFOptions::TwoColumnLeft:
542
                        PutDoc("/TwoColumnLeft\n");
543
                        break;
544
                case PDFOptions::TwoColumnRight:
545
                        PutDoc("/TwoColumnRight\n");
546
                        break;
547
        }
4264 craig 548
        if (Options.displayBookmarks)
4197 fschmid 549
                PutDoc("/PageMode /UseOutlines\n");
4264 craig 550
        else if (Options.displayFullscreen)
4197 fschmid 551
                PutDoc("/PageMode /FullScreen\n");
4264 craig 552
        else if (Options.displayThumbs)
4197 fschmid 553
                PutDoc("/PageMode /UseThumbs\n");
4264 craig 554
        else if ((Options.Version == 15) && (Options.displayLayers))
4197 fschmid 555
                        PutDoc("/PageMode /UseOC\n");
4264 craig 556
        if (!Options.openAction.isEmpty())
4197 fschmid 557
        {
4264 craig 558
                PutDoc("/OpenAction << /S /JavaScript /JS (this."+Options.openAction+"\\(\\)) >>\n");
3133 fschmid 559
        }
560
        PutDoc("/ViewerPreferences\n<<\n/PageDirection ");
4264 craig 561
        PutDoc( Options.Binding == 0 ? "/L2R\n" : "/R2L\n");
562
        if (Options.hideToolBar)
4201 fschmid 563
                PutDoc("/HideToolbar true\n");
4264 craig 564
        if (Options.hideMenuBar)
4201 fschmid 565
                PutDoc("/HideMenubar true\n");
4264 craig 566
        if (Options.fitWindow)
4201 fschmid 567
                PutDoc("/FitWindow true\n");
3133 fschmid 568
        PutDoc(" >>\n>>\nendobj\n");
3829 cbradney 569
        QString IDg(Datum);
4264 craig 570
        IDg += Options.Datei;
3133 fschmid 571
        IDg += "Scribus "+QString(VERSION);
6889 fschmid 572
        IDg += "Scribus PDF Library "+QString(VERSION);
4264 craig 573
        IDg += doc.documentInfo.getTitle();
574
        IDg += doc.documentInfo.getAuthor();
3133 fschmid 575
        IDg += "/False";
576
        FileID = ComputeMD5(IDg);
4264 craig 577
        if (Options.Encrypt)
3133 fschmid 578
        {
6165 fschmid 579
                if ((Options.Version == 14) || (Options.Version == 15))
580
                        KeyLen = 16;
581
                else
582
                        KeyLen = 5;
4264 craig 583
                CalcOwnerKey(Options.PassOwner, Options.PassUser);
584
                CalcUserKey(Options.PassUser, Options.Permissions);
3133 fschmid 585
                for (uint cl2 = 0; cl2 < 32; ++cl2)
586
                        ok += QChar(OwnerKey[cl2]);
587
                if (KeyLen > 5)
588
                {
589
                        for (uint cl3 = 0; cl3 < 16; ++cl3)
590
                                uk += QChar(UserKey[cl3]);
591
                        for (uint cl3r = 0; cl3r < 16; ++cl3r)
592
                                uk += QChar(KeyGen[cl3r]);
593
                }
594
                else
595
                {
596
                        for (uint cl = 0; cl < 32; ++cl)
597
                                uk += QChar(UserKey[cl]);
598
                }
599
        }
600
        QDate d = QDate::currentDate();
601
        Datum = "D:";
602
        tmp.sprintf("%4d", d.year());
603
        tmp.replace(QRegExp(" "), "0");
604
        Datum += tmp;
605
        tmp.sprintf("%2d", d.month());
606
        tmp.replace(QRegExp(" "), "0");
607
        Datum += tmp;
608
        tmp.sprintf("%2d", d.day());
609
        tmp.replace(QRegExp(" "), "0");
610
        Datum += tmp;
4229 craig 611
        tmp = QTime::currentTime().toString();
3133 fschmid 612
        tmp.replace(QRegExp(":"), "");
613
        Datum += tmp;
614
        StartObj(2);
615
        PutDoc("<<\n/Creator "+EncString("(Scribus "+QString(VERSION)+")",2)+"\n");
6889 fschmid 616
        PutDoc("/Producer "+EncString("(Scribus PDF Library "+QString(VERSION)+")",2)+"\n");
4718 fschmid 617
        QString docTitle = doc.documentInfo.getTitle();
618
        if ((Options.Version == 12) && (docTitle.isEmpty()))
7329 fschmid 619
                PutDoc("/Title "+EncStringUTF16("("+doc.DocName+")",2)+"\n");
4718 fschmid 620
        else
7329 fschmid 621
                PutDoc("/Title "+EncStringUTF16("("+doc.documentInfo.getTitle()+")",2)+"\n");
622
        PutDoc("/Author "+EncStringUTF16("("+doc.documentInfo.getAuthor()+")",2)+"\n");
623
        PutDoc("/Keywords "+EncStringUTF16("("+doc.documentInfo.getKeywords()+")",2)+"\n");
3133 fschmid 624
        PutDoc("/CreationDate "+EncString("("+Datum+")",2)+"\n");
625
        PutDoc("/ModDate "+EncString("("+Datum+")",2)+"\n");
4264 craig 626
        if (Options.Version == 12)
3133 fschmid 627
                PutDoc("/GTS_PDFXVersion (PDF/X-3:2002)\n");
628
        PutDoc("/Trapped /False\n>>\nendobj\n");
4229 craig 629
        for (int t = 0; t < 6; ++t)
630
                XRef.append(bytesWritten());
4264 craig 631
        if ((Options.Version == 15) && (Options.useLayers))
4229 craig 632
                XRef.append(bytesWritten());
4264 craig 633
        if (Options.Version == 12)
4229 craig 634
                XRef.append(bytesWritten());
4264 craig 635
        if (Options.Encrypt)
3133 fschmid 636
        {
637
                StartObj(ObjCounter);
638
                Encrypt = ObjCounter;
639
                ObjCounter++;
640
                PutDoc("<<\n/Filter /Standard\n");
641
                PutDoc( KeyLen > 5 ? "/R 3\n/V 2\n/Length 128\n" : "/R 2\n/V 1\n");
642
                PutDoc("/O <"+String2Hex(&ok)+">\n");
643
                PutDoc("/U <"+String2Hex(&uk)+">\n");
4264 craig 644
                PutDoc("/P "+QString::number(Options.Permissions)+"\n>>\nendobj\n");
3133 fschmid 645
        }
646
        RealFonts = DocFonts;
3544 avox 647
        QMap<QString,int> ReallyUsed;
3133 fschmid 648
        ReallyUsed.clear();
649
        PageItem* pgit;
4017 fschmid 650
        QMap<int, QString> ind2PDFabr;
4546 subik 651
        const QString tmpf[] = {"/Courier", "/Courier-Bold", "/Courier-Oblique", "/Courier-BoldOblique",
4017 fschmid 652
                                                                                                "/Helvetica", "/Helvetica-Bold", "/Helvetica-Oblique", "/Helvetica-BoldOblique",
4546 subik 653
                                                                                                "/Times-Roman", "/Times-Bold", "/Times-Italic", "/Times-BoldItalic",
4017 fschmid 654
                                                                                                "/ZapfDingbats", "/Symbol"};
655
        size_t ar = sizeof(tmpf) / sizeof(*tmpf);
656
        for (uint ax = 0; ax < ar; ++ax)
657
                ind2PDFabr[ax] = tmpf[ax];
4264 craig 658
        for (uint c = 0; c < doc.FrameItems.count(); ++c)
3133 fschmid 659
        {
4264 craig 660
                pgit = doc.FrameItems.at(c);
3133 fschmid 661
                if ((pgit->itemType() == PageItem::TextFrame) || (pgit->itemType() == PageItem::PathText))
662
                {
4084 cbradney 663
                        if (pgit->isAnnotation())
8350 fschmid 664
                        {
4084 cbradney 665
                                StdFonts.insert(ind2PDFabr[pgit->annotation().Font()], "");
8350 fschmid 666
                                if (pgit->annotation().Type() == 4)
667
                                        StdFonts.insert("/ZapfDingbats", "");
9656 fschmid 668
                                ReallyUsed.insert(pgit->font(), DocFonts[pgit->font()]);
8350 fschmid 669
                        }
3133 fschmid 670
                        for (uint e = 0; e < pgit->itemText.count(); ++e)
671
                        {
3544 avox 672
                                ReallyUsed.insert(pgit->itemText.at(e)->cfont->scName(), DocFonts[pgit->itemText.at(e)->cfont->scName()]);
3133 fschmid 673
                        }
674
                }
675
        }
4264 craig 676
        for (uint c = 0; c < doc.MasterItems.count(); ++c)
3133 fschmid 677
        {
4264 craig 678
                pgit = doc.MasterItems.at(c);
3133 fschmid 679
                if ((pgit->itemType() == PageItem::TextFrame) || (pgit->itemType() == PageItem::PathText))
680
                {
4084 cbradney 681
                        if (pgit->isAnnotation())
8350 fschmid 682
                        {
4084 cbradney 683
                                StdFonts.insert(ind2PDFabr[pgit->annotation().Font()], "");
8350 fschmid 684
                                if (pgit->annotation().Type() == 4)
685
                                        StdFonts.insert("/ZapfDingbats", "");
9656 fschmid 686
                                ReallyUsed.insert(pgit->font(), DocFonts[pgit->font()]);
8350 fschmid 687
                        }
3133 fschmid 688
                        for (uint e = 0; e < pgit->itemText.count(); ++e)
689
                        {
3544 avox 690
                                ReallyUsed.insert(pgit->itemText.at(e)->cfont->scName(), DocFonts[pgit->itemText.at(e)->cfont->scName()]);
3133 fschmid 691
                        }
692
                }
693
        }
4264 craig 694
        for (uint d = 0; d < doc.Items->count(); ++d)
3133 fschmid 695
        {
4264 craig 696
                pgit = doc.Items->at(d);
3133 fschmid 697
                if ((pgit->itemType() == PageItem::TextFrame) || (pgit->itemType() == PageItem::PathText))
698
                {
4084 cbradney 699
                        if (pgit->isAnnotation())
8350 fschmid 700
                        {
4084 cbradney 701
                                StdFonts.insert(ind2PDFabr[pgit->annotation().Font()], "");
8350 fschmid 702
                                if (pgit->annotation().Type() == 4)
703
                                        StdFonts.insert("/ZapfDingbats", "");
9656 fschmid 704
                                ReallyUsed.insert(pgit->font(), DocFonts[pgit->font()]);
8350 fschmid 705
                        }
3133 fschmid 706
                        for (uint e = 0; e < pgit->itemText.count(); ++e)
707
                        {
3544 avox 708
                                ReallyUsed.insert(pgit->itemText.at(e)->cfont->scName(), DocFonts[pgit->itemText.at(e)->cfont->scName()]);
3133 fschmid 709
                        }
710
                }
711
        }
4017 fschmid 712
        a = 0;
713
        QMap<QString, QString>::Iterator itStd;
714
        for (itStd = StdFonts.begin(); itStd != StdFonts.end(); ++itStd)
715
        {
716
                StartObj(ObjCounter);
717
                PutDoc("<<\n/Type /Font\n/Subtype /Type1\n");
8431 fschmid 718
                PutDoc("/Name /FoStd"+QString::number(a)+"\n");
4017 fschmid 719
                PutDoc("/BaseFont "+itStd.key()+"\n");
8431 fschmid 720
                if (itStd.key() != "/ZapfDingbats")
721
                {
722
                        PutDoc("/Encoding << \n");
723
                        PutDoc("/Differences [ \n");
724
                        PutDoc("24 /breve /caron /circumflex /dotaccent /hungarumlaut /ogonek /ring /tilde\n");
725
                        PutDoc("39 /quotesingle 96 /grave 128 /bullet /dagger /daggerdbl /ellipsis /emdash /endash /florin /fraction /guilsinglleft /guilsinglright\n");
726
                        PutDoc("/minus /perthousand /quotedblbase /quotedblleft /quotedblright /quoteleft /quoteright /quotesinglbase /trademark /fi /fl /Lslash /OE /Scaron\n");
727
                        PutDoc("/Ydieresis /Zcaron /dotlessi /lslash /oe /scaron /zcaron 164 /currency 166 /brokenbar 168 /dieresis /copyright /ordfeminine 172 /logicalnot\n");
728
                        PutDoc("/.notdef /registered /macron /degree /plusminus /twosuperior /threesuperior /acute /mu 183 /periodcentered /cedilla /onesuperior /ordmasculine\n");
729
                        PutDoc("188 /onequarter /onehalf /threequarters 192 /Agrave /Aacute /Acircumflex /Atilde /Adieresis /Aring /AE /Ccedilla /Egrave /Eacute /Ecircumflex\n");
730
                        PutDoc("/Edieresis /Igrave /Iacute /Icircumflex /Idieresis /Eth /Ntilde /Ograve /Oacute /Ocircumflex /Otilde /Odieresis /multiply /Oslash\n");
731
                        PutDoc("/Ugrave /Uacute /Ucircumflex /Udieresis /Yacute /Thorn /germandbls /agrave /aacute /acircumflex /atilde /adieresis /aring /ae /ccedilla\n");
732
                        PutDoc("/egrave /eacute /ecircumflex /edieresis /igrave /iacute /icircumflex /idieresis /eth /ntilde /ograve /oacute /ocircumflex /otilde /odieresis\n");
733
                        PutDoc("/divide /oslash /ugrave /uacute /ucircumflex /udieresis /yacute /thorn /ydieresis\n");
734
                        PutDoc("] >>\n");
735
                }
4017 fschmid 736
                PutDoc(">>\nendobj\n");
4229 craig 737
                Seite.FObjects["FoStd"+QString::number(a)] = ObjCounter;
738
                itStd.data() = "FoStd"+QString::number(a);
4017 fschmid 739
                ObjCounter++;
740
                a++;
741
        }
3544 avox 742
        QMap<QString,int>::Iterator it;
3133 fschmid 743
        a = 0;
744
        for (it = ReallyUsed.begin(); it != ReallyUsed.end(); ++it)
745
        {
746
                Foi::FontFormat fformat = AllFonts[it.key()]->formatCode;
7088 fschmid 747
                if ((!AllFonts[it.key()]->HasNames) || (Options.SubsetList.contains(it.key())))
3133 fschmid 748
                {
3829 cbradney 749
                        QString fon("");
3133 fschmid 750
                        QMap<uint,FPointArray>::Iterator ig;
751
                        for (ig = AllFonts[it.key()]->RealGlyphs.begin(); ig != AllFonts[it.key()]->RealGlyphs.end(); ++ig)
752
                        {
753
                                FPoint np, np1, np2;
754
                                bool nPath = true;
5609 cbradney 755
                                fon = "";
3133 fschmid 756
                                if (ig.data().size() > 3)
757
                                {
758
                                        FPointArray gly = ig.data().copy();
759
                                        QWMatrix mat;
760
                                        mat.scale(0.1, 0.1);
761
                                        gly.map(mat);
762
                                        for (uint poi = 0; poi < gly.size()-3; poi += 4)
763
                                        {
764
                                                if (gly.point(poi).x() > 900000)
765
                                                {
766
                                                        fon += "h\n";
767
                                                        nPath = true;
768
                                                        continue;
769
                                                }
770
                                                if (nPath)
771
                                                {
772
                                                        np = gly.point(poi);
773
                                                        fon += FToStr(np.x())+" "+FToStr(-np.y())+" m\n";
774
                                                        nPath = false;
775
                                                }
776
                                                np = gly.point(poi+1);
777
                                                np1 = gly.point(poi+3);
778
                                                np2 = gly.point(poi+2);
779
                                                fon += FToStr(np.x()) + " " + FToStr(-np.y()) + " " +
780
                                                         FToStr(np1.x()) + " " + FToStr(-np1.y()) + " " +
781
                                                         FToStr(np2.x()) + " " + FToStr(-np2.y()) + " c\n";
782
                                        }
783
                                        fon += "h f*\n";
784
                                        np = getMinClipF(&gly);
785
                                        np1 = getMaxClipF(&gly);
786
                                }
5609 cbradney 787
                                else
788
                                {
789
                                        fon = "h";
790
                                        np = FPoint(0, 0);
791
                                        np1 = FPoint(0, 0);
792
                                }
793
                                StartObj(ObjCounter);
794
                                ObjCounter++;
795
                                PutDoc("<<\n/Type /XObject\n/Subtype /Form\n/FormType 1\n");
796
                                PutDoc("/BBox [ "+FToStr(np.x())+" "+FToStr(-np.y())+" "+FToStr(np1.x())+ " "+FToStr(-np1.y())+" ]\n");
797
                                PutDoc("/Resources << /ProcSet [/PDF /Text /ImageB /ImageC /ImageI]\n");
798
                                PutDoc(">>\n");
799
                                if ((Options.Compress) && (CompAvail))
800
                                        fon = CompressStr(&fon);
801
                                PutDoc("/Length "+QString::number(fon.length()+1));
802
                                if ((Options.Compress) && (CompAvail))
803
                                        PutDoc("\n/Filter /FlateDecode");
804
                                PutDoc(" >>\nstream\n"+EncStream(fon, ObjCounter-1)+"\nendstream\nendobj\n");
805
                                Seite.XObjects[AllFonts[it.key()]->RealName().replace( QRegExp("[\\s\\/\\{\\[\\]\\}\\<\\>\\(\\)\\%]"), "_" )+QString::number(ig.key())] = ObjCounter-1;
3133 fschmid 806
                        }
807
                        AllFonts[it.key()]->RealGlyphs.clear();
808
                }
809
                else
810
                {
4229 craig 811
                        UsedFontsP.insert(it.key(), "/Fo"+QString::number(a));
4264 craig 812
                        if ((fformat == Foi::PFB) && (Options.EmbedList.contains(it.key())))
3133 fschmid 813
                        {
3829 cbradney 814
                                QString fon("");
3133 fschmid 815
                                StartObj(ObjCounter);
816
                                QByteArray bb;
817
                                AllFonts[it.key()]->RawData(bb);
818
                                uint posi;
819
                                for (posi = 6; posi < bb.size(); ++posi)
820
                                {
821
                                        if ((bb[posi] == static_cast<char>(0x80)) && (static_cast<int>(bb[posi+1]) == 2))
822
                                                break;
823
                                        fon += QChar(bb[posi]);
824
                                }
825
                                int len1 = fon.length();
826
                                uint ulen;
827
                                ulen = bb[posi+2] & 0xff;
828
                                ulen |= (bb[posi+3] << 8) & 0xff00;
829
                                ulen |= (bb[posi+4] << 16) & 0xff0000;
830
                                ulen |= (bb[posi+5] << 24) & 0xff000000;
831
                                if (ulen > bb.size())
832
                                        ulen = bb.size()-7;
833
                                posi += 6;
834
                                for (uint j = 0; j < ulen; ++j)
835
                                        fon += QChar(bb[posi++]);
836
                                posi += 6;
837
                                int len2 = fon.length()-len1;
838
                                for (uint j = posi; j < bb.size(); ++j)
839
                                {
840
                                        if ((bb[j] == static_cast<char>(0x80)) && (static_cast<int>(bb[j+1]) == 3))
841
                                                break;
842
                                        if (bb[j] == '\r')
843
                                                fon += "\n";
844
                                        else
845
                                                fon += QChar(bb[j]);
846
                                }
847
                                int len3 = fon.length()-len2-len1;
4264 craig 848
                                if ((Options.Compress) && (CompAvail))
3133 fschmid 849
                                        fon = CompressStr(&fon);
4229 craig 850
                                PutDoc("<<\n/Length "+QString::number(fon.length()+1)+"\n");
851
                                PutDoc("/Length1 "+QString::number(len1)+"\n");
852
                                PutDoc("/Length2 "+QString::number(len2)+"\n");
853
                                PutDoc("/Length3 "+QString::number(len3)+"\n");
4264 craig 854
                                if ((Options.Compress) && (CompAvail))
3133 fschmid 855
                                        PutDoc("/Filter /FlateDecode\n");
4229 craig 856
                                PutDoc(">>\nstream\n"+EncStream(fon,ObjCounter)+"\nendstream\nendobj\n");
3133 fschmid 857
                                ObjCounter++;
858
                        }
4264 craig 859
                        if ((fformat == Foi::PFA) && (Options.EmbedList.contains(it.key())))
3133 fschmid 860
                        {
3829 cbradney 861
                                QString fon("");
862
                                QString fon2("");
863
                                QString tm("");
3133 fschmid 864
                                uint value;
865
                                bool ok = true;
866
                                StartObj(ObjCounter);
867
                                AllFonts[it.key()]->EmbedFont(fon);
868
                                int len1 = fon.find("eexec")+5;
869
                                fon2 = fon.left(len1)+"\n";
870
                                int len2 = fon.find("0000000000000000000000000");
871
                                if (len2 == -1)
872
                                        len2 = fon.length()+1;
873
                                int count = 0;
874
                                for (int xx = len1; xx < len2-1; ++xx)
875
                                {
876
                                        tm = fon.at(xx);
877
                                        if ((tm == QChar(13)) || (tm == QChar(10)))
878
                                                continue;
879
                                        xx++;
880
                                        count++;
881
                                        tm += fon.at(xx);
882
                                        value = tm.toUInt(&ok, 16);
883
                                        fon2 += QChar(value);
884
                                }
885
                                fon2 += fon.mid(len2);
4264 craig 886
                                if ((Options.Compress) && (CompAvail))
3133 fschmid 887
                                        fon2 = CompressStr(&fon2);
4229 craig 888
                                PutDoc("<<\n/Length "+QString::number(fon2.length()+1)+"\n");
889
                                PutDoc("/Length1 "+QString::number(len1+1)+"\n");
890
                                PutDoc("/Length2 "+QString::number(count)+"\n");
891
                                PutDoc(static_cast<int>(fon.length()-len2) == -1 ? QString("/Length3 0\n") : "/Length3 "+QString::number(fon.length()-len2)+"\n");
4264 craig 892
                                if ((Options.Compress) && (CompAvail))
3133 fschmid 893
                                        PutDoc("/Filter /FlateDecode\n");
4229 craig 894
                                PutDoc(">>\nstream\n"+EncStream(fon2, ObjCounter)+"\nendstream\nendobj\n");
3133 fschmid 895
                                ObjCounter++;
896
                        }
4264 craig 897
                        if ((fformat == Foi::SFNT || fformat == Foi::TTCF) && (Options.EmbedList.contains(it.key())))
3133 fschmid 898
                        {
3829 cbradney 899
                                QString fon("");
3133 fschmid 900
                                StartObj(ObjCounter);
901
                                QByteArray bb;
902
                                AllFonts[it.key()]->RawData(bb);
903
                                //AV: += and append() dont't work because they stop at '\0' :-(
904
                                for (unsigned int i=0; i < bb.size(); i++)
905
                                        fon += QChar(bb[i]);
906
                                int len = fon.length();
4264 craig 907
                                if ((Options.Compress) && (CompAvail))
3133 fschmid 908
                                        fon = CompressStr(&fon);
909
                                //qDebug(QString("sfnt data: size=%1 before=%2 compressed=%3").arg(bb.size()).arg(len).arg(fon.length()));
4229 craig 910
                                PutDoc("<<\n/Length "+QString::number(fon.length()+1)+"\n");
911
                                PutDoc("/Length1 "+QString::number(len)+"\n");
4264 craig 912
                                if ((Options.Compress) && (CompAvail))
3133 fschmid 913
                                        PutDoc("/Filter /FlateDecode\n");
4229 craig 914
                                PutDoc(">>\nstream\n"+EncStream(fon, ObjCounter)+"\nendstream\nendobj\n");
3133 fschmid 915
                                ObjCounter++;
916
                        }
917
                        StartObj(ObjCounter);
918
                        PutDoc("<<\n/Type /FontDescriptor\n");
3440 fschmid 919
                        PutDoc("/FontName /"+AllFonts[it.key()]->RealName().replace( QRegExp("[\\s\\/\\{\\[\\]\\}\\<\\>\\(\\)\\%]"), "_" )+"\n");
3133 fschmid 920
                        PutDoc("/FontBBox [ "+AllFonts[it.key()]->FontBBox+" ]\n");
921
                        PutDoc("/Flags ");
3544 avox 922
                        //FIXME: isItalic() should be queried from Foi, not from Qt -- AV
923
                        //QFontInfo fo = QFontInfo(it.data());
3133 fschmid 924
                        int pfl = 0;
925
                        if (AllFonts[it.key()]->IsFixedPitch)
926
                                pfl = pfl ^ 1;
3544 avox 927
                        //if (fo.italic())
928
                        if (AllFonts[it.key()]->ItalicAngle != "0")
3133 fschmid 929
                                pfl = pfl ^ 64;
930
//                      pfl = pfl ^ 4;
931
                        pfl = pfl ^ 32;
4229 craig 932
                        PutDoc(QString::number(pfl)+"\n");
3133 fschmid 933
                        PutDoc("/Ascent "+AllFonts[it.key()]->Ascent+"\n");
934
                        PutDoc("/Descent "+AllFonts[it.key()]->Descender+"\n");
935
                        PutDoc("/CapHeight "+AllFonts[it.key()]->CapHeight+"\n");
936
                        PutDoc("/ItalicAngle "+AllFonts[it.key()]->ItalicAngle+"\n");
937
                        PutDoc("/StemV "+AllFonts[it.key()]->StdVW+"\n");
4264 craig 938
                        if ((fformat == Foi::SFNT || fformat == Foi::TTCF) && (Options.EmbedList.contains(it.key())))
4229 craig 939
                                PutDoc("/FontFile2 "+QString::number(ObjCounter-1)+" 0 R\n");
4264 craig 940
                        if ((fformat == Foi::PFB) && (Options.EmbedList.contains(it.key())))
4229 craig 941
                                PutDoc("/FontFile "+QString::number(ObjCounter-1)+" 0 R\n");
4264 craig 942
                        if ((fformat == Foi::PFA) && (Options.EmbedList.contains(it.key())))
4229 craig 943
                                PutDoc("/FontFile "+QString::number(ObjCounter-1)+" 0 R\n");
3133 fschmid 944
                        PutDoc(">>\nendobj\n");
945
                        ObjCounter++;
4546 subik 946
/*                      if (!FT_Has_PS_Glyph_Names(AllFonts[it.key()])
3133 fschmid 947
                        {
948
                                StartObj(ObjCounter);
949
                                int chCount = 31;
950
                                PutDoc("[ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ");
951
                                for (int ww = 31; ww < 256; ++ww)
952
                                {
4229 craig 953
                                        PutDoc(QString::number(static_cast<int>(AllFonts[it.key()]->CharWidth[itg.key()]*
3133 fschmid 954
                                                        1000))+" ");
955
                                        if (itg == gl.end())
956
                                                break;
957
                                        ++itg;
958
                                        chCount++;
959
                                }
960
                                PutDoc("]\nendobj\n");
961
                                ObjCounter++;
962
                                // put widths object
963
                                // encoding dictionary w/ base encoding w/o differences
964
                                StartObj(ObjCounter);
965
                                PutDoc("<<\n/Type /Font\n/Subtype ");
966
                                PutDoc((fformat == Foi::SFNT || fformat == Foi::TTCF) ? "/TrueType\n" : "/Type1\n");
4229 craig 967
                                PutDoc("/Name /Fo"+QString::number(a)+"\n");
3304 fschmid 968
                                PutDoc("/BaseFont /"+AllFonts[it.key()]->RealName().replace( QRegExp("[\\s\\/\\{\\[\\]\\}\\<\\>\\(\\)\\%]"), "" )+"\n");
3133 fschmid 969
                                //cf. widths:
970
                                PutDoc("/FirstChar 0\n");
4229 craig 971
                                PutDoc("/LastChar "+QString::number(chCount-1)+"\n");
972
                                PutDoc("/Widths "+QString::number(ObjCounter-1)+" 0 R\n");
973
                                PutDoc("/FontDescriptor "+QString::number(ObjCounter-2)+" 0 R\n");
3133 fschmid 974
                                PutDoc(">>\nendobj\n");
4229 craig 975
                                Seite.FObjects["Fo"+QString::number(a)] = ObjCounter;
3133 fschmid 976
                                ObjCounter++;
977
                        }
978
                        else */
979
//                      {
11098 jghali 980
 
981
                                GListeInd glyphIndexes;
982
                                struct GlNamInd glIndexName;
983
                                GlyphsIdxOfFont.insert(it.key(), glyphIndexes);
984
                                QMap<uint,std::pair<uint,QString> > gl;
985
                                GlyNames2(AllFonts[it.key()], &gl);
986
                                int nglyphs = 0;
987
                                QMap<uint,std::pair<uint,QString> >::Iterator gli;
988
                                for (gli = gl.begin(); gli != gl.end(); ++gli)
989
                                {
990
                                        if (gli.key() > static_cast<uint>(nglyphs))
991
                                                nglyphs = gli.key();
992
                                }
993
                                ++nglyphs;
994
//                              qDebug(QString("pdflib: nglyphs %1 max %2").arg(nglyphs).arg(AllFonts[it.key()].maxGlyph()));
3133 fschmid 995
                                uint FontDes = ObjCounter - 1;
11098 jghali 996
                                uint Fcc = nglyphs / 224;
997
                                if ((nglyphs % 224) != 0)
3133 fschmid 998
                                        Fcc += 1;
999
                                for (uint Fc = 0; Fc < Fcc; ++Fc)
1000
                                {
1001
                                        StartObj(ObjCounter);
11098 jghali 1002
                                        int chCount = 32;
1003
                                        PutDoc("[ 0 0 0 0 0  0 0 0 0 0  0 0 0 0 0  0 0 0 0 0  0 0 0 0 0  0 0 0 0 0  0 0 ");
1004
                                        for (int ww = 32; ww < 256; ++ww)
3133 fschmid 1005
                                        {
11098 jghali 1006
                                                uint glyph = 224 * Fc + ww - 32;
1007
                                                if (gl.contains(glyph))
1008
                                                {
1009
                                                        PutDoc(QString::number(static_cast<int>(AllFonts[it.key()]->CharWidth[gl[glyph].first] * 1000))+" ");
1010
                                                        glIndexName.Code = chCount + Fc * 256;
1011
                                                        glIndexName.Name = "/" + gl[glyph].second;
1012
                                                        glyphIndexes[gl[glyph].first] = glIndexName;
1013
                                                }
1014
                                                else
1015
                                                        PutDoc("0 ");
1016
                                                chCount++;
1017
                                                if (signed(glyph) == nglyphs-1)
3133 fschmid 1018
                                                        break;
1019
                                        }
1020
                                        PutDoc("]\nendobj\n");
1021
                                        ObjCounter++;
1022
                                        StartObj(ObjCounter);
1023
                                        ObjCounter++;
11098 jghali 1024
                                        QStringList toUnicodeMaps;
1025
                                        QValueList<int> toUnicodeMapsCount;
1026
                                        QString toUnicodeMap = "";
1027
                                        int toUnicodeMapCounter = 0;
3133 fschmid 1028
                                        PutDoc("<< /Type /Encoding\n");
11098 jghali 1029
                                        PutDoc("/Differences [ \n");
3133 fschmid 1030
                                        int crc = 0;
11098 jghali 1031
                                        bool startOfSeq = true;
3133 fschmid 1032
                                        for (int ww2 = 32; ww2 < 256; ++ww2)
1033
                                        {
11098 jghali 1034
                                                uint glyph = 224 * Fc + ww2 - 32;
1035
                                                QMap<uint,std::pair<uint,QString> >::Iterator glIt = gl.find(glyph);
1036
                                                if (glIt != gl.end() && !glIt.data().second.isEmpty())
1037
                                                {
1038
                                                        if (startOfSeq)
1039
                                                        {
1040
                                                                PutDoc(QString::number(ww2)+" ");
1041
                                                                startOfSeq = false;
1042
                                                        }
1043
                                                        PutDoc("/"+glIt.data().second+" ");
1044
                                                        QString tmp, tmp2;
1045
                                                        tmp.sprintf("%02X", ww2);
1046
                                                        tmp2.sprintf("%04X", glIt.data().first);
1047
                                                        toUnicodeMap += QString("<%1> <%2>\n").arg(tmp).arg((tmp2));
1048
                                                        toUnicodeMapCounter++;
1049
                                                        if (toUnicodeMapCounter == 100)
1050
                                                        {
1051
                                                                toUnicodeMaps.append(toUnicodeMap);
1052
                                                                toUnicodeMapsCount.append(toUnicodeMapCounter);
1053
                                                                toUnicodeMap = "";
1054
                                                                toUnicodeMapCounter = 0;
1055
                                                        }
1056
                                                        crc++;
1057
                                                }
1058
                                                else
1059
                                                {
1060
                                                        startOfSeq = true;
1061
                                                }
1062
                                                if (signed(glyph) == nglyphs-1)
3133 fschmid 1063
                                                        break;
1064
                                                if (crc > 8)
1065
                                                {
1066
                                                        PutDoc("\n");
1067
                                                        crc = 0;
1068
                                                }
1069
                                        }
11098 jghali 1070
                                        if (toUnicodeMapCounter != 0)
1071
                                        {
1072
                                                toUnicodeMaps.append(toUnicodeMap);
1073
                                                toUnicodeMapsCount.append(toUnicodeMapCounter);
1074
                                        }
3133 fschmid 1075
                                        PutDoc("]\n");
1076
                                        PutDoc(">>\nendobj\n");
11098 jghali 1077
                                        QString toUnicodeMapStream = "";
1078
                                        toUnicodeMapStream += "/CIDInit /ProcSet findresource begin\n";
1079
                                        toUnicodeMapStream += "12 dict begin\n";
1080
                                        toUnicodeMapStream += "begincmap\n";
1081
                                        toUnicodeMapStream += "/CIDSystemInfo <<\n";
1082
                                        toUnicodeMapStream += "/Registry (Adobe)\n";
1083
                                        toUnicodeMapStream += "/Ordering (UCS)\n";
1084
                                        toUnicodeMapStream += "/Supplement 0\n";
1085
                                        toUnicodeMapStream += ">> def\n";
1086
                                        toUnicodeMapStream += "/CMapName /Adobe-Identity-UCS def\n";
1087
                                        toUnicodeMapStream += "/CMapType 2 def\n";
1088
                                        toUnicodeMapStream += "1 begincodespacerange\n";
1089
                                        toUnicodeMapStream += "<0000> <FFFF>\n";
1090
                                        toUnicodeMapStream += "endcodespacerange\n";
1091
                                        for (uint uniC = 0; uniC < toUnicodeMaps.count(); uniC++)
1092
                                        {
1093
                                                toUnicodeMapStream += QString("%1 beginbfchar\n").arg(toUnicodeMapsCount[uniC]);
1094
                                                toUnicodeMapStream += toUnicodeMaps[uniC];
1095
                                                toUnicodeMapStream += "endbfchar\n";
1096
                                        }
1097
                                        toUnicodeMapStream += "endcmap\n";
1098
                                        toUnicodeMapStream += "CMapName currentdict /CMap defineresource pop\n";
1099
                                        toUnicodeMapStream += "end\n";
1100
                                        toUnicodeMapStream += "end\n";
1101
                                        WritePDFStream(toUnicodeMapStream);
3133 fschmid 1102
                                        StartObj(ObjCounter);
1103
                                        PutDoc("<<\n/Type /Font\n/Subtype ");
1104
                                        PutDoc((fformat == Foi::SFNT || fformat == Foi::TTCF) ? "/TrueType\n" : "/Type1\n");
4229 craig 1105
                                        PutDoc("/Name /Fo"+QString::number(a)+"S"+QString::number(Fc)+"\n");
3440 fschmid 1106
                                        PutDoc("/BaseFont /"+AllFonts[it.key()]->RealName().replace( QRegExp("[\\s\\/\\{\\[\\]\\}\\<\\>\\(\\)\\%]"), "_" )+"\n");
3133 fschmid 1107
                                        PutDoc("/FirstChar 0\n");
4229 craig 1108
                                        PutDoc("/LastChar "+QString::number(chCount-1)+"\n");
11098 jghali 1109
                                        PutDoc("/Widths "+QString::number(ObjCounter-3)+" 0 R\n");
1110
                                        PutDoc("/Encoding "+QString::number(ObjCounter-2)+" 0 R\n");
1111
                                        PutDoc("/ToUnicode "+QString::number(ObjCounter-1)+" 0 R\n");
4229 craig 1112
                                        PutDoc("/FontDescriptor "+QString::number(FontDes)+" 0 R\n");
3133 fschmid 1113
                                        PutDoc(">>\nendobj\n");
4229 craig 1114
                                        Seite.FObjects["Fo"+QString::number(a)+"S"+QString::number(Fc)] = ObjCounter;
3133 fschmid 1115
                                        ObjCounter++;
11098 jghali 1116
                                } // for(Fc)
1117
                                GlyphsIdxOfFont.insert(it.key(), glyphIndexes);
1118
                                StartObj(ObjCounter);
1119
                                PutDoc("[ 0 0 0 0 0  0 0 0 0 0  0 0 0 0 0  0 0 0 0 0  0 0 0 0 0  0 0 0 0 0  0 0 ");
1120
                                for (int ww = 32; ww < 256; ++ww)
1121
                                {
1122
                                        uint glyph = 99999999;
1123
                                        for (gli = gl.begin(); gli != gl.end(); ++gli)
8431 fschmid 1124
                                        {
11098 jghali 1125
                                                ushort uni = gli.data().first;
1126
                                                if (uni == ww)
1127
                                                {
1128
                                                        glyph = gli.key();
1129
                                                        break;
1130
                                                }
8431 fschmid 1131
                                        }
11098 jghali 1132
                                        if (gl.contains(glyph))
1133
                                                PutDoc(QString::number(static_cast<int>(AllFonts[it.key()]->CharWidth[gl[glyph].first]* 1000))+" ");
1134
                                        else
1135
                                                PutDoc("0 ");
1136
                                }
1137
                                PutDoc("]\nendobj\n");
1138
                                ObjCounter++;
1139
                                StartObj(ObjCounter);
1140
                                PutDoc("<<\n/Type /Font\n/Subtype ");
1141
                                PutDoc((fformat == Foi::SFNT || fformat == Foi::TTCF) ? "/TrueType\n" : "/Type1\n");
1142
//                              if (fformat == Foi::SFNT || fformat == ScFace::TTCF)
1143
//                              {
1144
//                                      PutDoc("/TrueType\n");
1145
                                        PutDoc("/Name /Fo"+QString::number(a)+"Form"+"\n");
1146
                                        Seite.FObjects["Fo"+QString::number(a)+"Form"] = ObjCounter;
1147
                                        UsedFontsF.insert(it.key(), "/Fo"+QString::number(a)+"Form");
1148
/*                              }
1149
                                else
1150
                                {
1151
                                        PutDoc("/Type1\n");
1152
                                        PutDoc("/Name /"+AllFonts[it.key()].psName().replace( QRegExp("[\\s\\/\\{\\[\\]\\}\\<\\>\\(\\)\\%]"), "_" )+"\n");
1153
                                        Seite.FObjects[AllFonts[it.key()].psName().replace( QRegExp("[\\s\\/\\{\\[\\]\\}\\<\\>\\(\\)\\%]"), "_" )] = ObjCounter;
1154
                                        UsedFontsF.insert(it.key(), "/"+AllFonts[it.key()].psName().replace( QRegExp("[\\s\\/\\{\\[\\]\\}\\<\\>\\(\\)\\%]"), "_" ));
1155
                                } */
1156
                                PutDoc("/BaseFont /"+AllFonts[it.key()]->RealName().replace( QRegExp("[\\s\\/\\{\\[\\]\\}\\<\\>\\(\\)\\%]"), "_" )+"\n");
1157
                                PutDoc("/Encoding << \n");
1158
                                PutDoc("/Differences [ \n");
1159
                                PutDoc("24 /breve /caron /circumflex /dotaccent /hungarumlaut /ogonek /ring /tilde\n");
1160
                                PutDoc("39 /quotesingle 96 /grave 128 /bullet /dagger /daggerdbl /ellipsis /emdash /endash /florin /fraction /guilsinglleft /guilsinglright\n");
1161
                                PutDoc("/minus /perthousand /quotedblbase /quotedblleft /quotedblright /quoteleft /quoteright /quotesinglbase /trademark /fi /fl /Lslash /OE /Scaron\n");
1162
                                PutDoc("/Ydieresis /Zcaron /dotlessi /lslash /oe /scaron /zcaron 164 /currency 166 /brokenbar 168 /dieresis /copyright /ordfeminine 172 /logicalnot\n");
1163
                                PutDoc("/.notdef /registered /macron /degree /plusminus /twosuperior /threesuperior /acute /mu 183 /periodcentered /cedilla /onesuperior /ordmasculine\n");
1164
                                PutDoc("188 /onequarter /onehalf /threequarters 192 /Agrave /Aacute /Acircumflex /Atilde /Adieresis /Aring /AE /Ccedilla /Egrave /Eacute /Ecircumflex\n");
1165
                                PutDoc("/Edieresis /Igrave /Iacute /Icircumflex /Idieresis /Eth /Ntilde /Ograve /Oacute /Ocircumflex /Otilde /Odieresis /multiply /Oslash\n");
1166
                                PutDoc("/Ugrave /Uacute /Ucircumflex /Udieresis /Yacute /Thorn /germandbls /agrave /aacute /acircumflex /atilde /adieresis /aring /ae /ccedilla\n");
1167
                                PutDoc("/egrave /eacute /ecircumflex /edieresis /igrave /iacute /icircumflex /idieresis /eth /ntilde /ograve /oacute /ocircumflex /otilde /odieresis\n");
1168
                                PutDoc("/divide /oslash /ugrave /uacute /ucircumflex /udieresis /yacute /thorn /ydieresis\n");
1169
                                PutDoc("] >>\n");
1170
                                PutDoc("/FirstChar 0\n");
1171
                                PutDoc("/LastChar 255\n");
1172
                                PutDoc("/Widths "+QString::number(ObjCounter-1)+" 0 R\n");
1173
                                PutDoc("/FontDescriptor "+QString::number(FontDes)+" 0 R\n");
1174
                                PutDoc(">>\nendobj\n");
1175
                                ObjCounter++;
3133 fschmid 1176
//                      } // FT_Has_PS_Glyph_Names
1177
                }
1178
                a++;
1179
        }
4264 craig 1180
        if (Options.UseLPI)
3133 fschmid 1181
        {
1182
                StartObj(ObjCounter);
1183
                PutDoc("<<\n/Type /Halftone\n/HalftoneType 5\n");
4264 craig 1184
                QMap<QString,LPIData>::const_iterator itlp;
1185
                for (itlp = Options.LPISettings.constBegin(); itlp != Options.LPISettings.constEnd(); ++itlp)
3133 fschmid 1186
                {
1187
                        PutDoc("/"+itlp.key()+"\n<<\n/Type /Halftone\n/HalftoneType 1\n/Frequency ");
4229 craig 1188
                        PutDoc(QString::number(itlp.data().Frequency)+"\n/Angle "+QString::number(itlp.data().Angle)+"\n/SpotFunction ");
3829 cbradney 1189
                        QString func ("");
3133 fschmid 1190
                        switch (itlp.data().SpotFunc)
1191
                        {
1192
                                case 0:
1193
                                        func = "/SimpleDot";
1194
                                        break;
1195
                                case 1:
1196
                                        func = "/Line";
1197
                                        break;
1198
                                case 2:
1199
                                        func = "/Round";
1200
                                        break;
1201
                                case 3:
1202
                                        func = "/Ellipse";
1203
                                        break;
1204
                                default:
1205
                                        func = "/SimpleDot";
1206
                                        break;
1207
                        }
1208
                        PutDoc(func+"\n>>\n");
1209
                }
1210
                PutDoc("/Default\n<<\n/Type /Halftone\n/HalftoneType 1\n/Frequency 50\n/Angle 45\n/SpotFunction /Round\n>>\n");
1211
                PutDoc(">>\nendobj\n");
1212
                ObjCounter++;
1213
                StartObj(ObjCounter);
4229 craig 1214
                HTName = ResNam+QString::number(ResCount);
3133 fschmid 1215
                Transpar[HTName] = ObjCounter;
4229 craig 1216
                PutDoc("<< /Type /ExtGState\n/HT "+QString::number(ObjCounter-1)+" 0 R\n>>\nendobj\n");
3133 fschmid 1217
                ResCount++;
1218
                ObjCounter++;
1219
        }
1220
#ifdef HAVE_CMS
4264 craig 1221
        if ((CMSuse) && (Options.UseProfiles))
3133 fschmid 1222
        {
1223
                StartObj(ObjCounter);
1224
                ObjCounter++;
1225
                QString dataP;
1226
                struct ICCD dataD;
4264 craig 1227
                loadText(ScMW->InputProfiles[Options.SolidProf], &dataP);
3133 fschmid 1228
                PutDoc("<<\n");
4264 craig 1229
                if ((Options.Compress) && (CompAvail))
3133 fschmid 1230
                {
1231
                        PutDoc("/Filter /FlateDecode\n");
1232
                        dataP = CompressStr(&dataP);
1233
                }
4229 craig 1234
                PutDoc("/Length "+QString::number(dataP.length()+1)+"\n");
4264 craig 1235
                PutDoc("/N "+QString::number(Options.SComp)+"\n");
4229 craig 1236
                PutDoc(">>\nstream\n"+EncStream(dataP, ObjCounter-1)+"\nendstream\nendobj\n");
3133 fschmid 1237
                StartObj(ObjCounter);
4229 craig 1238
                dataD.ResName = ResNam+QString::number(ResCount);
1239
                dataD.ICCArray = "[ /ICCBased "+QString::number(ObjCounter-1)+" 0 R ]";
3133 fschmid 1240
                dataD.ResNum = ObjCounter;
4264 craig 1241
                ICCProfiles[Options.SolidProf] = dataD;
4229 craig 1242
                PutDoc("[ /ICCBased "+QString::number(ObjCounter-1)+" 0 R ]\n");
3133 fschmid 1243
                PutDoc("endobj\n");
1244
                ResCount++;
1245
                ObjCounter++;
1246
        }
1247
#endif
4264 craig 1248
        if (((Options.isGrayscale == false) && (Options.UseRGB == false)) && (Options.UseSpotColors))
3133 fschmid 1249
        {
4264 craig 1250
                doc.getUsedColors(colorsToUse);
3133 fschmid 1251
                ColorList::Iterator itf;
1252
                for (itf = colorsToUse.begin(); itf != colorsToUse.end(); ++itf)
1253
                {
1254
                        if ((colorsToUse[itf.key()].isSpotColor()) || (colorsToUse[itf.key()].isRegistrationColor()))
1255
                        {
1256
                                int cc, cm, cy, ck;
1257
                                struct SpotC spotD;
1258
                                colorsToUse[itf.key()].getCMYK(&cc, &cm, &cy, &ck);
1259
                                QString colorDesc = "{\ndup "+FToStr(static_cast<double>(cc) / 255)+"\nmul exch dup ";
1260
                                colorDesc += FToStr(static_cast<double>(cm) / 255)+"\nmul exch dup ";
1261
                                colorDesc += FToStr(static_cast<double>(cy) / 255)+"\nmul exch ";
1262
                                colorDesc += FToStr(static_cast<double>(ck) / 255)+" mul }";
1263
                                StartObj(ObjCounter);
1264
                                ObjCounter++;
1265
                                PutDoc("<<\n/FunctionType 4\n");
1266
                                PutDoc("/Domain [0.0 1.0]\n");
1267
                                PutDoc("/Range [0.0 1.0 0.0 1.0 0.0 1.0 0.0 1.0]\n");
4229 craig 1268
                                PutDoc("/Length "+QString::number(colorDesc.length()+1)+"\n");
1269
                                PutDoc(">>\nstream\n"+EncStream(colorDesc, ObjCounter-1)+"\nendstream\nendobj\n");
3133 fschmid 1270
                                StartObj(ObjCounter);
1271
                                PutDoc("[ /Separation /");
1272
                                if (colorsToUse[itf.key()].isRegistrationColor())
1273
                                        PutDoc("All");
1274
                                else
7490 fschmid 1275
                                        PutDoc(itf.key().simplifyWhiteSpace().replace("#", "#23").replace( QRegExp("[\\s\\/\\{\\[\\]\\}\\<\\>\\(\\)\\%]"), "#20" ));
4229 craig 1276
                                PutDoc(" /DeviceCMYK "+QString::number(ObjCounter-1)+" 0 R ]\nendobj\n");
1277
                                spotD.ResName = spotNam+QString::number(spotCount);
3133 fschmid 1278
                                spotD.ResNum = ObjCounter;
1279
                                spotMap.insert(itf.key(), spotD);
1280
                                spotCount++;
1281
                                ObjCounter++;
1282
                        }
1283
                }
1284
        }
4264 craig 1285
        if ((Options.Version == 15) && (Options.useLayers))
3133 fschmid 1286
        {
1287
                struct Layer ll;
1288
                struct OCGInfo ocg;
1289
                ll.isPrintable = false;
1290
                ll.LNr = 0;
1291
                int Lnr = 0;
3829 cbradney 1292
                QString ocgNam("oc");
4264 craig 1293
                uint docLayersCount=doc.Layers.count();
3829 cbradney 1294
                for (uint la = 0; la < docLayersCount; ++la)
3133 fschmid 1295
                {
3829 cbradney 1296
                        QString tmp("");
4264 craig 1297
                        Level2Layer(&doc, &ll, Lnr);
3133 fschmid 1298
                        ocg.Name = ocgNam+tmp.setNum(ll.LNr);
1299
                        ocg.ObjNum = ObjCounter;
1300
                        ocg.visible = ll.isViewable;
1301
                        OCGEntries.insert(ll.Name, ocg);
1302
                        StartObj(ObjCounter);
1303
                        ObjCounter++;
1304
                        PutDoc("<<\n");
1305
                        PutDoc("/Type /OCG\n");
7329 fschmid 1306
                        PutDoc("/Name ");
1307
                        PutDoc(EncStringUTF16("("+ll.Name+")", ObjCounter-1));
1308
                        PutDoc("\n");
3133 fschmid 1309
                        PutDoc(">>\nendobj\n");
1310
                        Lnr++;
1311
                }
1312
        }
1313
        return true;
1314
}
1315
 
4241 craig 1316
void PDFlib::PDF_TemplatePage(const Page* pag, bool )
3133 fschmid 1317
{
1318
        QString tmp;
1319
        ActPageP = pag;
1320
        PageItem* ite;
1321
        QPtrList<PageItem> PItems;
1322
        int Lnr = 0;
1323
        struct Layer ll;
1324
        ll.isPrintable = false;
1325
        ll.LNr = 0;
1326
        Inhalt = "";
1327
        Seite.AObjects.clear();
4264 craig 1328
        for (uint la = 0; la < doc.Layers.count(); ++la)
3133 fschmid 1329
        {
4264 craig 1330
                Level2Layer(&doc, &ll, Lnr);
1331
                PItems = doc.MasterItems;
3133 fschmid 1332
                if (ll.isPrintable)
1333
                {
4264 craig 1334
                        if ((Options.Version == 15) && (Options.useLayers))
3133 fschmid 1335
                                PutPage("/OC /"+OCGEntries[ll.Name].Name+" BDC\n");
1336
                        for (uint a = 0; a < PItems.count(); ++a)
1337
                        {
1338
                                Inhalt = "";
1339
                                ite =PItems.at(a);
1340
                                if (ite->LayerNr != ll.LNr)
1341
                                        continue;
4726 fschmid 1342
                                double x = pag->xOffset();
1343
                                double y = pag->yOffset();
1344
                                double w = pag->width();
1345
                                double h1 = pag->height();
4580 cbradney 1346
                                double ilw=ite->lineWidth();
4726 fschmid 1347
                                double x2 = ite->BoundingX - ilw / 2.0;
1348
                                double y2 = ite->BoundingY - ilw / 2.0;
1349
                                double w2 = ite->BoundingW + ilw;
1350
                                double h2 = ite->BoundingH + ilw;
1351
                                if (!( QMAX( x, x2 ) <= QMIN( x+w, x2+w2 ) && QMAX( y, y2 ) <= QMIN( y+h1, y2+h2 )))
3133 fschmid 1352
                                        continue;
1353
                                if (ite->ChangedMasterItem)
1354
                                        continue;
3200 cbradney 1355
                                if ((!pag->PageNam.isEmpty()) && (ite->OwnPage != static_cast<int>(pag->pageNr())) && (ite->OwnPage != -1))
3133 fschmid 1356
                                        continue;
1357
                                PutPage("q\n");
4264 craig 1358
                                if (((ite->fillTransparency() != 0) || (ite->lineTransparency() != 0)) && (Options.Version >= 14))
3133 fschmid 1359
                                        PutPage(PDF_Transparenz(ite));
4679 fschmid 1360
/* Bookmarks on Master Pages do not make any sense */
1361
//                              if ((ite->isBookmark) && (Options.Bookmarks))
1362
//                                      PDF_Bookmark(ite, pag->height() - (ite->yPos() - pag->yOffset()));
4698 cbradney 1363
                                if (!ite->printEnabled() || ((ite->itemType() == PageItem::TextFrame) && (!pag->PageNam.isEmpty())))
3133 fschmid 1364
                                {
1365
                                        PutPage("Q\n");
1366
                                        continue;
1367
                                }
4546 subik 1368
                                if (ite->fillColor() != CommonStrings::None)
3133 fschmid 1369
                                        PutPage(putColor(ite->fillColor(), ite->fillShade(), true));
4546 subik 1370
                                if (ite->lineColor() != CommonStrings::None)
3133 fschmid 1371
                                        PutPage(putColor(ite->lineColor(), ite->lineShade(), false));
4580 cbradney 1372
                                Inhalt += FToStr(fabs(ite->lineWidth()))+" w\n";
3133 fschmid 1373
                                if (ite->DashValues.count() != 0)
1374
                                {
1375
                                        PutPage("[ ");
1376
                                        QValueList<double>::iterator it;
1377
                                        for ( it = ite->DashValues.begin(); it != ite->DashValues.end(); ++it )
1378
                                        {
1379
                                                int da = static_cast<int>(*it);
1380
                                                if (da != 0)
4229 craig 1381
                                                        PutPage(QString::number(da)+" ");
3133 fschmid 1382
                                        }
4229 craig 1383
                                        PutPage("] "+QString::number(static_cast<int>(ite->DashOffset))+" d\n");
3133 fschmid 1384
                                }
1385
                                else
1386
                                {
4580 cbradney 1387
                                        QString Dt = FToStr(QMAX(2*fabs(ite->lineWidth()), 1));
1388
                                        QString Da = FToStr(QMAX(6*fabs(ite->lineWidth()), 1));
3133 fschmid 1389
                                        switch (ite->PLineArt)
1390
                                        {
1391
                                                case Qt::SolidLine:
1392
                                                        PutPage("[] 0 d\n");
1393
                                                        break;
1394
                                                case Qt::DashLine:
1395
                                                        PutPage("["+Da+" "+Dt+"] 0 d\n");
1396
                                                        break;
1397
                                                case Qt::DotLine:
1398
                                                        PutPage("["+Dt+"] 0 d\n");
1399
                                                        break;
1400
                                                case Qt::DashDotLine:
1401
                                                        PutPage("["+Da+" "+Dt+" "+Dt+" "+Dt+"] 0 d\n");
1402
                                                        break;
1403
                                                case Qt::DashDotDotLine:
1404
                                                        PutPage("["+Da+" "+Dt+" "+Dt+" "+Dt+" "+Dt+" "+Dt+"] 0 d\n");
1405
                                                        break;
1406
                                                default:
1407
                                                        PutPage("[] 0 d\n");
1408
                                                        break;
1409
                                        }
1410
                                }
1411
                                switch (ite->PLineEnd)
1412
                                {
1413
                                        case Qt::FlatCap:
1414
                                                PutPage("0 J\n");
1415
                                                break;
1416
                                        case Qt::SquareCap:
1417
                                                PutPage("2 J\n");
1418
                                                break;
1419
                                        case Qt::RoundCap:
1420
                                                PutPage("1 J\n");
1421
                                                break;
1422
                                        default:
1423
                                                PutPage("0 J\n");
1424
                                                break;
1425
                                }
1426
                                switch (ite->PLineJoin)
1427
                                {
1428
                                        case Qt::MiterJoin:
1429
                                                PutPage("0 j\n");
1430
                                                break;
1431
                                        case Qt::BevelJoin:
1432
                                                PutPage("2 j\n");
1433
                                                break;
1434
                                        case Qt::RoundJoin:
1435
                                                PutPage("1 j\n");
1436
                                                break;
1437
                                        default:
1438
                                                PutPage("0 j\n");
1439
                                                break;
1440
                                }
3903 cbradney 1441
                                PutPage("1 0 0 1 "+FToStr(ite->xPos() - pag->xOffset())+" "+FToStr(pag->height() - (ite->yPos()  - pag->yOffset()))+" cm\n");
3934 cbradney 1442
                                if (ite->rotation() != 0)
3133 fschmid 1443
                                {
3934 cbradney 1444
                                        double sr = sin(-ite->rotation()* M_PI / 180.0);
1445
                                        double cr = cos(-ite->rotation()* M_PI / 180.0);
3133 fschmid 1446
                                        if ((cr * cr) < 0.000001)
1447
                                                cr = 0;
1448
                                        if ((sr * sr) < 0.000001)
1449
                                                sr = 0;
1450
                                        PutPage(FToStr(cr)+" "+FToStr(sr)+" "+FToStr(-sr)+" "+FToStr(cr)+" 0 0 cm\n");
1451
                                }
1452
                                switch (ite->itemType())
1453
                                {
1454
                                        case PageItem::ImageFrame:
4546 subik 1455
                                                if ((ite->fillColor() != CommonStrings::None) || (ite->GrType != 0))
3133 fschmid 1456
                                                {
1457
                                                        if (ite->GrType != 0)
1458
                                                                PutPage(PDF_Gradient(ite));
1459
                                                        else
1460
                                                        {
1461
                                                                PutPage(SetClipPath(ite));
1462
                                                                PutPage("h\nf*\n");
1463
                                                        }
1464
                                                }
1465
                                                PutPage("q\n");
1466
                                                if (ite->imageClip.size() != 0)
4744 fschmid 1467
                                                {
3133 fschmid 1468
                                                        PutPage(SetClipPathImage(ite));
4744 fschmid 1469
                                                        PutPage("h\nW*\nn\n");
1470
                                                }
1471
                                                PutPage(SetClipPath(ite));
3133 fschmid 1472
                                                PutPage("h\nW*\nn\n");
1473
                                                if (ite->imageFlippedH())
3934 cbradney 1474
                                                        PutPage("-1 0 0 1 "+FToStr(ite->width())+" 0 cm\n");
3133 fschmid 1475
                                                if (ite->imageFlippedV())
3934 cbradney 1476
                                                        PutPage("1 0 0 -1 0 "+FToStr(-ite->height())+" cm\n");
3133 fschmid 1477
                                                if ((ite->PicAvail) && (!ite->Pfile.isEmpty()))
3985 cbradney 1478
                                                        PutPage(PDF_Image(ite, ite->Pfile, ite->imageXScale(), ite->imageYScale(), ite->imageXOffset(), -ite->imageYOffset(), false, ite->IProfile, ite->UseEmbedded, ite->IRender));
3133 fschmid 1479
                                                PutPage("Q\n");
4546 subik 1480
                                                if (((ite->lineColor() != CommonStrings::None) || (!ite->NamedLStyle.isEmpty())) && (!ite->isTableItem))
3133 fschmid 1481
                                                {
4580 cbradney 1482
                                                        if ((ite->NamedLStyle.isEmpty()) && (ite->lineWidth() != 0.0))
3133 fschmid 1483
                                                        {
1484
                                                                PutPage(SetClipPath(ite));
1485
                                                                PutPage("h\nS\n");
1486
                                                        }
1487
                                                        else
1488
                                                        {
4264 craig 1489
                                                                multiLine ml = doc.MLineStyles[ite->NamedLStyle];
3133 fschmid 1490
                                                                for (int it = ml.size()-1; it > -1; it--)
1491
                                                                {
6569 fschmid 1492
                                                                        if ((ml[it].Color != CommonStrings::None) && (ml[it].Width != 0))
1493
                                                                        {
1494
                                                                                PutPage(setStrokeMulti(&ml[it]));
1495
                                                                                PutPage(SetClipPath(ite));
1496
                                                                                PutPage("h\nS\n");
1497
                                                                        }
3133 fschmid 1498
                                                                }
1499
                                                        }
1500
                                                }
1501
                                                break;
1502
                                        case PageItem::TextFrame:
1503
                                                break;
1504
                                        case PageItem::Line:
1505
                                                if (ite->NamedLStyle.isEmpty())
1506
                                                {
1507
                                                        PutPage("0 0 m\n");
3934 cbradney 1508
                                                        PutPage(FToStr(ite->width())+" 0 l\n");
3133 fschmid 1509
                                                        PutPage("S\n");
1510
                                                }
1511
                                                else
1512
                                                {
4264 craig 1513
                                                        multiLine ml = doc.MLineStyles[ite->NamedLStyle];
3133 fschmid 1514
                                                        for (int it = ml.size()-1; it > -1; it--)
1515
                                                        {
6569 fschmid 1516
                                                                if ((ml[it].Color != CommonStrings::None) && (ml[it].Width != 0))
1517
                                                                {
1518
                                                                        PutPage(setStrokeMulti(&ml[it]));
1519
                                                                        PutPage("0 0 m\n");
1520
                                                                        PutPage(FToStr(ite->width())+" 0 l\n");
1521
                                                                        PutPage("S\n");
1522
                                                                }
3133 fschmid 1523
                                                        }
1524
                                                }
4061 craig 1525
                                                if (ite->startArrowIndex() != 0)
3133 fschmid 1526
                                                {
1527
                                                        QWMatrix arrowTrans;
4264 craig 1528
                                                        FPointArray arrow = (*doc.arrowStyles.at(ite->startArrowIndex()-1)).points.copy();
3133 fschmid 1529
                                                        arrowTrans.translate(0, 0);
4580 cbradney 1530
                                                        arrowTrans.scale(ite->lineWidth(), ite->lineWidth());
3133 fschmid 1531
                                                        arrowTrans.scale(-1,1);
1532
                                                        arrow.map(arrowTrans);
4264 craig 1533
                                                        if ((ite->lineTransparency() != 0) && (Options.Version >= 14))
3133 fschmid 1534
                                                        {
1535
                                                                StartObj(ObjCounter);
4229 craig 1536
                                                                QString ShName = ResNam+QString::number(ResCount);
3133 fschmid 1537
                                                                Transpar[ShName] = ObjCounter;
1538
                                                                ResCount++;
1539
                                                                ObjCounter++;
1540
                                                                PutDoc("<< /Type /ExtGState\n");
1541
                                                                PutDoc("/CA "+FToStr(1.0 - ite->lineTransparency())+"\n");
1542
                                                                PutDoc("/ca "+FToStr(1.0 - ite->lineTransparency())+"\n");
1543
                                                                PutDoc("/SMask /None\n/AIS false\n/OPM 1\n");
1544
                                                                PutDoc("/BM /Normal\n>>\nendobj\n");
1545
                                                                PutPage("/"+ShName+" gs\n");
1546
                                                        }
4016 fschmid 1547
                                                        PutPage(putColor(ite->lineColor(), ite->lineShade(), true));
3133 fschmid 1548
                                                        PutPage(SetClipPathArray(&arrow));
1549
                                                        PutPage("h\nf*\n");
1550
                                                }
4061 craig 1551
                                                if (ite->endArrowIndex() != 0)
3133 fschmid 1552
                                                {
1553
                                                        QWMatrix arrowTrans;
4264 craig 1554
                                                        FPointArray arrow = (*doc.arrowStyles.at(ite->endArrowIndex()-1)).points.copy();
3934 cbradney 1555
                                                        arrowTrans.translate(ite->width(), 0);
4580 cbradney 1556
                                                        arrowTrans.scale(ite->lineWidth(), ite->lineWidth());
3133 fschmid 1557
                                                        arrow.map(arrowTrans);
4264 craig 1558
                                                        if ((ite->lineTransparency() != 0) && (Options.Version >= 14))
3133 fschmid 1559
                                                        {
1560
                                                                StartObj(ObjCounter);
4229 craig 1561
                                                                QString ShName = ResNam+QString::number(ResCount);
3133 fschmid 1562
                                                                Transpar[ShName] = ObjCounter;
1563
                                                                ResCount++;
1564
                                                                ObjCounter++;
1565
                                                                PutDoc("<< /Type /ExtGState\n");
1566
                                                                PutDoc("/CA "+FToStr(1.0 - ite->lineTransparency())+"\n");
1567
                                                                PutDoc("/ca "+FToStr(1.0 - ite->lineTransparency())+"\n");
1568
                                                                PutDoc("/SMask /None\n/AIS false\n/OPM 1\n");
1569
                                                                PutDoc("/BM /Normal\n>>\nendobj\n");
1570
                                                                PutPage("/"+ShName+" gs\n");
1571
                                                        }
4016 fschmid 1572
                                                        PutPage(putColor(ite->lineColor(), ite->lineShade(), true));
3133 fschmid 1573
                                                        PutPage(SetClipPathArray(&arrow));
1574
                                                        PutPage("h\nf*\n");
1575
                                                }
1576
                                                break;
3232 cbradney 1577
                                        case PageItem::ItemType1:
1578
                                        case PageItem::ItemType3:
3133 fschmid 1579
                                        case PageItem::Polygon:
1580
                                                if (ite->GrType != 0)
1581
                                                        PutPage(PDF_Gradient(ite));
1582
                                                else
1583
                                                {
4546 subik 1584
                                                        if (ite->fillColor() != CommonStrings::None)
3133 fschmid 1585
                                                        {
1586
                                                                PutPage(SetClipPath(ite));
1587
                                                                PutPage("h\nf*\n");
1588
                                                        }
1589
                                                }
4546 subik 1590
                                                if ((ite->lineColor() != CommonStrings::None) || (!ite->NamedLStyle.isEmpty()))
3133 fschmid 1591
                                                {
4580 cbradney 1592
                                                        if ((ite->NamedLStyle.isEmpty()) && (ite->lineWidth() != 0.0))
3133 fschmid 1593
                                                        {
1594
                                                                PutPage(SetClipPath(ite));
1595
                                                                PutPage("h\nS\n");
1596
                                                        }
1597
                                                        else
1598
                                                        {
4264 craig 1599
                                                                multiLine ml = doc.MLineStyles[ite->NamedLStyle];
3133 fschmid 1600
                                                                for (int it = ml.size()-1; it > -1; it--)
1601
                                                                {
6569 fschmid 1602
                                                                        if ((ml[it].Color != CommonStrings::None) && (ml[it].Width != 0))
1603
                                                                        {
1604
                                                                                PutPage(setStrokeMulti(&ml[it]));
1605
                                                                                PutPage(SetClipPath(ite));
1606
                                                                                PutPage("h\nS\n");
1607
                                                                        }
3133 fschmid 1608
                                                                }
1609
                                                        }
1610
                                                }
1611
                                                break;
1612
                                        case PageItem::PolyLine:
4658 fschmid 1613
                                                if (ite->PoLine.size() > 4) // && ((ite->PoLine.point(0) != ite->PoLine.point(1)) || (ite->PoLine.point(2) != ite->PoLine.point(3))))
3133 fschmid 1614
                                                {
1615
                                                        if (ite->GrType != 0)
1616
                                                                PutPage(PDF_Gradient(ite));
1617
                                                        else
1618
                                                        {
4546 subik 1619
                                                                if (ite->fillColor() != CommonStrings::None)
3133 fschmid 1620
                                                                {
1621
                                                                        PutPage(SetClipPath(ite));
1622
                                                                        PutPage("h\nf*\n");
1623
                                                                }
1624
                                                        }
1625
                                                }
4546 subik 1626
                                                if ((ite->lineColor() != CommonStrings::None) || (!ite->NamedLStyle.isEmpty()))
3133 fschmid 1627
                                                {
4580 cbradney 1628
                                                        if ((ite->NamedLStyle.isEmpty()) && (ite->lineWidth() != 0.0))
3133 fschmid 1629
                                                        {
1630
                                                                PutPage(SetClipPath(ite, false));
1631
                                                                PutPage("S\n");
1632
                                                        }
1633
                                                        else
1634
                                                        {
4264 craig 1635
                                                                multiLine ml = doc.MLineStyles[ite->NamedLStyle];
3133 fschmid 1636
                                                                for (int it = ml.size()-1; it > -1; it--)
1637
                                                                {
6569 fschmid 1638
                                                                        if ((ml[it].Color != CommonStrings::None) && (ml[it].Width != 0))
1639
                                                                        {
1640
                                                                                PutPage(setStrokeMulti(&ml[it]));
1641
                                                                                PutPage(SetClipPath(ite, false));
1642
                                                                                PutPage("S\n");
1643
                                                                        }
3133 fschmid 1644
                                                                }
1645
                                                        }
1646
                                                }
4061 craig 1647
                                                if (ite->startArrowIndex() != 0)
3133 fschmid 1648
                                                {
1649
                                                        FPoint Start = ite->PoLine.point(0);
1650
                                                        for (uint xx = 1; xx < ite->PoLine.size(); xx += 2)
1651
                                                        {
1652
                                                                FPoint Vector = ite->PoLine.point(xx);
1653
                                                                if ((Start.x() != Vector.x()) || (Start.y() != Vector.y()))
1654
                                                                {
1655
                                                                        double r = atan2(Start.y()-Vector.y(),Start.x()-Vector.x())*(180.0/M_PI);
1656
                                                                        QWMatrix arrowTrans;
4264 craig 1657
                                                                        FPointArray arrow = (*doc.arrowStyles.at(ite->startArrowIndex()-1)).points.copy();
3133 fschmid 1658
                                                                        arrowTrans.translate(Start.x(), Start.y());
1659
                                                                        arrowTrans.rotate(r);
4580 cbradney 1660
                                                                        arrowTrans.scale(ite->lineWidth(), ite->lineWidth());
3133 fschmid 1661
                                                                        arrow.map(arrowTrans);
4264 craig 1662
                                                                        if ((ite->lineTransparency() != 0) && (Options.Version >= 14))
3133 fschmid 1663
                                                                        {
1664
                                                                                StartObj(ObjCounter);
4229 craig 1665
                                                                                QString ShName = ResNam+QString::number(ResCount);
3133 fschmid 1666
                                                                                Transpar[ShName] = ObjCounter;
1667
                                                                                ResCount++;
1668
                                                                                ObjCounter++;
1669
                                                                                PutDoc("<< /Type /ExtGState\n");
1670
                                                                                PutDoc("/CA "+FToStr(1.0 - ite->lineTransparency())+"\n");
1671
                                                                                PutDoc("/ca "+FToStr(1.0 - ite->lineTransparency())+"\n");
1672
                                                                                PutDoc("/SMask /None\n/AIS false\n/OPM 1\n");
1673
                                                                                PutDoc("/BM /Normal\n>>\nendobj\n");
1674
                                                                                PutPage("/"+ShName+" gs\n");
1675
                                                                        }
4016 fschmid 1676
                                                                        PutPage(putColor(ite->lineColor(), ite->lineShade(), true));
3133 fschmid 1677
                                                                        PutPage(SetClipPathArray(&arrow));
1678
                                                                        PutPage("h\nf*\n");
1679
                                                                        break;
1680
                                                                }
1681
                                                        }
1682
                                                }
4061 craig 1683
                                                if (ite->endArrowIndex() != 0)
3133 fschmid 1684
                                                {
1685
                                                        FPoint End = ite->PoLine.point(ite->PoLine.size()-2);
1686
                                                        for (uint xx = ite->PoLine.size()-1; xx > 0; xx -= 2)
1687
                                                        {
1688
                                                                FPoint Vector = ite->PoLine.point(xx);
1689
                                                                if ((End.x() != Vector.x()) || (End.y() != Vector.y()))
1690
                                                                {
1691
                                                                        double r = atan2(End.y()-Vector.y(),End.x()-Vector.x())*(180.0/M_PI);
1692
                                                                        QWMatrix arrowTrans;
4264 craig 1693
                                                                        FPointArray arrow = (*doc.arrowStyles.at(ite->endArrowIndex()-1)).points.copy();
3133 fschmid 1694
                                                                        arrowTrans.translate(End.x(), End.y());
1695
                                                                        arrowTrans.rotate(r);
4580 cbradney 1696
                                                                        arrowTrans.scale(ite->lineWidth(), ite->lineWidth());
3133 fschmid 1697
                                                                        arrow.map(arrowTrans);
4264 craig 1698
                                                                        if ((ite->lineTransparency() != 0) && (Options.Version >= 14))
3133 fschmid 1699
                                                                        {
1700
                                                                                StartObj(ObjCounter);
4229 craig 1701
                                                                                QString ShName = ResNam+QString::number(ResCount);
3133 fschmid 1702
                                                                                Transpar[ShName] = ObjCounter;
1703
                                                                                ResCount++;
1704
                                                                                ObjCounter++;
1705
                                                                                PutDoc("<< /Type /ExtGState\n");
1706
                                                                                PutDoc("/CA "+FToStr(1.0 - ite->lineTransparency())+"\n");
1707
                                                                                PutDoc("/ca "+FToStr(1.0 - ite->lineTransparency())+"\n");
1708
                                                                                PutDoc("/SMask /None\n/AIS false\n/OPM 1\n");
1709
                                                                                PutDoc("/BM /Normal\n>>\nendobj\n");
1710
                                                                                PutPage("/"+ShName+" gs\n");
1711
                                                                        }
4016 fschmid 1712
                                                                        PutPage(putColor(ite->lineColor(), ite->lineShade(), true));
3133 fschmid 1713
                                                                        PutPage(SetClipPathArray(&arrow));
1714
                                                                        PutPage("h\nf*\n");
1715
                                                                        break;
1716
                                                                }
1717
                                                        }
1718
                                                }
1719
                                                break;
1720
                                        case PageItem::PathText:
1721
                                                if (ite->PoShow)
1722
                                                {
1723
                                                        if (ite->PoLine.size() > 3)
1724
                                                        {
1725
                                                                PutPage("q\n");
4546 subik 1726
                                                                if ((ite->lineColor() != CommonStrings::None) || (!ite->NamedLStyle.isEmpty()))
3133 fschmid 1727
                                                                {
4580 cbradney 1728
                                                                        if ((ite->NamedLStyle.isEmpty()) && (ite->lineWidth() != 0.0))
3133 fschmid 1729
                                                                        {
1730
                                                                                PutPage(SetClipPath(ite, false));
1731
                                                                                PutPage("S\n");
1732
                                                                        }
1733
                                                                        else
1734
                                                                        {
4264 craig 1735
                                                                                multiLine ml = doc.MLineStyles[ite->NamedLStyle];
6569 fschmid 1736
                                                                                for (int it = ml.size()-1; it > -1; it--)
1737
                                                                                {
1738
                                                                                        if ((ml[it].Color != CommonStrings::None) && (ml[it].Width != 0))
3133 fschmid 1739
                                                                                        {
6569 fschmid 1740
                                                                                                PutPage(setStrokeMulti(&ml[it]));