Subversion Repositories Scribus

Rev

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