Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
3 paul 1
/***************************************************************************
2
                          pslib.cpp  -  description
3
                             -------------------
4
    begin                : Sat May 26 2001
5
    copyright            : (C) 2001 by Franz Schmid
6
    email                : Franz.Schmid@altmuehlnet.de
7
 ***************************************************************************/
8
 
9
/***************************************************************************
10
 *                                                                         *
11
 *   This program is free software; you can redistribute it and/or modify  *
12
 *   it under the terms of the GNU General Public License as published by  *
13
 *   the Free Software Foundation; either version 2 of the License, or     *
14
 *   (at your option) any later version.                                   *
15
 *                                                                         *
16
 ***************************************************************************/
17
#include <qfileinfo.h>
18
#include <qtextstream.h>
19
#include <qimage.h>
20
#include <qcolor.h>
21
#include <qcstring.h>
22
#include <qfontinfo.h>
23
#include <cstdlib>
24
#include <qregexp.h>
128 Franz 25
 
617 cbradney 26
#ifdef _MSC_VER
27
 #if (_MSC_VER >= 1200)
28
  #include "win-config.h"
29
 #endif
128 Franz 30
#else
31
 #include "config.h"
32
#endif
33
 
3 paul 34
#include "pslib.h"
838 cbradney 35
#include "scribusdoc.h"
36
#include "scribusview.h"
3 paul 37
#include "scfonts.h"
38
#include <cmath>
39
 
456 fschmid 40
extern void Level2Layer(ScribusDoc *doc, struct Layer *ll, int Level);
41
extern double Cwidth(ScribusDoc *doc, QString name, QString ch, int Siz, QString ch2 = " ");
3 paul 42
extern bool loadText(QString nam, QString *Buffer);
201 Franz 43
extern QImage LoadPict(QString fn, bool *gray = 0);
3 paul 44
extern QString CompressStr(QString *in);
45
extern QString ImageToCMYK_PS(QImage *im, int pl, bool pre);
46
extern QString MaskToTxt(QImage *im, bool PDF = true);
47
extern char *toHex( uchar u );
48
extern QString String2Hex(QString *in, bool lang = true);
49
#ifdef HAVE_CMS
50
extern bool CMSuse;
51
extern QImage LoadPictCol(QString fn, QString Prof, bool UseEmbedded, bool *realCMYK);
52
#endif
53
 
54
extern "C" void* Run(bool psart, SCFonts &AllFonts, QMap<QString,QFont> DocFonts, CListe DocColors, bool pdf);
55
 
56
void* Run(bool psart, SCFonts &AllFonts, QMap<QString,QFont> DocFonts, CListe DocColors, bool pdf)
57
{
58
        PSLib *dia = new PSLib(psart, AllFonts, DocFonts, DocColors, pdf);
59
        return dia;
60
}
61
 
62
PSLib::PSLib(bool psart, SCFonts &AllFonts, QMap<QString,QFont> DocFonts, CListe DocColors, bool pdf)
63
{
64
        QString tmp, tmp2, tmp3, tmp4, CHset;
65
        QStringList wt;
188 Franz 66
        QString Epfad = PREL;
3 paul 67
        Seiten = 0;
68
        User = "";
456 fschmid 69
        Creator = "Scribus 1.3.0cvs";
3 paul 70
        Titel = "";
71
        FillColor = "0.0 0.0 0.0 0.0";
72
        StrokeColor = "0.0 0.0 0.0 0.0";
80 Franz 73
        Header = psart ? "%!PS-Adobe-3.0\n" : "%!PS-Adobe-3.0 EPSF-3.0\n";
3 paul 74
        BBox = "";
75
        BBoxH = "";
76
        Art = psart;
77
        isPDF = pdf;
78
        UsedFonts.clear();
79
        Fonts = "";
80
        FontDesc = "";
81
        GraySc = false;
82
        DoSep = false;
83
#ifdef HAVE_LIBZ
84
        CompAvail = true;
85
#else
86
        CompAvail = false;
87
#endif
88
        GrayCalc =  "/setcmykcolor {exch 0.11 mul add exch 0.59 mul add exch 0.3 mul add\n";
89
        GrayCalc += "               dup 1 gt {pop 1} if 1 exch sub oldsetgray} bind def\n";
90
        GrayCalc += "/setrgbcolor {0.11 mul exch 0.59 mul add exch 0.3 mul add\n";
91
        GrayCalc += "              oldsetgray} bind def\n";
92
        Farben = "%%CMYKCustomColor: ";
93
        FNamen = "%%DocumentCustomColors: ";
94
        CListe::Iterator itf;
95
        int c, m, y, k;
96
        bool erst = true;
97
        for (itf = DocColors.begin(); itf != DocColors.end(); ++itf)
188 Franz 98
        {
99
                if ((itf.key() != "Cyan") && (itf.key() != "Magenta") && (itf.key() != "Yellow") &&
100
                        (itf.key() != "Black"))
3 paul 101
                {
102
                        DocColors[itf.key()].getCMYK(&c, &m, &y, &k);
103
                        if (!erst)
188 Franz 104
                        {
3 paul 105
                                Farben += "%%+ ";
106
                                FNamen += "%%+ ";
188 Franz 107
                        }
108
                        Farben += ToStr(static_cast<double>(c) / 255) + " " +  
109
                                        ToStr(static_cast<double>(m) / 255) + " ";
110
                        Farben += ToStr(static_cast<double>(y) / 255) + " " +  
111
                                        ToStr(static_cast<double>(k) / 255) + " (" + itf.key() + ")\n";
3 paul 112
                        FNamen += "(" + itf.key() + ")\n";
113
                        erst = false;
114
                }
188 Franz 115
        }
3 paul 116
        QMap<QString,QFont>::Iterator it;
117
        int a = 0;
118
        for (it = DocFonts.begin(); it != DocFonts.end(); ++it)
188 Franz 119
        {
173 Franz 120
/* Subset all TTF Fonts until the bug in the TTF-Embedding Code is fixed */
121
                QFileInfo fd = QFileInfo(AllFonts[it.key()]->Datei);
122
                QString fext = fd.extension(false).lower();
123
 
124
                if ((fext == "ttf") || (AllFonts[it.key()]->isOTF) || (AllFonts[it.key()]->Subset))
188 Franz 125
                {
126
                        FontDesc += "/"+AllFonts[it.key()]->RealName()+
127
                                        " "+IToStr(AllFonts[it.key()]->RealGlyphs.count()+1)+" dict def\n";
68 Franz 128
                        FontDesc += AllFonts[it.key()]->RealName()+" begin\n";
129
                        QMap<uint,FPointArray>::Iterator ig;
188 Franz 130
                        for (ig = AllFonts[it.key()]->RealGlyphs.begin();
131
                                ig != AllFonts[it.key()]->RealGlyphs.end(); ++ig)
132
                        {
68 Franz 133
                                FontDesc += "/G"+IToStr(ig.key())+" { newpath\n";
134
                                FPoint np, np1, np2;
135
                                bool nPath = true;
136
                                if (ig.data().size() > 3)
188 Franz 137
                                {
138
                                        for (uint poi = 0; poi < ig.data().size()-3; poi += 4)
68 Franz 139
                                        {
188 Franz 140
                                                if (ig.data().point(poi).x() > 900000)
68 Franz 141
                                                {
142
                                                        FontDesc += "cl\n";
143
                                                        nPath = true;
144
                                                        continue;
188 Franz 145
                                                }
68 Franz 146
                                                if (nPath)
188 Franz 147
                                                {
68 Franz 148
                                                        np = ig.data().point(poi);
149
                                                        FontDesc += ToStr(np.x()) + " " + ToStr(-np.y()) + " m\n";
150
                                                        nPath = false;
188 Franz 151
                                                }
68 Franz 152
                                                np = ig.data().point(poi+1);
153
                                                np1 = ig.data().point(poi+3);
154
                                                np2 = ig.data().point(poi+2);
188 Franz 155
                                                FontDesc += ToStr(np.x()) + " " + ToStr(-np.y()) + " " +
156
                                                                ToStr(np1.x()) + " " + ToStr(-np1.y()) + " " +
157
                                                                ToStr(np2.x()) + " " + ToStr(-np2.y()) + " cu\n";
68 Franz 158
                                        }
188 Franz 159
                                }
68 Franz 160
                                FontDesc += "cl\n} bind def\n";
188 Franz 161
                        }
68 Franz 162
                        FontDesc += "end\n";
163
                        AllFonts[it.key()]->RealGlyphs.clear();
188 Franz 164
                }
68 Franz 165
                else
188 Franz 166
                {
68 Franz 167
                        UsedFonts.insert(it.key(), "/Fo"+IToStr(a));
3 paul 168
                        Fonts += "/Fo"+IToStr(a)+" /"+AllFonts[it.key()]->RealName()+" findfont definefont pop\n";
68 Franz 169
                        if (AllFonts[it.key()]->EmbedPS)
188 Franz 170
                        {
68 Franz 171
                                QString tmp;
172
                                if(AllFonts[it.key()]->EmbedFont(tmp))
188 Franz 173
                                {
68 Franz 174
                                        FontDesc += "%%BeginFont: " + AllFonts[it.key()]->RealName() + "\n";
175
                                        FontDesc += tmp + "\n%%EndFont\n";
3 paul 176
                                }
188 Franz 177
                        }
68 Franz 178
                        GListe gl;
179
                        AllFonts[it.key()]->GlNames(&gl);
180
                        GlyphsOfFont.insert(it.key(), gl);
181
                        a++;
3 paul 182
                }
188 Franz 183
        }
3 paul 184
        Prolog = "%%BeginProlog\n";
185
        Prolog += "/Scribusdict 100 dict def\n";
186
        Prolog += "Scribusdict begin\n";
187
        Prolog += "/sp {showpage} bind def\n";
188
        Prolog += "/oldsetgray /setgray load def\n";
189
        Prolog += "/cmyk {setcmykcolor} def\n";
190
        Prolog += "/m {moveto} bind def\n";
68 Franz 191
        Prolog += "/l {lineto} bind def\n";
3 paul 192
        Prolog += "/li {lineto} bind def\n";
68 Franz 193
        Prolog += "/cu {curveto} bind def\n";
3 paul 194
        Prolog += "/cl {closepath} bind def\n";
195
        Prolog += "/gs {gsave} bind def\n";
196
        Prolog += "/gr {grestore} bind def\n";
197
        Prolog += "/tr {translate} bind def\n";
198
        Prolog += "/ro {rotate} bind def\n";
199
        Prolog += "/sh {show} bind def\n";
200
        Prolog += "/shg {setcmykcolor moveto glyphshow} def\n";
201
        Prolog += "/sc {scale} bind def\n";
202
        Prolog += "/se {selectfont} bind def\n";
203
        Prolog += "/sf {setfont} bind def\n";
204
        Prolog += "/sw {setlinewidth} bind def\n";
205
        Prolog += "/f  {findfont} bind def\n";
206
        Prolog += "/fi {fill} bind def\n";
207
        Prolog += "/st {stroke} bind def\n";
122 Franz 208
        Prolog += "/shgf {gs dup scale begin cvx exec fill end gr} bind def\n";
68 Franz 209
        Prolog += "/shgs {gs dup 1 exch div currentlinewidth mul sw dup scale\n";
210
        Prolog += "       begin cvx exec st end gr} bind def\n";
3 paul 211
        Prolog += "/bEPS {\n";
212
        Prolog += "    /b4_Inc_state save def\n";
213
        Prolog += "    /dict_count countdictstack def\n";
214
        Prolog += "    /op_count count 1 sub def\n";
215
        Prolog += "    userdict begin\n";
216
        Prolog += "    /showpage { } def\n";
217
        Prolog += "    0 setgray 0 setlinecap\n";
218
        Prolog += "    1 setlinewidth 0 setlinejoin\n";
219
        Prolog += "    10 setmiterlimit [ ] 0 setdash newpath\n";
220
        Prolog += "    /languagelevel where\n";
221
        Prolog += "    {pop languagelevel\n";
222
        Prolog += "    1 ne\n";
223
        Prolog += "    {false setstrokeadjust false setoverprint\n";
224
        Prolog += "    } if } if } bind def\n";
225
        Prolog += "/eEPS { count op_count sub {pop} repeat\n";
226
        Prolog += "    countdictstack dict_count sub {end} repeat\n";
227
        Prolog += "    b4_Inc_state restore } bind def\n";
228
        Prolog += "    end\n";
229
        Prolog += "%%EndProlog\n";
230
}
231
 
