Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
3 paul 1
/***************************************************************************
2
                          scribusview.cpp  -  description
3
                             -------------------
4
    begin                : Fre Apr  6 21:47:55 CEST 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
 
18
#include "scribusview.h"
19
#include "scribusview.moc"
128 Franz 20
 
21
#if (_MSC_VER >= 1200)
22
 #include "win-config.h"
23
#else
24
 #include "config.h"
25
#endif
26
 
3 paul 27
#include "pageback.h"
28
#include <qcolor.h>
29
#include <qfont.h>
30
#include <qfontmetrics.h>
31
#include <qpixmap.h>
32
#include <qpointarray.h>
33
#include <qstringlist.h>
34
#include <qimage.h>
35
#include <qcstring.h>
68 Franz 36
 
3 paul 37
extern void Level2Layer(ScribusDoc *doc, struct Layer *ll, int Level);
80 Franz 38
extern double Cwidth(ScribusDoc *doc, QString name, QString ch, int Siz, QString ch2 = " ");
3 paul 39
 
40
ScribusView::ScribusView(QWidget *parent, ScribusDoc *doc, preV *prefs)
41
                                                : QScrollView(parent, "s", WRepaintNoErase | WNorthWestGravity)
42
{
43
        Ready = false;
44
        Doc = doc;
45
        Doc->PageC = 0;
46
  Prefs = prefs;
47
        setHScrollBarMode(QScrollView::AlwaysOn);
48
        setVScrollBarMode(QScrollView::AlwaysOn);
49
        setMargins(25, 25, 0, 0);
50
        setResizePolicy(Manual);
51
        enableClipper(true);
52
  viewport()->setBackgroundMode(PaletteBackground);
53
        QFont fo = QFont(font());
54
        fo.setPointSize(10);
68 Franz 55
  LE = new MSpinBox( this, 2 );
3 paul 56
        LE->setFont(fo);
68 Franz 57
  LE->setSuffix( tr( " %" ) );
146 Franz 58
        LE->setMaxValue( 3200 );
59
        LE->setMinValue( 10 );
60
        LE->setValue( 100 );
3 paul 61
        LE->setFocusPolicy(QWidget::ClickFocus);
62
        SB1 = new QPushButton(this);
63
        SB1->setPixmap(loadIcon("Klein.xpm"));
64
        SB1->setFocusPolicy(QWidget::NoFocus);
65
        SB2 = new QPushButton(this);
66
        SB2->setFocusPolicy(QWidget::NoFocus);
67
        SB2->setPixmap(loadIcon("Gross.xpm"));
160 Franz 68
        PGS = new QSpinBox(this);
69
        PGS->setMinValue(1);
70
        PGS->setMaxValue(1);
71
        PGS->setPrefix( tr("Page ") );
72
        PGS->setFont(fo);
73
        PGS->setFocusPolicy(QWidget::NoFocus);
3 paul 74
        LY = new QPushButton(this);
75
        LY->setFont(fo);
76
        Laymen = new QPopupMenu(this);
77
        Laymen->setFont(fo);
112 Franz 78
        LY->setText( tr("Layer")+" 0");
3 paul 79
        LY->setPopup(Laymen);
80
        LY->setFocusPolicy(QWidget::NoFocus);
81
        HR = new Hruler(this, Doc);
82
        VR = new Vruler(this, Doc);
83
        UN = new QToolButton(this);
84
        Unitmen = new QPopupMenu(this);
85
        Unitmen->insertItem("pt");
86
        Unitmen->insertItem("mm");
87
        Unitmen->insertItem("in");
88
        Unitmen->insertItem("p");
89
        UN->setPopup(Unitmen);
90
        UN->setFocusPolicy(QWidget::NoFocus);
91
        UN->setPopupDelay(10);
92
        switch (doc->Einheit)
93
                {
94
                case 0:
95
                        UN->setText("pt");
96
                        break;
97
                case 1:
98
                        UN->setText("mm");
99
                        break;
100
                case 2:
101
                        UN->setText("in");
102
                        break;
103
                case 3:
104
                        UN->setText("p");
105
                        break;
106
                }
107
        Pages.clear();
108
        MasterPages.clear();
109
        DocPages.clear();
110
        Ready = true;
111
        connect(SB1, SIGNAL(clicked()), this, SLOT(slotZoomOut()));
112
        connect(SB2, SIGNAL(clicked()), this, SLOT(slotZoomIn()));
68 Franz 113
        connect(LE, SIGNAL(valueChanged(int)), this, SLOT(Zval()));
160 Franz 114
        connect(PGS, SIGNAL(valueChanged(int)), this, SLOT(GotoPa(int)));
3 paul 115
        connect(Laymen, SIGNAL(activated(int)), this, SLOT(GotoLa(int)));
116
        connect(Unitmen, SIGNAL(activated(int)), this, SLOT(ChgUnit(int)));
117
        connect(this, SIGNAL(contentsMoving(int, int)), this, SLOT(setRulerPos(int, int)));
118
}
119
 
120
/** Waagrechter Scrollbalken */
121
void ScribusView::setHBarGeometry(QScrollBar &bar, int x, int y, int w, int h)
122
{
123
        bar.setGeometry(x+270, y, w-270, h);
124
        if (Ready)
125
                {
77 Franz 126
                QFontMetrics fom(LE->font());
3 paul 127
                LE->setGeometry(x, y, 60, h);
77 Franz 128
                if (fom.height() > LE->ed->height())
129
                        {
78 Franz 130
                        QFont ff = LE->font();
77 Franz 131
                        do
132
                                {
133
                                int si = LE->font().pointSize();
134
                                ff.setPointSize(si-1);
135
                                LE->setFont(ff);
136
                                fom = QFontMetrics(LE->font());
137
                                }
138
                        while (fom.height() > LE->ed->height());
160 Franz 139
                        PGS->setFont(ff);
78 Franz 140
                        LY->setFont(ff);
83 Franz 141
                        HR->setFont(ff);
142
                        VR->setFont(ff);
77 Franz 143
                        }
144
                QRect forec = fom.boundingRect("3200.00 %");
145
                int sadj = forec.width() - LE->ed->width();
146
                LE->setGeometry(x, y, 60+sadj, h);
147
                SB1->setGeometry(x+60+sadj, y, 15, h);
148
                SB2->setGeometry(x+75+sadj, y, 15, h);
160 Franz 149
                PGS->setGeometry(x+90+sadj, y, 70, h);
77 Franz 150
                LY->setGeometry(x+160+sadj, y, 110, h);
3 paul 151
                HR->setGeometry(25, 1, w-24, 25);
152
                }
153
}
154
 
155
/** Senkrechter Scrollbalken */
156
void ScribusView::setVBarGeometry(QScrollBar &bar, int x, int y, int w, int h)
157
{
158
        bar.setGeometry(x, y, w, h);
159
        if (Ready)
160
                {
161
                VR->setGeometry(1, 25, 25, h-24);
162
                UN->setGeometry(1, 1, 25, 25);
163
                }
164
}
165
 
166
void ScribusView::setRulerPos(int x, int y)
167
{
168
        HR->offs = x-static_cast<int>(10*Doc->Scale)-2;
169
        HR->repX = false;
170
        HR->repaint();
171
        VR->offs = y-static_cast<int>(10*Doc->Scale)-2;
172
        VR->repaint();
173
}
174
 
175
void ScribusView::Zval()
176
{
146 Franz 177
        Doc->Scale = LE->value() / 100.0 * Prefs->DisScale;
68 Franz 178
        slotDoZoom();
3 paul 179
        setFocus();
180
}
181
 
182
/** Fügt eine Seite hinzu */
183
Page* ScribusView::addPage(int nr)
184
{
185
        int z;
80 Franz 186
        double s = Doc->Scale;
3 paul 187
        QWidget* feh = new PageBack(viewport());
188
        feh->resize(static_cast<int>((Doc->PageB+5)*s), static_cast<int>((Doc->PageH+5)*s));
189
        Page* fe = new Page(feh, 0, 0, static_cast<int>(Doc->PageB*s), static_cast<int>(Doc->PageH*s), Doc, this);
190
        Doc->ActPage = fe;
191
        fe->Margins.Top = Doc->PageM.Top;
192
        fe->Margins.Bottom = Doc->PageM.Bottom;
193
        addChild(feh, static_cast<int>(10*s), static_cast<int>(Doc->PageC*((Doc->PageH+30)*s)+10*s));
194
        feh->show();
195
        Doc->PageC++;
196
        Pages.insert(nr, fe);
197
        reformPages();
198
        if ((Doc->PageAT) && (!Doc->loading))
199
                {
135 Franz 200
                z = fe->PaintText(fe->Margins.Left,
3 paul 201
                                                                                fe->Margins.Top,
202
                                                                                Doc->PageB-fe->Margins.Right-fe->Margins.Left,
203
                                                                                Doc->PageH-fe->Margins.Bottom-fe->Margins.Top,
204
                                                                                1, Doc->Dpen);
135 Franz 205
                fe->Items.at(z)->isAutoText = true;
206
                fe->Items.at(z)->BackBox = Doc->LastAuto;
137 Franz 207
                fe->Items.at(z)->Cols = qRound(Doc->PageSp);
135 Franz 208
                fe->Items.at(z)->ColGap = Doc->PageSpa;
209
                if (Doc->LastAuto != 0)
210
                        Doc->LastAuto->NextBox = fe->Items.at(z);
211
                else
212
                        Doc->FirstAuto = fe->Items.at(z);
213
                Doc->LastAuto = fe->Items.at(z);
214
                fe->SetRectFrame(fe->Items.at(z));
3 paul 215
                Doc->FirstAuto->Dirty = true;
216
                }
160 Franz 217
        disconnect(PGS, SIGNAL(valueChanged(int)), this, SLOT(GotoPa(int)));
218
        PGS->setMaxValue(Doc->PageC);
219
        PGS->setValue(nr+1);
220
        connect(PGS, SIGNAL(valueChanged(int)), this, SLOT(GotoPa(int)));
3 paul 221
        fe->setMouseTracking(true);
222
        connect(fe, SIGNAL(Hrule(int)), HR, SLOT(Draw(int)));
223
        connect(fe, SIGNAL(Vrule(int)), VR, SLOT(Draw(int)));
224
        connect(fe, SIGNAL(PgCh(int)), this, SLOT(setMenTxt(int)));
225
        connect(fe, SIGNAL(ZoomIn()), this, SLOT(slotZoomIn2()));
226
        connect(fe, SIGNAL(ZoomOut()), this, SLOT(slotZoomOut2()));
227
        connect(fe, SIGNAL(ZoomAbs()), this, SLOT(slotDoZoom()));
228
        connect(fe, SIGNAL(AbsPosi(int, int)), this, SLOT(SetCPo(int, int)));
229
        connect(fe, SIGNAL(AbsPosi2(int, int)), this, SLOT(SetCCPo(int, int)));
80 Franz 230
        return fe;
3 paul 231
}
232
 
