Subversion Repositories Scribus

Rev

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