232
void PSLib::PutSeite(QString c)
233
{
234
        QTextStream t(&Spool);
235
        t.writeRawBytes(c, c.length());
236
}
237
 
238
void PSLib::PutDoc(QString c)
239
{
240
        QTextStream t(&Spool);
241
        t.writeRawBytes(c, c.length());
242
}
243
 
80 Franz 244
QString PSLib::ToStr(double c)
3 paul 245
{
246
        QString cc;
247
        return cc.setNum(c);
248
}
249
 
250
QString PSLib::IToStr(int c)
251
{
252
        QString cc;
253
        return cc.setNum(c);
254
}
255
 
256
void PSLib::PS_set_Info(QString art, QString was)
257
{
258
        if (art == "Author")
259
                User = was;
260
        if (art == "Creator")
261
                Creator = was;
262
        if (art == "Title")
263
                Titel = was;
264
}
265
 
266
bool PSLib::PS_set_file(QString fn)
267
{
268
        Spool.setName(fn);
269
        return Spool.open(IO_WriteOnly);
270
}
271
 
741 fschmid 272
void PSLib::PS_begin_doc(int, double x, double y, double breite, double hoehe, int numpage)
3 paul 273
{
274
        PutDoc(Header);
275
        PutDoc("%%For: " + User + "\n");
276
        PutDoc("%%Title: " + Titel + "\n");
277
        PutDoc("%%Creator: " + Creator + "\n");
278
        PutDoc("%%Pages: " + IToStr(numpage) + "\n");
331 Franz 279
        BBox = "%%BoundingBox: " + IToStr(qRound(x)) + " " + IToStr(qRound(y)) + " " + IToStr(qRound(breite)) + " " + IToStr(qRound(hoehe)) + "\n";
280
        BBoxH = "%%HiResBoundingBox: " + ToStr(x) + " " + ToStr(y) + " " + ToStr(breite) + " " + ToStr(hoehe) + "\n";
188 Franz 281
        if (!Art)
282
        {
3 paul 283
                PutDoc(BBox);
284
                PutDoc(BBoxH);
188 Franz 285
        }
3 paul 286
        PutDoc(FNamen);
287
        PutDoc(Farben);
288
        PutDoc("%%LanguageLevel: 3\n");
289
        PutDoc("%%EndComments\n");
290
        PutDoc(Prolog);
291
        PutDoc("%%BeginSetup\n");
292
        PutDoc("/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse\n");
293
        if (FontDesc != "")
294
                PutDoc(FontDesc);
295
        PutDoc("Scribusdict begin\n");
296
        PutDoc(Fonts);
297
        if (GraySc)
298
                PutDoc(GrayCalc);
299
        PutDoc("%%EndSetup\n");
45 Franz 300
/*  if ((Art) && (Ori != 0))
3 paul 301
        {
302
                PutSeite("<< /PageSize [ "+ToStr(breite)+" "+ToStr(hoehe)+" ]\n");
303
                PutSeite("/Orientation 3\n");
304
                PutSeite(">> setpagedevice\n");
45 Franz 305
                }                    */
3 paul 306
        Prolog = "";
307
        FontDesc = "";
308
}
309
 
310
QString PSLib::PSEncode(QString in)
311
{
312
        QString tmp = "";
313
        QString cc;
314
        for (uint d = 0; d < in.length(); ++d)
188 Franz 315
        {
3 paul 316
                cc = in.at(d);
317
                if ((cc == "(") || (cc == ")") || (cc == "\\"))
318
                        tmp += "\\";
319
                tmp += cc;
188 Franz 320
        }
3 paul 321
        tmp = tmp.simplifyWhiteSpace().replace( QRegExp("\\s"), "" );
322
        return tmp;
323
}
324
 
80 Franz 325
void PSLib::PS_TemplateStart(QString Name, double breite, double hoehe)
3 paul 326
{
327
        PutDoc("/"+PSEncode(Name)+"\n<<\n");
328
        PutDoc("/FormType 1\n");
329
        PutDoc("/BBox [0 0 "+ToStr(breite)+" "+ToStr(hoehe)+"]\n");
330
        PutDoc("/Matrix [1 0 0 1 0 0]\n");
331
        PutDoc("/PaintProc\n{\n");
332
}
333
 
334
void PSLib::PS_UseTemplate(QString Name)
335
{
336
        PutDoc(PSEncode(Name)+" execform\n");
337
}
338
 
339
void PSLib::PS_TemplateEnd()
340
{
341
        PutDoc("pop } bind\n");
342
        PutDoc(">> def\n");
343
}
344
 
222 Franz 345
void PSLib::PS_begin_page(double breite, double hoehe, struct Margs* Ma, bool Clipping)
3 paul 346
{
222 Franz 347
        if (Clipping)
348
        {
349
                PDev = ToStr(Ma->Left) + " " + ToStr(Ma->Bottom) + " m\n";
350
                PDev += ToStr(breite - Ma->Right) + " " + ToStr(Ma->Bottom) + " li\n";
351
                PDev += ToStr(breite - Ma->Right) + " " + ToStr(hoehe - Ma->Top) + " li\n";
352
                PDev += ToStr(Ma->Left) + " " + ToStr(hoehe - Ma->Top) + " li cl clip newpath\n";
353
        }
3 paul 354
        Seiten++;
222 Franz 355
        PutSeite("%%Page: " + IToStr(Seiten) + " " + IToStr(Seiten) + "\nsave\n");
356
        if (Clipping)
357
                PutSeite(PDev);
188 Franz 358
        PutSeite("/DeviceCMYK setcolorspace\n");
3 paul 359
}
360
 
361
void PSLib::PS_end_page()
362
{
363
        PutSeite("%%PageTrailer\nrestore\nsp\n");
364
}
365
 
80 Franz 366
void PSLib::PS_curve(double x1, double y1, double x2, double y2, double x3, double y3)
3 paul 367
{
188 Franz 368
        PutSeite(ToStr(x1) + " " + ToStr(y1) + " " + ToStr(x2) + " " + ToStr(y2) + " " + ToStr(x3) + " " +
369
                        ToStr(y3) + " curveto\n");
3 paul 370
}
371
 
80 Franz 372
void PSLib::PS_moveto(double x, double y)
3 paul 373
{
374
        PutSeite(ToStr(x) + " " + ToStr(y) + " m\n");
375
}
376
 
80 Franz 377
void PSLib::PS_lineto(double x, double y)
3 paul 378
{
379
        PutSeite(ToStr(x) + " " + ToStr(y) + " li\n");
380
}
381
 
382
void PSLib::PS_closepath()
383
{
384
        PutSeite("cl\n");
385
}
386
 
80 Franz 387
void PSLib::PS_translate(double x, double y)
3 paul 388
{
389
        PutSeite(ToStr(x) + " " + ToStr(y) + " tr\n");
390
}
391
 
80 Franz 392
void PSLib::PS_scale(double x, double y)
3 paul 393
{
394
        PutSeite(ToStr(x) + " " + ToStr(y) + " sc\n");
395
}
396
 
80 Franz 397
void PSLib::PS_rotate(double x)
3 paul 398
{
399
        PutSeite(ToStr(x) + " ro\n");
400
}
401
 
402
void PSLib::PS_clip(bool mu)
403
{
80 Franz 404
        PutSeite( mu ? "eoclip newpath\n" : "clip newpath\n" );
3 paul 405
}
406
 
407
void PSLib::PS_save()
408
{
409
        PutSeite("gs\n");
410
}
411
 
412
void PSLib::PS_restore()
413
{
414
        PutSeite("gr\n");
415
}
416
 
80 Franz 417
void PSLib::PS_setcmykcolor_fill(double c, double m, double y, double k)
3 paul 418
{
419
        FillColor = ToStr(c) + " " + ToStr(m) + " " + ToStr(y) + " " + ToStr(k);
420
}
421
 
422
void PSLib::PS_setcmykcolor_dummy()
423
{
424
        PutSeite("0 0 0 0 cmyk\n");
425
}
426
 
80 Franz 427
void PSLib::PS_setcmykcolor_stroke(double c, double m, double y, double k)
3 paul 428
{
429
        StrokeColor = ToStr(c) + " " + ToStr(m) + " " + ToStr(y) + " " + ToStr(k);
430
}
431
 
80 Franz 432
void PSLib::PS_setlinewidth(double w)
3 paul 433
{
434
        PutSeite(ToStr(w) + " sw\n");
435
        LineW = w;
436
}
437
 
292 Franz 438
void PSLib::PS_setdash(Qt::PenStyle st, double offset, QValueList<double> dash)
3 paul 439
{
292 Franz 440
        QString Dt = ToStr(QMAX(2*LineW, 1));
441
        QString Da = ToStr(QMAX(6*LineW, 1));
442
        if (dash.count() != 0)
188 Franz 443
        {
292 Franz 444
                PutSeite("[ ");
445
                QValueList<double>::iterator it;
446
                for ( it = dash.begin(); it != dash.end(); ++it )
447
                {
448
                        PutSeite(IToStr(static_cast<int>(*it))+" ");
449
                }
450
                PutSeite("] "+IToStr(static_cast<int>(offset))+" setdash\n");
188 Franz 451
        }
292 Franz 452
        else
453
        {
454
                switch (st)
455
                {
456
                        case Qt::SolidLine:
457
                                PutSeite("[] 0 setdash\n");
458
                                break;
459
                        case Qt::DashLine:
460
                                PutSeite("["+Da+" "+Dt+"] 0 setdash\n");
461
                                break;
462
                        case Qt::DotLine:
463
                                PutSeite("["+Dt+"] 0 setdash\n");
464
                                break;
465
                        case Qt::DashDotLine:
466
                                PutSeite("["+Da+" "+Dt+" "+Dt+" "+Dt+"] 0 setdash\n");
467
                                break;
468
                        case Qt::DashDotDotLine:
469
                                PutSeite("["+Da+" "+Dt+" "+Dt+" "+Dt+" "+Dt+" "+Dt+"] 0 setdash\n");
470
                                break;
471
                        default:
472
                                PutSeite("[] 0 setdash\n");
473
                                break;
474
                }
475
        }
476
}
477
void PSLib::PS_setcapjoin(Qt::PenCapStyle ca, Qt::PenJoinStyle jo)
478
{
3 paul 479
        switch (ca)
480
                {
481
                case Qt::FlatCap:
482
                        PutSeite("0 setlinecap\n");
483
                        break;
484
                case Qt::SquareCap:
485
                        PutSeite("2 setlinecap\n");
486
                        break;
487
                case Qt::RoundCap:
488
                        PutSeite("1 setlinecap\n");
489
                        break;
490
                default:
491
                        PutSeite("0 setlinecap\n");
492
                        break;
493
                }
494
        switch (jo)
495
                {
496
                case Qt::MiterJoin:
497
                        PutSeite("0 setlinejoin\n");
498
                        break;
499
                case Qt::BevelJoin:
500
                        PutSeite("2 setlinejoin\n");
501
                        break;
502
                case Qt::RoundJoin:
503
                        PutSeite("1 setlinejoin\n");
504
                        break;
505
                default:
506
                        PutSeite("0 setlinejoin\n");
507
                        break;
508
                }
509
}
510
 
