Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
4430 cbradney 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
4360 cbradney 7
#include "scpageoutput.h"
8
 
9
#include "qpainter.h"
10
#include "pageitem.h"
11
#include "pageitem_imageframe.h"
12
#include "pageitem_line.h"
13
#include "pageitem_pathtext.h"
14
#include "pageitem_polygon.h"
15
#include "pageitem_polyline.h"
16
#include "pageitem_textframe.h"
17
#include "scfontmetrics.h"
18
#include "scribus.h"
19
#include "scimage.h"
20
#include "util.h"
21
 
22
//extern SCRIBUS_API ScribusMainWindow* ScMW;
23
 
24
ScPageOutput::ScPageOutput(ScribusDoc* doc, bool reloadImages, imageLoadMode loadMode, int resolution, bool useProfiles)
25
{
26
        m_doc = doc;
27
        m_reloadImages = reloadImages;
28
        m_imageRes = resolution;
29
        m_useProfiles = useProfiles;
30
        m_imageMode = loadMode;
31
}
32
 
33
void ScPageOutput::DrawPage( Page* page, ScPainterExBase* painter)
34
{
35
        int clipx = static_cast<int>(page->xOffset());
36
        int clipy = static_cast<int>(page->yOffset());
37
        int clipw = qRound(page->width());
38
        int cliph = qRound(page->height());
39
        DrawMasterItems(painter, page, QRect(clipx, clipy, clipw, cliph));
40
        DrawPageItems(painter, page, QRect(clipx, clipy, clipw, cliph));
41
}
42
 
43
void ScPageOutput::DrawMasterItems(ScPainterExBase *painter, Page *page, QRect clip)
44
{
45
        double z = painter->zoomFactor();
46
        if (!page->MPageNam.isEmpty())
47
        {
48
                Page* Mp = m_doc->MasterPages.at(m_doc->MasterNames[page->MPageNam]);
49
                if (page->FromMaster.count() != 0)
50
                {
51
                        QPainter p;
52
                        int Lnr;
53
                        struct Layer ll;
54
                        PageItem *currItem;
55
                        ll.isViewable = false;
56
                        ll.LNr = 0;
57
                        Lnr = 0;
58
                        uint layerCount = m_doc->layerCount();
59
                        for (uint la = 0; la < layerCount; ++la)
60
                        {
61
                                Level2Layer(m_doc, &ll, Lnr);
62
                                bool pr = true;
63
                                if ( !ll.isPrintable )
64
                                        pr = false;
65
                                if ((ll.isViewable) && (pr))
66
                                {
67
                                        uint pageFromMasterCount=page->FromMaster.count();
68
                                        for (uint a = 0; a < pageFromMasterCount; ++a)
69
                                        {
70
                                                currItem = page->FromMaster.at(a);
71
                                                if (currItem->LayerNr != ll.LNr)
72
                                                        continue;
73
                                                if ((currItem->OwnPage != -1) && (currItem->OwnPage != static_cast<int>(Mp->pageNr())))
74
                                                        continue;
75
                                                if (!currItem->printable())
76
                                                        continue;
77
                                                int savedOwnPage = currItem->OwnPage;
78
                                                double OldX = currItem->xPos();
79
                                                double OldY = currItem->yPos();
80
                                                double OldBX = currItem->BoundingX;
81
                                                double OldBY = currItem->BoundingY;
82
                                                currItem->OwnPage = page->pageNr();
83
                                                if (!currItem->ChangedMasterItem)
84
                                                {
85
                                                        currItem->moveBy(-Mp->xOffset() + page->xOffset(), -Mp->yOffset() + page->yOffset());
86
                                                        currItem->BoundingX = OldBX - Mp->xOffset() + page->xOffset();
87
                                                        currItem->BoundingY = OldBY - Mp->yOffset() + page->yOffset();
88
                                                }
89
                                                /*if (evSpon)
90
                                                        currItem->Dirty = true;*/
91
                                                QRect oldR(currItem->getRedrawBounding(m_scale));
92
                                                if (clip.intersects(oldR))
93
                                                        DrawItem(currItem, painter, clip);
94
                                                currItem->OwnPage = savedOwnPage;
95
                                                if (!currItem->ChangedMasterItem)
96
                                                {
97
                                                        currItem->setXPos(OldX);
98
                                                        currItem->setYPos(OldY);
99
                                                        currItem->BoundingX = OldBX;
100
                                                        currItem->BoundingY = OldBY;
101
                                                }
102
                                        }
103
                                        for (uint a = 0; a < pageFromMasterCount; ++a)
104
                                        {
105
                                                currItem = page->FromMaster.at(a);
106
                                                if (currItem->LayerNr != ll.LNr)
107
                                                        continue;
108
                                                if (!currItem->isTableItem)
109
                                                        continue;
110
                                                if ((currItem->OwnPage != -1) && (currItem->OwnPage != static_cast<int>(Mp->pageNr())))
111
                                                        continue;
112
                                                double OldX = currItem->xPos();
113
                                                double OldY = currItem->yPos();
114
                                                double OldBX = currItem->BoundingX;
115
                                                double OldBY = currItem->BoundingY;
116
                                                if (!currItem->ChangedMasterItem)
117
                                                {
118
                                                        currItem->setXPos(OldX - Mp->xOffset() + page->xOffset());
119
                                                        currItem->setYPos(OldY - Mp->yOffset() + page->yOffset());
120
                                                        currItem->BoundingX = OldBX - Mp->xOffset() + page->xOffset();
121
                                                        currItem->BoundingY = OldBY - Mp->yOffset() + page->yOffset();
122
                                                }
123
                                                QRect oldR(currItem->getRedrawBounding(m_scale));
124
                                                if (clip.intersects(oldR))
125
                                                {
126
                                                        painter->setZoomFactor(m_scale);
127
                                                        painter->save();
128
                                                        painter->translate(currItem->xPos() * m_scale, currItem->yPos() * m_scale);
129
                                                        painter->rotate(currItem->rotation());
130
                                                        if (currItem->lineColor() != "None")
131
                                                        {
132
                                                                ScColorShade tmp( m_doc->PageColors[currItem->lineColor()], currItem->lineShade());
133
                                                                if ((currItem->TopLine) || (currItem->RightLine) || (currItem->BottomLine) || (currItem->LeftLine))
134
                                                                {
135
                                                                        painter->setPen(tmp, currItem->Pwidth, currItem->PLineArt, Qt::SquareCap, currItem->PLineJoin);
136
                                                                        if (currItem->TopLine)
137
                                                                                painter->drawLine(FPoint(0.0, 0.0), FPoint(currItem->width(), 0.0));
138
                                                                        if (currItem->RightLine)
139
                                                                                painter->drawLine(FPoint(currItem->width(), 0.0), FPoint(currItem->width(), currItem->height()));
140
                                                                        if (currItem->BottomLine)
141
                                                                                painter->drawLine(FPoint(currItem->width(), currItem->height()), FPoint(0.0, currItem->height()));
142
                                                                        if (currItem->LeftLine)
143
                                                                                painter->drawLine(FPoint(0.0, currItem->height()), FPoint(0.0, 0.0));
144
                                                                }
145
                                                        }
146
                                                        painter->restore();
147
                                                }
148
                                                if (!currItem->ChangedMasterItem)
149
                                                {
150
                                                        currItem->setXPos(OldX);
151
                                                        currItem->setYPos(OldY);
152
                                                        currItem->BoundingX = OldBX;
153
                                                        currItem->BoundingY = OldBY;
154
                                                }
155
                                        }
156
                                }
157
                                Lnr++;
158
                        }
159
                }
160
        }
161
        painter->setZoomFactor(z);
162
}
163
 
164
void ScPageOutput::DrawPageItems(ScPainterExBase *painter, Page *page, QRect clip)
165
{
166
        //linkedFramesToShow.clear();
167
        double z = painter->zoomFactor();
168
        if (m_doc->Items->count() != 0)
169
        {
170
                QPainter p;
171
                int Lnr=0;
172
                struct Layer ll;
173
                PageItem *currItem;
174
                ll.isViewable = false;
175
                ll.LNr = 0;
176
                uint layerCount = m_doc->layerCount();
177
                //int docCurrPageNo=static_cast<int>(m_doc->currentPageNumber());
178
                int docCurrPageNo=static_cast<int>(page->pageNr());
179
                for (uint la2 = 0; la2 < layerCount; ++la2)
180
                {
181
                        Level2Layer(m_doc, &ll, Lnr);
182
                        bool pr = true;
183
                        if (!ll.isPrintable)
184
                                pr = false;
185
                        if ((ll.isViewable) && (pr))
186
                        {
187
                                QPtrListIterator<PageItem> docItem(*m_doc->Items);
188
                                while ( (currItem = docItem.current()) != 0)
189
                                {
190
                                        ++docItem;
191
                                        if (currItem->LayerNr != ll.LNr)
192
                                                continue;
193
                                        if (!currItem->printable())
194
                                                continue;
195
                                        if ((m_doc->masterPageMode()) && ((currItem->OwnPage != -1) && (currItem->OwnPage != docCurrPageNo)))
196
                                                continue;
197
                                        if (!m_doc->masterPageMode() && !currItem->OnMasterPage.isEmpty())
198
                                        {
199
                                                if (currItem->OnMasterPage != page->PageNam)
200
                                                        continue;
201
                                        }
202
                                        QRect oldR(currItem->getRedrawBounding(m_scale));
203
                                        if (clip.intersects(oldR))
204
                                        {
205
                                                /*if (evSpon)
206
                                                        currItem->Dirty = true;*/
207
                                                /*if (forceRedraw)
208
                                                        currItem->Dirty = false;*/
209
//                                              if ((!Mpressed) || (m_doc->EditClip))
210
                                                        DrawItem( currItem, painter, clip );
211
                                                //currItem->Redrawn = true;
212
                                                if ((currItem->asTextFrame()) && ((currItem->NextBox != 0) || (currItem->BackBox != 0)))
213
                                                {
214
                                                        PageItem *nextItem = currItem;
215
                                                        while (nextItem != 0)
216
                                                        {
217
                                                                if (nextItem->BackBox != 0)
218
                                                                        nextItem = nextItem->BackBox;
219
                                                                else
220
                                                                        break;
221
                                                        }
222
                                                        /*if (linkedFramesToShow.find(nextItem) == -1)
223
                                                                linkedFramesToShow.append(nextItem);*/
224
                                                }
225
                                        }
226
                                }
227
                                QPtrListIterator<PageItem> docItem2(*m_doc->Items);
228
                                while ( (currItem = docItem2.current()) != 0 )
229
                                {
230
                                        ++docItem2;
231
                                        if (currItem->LayerNr != ll.LNr)
232
                                                continue;
233
                                        if (!currItem->isTableItem)
234
                                                continue;
235
                                        QRect oldR(currItem->getRedrawBounding(m_scale));
236
                                        if (clip.intersects(oldR))
237
                                        {
238
                                                painter->setZoomFactor(m_scale);
239
                                                painter->save();
240
                                                painter->translate(currItem->xPos() * m_scale, currItem->yPos() * m_scale);
241
                                                painter->rotate(currItem->rotation());
242
                                                if (currItem->lineColor() != "None")
243
                                                {
244
                                                        ScColorShade tmp( m_doc->PageColors[currItem->lineColor()], currItem->lineShade() );
245
                                                        if ((currItem->TopLine) || (currItem->RightLine) || (currItem->BottomLine) || (currItem->LeftLine))
246
                                                        {
247
                                                                painter->setPen(tmp, currItem->Pwidth, currItem->PLineArt, Qt::SquareCap, currItem->PLineJoin);
248
                                                                if (currItem->TopLine)
249
                                                                        painter->drawLine(FPoint(0.0, 0.0), FPoint(currItem->width(), 0.0));
250
                                                                if (currItem->RightLine)
251
                                                                        painter->drawLine(FPoint(currItem->width(), 0.0), FPoint(currItem->width(), currItem->height()));
252
                                                                if (currItem->BottomLine)
253
                                                                        painter->drawLine(FPoint(currItem->width(), currItem->height()), FPoint(0.0, currItem->height()));
254
                                                                if (currItem->LeftLine)
255
                                                                        painter->drawLine(FPoint(0.0, currItem->height()), FPoint(0.0, 0.0));
256
                                                        }
257
                                                }
258
                                                painter->restore();
259
                                        }
260
                                }
261
                        }
262
                        Lnr++;
263
                }
264
        }
265
        painter->setZoomFactor(z);
266
}
267
 
