Subversion Repositories Scribus

Rev

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