111 Franz 511
void PSLib::PS_selectfont(QString f, double s)
3 paul 512
{
111 Franz 513
        PutSeite(UsedFonts[f] + " " + ToStr(s) + " se\n");
3 paul 514
}
515
 
271 Franz 516
void PSLib::PS_fill()
3 paul 517
{
271 Franz 518
        PutSeite(FillColor + " cmyk eofill\n");
3 paul 519
}
520
 
521
void PSLib::PS_stroke()
522
{
523
        PutSeite(StrokeColor + " cmyk st\n");
524
}
525
 
271 Franz 526
void PSLib::PS_fill_stroke()
3 paul 527
{
528
        PS_save();
271 Franz 529
        PS_fill();
3 paul 530
        PS_restore();
531
        PS_stroke();
532
}
533
 
534
void PSLib::PS_newpath()
535
{
536
        PutSeite("newpath\n");
537
}
538
 
297 Franz 539
void PSLib::PS_MultiRadGradient(double w, double h, double x, double y, QValueList<double> Stops, QStringList Colors)
295 Franz 540
{
541
        bool first = true;
542
        PutSeite( "clipsave\n" );
543
        PutSeite("eoclip\n");
544
        for (uint c = 0; c < Colors.count()-1; ++c)
545
        {
546
                PutSeite("<<\n");
547
                PutSeite("/ShadingType 3\n");
548
                PutSeite( DoSep ? "/ColorSpace /DeviceGray\n" : "/ColorSpace /DeviceCMYK\n" );
549
                PutSeite("/BBox [0 "+ToStr(h)+" "+ToStr(w)+" 0]\n");
326 Franz 550
                if (Colors.count() == 2)
551
                        PutDoc("/Extend [true true]\n");
295 Franz 552
                else
553
                {
326 Franz 554
                        if (first)
555
                                PutSeite("/Extend [false true]\n");
295 Franz 556
                        else
326 Franz 557
                        {
558
                                if (c == Colors.count()-2)
559
                                        PutSeite("/Extend [true false]\n");
560
                                else
561
                                        PutSeite("/Extend [false false]\n");
562
                        }
295 Franz 563
                }
297 Franz 564
                PutSeite("/Coords ["+ToStr(x)+" "+ToStr(y)+" "+ToStr((*Stops.at(c+1)))+" "+ToStr(x)+" "+ToStr(y)+" "+ToStr((*Stops.at(c)))+"]\n");
295 Franz 565
                PutSeite("/Function\n");
566
                PutSeite("<<\n");
567
                PutSeite("/FunctionType 2\n");
568
                PutSeite("/Domain [0 1]\n");
569
                if (DoSep)
570
                {
571
                        int pla = Plate - 1 < 0 ? 3 : Plate - 1;
572
                        QStringList cols1 = QStringList::split(" ", Colors[c+1]);
573
                        QStringList cols2 = QStringList::split(" ", Colors[c]);
574
                        PutSeite("/C1 ["+ToStr(1-cols1[pla].toDouble())+"]\n");
575
                        PutSeite("/C0 ["+ToStr(1-cols2[pla].toDouble())+"]\n");
576
                }
577
                else
578
                {
579
                        PutSeite("/C0 ["+Colors[c+1]+"]\n");
580
                        PutSeite("/C1 ["+Colors[c]+"]\n");
581
                }
582
                PutSeite("/N 1\n");
583
                PutSeite(">>\n");
584
                PutSeite(">>\n");
585
                PutSeite("shfill\n");
586
                first = false;
587
        }
588
        PutSeite("cliprestore\n");
589
}
590
 
591
void PSLib::PS_MultiLinGradient(double w, double h, QValueList<double> Stops, QStringList Colors)
592
{
593
        bool first = true;
594
        PutSeite( "clipsave\n" );
595
        PutSeite("eoclip\n");
596
        for (uint c = 0; c < Colors.count()-1; ++c)
597
        {
598
                PutSeite("<<\n");
599
                PutSeite("/ShadingType 2\n");
600
                PutSeite( DoSep ? "/ColorSpace /DeviceGray\n" : "/ColorSpace /DeviceCMYK\n" );
601
                PutSeite("/BBox [0 "+ToStr(h)+" "+ToStr(w)+" 0]\n");
328 Franz 602
                if (Colors.count() == 2)
603
                        PutDoc("/Extend [true true]\n");
295 Franz 604
                else
605
                {
328 Franz 606
                        if (first)
607
                                PutSeite("/Extend [true false]\n");
295 Franz 608
                        else
328 Franz 609
                        {
610
                                if (c == Colors.count()-2)
611
                                        PutSeite("/Extend [false true]\n");
612
                                else
613
                                        PutSeite("/Extend [false false]\n");
614
                        }
295 Franz 615
                }
616
                first = false;
617
                PutSeite("/Coords ["+ToStr((*Stops.at(c*2)))+"  "+ToStr((*Stops.at(c*2+1)))+" "+ToStr((*Stops.at(c*2+2)))+" "+ToStr((*Stops.at(c*2+3)))+"]\n");
618
                PutSeite("/Function\n");
619
                PutSeite("<<\n");
620
                PutSeite("/FunctionType 2\n");
621
                PutSeite("/Domain [0 1]\n");
622
                if (DoSep)
623
                {
624
                        int pla = Plate - 1 < 0 ? 3 : Plate - 1;
625
                        QStringList cols1 = QStringList::split(" ", Colors[c]);
626
                        QStringList cols2 = QStringList::split(" ", Colors[c+1]);
627
                        PutSeite("/C1 ["+ToStr(1-cols1[pla].toDouble())+"]\n");
628
                        PutSeite("/C0 ["+ToStr(1-cols2[pla].toDouble())+"]\n");
629
                }
630
                else
631
                {
632
                        PutSeite("/C0 ["+Colors[c]+"]\n");
633
                        PutSeite("/C1 ["+Colors[c+1]+"]\n");
634
                }
635
                PutSeite("/N 1\n");
636
                PutSeite(">>\n");
637
                PutSeite(">>\n");
638
                PutSeite("shfill\n");
639
        }
640
        PutSeite("cliprestore\n");
641
}
642
 
80 Franz 643
void PSLib::PS_show_xyG(QString font, QString ch, double x, double y)
3 paul 644
{
645
        QString Name;
646
        uint cc = ch[0].unicode();
80 Franz 647
        Name = GlyphsOfFont[font].contains(cc) ? GlyphsOfFont[font][cc] : QString(".notdef");
3 paul 648
        PutSeite("/"+Name+" "+ToStr(x)+" "+ToStr(y)+" "+StrokeColor+" shg\n");
649
}
650
 
80 Franz 651
void PSLib::PS_show(double x, double y)
3 paul 652
{
653
        PS_moveto(x, y);
654
        PutSeite("/hyphen glyphshow\n");
655
}
656
 
111 Franz 657
void PSLib::PS_showSub(uint chr, QString font, double size, bool stroke)
68 Franz 658
{
659
        PutSeite(FillColor + " cmyk (G"+IToStr(chr)+") "+font+" "+ToStr(size / 10.0)+" ");
80 Franz 660
        PutSeite(stroke ? "shgs\n" : "shgf\n");
68 Franz 661
}
662
 
20 Franz 663
void PSLib::PS_ImageData(bool inver, QString fn, QString Name, QString Prof, bool UseEmbedded, bool UseProf)
3 paul 664
{
665
        QString tmp;
666
        QFileInfo fi = QFileInfo(fn);
667
        QString ext = fi.extension(false).lower();
668
        if (ext == "eps")
188 Franz 669
        {
670
                if (loadText(fn, &tmp))
3 paul 671
                {
672
                        PutSeite("currentfile 1 (%ENDEPSDATA) /SubFileDecode filter /ReusableStreamDecode filter\n");
188 Franz 673
                        PutSeite("%%BeginDocument: " + fi.fileName() + "\n");
674
                        PutSeite(tmp+"\n");
675
                        PutSeite("%ENDEPSDATA\n");
676
                        PutSeite("%%EndDocument\n");
3 paul 677
                        PutSeite("/"+PSEncode(Name)+"Bild exch def\n");
188 Franz 678
                }
3 paul 679
                return;
188 Franz 680
        }
681
        QString ImgStr = "";
3 paul 682
        QImage image;
683
#ifdef HAVE_CMS
684
        QImage image2;
685
        bool cmy = false;
686
        if ((CMSuse) && (UseProf))
188 Franz 687
        {
3 paul 688
                image = LoadPict(fn);
689
                image = image.convertDepth(32);
690
                image2 = LoadPictCol(fn, Prof, UseEmbedded, &cmy);
20 Franz 691
                if (inver)
188 Franz 692
                {
20 Franz 693
                        image.invertPixels();
694
                        image2.invertPixels();
188 Franz 695
                }
3 paul 696
                ImgStr = ImageToCMYK_PS(&image2, -1, cmy);
188 Franz 697
        }
3 paul 698
        else
188 Franz 699
        {
3 paul 700
                image = LoadPict(fn);
20 Franz 701
                if (inver)
702
                        image.invertPixels();
3 paul 703
                ImgStr = ImageToCMYK_PS(&image, -1, false);
188 Franz 704
        }
3 paul 705
#else
706
        image = LoadPict(fn);
707
  image = image.convertDepth(32);
20 Franz 708
        if (inver)
709
                image.invertPixels();
3 paul 710
        ImgStr = ImageToCMYK_PS(&image, -1, false);
711
#endif
712
        if (CompAvail)
188 Franz 713
        {
3 paul 714
                PutSeite("currentfile /ASCIIHexDecode filter /FlateDecode filter /ReusableStreamDecode filter\n");
715
                ImgStr = CompressStr(&ImgStr);
188 Franz 716
        }
3 paul 717
        else
718
                PutSeite("currentfile /ASCIIHexDecode filter /ReusableStreamDecode filter\n");
719
        ImgStr = String2Hex(&ImgStr);
720
        PutSeite(ImgStr);
721
        PutSeite("\n>\n");
722
        PutSeite("/"+PSEncode(Name)+"Bild exch def\n");
723
        ImgStr = "";
724
  if (image.hasAlphaBuffer())
725
        {
726
                QImage iMask = image.createAlphaMask();
727
                ImgStr = MaskToTxt(&iMask, false);
728
                if (CompAvail)
188 Franz 729
                {
3 paul 730
                        PutSeite("currentfile /ASCIIHexDecode filter /FlateDecode filter /ReusableStreamDecode filter\n");
731
                        ImgStr = CompressStr(&ImgStr);
188 Franz 732
                }
3 paul 733
                else
734
                        PutSeite("currentfile /ASCIIHexDecode filter /ReusableStreamDecode filter\n");
735
                ImgStr = String2Hex(&ImgStr);
736
                PutSeite(ImgStr);
737
                PutSeite("\n>\n");
738
                PutSeite("/"+PSEncode(Name)+"Mask exch def\n");
188 Franz 739
        }
3 paul 740
}
741
 