233
/** Löscht eine Seite */
234
void ScribusView::delPage(int Nr)
235
{
236
        if (Doc->PageC == 1)
237
                { return; }
238
        if (Doc->PageC < Nr-1)
239
                { return; }
240
        removeChild(Pages.at(Nr)->parentWidget());
241
        delete Pages.at(Nr)->parentWidget();
242
        Pages.remove(Nr);
108 Franz 243
        Doc->UnDoValid = false;
3 paul 244
        Doc->PageC -= 1;
245
        Doc->ActPage = Pages.at(0);
160 Franz 246
        disconnect(PGS, SIGNAL(valueChanged(int)), this, SLOT(GotoPa(int)));
247
        PGS->setMaxValue(Doc->PageC);
248
        PGS->setValue(1);
249
        connect(PGS, SIGNAL(valueChanged(int)), this, SLOT(GotoPa(int)));
3 paul 250
}
251
 
252
void ScribusView::movePage(int from, int to, int ziel, int art)
253
{
254
        QPtrList<Page> Buf;
255
        int a;
256
        uint b;
257
        int zz = ziel;
258
        Buf.clear();
259
        for (a = from; a < to; a++)
260
                {
261
                Buf.append(Pages.at(from));
262
                Pages.remove(from);
263
                if (a <= zz)
80 Franz 264
                        zz--;
3 paul 265
                }
266
        switch (art)
267
                {
268
                case 0:
269
                        for (b = 0; b < Buf.count(); b++)
270
                                {
271
                                Pages.insert(zz, Buf.at(b));
272
                                zz++;
273
                                }
274
                        break;
275
                case 1:
276
                        for (b = 0; b < Buf.count(); b++)
277
                                {
278
                                zz++;
279
                                Pages.insert(zz, Buf.at(b));
280
                                }
281
                        break;
282
                case 2:
283
                        for (b = 0; b < Buf.count(); b++)
284
                                {
285
                                Pages.append(Buf.at(b));
286
                                }
287
                        break;
288
                }
289
        reformPages();
290
}
291
 
292
void ScribusView::reformPages()
80 Franz 293
{
3 paul 294
        uint a;
295
        Page* Seite;
296
        QWidget* PSeite = Doc->ActPage->parentWidget();
297
        for (a=0; a < Pages.count(); a++)
298
                {
299
                Seite = Pages.at(a);
300
                Seite->PageNr = a;
301
                PSeite = Seite->parentWidget();
302
                if (Doc->PageFP)
303
                        {
304
                        if (Doc->MasterP)
305
                                {
306
                                if (Seite->LeftPg)
307
                                        {
308
                                        Seite->Margins.Left = Doc->PageM.Right;
309
                                        Seite->Margins.Right = Doc->PageM.Left;
310
                                        }
311
                                else
312
                                        {
313
                                        Seite->Margins.Right = Doc->PageM.Right;
314
                                        Seite->Margins.Left = Doc->PageM.Left;
315
                                        }
316
                                }
317
                        else
80 Franz 318
                                {
3 paul 319
                                if (a % 2 == 0)
320
                                        {
321
                                        if (Doc->FirstPageLeft)
322
                                                {
323
                                                Seite->Margins.Left = Doc->PageM.Right;
324
                                                Seite->Margins.Right = Doc->PageM.Left;
325
                                                }
326
                                        else
327
                                                {
328
                                                Seite->Margins.Right = Doc->PageM.Right;
329
                                                Seite->Margins.Left = Doc->PageM.Left;
330
                                                }
331
                                        }
332
                                else
333
                                        {
334
                                        if (Doc->FirstPageLeft)
335
                                                {
336
                                                Seite->Margins.Right = Doc->PageM.Right;
337
                                                Seite->Margins.Left = Doc->PageM.Left;
338
                                                }
339
                                        else
340
                                                {
341
                                                Seite->Margins.Left = Doc->PageM.Right;
342
                                                Seite->Margins.Right = Doc->PageM.Left;
343
                                                }
344
                                        }
345
                                }
346
                        }
347
                else
348
                        {
349
                        Seite->Margins.Right = Doc->PageM.Right;
350
                        Seite->Margins.Left = Doc->PageM.Left;
351
                        }
352
                Seite->Margins.Top = Doc->PageM.Top;
353
                Seite->Margins.Bottom = Doc->PageM.Bottom;
354
                if (Doc->MasterP)
355
                        addChild(PSeite, static_cast<int>(10*Doc->Scale), static_cast<int>((Doc->PageC-1)*(PSeite->height()+25*Doc->Scale)+10*Doc->Scale));
356
                else
357
                        {
45 Franz 358
                        if ((Doc->PageFP) && (Doc->PagesSbS))
3 paul 359
                                {
360
                                if (a % 2 == 0)
361
                                        {
362
                                        if (Doc->FirstPageLeft)
363
                                                addChild(PSeite, static_cast<int>(10*Doc->Scale),
364
                                                        static_cast<int>(a/2 * (PSeite->height()+25*Doc->Scale)+10*Doc->Scale));
365
                                        else
366
                                                addChild(PSeite, static_cast<int>(PSeite->width()+35*Doc->Scale),
367
                                                        static_cast<int>((a+1)/2 * (PSeite->height()+25*Doc->Scale)+10*Doc->Scale));
368
                                        }
369
                                else
370
                                        {
371
                                        if (Doc->FirstPageLeft)
372
                                                addChild(PSeite, static_cast<int>(PSeite->width()+35*Doc->Scale),
373
                                                                                static_cast<int>(a/2 * (PSeite->height()+25*Doc->Scale)+10*Doc->Scale));
374
                                        else
375
                                                addChild(PSeite, static_cast<int>(10*Doc->Scale),
376
                                                                                static_cast<int>((a+1)/2 * (PSeite->height()+25*Doc->Scale)+10*Doc->Scale));
377
                                        }
378
                                }
379
                        else
380
                                addChild(PSeite, static_cast<int>(10*Doc->Scale), static_cast<int>(a*(PSeite->height()+25*Doc->Scale)+10*Doc->Scale));
381
                        }
382
                }
383
        PSeite = Doc->ActPage->parentWidget();
45 Franz 384
        if ((Doc->PageFP) && (Doc->PagesSbS))
3 paul 385
                {
386
                if (Doc->FirstPageLeft)
387
                        resizeContents(static_cast<int>(PSeite->width()*2+60*Doc->Scale),
388
                                                                                static_cast<int>(((Doc->PageC-1)/2 + 1) * (PSeite->height()+25*Doc->Scale)+30));
389
                else
390
                        resizeContents(static_cast<int>(PSeite->width()*2+60*Doc->Scale),
391
                                                                                 static_cast<int>((Doc->PageC/2 + 1) * (PSeite->height()+25*Doc->Scale)+30));
392
                setContentsPos(childX(Doc->ActPage->parentWidget())-static_cast<int>(10*Doc->Scale),
393
                                                                         childY(Doc->ActPage->parentWidget())-static_cast<int>(10*Doc->Scale));
394
                }
395
        else
396
                {
397
                resizeContents(static_cast<int>(PSeite->width()+30*Doc->Scale), static_cast<int>(Doc->PageC * (PSeite->height()+25*Doc->Scale)+30));
398
                setContentsPos(0, childY(Doc->ActPage->parentWidget())-static_cast<int>(10*Doc->Scale));
399
                }
400
        setRulerPos(contentsX(), contentsY());
401
        setMenTxt(Doc->ActPage->PageNr);
80 Franz 402
}
3 paul 403
 
404
void ScribusView::setMenTxt(int Seite)
405
{
160 Franz 406
        disconnect(PGS, SIGNAL(valueChanged(int)), this, SLOT(GotoPa(int)));
407
        PGS->setMaxValue(Doc->PageC);
408
        PGS->setValue(Seite+1);
409
        connect(PGS, SIGNAL(valueChanged(int)), this, SLOT(GotoPa(int)));
3 paul 410
}
411
 
412
void ScribusView::setLayMenTxt(int l)
413
{
153 Franz 414
        QValueList<Layer>::iterator it;
415
        for (it = Doc->Layers.begin(); it != Doc->Layers.end(); ++it)
416
                {
417
                if ((*it).LNr == l)
418
                        break;
419
                }
420
                LY->setText((*it).Name);
3 paul 421
}
422
 