268
void ScPageOutput::DrawItem( PageItem* item, ScPainterExBase* painter, QRect rect )
269
{
270
        double sc = m_scale;
271
        DrawItem_Pre(item, painter, sc);
272
        PageItem::ItemType itemType = item->itemType();
273
        if( itemType == PageItem::ImageFrame )
274
                DrawItem_ImageFrame( (PageItem_ImageFrame*) item, painter, sc );
275
        else if( itemType == PageItem::Line )
276
                DrawItem_Line( (PageItem_Line*) item, painter );
277
        else if( itemType == PageItem::PathText )
278
                DrawItem_PathText(  (PageItem_PathText*) item, painter, sc );
279
        else if( itemType == PageItem::Polygon )
280
                DrawItem_Polygon( (PageItem_Polygon*) item, painter );
281
        else if( itemType == PageItem::PolyLine )
282
                DrawItem_PolyLine( (PageItem_PolyLine*) item, painter );
283
        else if( itemType == PageItem::TextFrame )
284
                DrawItem_TextFrame( (PageItem_TextFrame*) item, painter, rect, sc);
285
        DrawItem_Post(item, painter);
286
}
287
 
288
void ScPageOutput::DrawItem_Pre( PageItem* item, ScPainterExBase* painter, double scale  )
289
{
290
        double sc = scale;
291
        painter->save();
292
        if (!item->isEmbedded)
293
        {
294
                painter->setZoomFactor(sc);
295
                painter->translate( item->xPos() * sc, item->yPos() * sc);
296
//              painter->rotate(item->rotation());
297
        }
298
        painter->rotate(item->rotation());
299
        painter->setLineWidth(item->Pwidth);
300
        if (item->GrType != 0)
301
        {
302
                painter->setFillMode(ScPainterExBase::Gradient);
303
                painter->fill_gradient = VGradientEx(item->fill_gradient, *m_doc);
304
                QWMatrix grm;
305
                grm.rotate(item->rotation());
306
                FPointArray gra;
307
                switch (item->GrType)
308
                {
309
                        case 1:
310
                        case 2:
311
                        case 3:
312
                        case 4:
313
                        case 6:
314
                                gra.setPoints(2, item->GrStartX, item->GrStartY, item->GrEndX, item->GrEndY);
315
                                gra.map(grm);
316
                                painter->setGradient(VGradientEx::linear, gra.point(0), gra.point(1));
317
                                break;
318
                        case 5:
319
                        case 7:
320
                                gra.setPoints(2, item->GrStartX, item->GrStartY, item->GrEndX, item->GrEndY);
321
                                painter->setGradient(VGradientEx::radial, gra.point(0), gra.point(1), gra.point(0));
322
                                break;
323
                }
324
        }
325
        else
326
        {
327
                painter->fill_gradient = VGradientEx(VGradientEx::linear);
328
                if (item->fillColor() != "None")
329
                {
330
                        painter->setBrush( ScColorShade(m_doc->PageColors[item->fillColor()], item->fillShade()) );
331
                        painter->setFillMode(ScPainterExBase::Solid);
332
                }
333
                else
334
                        painter->setFillMode(ScPainterExBase::None);
335
        }
336
        if (item->lineColor() != "None")
337
        {
338
                if ((item->Pwidth == 0) && !item->asLine())
339
                        painter->setLineWidth(0);
340
                else
341
                {
342
                        ScColorShade tmp(m_doc->PageColors[item->lineColor()], item->lineShade());
343
                        painter->setPen( tmp , item->Pwidth, item->PLineArt, item->PLineEnd, item->PLineJoin);
344
                        if (item->DashValues.count() != 0)
345
                                painter->setDash(item->DashValues, item->DashOffset);
346
                }
347
        }
348
        else
349
                painter->setLineWidth(0);
350
        painter->setBrushOpacity(1.0 - item->fillTransparency());
351
        painter->setPenOpacity(1.0 - item->lineTransparency());
352
}
353
 
354
void ScPageOutput::DrawItem_Post( PageItem* item, ScPainterExBase* painter )
355
{
356
        bool doStroke=true;
357
        if ( item->itemType() == PageItem::PathText || item->itemType() == PageItem::PolyLine || item->itemType() == PageItem::Line )
358
                doStroke=false;
359
        if ((doStroke))
360
        {
361
                if (item->lineColor() != "None")
362
                {
363
                        ScColorShade tmp(m_doc->PageColors[item->lineColor()], item->lineShade());
364
                        painter->setPen(tmp, item->Pwidth, item->PLineArt, item->PLineEnd, item->PLineJoin);
365
                        if (item->DashValues.count() != 0)
366
                                painter->setDash(item->DashValues, item->DashOffset);
367
                }
368
                else
369
                        painter->setLineWidth(0);
370
                if (!item->isTableItem)
371
                {
372
                        painter->setupPolygon(&item->PoLine);
373
                        if (item->NamedLStyle.isEmpty())
374
                                painter->strokePath();
375
                        else
376
                        {
377
                                multiLine ml = m_doc->MLineStyles[item->NamedLStyle];
378
                                for (int it = ml.size()-1; it > -1; it--)
379
                                {
380
                                        ScColorShade tmp( m_doc->PageColors[ml[it].Color], ml[it].Shade );
381
                                        painter->setPen(tmp, ml[it].Width,
382
                                                        static_cast<Qt::PenStyle>(ml[it].Dash),
383
                                                        static_cast<Qt::PenCapStyle>(ml[it].LineEnd),
384
                                                        static_cast<Qt::PenJoinStyle>(ml[it].LineJoin));
385
                                        painter->strokePath();
386
                                }
387
                        }
388
                }
389
        }
390
        if ((!item->isEmbedded))
391
        {
392
                double scpInv = 1.0 / (QMAX(m_scale, 1));
393
        }
394
        item->Tinput = false;
395
        item->FrameOnly = false;
396
        painter->restore();
397
}
398
 