80 Franz 742
void PSLib::PS_image(bool inver, double x, double y, QString fn, double scalex, double scaley, QString Prof, bool UseEmbedded, bool UseProf, QString Name)
3 paul 743
{
744
        QString tmp;
745
        QFileInfo fi = QFileInfo(fn);
746
        QString ext = fi.extension(false).lower();
747
        if (ext == "eps")
188 Franz 748
        {
749
                if (loadText(fn, &tmp))
3 paul 750
                {
188 Franz 751
                        PutSeite("bEPS\n");
752
                        PutSeite(ToStr(scalex) + " " + ToStr(scaley) + " sc\n");
753
                        PutSeite(ToStr(x) + " " + ToStr(y) + " tr\n");
754
                        if (Name != "")
3 paul 755
                        {
188 Franz 756
                                PutSeite(PSEncode(Name)+"Bild cvx exec\n");
757
                                PutSeite(PSEncode(Name)+"Bild resetfile\n");
3 paul 758
                        }
188 Franz 759
                        else
760
                        {
761
                                PutSeite("%%BeginDocument: " + fi.fileName() + "\n");
762
                                PutSeite(tmp+"\n");
763
                                PutSeite("%%EndDocument\n");
764
                        }
765
                        PutSeite("eEPS\n");
3 paul 766
                }
188 Franz 767
        }
3 paul 768
        else
188 Franz 769
        {
770
                QString ImgStr = "";
3 paul 771
                QImage image;
772
#ifdef HAVE_CMS
773
                QImage image2;
774
                bool cmy = false;
188 Franz 775
                image = LoadPict(fn);
111 Franz 776
                image = image.convertDepth(32);
188 Franz 777
                if ((CMSuse) && (UseProf))
3 paul 778
                        image2 = LoadPictCol(fn, Prof, UseEmbedded, &cmy);
20 Franz 779
                if (inver)
188 Franz 780
                {
20 Franz 781
                        image.invertPixels();
782
                        image2.invertPixels();
188 Franz 783
                }
3 paul 784
#else
785
                image = LoadPict(fn);
188 Franz 786
                image = image.convertDepth(32);
20 Franz 787
                if (inver)
788
                        image.invertPixels();
3 paul 789
#endif
790
                int w = image.width();
791
                int h = image.height();
188 Franz 792
                PutSeite(ToStr(x*scalex) + " " + ToStr(y*scaley) + " tr\n");
793
                PutSeite(ToStr(scalex*w) + " " + ToStr(scaley*h) + " sc\n");
794
                PutSeite(((!DoSep) && (!GraySc)) ? "/DeviceCMYK setcolorspace\n" : "/DeviceGray setcolorspace\n");
795
                if (image.hasAlphaBuffer())
796
                {
3 paul 797
                        QImage iMask = image.createAlphaMask();
798
#ifdef HAVE_CMS
799
                        if ((CMSuse) && (UseProf))
188 Franz 800
                        {
3 paul 801
                                if (DoSep)
802
                                        ImgStr = ImageToCMYK_PS(&image2, Plate, cmy);
803
                                else
188 Franz 804
                                        ImgStr = GraySc ? ImageToCMYK_PS(&image2, -2, cmy) :
805
                                                                ImageToCMYK_PS(&image2, -1, cmy);
806
                        }
3 paul 807
                        else
188 Franz 808
                        {
3 paul 809
                                if (DoSep)
810
                                        ImgStr = ImageToCMYK_PS(&image, Plate, false);
811
                                else
188 Franz 812
                                        ImgStr = GraySc ? ImageToCMYK_PS(&image, -2, false) :
813
                                                                ImageToCMYK_PS(&image, -1, false);
814
                        }
3 paul 815
#else
816
                        if (DoSep)
817
                                ImgStr = ImageToCMYK_PS(&image, Plate, false);
818
                        else
188 Franz 819
                                ImgStr = GraySc ? ImageToCMYK_PS(&image, -2, false) : ImageToCMYK_PS(&image, -1,
820
                                                                                                        false);
3 paul 821
#endif
822
                        if (Name == "")
188 Franz 823
                        {
824
                                if (CompAvail)
3 paul 825
                                {
826
                                        PutSeite("currentfile /ASCIIHexDecode filter /FlateDecode filter /ReusableStreamDecode filter\n");
827
                                        ImgStr = CompressStr(&ImgStr);
188 Franz 828
                                }
3 paul 829
                                else
830
                                        PutSeite("currentfile /ASCIIHexDecode filter /ReusableStreamDecode filter\n");
831
                                ImgStr = String2Hex(&ImgStr);
832
                                PutSeite(ImgStr);
833
                                ImgStr = "";
834
                                PutSeite("\n>\n");
835
                                PutSeite("/Bild exch def\n");
836
                                ImgStr = MaskToTxt(&iMask, false);
837
                                if (CompAvail)
188 Franz 838
                                {
3 paul 839
                                        PutSeite("currentfile /ASCIIHexDecode filter /FlateDecode filter /ReusableStreamDecode filter\n");
840
                                        ImgStr = CompressStr(&ImgStr);
188 Franz 841
                                }
3 paul 842
                                else
843
                                        PutSeite("currentfile /ASCIIHexDecode filter /ReusableStreamDecode filter\n");
844
                                ImgStr = String2Hex(&ImgStr);
845
                                PutSeite(ImgStr);
846
                                PutSeite("\n>\n");
847
                                PutSeite("/Mask exch def\n");
188 Franz 848
                        }
3 paul 849
                        PutSeite("<<\n");
850
                        PutSeite("  /PaintType   1\n");
851
                        PutSeite("  /PatternType 1\n");
852
                        PutSeite("  /TilingType  3\n");
853
                        PutSeite("  /BBox        [ 0 0 1 1 ]\n");
854
                        PutSeite("  /XStep       2\n");
855
                        PutSeite("  /YStep       2\n");
856
                        PutSeite("  /PaintProc   {\n");
857
                        PutSeite("   pop\n");
858
                        PutSeite("   1 1 1 1 setcmykcolor\n");
859
                        PutSeite("   <<\n");
860
                        PutSeite("   /ImageType 1\n");
861
                        PutSeite("   /Height    " + IToStr(h) + "\n");
862
                        PutSeite("   /Width     " + IToStr(w) + "\n");
188 Franz 863
                        PutSeite("   /ImageMatrix [" + IToStr(w) + " 0 0 " + IToStr(-h) + " 0 " + IToStr(h)
864
                                +"]\n");
3 paul 865
                        if (DoSep)
866
                                PutSeite("   /Decode [1 0]\n");
867
                        else
80 Franz 868
                                PutSeite( GraySc ? "   /Decode [1 0]\n" : "   /Decode [0 1 0 1 0 1 0 1]\n" );
3 paul 869
                        PutSeite("   /BitsPerComponent 8\n");
870
                        PutSeite("   /DataSource "+PSEncode(Name)+"Bild\n");
871
                        PutSeite("   >>\n");
872
                        PutSeite("   image\n");
873
                        PutSeite("   }\n");
874
                        PutSeite(">> matrix makepattern setpattern\n");
80 Franz 875
                        PutSeite("<< /ImageType 1\n");
3 paul 876
                        PutSeite("   /Width " + IToStr(w) + "\n");
877
                        PutSeite("   /Height " + IToStr(h) + "\n");
878
                        PutSeite("   /BitsPerComponent 1\n");
879
                        PutSeite("   /Decode [1 0]\n");
234 Franz 880
                        PutSeite("   /ImageMatrix [" + IToStr(w) + " 0 0 " + IToStr(-h) + " 0 " + IToStr(h) + "]\n");
3 paul 881
                        PutSeite("   /DataSource "+PSEncode(Name)+"Mask\n");
882
                        PutSeite(">>\n");
883
                        PutSeite("imagemask\n");
884
                        if (Name != "")
188 Franz 885
                        {
3 paul 886
                                PutSeite(PSEncode(Name)+"Bild resetfile\n");
887
                                PutSeite(PSEncode(Name)+"Mask resetfile\n");
888
                        }
188 Franz 889
                }
3 paul 890
                else
188 Franz 891
                {
80 Franz 892
                        PutSeite("<< /ImageType 1\n");
3 paul 893
                        PutSeite("   /Width " + IToStr(w) + "\n");
894
                        PutSeite("   /Height " + IToStr(h) + "\n");
895
                        PutSeite("   /BitsPerComponent 8\n");
896
                        if (DoSep)
897
                                PutSeite("   /Decode [1 0]\n");
898
                        else
80 Franz 899
                                PutSeite( GraySc ? "   /Decode [1 0]\n" : "   /Decode [0 1 0 1 0 1 0 1]\n");
188 Franz 900
                        PutSeite("   /ImageMatrix [" + IToStr(w) + " 0 0 " + IToStr(-h) + " 0 " + IToStr(h) +
901
                                        "]\n");
3 paul 902
                        if (Name != "")
188 Franz 903
                        {
3 paul 904
                                PutSeite("   /DataSource "+PSEncode(Name)+"Bild >>\n");
905
                                PutSeite("image\n");
906
                                PutSeite(PSEncode(Name)+"Bild resetfile\n");
188 Franz 907
                        }
3 paul 908
                        else
234 Franz 909
                        {
80 Franz 910
                                PutSeite ( CompAvail ? "   /DataSource currentfile /ASCIIHexDecode filter /FlateDecode filter >>\n" :
188 Franz 911
                                                        "   /DataSource currentfile /ASCIIHexDecode filter >>\n");
3 paul 912
                                PutSeite("image\n");
913
#ifdef HAVE_CMS
914
                                if ((CMSuse) && (UseProf))
188 Franz 915
                                {
3 paul 916
                                        if (DoSep)
917
                                                ImgStr = ImageToCMYK_PS(&image2, Plate, cmy);
918
                                        else
188 Franz 919
                                                ImgStr = GraySc ? ImageToCMYK_PS(&image2, -2, cmy) :
920
                                                                        ImageToCMYK_PS(&image2, -1, cmy);
921
                                }
3 paul 922
                                else
188 Franz 923
                                {
3 paul 924
                                        if (DoSep)
925
                                                ImgStr = ImageToCMYK_PS(&image, Plate, false);
926
                                        else
188 Franz 927
                                                ImgStr = GraySc ? ImageToCMYK_PS(&image, -2, false) :
928
                                                                        ImageToCMYK_PS(&image, -1, false);
929
                                }
3 paul 930
#else
931
                                if (DoSep)
932
                                        ImgStr = ImageToCMYK_PS(&image, Plate, false);
933
                                else
188 Franz 934
                                        ImgStr = GraySc ? ImageToCMYK_PS(&image, -2, false) :          
935
                                                                ImageToCMYK_PS(&image, -1, false);
3 paul 936
#endif
937
                                if (CompAvail)
938
                                        ImgStr = CompressStr(&ImgStr);
939
                                ImgStr = String2Hex(&ImgStr);
940
                                PutSeite(ImgStr);
941
                                PutSeite("\n>\n");
942
                        }
188 Franz 943
                }
234 Franz 944
        }
3 paul 945
}
946
 
80 Franz 947
 
3 paul 948
void PSLib::PS_plate(int nr)
949
{
950
        switch (nr)
188 Franz 951
        {
3 paul 952
                case 0:
953
                        PutSeite("%%PlateColor Black\n");
954
                        PutSeite("/setcmykcolor {exch pop exch pop exch pop 1 exch sub oldsetgray} bind def\n");
955
                        PutSeite("/setrgbcolor {pop pop pop 1 oldsetgray} bind def\n");
956
                        break;
957
                case 1:
958
                        PutSeite("%%PlateColor Cyan\n");
959
                        PutSeite("/setcmykcolor {pop pop pop 1 exch sub oldsetgray} bind def\n");
960
                        PutSeite("/setrgbcolor {pop pop oldsetgray} bind def\n");
961
                        break;
962
                case 2:
963
                        PutSeite("%%PlateColor Magenta\n");
964
                        PutSeite("/setcmykcolor {pop pop exch pop 1 exch sub oldsetgray} bind def\n");
965
                        PutSeite("/setrgbcolor {pop exch pop oldsetgray} bind def\n");
966
                        break;
967
                case 3:
968
                        PutSeite("%%PlateColor Yellow\n");
969
                        PutSeite("/setcmykcolor {pop exch pop exch pop 1 exch sub oldsetgray} bind def\n");
970
                        PutSeite("/setrgbcolor {exch pop exch pop oldsetgray} bind def\n");
971
                        break;
188 Franz 972
        }
3 paul 973
        Plate = nr;
974
        DoSep = true;
975
}
976
 