11 Franz 423
/** Fuehrt die Vergroesserung/Verkleinerung aus */
3 paul 424
void ScribusView::slotDoZoom()
80 Franz 425
{
3 paul 426
        uint a;
427
        Page* Seite;
428
        QWidget* PSeite = Doc->ActPage->parentWidget();
429
        if (Doc->Scale > 32)
430
                Doc->Scale = 32;
431
        if (Pages.count() != 0)
432
                {
433
                for (a=0; a < Pages.count(); a++)
434
                        {
435
                        Seite = Pages.at(a);
436
                        PSeite = Seite->parentWidget();
437
                        Seite->resize(static_cast<int>(Doc->PageB*Doc->Scale), static_cast<int>(Doc->PageH*Doc->Scale));
438
                        PSeite->resize(static_cast<int>((Doc->PageB+5)*Doc->Scale), static_cast<int>((Doc->PageH+5)*Doc->Scale));
439
                        if (Doc->MasterP)
440
                                addChild(PSeite, static_cast<int>(10*Doc->Scale), static_cast<int>((Doc->PageC-1)*(PSeite->height()+25*Doc->Scale)+10*Doc->Scale));
441
                        else
442
                                {
45 Franz 443
                                if ((Doc->PageFP) && (Doc->PagesSbS))
3 paul 444
                                        {
445
                                        if (a % 2 == 0)
446
                                                {
447
                                                if (Doc->FirstPageLeft)
448
                                                        addChild(PSeite, static_cast<int>(10*Doc->Scale),
449
                                                                static_cast<int>(a/2 * (PSeite->height()+25*Doc->Scale)+10*Doc->Scale));
450
                                                else
451
                                                        addChild(PSeite, static_cast<int>(PSeite->width()+35*Doc->Scale),
452
                                                                static_cast<int>((a+1)/2 * (PSeite->height()+25*Doc->Scale)+10*Doc->Scale));
453
                                                }
454
                                        else
455
                                                {
456
                                                if (Doc->FirstPageLeft)
457
                                                        addChild(PSeite, static_cast<int>(PSeite->width()+35*Doc->Scale),
458
                                                                                        static_cast<int>(a/2 * (PSeite->height()+25*Doc->Scale)+10*Doc->Scale));
459
                                                else
460
                                                        addChild(PSeite, static_cast<int>(10*Doc->Scale),
461
                                                                                        static_cast<int>((a+1)/2 * (PSeite->height()+25*Doc->Scale)+10*Doc->Scale));
462
                                                }
463
                                        }
464
                                else
465
                                        addChild(PSeite, static_cast<int>(10*Doc->Scale), static_cast<int>(a*(PSeite->height()+25*Doc->Scale)+10*Doc->Scale));
466
                                }
467
                        }
45 Franz 468
                if ((Doc->PageFP) && (Doc->PagesSbS))
3 paul 469
                        {
470
                        if (Doc->FirstPageLeft)
471
                                        resizeContents(static_cast<int>(PSeite->width()*2+60*Doc->Scale),
472
                                                                                                static_cast<int>(((Doc->PageC-1)/2 + 1) * (PSeite->height()+25*Doc->Scale)+30));
473
                        else
474
                                resizeContents(static_cast<int>(PSeite->width()*2+60*Doc->Scale),
475
                                                                                        static_cast<int>((Doc->PageC/2 + 1) * (PSeite->height()+25*Doc->Scale)+30));
476
                        setContentsPos(childX(Doc->ActPage->parentWidget())-static_cast<int>(10*Doc->Scale),
477
                                                                                childY(Doc->ActPage->parentWidget())-static_cast<int>(10*Doc->Scale));
478
                        }
479
                else
480
                        {
481
                        resizeContents(static_cast<int>(PSeite->width()+30*Doc->Scale), static_cast<int>(Doc->PageC * (PSeite->height()+25*Doc->Scale)+30));
482
                        setContentsPos(0, childY(Doc->ActPage->parentWidget())-static_cast<int>(10*Doc->Scale));
483
                        }
68 Franz 484
                disconnect(LE, SIGNAL(valueChanged(int)), this, SLOT(Zval()));
146 Franz 485
                LE->setValue(Doc->Scale/Prefs->DisScale*100);
68 Franz 486
                connect(LE, SIGNAL(valueChanged(int)), this, SLOT(Zval()));
3 paul 487
                setRulerPos(contentsX(), contentsY());
488
                if (Doc->ActPage->SelItem.count() != 0)
489
                        {
490
                        PageItem *b = Doc->ActPage->SelItem.at(0);
491
                        SetCCPo(static_cast<int>(b->Xpos + b->Width/2), static_cast<int>(b->Ypos + b->Height/2));
492
                        }
493
                }
494
}
495
 
496
void ScribusView::SetCCPo(int x, int y)
497
{
498
        center(static_cast<int>(childX(Doc->ActPage->parentWidget())+x*Doc->Scale), static_cast<int>(childY(Doc->ActPage->parentWidget())+y*Doc->Scale));
80 Franz 499
        setRulerPos(contentsX(), contentsY());
3 paul 500
}
501
 
502
void ScribusView::SetCPo(int x, int y)
503
{
504
        setContentsPos(static_cast<int>(childX(Doc->ActPage->parentWidget())+x*Doc->Scale), static_cast<int>(childY(Doc->ActPage->parentWidget())+y*Doc->Scale));
80 Franz 505
        setRulerPos(contentsX(), contentsY());
3 paul 506
}
507
 
508
void ScribusView::LaMenu()
509
{
510
        uint a;
511
        Laymen->clear();
512
        if (Doc->Layers.count() != 0)
513
                {
514
                for (a=0; a < Doc->Layers.count(); a++)
515
                        {
516
                        Laymen->insertItem(Doc->Layers[a].Name);
517
                        }
518
                }
519
}
520
 
521
void ScribusView::GotoLa(int l)
522
{
523
        int d = Laymen->indexOf(l);
524
        Doc->ActiveLayer = d;
525
        LY->setText(Doc->Layers[d].Name);
526
        emit changeLA(d);
527
}
528
 
529
void ScribusView::GotoPa(int Seite)
530
{
160 Franz 531
        GotoPage(Seite-1);
3 paul 532
}
533
 
534
void ScribusView::ChgUnit(int art)
535
{
536
        int d = Unitmen->indexOf(art);
537
        emit changeUN(d);
538
}
539
 
540
void ScribusView::GotoPage(int Seite)
541
{
542
        Doc->ActPage = Pages.at(Seite);
543
        setContentsPos(static_cast<int>(childX(Doc->ActPage->parentWidget())-10*Doc->Scale), static_cast<int>(childY(Doc->ActPage->parentWidget())-10*Doc->Scale));
160 Franz 544
        disconnect(PGS, SIGNAL(valueChanged(int)), this, SLOT(GotoPa(int)));
545
        PGS->setMaxValue(Doc->PageC);
546
        PGS->setValue(Seite+1);
547
        connect(PGS, SIGNAL(valueChanged(int)), this, SLOT(GotoPa(int)));
3 paul 548
}
549
 
550
/** Vergrößert die Ansicht */
551
void ScribusView::slotZoomIn()
552
{
553
        Doc->Scale *= 2;
554
        if (Doc->Scale > 32)
555
                Doc->Scale = 32;
556
        slotDoZoom();
557
}
558
 
559
/** Verkleinert die Ansicht */
560
void ScribusView::slotZoomOut()
561
{
562
        Doc->Scale /= 2;
563
        slotDoZoom();
564
}
565
 
566
/** Vergrößert die Ansicht */
567
void ScribusView::slotZoomIn2()
568
{
80 Franz 569
        Doc->Scale += static_cast<double>(Doc->MagStep)/100;
570
        if (Doc->Scale > static_cast<double>(Doc->MagMax)/100)
571
                Doc->Scale = static_cast<double>(Doc->MagMax)/100;
3 paul 572
        slotDoZoom();
573
}
574
 
575
/** Verkleinert die Ansicht */
576
void ScribusView::slotZoomOut2()
577
{
80 Franz 578
        Doc->Scale -= static_cast<double>(Doc->MagStep)/100;
579
        if (Doc->Scale < static_cast<double>(Doc->MagMin)/100)
580
                Doc->Scale = static_cast<double>(Doc->MagMin)/100;
3 paul 581
        slotDoZoom();
582
}
583
 
584
void ScribusView::DrawNew()
80 Franz 585
{
3 paul 586
        uint a;
587
        Page *b = Doc->ActPage;
588
        if (Pages.count() != 0)
589
                {
590
                for (a=0; a < Pages.count(); a++)
591
                        {
592
                        Doc->ActPage = Pages.at(a);
593
                        Pages.at(a)->setEraseColor(Doc->papColor);
594
                        Pages.at(a)->update();
595
                        }
596
                }
597
        HR->repX = false;
598
        HR->repaint();
599
        VR->repaint();
600
        Doc->ActPage = b;
68 Franz 601
        disconnect(LE, SIGNAL(valueChanged(int)), this, SLOT(Zval()));
146 Franz 602
        LE->setValue(Doc->Scale/Prefs->DisScale*100);
68 Franz 603
        connect(LE, SIGNAL(valueChanged(int)), this, SLOT(Zval()));
3 paul 604
}
605
 
606
int ScribusView::CountElements()
607
{
608
        int cc = 0;
609
        for (uint a=0; a < Pages.count(); a++)
610
                cc += Pages.at(a)->Items.count();
611
        return cc;
612
}
613
 
108 Franz 614
void ScribusView::RecalcTextPos()
615
{
616
        Doc->RePos = true;
617
        QPixmap pgPix(10, 10);
618
        QRect rd = QRect(0,0,9,9);
619
        ScPainter *painter = new ScPainter(&pgPix, pgPix.width(), pgPix.height());
620
        for (uint az=0; az<MasterPages.count(); az++)
621
                {
622
                for (uint azz=0; azz<MasterPages.at(az)->Items.count(); ++azz)
623
                        {
624
                        PageItem *ite = MasterPages.at(az)->Items.at(azz);
625
                        if (ite->PType == 4)
626
                                ite->DrawObj(painter, rd);
627
                        }
628
                }
629
        for (uint az=0; az<Pages.count(); az++)
630
                {
631
                for (uint azz=0; azz<Pages.at(az)->Items.count(); ++azz)
632
                        {
633
                        PageItem *ite = Pages.at(az)->Items.at(azz);
634
                        if (ite->PType == 4)
635
                                ite->DrawObj(painter, rd);
636
                        }
637
                }
638
        delete painter;
639
        Doc->RePos = false;
640
}
641
 
3 paul 642
void ScribusView::RecalcPictures(ProfilesL *Pr, QProgressBar *dia)
80 Franz 643
{
3 paul 644
        uint a, i;
645
        Page *b = Doc->ActPage;
646
        PageItem* it;
647
        int counter;
648
        if (dia != NULL)
649
                counter = dia->progress();
650
        else
651
                counter = 0;
652
        if (Pages.count() != 0)
653
                {
654
                for (a=0; a < Pages.count(); a++)
655
                        {
656
                        Doc->ActPage = Pages.at(a);
657
                        for (i=0; i < Pages.at(a)->Items.count(); i++)
658
                                {
659
                                it = Pages.at(a)->Items.at(i);
660
                                if ((it->PType == 2) && (it->PicAvail))
661
                                        {
662
                                        if (Pr->contains(it->IProfile))
663
                                                Pages.at(a)->LoadPict(it->Pfile, i);
664
                                        else
665
                                                {
666
                                                it->IProfile = Doc->CMSSettings.DefaultInputProfile;
667
                                                Pages.at(a)->LoadPict(it->Pfile, i);
668
                                                }
669
                                        it->Sizing = true;
670
                                        Pages.at(a)->AdjustPreview(it);
671
                                        it->Sizing = false;
672
                                        }
673
                                counter++;
674
                                if (dia != NULL)
675
                                        dia->setProgress(counter);
676
                                }
677
                        }
678
                }
679
        Doc->ActPage = b;
680
}
681
 
682
void ScribusView::ShowTemplate(int nr)
683
{
684
        for (uint a=0; a<Pages.count(); a++)
685
                {
686
                Pages.at(a)->parentWidget()->hide();
687
                }
688
        if (!Doc->MasterP)
689
                {
690
                DocPages = Pages;
691
                Pages = MasterPages;
692
                }
693
        Doc->PageC = 1;
694
        Doc->MasterP = true;
695
        Doc->ActPage = Pages.at(nr);
696
        Pages.at(nr)->parentWidget()->show();
160 Franz 697
//      LA->setEnabled(false);
698
        PGS->setEnabled(false);
3 paul 699
        reformPages();
700
        slotDoZoom();
701
}
702
 