399
void ScPageOutput::DrawCharacters( PageItem* item, ScPainterExBase *painter, struct PageItem::ZZ *hl)
400
{
401
        double csi = static_cast<double>(hl->Siz) / 100.0;
402
        QString ccx = hl->Zeich;
403
        if ((ccx == QChar(13)) || (ccx == QChar(9)) || (ccx == QChar(28)) || (ccx == QChar(27)) || (ccx == QChar(26)))
404
                return;
405
        if (ccx == QChar(29))
406
                ccx = " ";
407
        if (ccx == QChar(24))
408
                ccx = "-";
409
        uint chr = ccx[0].unicode();
410
        if (hl->ZFo->CharWidth.contains(chr))
411
        {
412
                QWMatrix chma, chma2, chma3, chma4, chma5, chma6;
413
                chma.scale(csi, csi);
414
                chma5.scale(painter->zoomFactor(), painter->zoomFactor());
415
                FPointArray gly = hl->ZFo->GlyphArray[chr].Outlines.copy();
416
                if (gly.size() > 3)
417
                {
418
                        chma2.scale(hl->scale / 1000.0, hl->scalev / 1000.0);
419
                        if (item->reversed())
420
                        {
421
                                chma3.scale(-1, 1);
422
                                chma3.translate(-hl->wide, 0);
423
                                chma4.translate(hl->xco, hl->yco-((hl->Siz / 10.0) * (hl->scalev / 1000.0)));
424
                        }
425
                        else
426
                                chma4.translate(hl->xco, hl->yco-((hl->Siz / 10.0) * (hl->scalev / 1000.0)));
427
                        if (hl->base != 0)
428
                                chma6.translate(0, -(hl->Siz / 10.0) * (hl->base / 1000.0) * painter->zoomFactor());
429
                        gly.map(chma * chma2 * chma3 * chma4 * chma5 * chma6);
430
                        painter->setFillMode(1);
431
                        bool fr = painter->fillRule();
432
                        painter->setFillRule(false);
433
                        painter->setupTextPolygon(&gly);
434
                        if ((hl->ZFo->isStroked) && ((hl->Siz * hl->outline / 10000.0) != 0))
435
                        {
436
                                painter->setPen(painter->brush(), 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
437
                                painter->setLineWidth(hl->Siz * hl->outline / 10000.0);
438
                                painter->strokePath();
439
                        }
440
                        else
441
                        {
442
                                if ((hl->Style & 256) && (hl->Farb2 != "None"))
443
                                {
444
                                        painter->save();
445
                                        painter->translate((hl->Siz * hl->shadowX / 10000.0) * painter->zoomFactor(), -(hl->Siz * hl->shadowY / 10000.0) * painter->zoomFactor());
446
                                        ScColorShade tmp = painter->brush();
447
                                        painter->setBrush(painter->pen());
448
                                        painter->setupTextPolygon(&gly); // Necessary if path is not part of the graphic state
449
                                        painter->fillPath();
450
                                        painter->setBrush(tmp);
451
                                        painter->restore();
452
                                        painter->setupTextPolygon(&gly); // Necessary if path is not part of the graphic state
453
                                }
454
                                if (hl->Farb != "None")
455
                                        painter->fillPath();
456
                                if ((hl->Style & 4) && (hl->Farb2 != "None") && ((hl->Siz * hl->outline / 10000.0) != 0))
457
                                {
458
                                        painter->setLineWidth(hl->Siz * hl->outline / 10000.0);
459
                                        painter->strokePath();
460
                                }
461
                        }
462
                        painter->setFillRule(fr);
463
                }
464
                if (hl->Style & 16)
465
                {
466
                        double st, lw;
467
                        if ((hl->strikepos != -1) || (hl->strikewidth != -1))
468
                        {
469
                                if (hl->strikepos != -1)
470
                                        st = (hl->strikepos / 1000.0) * (hl->ZFo->numAscent * (hl->realSiz / 10.0));
471
                                else
472
                                        st = hl->ZFo->strikeout_pos * (hl->realSiz / 10.0);
473
                                if (hl->strikewidth != -1)
474
                                        lw = (hl->strikewidth / 1000.0) * (hl->realSiz / 10.0);
475
                                else
476
                                        lw = QMAX(hl->ZFo->strokeWidth * (hl->realSiz / 10.0), 1);
477
                        }
478
                        else
479
                        {
480
                                st = hl->ZFo->strikeout_pos * (hl->realSiz / 10.0);
481
                                lw = QMAX(hl->ZFo->strokeWidth * (hl->realSiz / 10.0), 1);
482
                        }
483
                        if (hl->base != 0)
484
                                st += (hl->Siz / 10.0) * (hl->base / 1000.0);
485
                        painter->setPen(painter->brush());
486
                        painter->setLineWidth(lw);
487
                        painter->drawLine(FPoint(hl->xco-hl->kern, hl->yco-st), FPoint(hl->xco+hl->wide, hl->yco-st));
488
                }
489
                if ((hl->Style & 8) || ((hl->Style & 512) && (!ccx[0].isSpace())))
490
                {
491
                        double st, lw;
492
                        if ((hl->underpos != -1) || (hl->underwidth != -1))
493
                        {
494
                                if (hl->underpos != -1)
495
                                        st = (hl->underpos / 1000.0) * (hl->ZFo->numDescender * (hl->realSiz / 10.0));
496
                                else
497
                                        st = hl->ZFo->underline_pos * (hl->realSiz / 10.0);
498
                                if (hl->underwidth != -1)
499
                                        lw = (hl->underwidth / 1000.0) * (hl->realSiz / 10.0);
500
                                else
501
                                        lw = QMAX(hl->ZFo->strokeWidth * (hl->realSiz / 10.0), 1);
502
                        }
503
                        else
504
                        {
505
                                st = hl->ZFo->underline_pos * (hl->realSiz / 10.0);
506
                                lw = QMAX(hl->ZFo->strokeWidth * (hl->realSiz / 10.0), 1);
507
                        }
508
                        if (hl->base != 0)
509
                                st += (hl->Siz / 10.0) * (hl->base / 1000.0);
510
                        painter->setPen(painter->brush());
511
                        painter->setLineWidth(lw);
512
                        painter->drawLine(FPoint(hl->xco-hl->kern, hl->yco-st), FPoint(hl->xco+hl->wide, hl->yco-st));
513
                }
514
        }
515
        else
516
        {
517
                ScColorShade colorRed( ScColor(255, 0, 0), 100 );
518
                painter->setLineWidth(1);
519
                painter->setPen(colorRed);
520
                painter->setBrush(colorRed);
521
                painter->setFillMode(1);
522
                painter->drawRect(hl->xco, hl->yco-(hl->Siz / 10.0), (hl->Siz / 10.0)*(hl->scale / 1000.0), (hl->Siz / 10.0));
523
        }
524
}
525
 
526
void ScPageOutput::DrawItem_Embedded( PageItem* item, ScPainterExBase *p, QRect e, struct PageItem::ZZ *hl)
527
{
528
        QPtrList<PageItem> emG;
529
        emG.clear();
530
        if (hl->embedded != 0)
531
        {
532
                if (!m_doc->DoDrawing)
533
                {
534
                        hl->embedded->Redrawn = true;
535
                        hl->embedded->Tinput = false;
536
                        hl->embedded->FrameOnly = false;
537
                        return;
538
                }
539
                emG.append(hl->embedded);
540
                if (hl->embedded->Groups.count() != 0)
541
                {
542
                        for (uint ga=0; ga<m_doc->FrameItems.count(); ++ga)
543
                        {
544
                                if (m_doc->FrameItems.at(ga)->Groups.count() != 0)
545
                                {
546
                                        if (m_doc->FrameItems.at(ga)->Groups.top() == hl->embedded->Groups.top())
547
                                        {
548
                                                if (m_doc->FrameItems.at(ga)->ItemNr != hl->embedded->ItemNr)
549
                                                {
550
                                                        if (emG.find(m_doc->FrameItems.at(ga)) == -1)
551
                                                                emG.append(m_doc->FrameItems.at(ga));
552
                                                }
553
                                        }
554
                                }
555
                        }
556
                }
557
                for (uint em = 0; em < emG.count(); ++em)
558
                {
559
                        PageItem* embedded = emG.at(em);
560
                        struct ParagraphStyle vg;
561
                        QValueList<ParagraphStyle> savedParagraphStyles;
562
                        for (int xxx=0; xxx<5; ++xxx)
563
                        {
564
                                vg.LineSpaMode = m_doc->docParagraphStyles[xxx].LineSpaMode;
565
                                vg.BaseAdj = m_doc->docParagraphStyles[xxx].BaseAdj;
566
                                vg.LineSpa = m_doc->docParagraphStyles[xxx].LineSpa;
567
                                vg.FontSize = m_doc->docParagraphStyles[xxx].FontSize;
568
                                vg.Indent = m_doc->docParagraphStyles[xxx].Indent;
569
                                vg.First = m_doc->docParagraphStyles[xxx].First;
570
                                vg.gapBefore = m_doc->docParagraphStyles[xxx].gapBefore;
571
                                vg.gapAfter = m_doc->docParagraphStyles[xxx].gapAfter;
572
                                savedParagraphStyles.append(vg);
573
                        }
574
                        p->save();
575
                        embedded->setXPos(embedded->xPos() + hl->xco + embedded->gXpos);
576
                        embedded->setYPos(embedded->yPos() + (hl->yco - (embedded->gHeight * (hl->scalev / 1000.0))) + embedded->gYpos);
577
                        p->translate((hl->xco + embedded->gXpos * (hl->scale / 1000.0)) * p->zoomFactor(), (hl->yco - (embedded->gHeight * (hl->scalev / 1000.0)) + embedded->gYpos * (hl->scalev / 1000.0)) * p->zoomFactor());
578
                        if (hl->base != 0)
579
                        {
580
                                p->translate(0, -embedded->gHeight * (hl->base / 1000.0) * p->zoomFactor());
581
                                embedded->setYPos(embedded->yPos() - embedded->gHeight * (hl->base / 1000.0));
582
                        }
583
                        p->scale(hl->scale / 1000.0, hl->scalev / 1000.0);
584
                        //embedded->Dirty = Dirty;
585
                        double sc = 1;
586
                        double pws = embedded->Pwidth;
587
                        DrawItem_Pre(embedded, p, sc);
588
                        switch(embedded->itemType())
589
                        {
590
                                case PageItem::ImageFrame:
591
                                        DrawItem_ImageFrame((PageItem_ImageFrame*) embedded, p, sc);
592
                                        break;
593
                                case PageItem::TextFrame:
594
                                        DrawItem_TextFrame((PageItem_TextFrame*) embedded, p, e, sc);
595
                                        break;
596
                                case PageItem::Line:
597
                                        embedded->Pwidth = pws * QMIN(hl->scale / 1000.0, hl->scalev / 1000.0);
598
                                        DrawItem_Line((PageItem_Line*) embedded, p);
599
                                        break;
600
                                case PageItem::Polygon:
601
                                        DrawItem_Polygon((PageItem_Polygon*) embedded, p);
602
                                        break;
603
                                case PageItem::PolyLine:
604
                                        embedded->Pwidth = pws * QMIN(hl->scale / 1000.0, hl->scalev / 1000.0);
605
                                        DrawItem_PolyLine((PageItem_PolyLine*) embedded, p);
606
                                        break;
607
                                case PageItem::PathText:
608
                                        DrawItem_PathText( (PageItem_PathText*) embedded, p, sc);
609
                                        break;
610
                                default:
611
                                        break;
612
                        }
613
                        embedded->Pwidth = pws * QMIN(hl->scale / 1000.0, hl->scalev / 1000.0);
614
                        DrawItem_Post(embedded, p);
615
                        p->restore();
616
                        embedded->Pwidth = pws;
617
                        for (int xxx=0; xxx<5; ++xxx)
618
                        {
619
                                m_doc->docParagraphStyles[xxx].LineSpaMode = savedParagraphStyles[xxx].LineSpaMode;
620
                                m_doc->docParagraphStyles[xxx].BaseAdj = savedParagraphStyles[xxx].BaseAdj;
621
                                m_doc->docParagraphStyles[xxx].LineSpa = savedParagraphStyles[xxx].LineSpa;
622
                                m_doc->docParagraphStyles[xxx].FontSize = savedParagraphStyles[xxx].FontSize;
623
                                m_doc->docParagraphStyles[xxx].Indent = savedParagraphStyles[xxx].Indent;
624
                                m_doc->docParagraphStyles[xxx].First = savedParagraphStyles[xxx].First;
625
                                m_doc->docParagraphStyles[xxx].gapBefore = savedParagraphStyles[xxx].gapBefore;
626
                                m_doc->docParagraphStyles[xxx].gapAfter = savedParagraphStyles[xxx].gapAfter;
627
                        }
628
                        savedParagraphStyles.clear();
629
                }
630
        }
631
}
632
 
633
void ScPageOutput::DrawItem_ImageFrame( PageItem_ImageFrame* item, ScPainterExBase* painter, double scale  )
634
{
635
        if ((item->fillColor() != "None") || (item->GrType != 0))
636
        {
637
                painter->setupPolygon(&item->PoLine);
638
                painter->fillPath();
639
        }
640
        if (item->Pfile.isEmpty())
641
        {
642
                if ((item->Frame) && (m_doc->guidesSettings.framesShown))
643
                {
644
                        painter->setPen( ScColorShade(Qt::black, 100), 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
645
                        painter->drawLine(FPoint(0, 0), FPoint(item->width(), item->height()));
646
                        painter->drawLine(FPoint(0, item->height()), FPoint(item->width(), 0));
647
                }
648
        }
649
        else
650
        {
651
                if ((!item->PicArt) || (!item->PicAvail))
652
                {
653
                        if ((item->Frame) && (m_doc->guidesSettings.framesShown))
654
                        {
655
                                painter->setPen( ScColorShade(Qt::red, 100), 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
656
                                painter->drawLine(FPoint(0, 0), FPoint(item->width(), item->height()));
657
                                painter->drawLine(FPoint(0, item->height()), FPoint(item->width(), 0));
658
                        }
659
                }
660
                else
661
                {
662
                        ScImage scImg;
663
                        ScImage* pImage = NULL;
664
                        double imScaleX = item->imageXScale();
665
                        double imScaleY = item->imageYScale();
666
                        if( m_reloadImages )
667
                        {
668
                                bool dummy;
669
                                QFileInfo fInfo(item->Pfile);
670
                                QString ext = fInfo.extension(false);
671
                                scImg.imgInfo.valid = false;
672
                                scImg.imgInfo.clipPath = "";
673
                                scImg.imgInfo.PDSpathData.clear();
674
                                scImg.imgInfo.layerInfo.clear();
675
                                scImg.imgInfo.RequestProps = item->pixm.imgInfo.RequestProps;
676
                                scImg.imgInfo.isRequest = item->pixm.imgInfo.isRequest;
677
                                scImg.LoadPicture(item->Pfile, item->IProfile, 0, item->UseEmbedded, m_useProfiles, (int) m_imageMode, m_imageRes, &dummy);
678
                                if( ext == "eps" || ext == "pdf" || ext == "ps" )
679
                                {
680
                                        imScaleX *= (72.0 / (double) m_imageRes);
681
                                        imScaleY *= (72.0 / (double) m_imageRes);
682
                                }
683
                                scImg.applyEffect(item->effectsInUse, m_doc->PageColors, true);
684
                                pImage = &scImg;
685
                        }
686
                        else
687
                                pImage = &item->pixm;
688
 
689
                        painter->save();
690
                        if (item->imageClip.size() != 0)
691
                                painter->setupPolygon(&item->imageClip);
692
                        else
693
                                painter->setupPolygon(&item->PoLine);
694
                        painter->setClipPath();
695
                        if (item->imageFlippedH())
696
                        {
697
                                painter->translate(item->width() * scale, 0);
698
                                painter->scale(-1, 1);
699
                        }
700
                        if (item->imageFlippedV())
701
                        {
702
                                painter->translate(0, item->height() * scale);
703
                                painter->scale(1, -1);
704
                        }
705
                        painter->translate(item->imageXOffset() * item->imageXScale() * scale, item->imageYOffset() * item->imageYScale() * scale);
706
                        //painter->translate(item->LocalX * imScaleX * scale, item->LocalY * imScaleY * scale); ??
707
                        painter->scale( imScaleX, imScaleY );
708
                        if (pImage->imgInfo.lowResType != 0)
709
                                painter->scale(pImage->imgInfo.lowResScale, pImage->imgInfo.lowResScale);
710
                        painter->drawImage(pImage);
711
                        painter->restore();
712
                }
713
        }
714
}
715
 
716
void ScPageOutput::DrawItem_Line( PageItem_Line* item, ScPainterExBase* painter )
717
{
718
 int startArrowIndex;
719
 int endArrowIndex;
720
 
721
        startArrowIndex = item->startArrowIndex();
722
        endArrowIndex = item->endArrowIndex();
723
 
724
        if (item->NamedLStyle.isEmpty())
725
                painter->drawLine(FPoint(0, 0), FPoint(item->width(), 0));
726
        else
727
        {
728
                multiLine ml = m_doc->MLineStyles[item->NamedLStyle];
729
                for (int it = ml.size()-1; it > -1; it--)
730
                {
731
                        ScColorShade colorShade(m_doc->PageColors[ml[it].Color], ml[it].Shade);
732
                        painter->setPen(colorShade, ml[it].Width,
733
                                                static_cast<Qt::PenStyle>(ml[it].Dash),
734
                                                static_cast<Qt::PenCapStyle>(ml[it].LineEnd),
735
                                                static_cast<Qt::PenJoinStyle>(ml[it].LineJoin));
736
                        painter->drawLine(FPoint(0, 0), FPoint(item->width(), 0));
737
                }
738
        }
739
        if (startArrowIndex != 0)
740
        {
741
                QWMatrix arrowTrans;
742
                FPointArray arrow = ( *m_doc->arrowStyles.at(startArrowIndex - 1) ).points.copy();
743
                arrowTrans.translate( 0, 0 );
744
                arrowTrans.scale( item->lineWidth(), item->lineWidth());
745
                arrowTrans.scale( -1 , 1 );
746
                arrow.map( arrowTrans );
747
                painter->setBrush( painter->pen() );
748
                painter->setBrushOpacity( 1.0 - item->lineTransparency() );
749
                painter->setLineWidth( 0 );
750
                painter->setFillMode(ScPainterExBase::Solid);
751
                painter->setupPolygon( &arrow );
752
                painter->fillPath();
753
        }
754
        if (endArrowIndex != 0)
755
        {
756
                QWMatrix arrowTrans;
757
                FPointArray arrow = (*m_doc->arrowStyles.at(endArrowIndex-1) ).points.copy();
758
                arrowTrans.translate( item->width(), 0 );
759
                arrowTrans.scale( item->lineWidth(), item->lineWidth());
760
                arrow.map( arrowTrans );
761
                painter->setBrush( painter->pen() );
762
                painter->setBrushOpacity( 1.0 - item->lineTransparency() );
763
                painter->setLineWidth( 0 );
764
                painter->setFillMode( ScPainterExBase::Solid );
765
                painter->setupPolygon( &arrow );
766
                painter->fillPath();
767
        }
768
}
769
 
770
void ScPageOutput::DrawItem_PathText( PageItem_PathText* item, ScPainterExBase* painter, double scale )
771
{
772
        uint a;
773
        int chs;
774
        double wide;
775
        QString chx, chx2, chx3;
776
        struct ScText *hl;
777
        struct PageItem::ZZ *Zli;
778
        double dx;
779
        double sp = 0;
780
        double oldSp = 0;
781
        double oCurX = 0;
782
        FPoint point = FPoint(0, 0);
783
        FPoint normal = FPoint(0, 0);
784
        FPoint tangent = FPoint(0, 0);
785
        FPoint extPoint = FPoint(0, 0);
786
        bool ext = false;
787
        bool first = true;
788
        double fsx = 0;
789
        uint seg = 0;
790
        double segLen = 0;
791
        double distCurX;
792
        double CurX = item->textToFrameDistLeft(); // item->CurX = item->textToFrameDistLeft()
793
        double CurY = 0;
794
        if (item->lineColor() != "None" && item->PoShow)
795
        {
796
                painter->setupPolygon(&item->PoLine, false);
797
                painter->strokePath();
798
        }
799
        if (item->itemText.count() != 0)
800
                CurX += item->itemText.at(0)->csize * item->itemText.at(0)->cextra / 10000.0;
801
        segLen = item->PoLine.lenPathSeg(seg);
802
        for (a = 0; a < item->itemText.count(); ++a)
803
        {
804
                CurY = 0;
805
                hl = item->itemText.at(a);
806
                chx = hl->ch;
807
                if ((chx == QChar(30)) || (chx == QChar(13)) || (chx == QChar(9)) || (chx == QChar(28)))
808
                        continue;
809
                chs = hl->csize;
810
                item->SetZeichAttr(hl, &chs, &chx);
811
                if (chx == QChar(29))
812
                        chx2 = " ";
813
                else if (chx == QChar(24))
814
                        chx2 = "-";
815
                else
816
                        chx2 = chx;
817
                if (a < item->itemText.count()-1)
818
                {
819
                        if (item->itemText.at(a+1)->ch == QChar(29))
820
                                chx3 = " ";
821
                        else if (item->itemText.at(a+1)->ch == QChar(24))
822
                                chx3 = "-";
823
                        else
824
                                chx3 = item->itemText.at(a+1)->ch;
825
                        wide = Cwidth(m_doc, hl->cfont, chx2, chs, chx3);
826
                }
827
                else
828
                        wide = Cwidth(m_doc, hl->cfont, chx2, chs);
829
                wide = wide * (hl->cscale / 1000.0);
830
                dx = wide / 2.0;
831
                CurX += dx;
832
                ext = false;
833
                while ( (seg < item->PoLine.size()-3) && (CurX > fsx + segLen))
834
                {
835
                        fsx += segLen;
836
                        seg += 4;
837
                        if (seg > item->PoLine.size()-3)
838
                                break;
839
                        segLen = item->PoLine.lenPathSeg(seg);
840
                        ext = true;
841
                }
842
                if (seg > item->PoLine.size()-3)
843
                        break;
844
                if (CurX > fsx + segLen)
845
                        break;
846
                if (ext)
847
                {
848
                        sp = 0;
849
                        distCurX = item->PoLine.lenPathDist(seg, 0, sp);
850
                        while (distCurX <= ((CurX - oCurX) - (fsx - oCurX)))
851
                        {
852
                                sp += 0.001;
853
                                distCurX = item->PoLine.lenPathDist(seg, 0, sp);
854
                        }
855
                        item->PoLine.pointTangentNormalAt(seg, sp, &point, &tangent, &normal );
856
                        CurX = (CurX - (CurX - fsx)) + distCurX;
857
                        oldSp = sp;
858
                        ext = false;
859
                }
860
                else
861
                {
862
                        if( seg < item->PoLine.size()-3 )
863
                        {
864
                                if (CurX > fsx + segLen)
865
                                        break;
866
                                distCurX = item->PoLine.lenPathDist(seg, oldSp, sp);
867
                                while (distCurX <= (CurX - oCurX))
868
                                {
869
                                        sp += 0.001;
870
                                        if (sp >= 1.0)
871
                                        {
872
                                                sp = 0.9999;
873
                                                break;
874
                                        }
875
                                        distCurX = item->PoLine.lenPathDist(seg, oldSp, sp);
876
                                }
877
                                item->PoLine.pointTangentNormalAt(seg, sp, &point, &tangent, &normal );
878
                                CurX = oCurX + distCurX;
879
                                oldSp = sp;
880
                        }
881
                        else
882
                                break;
883
                }
884
                hl->xp = point.x();
885
                hl->yp = point.y();
886
                hl->PtransX = tangent.x();
887
                hl->PtransY = tangent.y();
888
                hl->PRot = dx;
889
                QWMatrix trafo = QWMatrix( 1, 0, 0, -1, -dx * scale, 0 );
890
                trafo *= QWMatrix( tangent.x(), tangent.y(), tangent.y(), -tangent.x(), point.x() * scale, point.y() * scale);
891
                QWMatrix sca = painter->worldMatrix();
892
                trafo *= sca;
893
                painter->save();
894
                QWMatrix savWM = painter->worldMatrix();
895
                painter->setWorldMatrix(trafo);
896
                Zli = new PageItem::ZZ;
897
                Zli->Zeich = chx;
898
                if (hl->ccolor != "None")
899
                {
900
                        ScColorShade tmp(m_doc->PageColors[hl->ccolor], hl->cshade);
901
                        painter->setBrush(tmp);
902
                }
903
                if (hl->cstroke != "None")
904
                {
905
                        ScColorShade tmp(m_doc->PageColors[hl->cstroke], hl->cshade2);
906
                        painter->setPen(tmp, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
907
                }
908
                Zli->Farb = hl->ccolor;
909
                Zli->Farb2 = hl->cstroke;
910
                Zli->shade = hl->cshade;
911
                Zli->shade2 = hl->cshade2;
912
                Zli->xco = 0;
913
                Zli->yco = item->BaseOffs;
914
                Zli->Sele = hl->cselect;
915
                Zli->Siz = chs;
916
                Zli->realSiz = hl->csize;
917
                Zli->Style = hl->cstyle;
918
                Zli->ZFo = hl->cfont;
919
                Zli->wide = wide;
920
                Zli->kern = hl->csize * hl->cextra / 10000.0;
921
                Zli->scale = hl->cscale;
922
                Zli->scalev = hl->cscalev;
923
                Zli->base = hl->cbase;
924
                Zli->shadowX = hl->cshadowx;
925
                Zli->shadowY = hl->cshadowx;
926
                Zli->outline = hl->coutline;
927
                Zli->underpos = hl->cunderpos;
928
                Zli->underwidth = hl->cunderwidth;
929
                Zli->strikepos = hl->cstrikepos;
930
                Zli->strikewidth = hl->cstrikewidth;
931
                Zli->embedded = 0;
932
                DrawCharacters(item, painter, Zli);
933
                delete Zli;
934
                painter->setWorldMatrix(savWM);
935
                painter->restore();
936
                painter->setZoomFactor(scale);
937
                item->MaxChars = a+1;
938
                oCurX = CurX;
939
                CurX -= dx;
940
                CurX += wide+hl->csize * hl->cextra / 10000.0;
941
                first = false;
942
        }
943
}
944
 
945
void ScPageOutput::DrawItem_Polygon ( PageItem_Polygon* item , ScPainterExBase* painter )
946
{
947
        painter->setupPolygon(&item->PoLine);
948
        painter->fillPath();
949
}
950
 
951
void ScPageOutput::DrawItem_PolyLine( PageItem_PolyLine* item, ScPainterExBase* painter )
952
{
953
 int startArrowIndex;
954
 int endArrowIndex;
955
 
956
        startArrowIndex = item->startArrowIndex();
957
        endArrowIndex = item->endArrowIndex();
958
 
959
        if (item->PoLine.size()>=4)
960
        {
961
                if ((item->fillColor() != "None") || (item->GrType != 0))
962
                {
963
                        FPointArray cli;
964
                        FPoint Start;
965
                        bool firstp = true;
966
                        for (uint n = 0; n < item->PoLine.size()-3; n += 4)
967
                        {
968
                                if (firstp)
969
                                {
970
                                        Start = item->PoLine.point(n);
971
                                        firstp = false;
972
                                }
973
                                if (item->PoLine.point(n).x() > 900000)
974
                                {
975
                                        cli.addPoint(item->PoLine.point(n-2));
976
                                        cli.addPoint(item->PoLine.point(n-2));
977
                                        cli.addPoint(Start);
978
                                        cli.addPoint(Start);
979
                                        cli.setMarker();
980
                                        firstp = true;
981
                                        continue;
982
                                }
983
                                cli.addPoint(item->PoLine.point(n));
984
                                cli.addPoint(item->PoLine.point(n+1));
985
                                cli.addPoint(item->PoLine.point(n+2));
986
                                cli.addPoint(item->PoLine.point(n+3));
987
                        }
988
                        if (cli.size() > 2)
989
                        {
990
                                FPoint l1 = cli.point(cli.size()-2);
991
                                cli.addPoint(l1);
992
                                cli.addPoint(l1);
993
                                cli.addPoint(Start);
994
                                cli.addPoint(Start);
995
                        }
996
                        painter->setupPolygon(&cli);
997
                        painter->fillPath();
998
                }
999
                painter->setupPolygon(&item->PoLine, false);
1000
                if (item->NamedLStyle.isEmpty())
1001
                        painter->strokePath();
1002
                else
1003
                {
1004
                        multiLine ml = m_doc->MLineStyles[item->NamedLStyle];
1005
                        for (int it = ml.size()-1; it > -1; it--)
1006
                        {
1007
                                ScColorShade tmp(m_doc->PageColors[ml[it].Color], ml[it].Shade);
1008
                                painter->setPen(tmp, ml[it].Width,
1009
                                                        static_cast<Qt::PenStyle>(ml[it].Dash),
1010
                                                        static_cast<Qt::PenCapStyle>(ml[it].LineEnd),
1011
                                                        static_cast<Qt::PenJoinStyle>(ml[it].LineJoin));
1012
                                painter->strokePath();
1013
                        }
1014
                }
1015
                if (startArrowIndex != 0)
1016
                {
1017
                        FPoint Start = item->PoLine.point(0);
1018
                        for (uint xx = 1; xx < item->PoLine.size(); xx += 2)
1019
                        {
1020
                                FPoint Vector = item->PoLine.point(xx);
1021
                                if ((Start.x() != Vector.x()) || (Start.y() != Vector.y()))
1022
                                {
1023
                                        double r = atan2(Start.y()-Vector.y(),Start.x()-Vector.x())*(180.0/M_PI);
1024
                                        QWMatrix arrowTrans;
1025
                                        FPointArray arrow = (*m_doc->arrowStyles.at(startArrowIndex-1)).points.copy();
1026
                                        arrowTrans.translate(Start.x(), Start.y());
1027
                                        arrowTrans.rotate(r);
1028
                                        arrowTrans.scale(item->lineWidth(), item->lineWidth());
1029
                                        arrow.map(arrowTrans);
1030
                                        painter->setBrush(painter->pen());
1031
                                        painter->setBrushOpacity(1.0 - item->lineTransparency());
1032
                                        painter->setLineWidth(0);
1033
                                        painter->setFillMode(ScPainterExBase::Solid);
1034
                                        painter->setupPolygon(&arrow);
1035
                                        painter->fillPath();
1036
                                        break;
1037
                                }
1038
                        }
1039
                }
1040
                if (endArrowIndex != 0)
1041
                {
1042
                        FPoint End = item->PoLine.point(item->PoLine.size()-2);
1043
                        for (uint xx = item->PoLine.size()-1; xx > 0; xx -= 2)
1044
                        {
1045
                                FPoint Vector = item->PoLine.point(xx);
1046
                                if ((End.x() != Vector.x()) || (End.y() != Vector.y()))
1047
                                {
1048
                                        double r = atan2(End.y()-Vector.y(),End.x()-Vector.x())*(180.0/M_PI);
1049
                                        QWMatrix arrowTrans;
1050
                                        FPointArray arrow = (*m_doc->arrowStyles.at(endArrowIndex-1)).points.copy();
1051
                                        arrowTrans.translate(End.x(), End.y());
1052
                                        arrowTrans.rotate(r);
1053
                                        arrowTrans.scale( item->lineWidth(), item->lineWidth() );
1054
                                        arrow.map(arrowTrans);
1055
                                        painter->setBrush(painter->pen());
1056
                                        painter->setBrushOpacity(1.0 - item->lineTransparency());
1057
                                        painter->setLineWidth(0);
1058
                                        painter->setFillMode(ScPainterExBase::Solid);
1059
                                        painter->setupPolygon(&arrow);
1060
                                        painter->fillPath();
1061
                                        break;
1062
                                }
1063
                        }
1064
                }
1065
        }
1066
}
1067
 
1068
void ScPageOutput::DrawItem_TextFrame( PageItem_TextFrame* item, ScPainterExBase* painter, QRect e, double scale )
1069
{
1070
 double CurX = 0; // item->CurX = item->textToFrameDistLeft()
1071
 double CurY = 0;
1072
 
1073
        switch (item->itemType())
1074
        {
1075
                case PageItem::TextFrame:
1076
                {
1077
                        QPainter pp, pf2;
1078
                        PageItem *nextItem;
1079
                        QPoint pt1, pt2;
1080
                        FPoint ColBound;
1081
                        QRegion cm;
1082
                        uint a, nrc, nrc2, startLin;
1083
                        int absa, aSpa, chs, chsd, CurrCol;
1084
                        uint BuPos, LastSP, MaxText;
1085
                        double oldCurY, LastXp, EndX, OFs, OFs2, wide, lineCorr, ColWidth, kernVal, RTabX;
1086
                        QString chx, chx2, chx3;
1087
                        struct ScText *hl;
1088
                        struct PageItem::ZZ *Zli;
1089
                        struct PageItem::ZZ *Zli2;
1090
 
1091
                        bool outs = false;
1092
                        bool fBorder = false;
1093
                        bool RTab = false;
1094
                        bool goNoRoom = false;
1095
                        bool goNextColumn = false;
1096
                        uint StartRT, StartRT2;
1097
                        int TabCode = 0;
1098
                        int HyphenCount = 0;
1099
                        QValueList<PageItem::TabRecord> tTabValues;
1100
                        bool DropCmode = false;
1101
                        bool AbsHasDrop = false;
1102
                        double desc, asce, maxDY, firstDes, desc2, maxDX, tabDist;
1103
                        int DropLines;
1104
                        bool StartOfCol = true;
1105
                        tTabValues.clear();
1106
 
1107
                        for (int xxx=0; xxx<5; ++xxx)
1108
                        {
1109
                                m_doc->docParagraphStyles[xxx].LineSpaMode = item->LineSpMode;
1110
                                if (item->LineSpMode == 2)
1111
                                        m_doc->docParagraphStyles[xxx].BaseAdj = true;
1112
                                else
1113
                                        m_doc->docParagraphStyles[xxx].BaseAdj = false;
1114
                                m_doc->docParagraphStyles[xxx].LineSpa = item->LineSp;
1115
                                m_doc->docParagraphStyles[xxx].FontSize = item->fontSize();
1116
                                m_doc->docParagraphStyles[xxx].Indent = 0;
1117
                                m_doc->docParagraphStyles[xxx].First = 0;
1118
                                m_doc->docParagraphStyles[xxx].gapBefore = 0;
1119
                                m_doc->docParagraphStyles[xxx].gapAfter = 0;
1120
                                m_doc->docParagraphStyles[xxx].textAlignment = xxx;
1121
                        }
1122
 
1123
                        QPtrList<PageItem::ZZ> LiList;
1124
                        LiList.setAutoDelete(true);
1125
                        QRect e2 = QRect(qRound(e.x()  / scale + m_doc->minCanvasCoordinate.x()), qRound(e.y()  / scale + m_doc->minCanvasCoordinate.y()), qRound(e.width() / scale), qRound(e.height() / scale));
1126
                        painter->save();
1127
                        pf2.begin(ScMW->view->viewport());
1128
                        pf2.translate(item->xPos(), item->yPos());
1129
                        pf2.rotate(item->rotation());
1130
                        //painter->translate(item->xPos(), item->yPos());
1131
                        //painter->rotate(item->rotation());
1132
                        if ((item->fillColor() != "None") || (item->GrType != 0))
1133
                        {
1134
                                painter->setupPolygon(&item->PoLine);
1135
                                painter->fillPath();
1136
                        }
1137
                        if (item->lineColor() != "None")
1138
                                lineCorr = item->lineWidth() / 2.0;
1139
                        else
1140
                                lineCorr = 0;
1141
                        if ((item->isAnnotation()) && (item->annotation().Type() == 2) && (!item->Pfile.isEmpty()) && (item->PicAvail) && (item->PicArt) && (item->annotation().UseIcons()))
1142
                        {
1143
                                painter->setupPolygon(&item->PoLine);
1144
                                painter->setClipPath();
1145
                                painter->save();
1146
                                painter->scale(item->imageXScale(), item->imageYScale());
1147
                                painter->translate(static_cast<int>(item->imageXOffset() * item->imageXScale()), static_cast<int>(item->imageYOffset()  * item->imageYScale()));
1148
                                if (!item->pixm.isNull())
1149
                                        painter->drawImage(&item->pixm);
1150
                                painter->restore();
1151
                        }
1152
                        if ((item->itemText.count() != 0))
1153
                        {
1154
                                if (item->imageFlippedH())
1155
                                {
1156
                                        painter->translate(item->width() * scale, 0);
1157
                                        painter->scale(-1, 1);
1158
                                }
1159
                                if (item->imageFlippedV())
1160
                                {
1161
                                        painter->translate(0, item->height() * scale);
1162
                                        painter->scale(1, -1);
1163
                                }
1164
                                struct PageItem::ZZ Zli3;
1165
                                CurrCol = 0;
1166
                                ColWidth = item->columnWidth();
1167
                                ColBound = FPoint((ColWidth + item->ColGap) * CurrCol + item->textToFrameDistLeft() + lineCorr, ColWidth * (CurrCol+1) + item->ColGap * CurrCol + item->textToFrameDistLeft()+lineCorr);
1168
                                ColBound = FPoint(ColBound.x(), ColBound.y() + item->textToFrameDistRight() + lineCorr);
1169
                                tabDist = ColBound.x();
1170
                                uint tabCc = 0;
1171
                                for (a = 0; a < item->itemText.count(); ++a)
1172
                                {
1173
                                        if (a >= item->MaxChars)
1174
                                                break;
1175
                                        hl = item->itemText.at(a);
1176
                                        if (hl->cab < 5)
1177
                                                tTabValues = item->TabValues;
1178
                                        else
1179
                                                tTabValues = m_doc->docParagraphStyles[hl->cab].TabValues;
1180
                                        if (hl->cstyle & 16384)
1181
                                                tabCc = 0;
1182
                                        chx = hl->ch;
1183
                                        if (hl->yp == 0)
1184
                                                continue;
1185
                                        if (hl->ch == QChar(30))
1186
                                                chx = item->ExpandToken(a);
1187
                                        if (hl->ccolor != "None")
1188
                                        {
1189
                                                ScColorShade tmp(m_doc->PageColors[hl->ccolor], hl->cshade);
1190
                                                painter->setBrush(tmp);
1191
                                        }
1192
                                        if (hl->cstroke != "None")
1193
                                        {
1194
                                                ScColorShade tmp(m_doc->PageColors[hl->cstroke], hl->cshade2);
1195
                                                painter->setPen(tmp, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
1196
                                        }
1197
                                        chs = hl->csize;
1198
                                        if (hl->cstyle & 2048)
1199
                                        {
1200
                                                if (m_doc->docParagraphStyles[hl->cab].BaseAdj)
1201
                                                        chs = qRound(10 * ((m_doc->typographicSettings.valueBaseGrid * (m_doc->docParagraphStyles[hl->cab].DropLin-1)+(hl->cfont->numAscent * (m_doc->docParagraphStyles[hl->cab].FontSize / 10.0))) / (RealCHeight(m_doc, hl->cfont, chx, 10))));
1202
                                                else
1203
                                                {
1204
                                                        if (m_doc->docParagraphStyles[hl->cab].LineSpaMode == 0)
1205
                                                                chs = qRound(10 * ((m_doc->docParagraphStyles[hl->cab].LineSpa * (m_doc->docParagraphStyles[hl->cab].DropLin-1)+(hl->cfont->numAscent * (m_doc->docParagraphStyles[hl->cab].FontSize / 10.0))) / (RealCHeight(m_doc, hl->cfont, chx, 10))));
1206
                                                        else
1207
                                                        {
1208
                                                                double currasce = RealFHeight(m_doc, hl->cfont, m_doc->docParagraphStyles[hl->cab].FontSize);
1209
                                                                chs = qRound(10 * ((currasce * (m_doc->docParagraphStyles[hl->cab].DropLin-1)+(hl->cfont->numAscent * (m_doc->docParagraphStyles[hl->cab].FontSize / 10.0))) / RealCHeight(m_doc, hl->cfont, chx, 10)));
1210
                                                        }
1211
                                                }
1212
                                        }
1213
                                        oldCurY = item->SetZeichAttr(hl, &chs, &chx);
1214
                                        if ((chx == QChar(9)) && (tTabValues.count() != 0) && (tabCc < tTabValues.count()) && (!tTabValues[tabCc].tabFillChar.isNull()))
1215
                                        {
1216
                                                QString tabFillCharQStr(tTabValues[tabCc].tabFillChar);
1217
                                                double wt = Cwidth(m_doc, hl->cfont, tabFillCharQStr, chs);
1218
                                                int coun = static_cast<int>((hl->xp - tabDist) / wt);
1219
                                                double sPos = hl->xp - (hl->xp - tabDist) + 1;
1220
                                                desc = hl->cfont->numDescender * (-chs / 10.0);
1221
                                                asce = hl->cfont->numAscent * (chs / 10.0);
1222
                                                Zli3.Zeich = tabFillCharQStr;
1223
                                                Zli3.Farb = hl->ccolor;
1224
                                                Zli3.Farb2 = hl->cstroke;
1225
                                                Zli3.shade = hl->cshade;
1226
                                                Zli3.shade2 = hl->cshade2;
1227
                                                Zli3.yco = hl->yp;
1228
                                                Zli3.Sele = hl->cselect;
1229
                                                Zli3.Siz = chs;
1230
                                                Zli3.realSiz = hl->csize;
1231
                                                Zli3.Style = hl->cstyle;
1232
                                                Zli3.ZFo = hl->cfont;
1233
                                                Zli3.wide = wt;
1234
                                                Zli3.kern = 0;
1235
                                                Zli3.scale = 1000;
1236
                                                Zli3.scalev = 1000;
1237
                                                Zli3.shadowX = hl->cshadowx;
1238
                                                Zli3.shadowY = hl->cshadowy;
1239
                                                Zli3.outline = hl->coutline;
1240
                                                Zli3.base = hl->cbase;
1241
                                                Zli3.underpos = hl->cunderpos;
1242
                                                Zli3.underwidth = hl->cunderwidth;
1243
                                                Zli3.strikepos = hl->cstrikepos;
1244
                                                Zli3.strikewidth = hl->cstrikewidth;
1245
                                                for (int cx = 0; cx < coun; ++cx)
1246
                                                {
1247
                                                        Zli3.xco =  sPos + wt * cx;
1248
                                                        if (e2.intersects(pf2.xForm(QRect(qRound(Zli3.xco),qRound(Zli3.yco-asce), qRound(Zli3.wide+1), qRound(asce+desc)))))
1249
                                                                DrawCharacters(item, painter, &Zli3);
1250
                                                }
1251
                                        }
1252
                                        if (chx == QChar(9))
1253
                                                tabCc++;
1254
                                        Zli3.Zeich = chx;
1255
                                        Zli3.Farb = hl->ccolor;
1256
                                        Zli3.Farb2 = hl->cstroke;
1257
                                        Zli3.shade = hl->cshade;
1258
                                        Zli3.shade2 = hl->cshade2;
1259
                                        Zli3.xco = hl->xp;
1260
                                        Zli3.yco = hl->yp;
1261
                                        Zli3.Sele = hl->cselect;
1262
                                        Zli3.Siz = chs;
1263
                                        Zli3.realSiz = hl->csize;
1264
                                        Zli3.Style = hl->cstyle;
1265
                                        Zli3.ZFo = hl->cfont;
1266
                                        if ((hl->ch == QChar(25)) && (hl->cembedded != 0))
1267
                                                Zli3.wide = (hl->cembedded->gWidth + hl->cembedded->Pwidth) * (hl->cscale / 1000.0);
1268
                                        else
1269
                                                Zli3.wide = Cwidth(m_doc, hl->cfont, chx, hl->csize) * (hl->cscale / 1000.0);
1270
                                        if (hl->cstyle & 16384)
1271
                                                Zli3.kern = 0;
1272
                                        else
1273
                                                Zli3.kern = chs * hl->cextra / 10000.0;
1274
                                        Zli3.scale = hl->cscale;
1275
                                        Zli3.scalev = hl->cscalev;
1276
                                        Zli3.base = hl->cbase;
1277
                                        Zli3.shadowX = hl->cshadowx;
1278
                                        Zli3.shadowY = hl->cshadowy;
1279
                                        Zli3.outline = hl->coutline;
1280
                                        Zli3.underpos = hl->cunderpos;
1281
                                        Zli3.underwidth = hl->cunderwidth;
1282
                                        Zli3.strikepos = hl->cstrikepos;
1283
                                        Zli3.strikewidth = hl->cstrikewidth;
1284
                                        Zli3.embedded = hl->cembedded;
1285
                                        /*if (!m_doc->RePos)*/
1286
                                        {
1287
                                                double xcoZli = Zli3.xco;
1288
                                                desc = Zli3.ZFo->numDescender * (-Zli3.Siz / 10.0);
1289
                                                asce = Zli3.ZFo->numAscent * (Zli3.Siz / 10.0);
1290
                                                if ((((Zli3.Sele) && (item->isSelected())) || (((item->NextBox != 0) || (item->BackBox != 0)) && (Zli3.Sele))) && (m_doc->appMode == modeEdit))
1291
                                                {
1292
                                                        wide = Zli3.wide;
1293
                                                        painter->setFillMode(1);
1294
                                                        painter->setBrush(ScColorShade(Qt::darkBlue, 100));
1295
                                                        painter->setLineWidth(0);
1296
                                                        if ((a > 0) && (Zli3.Zeich == QChar(9)))
1297
                                                        {
1298
                                                                xcoZli = item->itemText.at(a-1)->xp+Cwidth(m_doc, item->itemText.at(a-1)->cfont, item->itemText.at(a-1)->ch, item->itemText.at(a-1)->csize);
1299
                                                                wide = Zli3.xco - xcoZli + Zli3.wide;
1300
                                                        }
1301
                                                        //if (!m_doc->RePos)
1302
                                                                painter->drawRect(xcoZli, qRound(Zli3.yco-asce * (Zli3.scalev / 1000.0)), wide+1, qRound((asce+desc) * (Zli3.scalev / 1000.0)));
1303
                                                        painter->setBrush(ScColorShade(Qt::white, 100));
1304
                                                }
1305
                                                if (Zli3.Farb2 != "None")
1306
                                                {
1307
                                                        ScColorShade tmp(m_doc->PageColors[Zli3.Farb2], Zli3.shade2);
1308
                                                        painter->setPen(tmp, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
1309
                                                }
1310
                                                if (((chx == QChar(13)) || (chx == QChar(28))) && (m_doc->guidesSettings.showControls))
1311
                                                {
1312
                                                        if (e2.intersects(pf2.xForm(QRect(qRound(Zli3.xco+Zli3.wide),qRound(Zli3.yco-asce), qRound(Zli3.wide+1), qRound(asce+desc)))))
1313
                                                        {
1314
                                                                FPointArray points;
1315
                                                                QWMatrix chma, chma2, chma4, chma5;
1316
                                                                double ytrans, xtrans;
1317
                                                                if (chx == QChar(13))
1318
                                                                {
1319
                                                                        points = m_doc->symReturn.copy();
1320
                                                                        if (a > 0)
1321
                                                                                ytrans = item->itemText.at(a-1)->yp-((Zli3.Siz / 10.0) * 0.8);
1322
                                                                        else
1323
                                                                                ytrans = Zli3.yco-m_doc->docParagraphStyles[hl->cab].LineSpa-((Zli3.Siz / 10.0) * 0.8);
1324
                                                                }
1325
                                                                else
1326
                                                                {
1327
                                                                        points = m_doc->symNewLine.copy();
1328
                                                                        if (a > 0)
1329
                                                                                ytrans = item->itemText.at(a-1)->yp-((Zli3.Siz / 10.0) * 0.4);
1330
                                                                        else
1331
                                                                                ytrans = Zli3.yco-m_doc->docParagraphStyles[hl->cab].LineSpa-((Zli3.Siz / 10.0) * 0.4);
1332
                                                                }
1333
                                                                if (hl->cstyle & 16384)
1334
                                                                        xtrans = Zli3.xco;
1335
                                                                else
1336
                                                                {
1337
                                                                        if (a > 0)
1338
                                                                                xtrans = item->itemText.at(a-1)->xp+ Cwidth(m_doc, item->itemText.at(a-1)->cfont, item->itemText.at(a-1)->ch, item->itemText.at(a-1)->csize);
1339
                                                                        else
1340
                                                                                xtrans = Zli3.xco;
1341
                                                                }
1342
                                                                chma4.translate(xtrans, ytrans);
1343
                                                                chma.scale(Zli3.Siz / 100.0, Zli3.Siz / 100.0);
1344
                                                                chma2.scale(Zli3.scale / 1000.0, Zli3.scalev / 1000.0);
1345
                                                                chma5.scale(painter->zoomFactor(), painter->zoomFactor());
1346
                                                                points.map(chma * chma2 * chma4 * chma5);
1347
                                                                painter->setupTextPolygon(&points);
1348
                                                                painter->setFillMode(1);
1349
                                                                painter->fillPath();
1350
                                                        }
1351
                                                }
1352
                                                if (e2.intersects(pf2.xForm(QRect(qRound(Zli3.xco),qRound(Zli3.yco-asce), qRound(Zli3.wide+1), qRound(asce+desc)))))
1353
                                                {
1354
                                                        if (Zli3.Zeich == QChar(25))
1355
                                                                DrawItem_Embedded(item, painter, e, &Zli3);
1356
                                                        else
1357
                                                                DrawCharacters(item, painter, &Zli3);
1358
                                                }
1359
                                                if (hl->cstyle & 8192)
1360
                                                {
1361
                                                        Zli3.Zeich = "-";
1362
                                                        Zli3.xco = Zli3.xco + Zli3.wide;
1363
                                                        if (e2.intersects(pf2.xForm(QRect(qRound(Zli3.xco),qRound(Zli3.yco-asce), qRound(Zli3.wide+1), qRound(asce+desc)))))
1364
                                                                DrawCharacters(item, painter, &Zli3);
1365
                                                }
1366
                                        }
1367
                                        tabDist = Zli3.xco+Zli3.wide;
1368
                                }
1369
                                //Dirty = false;
1370
                                //Redrawn = true;
1371
                                pf2.end();
1372
                                painter->restore();
1373
                                break;
1374
                        }
1375
                        if ((item->itemText.count() != 0) || (item->NextBox != 0))
1376
                        {
1377
                                if (item->NextBox != 0)
1378
                                {
1379
                                        nextItem = item->NextBox;
1380
                                        while (nextItem != 0)
1381
                                        {
1382
                                                a = nextItem->itemText.count();
1383
                                                for (uint s=0; s<a; ++s)
1384
                                                {
1385
                                                        item->itemText.append(nextItem->itemText.take(0));
1386
                                                }
1387
                                                nextItem->MaxChars = 0;
1388
                                                nextItem = nextItem->NextBox;
1389
                                        }
1390
                                        nextItem = item->NextBox;
1391
                                }
1392
                                m_doc->docParagraphStyles[0].LineSpa = item->LineSp;
1393
                                QRegion cl = QRegion(pf2.xForm(item->Clip));
1394
                                int LayerLev = m_doc->layerLevelFromNumber(item->LayerNr);
1395
                                uint docItemsCount=m_doc->Items->count();
1396
                                if (!item->isEmbedded)
1397
                                {
1398
                                        if (!item->OnMasterPage.isEmpty())
1399
                                        {
1400
                                                Page* Mp = m_doc->MasterPages.at(m_doc->MasterNames[item->OnMasterPage]);
4418 cbradney 1401
                                                Page* Dp = m_doc->Pages->at(item->savedOwnPage);
4360 cbradney 1402
                                                for (a = 0; a < m_doc->MasterItems.count(); ++a)
1403
                                                {
1404
                                                        PageItem* docItem = m_doc->MasterItems.at(a);
1405
                                                        int LayerLevItem = m_doc->layerLevelFromNumber(docItem->LayerNr);
1406
                                                        if (((docItem->ItemNr > item->ItemNr) && (docItem->LayerNr == item->LayerNr)) || (LayerLevItem > LayerLev))
1407
                                                        {
1408
                                                                if (docItem->textFlowsAroundFrame())
1409
                                                                {
1410
                                                                        pp.begin(ScMW->view->viewport());
1411
                                                                        pp.translate(docItem->xPos() - Mp->xOffset() + Dp->xOffset(), docItem->yPos() - Mp->yOffset() + Dp->yOffset());
1412
                                                                        pp.rotate(docItem->rotation());
1413
                                                                        if (docItem->textFlowUsesBoundingBox())
1414
                                                                        {
1415
                                                                                QPointArray tcli;
1416
                                                                                tcli.resize(4);
1417
                                                                                tcli.setPoint(0, QPoint(0,0));
1418
                                                                                tcli.setPoint(1, QPoint(qRound(docItem->width()), 0));
1419
                                                                                tcli.setPoint(2, QPoint(qRound(docItem->width()), qRound(docItem->height())));
1420
                                                                                tcli.setPoint(3, QPoint(0, qRound(docItem->height())));
1421
                                                                                cm = QRegion(pp.xForm(tcli));
1422
                                                                        }
1423
                                                                        else
1424
                                                                        {
1425
                                                                                if ((docItem->textFlowUsesContourLine()) && (docItem->ContourLine.size() != 0))
1426
                                                                                {
1427
                                                                                        QValueList<uint> Segs;
1428
                                                                                        QPointArray Clip2 = FlattenPath(docItem->ContourLine, Segs);
1429
                                                                                        cm = QRegion(pp.xForm(Clip2));
1430
                                                                                }
1431
                                                                                else
1432
                                                                                        cm = QRegion(pp.xForm(docItem->Clip));
1433
                                                                        }
1434
                                                                        pp.end();
1435
                                                                        cl = cl.subtract(cm);
1436
                                                                }
1437
                                                        }
1438
                                                }
4418 cbradney 1439
                                                if (!m_doc->masterPageMode())
4360 cbradney 1440
                                                {
4418 cbradney 1441
                                                        for (a = 0; a < docItemsCount; ++a)
4360 cbradney 1442
                                                        {
4418 cbradney 1443
                                                                PageItem* docItem = m_doc->Items->at(a);
1444
                                                                Page* Mp = m_doc->MasterPages.at(m_doc->MasterNames[item->OnMasterPage]);
1445
                                                                Page* Dp = m_doc->Pages->at(item->OwnPage);
1446
                                                                if (docItem->textFlowsAroundFrame() && (docItem->OwnPage == item->OwnPage))
4360 cbradney 1447
                                                                {
4418 cbradney 1448
                                                                        pp.begin(ScMW->view->viewport());
1449
                                                                        pp.translate(docItem->xPos() - Mp->xOffset() + Dp->xOffset(), docItem->yPos() - Mp->yOffset() + Dp->yOffset());
1450
                                                                        pp.rotate(docItem->rotation());
1451
                                                                        if (docItem->textFlowUsesBoundingBox())
4360 cbradney 1452
                                                                        {
4418 cbradney 1453
                                                                                QPointArray tcli(4);
1454
                                                                                tcli.setPoint(0, QPoint(0,0));
1455
                                                                                tcli.setPoint(1, QPoint(qRound(docItem->width()), 0));
1456
                                                                                tcli.setPoint(2, QPoint(qRound(docItem->width()), qRound(docItem->height())));
1457
                                                                                tcli.setPoint(3, QPoint(0, qRound(docItem->height())));
1458
                                                                                cm = QRegion(pp.xForm(tcli));
4360 cbradney 1459
                                                                        }
1460
                                                                        else
4418 cbradney 1461
                                                                        {
1462
                                                                                if ((docItem->textFlowUsesContourLine()) && (docItem->ContourLine.size() != 0))
1463
                                                                                {
1464
                                                                                        QValueList<uint> Segs;
1465
                                                                                        QPointArray Clip2 = FlattenPath(docItem->ContourLine, Segs);
1466
                                                                                        cm = QRegion(pp.xForm(Clip2));
1467
                                                                                }
1468
                                                                                else
1469
                                                                                        cm = QRegion(pp.xForm(docItem->Clip));
1470
                                                                        }
1471
                                                                        pp.end();
1472
                                                                        cl = cl.subtract(cm);
4360 cbradney 1473
                                                                }
1474
                                                        }
1475
                                                }
1476
                                        }
4418 cbradney 1477
                                        else
4360 cbradney 1478
                                        {
4418 cbradney 1479
                                                for (a = 0; a < docItemsCount; ++a)
4360 cbradney 1480
                                                {
4418 cbradney 1481
                                                        PageItem* docItem = m_doc->Items->at(a);
1482
                                                        int LayerLevItem = m_doc->layerLevelFromNumber(docItem->LayerNr);
1483
                                                        if (((docItem->ItemNr > item->ItemNr) && (docItem->LayerNr == item->LayerNr)) || (LayerLevItem > LayerLev))
4360 cbradney 1484
                                                        {
4418 cbradney 1485
                                                                if (docItem->textFlowsAroundFrame())
4360 cbradney 1486
                                                                {
4418 cbradney 1487
                                                                        pp.begin(ScMW->view->viewport());
1488
                                                                        pp.translate(docItem->xPos(), docItem->yPos());
1489
                                                                        pp.rotate(docItem->rotation());
1490
                                                                        if (docItem->textFlowUsesBoundingBox())
4360 cbradney 1491
                                                                        {
4418 cbradney 1492
                                                                                QPointArray tcli;
1493
                                                                                tcli.resize(4);
1494
                                                                                tcli.setPoint(0, QPoint(0,0));
1495
                                                                                tcli.setPoint(1, QPoint(qRound(docItem->width()), 0));
1496
                                                                                tcli.setPoint(2, QPoint(qRound(docItem->width()), qRound(docItem->height())));
1497
                                                                                tcli.setPoint(3, QPoint(0, qRound(docItem->height())));
1498
                                                                                cm = QRegion(pp.xForm(tcli));
4360 cbradney 1499
                                                                        }
1500
                                                                        else
4418 cbradney 1501
                                                                        {
1502
                                                                                if ((docItem->textFlowUsesContourLine()) && (docItem->ContourLine.size() != 0))
1503
                                                                                {
1504
                                                                                        QValueList<uint> Segs;
1505
                                                                                        QPointArray Clip2 = FlattenPath(docItem->ContourLine, Segs);
1506
                                                                                        cm = QRegion(pp.xForm(Clip2));
1507
                                                                                }
1508
                                                                                else
1509
                                                                                        cm = QRegion(pp.xForm(docItem->Clip));
1510
                                                                        }
1511
                                                                        pp.end();
1512
                                                                        cl = cl.subtract(cm);
4360 cbradney 1513
                                                                }
1514
                                                        }
1515
                                                }
1516
                                        }
1517
                                }
1518
                                if (item->imageFlippedH())
1519
                                {
1520
                                        painter->translate(item->width() * scale, 0);
1521
                                        painter->scale(-1, 1);
1522
                                        pf2.translate(item->width(), 0);
1523
                                        pf2.scale(-1, 1);
1524
                                }
1525
                                if (item->imageFlippedV())
1526
                                {
1527
                                        painter->translate(0, item->height() * scale);
1528
                                        painter->scale(1, -1);
1529
                                        pf2.translate(0, item->height());
1530
                                        pf2.scale(1, -1);
1531
                                }
1532
                                CurrCol = 0;
1533
                                //ColWidth = (item->width() - (item->ColGap * (item->Cols - 1)) - item->textToFrameDistLeft() - item->textToFrameDistRight() - 2*lineCorr) / item->Cols;
1534
                                ColWidth = item->columnWidth();
1535
                                ColBound = FPoint((ColWidth + item->ColGap) * CurrCol + item->textToFrameDistLeft() + lineCorr, ColWidth * (CurrCol+1) + item->ColGap * CurrCol + item->textToFrameDistLeft() + lineCorr);
1536
                                ColBound = FPoint(ColBound.x(), ColBound.y() + item->textToFrameDistRight() + lineCorr);
1537
                                CurX = ColBound.x();
1538
                                if (item->itemText.count() > 0)
1539
                                {
1540
                                        hl = item->itemText.at(0);
1541
                                        if (m_doc->docParagraphStyles[hl->cab].Drop)
1542
                                        {
1543
                                                if (m_doc->docParagraphStyles[hl->cab].BaseAdj)
1544
                                                        chs = qRound(m_doc->typographicSettings.valueBaseGrid  * m_doc->docParagraphStyles[hl->cab].DropLin * 10);
1545
                                                else
1546
                                                        chs = qRound(m_doc->docParagraphStyles[hl->cab].LineSpa * m_doc->docParagraphStyles[hl->cab].DropLin * 10);
1547
                                        }
1548
                                        else
1549
                                                chs = hl->csize;
1550
                                        desc2 = -hl->cfont->numDescender * (chs / 10.0);
1551
                                        CurY = item->textToFrameDistTop() + lineCorr;
1552
                                }
1553
                                else
1554
                                {
1555
                                        desc2 = -(*m_doc->AllFonts)[item->font()]->numDescender * (item->fontSize() / 10.0);
1556
                                        CurY = m_doc->docParagraphStyles[0].LineSpa + item->textToFrameDistTop() + lineCorr - desc2;
1557
                                }
1558
                                firstDes = desc2;
1559
                                LiList.clear();
1560
                                BuPos = 0;
1561
                                LastSP = 0;
1562
                                LastXp = 0;
1563
                                outs = false;
1564
                                OFs = 0;
1565
                                OFs2 = 0;
1566
                                aSpa = 0;
1567
                                absa = 0;
1568
                                item->MaxChars = 0;
1569
                                tabDist = 0;
1570
                                MaxText = item->itemText.count();
1571
                                StartOfCol = true;
1572
                                for (a = 0; a < MaxText; ++a)
1573
                                {
1574
                                        hl = item->itemText.at(a);
1575
                                        chx = hl->ch;
1576
                                        if (hl->ch == QChar(30))
1577
                                                chx = item->ExpandToken(a);
1578
                                        absa = hl->cab;
1579
                                        if (m_doc->docParagraphStyles[absa].LineSpaMode == 1)
1580
                                                m_doc->docParagraphStyles[absa].LineSpa = RealFHeight(m_doc, hl->cfont, hl->csize);
1581
                                        if (a == 0)
1582
                                        {
1583
                                                if (item->BackBox != 0)
1584
                                                {
1585
                                                        nextItem = item->BackBox;
1586
                                                        while (nextItem != 0)
1587
                                                        {
1588
                                                                uint nextItemTextCount=nextItem->itemText.count();
1589
                                                                if (nextItemTextCount != 0)
1590
                                                                {
1591
                                                                        if (nextItem->itemText.at(nextItemTextCount-1)->ch == QChar(13))
1592
                                                                        {
1593
                                                                                CurY += m_doc->docParagraphStyles[absa].gapBefore;
1594
                                                                                if (chx != QChar(13))
1595
                                                                                {
1596
                                                                                        DropCmode = m_doc->docParagraphStyles[absa].Drop;
1597
                                                                                        if (DropCmode)
1598
                                                                                                DropLines = m_doc->docParagraphStyles[absa].DropLin;
1599
                                                                                }
1600
                                                                                else
1601
                                                                                        DropCmode = false;
1602
                                                                                break;
1603
                                                                        }
1604
                                                                        else
1605
                                                                                break;
1606
                                                                }
1607
                                                                nextItem = nextItem->BackBox;
1608
                                                        }
1609
                                                }
1610
                                                else
1611
                                                {
1612
                                                        if (chx != QChar(13))
1613
                                                        {
1614
                                                                DropCmode = m_doc->docParagraphStyles[absa].Drop;
1615
                                                                if (DropCmode)
1616
                                                                        DropLines = m_doc->docParagraphStyles[absa].DropLin;
1617
                                                        }
1618
                                                        else
1619
                                                                DropCmode = false;
1620
                                                        CurY += m_doc->docParagraphStyles[absa].gapBefore;
1621
                                                }
1622
                                        }
1623
                                        hl->cstyle &= 0xF7FF; // 2047;
1624
                                        hl->cstyle &= 8191;
1625
                                        if (((m_doc->docParagraphStyles[absa].textAlignment == 3) || (m_doc->docParagraphStyles[absa].textAlignment == 4)) && (LiList.count() == 0) && (hl->ch == " "))
1626
                                        {
1627
                                                hl->cstyle |= 4096;
1628
                                                continue;
1629
                                        }
1630
                                        else
1631
                                                hl->cstyle &= 0xEFFF; // 4095;
1632
                                        if (LiList.count() == 0)
1633
                                        {
1634
                                                if (((a > 0) && (item->itemText.at(a-1)->ch == QChar(13))) || ((a == 0) && (item->BackBox == 0)) && (!StartOfCol))
1635
                                                {
1636
                                                        CurY += m_doc->docParagraphStyles[absa].gapBefore;
1637
                                                        if (chx != QChar(13))
1638
                                                                DropCmode = m_doc->docParagraphStyles[absa].Drop;
1639
                                                        else
1640
                                                                DropCmode = false;
1641
                                                        if (DropCmode)
1642
                                                        {
1643
                                                                DropLines = m_doc->docParagraphStyles[absa].DropLin;
1644
                                                                if (m_doc->docParagraphStyles[hl->cab].BaseAdj)
1645
                                                                        CurY += m_doc->typographicSettings.valueBaseGrid * (DropLines-1);
1646
                                                                else
1647
                                                                {
1648
                                                                        if (m_doc->docParagraphStyles[absa].LineSpaMode == 0)
1649
                                                                                CurY += m_doc->docParagraphStyles[absa].LineSpa * (DropLines-1);
1650
                                                                        else
1651
                                                                                CurY += RealFHeight(m_doc, hl->cfont, m_doc->docParagraphStyles[absa].FontSize) * (DropLines-1);
1652
                                                                }
1653
                                                        }
1654
                                                }
1655
                                        }
1656
                                        if (DropCmode)
1657
                                        {
1658
                                                if (m_doc->docParagraphStyles[hl->cab].BaseAdj)
1659
                                                {
1660
                                                        chsd = qRound(10 * ((m_doc->typographicSettings.valueBaseGrid * (DropLines-1)+(hl->cfont->numAscent * (m_doc->docParagraphStyles[hl->cab].FontSize / 10.0))) / (RealCHeight(m_doc, hl->cfont, chx, 10))));
1661
                                                        chs = qRound(10 * ((m_doc->typographicSettings.valueBaseGrid * (DropLines-1)+(hl->cfont->numAscent * (m_doc->docParagraphStyles[hl->cab].FontSize / 10.0))) / RealCAscent(m_doc, hl->cfont, chx, 10)));
1662
                                                }
1663
                                                else
1664
                                                {
1665
                                                        if (m_doc->docParagraphStyles[absa].LineSpaMode == 0)
1666
                                                        {
1667
                                                                chsd = qRound(10 * ((m_doc->docParagraphStyles[absa].LineSpa * (DropLines-1)+(hl->cfont->numAscent * (m_doc->docParagraphStyles[hl->cab].FontSize / 10.0))) / (RealCHeight(m_doc, hl->cfont, chx, 10))));
1668
                                                                chs = qRound(10 * ((m_doc->docParagraphStyles[absa].LineSpa * (DropLines-1)+(hl->cfont->numAscent * (m_doc->docParagraphStyles[hl->cab].FontSize / 10.0))) / RealCAscent(m_doc, hl->cfont, chx, 10)));
1669
                                                        }
1670
                                                        else
1671
                                                        {
1672
                                                                double currasce = RealFHeight(m_doc, hl->cfont, m_doc->docParagraphStyles[hl->cab].FontSize);
1673
                                                                chsd = qRound(10 * ((currasce * (DropLines-1)+(hl->cfont->numAscent * (m_doc->docParagraphStyles[hl->cab].FontSize / 10.0))) / (RealCHeight(m_doc, hl->cfont, chx, 10))));
1674
                                                                chs = qRound(10 * ((currasce * (DropLines-1)+(hl->cfont->numAscent * (m_doc->docParagraphStyles[hl->cab].FontSize / 10.0))) / RealCAscent(m_doc, hl->cfont, chx, 10)));
1675
                                                        }
1676
                                                }
1677
                                                hl->cstyle |= 2048;
1678
                                        }
1679
                                        else
1680
                                        {
1681
                                                if ((hl->ch == QChar(25)) && (hl->cembedded != 0))
1682
                                                        chs = qRound((hl->cembedded->gHeight + hl->cembedded->Pwidth) * 10);
1683
                                                else
1684
                                                        chs = hl->csize;
1685
                                        }
1686
                                        oldCurY = item->SetZeichAttr(hl, &chs, &chx);
1687
                                        if (chx == QChar(29))
1688
                                                chx2 = " ";
1689
                                        else if (chx == QChar(24))
1690
                                                chx2 = "-";
1691
                                        else
1692
                                                chx2 = chx;
1693
                                        if ((hl->ch == QChar(25)) && (hl->cembedded != 0))
1694
                                                wide = hl->cembedded->gWidth + hl->cembedded->Pwidth;
1695
                                        else
1696
                                        {
1697
                                                if (a < MaxText-1)
1698
                                                {
1699
                                                        if (item->itemText.at(a+1)->ch == QChar(29))
1700
                                                                chx3 = " ";
1701
                                                        else if (item->itemText.at(a+1)->ch == QChar(24))
1702
                                                                chx3 = "-";
1703
                                                        else
1704
                                                                chx3 = item->itemText.at(a+1)->ch;
1705
                                                        wide = Cwidth(m_doc, hl->cfont, chx2, chs, chx3);
1706
                                                }
1707
                                                else
1708
                                                        wide = Cwidth(m_doc, hl->cfont, chx2, chs);
1709
                                        }
1710
                                        if (DropCmode)
1711
                                        {
1712
                                                if ((hl->ch == QChar(25)) && (hl->cembedded != 0))
1713
                                                {
1714
                                                        wide = hl->cembedded->gWidth + hl->cembedded->Pwidth;
1715
                                                        if (m_doc->docParagraphStyles[hl->cab].BaseAdj)
1716
                                                                asce = m_doc->typographicSettings.valueBaseGrid * DropLines;
1717
                                                        else
1718
                                                        {
1719
                                                                if (m_doc->docParagraphStyles[absa].LineSpaMode == 0)
1720
                                                                        asce = m_doc->docParagraphStyles[absa].LineSpa * DropLines;
1721
                                                                else
1722
                                                                        asce = RealFHeight(m_doc, hl->cfont, m_doc->docParagraphStyles[absa].FontSize) * DropLines;
1723
                                                        }
1724
                                                        hl->cscalev = qRound(asce / (hl->cembedded->gHeight + hl->cembedded->Pwidth) * 1000.0);
1725
                                                        hl->cscale = hl->cscalev;
1726
                                                }
1727
                                                else
1728
                                                {
1729
                                                        wide = RealCWidth(m_doc, hl->cfont, chx2, chsd);
1730
                                                        asce = RealCHeight(m_doc, hl->cfont, chx2, chsd);
1731
                                                }
1732
                                                desc2 = 0;
1733
                                                desc = 0;
1734
                                        }
1735
                                        else
1736
                                        {
1737
                                                if ((hl->ch == QChar(25)) && (hl->cembedded != 0))
1738
                                                {
1739
                                                        asce = hl->cfont->numAscent * (hl->csize / 10.0);
1740
                                                        desc2 = 0;
1741
                                                        desc = 0;
1742
                                                }
1743
                                                else
1744
                                                {
1745
                                                        desc2 = -hl->cfont->numDescender * (hl->csize / 10.0);
1746
                                                        desc = -hl->cfont->numDescender * (hl->csize / 10.0);
1747
                                                        asce = hl->cfont->numAscent * (hl->csize / 10.0);
1748
                                                }
1749
                                        }
1750
                                        wide = wide * (hl->cscale / 1000.0);
1751
                                        fBorder = false;
1752
                                        if (CurY + item->textToFrameDistBottom() + lineCorr > item->height())
1753
                                        {
1754
                                                StartOfCol = true;
1755
                                                CurrCol++;
1756
                                                if (CurrCol < item->Cols)
1757
                                                {
1758
                                                        //ColWidth = (item->width() - (item->ColGap * (item->Cols - 1)) - item->textToFrameDistLeft() - item->textToFrameDistRight() - 2*lineCorr) / item->Cols;
1759
                                                        ColWidth = item->columnWidth();
1760
                                                        ColBound = FPoint((ColWidth + item->ColGap) * CurrCol + item->textToFrameDistLeft() + lineCorr, ColWidth * (CurrCol+1) + item->ColGap * CurrCol + item->textToFrameDistLeft() + lineCorr);
1761
                                                        CurX = ColBound.x();
1762
                                                        ColBound = FPoint(ColBound.x(), ColBound.y() + item->textToFrameDistRight() + lineCorr);
1763
                                                        CurY = asce + item->textToFrameDistTop() + lineCorr + 1;
1764
                                                        if (((a > 0) && (item->itemText.at(a-1)->ch == QChar(13))) || ((a == 0) && (item->BackBox == 0)))
1765
                                                        {
1766
                                                                if (chx != QChar(13))
1767
                                                                        DropCmode = m_doc->docParagraphStyles[hl->cab].Drop;
1768
                                                                else
1769
                                                                        DropCmode = false;
1770
                                                                if (DropCmode)
1771
                                                                {
1772
                                                                        if (m_doc->docParagraphStyles[hl->cab].BaseAdj)
1773
                                                                                desc2 = -hl->cfont->numDescender * m_doc->typographicSettings.valueBaseGrid * m_doc->docParagraphStyles[hl->cab].DropLin;
1774
                                                                        else
1775
                                                                                desc2 = -hl->cfont->numDescender * m_doc->docParagraphStyles[hl->cab].LineSpa * m_doc->docParagraphStyles[hl->cab].DropLin;
1776
                                                                }
1777
                                                                if (DropCmode)
1778
                                                                        DropLines = m_doc->docParagraphStyles[hl->cab].DropLin;
1779
                                                        }
1780
                                                        if (m_doc->docParagraphStyles[hl->cab].BaseAdj)
1781
                                                        {
1782
                                                                double by = item->yPos();
1783
                                                                if (item->OwnPage != -1)
1784
                                                                        by = item->yPos() - m_doc->Pages->at(item->OwnPage)->yOffset();
1785
                                                                int ol1 = qRound((by + CurY - m_doc->typographicSettings.offsetBaseGrid) * 10000.0);
1786
                                                                int ol2 = static_cast<int>(ol1 / m_doc->typographicSettings.valueBaseGrid);
1787
                                                                CurY = ceil(  ol2 / 10000.0 ) * m_doc->typographicSettings.valueBaseGrid + m_doc->typographicSettings.offsetBaseGrid - by;
1788
                                                        }
1789
                                                }
1790
                                                else
1791
                                                {
1792
                                                        nrc = a;
1793
                                                        goto NoRoom;
1794
                                                }
1795
                                        }
1796
                                        if (LiList.isEmpty())
1797
                                        {
1798
                                                startLin = a;
1799
                                                double TopOffset = asce;
1800
                                                double BotOffset = desc2;
1801
                                                goNoRoom = false;
1802
                                                if (StartOfCol)
1803
                                                {
1804
                                                        CurY = asce + item->textToFrameDistTop() + lineCorr+1;
1805
//                                                      if (((a > 0) && (item->itemText.at(a-1)->ch == QChar(13))) || ((a == 0) && (BackBox == 0)))
1806
//                                                              CurY += m_doc->docParagraphStyles[hl->cab].gapBefore;
1807
                                                }
1808
                                                if (m_doc->docParagraphStyles[hl->cab].BaseAdj)
1809
                                                {
1810
                                                        double by = item->yPos();
1811
                                                        if (item->OwnPage != -1)
1812
                                                                by = item->yPos() - m_doc->Pages->at(item->OwnPage)->yOffset();
1813
                                                        int ol1 = qRound((by + CurY - m_doc->typographicSettings.offsetBaseGrid) * 10000.0);