977
void PSLib::PS_setGray()
978
{
979
        GraySc = true;
980
}
981
 
982
void PSLib::PDF_Bookmark(QString text, uint Seite)
983
{
984
        PutSeite("[/Title ("+text+") /Page "+IToStr(Seite)+" /View [/Fit]\n");
985
        PutSeite("/OUT pdfmark\n");
986
        isPDF = true;
987
}
988
 
80 Franz 989
void PSLib::PDF_Annotation(QString text, double x, double y, double b, double h)
3 paul 990
{
188 Franz 991
        PutSeite("[ /Rect [ "+ToStr(static_cast<int>(x))+" "+ToStr(static_cast<int>(y))
992
                        +" "+ToStr(static_cast<int>(b))+" "+ToStr(static_cast<int>(h))+" ]\n");
3 paul 993
        PutSeite("  /Contents ("+text+")\n  /Open false\n");
994
        PutSeite("/ANN pdfmark\n");
995
        isPDF = true;
996
}
997
 
998
 
999
void PSLib::PS_close()
1000
{
1001
        PutDoc("%%Trailer\n");
1002
        PutDoc("end\n");
1003
        PutDoc("%%EOF\n");
1004
        Spool.close();
1005
}
68 Franz 1006
 
1007
 
1008
void PSLib::PS_insert(QString i)
1009
{
1010
        PutDoc(i);
1011
}
456 fschmid 1012
 