703
void ScribusView::HideTemplate()
704
{
705
        for (uint a=0; a<Pages.count(); a++)
706
                {
707
                Pages.at(a)->Deselect(true);
708
                Pages.at(a)->parentWidget()->hide();
709
                }
710
        MasterPages = Pages;
711
        Doc->PageC = DocPages.count();
712
        Pages = DocPages;
713
        Doc->MasterP = false;
714
        Doc->ActPage = Pages.at(0);
715
        for (uint a=0; a<Pages.count(); a++)
716
                {
717
                Pages.at(a)->parentWidget()->show();
718
                }
160 Franz 719
//      LA->setEnabled(true);
720
        PGS->setEnabled(true);
3 paul 721
        reformPages();
722
        GotoPage(0);
723
        slotDoZoom();
724
}
725
 
726
QPixmap ScribusView::MPageToPixmap(QString name, int maxGr)
727
{
728
        QPixmap pm = QPixmap(static_cast<int>(Doc->PageB), static_cast<int>(Doc->PageH));
68 Franz 729
        ScPainter *painter = new ScPainter(&pm, pm.width(), pm.height());
80 Franz 730
        double sca = Doc->Scale;
3 paul 731
        bool frs = Doc->ShFrames;
732
        int Lnr;
733
        struct Layer ll;
734
        ll.Drucken = false;
735
        ll.LNr = 0;
736
        Doc->ShFrames = false;
737
        Doc->Scale = 1;
738
        PageItem *b;
739
        PageItem *bb;
740
        PageItem *nb;
741
        Lnr = 0;
742
        Page* Mp = MasterPages.at(MasterNames[name]);
743
        QWidget* Opa;
744
        Page* Opa2;
745
        if (Mp->Items.count() != 0)
746
                {
747
                Lnr = 0;
748
                for (uint la = 0; la < Doc->Layers.count(); la++)
749
                        {
750
                        Level2Layer(Doc, &ll, Lnr);
751
                        if (ll.Drucken)
752
                                {
753
                                for (uint a = 0; a < Mp->Items.count(); a++)
754
                                        {
755
                                        b = Mp->Items.at(a);
756
                                        if (b->LayerNr != ll.LNr)
757
                                                continue;
758
                                        Opa = b->Parent;
759
                                        Opa2 = b->OwnPage;
760
                                        b->Parent = Mp;
761
                                        b->OwnPage = Mp;
762
                                        nb = b->NextBox;
763
                                        bb = b->BackBox;
764
                                        b->NextBox = 0;
765
                                        b->BackBox = 0;
68 Franz 766
                                        b->DrawObj(painter, QRect(0, 0, static_cast<int>(Doc->PageB), static_cast<int>(Doc->PageH)));
3 paul 767
                                        b->NextBox = nb;
768
                                        b->BackBox = bb;
769
                                        b->Parent = Opa;
770
                                        b->OwnPage = Opa2;
771
                                        }
772
                                }
773
                        Lnr++;
774
                        }
775
                }
68 Franz 776
        painter->end();
3 paul 777
        Doc->ShFrames = frs;
778
        Doc->Scale = sca;
779
        QImage im2;
780
        QImage im = pm.convertToImage();
80 Franz 781
        double sx = im.width() / static_cast<double>(maxGr);
782
        double sy = im.height() / static_cast<double>(maxGr);
3 paul 783
        if (sy < sx)
784
                im2 = im.smoothScale(static_cast<int>(im.width() / sx), static_cast<int>(im.height() / sx));
785
        else
786
                im2 = im.smoothScale(static_cast<int>(im.width() / sy), static_cast<int>(im.height() / sy));
787
        pm.convertFromImage(im2);
788
        QPainter p;
789
        p.begin(&pm);
790
        p.setBrush(NoBrush);
791
        p.setPen(black);
792
        p.drawRect(0, 0, pm.width(), pm.height());
793
        p.end();
794
        im2.detach();
68 Franz 795
        delete painter;
3 paul 796
        return pm;
797
}
798
 
799
QPixmap ScribusView::PageToPixmap(int Nr, int maxGr)
800
{
801
        QPixmap pm = QPixmap(static_cast<int>(Doc->PageB), static_cast<int>(Doc->PageH));
68 Franz 802
        ScPainter *painter = new ScPainter(&pm, pm.width(), pm.height());
80 Franz 803
        double sca = Doc->Scale;
3 paul 804
        bool frs = Doc->ShFrames;
805
        int Lnr;
806
        struct Layer ll;
807
        ll.Drucken = false;
808
        ll.LNr = 0;
809
        Doc->ShFrames = false;
810
        Doc->Scale = 1;
811
        PageItem *b;
812
        PageItem *bb;
813
        PageItem *nb;
814
        Lnr = 0;
815
        if (Pages.at(Nr)->MPageNam != "")
816
                {
817
                Page* Mp = MasterPages.at(MasterNames[Pages.at(Nr)->MPageNam]);
818
                QWidget* Opa;
819
                Page* Opa2;
820
                if (Mp->Items.count() != 0)
821
                        {
822
                        Lnr = 0;
823
                        for (uint la = 0; la < Doc->Layers.count(); la++)
824
                                {
825
                                Level2Layer(Doc, &ll, Lnr);
826
                                if (ll.Drucken)
827
                                        {
828
                                        for (uint a = 0; a < Mp->Items.count(); a++)
829
                                                {
830
                                                b = Mp->Items.at(a);
831
                                                if (b->LayerNr != ll.LNr)
832
                                                        continue;
833
                                                Opa = b->Parent;
834
                                                Opa2 = b->OwnPage;
835
                                                b->Parent = Pages.at(Nr);
836
                                                b->OwnPage = Pages.at(Nr);
837
                                                nb = b->NextBox;
838
                                                bb = b->BackBox;
839
                                                b->NextBox = 0;
840
                                                b->BackBox = 0;
68 Franz 841
                                                b->DrawObj(painter, QRect(0, 0, static_cast<int>(Doc->PageB), static_cast<int>(Doc->PageH)));
3 paul 842
                                                b->NextBox = nb;
843
                                                b->BackBox = bb;
844
                                                b->Parent = Opa;
845
                                                b->OwnPage = Opa2;
846
                                                }
847
                                        }
848
                                Lnr++;
849
                                }
850
                        }
851
                }
852
        Lnr = 0;
853
        ll.Drucken = false;
854
        ll.LNr = 0;
855
        for (uint la2 = 0; la2 < Doc->Layers.count(); la2++)
856
                {
857
                Level2Layer(Doc, &ll, Lnr);
858
                if (ll.Drucken)
859
                        {
860
                        for (uint a = 0; a < Pages.at(Nr)->Items.count(); a++)
861
                                {
862
                                b = Pages.at(Nr)->Items.at(a);
863
                                if (b->LayerNr != ll.LNr)
864
                                        continue;
865
                                if (b->isPrintable)
866
                                        {
867
                                        if ((b->isAnnotation) && (b->AnType != 11))
868
                                                continue;
869
                                        nb = b->NextBox;
870
                                        bb = b->BackBox;
871
                                        b->NextBox = 0;
872
                                        b->BackBox = 0;
68 Franz 873
                                        b->DrawObj(painter, QRect(0, 0, static_cast<int>(Doc->PageB), static_cast<int>(Doc->PageH)));
3 paul 874
                                        b->NextBox = nb;
875
                                        b->BackBox = bb;
876
                                        }
877
                                }
878
                        }
879
                Lnr++;
880
                }
68 Franz 881
        painter->end();
3 paul 882
        Doc->ShFrames = frs;
883
        Doc->Scale = sca;
884
        QImage im2;
885
        QImage im = pm.convertToImage();
80 Franz 886
        double sx = im.width() / static_cast<double>(maxGr);
887
        double sy = im.height() / static_cast<double>(maxGr);
3 paul 888
        if (sy < sx)
889
                im2 = im.smoothScale(static_cast<int>(im.width() / sx), static_cast<int>(im.height() / sx));
890
        else
891
                im2 = im.smoothScale(static_cast<int>(im.width() / sy), static_cast<int>(im.height() / sy));
892
        pm.convertFromImage(im2);
893
        QPainter p;
894
        p.begin(&pm);
895
        p.setBrush(NoBrush);
896
        p.setPen(black);
897
        p.drawRect(0, 0, pm.width(), pm.height());
898
        p.end();
899
        im2.detach();
68 Franz 900
        delete painter;
3 paul 901
        return pm;
902
}
903
 
904
void ScribusView::CreatePS(PSLib *p, uint von, uint bis, int step, bool sep, QString SepNam, bool farb, bool Hm, bool Vm, bool Ic)
905
{
906
        uint a;
907
        int sepac;
80 Franz 908
        double wideR;
3 paul 909
        bool multiPath = false;
108 Franz 910
        RecalcTextPos();
3 paul 911
        p->PS_set_Info("Author", Doc->DocAutor);
912
        p->PS_set_Info("Title", Doc->DocTitel);
913
        if (!farb)
914
                p->PS_setGray();
915
        p->PS_begin_doc(Doc->PageOri, Doc->PageB, Doc->PageH, abs(bis-von));
916
        a = von;
917
        sepac = 0;
918
        for (uint ap = 0; ap < MasterPages.count(); ++ap)
919
                {
920
                if (MasterPages.at(ap)->Items.count() != 0)
921
                        {
922
                        if ((!sep) && (farb))
923
                                {
924
                                for (uint api = 0; api < MasterPages.at(ap)->Items.count(); ++api)
925
                                        {
926
                                        PageItem *it = MasterPages.at(ap)->Items.at(api);
927
                                        if ((it->PType == 2) && (it->PicAvail) && (it->Pfile != "") && (it->isPrintable))
20 Franz 928
                                                p->PS_ImageData(it->InvPict, it->Pfile, it->AnName, it->IProfile, it->UseEmbedded, Ic);
3 paul 929
                                        }
80 Franz 930
                                }
3 paul 931
                        p->PS_TemplateStart(MasterPages.at(ap)->PageNam, Doc->PageB, Doc->PageH);
932
                        ProcessPage(p, MasterPages.at(ap), ap+1, sep, farb, Ic);
933
                        p->PS_TemplateEnd();
934
                        }
935
                }
936
        while (a != bis)
937
                {
938
                p->PS_begin_page(Doc->PageB, Doc->PageH, &Pages.at(a)->Margins);
939
                if (Hm)
940
                        {
941
                        p->PS_translate(Doc->PageB, 0);
942
                        p->PS_scale(-1, 1);
943
                        }
944
                if (Vm)
945
                        {
946
                        p->PS_translate(0, Doc->PageH);
947
                        p->PS_scale(1, -1);
948
                        }
949
                if (sep)
950
                        {
951
                        if (SepNam == "Black")
952
                                p->PS_plate(0);
953
                        if (SepNam == "Cyan")
954
                                p->PS_plate(1);
955
                        if (SepNam == "Magenta")
956
                                p->PS_plate(2);
957
                        if (SepNam == "Yellow")
958
                                p->PS_plate(3);
959
                        if (SepNam == tr("All"))
960
                                p->PS_plate(sepac);
961
                        }
962
                if (Pages.at(a)->MPageNam != "")
963
                        {
964
                        int h, s, v, k, tsz;
965
                        QCString chxc;
966
                        QString chx;
967
                        struct Pti *hl;
968
                        int Lnr = 0;
969
                        struct Layer ll;
970
                        ll.Drucken = false;
971
                        ll.LNr = 0;
972
                        Page* mPage = MasterPages.at(MasterNames[Pages.at(a)->MPageNam]);
973
                        if (mPage->Items.count() != 0)
974
                                {
975
                                p->PS_UseTemplate(Pages.at(a)->MPageNam);
976
                                for (uint lam = 0; lam < Doc->Layers.count(); ++lam)
977
                                        {
978
                                        Level2Layer(Doc, &ll, Lnr);
979
                                        if (ll.Drucken)
980
                                                {
981
                                                for (uint am = 0; am < mPage->Items.count(); ++am)
982
                                                        {
983
                                                        PageItem *ite = mPage->Items.at(am);
984
                                                        if (ite->Segments.count() != 0)
985
                                                                multiPath = true;
986
                                                        else
987
                                                                multiPath = false;
988
                                                        if ((ite->LayerNr != ll.LNr) || (!ite->isPrintable))
989
                                                                continue;
990
                                                        if ((ite->PType == 2) && ((sep) || (!farb)))
991
                                                                {
992
                                                                p->PS_save();
993
                                                                p->PS_translate(ite->Xpos, Doc->PageH - ite->Ypos);
994
                                                                if (ite->Rot != 0)
995
                                                                        p->PS_rotate(-ite->Rot);
996
                                                                if (ite->Pcolor != "None")
997
                                                                        {
998
                                                                        SetFarbe(ite->Pcolor, ite->Shade, &h, &s, &v, &k);
999
                                                                        p->PS_setcmykcolor_fill(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
68 Franz 1000
                                                                        SetClipPath(p, &ite->PoLine);
3 paul 1001
                                                                        p->PS_closepath();
1002
                                                                        p->PS_fill(multiPath);
1003
                                                                        }
1004
                                                                else
1005
                                                                        p->PS_setcmykcolor_dummy();
68 Franz 1006
                                                                SetClipPath(p, &ite->PoLine);
3 paul 1007
                                                                p->PS_closepath();
1008
                                                                p->PS_clip(multiPath);
9 Franz 1009
                                                                p->PS_save();
3 paul 1010
                                                                if ((ite->flippedH % 2) != 0)
1011
                                                                        {
1012
                                                                        p->PS_translate(ite->Width, 0);
1013
                                                                        p->PS_scale(-1, 1);
1014
                                                                        }
1015
                                                                if ((ite->flippedV % 2) != 0)
1016
                                                                        {
1017
                                                                        p->PS_translate(0, -ite->Height);
1018
                                                                        p->PS_scale(1, -1);
1019
                                                                        }
1020
                                                                if ((ite->PicAvail) && (ite->Pfile != ""))
1021
                                                                        {
1022
                                                                        p->PS_translate(0, -ite->BBoxH*ite->LocalScY);
20 Franz 1023
                                                                        p->PS_image(ite->InvPict, -ite->BBoxX+ite->LocalX, -ite->LocalY, ite->Pfile, ite->LocalScX, ite->LocalScY, ite->IProfile, ite->UseEmbedded, Ic);
3 paul 1024
                                                                        }
1025
                                                                p->PS_restore();
27 Franz 1026
                                                                if ((ite->Pcolor2 != "None") || (ite->NamedLStyle != ""))
9 Franz 1027
                                                                        {
27 Franz 1028
                                                                        if (ite->NamedLStyle == "")
1029
                                                                                {
68 Franz 1030
                                                                                SetClipPath(p, &ite->PoLine);
27 Franz 1031
                                                                                p->PS_closepath();
1032
                                                                                p->PS_stroke();
1033
                                                                                }
1034
                                                                        else
1035
                                                                                {
1036
                                                                                multiLine ml = Doc->MLineStyles[ite->NamedLStyle];
34 Franz 1037
                                                                                for (int it = ml.size()-1; it > -1; it--)
27 Franz 1038
                                                                                        {
1039
                                                                                        SetFarbe(ml[it].Color, ml[it].Shade, &h, &s, &v, &k);
1040
                                                                                        p->PS_setcmykcolor_stroke(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1041
                                                                                        p->PS_setlinewidth(ml[it].Width);
1042
                                                                                        p->PS_setdash(static_cast<PenStyle>(ml[it].Dash), static_cast<PenCapStyle>(ml[it].LineEnd), static_cast<PenJoinStyle>(ml[it].LineJoin));
68 Franz 1043
                                                                                        SetClipPath(p, &ite->PoLine);
27 Franz 1044
                                                                                        p->PS_closepath();
1045
                                                                                        p->PS_stroke();
1046
                                                                                        }
1047
                                                                                }
9 Franz 1048
                                                                        }
1049
                                                                p->PS_restore();
3 paul 1050
                                                                }
1051
                                                        if (ite->PType == 4)
1052
                                                                {
1053
                                                                p->PS_save();
1054
                                                                if (ite->Pcolor != "None")
1055
                                                                        {
1056
                                                                        SetFarbe(ite->Pcolor, ite->Shade, &h, &s, &v, &k);
1057
                                                                        p->PS_setcmykcolor_fill(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1058
                                                                        }
1059
                                                                p->PS_translate(ite->Xpos, Doc->PageH - ite->Ypos);
80 Franz 1060
                                                                if (ite->Rot != 0)
3 paul 1061
                                                                        p->PS_rotate(-ite->Rot);
1062
                                                                if ((ite->Pcolor != "None") || (ite->GrType != 0))
1063
                                                                        {
68 Franz 1064
                                                                        SetClipPath(p, &ite->PoLine);
3 paul 1065
                                                                        p->PS_closepath();
27 Franz 1066
                                                                        p->PS_fill(multiPath);
3 paul 1067
                                                                        }
1068
                                                                if ((ite->flippedH % 2) != 0)
1069
                                                                        {
1070
                                                                        p->PS_translate(ite->Width, 0);
1071
                                                                        p->PS_scale(-1, 1);
1072
                                                                        }
1073
                                                                if ((ite->flippedV % 2) != 0)
1074
                                                                        {
1075
                                                                        p->PS_translate(0, -ite->Height);
1076
                                                                        p->PS_scale(1, -1);
1077
                                                                        }
1078
                                                                for (uint d = 0; d < ite->MaxChars; ++d)
1079
                                                                        {
1080
                                                                        hl = ite->Ptext.at(d);
139 Franz 1081
                                                                        if ((hl->ch == QChar(13)) || (hl->ch == QChar(10)) || (hl->ch == QChar(9)))
3 paul 1082
                                                                                continue;
1083
                                                                        if (hl->yp == 0)
1084
                                                                                break;
1085
                                                                        tsz = hl->csize;
1086
                                                                        chx = hl->ch;
55 Franz 1087
                                                                        if (hl->ch == QChar(29))
1088
                                                                                chx = " ";
3 paul 1089
                                                                        if (hl->ch == QChar(30))
1090
                                                                                {
1091
                                                                                if (Doc->MasterP)
1092
                                                                                        chx = "#";
1093
                                                                                else
1094
                                                                                        {
1095
                                                                                        uint zae = 0;
1096
                                                                                        while (ite->Ptext.at(d+zae)->ch == QChar(30))
1097
                                                                                                {
1098
                                                                                                zae++;
1099
                                                                                                if (d+zae == ite->MaxChars)
1100
                                                                                                        break;
1101
                                                                                                }
1102
                                                                                        QString out="%1";
1103
                                                                                        chx = out.arg(a+Doc->FirstPnum, zae).right(zae).left(1);
1104
                                                                                        }
1105
                                                                                }
1106
                                                                        if (hl->cstyle & 64)
1107
                                                                                {
1108
                                                                                if (chx.upper() != chx)
1109
                                                                                        {
1110
                                                                                        tsz = hl->csize * Doc->VKapit / 100;
1111
                                                                                        chx = chx.upper();
1112
                                                                                        }
1113
                                                                                }
1114
                                                                        if (hl->cstyle & 1)
1115
                                                                                tsz = hl->csize * Doc->VHochSc / 100;
1116
                                                                        if (hl->cstyle & 2)
1117
                                                                                tsz = hl->csize * Doc->VHochSc / 100;
68 Franz 1118
                                                                        if (((*Doc->AllFonts)[hl->cfont]->isOTF) || ((*Doc->AllFonts)[hl->cfont]->Subset))
3 paul 1119
                                                                                {
68 Franz 1120
                                                                                uint chr = chx[0].unicode();
1121
                                                                                if (((*Doc->AllFonts)[hl->cfont]->CharWidth.contains(chr)) && (chr != 32))
1122
                                                                                        {
1123
                                                                                        p->PS_save();
1124
                                                                                        if (ite->Reverse)
1125
                                                                                                {
111 Franz 1126
                                                                                                p->PS_translate(hl->xp, (hl->yp - (tsz / 10.0)) * -1);
68 Franz 1127
                                                                                                p->PS_scale(-1, 1);
1128
                                                                                                if (d < ite->MaxChars-1)
1129
                                                                                                        {
1130
                                                                                                        QString ctx = ite->Ptext.at(d+1)->ch;
1131
                                                                                                        if (ctx == QChar(29))
1132
                                                                                                                ctx = " ";
1133
                                                                                                        wideR = -Cwidth(Doc, hl->cfont, chx, tsz, ctx) * (hl->cscale / 100.0);
1134
                                                                                                        }
1135
                                                                                                else
1136
                                                                                                        wideR = -Cwidth(Doc, hl->cfont, chx, tsz) * (hl->cscale / 100.0);
1137
                                                                                                p->PS_translate(wideR, 0);
1138
                                                                                                }
1139
                                                                                        else
111 Franz 1140
                                                                                                p->PS_translate(hl->xp, (hl->yp - (tsz / 10.0)) * -1);
68 Franz 1141
                                                                                        if (hl->cscale != 100)
1142
                                                                                                p->PS_scale(hl->cscale / 100.0, 1);
1143
                                                                                        if (hl->ccolor != "None")
1144
                                                                                                {
1145
                                                                                                SetFarbe(hl->ccolor, hl->cshade, &h, &s, &v, &k);
1146
                                                                                                p->PS_setcmykcolor_fill(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
111 Franz 1147
                                                                                                p->PS_showSub(chr, (*Doc->AllFonts)[hl->cfont]->RealName(), tsz / 10.0, false);
68 Franz 1148
                                                                                                }
1149
                                                                                        p->PS_restore();
1150
                                                                                        }
3 paul 1151
                                                                                }
68 Franz 1152
                                                                        else
3 paul 1153
                                                                                {
111 Franz 1154
                                                                                p->PS_selectfont(hl->cfont, tsz / 10.0);
68 Franz 1155
                                                                                if (hl->ccolor != "None")
1156
                                                                                        {
1157
                                                                                        SetFarbe(hl->ccolor, hl->cshade, &h, &s, &v, &k);
1158
                                                                                        p->PS_setcmykcolor_stroke(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1159
                                                                                        }
1160
                                                                                p->PS_save();
3 paul 1161
                                                                                if (ite->Reverse)
1162
                                                                                        {
1163
                                                                                        int chs = hl->csize;
68 Franz 1164
                                                                                        ite->SetZeichAttr(hl, &chs, &chx);
3 paul 1165
                                                                                        p->PS_translate(hl->xp, -hl->yp);
1166
                                                                                        p->PS_scale(-1, 1);
1167
                                                                                        if (d < ite->MaxChars-1)
55 Franz 1168
                                                                                                {
1169
                                                                                                QString ctx = ite->Ptext.at(d+1)->ch;
1170
                                                                                                if (ctx == QChar(29))
1171
                                                                                                        ctx = " ";
68 Franz 1172
                                                                                                wideR = -Cwidth(Doc, hl->cfont, chx, chs, ctx) * (hl->cscale / 100.0);
1173
                                                                                                p->PS_translate(wideR, 0);
55 Franz 1174
                                                                                                }
3 paul 1175
                                                                                        else
68 Franz 1176
                                                                                                {
1177
                                                                                                wideR = -Cwidth(Doc, hl->cfont, chx, chs) * (hl->cscale / 100.0);
1178
                                                                                                p->PS_translate(wideR, 0);
1179
                                                                                                }
1180
                                                                                        if (hl->cscale != 100)
1181
                                                                                                p->PS_scale(hl->cscale / 100.0, 1);
3 paul 1182
                                                                                        p->PS_show_xyG(hl->cfont, chx, 0, 0);
1183
                                                                                        }
1184
                                                                                else
68 Franz 1185
                                                                                        {
1186
                                                                                        p->PS_translate(hl->xp, -hl->yp);
1187
                                                                                        if (hl->cscale != 100)
1188
                                                                                                p->PS_scale(hl->cscale / 100.0, 1);
1189
                                                                                        p->PS_show_xyG(hl->cfont, chx, 0, 0);
1190
                                                                                        }
1191
                                                                                p->PS_restore();
3 paul 1192
                                                                                }
68 Franz 1193
                                                                        if ((hl->cstyle & 4) && (chx != QChar(13)))
3 paul 1194
                                                                                {
68 Franz 1195
                                                                                uint chr = chx[0].unicode();
1196
                                                                                if ((*Doc->AllFonts)[hl->cfont]->CharWidth.contains(chr))
3 paul 1197
                                                                                        {
68 Franz 1198
                                                                                        FPointArray gly = (*Doc->AllFonts)[hl->cfont]->GlyphArray[chr].Outlines.copy();
1199
                                                                                        QWMatrix chma;
111 Franz 1200
                                                                                        chma.scale(tsz / 100.0, tsz / 100.0);
68 Franz 1201
                                                                                        gly.map(chma);
1202
                                                                                        chma = QWMatrix();
1203
                                                                                        chma.scale(hl->cscale / 100.0, 1);
1204
                                                                                        gly.map(chma);
3 paul 1205
                                                                                        if (ite->Reverse)
1206
                                                                                                {
68 Franz 1207
                                                                                                chma = QWMatrix();
1208
                                                                                                chma.scale(-1, 1);
1209
                                                                                                chma.translate(wideR, 0);
1210
                                                                                                gly.map(chma);
1211
                                                                                                }
1212
                                                                                        if (hl->cstroke != "None")
1213
                                                                                                {
3 paul 1214
                                                                                                p->PS_save();
111 Franz 1215
                                                                                                p->PS_setlinewidth(QMAX((*Doc->AllFonts)[hl->cfont]->strokeWidth / 2 * (tsz / 10.0), 1));
68 Franz 1216
                                                                                                p->PS_setdash(SolidLine, FlatCap, MiterJoin);
1217
                                                                                                p->PS_translate(hl->xp, (hl->yp - tsz) * -1);
1218
                                                                                                SetFarbe(hl->cstroke, hl->cshade2, &h, &s, &v, &k);
1219
                                                                                                p->PS_setcmykcolor_stroke(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1220
                                                                                                SetClipPath(p, &gly);
1221
                                                                                                p->PS_closepath();
1222
                                                                                                p->PS_stroke();
3 paul 1223
                                                                                                p->PS_restore();
1224
                                                                                                }
1225
                                                                                        }
68 Franz 1226
                                                                                }
1227
                                                                        if (hl->cstyle & 16)
1228
                                                                                {
80 Franz 1229
                                                                                double Ulen = Cwidth(Doc, hl->cfont, chx, hl->csize) * (hl->cscale / 100.0);
111 Franz 1230
                                                                                double Upos = (*Doc->AllFonts)[hl->cfont]->strikeout_pos * (tsz / 10.0);
68 Franz 1231
                                                                                if (hl->ccolor != "None")
3 paul 1232
                                                                                        {
68 Franz 1233
                                                                                        p->PS_setdash(SolidLine, FlatCap, MiterJoin);
1234
                                                                                        SetFarbe(hl->ccolor, hl->cshade, &h, &s, &v, &k);
1235
                                                                                        p->PS_setcmykcolor_stroke(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1236
                                                                                        }
111 Franz 1237
                                                                                p->PS_setlinewidth((*Doc->AllFonts)[hl->cfont]->strokeWidth * (tsz / 10.0));
68 Franz 1238
                                                                                p->PS_moveto(hl->xp, -hl->yp+Upos);
1239
                                                                                p->PS_lineto(hl->xp+Ulen, -hl->yp+Upos);
1240
                                                                                p->PS_stroke();
1241
                                                                                }
1242
                                                                        if ((hl->cstyle & 128) && (((ite->Ptext.at(QMIN(d+1, ite->Ptext.count()-1))->yp != hl->yp) && (ite->Ptext.at(QMIN(d+1, ite->Ptext.count()-1))->ch != QChar(13))) || ((ite->NextBox != 0) && (d == ite->Ptext.count()-1))))
1243
                                                                                {
1244
                                                                                int chs = hl->csize;
1245
                                                                                ite->SetZeichAttr(hl, &chs, &chx);
80 Franz 1246
                                                                                double wide = Cwidth(Doc, hl->cfont, chx, chs);
75 Franz 1247
                                                                                chx = "-";
1248
                                                                                uint chr = chx[0].unicode();
1249
                                                                                if ((*Doc->AllFonts)[hl->cfont]->CharWidth.contains(chr))
1250
                                                                                        {
1251
                                                                                        FPointArray gly = (*Doc->AllFonts)[hl->cfont]->GlyphArray[chr].Outlines.copy();
1252
                                                                                        QWMatrix chma;
111 Franz 1253
                                                                                        chma.scale(tsz / 100.0, tsz / 100.0);
75 Franz 1254
                                                                                        gly.map(chma);
1255
                                                                                        chma = QWMatrix();
1256
                                                                                        chma.scale(hl->cscale / 100.0, 1);
1257
                                                                                        gly.map(chma);
1258
                                                                                        if (hl->ccolor != "None")
1259
                                                                                                {
1260
                                                                                                p->PS_save();
111 Franz 1261
                                                                                                p->PS_translate(hl->xp+wide, (hl->yp - (tsz / 10.0)) * -1);
75 Franz 1262
                                                                                                SetFarbe(hl->ccolor, hl->cshade, &h, &s, &v, &k);
1263
                                                                                                p->PS_setcmykcolor_fill(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1264
                                                                                                SetClipPath(p, &gly);
1265
                                                                                                p->PS_closepath();
1266
                                                                                                p->PS_fill(true);
1267
                                                                                                p->PS_restore();
1268
                                                                                                }
1269
                                                                                        }
68 Franz 1270
                                                                                }
1271
                                                                        if ((hl->cstyle & 8) && (chx != QChar(13)))
1272
                                                                                {
1273
                                                                                int chs = hl->csize;
1274
                                                                                ite->SetZeichAttr(hl, &chs, &chx);
80 Franz 1275
                                                                                double csi = chs / 10.0;
1276
                                                                                double wid = Cwidth(Doc, hl->cfont, chx, chs) * (hl->cscale / 100.0);
111 Franz 1277
                                                                                QPixmap pgPix(static_cast<int>(wid), static_cast<int>(hl->csize / 10.0));
1278
                                                                                ScPainter *painter = new ScPainter(&pgPix, static_cast<int>(wid), static_cast<int>(hl->csize / 10.0));
68 Franz 1279
                                                                                QString psSt = "1 -1 scale\n";
1280
                                                                                uint chr = chx[0].unicode();
1281
                                                                                if ((*Doc->AllFonts)[hl->cfont]->CharWidth.contains(chr))
1282
                                                                                        {
1283
                                                                                        FPointArray gly = (*Doc->AllFonts)[hl->cfont]->GlyphArray[chr].Outlines.copy();
111 Franz 1284
                                                                                        double st = (*Doc->AllFonts)[hl->cfont]->underline_pos * csi;
1285
                                                                                        painter->setLineWidth(QMAX((*Doc->AllFonts)[hl->cfont]->strokeWidth * csi, 1));
68 Franz 1286
                                                                                        if (gly.size() < 4)
1287
                                                                                                {
1288
                                                                                                gly.resize(0);
1289
                                                                                                gly.addPoint(FPoint(0,0));
1290
                                                                                                gly.addPoint(FPoint(0,0));
1291
                                                                                                gly.addPoint(FPoint(1,0));
1292
                                                                                                gly.addPoint(FPoint(1,0));
1293
                                                                                                }
1294
                                                                                        QWMatrix chma;
111 Franz 1295
                                                                                        chma.scale(csi / 10.0, csi / 10.0);
68 Franz 1296
                                                                                        gly.map(chma);
1297
                                                                                        chma = QWMatrix();
1298
                                                                                        chma.scale(hl->cscale / 100.0, 1);
1299
                                                                                        gly.map(chma);
1300
                                                                                        painter->setupPolygon(&gly);
111 Franz 1301
                                                                                        painter->drawUnderline(FPoint(0-hl->cextra, csi-st), FPoint(wid, csi-st), true, &psSt);
68 Franz 1302
                                                                                        p->PS_save();
3 paul 1303
                                                                                        if (ite->Reverse)
1304
                                                                                                {
68 Franz 1305
                                                                                                p->PS_translate(hl->xp, (hl->yp - st) * -1);
3 paul 1306
                                                                                                p->PS_scale(-1, 1);
68 Franz 1307
                                                                                                p->PS_translate(-wid, 0);
3 paul 1308
                                                                                                }
1309
                                                                                        else
68 Franz 1310
                                                                                                p->PS_translate(hl->xp, (hl->yp - st) * -1);
1311
                                                                                        if (hl->ccolor != "None")
1312
                                                                                                {
1313
                                                                                                SetFarbe(hl->ccolor, hl->cshade, &h, &s, &v, &k);
1314
                                                                                                p->PS_setcmykcolor_fill(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1315
                                                                                                }
1316
                                                                                        p->PS_insert(psSt+"closepath\n");
1317
                                                                                        p->PS_fill(true);
1318
                                                                                        p->PS_restore();
1319
                                                                                        painter->end();
1320
                                                                                        delete painter;
3 paul 1321
                                                                                        }
1322
                                                                                }
68 Franz 1323
                                                                        }
1324
                                                                if ((ite->Pcolor2 != "None") || (ite->NamedLStyle != ""))
1325
                                                                        {
1326
                                                                        SetFarbe(ite->Pcolor2, ite->Shade2, &h, &s, &v, &k);
1327
                                                                        p->PS_setcmykcolor_stroke(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1328
                                                                        p->PS_setlinewidth(ite->Pwidth);
1329
                                                                        p->PS_setdash(ite->PLineArt, ite->PLineEnd, ite->PLineJoin);
1330
                                                                        if (ite->NamedLStyle == "")
3 paul 1331
                                                                                {
68 Franz 1332
                                                                                SetClipPath(p, &ite->PoLine);
1333
                                                                                p->PS_closepath();
1334
                                                                                p->PS_stroke();
3 paul 1335
                                                                                }
68 Franz 1336
                                                                        else
1337
                                                                                {
1338
                                                                                multiLine ml = Doc->MLineStyles[ite->NamedLStyle];
1339
                                                                                for (int it = ml.size()-1; it > -1; it--)
1340
                                                                                        {
1341
                                                                                        SetFarbe(ml[it].Color, ml[it].Shade, &h, &s, &v, &k);
1342
                                                                                        p->PS_setcmykcolor_stroke(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1343
                                                                                        p->PS_setlinewidth(ml[it].Width);
1344
                                                                                        p->PS_setdash(static_cast<PenStyle>(ml[it].Dash), static_cast<PenCapStyle>(ml[it].LineEnd), static_cast<PenJoinStyle>(ml[it].LineJoin));
1345
                                                                                        SetClipPath(p, &ite->PoLine);
1346
                                                                                        p->PS_closepath();
1347
                                                                                        p->PS_stroke();
1348
                                                                                        }
1349
                                                                                }
3 paul 1350
                                                                        }
1351
                                                                p->PS_restore();
1352
                                                                }
1353
                                                        }
1354
                                                }
1355
                                        Lnr++;
1356
                                        }
1357
                                }
1358
                        }
1359
                ProcessPage(p, Pages.at(a), a+1, sep, farb, Ic);
1360
                p->PS_end_page();
1361
                if (sep)
1362
                        {
1363
                        if (SepNam != tr("All"))
1364
                                a += step;
1365
                        else
1366
                                {
1367
                                if (sepac == 3)
1368
                                        {
1369
                                        a += step;
1370
                                        sepac = 0;
1371
                                        }
1372
                                else
1373
                                        sepac++;
1374
                                }
1375
                        }
1376
                else
1377
                        a += step;
1378
                }
1379
        p->PS_close();
1380
}
1381
 
1382
void ScribusView::ProcessPage(PSLib *p, Page* a, uint PNr, bool sep, bool farb, bool ic)
1383
{
1384
        uint b, d;
1385
        int h, s, v, k, tsz;
80 Franz 1386
        double wideR;
3 paul 1387
        QCString chxc;
68 Franz 1388
        QString chx, chglyph, tmp;
3 paul 1389
        PageItem *c;
1390
        struct Pti *hl;
1391
        bool multiPath = false;
1392
        int Lnr = 0;
1393
        struct Layer ll;
1394
        ll.Drucken = false;
1395
        ll.LNr = 0;
1396
        for (uint la = 0; la < Doc->Layers.count(); ++la)
1397
                {
1398
                Level2Layer(Doc, &ll, Lnr);
1399
                if (ll.Drucken)
1400
                        {
1401
                        for (b = 0; b < a->Items.count(); ++b)
1402
                                {
1403
                                c = a->Items.at(b);
1404
                                if (c->Segments.count() != 0)
1405
                                        multiPath = true;
1406
                                else
1407
                                        multiPath = false;
1408
                                if (c->LayerNr != ll.LNr)
1409
                                        continue;
1410
                                if ((a->PageNam != "") && (c->PType == 4))
1411
                                        continue;
1412
                                if ((a->PageNam != "") && (c->PType == 2) && ((sep) || (!farb)))
1413
                                        continue;
1414
                                if (c->isPrintable)
1415
                                        {
1416
                                        p->PS_save();
1417
                                        if (c->Pcolor != "None")
1418
                                                {
1419
                                                SetFarbe(c->Pcolor, c->Shade, &h, &s, &v, &k);
1420
                                                p->PS_setcmykcolor_fill(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1421
                                                }
1422
                                        if (c->Pcolor2 != "None")
1423
                                                {
1424
                                                SetFarbe(c->Pcolor2, c->Shade2, &h, &s, &v, &k);
1425
                                                p->PS_setcmykcolor_stroke(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1426
                                                }
1427
                                        p->PS_setlinewidth(c->Pwidth);
1428
                                        p->PS_setdash(c->PLineArt, c->PLineEnd, c->PLineJoin);
1429
                                        p->PS_translate(c->Xpos, Doc->PageH - c->Ypos);
1430
                                        if (c->Rot != 0)
1431
                                                p->PS_rotate(-c->Rot);
1432
                                        switch (c->PType)
1433
                                                {
1434
                                                case 2:
27 Franz 1435
                                                        if ((c->Pcolor != "None") || (c->GrType != 0))
3 paul 1436
                                                                {
68 Franz 1437
                                                                SetClipPath(p, &c->PoLine);
3 paul 1438
                                                                p->PS_closepath();
27 Franz 1439
                                                                if ((c->GrType != 0) && (a->PageNam == ""))
1440
                                                                        {
1441
                                                                        SetFarbe(c->GrColor2, c->GrShade2, &h, &s, &v, &k);
1442
                                                                        p->PS_GradientCol1(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1443
                                                                        SetFarbe(c->GrColor, c->GrShade, &h, &s, &v, &k);
1444
                                                                        p->PS_GradientCol2(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1445
                                                                        switch (c->GrType)
1446
                                                                                {
1447
                                                                                case 1:
1448
                                                                                case 2:
1449
                                                                                case 3:
1450
                                                                                case 4:
1451
                                                                                        p->PS_LinGradient(c->Width, -c->Height, c->PType, c->GrType, multiPath);
1452
                                                                                        break;
1453
                                                                                case 5:
1454
                                                                                        p->PS_RadGradient(c->Width, -c->Height, c->PType, multiPath);
1455
                                                                                        break;
1456
                                                                                default:
1457
                                                                                        break;
1458
                                                                                }
1459
                                                                        }
1460
                                                                else
1461
                                                                        p->PS_fill(multiPath);
3 paul 1462
                                                                }
27 Franz 1463
                                                        p->PS_save();
68 Franz 1464
                                                        SetClipPath(p, &c->PoLine);
3 paul 1465
                                                        p->PS_closepath();
1466
                                                        p->PS_clip(multiPath);
1467
                                                        if ((c->flippedH % 2) != 0)
1468
                                                                {
1469
                                                                p->PS_translate(c->Width, 0);
1470
                                                                p->PS_scale(-1, 1);
1471
                                                                }
1472
                                                        if ((c->flippedV % 2) != 0)
1473
                                                                {
1474
                                                                p->PS_translate(0, -c->Height);
1475
                                                                p->PS_scale(1, -1);
1476
                                                                }
1477
                                                        if ((c->PicAvail) && (c->Pfile != ""))
1478
                                                                {
1479
                                                                p->PS_translate(0, -c->BBoxH*c->LocalScY);
1480
                                                                if (a->PageNam != "")
20 Franz 1481
                                                                        p->PS_image(c->InvPict, -c->BBoxX+c->LocalX, -c->LocalY, c->Pfile, c->LocalScX, c->LocalScY, c->IProfile, c->UseEmbedded, ic, c->AnName);
3 paul 1482
                                                                else
20 Franz 1483
                                                                        p->PS_image(c->InvPict, -c->BBoxX+c->LocalX, -c->LocalY, c->Pfile, c->LocalScX, c->LocalScY, c->IProfile, c->UseEmbedded, ic);
9 Franz 1484
                                                                }
1485
                                                        p->PS_restore();
27 Franz 1486
                                                        if ((c->Pcolor2 != "None") || (c->NamedLStyle != ""))
9 Franz 1487
                                                                {
27 Franz 1488
                                                                if (c->NamedLStyle == "")
1489
                                                                        {
68 Franz 1490
                                                                        SetClipPath(p, &c->PoLine);
27 Franz 1491
                                                                        p->PS_closepath();
1492
                                                                        p->PS_stroke();
1493
                                                                        }
1494
                                                                else
1495
                                                                        {
1496
                                                                        multiLine ml = Doc->MLineStyles[c->NamedLStyle];
34 Franz 1497
                                                                        for (int it = ml.size()-1; it > -1; it--)
27 Franz 1498
                                                                                {
1499
                                                                                SetFarbe(ml[it].Color, ml[it].Shade, &h, &s, &v, &k);
1500
                                                                                p->PS_setcmykcolor_stroke(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1501
                                                                                p->PS_setlinewidth(ml[it].Width);
1502
                                                                                p->PS_setdash(static_cast<PenStyle>(ml[it].Dash), static_cast<PenCapStyle>(ml[it].LineEnd), static_cast<PenJoinStyle>(ml[it].LineJoin));
68 Franz 1503
                                                                                SetClipPath(p, &c->PoLine);
27 Franz 1504
                                                                                p->PS_closepath();
1505
                                                                                p->PS_stroke();
1506
                                                                                }
1507
                                                                        }
80 Franz 1508
                                                                }
3 paul 1509
                                                        break;
1510
                                                case 4:
1511
                                                        if (c->isBookmark)
1512
                                                                {
1513
                                                                QString bm = "";
1514
                                                                QString cc;
1515
                                                                for (d = 0; d < c->Ptext.count(); ++d)
1516
                                                                        {
1517
                                                                        if ((c->Ptext.at(d)->ch == QChar(13)) || (c->Ptext.at(d)->ch == QChar(10)))
1518
                                                                                break;
55 Franz 1519
                                                                        bm += "\\"+cc.setNum(QMAX(c->Ptext.at(d)->ch.at(0).unicode(), 32), 8);
3 paul 1520
                                                                        }
1521
                                                                p->PDF_Bookmark(bm, a->PageNr+1);
1522
                                                                }
1523
                                                        if (c->isAnnotation)
1524
                                                                {
1525
                                                                QString bm = "";
1526
                                                                QString cc;
1527
                                                                for (d = 0; d < c->Ptext.count(); ++d)
1528
                                                                        {
55 Franz 1529
                                                                        bm += "\\"+cc.setNum(QMAX(c->Ptext.at(d)->ch.at(0).unicode(), 32), 8);
3 paul 1530
                                                                        }
1531
                                                                p->PDF_Annotation(bm, 0, 0, c->Width, -c->Height);
1532
                                                                break;
1533
                                                                }
1534
                                                        if ((c->Pcolor != "None") || (c->GrType != 0))
1535
                                                                {
68 Franz 1536
                                                                SetClipPath(p, &c->PoLine);
3 paul 1537
                                                                p->PS_closepath();
1538
                                                                if ((c->GrType != 0) && (a->PageNam == ""))
1539
                                                                        {
1540
                                                                        SetFarbe(c->GrColor2, c->GrShade2, &h, &s, &v, &k);
1541
                                                                        p->PS_GradientCol1(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1542
                                                                        SetFarbe(c->GrColor, c->GrShade, &h, &s, &v, &k);
1543
                                                                        p->PS_GradientCol2(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1544
                                                                        switch (c->GrType)
1545
                                                                                {
1546
                                                                                case 1:
1547
                                                                                case 2:
1548
                                                                                case 3:
1549
                                                                                case 4:
1550
                                                                                        p->PS_LinGradient(c->Width, -c->Height, c->PType, c->GrType, multiPath);
1551
                                                                                        break;
1552
                                                                                case 5:
1553
                                                                                        p->PS_RadGradient(c->Width, -c->Height, c->PType, multiPath);
1554
                                                                                        break;
1555
                                                                                default:
1556
                                                                                        break;
1557
                                                                                }
1558
                                                                        }
1559
                                                                else
1560
                                                                        p->PS_fill(multiPath);
1561
                                                                }
1562
                                                        if ((c->flippedH % 2) != 0)
1563
                                                                {
1564
                                                                p->PS_translate(c->Width, 0);
1565
                                                                p->PS_scale(-1, 1);
1566
                                                                }
1567
                                                        if ((c->flippedV % 2) != 0)
1568
                                                                {
1569
                                                                p->PS_translate(0, -c->Height);
1570
                                                                p->PS_scale(1, -1);
1571
                                                                }
1572
                                                        for (d = 0; d < c->MaxChars; ++d)
1573
                                                                {
1574
                                                                hl = c->Ptext.at(d);
139 Franz 1575
                                                                if ((hl->ch == QChar(13)) || (hl->ch == QChar(10)) || (hl->ch == QChar(9)))
3 paul 1576
                                                                        continue;
1577
                                                                if (hl->yp == 0)
1578
                                                                        break;
1579
                                                                tsz = hl->csize;
1580
                                                                chx = hl->ch;
55 Franz 1581
                                                                if (hl->ch == QChar(29))
1582
                                                                        chx = " ";
3 paul 1583
                                                                if (hl->ch == QChar(30))
1584
                                                                        {
1585
                                                                        if (Doc->MasterP)
1586
                                                                                chx = "#";
1587
                                                                        else
1588
                                                                                {
1589
                                                                                uint zae = 0;
1590
                                                                                while (c->Ptext.at(d+zae)->ch == QChar(30))
1591
                                                                                        {
1592
                                                                                        zae++;
1593
                                                                                        if (d+zae == c->MaxChars)
1594
                                                                                                break;
1595
                                                                                        }
1596
                                                                                QString out="%1";
1597
                                                                                chx = out.arg(PNr-1+Doc->FirstPnum, zae).right(zae).left(1);
1598
                                                                                }
1599
                                                                        }
1600
                                                                if (hl->cstyle & 64)
1601
                                                                        {
1602
                                                                        if (chx.upper() != chx)
1603
                                                                                {
1604
                                                                                tsz = hl->csize * Doc->VKapit / 100;
1605
                                                                                chx = chx.upper();
1606
                                                                                }
1607
                                                                        }
1608
                                                                if (hl->cstyle & 1)
1609
                                                                        tsz = hl->csize * Doc->VHochSc / 100;
1610
                                                                if (hl->cstyle & 2)
1611
                                                                        tsz = hl->csize * Doc->VHochSc / 100;
111 Franz 1612
                                                                if (((*Doc->AllFonts)[hl->cfont]->isOTF) || ((*Doc->AllFonts)[hl->cfont]->Subset))
3 paul 1613
                                                                        {
68 Franz 1614
                                                                        uint chr = chx[0].unicode();
1615
                                                                        if (((*Doc->AllFonts)[hl->cfont]->CharWidth.contains(chr)) && (chr != 32))
1616
                                                                                {
1617
                                                                                p->PS_save();
1618
                                                                                if (c->Reverse)
1619
                                                                                        {
111 Franz 1620
                                                                                        p->PS_translate(hl->xp, (hl->yp - (tsz / 10.0)) * -1);
68 Franz 1621
                                                                                        p->PS_scale(-1, 1);
1622
                                                                                        if (d < c->MaxChars-1)
1623
                                                                                                {
1624
                                                                                                QString ctx = c->Ptext.at(d+1)->ch;
1625
                                                                                                if (ctx == QChar(29))
1626
                                                                                                        ctx = " ";
1627
                                                                                                wideR = -Cwidth(Doc, hl->cfont, chx, tsz, ctx) * (hl->cscale / 100.0);
1628
                                                                                                }
1629
                                                                                        else
1630
                                                                                                wideR = -Cwidth(Doc, hl->cfont, chx, tsz) * (hl->cscale / 100.0);
1631
                                                                                        p->PS_translate(wideR, 0);
1632
                                                                                        }
1633
                                                                                else
111 Franz 1634
                                                                                        p->PS_translate(hl->xp, (hl->yp - (tsz / 10.0)) * -1);
68 Franz 1635
                                                                                if (hl->cscale != 100)
1636
                                                                                        p->PS_scale(hl->cscale / 100.0, 1);
1637
                                                                                if (hl->ccolor != "None")
1638
                                                                                        {
1639
                                                                                        SetFarbe(hl->ccolor, hl->cshade, &h, &s, &v, &k);
1640
                                                                                        p->PS_setcmykcolor_fill(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
111 Franz 1641
                                                                                        p->PS_showSub(chr, (*Doc->AllFonts)[hl->cfont]->RealName(), tsz / 10.0, false);
68 Franz 1642
                                                                                        }
1643
                                                                                p->PS_restore();
1644
                                                                                }
3 paul 1645
                                                                        }
68 Franz 1646
                                                                else
3 paul 1647
                                                                        {
111 Franz 1648
                                                                        p->PS_selectfont(hl->cfont, tsz / 10.0);
68 Franz 1649
                                                                        if (hl->ccolor != "None")
1650
                                                                                {
1651
                                                                                SetFarbe(hl->ccolor, hl->cshade, &h, &s, &v, &k);
1652
                                                                                p->PS_setcmykcolor_stroke(h / 255.0, s / 255.0, v / 255.0, k / 255.0);
1653
                                                                                }
1654
                                                                        p->PS_save();
3 paul 1655
                                                                        if (c->Reverse)
1656
                                                                                {
1657
                                                                                int chs = hl->csize;
68 Franz 1658
                                                                                c->SetZeichAttr(hl, &chs, &chx);
3 paul 1659
                                                                                p->PS_translate(hl->xp, -hl->yp);
1660
                                                                                p->PS_scale(-1, 1);
1661
                                                                                if (d < c->MaxChars-1)
55 Franz 1662
                                                                                        {
1663
                                                                                        QString ctx = c->Ptext.at(d+1)->ch;
1664
                                                                                        if (ctx == QChar(29))
1665
                                                                                                ctx = " ";
68 Franz 1666
                                                                                        wideR = -Cwidth(Doc, hl->cfont, chx, chs, ctx) * (hl->cscale / 100.0);
1667
                                                                                        p->PS_translate(wideR, 0);
55 Franz 1668
                                                                                        }
3 paul 1669
                                                                                else
68 Franz 1670
                                                                                        {
1671
                                                                                        wideR = -Cwidth(Doc, hl->cfont, chx, chs) * (hl->cscale / 100.0);
1672
                                                                                        p->PS_translate(wideR, 0);
1673
                                                                                        }
1674
                                                                                if (hl->cscale != 100)
1675
                                                                                        p->PS_scale(hl->cscale / 100.0, 1);
3 paul 1676
                                                                                p->PS_show_xyG(hl->cfont, chx, 0, 0);
1677
                                                                                }
1678
                                                                        else
68 Franz 1679
                                                                                {
1680
                                                                                p->PS_translate(hl->xp, -hl->yp);
1681
                                                                                if (hl->cscale != 100)
1682
                                                                                        p->PS_scale(hl->cscale / 100.0, 1);
1683
                                                                                p->PS_show_xyG(hl->cfont, chx, 0, 0);
1684
                                                                                }
1685
                                                                        p->PS_restore();
3 paul 1686
                                                                        }
68 Franz 1687
                                                                if ((hl->cstyle & 4) && (chx != QChar(13)))
3 paul 1688
                                                                        {
68 Franz 1689
                                                                        uint chr = chx[0].unicode();
1690
                                                                        if ((*Doc->AllFonts)[hl->cfont]->CharWidth.contains(chr))
3 paul 1691
                                                                                {
68 Franz 1692
                                                                                FPointArray gly = (*Doc->AllFonts)[hl->cfont]->GlyphArray[chr].Outlines.copy();
1693
                                                                                QWMatrix chma;
111 Franz 1694
                                                                                chma.scale(tsz / 100.0, tsz / 100.0);
68 Franz 1695
                                                                                gly.map(chma);
1696
                                                                                chma = QWMatrix();
1697
                                                                                chma.scale(hl->cscale /