1013
void PSLib::CreatePS(ScribusDoc* Doc, ScribusView* view, std::vector<int> &pageNs, bool sep, QString SepNam, bool farb, bool Hm, bool Vm, bool Ic, bool gcr)
1014
{
1015
        uint a;
1016
        int sepac;
741 fschmid 1017
        double wideR = 0;
456 fschmid 1018
        QValueList<double> dum;
1019
        double gx, gy, gw, gh;
1020
        dum.clear();
1021
        PS_set_Info("Author", Doc->DocAutor);
1022
        PS_set_Info("Title", Doc->DocTitel);
1023
        if (!farb)
1024
                PS_setGray();
1025
        if ((!Art) && (view->SelItem.count() != 0))
1026
        {
1027
                view->setGroupRect();
1028
                view->getGroupRect(&gx, &gy, &gw, &gh);
1029
                int pgNum = pageNs[0];
1030
                gx -= Doc->Pages.at(pgNum)->Xoffset;
1031
                gy -= Doc->Pages.at(pgNum)->Yoffset;
1032
                PS_begin_doc(Doc->PageOri, gx, Doc->PageH - (gy+gh), gx + gw, Doc->PageH - gy, 1);
1033
        }
1034
        else
1035
                PS_begin_doc(Doc->PageOri, 0.0, 0.0, Doc->PageB, Doc->PageH, pageNs.size());
1036
        for (uint ap = 0; ap < Doc->MasterPages.count(); ++ap)
1037
        {
1038
                if (Doc->MasterItems.count() != 0)
1039
                {
1040
                        if ((!sep) && (farb))
1041
                        {
1042
                                for (uint api = 0; api < Doc->MasterItems.count(); ++api)
1043
                                {
1044
                                        PageItem *it = Doc->MasterItems.at(api);
1045
                                        int x = static_cast<int>(Doc->MasterPages.at(ap)->Xoffset);
1046
                                        int y = static_cast<int>(Doc->MasterPages.at(ap)->Yoffset);
1047
                                        int w = static_cast<int>(Doc->MasterPages.at(ap)->Width);
1048
                                        int h = static_cast<int>(Doc->MasterPages.at(ap)->Height);
517 fschmid 1049
                                        int x2 = static_cast<int>(it->BoundingX - it->Pwidth / 2.0);
1050
                                        int y2 = static_cast<int>(it->BoundingY - it->Pwidth / 2.0);
1051
                                        int w2 = static_cast<int>(it->BoundingW + it->Pwidth);
1052
                                        int h2 = static_cast<int>(it->BoundingH + it->Pwidth);
456 fschmid 1053
                                        if (!QRect(x, y, w, h).intersects(QRect(x2, y2, w2, h2)))
1054
                                                continue;
1055
                                        if ((it->OwnPage != static_cast<int>(Doc->MasterPages.at(ap)->PageNr)) && (it->OwnPage != -1))
1056
                                                continue;
1057
                                        if ((it->PType == 2) && (it->PicAvail) && (it->Pfile != "") && (it->isPrintable))
1058
                                                PS_ImageData(it->InvPict, it->Pfile, it->AnName, it->IProfile, it->UseEmbedded, Ic);
1059
                                }
1060
                        }
1061
                        PS_TemplateStart(Doc->MasterPages.at(ap)->PageNam, Doc->PageB, Doc->PageH);
1062
                        ProcessPage(Doc, view, Doc->MasterPages.at(ap), ap+1, sep, farb, Ic, gcr);
1063
                        PS_TemplateEnd();
1064
                }
1065
        }
1066
        sepac = 0;
1067
        uint aa = 0;
1068
        while (aa < pageNs.size())
1069
        {
1070
                a = pageNs[aa]-1;
1071
                if ((!Art) && (view->SelItem.count() != 0))
1072
                {
1073
                        struct Margs Ma;
1074
                        Ma.Left = gx;
1075
                        Ma.Top = gy;
1076
                        Ma.Bottom = Doc->PageH - (gy + gh);
1077
                        Ma.Right = Doc->PageB - (gx + gw);
1078
                        PS_begin_page(Doc->PageB, Doc->PageH, &Ma, true);
1079
                }
1080
                else
1081
                        PS_begin_page(Doc->PageB, Doc->PageH, &Doc->Pages.at(a)->Margins, view->Prefs->ClipMargin);
1082
                if (Hm)
1083
                {
1084
                        PS_translate(Doc->PageB, 0);
1085
                        PS_scale(-1, 1);
1086
                }
1087
                if (Vm)
1088
                {
1089
                        PS_translate(0, Doc->PageH);
1090
                        PS_scale(1, -1);
1091
                }
1092
                if (sep)
1093
                {
1094
                        if (SepNam == "Black")
1095
                                PS_plate(0);
1096
                        if (SepNam == "Cyan")
1097
                                PS_plate(1);
1098
                        if (SepNam == "Magenta")
1099
                                PS_plate(2);
1100
                        if (SepNam == "Yellow")
1101
                                PS_plate(3);
1102
                        if (SepNam == QObject::tr("All"))
1103
                                PS_plate(sepac);
1104
                }
1105
                if (Doc->Pages.at(a)->MPageNam != "")
1106
                {
1107
                        int h, s, v, k, tsz;
1108
                        QCString chxc;
1109
                        QString chx;
1110
                        struct Pti *hl;
1111
                        int Lnr = 0;
1112
                        struct Layer ll;
1113
                        ll.Drucken = false;
1114
                        ll.LNr = 0;
1115
                        Page* mPage = Doc->MasterPages.at(Doc->MasterNames[Doc->Pages.at(a)->MPageNam]);
1116
                        if (Doc->MasterItems.count() != 0)
1117
                        {
1118
                                PS_UseTemplate(Doc->Pages.at(a)->MPageNam);
1119
                                for (uint lam = 0; lam < Doc->Layers.count(); ++lam)
1120
                                {
1121
                                        Level2Layer(Doc, &ll, Lnr);
1122
                                        if (ll.Drucken)
1123
                                        {
1124
                                                for (uint am = 0; am < Doc->Pages.at(a)->FromMaster.count(); ++am)
1125
                                                {
1126
                                                        PageItem *ite = Doc->Pages.at(a)->FromMaster.at(am);
1127
                                                        if ((ite->LayerNr != ll.LNr) || (!ite->isPrintable))
1128
                                                                continue;
1129
                                                        if ((ite->PType == 2) && ((sep) || (!farb)))
1130
                                                        {
1131
                                                                PS_save();
1132
                                                                PS_translate(ite->Xpos - mPage->Xoffset, Doc->PageH -(ite->Ypos) - mPage->Yoffset);
1133
                                                                if (ite->Rot != 0)
1134
                                                                        PS_rotate(-ite->Rot);
1135
                                                                if (ite->Pcolor != "None")
1136
                                                                {
1137
                                                                        SetFarbe(Doc, ite->Pcolor, ite->Shade, &h, &s, &v, &k, gcr);
1138
                                                                        PS_setcmykcolor_fill(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1139
                                                                        SetClipPath(&ite->PoLine);
1140
                                                                        PS_closepath();
1141
                                                                        PS_fill();
1142
                                                                }
1143
                                                                else
1144
                                                                        PS_setcmykcolor_dummy();
1145
                                                                SetClipPath(&ite->PoLine);
1146
                                                                PS_closepath();
1147
                                                                PS_clip(false);
1148
                                                                PS_save();
1149
                                                                if ((ite->flippedH % 2) != 0)
1150
                                                                {
1151
                                                                        PS_translate(ite->Width, 0);
1152
                                                                        PS_scale(-1, 1);
1153
                                                                }
1154
                                                                if ((ite->flippedV % 2) != 0)
1155
                                                                {
1156
                                                                        PS_translate(0, -ite->Height);
1157
                                                                        PS_scale(1, -1);
1158
                                                                }
1159
                                                                if ((ite->PicAvail) && (ite->Pfile != ""))
1160
                                                                {
1161
                                                                        PS_translate(0, -ite->BBoxH*ite->LocalScY);
1162
                                                                        PS_image(ite->InvPict, -ite->BBoxX+ite->LocalX, -ite->LocalY, ite->Pfile, ite->LocalScX, ite->LocalScY, ite->IProfile, ite->UseEmbedded, Ic, ite->AnName);
1163
                                                                }
1164
                                                                PS_restore();
1165
                                                                if (((ite->Pcolor2 != "None") || (ite->NamedLStyle != "")) && (!ite->isTableItem))
1166
                                                                {
1167
                                                                        if ((ite->NamedLStyle == "") && (ite->Pwidth != 0.0))
1168
                                                                        {
1169
                                                                                SetFarbe(Doc, ite->Pcolor2, ite->Shade2, &h, &s, &v, &k, gcr);
1170
                                                                                PS_setcmykcolor_stroke(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1171
                                                                                PS_setlinewidth(ite->Pwidth);
1172
                                                                                PS_setcapjoin(ite->PLineEnd, ite->PLineJoin);
1173
                                                                                PS_setdash(ite->PLineArt, ite->DashOffset, ite->DashValues);
1174
                                                                                SetClipPath(&ite->PoLine);
1175
                                                                                PS_closepath();
1176
                                                                                PS_stroke();
1177
                                                                        }
1178
                                                                        else
1179
                                                                        {
1180
                                                                                multiLine ml = Doc->MLineStyles[ite->NamedLStyle];
1181
                                                                                for (int it = ml.size()-1; it > -1; it--)
1182
                                                                                {
1183
                                                                                        SetFarbe(Doc, ml[it].Color, ml[it].Shade, &h, &s, &v, &k, gcr);
1184
                                                                                        PS_setcmykcolor_stroke(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1185
                                                                                        PS_setlinewidth(ml[it].Width);
1186
                                                                                        PS_setcapjoin(static_cast<Qt::PenCapStyle>(ml[it].LineEnd), static_cast<Qt::PenJoinStyle>(ml[it].LineJoin));
1187
                                                                                        PS_setdash(static_cast<Qt::PenStyle>(ml[it].Dash), 0, dum);
1188
                                                                                        SetClipPath(&ite->PoLine);
1189
                                                                                        PS_closepath();
1190
                                                                                        PS_stroke();
1191
                                                                                }
1192
                                                                        }
1193
                                                                }
1194
                                                                PS_restore();
1195
                                                        }
1196
                                                        if (ite->PType == 4)
1197
                                                        {
1198
                                                                double savScale = view->Scale;
1199
                                                                view->Scale = 1.0;
1200
                                                                Doc->RePos = true;
1201
                                                                QPixmap pgPix(10, 10);
1202
                                                                QRect rd = QRect(0,0,9,9);
1203
                                                                ScPainter *painter = new ScPainter(&pgPix, pgPix.width(), pgPix.height());
1204
                                                                ite->DrawObj(painter, rd);
1205
                                                                Doc->RePos = false;
1206
                                                                view->Scale = savScale;
1207
                                                                delete painter;
1208
                                                                PS_save();
1209
                                                                if (ite->Pcolor != "None")
1210
                                                                {
1211
                                                                        SetFarbe(Doc, ite->Pcolor, ite->Shade, &h, &s, &v, &k, gcr);
1212
                                                                        PS_setcmykcolor_fill(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1213
                                                                }
1214
                                                                PS_translate(ite->Xpos - mPage->Xoffset, Doc->PageH - (ite->Ypos - mPage->Yoffset));
1215
                                                                if (ite->Rot != 0)
1216
                                                                        PS_rotate(-ite->Rot);
1217
                                                                if ((ite->Pcolor != "None") || (ite->GrType != 0))
1218
                                                                {
1219
                                                                        SetClipPath(&ite->PoLine);
1220
                                                                        PS_closepath();
1221
                                                                        PS_fill();
1222
                                                                }
1223
                                                                if ((ite->flippedH % 2) != 0)
1224
                                                                {
1225
                                                                        PS_translate(ite->Width, 0);
1226
                                                                        PS_scale(-1, 1);
1227
                                                                }
1228
                                                                if ((ite->flippedV % 2) != 0)
1229
                                                                {
1230
                                                                        PS_translate(0, -ite->Height);
1231
                                                                        PS_scale(1, -1);
1232
                                                                }
1233
                                                                for (uint d = 0; d < ite->MaxChars; ++d)
1234
                                                                {
1235
                                                                        hl = ite->Ptext.at(d);
1236
                                                                        if ((hl->ch == QChar(13)) || (hl->ch == QChar(10)) || (hl->ch == QChar(9)) || (hl->ch == QChar(28)))
1237
                                                                                continue;
1238
                                                                        if (hl->cstyle & 256)
1239
                                                                                continue;
1240
                                                                        if (hl->yp == 0)
1241
                                                                                continue;
1242
                                                                        tsz = hl->csize;
1243
                                                                        chx = hl->ch;
1244
                                                                        if (hl->ch == QChar(29))
1245
                                                                                chx = " ";
1246
                                                                        if (hl->ch == QChar(30))
1247
                                                                        {
1248
                                                                                if (Doc->MasterP)
1249
                                                                                        chx = "#";
1250
                                                                                else
1251
                                                                                {
1252
                                                                                        uint zae = 0;
1253
                                                                                        uint za2 = d;
1254
                                                                                        do
1255
                                                                                        {
1256
                                                                                                if (za2 == 0)
1257
                                                                                                        break;
1258
                                                                                                za2--;
1259
                                                                                        }
1260
                                                                                        while (ite->Ptext.at(za2)->ch == QChar(30));
1261
                                                                                        if (ite->Ptext.at(za2)->ch != QChar(30))
1262
                                                                                                za2++;
1263
                                                                                        while (ite->Ptext.at(za2+zae)->ch == QChar(30))
1264
                                                                                        {
1265
                                                                                                zae++;
1266
                                                                                                if (za2+zae == ite->MaxChars)
1267
                                                                                                        break;
1268
                                                                                        }
1269
                                                                                        QString out="%1";
1270
                                                                                        QString out2;
1271
                                                                                        out2 = out.arg(a+Doc->FirstPnum, -zae);
1272
                                                                                        chx = out2.mid(d-za2, 1);
1273
                                                                                }
1274
                                                                        }
1275
                                                                        if (hl->cstyle & 64)
1276
                                                                        {
1277
                                                                                if (chx.upper() != chx)
1278
                                                                                {
823 fschmid 1279
                                                                                        tsz = hl->csize * Doc->typographicSetttings.valueSmallCaps / 100;
456 fschmid 1280
                                                                                        chx = chx.upper();
1281
                                                                                }
1282
                                                                        }
1283
                                                                        if (hl->cstyle & 1)
823 fschmid 1284
                                                                                tsz = hl->csize * Doc->typographicSetttings.scalingSuperScript / 100;
456 fschmid 1285
                                                                        if (hl->cstyle & 2)
823 fschmid 1286
                                                                                tsz = hl->csize * Doc->typographicSetttings.scalingSuperScript / 100;
456 fschmid 1287
                                                                        /* Subset all TTF Fonts until the bug in the TTF-Embedding Code is fixed */
1288
                                                                        QFileInfo fd = QFileInfo((*Doc->AllFonts)[hl->cfont]->Datei);
1289
                                                                        QString fext = fd.extension(false).lower();
1290
                                                                        if ((fext == "ttf") || ((*Doc->AllFonts)[hl->cfont]->isOTF) || ((*Doc->AllFonts)[hl->cfont]->Subset))
1291
                                                                        {
1292
                                                                                uint chr = chx[0].unicode();
1293
                                                                                if (((*Doc->AllFonts)[hl->cfont]->CharWidth.contains(chr)) && (chr != 32))
1294
                                                                                {
1295
                                                                                        PS_save();
1296
                                                                                        if (ite->Reverse)
1297
                                                                                        {
1298
                                                                                                PS_translate(hl->xp, (hl->yp - (tsz / 10.0)) * -1);
1299
                                                                                                PS_scale(-1, 1);
1300
                                                                                                if (d < ite->MaxChars-1)
1301
                                                                                                {
1302
                                                                                                        QString ctx = ite->Ptext.at(d+1)->ch;
1303
                                                                                                        if (ctx == QChar(29))
1304
                                                                                                                ctx = " ";
1305
                                                                                                        wideR = -Cwidth(Doc, hl->cfont, chx, tsz, ctx) * (hl->cscale / 100.0);
1306
                                                                                                }
1307
                                                                                                else
1308
                                                                                                        wideR = -Cwidth(Doc, hl->cfont, chx, tsz) * (hl->cscale / 100.0);
1309
                                                                                                PS_translate(wideR, 0);
1310
                                                                                        }
1311
                                                                                        else
1312
                                                                                                PS_translate(hl->xp, (hl->yp - (tsz / 10.0)) * -1);
1313
                                                                                        if (hl->cscale != 100)
1314
                                                                                                PS_scale(hl->cscale / 100.0, 1);
1315
                                                                                        if (hl->ccolor != "None")
1316
                                                                                        {
1317
                                                                                                SetFarbe(Doc, hl->ccolor, hl->cshade, &h, &s, &v, &k, gcr);
1318
                                                                                                PS_setcmykcolor_fill(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1319
                                                                                                PS_showSub(chr, (*Doc->AllFonts)[hl->cfont]->RealName(), tsz / 10.0, false);
1320
                                                                                        }
1321
                                                                                        PS_restore();
1322
                                                                                }
1323
                                                                        }
1324
                                                                        else
1325
                                                                        {
1326
                                                                                PS_selectfont(hl->cfont, tsz / 10.0);
1327
                                                                                if (hl->ccolor != "None")
1328
                                                                                {
1329
                                                                                        SetFarbe(Doc, hl->ccolor, hl->cshade, &h, &s, &v, &k, gcr);
1330
                                                                                        PS_setcmykcolor_stroke(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1331
                                                                                }
1332
                                                                                PS_save();
1333
                                                                                if (ite->Reverse)
1334
                                                                                {
1335
                                                                                        int chs = hl->csize;
1336
                                                                                        ite->SetZeichAttr(hl, &chs, &chx);
1337
                                                                                        PS_translate(hl->xp, -hl->yp);
1338
                                                                                        PS_scale(-1, 1);
1339
                                                                                        if (d < ite->MaxChars-1)
1340
                                                                                        {
1341
                                                                                                QString ctx = ite->Ptext.at(d+1)->ch;
1342
                                                                                                if (ctx == QChar(29))
1343
                                                                                                        ctx = " ";
1344
                                                                                                wideR = -Cwidth(Doc, hl->cfont, chx, chs, ctx) * (hl->cscale / 100.0);
1345
                                                                                                PS_translate(wideR, 0);
1346
                                                                                        }
1347
                                                                                        else
1348
                                                                                        {
1349
                                                                                                wideR = -Cwidth(Doc, hl->cfont, chx, chs) * (hl->cscale / 100.0);
1350
                                                                                                PS_translate(wideR, 0);
1351
                                                                                        }
1352
                                                                                        if (hl->cscale != 100)
1353
                                                                                                PS_scale(hl->cscale / 100.0, 1);
1354
                                                                                        PS_show_xyG(hl->cfont, chx, 0, 0);
1355
                                                                                }
1356
                                                                                else
1357
                                                                                {
1358
                                                                                        PS_translate(hl->xp, -hl->yp);
1359
                                                                                        if (hl->cscale != 100)
1360
                                                                                                PS_scale(hl->cscale / 100.0, 1);
1361
                                                                                        PS_show_xyG(hl->cfont, chx, 0, 0);
1362
                                                                                }
1363
                                                                                PS_restore();
1364
                                                                        }
1365
                                                                        if ((hl->cstyle & 4) && (chx != QChar(13)))
1366
                                                                        {
1367
                                                                                uint chr = chx[0].unicode();
1368
                                                                                if ((*Doc->AllFonts)[hl->cfont]->CharWidth.contains(chr))
1369
                                                                                {
1370
                                                                                        FPointArray gly = (*Doc->AllFonts)[hl->cfont]->GlyphArray[chr].Outlines.copy();
1371
                                                                                        QWMatrix chma;
1372
                                                                                        chma.scale(tsz / 100.0, tsz / 100.0);
1373
                                                                                        gly.map(chma);
1374
                                                                                        chma = QWMatrix();
1375
                                                                                        chma.scale(hl->cscale / 100.0, 1);
1376
                                                                                        gly.map(chma);
1377
                                                                                        if (ite->Reverse)
1378
                                                                                        {
1379
                                                                                                chma = QWMatrix();
1380
                                                                                                chma.scale(-1, 1);
1381
                                                                                                chma.translate(wideR, 0);
1382
                                                                                                gly.map(chma);
1383
                                                                                        }
1384
                                                                                        if (hl->cstroke != "None")
1385
                                                                                        {
1386
                                                                                                PS_save();
1387
                                                                                                PS_setlinewidth(QMAX((*Doc->AllFonts)[hl->cfont]->strokeWidth / 2 * (tsz / 10.0), 1));
1388
                                                                                                PS_setcapjoin(Qt::FlatCap, Qt::MiterJoin);
1389
                                                                                                PS_setdash(Qt::SolidLine, 0, dum);
1390
                                                                                                PS_translate(hl->xp, (hl->yp - tsz) * -1);
1391
                                                                                                SetFarbe(Doc, hl->cstroke, hl->cshade2, &h, &s, &v, &k, gcr);
1392
                                                                                                PS_setcmykcolor_stroke(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1393
                                                                                                SetClipPath(&gly);
1394
                                                                                                PS_closepath();
1395
                                                                                                PS_stroke();
1396
                                                                                                PS_restore();
1397
                                                                                        }
1398
                                                                                }
1399
                                                                        }
1400
                                                                        if ((hl->cstyle & 16) && (chx != QChar(13)))
1401
                                                                        {
1402
                                                                                double Ulen = Cwidth(Doc, hl->cfont, chx, hl->csize) * (hl->cscale / 100.0);
1403
                                                                                double Upos = (*Doc->AllFonts)[hl->cfont]->strikeout_pos * (tsz / 10.0);
1404
                                                                                if (hl->ccolor != "None")
1405
                                                                                {
1406
                                                                                        PS_setcapjoin(Qt::FlatCap, Qt::MiterJoin);
1407
                                                                                        PS_setdash(Qt::SolidLine, 0, dum);
1408
                                                                                        SetFarbe(Doc, hl->ccolor, hl->cshade, &h, &s, &v, &k, gcr);
1409
                                                                                        PS_setcmykcolor_stroke(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1410
                                                                                }
1411
                                                                                PS_setlinewidth((*Doc->AllFonts)[hl->cfont]->strokeWidth * (tsz / 10.0));
1412
                                                                                PS_moveto(hl->xp, -hl->yp+Upos);
1413
                                                                                PS_lineto(hl->xp+Ulen, -hl->yp+Upos);
1414
                                                                                PS_stroke();
1415
                                                                        }
1416
                                                                        if ((hl->cstyle & 8) && (chx != QChar(13)))
1417
                                                                        {
1418
                                                                                double Ulen = Cwidth(Doc, hl->cfont, chx, hl->csize) * (hl->cscale / 100.0);
1419
                                                                                double Upos = (*Doc->AllFonts)[hl->cfont]->underline_pos * (tsz / 10.0);
1420
                                                                                if (hl->ccolor != "None")
1421
                                                                                {
1422
                                                                                        PS_setcapjoin(Qt::FlatCap, Qt::MiterJoin);
1423
                                                                                        PS_setdash(Qt::SolidLine, 0, dum);
1424
                                                                                        SetFarbe(Doc, hl->ccolor, hl->cshade, &h, &s, &v, &k, gcr);
1425
                                                                                        PS_setcmykcolor_stroke(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1426
                                                                                }
1427
                                                                                PS_setlinewidth((*Doc->AllFonts)[hl->cfont]->strokeWidth * (tsz / 10.0));
1428
                                                                                PS_moveto(hl->xp, -hl->yp+Upos);
1429
                                                                                PS_lineto(hl->xp+Ulen, -hl->yp+Upos);
1430
                                                                                PS_stroke();
1431
                                                                        }
1432
                                                                        if (hl->cstyle & 512)
1433
                                                                        {
1434
                                                                                int chs = hl->csize;
1435
                                                                                ite->SetZeichAttr(hl, &chs, &chx);
1436
                                                                                double wide = Cwidth(Doc, hl->cfont, chx, chs);
1437
                                                                                chx = "-";
1438
                                                                                uint chr = chx[0].unicode();
1439
                                                                                if ((*Doc->AllFonts)[hl->cfont]->CharWidth.contains(chr))
1440
                                                                                {
1441
                                                                                        FPointArray gly = (*Doc->AllFonts)[hl->cfont]->GlyphArray[chr].Outlines.copy();
1442
                                                                                        QWMatrix chma;
1443
                                                                                        chma.scale(tsz / 100.0, tsz / 100.0);
1444
                                                                                        gly.map(chma);
1445
                                                                                        chma = QWMatrix();
1446
                                                                                        chma.scale(hl->cscale / 100.0, 1);
1447
                                                                                        gly.map(chma);
1448
                                                                                        if (hl->ccolor != "None")
1449
                                                                                        {
1450
                                                                                                PS_save();
1451
                                                                                                PS_newpath();
1452
                                                                                                PS_translate(hl->xp+wide, (hl->yp - (tsz / 10.0)) * -1);
1453
                                                                                                SetFarbe(Doc, hl->ccolor, hl->cshade, &h, &s, &v, &k, gcr);
1454
                                                                                                PS_setcmykcolor_fill(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1455
                                                                                                SetClipPath(&gly);
1456
                                                                                                PS_closepath();
1457
                                                                                                PS_fill();
1458
                                                                                                PS_restore();
1459
                                                                                        }
1460
                                                                                }
1461
                                                                        }
1462
                                                                }
1463
                                                                if (((ite->Pcolor2 != "None") || (ite->NamedLStyle != "")) && (!ite->isTableItem))
1464
                                                                {
1465
                                                                        if ((ite->NamedLStyle == "") && (ite->Pwidth != 0.0))
1466
                                                                        {
1467
                                                                                SetFarbe(Doc, ite->Pcolor2, ite->Shade2, &h, &s, &v, &k, gcr);
1468
                                                                                PS_setcmykcolor_stroke(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1469
                                                                                PS_setlinewidth(ite->Pwidth);
1470
                                                                                PS_setcapjoin(ite->PLineEnd, ite->PLineJoin);
1471
                                                                                PS_setdash(ite->PLineArt, ite->DashOffset, ite->DashValues);
1472
                                                                                SetClipPath(&ite->PoLine);
1473
                                                                                PS_closepath();
1474
                                                                                PS_stroke();
1475
                                                                        }
1476
                                                                        else
1477
                                                                        {
1478
                                                                                multiLine ml = Doc->MLineStyles[ite->NamedLStyle];
1479
                                                                                for (int it = ml.size()-1; it > -1; it--)
1480
                                                                                {
1481
                                                                                        SetFarbe(Doc, ml[it].Color, ml[it].Shade, &h, &s, &v, &k, gcr);
1482
                                                                                        PS_setcmykcolor_stroke(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1483
                                                                                        PS_setlinewidth(ml[it].Width);
1484
                                                                                        PS_setcapjoin(static_cast<Qt::PenCapStyle>(ml[it].LineEnd), static_cast<Qt::PenJoinStyle>(ml[it].LineJoin));
1485
                                                                                        PS_setdash(static_cast<Qt::PenStyle>(ml[it].Dash), 0, dum);
1486
                                                                                        SetClipPath(&ite->PoLine);
1487
                                                                                        PS_closepath();
1488
                                                                                        PS_stroke();
1489
                                                                                }
1490
                                                                        }
1491
                                                                }
1492
                                                                PS_restore();
1493
                                                        }
1494
                                                }
1495
                                        }
1496
                                        for (uint am = 0; am < Doc->Pages.at(a)->FromMaster.count(); ++am)
1497
                                        {
1498
                                                PageItem *ite = Doc->Pages.at(a)->FromMaster.at(am);
1499
                                                if ((ite->PType == 2) && ((sep) || (!farb)))
1500
                                                        continue;
1501
                                                if (ite->isPrintable)
1502
                                                {
1503
                                                        PS_save();
1504
                                                        if (ite->Pcolor2 != "None")
1505
                                                        {
1506
                                                                SetFarbe(Doc, ite->Pcolor2, ite->Shade2, &h, &s, &v, &k, gcr);
1507
                                                                PS_setcmykcolor_stroke(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1508
                                                        }
1509
                                                        PS_setlinewidth(ite->Pwidth);
1510
                                                        PS_setcapjoin(ite->PLineEnd, ite->PLineJoin);
1511
                                                        PS_setdash(ite->PLineArt, ite->DashOffset, ite->DashValues);
1512
                                                        PS_translate(ite->Xpos - mPage->Xoffset, Doc->PageH - (ite->Ypos - mPage->Yoffset));
1513
                                                        if (ite->Rot != 0)
1514
                                                                PS_rotate(-ite->Rot);
1515
                                                        if (ite->isTableItem)
1516
                                                        {
1517
                                                                if ((ite->TopLine) || (ite->RightLine) || (ite->BottomLine) || (ite->LeftLine))
1518
                                                                {
1519
                                                                        if (ite->TopLine)
1520
                                                                        {
1521
                                                                                PS_moveto(0, 0);
1522
                                                                                PS_lineto(ite->Width, 0);
1523
                                                                        }
1524
                                                                        if (ite->RightLine)
1525
                                                                        {
1526
                                                                                PS_moveto(ite->Width, 0);
1527
                                                                                PS_lineto(ite->Width, -ite->Height);
1528
                                                                        }
1529
                                                                        if (ite->BottomLine)
1530
                                                                        {
1531
                                                                                PS_moveto(0, -ite->Height);
1532
                                                                                PS_lineto(ite->Width, -ite->Height);
1533
                                                                        }
1534
                                                                        if (ite->LeftLine)
1535
                                                                        {
1536
                                                                                PS_moveto(0, 0);
1537
                                                                                PS_lineto(0, -ite->Height);
1538
                                                                        }
1539
                                                                        PS_stroke();
1540
                                                                }
1541
                                                        }
1542
                                                        PS_restore();
1543
                                                }
1544
                                        }
1545
                                        Lnr++;
1546
                                }
1547
                        }
1548
                }
1549
                ProcessPage(Doc, view, Doc->Pages.at(a), a+1, sep, farb, Ic, gcr);
1550
                PS_end_page();
1551
                if (sep)
1552
                {
1553
                        if (SepNam != QObject::tr("All"))
1554
                                aa++;
1555
                        else
1556
                        {
1557
                                if (sepac == 3)
1558
                                {
1559
                                        aa++;
1560
                                        sepac = 0;
1561
                                }
1562
                                else
1563
                                        sepac++;
1564
                        }
1565
                }
1566
                else
1567
                        aa++;
1568
        }
1569
        PS_close();
1570
}
1571
 
1572
void PSLib::ProcessPage(ScribusDoc* Doc, ScribusView* view, Page* a, uint PNr, bool sep, bool farb, bool ic, bool gcr)
1573
{
1574
        uint b, d;
1575
        int h, s, v, k, tsz;
741 fschmid 1576
        double wideR = 0;
456 fschmid 1577
        QValueList<double> dum;
1578
        dum.clear();
1579
        QCString chxc;
1580
        QString chx, chglyph, tmp;
1581
        PageItem *c;
1582
        QPtrList<PageItem> PItems;
1583
        struct Pti *hl;
1584
        int Lnr = 0;
1585
        struct Layer ll;
1586
        ll.Drucken = false;
1587
        ll.LNr = 0;
1588
        for (uint la = 0; la < Doc->Layers.count(); ++la)
1589
        {
1590
                Level2Layer(Doc, &ll, Lnr);
1591
                if (a->PageNam != "")
1592
                        PItems = Doc->MasterItems;
1593
                else
1594
                        PItems = Doc->Items;
1595
                if (ll.Drucken)
1596
                {
1597
                        for (b = 0; b < PItems.count(); ++b)
1598
                        {
1599
                                c = PItems.at(b);
1600
                                if (c->LayerNr != ll.LNr)
1601
                                        continue;
1602
                                if ((a->PageNam != "") && (c->PType == 4))
1603
                                        continue;
1604
                                if ((a->PageNam != "") && (c->PType == 2) && ((sep) || (!farb)))
1605
                                        continue;
1606
                                if ((!Art) && (view->SelItem.count() != 0) && (!c->Select))
1607
                                        continue;
1608
                                int x = static_cast<int>(a->Xoffset);
1609
                                int y = static_cast<int>(a->Yoffset);
1610
                                int w = static_cast<int>(a->Width);
1611
                                int h1 = static_cast<int>(a->Height);
517 fschmid 1612
                                int x2 = static_cast<int>(c->BoundingX - c->Pwidth / 2.0);
1613
                                int y2 = static_cast<int>(c->BoundingY - c->Pwidth / 2.0);
1614
                                int w2 = static_cast<int>(c->BoundingW + c->Pwidth);
1615
                                int h2 = static_cast<int>(c->BoundingH + c->Pwidth);
456 fschmid 1616
                                if (!QRect(x, y, w, h1).intersects(QRect(x2, y2, w2, h2)))
1617
                                        continue;
501 fschmid 1618
                                if (c->ChangedMasterItem)
1619
                                        continue;
456 fschmid 1620
                                if ((a->PageNam != "") && (c->OwnPage != static_cast<int>(a->PageNr)) && (c->OwnPage != -1))
1621
                                        continue;
1622
                                if (c->isPrintable)
1623
                                {
1624
                                        PS_save();
1625
                                        if (c->Pcolor != "None")
1626
                                        {
1627
                                                SetFarbe(Doc, c->Pcolor, c->Shade, &h, &s, &v, &k, gcr);
1628
                                                PS_setcmykcolor_fill(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1629
                                        }
1630
                                        if (c->Pcolor2 != "None")
1631
                                        {
1632
                                                SetFarbe(Doc, c->Pcolor2, c->Shade2, &h, &s, &v, &k, gcr);
1633
                                                PS_setcmykcolor_stroke(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1634
                                        }
1635
                                        PS_setlinewidth(c->Pwidth);
1636
                                        PS_setcapjoin(c->PLineEnd, c->PLineJoin);
1637
                                        PS_setdash(c->PLineArt, c->DashOffset, c->DashValues);
1638
                                        PS_translate(c->Xpos - a->Xoffset, Doc->PageH - (c->Ypos - a->Yoffset));
1639
                                        if (c->Rot != 0)
1640
                                                PS_rotate(-c->Rot);
1641
                                        switch (c->PType)
1642
                                        {
1643
                                        case 2:
1644
                                                if ((c->Pcolor != "None") || (c->GrType != 0))
1645
                                                {
1646
                                                        SetClipPath(&c->PoLine);
1647
                                                        PS_closepath();
1648
                                                        if ((c->GrType != 0) && (a->PageNam == ""))
1649
                                                                HandleGradient(Doc, c, c->Width, c->Height, gcr);
1650
                                                        else
1651
                                                                PS_fill();
1652
                                                        PS_newpath();
1653
                                                }
1654
                                                PS_save();
1655
                                                SetClipPath(&c->PoLine);
1656
                                                PS_closepath();
1657
                                                PS_clip(true);
1658
                                                if ((c->flippedH % 2) != 0)
1659
                                                {
1660
                                                        PS_translate(c->Width, 0);
1661
                                                        PS_scale(-1, 1);
1662
                                                }
1663
                                                if ((c->flippedV % 2) != 0)
1664
                                                {
1665
                                                        PS_translate(0, -c->Height);
1666
                                                        PS_scale(1, -1);
1667
                                                }
1668
                                                if ((c->PicAvail) && (c->Pfile != ""))
1669
                                                {
1670
                                                        PS_translate(0, -c->BBoxH*c->LocalScY);
1671
                                                        if (a->PageNam != "")
1672
                                                                PS_image(c->InvPict, -c->BBoxX+c->LocalX, -c->LocalY, c->Pfile, c->LocalScX, c->LocalScY, c->IProfile, c->UseEmbedded, ic, c->AnName);
1673
                                                        else
1674
                                                                PS_image(c->InvPict, -c->BBoxX+c->LocalX, -c->LocalY, c->Pfile, c->LocalScX, c->LocalScY, c->IProfile, c->UseEmbedded, ic);
1675
                                                }
1676
                                                PS_restore();
1677
                                                if (((c->Pcolor2 != "None") || (c->NamedLStyle != "")) && (!c->isTableItem))
1678
                                                {
1679
                                                        if ((c->NamedLStyle == "") && (c->Pwidth != 0.0))
1680
                                                        {
1681
                                                                SetFarbe(Doc, c->Pcolor2, c->Shade2, &h, &s, &v, &k, gcr);
1682
                                                                PS_setcmykcolor_stroke(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1683
                                                                PS_setlinewidth(c->Pwidth);
1684
                                                                PS_setcapjoin(c->PLineEnd, c->PLineJoin);
1685
                                                                PS_setdash(c->PLineArt, c->DashOffset, c->DashValues);
1686
                                                                SetClipPath(&c->PoLine);
1687
                                                                PS_closepath();
1688
                                                                PS_stroke();
1689
                                                        }
1690
                                                        else
1691
                                                        {
1692
                                                                multiLine ml = Doc->MLineStyles[c->NamedLStyle];
1693
                                                                for (int it = ml.size()-1; it > -1; it--)
1694
                                                                {
1695
                                                                        SetFarbe(Doc, ml[it].Color, ml[it].Shade, &h, &s, &v, &k, gcr);
1696
                                                                        PS_setcmykcolor_stroke(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1697
                                                                        PS_setlinewidth(ml[it].Width);
1698
                                                                        PS_setcapjoin(static_cast<Qt::PenCapStyle>(ml[it].LineEnd), static_cast<Qt::PenJoinStyle>(ml[it].LineJoin));
1699
                                                                        PS_setdash(static_cast<Qt::PenStyle>(ml[it].Dash), 0, dum);
1700
                                                                        SetClipPath(&c->PoLine);
1701
                                                                        PS_closepath();
1702
                                                                        PS_stroke();
1703
                                                                }
1704
                                                        }
1705
                                                }
1706
                                                break;
1707
                                        case 4:
1708
                                                if (c->isBookmark)
1709
                                                {
1710
                                                        QString bm = "";
1711
                                                        QString cc;
1712
                                                        for (d = 0; d < c->Ptext.count(); ++d)
1713
                                                        {
1714
                                                                if ((c->Ptext.at(d)->ch == QChar(13)) || (c->Ptext.at(d)->ch == QChar(10)) || (c->Ptext.at(d)->ch == QChar(28)))
1715
                                                                        break;
1716
                                                                bm += "\\"+cc.setNum(QMAX(c->Ptext.at(d)->ch.at(0).unicode(), 32), 8);
1717
                                                        }
1718
                                                        PDF_Bookmark(bm, a->PageNr+1);
1719
                                                }
1720
                                                if (c->isAnnotation)
1721
                                                {
1722
                                                        QString bm = "";
1723
                                                        QString cc;
1724
                                                        for (d = 0; d < c->Ptext.count(); ++d)
1725
                                                        {
1726
                                                                bm += "\\"+cc.setNum(QMAX(c->Ptext.at(d)->ch.at(0).unicode(), 32), 8);
1727
                                                        }
1728
                                                        PDF_Annotation(bm, 0, 0, c->Width, -c->Height);
1729
                                                        break;
1730
                                                }
1731
                                                if ((c->Pcolor != "None") || (c->GrType != 0))
1732
                                                {
1733
                                                        SetClipPath(&c->PoLine);
1734
                                                        PS_closepath();
1735
                                                        if ((c->GrType != 0) && (a->PageNam == ""))
1736
                                                                HandleGradient(Doc, c, c->Width, c->Height, gcr);
1737
                                                        else
1738
                                                                PS_fill();
1739
                                                }
1740
                                                if ((c->flippedH % 2) != 0)
1741
                                                {
1742
                                                        PS_translate(c->Width, 0);
1743
                                                        PS_scale(-1, 1);
1744
                                                }
1745
                                                if ((c->flippedV % 2) != 0)
1746
                                                {
1747
                                                        PS_translate(0, -c->Height);
1748
                                                        PS_scale(1, -1);
1749
                                                }
1750
                                                for (d = 0; d < c->MaxChars; ++d)
1751
                                                {
1752
                                                        hl = c->Ptext.at(d);
1753
                                                        if ((hl->ch == QChar(13)) || (hl->ch == QChar(10)) || (hl->ch == QChar(9)) || (hl->ch == QChar(28)))
1754
                                                                continue;
1755
                                                        if (hl->cstyle & 256)
1756
                                                                continue;
1757
                                                        if (hl->yp == 0)
1758
                                                                continue;
1759
                                                        tsz = hl->csize;
1760
                                                        chx = hl->ch;
1761
                                                        if (hl->ch == QChar(29))
1762
                                                                chx = " ";
1763
                                                        if (hl->ch == QChar(30))
1764
                                                        {
1765
                                                                if (Doc->MasterP)
1766
                                                                        chx = "#";
1767
                                                                else
1768
                                                                {
1769
                                                                        uint zae = 0;
1770
                                                                        uint za2 = d;
1771
                                                                        do
1772
                                                                        {
1773
                                                                                if (za2 == 0)
1774
                                                                                        break;
1775
                                                                                za2--;
1776
                                                                        }
1777
                                                                        while (c->Ptext.at(za2)->ch == QChar(30));
1778
                                                                        if (c->Ptext.at(za2)->ch != QChar(30))
1779
                                                                                za2++;
1780
                                                                        while (c->Ptext.at(za2+zae)->ch == QChar(30))
1781
                                                                        {
1782
                                                                                zae++;
1783
                                                                                if (za2+zae == c->MaxChars)
1784
                                                                                        break;
1785
                                                                        }
1786
                                                                        QString out="%1";
1787
                                                                        QString out2;
1788
                                                                        out2 = out.arg(PNr-1+Doc->FirstPnum, -zae);
1789
                                                                        chx = out2.mid(d-za2, 1);
1790
                                                                }
1791
                                                        }
1792
                                                        if (hl->cstyle & 64)
1793
                                                        {
1794
                                                                if (chx.upper() != chx)
1795
                                                                {
823 fschmid 1796
                                                                        tsz = hl->csize * Doc->typographicSetttings.valueSmallCaps / 100;
456 fschmid 1797
                                                                        chx = chx.upper();
1798
                                                                }
1799
                                                        }
1800
                                                        if (hl->cstyle & 1)
823 fschmid 1801
                                                                tsz = hl->csize * Doc->typographicSetttings.scalingSuperScript / 100;
456 fschmid 1802
                                                        if (hl->cstyle & 2)
823 fschmid 1803
                                                                tsz = hl->csize * Doc->typographicSetttings.scalingSuperScript / 100;
456 fschmid 1804
                                                        /* Subset all TTF Fonts until the bug in the TTF-Embedding Code is fixed */
1805
                                                        QFileInfo fd = QFileInfo((*Doc->AllFonts)[hl->cfont]->Datei);
1806
                                                        QString fext = fd.extension(false).lower();
1807
                                                        if ((fext == "ttf") || ((*Doc->AllFonts)[hl->cfont]->isOTF) || ((*Doc->AllFonts)[hl->cfont]->Subset))
1808
                                                        {
1809
                                                                uint chr = chx[0].unicode();
1810
                                                                if (((*Doc->AllFonts)[hl->cfont]->CharWidth.contains(chr)) && (chr != 32))
1811
                                                                {
1812
                                                                        PS_save();
1813
                                                                        if (c->Reverse)
1814
                                                                        {
1815
                                                                                PS_translate(hl->xp, (hl->yp - (tsz / 10.0)) * -1);
1816
                                                                                PS_scale(-1, 1);
1817
                                                                                if (d < c->MaxChars-1)
1818
                                                                                {
1819
                                                                                        QString ctx = c->Ptext.at(d+1)->ch;
1820
                                                                                        if (ctx == QChar(29))
1821
                                                                                                ctx = " ";
1822
                                                                                        wideR = -Cwidth(Doc, hl->cfont, chx, tsz, ctx) * (hl->cscale / 100.0);
1823
                                                                                }
1824
                                                                                else
1825
                                                                                        wideR = -Cwidth(Doc, hl->cfont, chx, tsz) * (hl->cscale / 100.0);
1826
                                                                                PS_translate(wideR, 0);
1827
                                                                        }
1828
                                                                        else
1829
                                                                                PS_translate(hl->xp, (hl->yp - (tsz / 10.0)) * -1);
1830
                                                                        if (hl->cscale != 100)
1831
                            &