Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
8 paul 1
/***************************************************************************
2
                          util.cpp  -  description
3
                             -------------------
4
    begin                : Fri Sep 14 2001
5
    copyright            : (C) 2001 by Franz Schmid
6
    email                : Franz.Schmid@altmuehlnet.de
7
 ***************************************************************************/
8
 
9
/***************************************************************************
10
 *                                                                         *
11
 *   This program is free software; you can redistribute it and/or modify  *
12
 *   it under the terms of the GNU General Public License as published by  *
13
 *   the Free Software Foundation; either version 2 of the License, or     *
14
 *   (at your option) any later version.                                   *
15
 *                                                                         *
16
 ***************************************************************************/
9 Franz 17
 
8 paul 18
#include <qstring.h>
19
#include <qpixmap.h>
20
#include <qbitmap.h>
21
#include <qpainter.h>
22
#include <qfile.h>
23
#include <qfileinfo.h>
24
#include <qtextstream.h>
25
#include <qstringlist.h>
26
#include <qmap.h>
27
#include <qdom.h>
28
#include <qimage.h>
19 Franz 29
#include <qdir.h>
8 paul 30
#include <qpointarray.h>
90 Franz 31
#include <qmessagebox.h>
8 paul 32
#include <cstdlib>
33
#include <cmath>
34
#include "md5.h"
201 Franz 35
#include <setjmp.h>
128 Franz 36
 
37
#if (_MSC_VER >= 1200)
38
 #include "win-config.h"
39
#else
40
 #include "config.h"
41
#endif
42
 
201 Franz 43
extern "C" {
44
#define XMD_H           // shut JPEGlib up
45
#if defined(Q_OS_UNIXWARE)
46
#  define HAVE_BOOLEAN  // libjpeg under Unixware seems to need this
47
#endif
48
#include <jpeglib.h>
49
#include <jerror.h>
50
#undef HAVE_STDLIB_H
51
#ifdef const
52
#  undef const          // remove crazy C hackery in jconfig.h
53
#endif
54
}
55
 
8 paul 56
#include "scribusdoc.h"
57
#include "libpdf/pdflib.h"
68 Franz 58
#include <ft2build.h>
59
#include FT_FREETYPE_H
60
#include FT_OUTLINE_H
61
#include FT_GLYPH_H
8 paul 62
#ifdef HAVE_LIBZ
63
        #include <zlib.h>
64
#endif
65
#ifdef HAVE_TIFF
66
        #include <tiffio.h>
67
#endif
68
#ifdef HAVE_CMS
44 Franz 69
        #include CMS_INC
8 paul 70
extern cmsHPROFILE CMSoutputProf;
71
extern cmsHPROFILE CMSprinterProf;
72
extern cmsHTRANSFORM stdTrans;
73
extern cmsHTRANSFORM stdProof;
74
extern cmsHTRANSFORM stdTransImg;
75
extern cmsHTRANSFORM stdProofImg;
76
extern bool SoftProofing;
77
extern bool Gamut;
78
extern bool CMSuse;
79
extern int IntentMonitor;
80
extern int IntentPrinter;
81
#endif
82
extern ProfilesL InputProfiles;
83
 
203 Franz 84
void ReOrderText(ScribusDoc *doc, ScribusView *view);
125 Franz 85
void WordAndPara(PageItem* b, int *w, int *p, int *c, int *wN, int *pN, int *cN);
124 Franz 86
void CopyPageItem(struct CLBuf *Buffer, PageItem *b);
90 Franz 87
bool overwrite(QWidget *parent, QString filename);
80 Franz 88
FPointArray traceChar(FT_Face face, uint chr, int chs, double *x, double *y);
95 Franz 89
FPoint GetMaxClipF(FPointArray Clip);
92 Franz 90
QPixmap FontSample(QString da, int s, QString ts, QColor back);
19 Franz 91
QString Path2Relative(QString Path);
20 Franz 92
QPixmap LoadPDF(QString fn, int Seite, int Size, int *w, int *h);
8 paul 93
bool GlyNames(QMap<uint, QString> *GList, QString Dat);
94
bool GlyIndex(QMap<uint, PDFlib::GlNamInd> *GListInd, QString Dat);
95
QByteArray ComputeMD5Sum(QByteArray *in);
96
char *toHex( uchar u );
97
QString String2Hex(QString *in, bool lang = true);
98
QString CompressStr(QString *in);
99
QString ImageToTxt(QImage *im);
100
QString ImageToCMYK(QImage *im);
101
QString ImageToCMYK_PS(QImage *im, int pl, bool pre);
202 Franz 102
void Convert2JPG(QString fn, QImage *image, int Quality, bool isCMYK);
8 paul 103
QString MaskToTxt(QImage *im, bool PDF = true);
203 Franz 104
QString MaskToTxt14(QImage *im);
8 paul 105
void Level2Layer(ScribusDoc *doc, struct Layer *ll, int Level);
106
void BezierPoints(QPointArray *ar, QPoint n1, QPoint n2, QPoint n3, QPoint n4);
80 Franz 107
double xy2Deg(double x, double y);
8 paul 108
QPointArray FlattenPath(FPointArray ina, QValueList<uint> &Segs);
80 Franz 109
QPointArray RegularPolygon(double w, double h, uint c, bool star, double factor, double rota);
110
FPointArray RegularPolygonF(double w, double h, uint c, bool star, double factor, double rota);
8 paul 111
QPixmap loadIcon(QString nam);
112
bool loadText(QString nam, QString *Buffer);
80 Franz 113
double Cwidth(ScribusDoc *doc, QString name, QString ch, int Siz, QString ch2 = " ");
114
double QStodouble(QString in);
8 paul 115
int QStoInt(QString in);
116
QString GetAttr(QDomElement *el, QString at, QString def="0");
201 Franz 117
QImage LoadPict(QString fn, bool *gray = 0);
8 paul 118
#ifdef HAVE_CMS
119
QImage ProofPict(QImage *Im, QString Prof, int Rend, cmsHPROFILE emPr=0);
120
QImage LoadPictCol(QString fn, QString Prof, bool UseEmbedded, bool *realCMYK);
121
#else
122
QImage ProofPict(QImage *Im, QString Prof, int Rend);
123
#endif
124
QImage ProofImage(QImage *Im);
125
 
126
#ifdef HAVE_CMS
127
QImage ProofPict(QImage *Im, QString Prof, int Rend, cmsHPROFILE emPr)
128
#else
129
QImage ProofPict(QImage *Im, QString Prof, int Rend)
130
#endif
131
{
132
        bool emp = false;
133
        if (Prof == "")
134
                return Im->copy();
135
#ifdef HAVE_CMS
136
        QImage out = Im->copy();
137
        if ((CMSuse) && (SoftProofing))
167 Franz 138
        {
8 paul 139
                cmsHTRANSFORM xform;
140
                cmsHPROFILE inputProf;
167 Franz 141
                if (emPr != 0)
142
                        inputProf = emPr;
143
                else
144
                {
145
                        inputProf = cmsOpenProfileFromFile(InputProfiles[Prof], "r");
8 paul 146
                        emp = true;
167 Franz 147
                }
8 paul 148
                int dcmsFlags = 0;
167 Franz 149
                dcmsFlags |= Gamut ? cmsFLAGS_GAMUTCHECK : cmsFLAGS_SOFTPROOFING;
8 paul 150
                xform = cmsCreateProofingTransform(inputProf, TYPE_RGBA_8,
167 Franz 151
                                                                                                 CMSoutputProf, TYPE_RGBA_8,
152
                                                                                                 CMSprinterProf,
153
                                                                                                 IntentPrinter,
154
                                                                                                 Rend, dcmsFlags);
8 paul 155
                for (int i=0; i < out.height(); ++i)
167 Franz 156
                {
8 paul 157
                        LPBYTE ptr = out.scanLine(i);
158
                        cmsDoTransform(xform, ptr, ptr, out.width());
167 Franz 159
                }
8 paul 160
                cmsDeleteTransform(xform);
161
                if (emp)
162
                        cmsCloseProfile(inputProf);
167 Franz 163
        }
8 paul 164
        else
167 Franz 165
        {
166
                if (CMSuse)
8 paul 167
                {
168
                        cmsHTRANSFORM xform;
169
                        cmsHPROFILE inputProf;
167 Franz 170
                        if (emPr != 0)
171
                                inputProf = emPr;
172
                        else
173
                        {
174
                                inputProf = cmsOpenProfileFromFile(InputProfiles[Prof], "r");
8 paul 175
                                emp = true;
167 Franz 176
                        }
8 paul 177
                        xform = cmsCreateTransform(inputProf, TYPE_RGBA_8,
167 Franz 178
                                                                                         CMSoutputProf, TYPE_RGBA_8,
179
                                                                                         Rend,
180
                                                                                         0);
8 paul 181
                        for (int i=0; i < out.height(); ++i)
167 Franz 182
                        {
8 paul 183
                                LPBYTE ptr = out.scanLine(i);
184
                                cmsDoTransform(xform, ptr, ptr, out.width());
167 Franz 185
                        }
8 paul 186
                        cmsDeleteTransform(xform);
187
                        if (emp)
188
                                cmsCloseProfile(inputProf);
189
                }
167 Franz 190
        }
8 paul 191
        return out;
192
#else
193
        return Im->copy();
194
#endif
195
}
196
 
197
QImage ProofImage(QImage *Im)
198
{
199
#ifdef HAVE_CMS
200
        QImage out = Im->copy();
201
        if ((CMSuse) && (SoftProofing))
167 Franz 202
        {
203
                for (int i=0; i < out.height(); ++i)
8 paul 204
                {
205
                        LPBYTE ptr = out.scanLine(i);
206
                        cmsDoTransform(stdProofImg, ptr, ptr, out.width());
207
                }
167 Franz 208
        }
8 paul 209
        else
167 Franz 210
        {
211
                if (CMSuse)
8 paul 212
                {
167 Franz 213
                        for (int i=0; i < out.height(); ++i)
8 paul 214
                        {
215
                                LPBYTE ptr = out.scanLine(i);
216
                                cmsDoTransform(stdTransImg, ptr, ptr, out.width());
217
                        }
218
                }
167 Franz 219
        }
8 paul 220
        return out;
221
#else
222
        return Im->copy();
223
#endif
224
}
225
 
20 Franz 226
QPixmap LoadPDF(QString fn, int Seite, int Size, int *w, int *h)
19 Franz 227
{
228
        QString tmp, cmd1, cmd2;
167 Franz 229
        QString tmpFile = QString(getenv("HOME"))+"/.scribus/sc.png";
19 Franz 230
        QPixmap pm;
231
        int ret = -1;
232
        tmp.setNum(Seite);
159 Franz 233
        cmd1 = "gs -q -dNOPAUSE -sDEVICE=png16m -r72 -sOutputFile="+tmpFile+" -dFirstPage="+tmp+" -dLastPage="+tmp+" ";
19 Franz 234
        cmd2 = " -c showpage -c quit";
86 Franz 235
        ret = system(cmd1 + "\"" + fn + "\"" + cmd2);
19 Franz 236
        if (ret == 0)
167 Franz 237
        {
19 Franz 238
                QImage image;
159 Franz 239
                image.load(tmpFile);
240
                system("rm -f "+tmpFile);
167 Franz 241
                QImage im2;
20 Franz 242
                *h = image.height();
243
                *w = image.width();
80 Franz 244
                double sx = image.width() / static_cast<double>(Size);
245
                double sy = image.height() / static_cast<double>(Size);
167 Franz 246
                double t = (sy < sx ? sx : sy);
247
                im2 = image.smoothScale(static_cast<int>(image.width() / t), static_cast<int>(image.height() / t));
19 Franz 248
                pm.convertFromImage(im2);
249
                QPainter p;
250
                p.begin(&pm);
251
                p.setBrush(Qt::NoBrush);
252
                p.setPen(Qt::black);
253
                p.drawRect(0, 0, pm.width(), pm.height());
254
                p.end();
255
                im2.detach();
167 Franz 256
        }
19 Franz 257
        return pm;
258
}
259
 
201 Franz 260
QImage LoadPict(QString fn, bool *gray)
8 paul 261
{
84 Franz 262
        QString tmp, dummy, cmd1, cmd2, BBox, tmp2;
8 paul 263
        QChar tc;
264
        QImage Bild;
80 Franz 265
        double x, y, b, h;
8 paul 266
        bool found = false;
267
        int ret = -1;
167 Franz 268
        QString tmpFile = QString(getenv("HOME"))+"/.scribus/sc.png";
8 paul 269
        QFileInfo fi = QFileInfo(fn);
270
        QString ext = fi.extension(false).lower();
16 Franz 271
        if (ext == "pdf")
167 Franz 272
        {
159 Franz 273
                cmd1 = "gs -q -dNOPAUSE -sDEVICE=png16m -r72 -sOutputFile="+tmpFile+" -dFirstPage=1 -dLastPage=1 ";
16 Franz 274
                cmd2 = " -c showpage -c quit";
86 Franz 275
                ret = system(cmd1 + "\"" + fn + "\"" + cmd2);
16 Franz 276
                if (ret == 0)
167 Franz 277
                {
16 Franz 278
                        QImage image;
159 Franz 279
                        image.load(tmpFile);
167 Franz 280
                        Bild = image.convertDepth(32);
159 Franz 281
                        system("rm -f "+tmpFile);
16 Franz 282
                }
167 Franz 283
        }
8 paul 284
        if ((ext == "eps") || (ext == "ps"))
167 Franz 285
        {
8 paul 286
                QFile f(fn);
287
                if (f.open(IO_ReadOnly))
167 Franz 288
                {
8 paul 289
                        QTextStream ts(&f);
290
                        while (!ts.atEnd())
167 Franz 291
                        {
8 paul 292
                                tc = ' ';
293
                                tmp = "";
294
                                while ((tc != '\n') && (tc != '\r'))
167 Franz 295
                                {
8 paul 296
                                        ts >> tc;
297
                                        if ((tc != '\n') && (tc != '\r'))
298
                                                tmp += tc;
167 Franz 299
                                }
8 paul 300
                                if (tmp.startsWith("%%BoundingBox"))
167 Franz 301
                                {
8 paul 302
                                        found = true;
303
                                        BBox = tmp;
167 Franz 304
                                }
8 paul 305
                                if (tmp.startsWith("%%EndComments"))
306
                                        break;
167 Franz 307
                        }
8 paul 308
                        f.close();
309
                        if (found)
167 Franz 310
                        {
8 paul 311
                                QTextStream ts2(&BBox, IO_ReadOnly);
312
                                ts2 >> dummy >> x >> y >> b >> h;
159 Franz 313
                                cmd1 = "gs -q -dNOPAUSE -sDEVICE=png16m -r72 -sOutputFile="+tmpFile+" -g";
8 paul 314
                                cmd2 = " -c showpage -c quit";
167 Franz 315
                                ret = system(cmd1 + tmp.setNum(qRound(b)) + "x" + tmp2.setNum(qRound(h)) + " \"" +
316
                                                                fn + "\"" + cmd2);
8 paul 317
                                if (ret == 0)
167 Franz 318
                                {
8 paul 319
                                        QImage image;
159 Franz 320
                                        image.load(tmpFile);
188 Franz 321
                                        image = image.convertDepth(32);
322
                                        image.setAlphaBuffer(true);
8 paul 323
                                        int wi = image.width();
324
                                        int hi = image.height();
188 Franz 325
                                    for( int yi=0; yi < hi; ++yi )
8 paul 326
                                                {
188 Franz 327
                                                QRgb *s = (QRgb*)(image.scanLine( yi ));
328
                                                for(int xi=0; xi < wi; ++xi )
8 paul 329
                                                        {
188 Franz 330
                                                        if((*s) == 0xffffffff)
331
                                                                (*s) &= 0x00ffffff;
332
                                                        s++;
333
                                                        }
334
                                        }
335
                                        Bild = image.copy(static_cast<int>(x), 0, static_cast<int>(b-x), static_cast<int>(h-y));
159 Franz 336
                                        system("rm -f "+tmpFile);
8 paul 337
                                }
338
                        }
339
                }
167 Franz 340
        }
8 paul 341
#ifdef HAVE_TIFF
342
        if (ext == "tif")
167 Franz 343
        {
8 paul 344
                QImage img;
345
                QImage inI2;
346
                TIFF* tif = TIFFOpen(fn, "r");
347
                if(tif)
167 Franz 348
                {
8 paul 349
                        unsigned width, height,size;
350
                        TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width);
351
                        TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height);
352
                        size=width*height;
353
                        uint32 *bits=(uint32*) _TIFFmalloc(size * sizeof (uint32));
354
                        if(bits)
167 Franz 355
                        {
356
                                if (TIFFReadRGBAImage(tif, width, height, bits, 0))
8 paul 357
                                {
189 Franz 358
                                img.create(width,height,32);
359
                                img.setAlphaBuffer(true);
8 paul 360
                                        if(TIFFGetR(0x1234567)==qRed  (0x1234567) &&
361
                                                 TIFFGetG(0x1234567)==qGreen(0x1234567) &&
362
                                                 TIFFGetB(0x1234567)==qBlue (0x1234567))
167 Franz 363
                                        {
8 paul 364
                                                for(unsigned y=0; y<height; ++y)
365
                                                        memcpy(img.scanLine(height-1-y),bits+y*width,width*4);
167 Franz 366
                                        }
8 paul 367
                                        else
167 Franz 368
                                        {
8 paul 369
                                                uint32 *inp=bits;
370
                                                for(unsigned y=0; y<height; ++y)
167 Franz 371
                                                {
8 paul 372
                                                        QRgb *row=(QRgb*) (img.scanLine(height-1-y));
373
                                                        for(unsigned x=0; x<width; ++x)
167 Franz 374
                                                        {
8 paul 375
                                                                const uint32 col=*(inp++);
189 Franz 376
                                                                row[x]=qRgba(TIFFGetR(col), TIFFGetG(col), TIFFGetB(col), TIFFGetA(col));
8 paul 377
                                                        }
378
                                                }
167 Franz 379
                                        }
8 paul 380
                                        Bild = img.copy();
167 Franz 381
                                }
8 paul 382
                                _TIFFfree(bits);
167 Franz 383
                        }
8 paul 384
                        TIFFClose(tif);
385
                }
167 Franz 386
        }
8 paul 387
#endif
388
        else
167 Franz 389
        {
8 paul 390
                Bild.load(fn);
201 Franz 391
                if (gray != 0)
392
                {
202 Franz 393
                        if ((Bild.depth() == 8) && (Bild.isGrayscale()))
201 Franz 394
                                *gray = true;
395
                        else
396
                                *gray = false;
397
                }
167 Franz 398
                Bild = Bild.convertDepth(32);
399
        }
8 paul 400
        return Bild;
401
}
402
 
403
#ifdef HAVE_CMS
404
QImage LoadPictCol(QString fn, QString Prof, bool UseEmbedded, bool *realCMYK)
405
{
84 Franz 406
        QString tmp, dummy, cmd1, cmd2, BBox, tmp2;
8 paul 407
        QChar tc;
408
        QImage Bild;
80 Franz 409
        double x, y, b, h;
8 paul 410
        bool found = false;
411
        int ret = -1;
167 Franz 412
        QString tmpFile = QString(getenv("HOME"))+"/.scribus/sc.png";
8 paul 413
        QFileInfo fi = QFileInfo(fn);
414
        QString ext = fi.extension(false).lower();
16 Franz 415
        if (ext == "pdf")
167 Franz 416
        {
159 Franz 417
                cmd1 = "gs -q -dNOPAUSE -sDEVICE=png16m -r72 -sOutputFile="+tmpFile+" -dFirstPage=1 -dLastPage=1 ";
16 Franz 418
                cmd2 = " -c showpage -c quit";
86 Franz 419
                ret = system(cmd1 + "\"" + fn + "\"" + cmd2);
16 Franz 420
                if (ret == 0)
167 Franz 421
                {
16 Franz 422
                        QImage image;
159 Franz 423
                        image.load(tmpFile);
167 Franz 424
                        Bild = image.convertDepth(32);
159 Franz 425
                        system("rm -f "+tmpFile);
16 Franz 426
                        *realCMYK = false;
427
                }
167 Franz 428
                }
429
                if ((ext == "eps") || (ext == "ps"))
8 paul 430
                {
167 Franz 431
                        QFile f(fn);
432
                        if (f.open(IO_ReadOnly))
8 paul 433
                        {
167 Franz 434
                                QTextStream ts(&f);
435
                                while (!ts.atEnd())
8 paul 436
                                {
167 Franz 437
                                        tc = ' ';
438
                                        tmp = "";
439
                                        while ((tc != '\n') && (tc != '\r'))
8 paul 440
                                        {
167 Franz 441
                                                ts >> tc;
442
                                                if ((tc != '\n') && (tc != '\r'))
443
                                                        tmp += tc;
8 paul 444
                                        }
167 Franz 445
                                        if (tmp.startsWith("%%BoundingBox"))
8 paul 446
                                        {
167 Franz 447
                                                found = true;
448
                                                BBox = tmp;
8 paul 449
                                        }
167 Franz 450
                                        if (tmp.startsWith("%%EndComments"))
451
                                                break;
8 paul 452
                                }
167 Franz 453
                                f.close();
454
                                if (found)
8 paul 455
                                {
167 Franz 456
                                        QTextStream ts2(&BBox, IO_ReadOnly);
457
                                        ts2 >> dummy >> x >> y >> b >> h;
458
                                        cmd1 = "gs -q -dNOPAUSE -sDEVICE=png16m -r72 -sOutputFile="+tmpFile+" -g";
459
                                        cmd2 = " -c showpage -c quit";
460
                                        ret = system(cmd1 + tmp.setNum(qRound(b)) + "x" + tmp2.setNum(qRound(h)) + " \"" +
461
                                                                        fn + "\"" + cmd2);
462
                                        if (ret == 0)
8 paul 463
                                        {
167 Franz 464
                                                QImage image;
465
                                                image.load(tmpFile);
188 Franz 466
                                                image = image.convertDepth(32);
467
                                                image.setAlphaBuffer(true);
167 Franz 468
                                                int wi = image.width();
469
                                                int hi = image.height();
188 Franz 470
                                            for( int yi=0; yi < hi; ++yi )
8 paul 471
                                                        {
188 Franz 472
                                                        QRgb *s = (QRgb*)(image.scanLine( yi ));
473
                                                        for(int xi=0; xi < wi; ++xi )
8 paul 474
                                                                {
188 Franz 475
                                                                if((*s) == 0xffffffff)
476
                                                                        (*s) &= 0x00ffffff;
477
                                                                s++;
478
                                                                }
479
                                                }
480
                                                Bild = image.copy(static_cast<int>(x), 0, static_cast<int>(b-x), static_cast<int>(h-y));
167 Franz 481
                                                system("rm -f "+tmpFile);
482
                                                *realCMYK = false;
8 paul 483
                                        }
484
                                }
485
                        }
486
                }
487
#ifdef HAVE_TIFF
167 Franz 488
                if (ext == "tif")
8 paul 489
                {
167 Franz 490
                        QImage img;
491
                        QImage inI2;
492
                        TIFF* tif = TIFFOpen(fn, "r");
493
                        if(tif)
8 paul 494
                        {
167 Franz 495
                        DWORD EmbedLen = 0;
496
                        LPBYTE EmbedBuffer;
497
                                unsigned width, height,size;
498
                                TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width);
499
                                TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height);
500
                                size=width*height;
501
                                uint32 *bits=(uint32*) _TIFFmalloc(size * sizeof (uint32));
502
                                if(bits)
8 paul 503
                                {
167 Franz 504
                                        if (TIFFReadRGBAImage(tif, width, height, bits, 0))
8 paul 505
                                        {
167 Franz 506
                                img.create(width,height,32);
189 Franz 507
                                img.setAlphaBuffer(true);
167 Franz 508
                                                if(TIFFGetR(0x1234567)==qRed  (0x1234567) &&
509
                                                         TIFFGetG(0x1234567)==qGreen(0x1234567) &&
510
                                                         TIFFGetB(0x1234567)==qBlue (0x1234567))
8 paul 511
                                                {
167 Franz 512
                                                        for(unsigned y=0; y<height; ++y)
513
                                                                memcpy(img.scanLine(height-1-y),bits+y*width,width*4);
8 paul 514
                                                }
167 Franz 515
                                                else
8 paul 516
                                                {
167 Franz 517
                                                        uint32 *inp=bits;
518
                                                        for(unsigned y=0; y<height; ++y)
8 paul 519
                                                        {
167 Franz 520
                                                                QRgb *row=(QRgb*) (img.scanLine(height-1-y));
521
                                                                for(unsigned x=0; x<width; ++x)
8 paul 522
                                                                {
167 Franz 523
                                                                        const uint32 col=*(inp++);
189 Franz 524
                                                                        row[x]=qRgba(TIFFGetR(col), TIFFGetG(col), TIFFGetB(col), TIFFGetA(col));
8 paul 525
                                                                }
526
                                                        }
527
                                                }
167 Franz 528
                                                Bild = img.copy();
8 paul 529
                                        }
167 Franz 530
                                        _TIFFfree(bits);
531
                                        cmsHTRANSFORM xform;
532
                                        cmsHPROFILE inputProf;
533
                                        if((TIFFGetField(tif, TIFFTAG_ICCPROFILE, &EmbedLen, &EmbedBuffer)) && (UseEmbedded))
8 paul 534
                                        {
167 Franz 535
                                                inputProf = cmsOpenProfileFromMem(EmbedBuffer, EmbedLen);
536
                                                if (static_cast<int>(cmsGetColorSpace(inputProf)) == icSigRgbData)
8 paul 537
                                                {
167 Franz 538
                                                        switch (static_cast<int>(cmsGetColorSpace(CMSprinterProf)))
8 paul 539
                                                        {
167 Franz 540
                                                                case icSigRgbData:
541
                                                                                *realCMYK = false;
542
                                                                                xform = cmsCreateTransform(inputProf, TYPE_RGBA_8, CMSprinterProf,
543
                                                                                                                                         TYPE_RGBA_8, IntentPrinter, 0);
544
                                                                                break;
545
                                                                case icSigCmykData:
546
                                                                                *realCMYK = true;
547
                                                                                xform = cmsCreateTransform(inputProf, TYPE_RGBA_8, CMSprinterProf,
548
                                                                                                                                         TYPE_CMYK_8, IntentPrinter, 0);
549
                                                                        break;
8 paul 550
                                                        }
167 Franz 551
                                                        for (int i=0; i < Bild.height(); ++i)
8 paul 552
                                                        {
167 Franz 553
                                                                LPBYTE ptr = Bild.scanLine(i);
554
                                                                cmsDoTransform(xform, ptr, ptr, Bild.width());
8 paul 555
                                                        }
556
                                                }
557
                                        }
167 Franz 558
                                        else
8 paul 559
                                        {
167 Franz 560
                                                inputProf = cmsOpenProfileFromFile(InputProfiles[Prof], "r");
561
                                                switch (static_cast<int>(cmsGetColorSpace(CMSprinterProf)))
8 paul 562
                                                {
167 Franz 563
                                                        case icSigRgbData:
564
                                                                                *realCMYK = false;
565
                                                                                xform = cmsCreateTransform(inputProf, TYPE_RGBA_8, CMSprinterProf,
566
                                                                                                                                         TYPE_RGBA_8, IntentPrinter, 0);
567
                                                                                break;
568
                                                        case icSigCmykData:
569
                                                                                *realCMYK = true;
570
                                                                                xform = cmsCreateTransform(inputProf, TYPE_RGBA_8, CMSprinterProf,
571
                                                                                                                                         TYPE_CMYK_8, IntentPrinter, 0);
572
                                                                                break;
8 paul 573
                                                }
167 Franz 574
                                                for (int i=0; i < Bild.height(); ++i)
8 paul 575
                                                {
167 Franz 576
                                                        LPBYTE ptr = Bild.scanLine(i);
577
                                                        cmsDoTransform(xform, ptr, ptr, Bild.width());
8 paul 578
                                                }
579
                                        }
167 Franz 580
                                        cmsDeleteTransform(xform);
581
                                        cmsCloseProfile(inputProf);
8 paul 582
                                }
167 Franz 583
                                TIFFClose(tif);
8 paul 584
                        }
585
                }
586
#endif
587
        else
167 Franz 588
        {
8 paul 589
                cmsHTRANSFORM xform;
590
                cmsHPROFILE inputProf;
591
                Bild.load(fn);
167 Franz 592
                Bild = Bild.convertDepth(32);
8 paul 593
                inputProf = cmsOpenProfileFromFile(InputProfiles[Prof], "r");
49 paul 594
                switch (static_cast<int>(cmsGetColorSpace(CMSprinterProf)))
167 Franz 595
                {
8 paul 596
                        case icSigRgbData:
597
                                *realCMYK = false;
598
                                xform = cmsCreateTransform(inputProf, TYPE_RGBA_8, CMSprinterProf, TYPE_RGBA_8, IntentPrinter, 0);
599
                                break;
600
                        case icSigCmykData:
601
                                *realCMYK = true;
602
                                xform = cmsCreateTransform(inputProf, TYPE_RGBA_8, CMSprinterProf, TYPE_CMYK_8, IntentPrinter, 0);
603
                                break;
167 Franz 604
                }
8 paul 605
                for (int i=0; i < Bild.height(); ++i)
167 Franz 606
                {
8 paul 607
                        LPBYTE ptr = Bild.scanLine(i);
608
                        cmsDoTransform(xform, ptr, ptr, Bild.width());
167 Franz 609
                }
8 paul 610
                cmsDeleteTransform(xform);
150 Franz 611
                cmsCloseProfile(inputProf);
167 Franz 612
        }
8 paul 613
        return Bild;
614
}
615
#endif
616
 
617
QString GetAttr(QDomElement *el, QString at, QString def)
618
{
619
        return el->attribute(at, def);
620
}
621
 
622
int QStoInt(QString in)
623
{
624
        bool ok = false;
625
        int c = in.toInt(&ok);
167 Franz 626
        return ok ? c : 0;
8 paul 627
}
628
 
80 Franz 629
double QStodouble(QString in)
8 paul 630
{
631
        bool ok = false;
80 Franz 632
        double c = in.toDouble(&ok);
167 Franz 633
        return ok ? c : 0.0;
8 paul 634
}
635
 
636
QPixmap loadIcon(QString nam)
637
{
167 Franz 638
        QString pfad = PREL;
639
        pfad += "/lib/scribus/icons/"+nam;
8 paul 640
        QPixmap pm;
641
        pm.load(pfad);
642
        return pm;
643
}
644
 
645
bool loadText(QString nam, QString *Buffer)
646
{
647
        QFile f(nam);
648
        QFileInfo fi(f);
649
        if (!fi.exists())
650
                return false;
651
        uint posi;
167 Franz 652
        bool ret;
8 paul 653
        QByteArray bb(f.size());
654
        if (f.open(IO_ReadOnly))
167 Franz 655
        {
8 paul 656
                f.readBlock(bb.data(), f.size());
657
                f.close();
658
                for (posi = 0; posi < bb.size(); ++posi)
659
                        *Buffer += bb[posi];
660
                ret = true;
167 Franz 661
        }
8 paul 662
        else
663
                ret = false;
664
        return ret;
665
}
666
 
80 Franz 667
double Cwidth(ScribusDoc *doc, QString name, QString ch, int Siz, QString ch2)
8 paul 668
{
80 Franz 669
        double w;
8 paul 670
        FT_Vector  delta;
671
        uint c1 = ch.at(0).unicode();
672
        uint c2 = ch2.at(0).unicode();
673
        Foi* fo = (*doc->AllFonts)[name];
674
        if (fo->CharWidth.contains(c1))
167 Franz 675
        {
111 Franz 676
                w = fo->CharWidth[c1]*(Siz / 10.0);
8 paul 677
                if (fo->HasKern)
167 Franz 678
                {
8 paul 679
                        uint cl = FT_Get_Char_Index(doc->FFonts[name], c1);
680
                        uint cr = FT_Get_Char_Index(doc->FFonts[name], c2);
9 Franz 681
                        FT_Get_Kerning(doc->FFonts[name], cl, cr, ft_kerning_unscaled, &delta);
111 Franz 682
                        w += delta.x / fo->uniEM * (Siz / 10.0);
167 Franz 683
                }
8 paul 684
                return w;
167 Franz 685
        }
8 paul 686
        else
111 Franz 687
                return static_cast<double>(Siz / 10.0);
8 paul 688
}
689
 
80 Franz 690
QPointArray RegularPolygon(double w, double h, uint c, bool star, double factor, double rota)
8 paul 691
{
167 Franz 692
        uint cx = star ? c * 2 : c;
80 Franz 693
        double seg = 360.0 / cx;
694
        double sc = rota + 180.0;
695
        double di = factor;
8 paul 696
        int mx = 0;
697
        int my = 0;
698
        QPointArray pts = QPointArray();
699
        for (uint x = 0; x < cx; ++x)
167 Franz 700
        {
8 paul 701
                sc = seg * x + 180.0 + rota;
702
                if (star)
167 Franz 703
                {
704
                        double wf = x % 2 == 0 ? w / 2 : w / 2 * di;
705
                        double hf = x % 2 == 0 ? h / 2 : h / 2 * di;
706
                        mx = qRound(sin(sc / 180 * M_PI) * (wf) + (w/2));
707
                        my = qRound(cos(sc / 180 * M_PI) * (hf) + (h/2));
708
                }
8 paul 709
                else
167 Franz 710
                {
8 paul 711
                        mx = qRound(sin(sc / 180 * M_PI) * (w/2) + (w/2));
712
                        my = qRound(cos(sc / 180 * M_PI) * (h/2) + (h/2));
167 Franz 713
                }
8 paul 714
                pts.resize(x+1);
715
                pts.setPoint(x, mx, my);
167 Franz 716
        }
8 paul 717
        return pts;
718
}
719
 
80 Franz 720
FPointArray RegularPolygonF(double w, double h, uint c, bool star, double factor, double rota)
8 paul 721
{
167 Franz 722
        uint cx = star ? c * 2 : c;
80 Franz 723
        double seg = 360.0 / cx;
724
        double sc = rota + 180.0;
725
        double di = factor;
726
        double mx = 0;
727
        double my = 0;
8 paul 728
        FPointArray pts = FPointArray();
729
        for (uint x = 0; x < cx; ++x)
167 Franz 730
        {
8 paul 731
                sc = seg * x + 180.0 + rota;
732
                if (star)
167 Franz 733
                {
734
                        double wf = x % 2 == 0 ? w / 2 : w / 2 * di;
735
                        double hf = x % 2 == 0 ? h / 2 : h / 2 * di;
736
                        mx = qRound(sin(sc / 180 * M_PI) * (wf) + (w/2));
737
                        my = qRound(cos(sc / 180 * M_PI) * (hf) + (h/2));
738
                }
8 paul 739
                else
167 Franz 740
                {
8 paul 741
                        mx = sin(sc / 180 * M_PI) * (w/2) + (w/2);
742
                        my = cos(sc / 180 * M_PI) * (h/2) + (h/2);
167 Franz 743
                }
8 paul 744
                pts.resize(x+1);
745
                pts.setPoint(x, mx, my);
167 Franz 746
        }
8 paul 747
        return pts;
748
}
749
 
750
QPointArray FlattenPath(FPointArray ina, QValueList<uint> &Segs)
751
{
752
        QPointArray Bez(4);
753
        QPointArray outa, cli;
754
        Segs.clear();
755
        if (ina.size() > 3)
167 Franz 756
        {
757
                for (uint poi=0; poi<ina.size()-3; poi += 4)
8 paul 758
                {
167 Franz 759
                        if (ina.point(poi).x() > 900000)
8 paul 760
                        {
761
                                outa.resize(outa.size()+1);
762
                                outa.setPoint(outa.size()-1, cli.point(cli.size()-1));
80 Franz 763
                                Segs.append(outa.size());
8 paul 764
                                continue;
167 Franz 765
                        }
8 paul 766
                        BezierPoints(&Bez, ina.pointQ(poi), ina.pointQ(poi+1), ina.pointQ(poi+3), ina.pointQ(poi+2));
767
                        cli = Bez.cubicBezier();
768
                        outa.putPoints(outa.size(), cli.size()-1, cli);
167 Franz 769
                }
8 paul 770
                outa.resize(outa.size()+1);
771
                outa.setPoint(outa.size()-1, cli.point(cli.size()-1));
167 Franz 772
        }
8 paul 773
        return outa;
774
}
775
 
80 Franz 776
double xy2Deg(double x, double y)
8 paul 777
{
778
        return (atan2(y,x)*(180.0/M_PI));
779
}
780
 
781
void BezierPoints(QPointArray *ar, QPoint n1, QPoint n2, QPoint n3, QPoint n4)
782
{
783
        ar->setPoint(0, n1);
784
        ar->setPoint(1, n2);
785
        ar->setPoint(2, n3);
786
        ar->setPoint(3, n4);
787
        return;
788
}
789
 
790
void Level2Layer(ScribusDoc *doc, struct Layer *ll, int Level)
791
{
792
        for (uint la2 = 0; la2 < doc->Layers.count(); ++la2)
167 Franz 793
        {
794
                if (doc->Layers[la2].Level == Level)
8 paul 795
                {
796
                        ll->Sichtbar = doc->Layers[la2].Sichtbar;
797
                        ll->Drucken = doc->Layers[la2].Drucken;
798
                        ll->LNr = doc->Layers[la2].LNr;
799
                        break;
800
                }
167 Franz 801
        }
8 paul 802
}
803
 
804
QString ImageToTxt(QImage *im)
805
{
806
        int h = im->height();
807
        int w = im->width();
808
        QString ImgStr = "";
809
        for( int yi=0; yi < h; ++yi )
167 Franz 810
        {
8 paul 811
                QRgb * s = (QRgb*)(im->scanLine( yi ));
812
                for( int xi=0; xi < w; ++xi )
167 Franz 813
                {
8 paul 814
                        QRgb r=*s++;
815
                        unsigned char u=qRed(r);
816
                        ImgStr += u;
817
                        u=qGreen(r);
818
                        ImgStr += u;
819
                        u=qBlue(r);
820
                        ImgStr += u;
821
                }
167 Franz 822
        }
8 paul 823
        return ImgStr;
824
}
825
 
826
QString ImageToCMYK(QImage *im)
827
{
828
        int h = im->height();
829
        int w = im->width();
830
        QString ImgStr = "";
831
        for( int yi=0; yi < h; ++yi )
167 Franz 832
        {
8 paul 833
                QRgb * s = (QRgb*)(im->scanLine( yi ));
834
                for( int xi=0; xi < w; ++xi )
167 Franz 835
                {
201 Franz 836
                        QRgb r=*s;
8 paul 837
                        int c = 255 - qRed(r);
838
                        int m = 255 - qGreen(r);
839
                        int y = 255 - qBlue(r);
840
                        int k = QMIN(QMIN(c, m), y);
201 Franz 841
                        *s = qRgba(m - k, y - k, k, c - k);
8 paul 842
                        ImgStr += c - k;
843
                        ImgStr += m - k;
844
                        ImgStr += y - k;
845
                        ImgStr += k;
201 Franz 846
                        s++;
8 paul 847
                }
167 Franz 848
        }
8 paul 849
        return ImgStr;
850
}
851
 
852
QString ImageToCMYK_PS(QImage *im, int pl, bool pre)
853
{
854
        int h = im->height();
855
        int w = im->width();
856
        QString ImgStr = "";
857
        if (pre)
167 Franz 858
        {
859
                for( int yi=0; yi < h; ++yi )
8 paul 860
                {
861
                        QRgb * s = (QRgb*)(im->scanLine( yi ));
862
                        for( int xi=0; xi < w; ++xi )
167 Franz 863
                        {
8 paul 864
                                QRgb r=*s++;
865
                                int c = qRed(r);
866
                                int m = qGreen(r);
867
                                int y = qBlue(r);
868
                                int k = qAlpha(r);
869
                                if (pl == -1)
167 Franz 870
                                {
8 paul 871
                                        ImgStr += c;
872
                                        ImgStr += m;
873
                                        ImgStr += y;
874
                                        ImgStr += k;
167 Franz 875
                                }
8 paul 876
                                else
167 Franz 877
                                {
8 paul 878
                                        if (pl == -2)
879
                                                ImgStr += QMIN(255, qRound(0.3 * c + 0.59 * m + 0.11 * y + k));
880
                                        if (pl == 1)
881
                                                ImgStr += c;
882
                                        if (pl == 2)
883
                                                ImgStr += m;
884
                                        if (pl == 3)
885
                                                ImgStr += y;
886
                                        if (pl == 0)
887
                                                ImgStr += k;
888
                                }
889
                        }
890
                }
167 Franz 891
        }
8 paul 892
        else
167 Franz 893
        {
894
                for( int yi=0; yi < h; ++yi )
8 paul 895
                {
896
                        QRgb * s = (QRgb*)(im->scanLine( yi ));
897
                        for( int xi=0; xi < w; ++xi )
167 Franz 898
                        {
8 paul 899
                                QRgb r=*s++;
900
                                int c = 255 - qRed(r);
901
                                int m = 255 - qGreen(r);
902
                                int y = 255 - qBlue(r);
903
                                int k = QMIN(QMIN(c, m), y);
904
                                if (pl == -1)
167 Franz 905
                                {
8 paul 906
                                        ImgStr += c - k;
907
                                        ImgStr += m - k;
908
                                        ImgStr += y - k;
909
                                        ImgStr += k;
167 Franz 910
                                }
8 paul 911
                                else
167 Franz 912
                                {
8 paul 913
                                        if (pl == -2)
914
                                                ImgStr += QMIN(255, qRound(0.3 * c + 0.59 * m + 0.11 * y + k));
915
                                        if (pl == 1)
916
                                                ImgStr += c - k;
917
                                        if (pl == 2)
918
                                                ImgStr += m - k;
919
                                        if (pl == 3)
920
                                                ImgStr += y - k;
921
                                        if (pl == 0)
922
                                                ImgStr += k;
923
                                }
924
                        }
925
                }
167 Franz 926
        }
8 paul 927
        return ImgStr;
928
}
929
 
930
QString MaskToTxt(QImage *im, bool PDF)
931
{
932
        int h = im->height();
933
        int w = im->width();
167 Franz 934
        int w2;
935
        w2 = w / 8;
936
        if ((w % 8) != 0)
937
                w2++;
8 paul 938
        QString ImgStr = "";
939
        for( int yi=0; yi < h; ++yi )
167 Franz 940
        {
8 paul 941
                uchar * s = im->scanLine( yi );
942
                for( int xi=0; xi < w2; ++xi )
167 Franz 943
                {
8 paul 944
                        unsigned char u = *(s+xi);
167 Franz 945
                        ImgStr += PDF ? ~u : u;
8 paul 946
                }
167 Franz 947
        }
8 paul 948
        return ImgStr;
949
}
950
 
203 Franz 951
QString MaskToTxt14(QImage *im)
952
{
953
        int h = im->height();
954
        int w = im->width();
955
        QString ImgStr = "";
956
        for( int yi=0; yi < h; ++yi )
957
        {
958
                QRgb * s = (QRgb*)(im->scanLine( yi ));
959
                for( int xi=0; xi < w; ++xi )
960
                {
961
                        QRgb r=*s++;
962
                        unsigned char u=qAlpha(r);
963
                        ImgStr += u;
964
                }
965
        }
966
        return ImgStr;
967
}
968
 
201 Franz 969
typedef struct my_error_mgr
970
{
971
  struct jpeg_error_mgr pub;            /* "public" fields */
972
  jmp_buf setjmp_buffer;  /* for return to caller */
973
} *my_error_ptr;
974
 
975
/*
976
 * Here's the routine that will replace the standard error_exit method:
977
 */
978
 
979
static void my_error_exit (j_common_ptr cinfo)
980
{
981
  my_error_ptr myerr = (my_error_ptr) cinfo->err;
982
  (*cinfo->err->output_message) (cinfo);
983
  longjmp (myerr->setjmp_buffer, 1);
984
}
985
 
202 Franz 986
void Convert2JPG(QString fn, QImage *image, int Quality, bool isCMYK)
201 Franz 987
{
988
        struct jpeg_compress_struct cinfo;
989
        struct my_error_mgr         jerr;
990
        FILE     *outfile;
991
        JSAMPROW row_pointer[1];
992
        row_pointer[0] = 0;
993
        cinfo.err = jpeg_std_error (&jerr.pub);
994
        jerr.pub.error_exit = my_error_exit;
995
        outfile = NULL;
996
        if (setjmp (jerr.setjmp_buffer))
997
        {
998
                jpeg_destroy_compress (&cinfo);
999
                if (outfile)
1000
                        fclose (outfile);
1001
                return;
1002
        }
1003
        jpeg_create_compress (&cinfo);
1004
        if ((outfile = fopen (fn, "wb")) == NULL)
1005
                return;
1006
        jpeg_stdio_dest (&cinfo, outfile);
1007
        cinfo.image_width  = image->width();
1008
        cinfo.image_height = image->height();
1009
        if (isCMYK)
1010
        {
1011
                cinfo.in_color_space = JCS_CMYK;
1012
                cinfo.input_components = 4;
1013
        }
1014
        else
1015
        {
1016
                cinfo.in_color_space = JCS_RGB;
1017
                cinfo.input_components = 3;
1018
        }
1019
        jpeg_set_defaults (&cinfo);
202 Franz 1020
        int qual[] = { 95, 85, 75, 50, 25 };  // These are the JPEG Quality settings 100 means best, 0 .. don't discuss
1021
        jpeg_set_quality (&cinfo, qual[Quality], true);
201 Franz 1022
        jpeg_start_compress (&cinfo, TRUE);
1023
        row_pointer[0] = new uchar[cinfo.image_width*cinfo.input_components];
1024
        int w = cinfo.image_width;
1025
        while (cinfo.next_scanline < cinfo.image_height)
1026
        {
1027
                uchar *row = row_pointer[0];
1028
                if (isCMYK)
1029
                {
1030
                        QRgb* rgba = (QRgb*)image->scanLine(cinfo.next_scanline);
1031
                        for (int i=0; i<w; ++i)
1032
                        {
1033
                                *row++ = qAlpha(*rgba);
1034
                                *row++ = qRed(*rgba);
1035
                                *row++ = qGreen(*rgba);
1036
                                *row++ = qBlue(*rgba);
1037
                                ++rgba;
1038
                        }
1039
                }
1040
                else
1041
                {
1042
                        QRgb* rgb = (QRgb*)image->scanLine(cinfo.next_scanline);
1043
                        for (int i=0; i<w; i++)
1044
                        {
1045
                                *row++ = qRed(*rgb);
1046
                                *row++ = qGreen(*rgb);
1047
                                *row++ = qBlue(*rgb);
1048
                                ++rgb;
1049
                        }
1050
                }
1051
                jpeg_write_scanlines (&cinfo, row_pointer, 1);
1052
        }
1053
        jpeg_finish_compress (&cinfo);
1054
        fclose (outfile);
1055
        jpeg_destroy_compress (&cinfo);
1056
        delete [] row_pointer[0];
1057
}
1058
 
8 paul 1059
QString CompressStr(QString *in)
1060
{
1061
        QString out = "";
1062
#ifdef HAVE_LIBZ
1063
        QByteArray bb(in->length());
1064
        for (uint ax = 0; ax < in->length(); ++ax)
1065
                bb[ax] = uchar(QChar(in->at(ax)));
1066
        uLong exlen = uint(bb.size() * 0.001 + 16) + bb.size();
1067
        QByteArray bc(exlen);
1068
        compress2((Byte *)bc.data(), &exlen, (Byte *)bb.data(), uLong(bb.size()), 9);
1069
        for (uint cl = 0; cl < exlen; ++cl)
1070
                out += bc[cl];
1071
#else
1072
        out = *in;
1073
#endif
1074
        return out;
1075
}
1076
 
1077
char *toHex( uchar u )
1078
{
1079
    static char hexVal[3];
1080
    int i = 1;
1081
    while ( i >= 0 )
167 Franz 1082
        {
1083
                ushort hex = (u & 0x000f);
1084
                if ( hex < 0x0a )
8 paul 1085
                hexVal[i] = '0'+hex;
167 Franz 1086
                else
8 paul 1087
                hexVal[i] = 'A'+(hex-0x0a);
167 Franz 1088
                u = u >> 4;
8 paul 1089
                        i--;
167 Franz 1090
    }
8 paul 1091
    hexVal[2] = '\0';
1092
    return hexVal;
1093
}
1094
 
1095
QString String2Hex(QString *in, bool lang)
1096
{
1097
        int i = 0;
1098
        QString out = "";
1099
        for( uint xi = 0; xi < in->length(); ++xi )
167 Franz 1100
        {
8 paul 1101
                out += toHex(uchar(QChar(in->at(xi))));
1102
                ++i;
1103
                if ((i>40) && (lang))
167 Franz 1104
                {
8 paul 1105
                        out += '\n';
1106
                        i=0;
1107
                }
167 Franz 1108
        }
8 paul 1109
        return out;
1110
}
1111
 
1112
QByteArray ComputeMD5Sum(QByteArray *in)
1113
{
1114
        QByteArray MDsum(16);
49 paul 1115
        md5_buffer (in->data(), in->size(), reinterpret_cast<void*>(MDsum.data()));
8 paul 1116
        return MDsum;
1117
}
1118
 
19 Franz 1119
QString Path2Relative(QString Path)
1120
{
1121
        QString Ndir = "";
1122
        QStringList Pdir = QStringList::split("/", QDir::currentDirPath());
1123
        QFileInfo Bfi = QFileInfo(Path);
1124
        QStringList Bdir = QStringList::split("/", Bfi.dirPath(true));
1125
        bool ende = true;
1126
        uint dcoun = 0;
1127
        uint dcoun2 = 0;
1128
        while (ende)
167 Franz 1129
        {
19 Franz 1130
                if (Pdir[dcoun] == Bdir[dcoun])
1131
                        dcoun++;
1132
                else
1133
                        break;
1134
                if (dcoun > Pdir.count())
1135
                        break;
167 Franz 1136
        }
19 Franz 1137
        dcoun2 = dcoun;
1138
        for (uint ddx2 = dcoun; ddx2 < Pdir.count(); ddx2++)
1139
                Ndir += "../";
1140
        for (uint ddx = dcoun2; ddx < Bdir.count(); ddx++)
1141
                Ndir += Bdir[ddx]+"/";
1142
        Ndir += Bfi.fileName();
1143
        return Ndir;
1144
}
1145
 
8 paul 1146
bool GlyNames(QMap<uint, QString> *GList, QString Dat)
1147
{
1148
        bool error;
1149
        char *buf[50];
1150
        FT_Library library;
1151
        FT_Face face;
1152
        FT_ULong  charcode;
167 Franz 1153
        FT_UInt gindex;
8 paul 1154
        error = FT_Init_FreeType(&library);
1155
        error = FT_New_Face(library, Dat, 0, &face);
77 Franz 1156
        gindex = 0;
167 Franz 1157
        charcode = FT_Get_First_Char(face, &gindex );
1158
        while (gindex != 0)
1159
        {
8 paul 1160
                FT_Get_Glyph_Name(face, gindex, buf, 50);
49 paul 1161
                GList->insert(charcode, QString(reinterpret_cast<char*>(buf)));
167 Franz 1162
        charcode = FT_Get_Next_Char(face, charcode, &gindex );
1163
        }
8 paul 1164
        FT_Done_FreeType( library );
1165
        return true;
1166
}
1167
 
1168
bool GlyIndex(QMap<uint, PDFlib::GlNamInd> *GListInd, QString Dat)
1169
{
1170
        struct PDFlib::GlNamInd gln;
1171
        bool error;
1172
        char *buf[50];
1173
        FT_Library library;
1174
        FT_Face face;
1175
        FT_ULong  charcode;
167 Franz 1176
        FT_UInt   gindex;
1177
        uint counter1 = 32;
1178
        uint counter2 = 0;
8 paul 1179
        error = FT_Init_FreeType(&library);
1180
        error = FT_New_Face(library, Dat, 0, &face);
77 Franz 1181
        gindex = 0;
167 Franz 1182
        charcode = FT_Get_First_Char(face, &gindex );
1183
        while (gindex != 0)
1184
        {
8 paul 1185
                FT_Get_Glyph_Name(face, gindex, buf, 50);
1186
                gln.Code = counter1 + counter2;
49 paul 1187
                gln.Name = "/"+QString(reinterpret_cast<char*>(buf));
8 paul 1188
                GListInd->insert(charcode, gln);
167 Franz 1189
        charcode = FT_Get_Next_Char(face, charcode, &gindex );
1190
        counter1++;
1191
        if (counter1 > 255)
1192
                {
8 paul 1193
                        counter1 = 32;
1194
                        counter2 += 0x100;
1195
                }
167 Franz 1196
        }
8 paul 1197
        FT_Done_FreeType( library );
1198
        return true;
1199
}
1200
 
1201
FPoint firstP;
1202
bool FirstM;
1203
 
1204
int traceMoveto( FT_Vector *to, FPointArray *composite )
1205
{
1206
        double tox = ( to->x / 64.0 );
1207
        double toy = ( to->y / 64.0 );
1208
        if (!FirstM)
167 Franz 1209
        {
68 Franz 1210
                composite->addPoint(firstP);
1211
                composite->addPoint(firstP);
1212
                composite->setMarker();
167 Franz 1213
        }
8 paul 1214
        else
1215
                FirstM = false;
68 Franz 1216
        composite->addPoint(FPoint(tox, toy));
1217
        composite->addPoint(FPoint(tox, toy));
8 paul 1218
        firstP = FPoint(tox, toy);
1219
        return 0;
1220
}
1221
 
1222
int traceLineto( FT_Vector *to, FPointArray *composite )
1223
{
1224
        double tox = ( to->x / 64.0 );
1225
        double toy = ( to->y / 64.0 );
120 Franz 1226
        if (composite->size() > 4)
167 Franz 1227
        {
120 Franz 1228
                FPoint b1 = composite->point(composite->size()-4);
1229
                FPoint b2 = composite->point(composite->size()-3);
1230
                FPoint b3 = composite->point(composite->size()-2);
1231
                FPoint b4 = composite->point(composite->size()-1);
1232
                FPoint n1 = FPoint(tox, toy);
1233
                FPoint n2 = FPoint(tox, toy);
1234
                FPoint n3 = FPoint(tox, toy);
1235
                FPoint n4 = FPoint(tox, toy);
1236
                if ((b1 == n1) && (b2 == n2) && (b3 == n3) && (b4 == n4))
1237
                        return 0;
167 Franz 1238
        }
68 Franz 1239
        composite->addPoint(FPoint(tox, toy));
1240
        composite->addPoint(FPoint(tox, toy));
1241
        composite->addPoint(FPoint(tox, toy));
1242
        composite->addPoint(FPoint(tox, toy));
8 paul 1243
        return 0;
1244
}
1245
 
1246
int traceQuadraticBezier( FT_Vector *control, FT_Vector *to, FPointArray *composite )
1247
{
1248
        double x1 = ( control->x / 64.0 );
1249
        double y1 = ( control->y / 64.0 );
1250
        double x2 = ( to->x / 64.0 );
1251
        double y2 = ( to->y / 64.0 );
120 Franz 1252
        if (composite->size() > 4)
167 Franz 1253
        {
120 Franz 1254
                FPoint b1 = composite->point(composite->size()-4);
1255
                FPoint b2 = composite->point(composite->size()-3);
1256
                FPoint b3 = composite->point(composite->size()-2);
1257
                FPoint b4 = composite->point(composite->size()-1);
1258
                FPoint n1 = FPoint(x2, y2);
1259
                FPoint n2 = FPoint(x1, y1);
1260
                FPoint n3 = FPoint(x2, y2);
1261
                FPoint n4 = FPoint(x2, y2);
1262
                if ((b1 == n1) && (b2 == n2) && (b3 == n3) && (b4 == n4))
1263
                        return 0;
167 Franz 1264
        }
68 Franz 1265
        composite->addPoint(FPoint(x2, y2));
1266
        composite->addPoint(FPoint(x1, y1));
1267
        composite->addPoint(FPoint(x2, y2));
1268
        composite->addPoint(FPoint(x2, y2));
8 paul 1269
        return 0;
167 Franz 1270
}
8 paul 1271
 
1272
int traceCubicBezier( FT_Vector *p, FT_Vector *q, FT_Vector *to, FPointArray *composite )
1273
{
1274
        double x1 = ( p->x / 64.0 );
1275
        double y1 = ( p->y / 64.0 );
1276
        double x2 = ( q->x / 64.0 );
1277
        double y2 = ( q->y / 64.0 );
1278
        double x3 = ( to->x / 64.0 );
1279
        double y3 = ( to->y / 64.0 );
120 Franz 1280
        if (composite->size() > 4)
167 Franz 1281
        {
120 Franz 1282
                FPoint b1 = composite->point(composite->size()-4);
1283
                FPoint b2 = composite->point(composite->size()-3);
1284
                FPoint b3 = composite->point(composite->size()-2);
1285
                FPoint b4 = composite->point(composite->size()-1);
1286
                FPoint n1 = FPoint(x3, y3);
1287
                FPoint n2 = FPoint(x2, y2);
1288
                FPoint n3 = FPoint(x3, y3);
1289
                FPoint n4 = FPoint(x3, y3);
1290
                if ((b1 == n1) && (b2 == n2) && (b3 == n3) && (b4 == n4))
1291
                        return 0;
167 Franz 1292
        }
8 paul 1293
        composite->setPoint(composite->size()-1, FPoint(x1, y1));
68 Franz 1294
        composite->addPoint(FPoint(x3, y3));
1295
        composite->addPoint(FPoint(x2, y2));
1296
        composite->addPoint(FPoint(x3, y3));
1297
        composite->addPoint(FPoint(x3, y3));
8 paul 1298
        return 0;
1299
}
1300
 
1301
FT_Outline_Funcs OutlineMethods =
1302
{
1303
        (FT_Outline_MoveTo_Func) traceMoveto,
1304
        (FT_Outline_LineTo_Func) traceLineto,
1305
        (FT_Outline_ConicTo_Func) traceQuadraticBezier,
1306
        (FT_Outline_CubicTo_Func) traceCubicBezier,
1307
        0,
1308
 
1309
};
1310
 
80 Franz 1311
FPointArray traceChar(FT_Face face, uint chr, int chs, double *x, double *y)
8 paul 1312
{
1313
        FT_UInt glyphIndex;
1314
        FPointArray pts, pts2;
1315
        pts.resize(0);
1316
        firstP = FPoint(0,0);
1317
        FirstM = true;
1318
        FT_Set_Char_Size(       face, 0, chs*64, 72, 72 );
1319
        glyphIndex = FT_Get_Char_Index(face, chr);
1320
        FT_Load_Glyph( face, glyphIndex, FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP );
49 paul 1321
        FT_Outline_Decompose(&face->glyph->outline, &OutlineMethods, reinterpret_cast<void*>(&pts));
87 Franz 1322
        *x = face->glyph->metrics.horiBearingX / 64.0;
1323
        *y = face->glyph->metrics.horiBearingY / 64.0;
8 paul 1324
        QWMatrix ma;
1325
        ma.scale(1, -1);
1326
        pts.map(ma);
1327
        pts.translate(0, chs);
1328
        pts2.resize(0);
1329
        pts2.putPoints(0, pts.size()-2, pts, 0);
1330
        return pts2;
1331
}
90 Franz 1332
 
95 Franz 1333
FPoint GetMaxClipF(FPointArray Clip)
1334
{
1335
        FPoint np, rp;
1336
        double mx = 0;
1337
        double my = 0;
1338
        for (uint c = 0; c < Clip.size(); ++c)
167 Franz 1339
        {
95 Franz 1340
                np = Clip.point(c);
1341
                if (np.x() > 900000)
1342
                        continue;
1343
                if (np.x() > mx)
1344
                        mx = np.x();
1345
                if (np.y() > my)
1346
                        my = np.y();
167 Franz 1347
        }
95 Franz 1348
        rp = FPoint(mx, my);
1349
        return rp;
1350
}
1351
 
92 Franz 1352
QPixmap FontSample(QString da, int s, QString ts, QColor back)
1353
{
1354
        FT_Face face;
1355
        FT_Library library;
95 Franz 1356
        double x, y, ymax;
92 Franz 1357
        bool error;
1358
        int  pen_x;
95 Franz 1359
        FPoint gp;
92 Franz 1360
        error = FT_Init_FreeType( &library );
1361
        error = FT_New_Face( library, da, 0, &face );
1362
        double uniEM = static_cast<double>(face->units_per_EM);
95 Franz 1363
        int h = qRound(face->height / uniEM) * s + 1;
1364
        double a = static_cast<double>(face->descender) / uniEM * s + 1;
92 Franz 1365
        int w = qRound((face->bbox.xMax - face->bbox.xMin) / uniEM) * s * (ts.length()+1);
1366
        QPixmap pm(w, h);
1367
        pm.fill();
1368
        pen_x = 0;
95 Franz 1369
        ymax = 0.0;
92 Franz 1370
        ScPainter *p = new ScPainter(&pm, pm.width(), pm.height());
1371
        p->setFillMode(1);
1372
        p->setLineWidth(0.0);
1373
        p->setBrush(back);
1374
        p->drawRect(0.0, 0.0, static_cast<double>(w), static_cast<double>(h));
1375
        p->setBrush(Qt::black);
167 Franz 1376
        for (uint n = 0; n < ts.length(); ++n)
1377
        {
92 Franz 1378
                uint dv = ts[n].unicode();
1379
                FPointArray gly = traceChar(face, dv, s, &x, &y);
1380
                if (gly.size() > 3)
167 Franz 1381
                {
92 Franz 1382
                        gly.translate(static_cast<double>(pen_x) / 64.0, a);
95 Franz 1383
                        gp = GetMaxClipF(gly);
1384
                        ymax = QMAX(ymax, gp.y());
92 Franz 1385
                        p->setupPolygon(&gly);
1386
                        p->fillPath();
167 Franz 1387
                }
92 Franz 1388
                pen_x += face->glyph->advance.x;
167 Franz 1389
        }
92 Franz 1390
        p->end();
95 Franz 1391
        pm.resize(QMIN(qRound(gp.x()), w), QMIN(qRound(ymax), h));
92 Franz 1392
        delete p;
1393
        FT_Done_FreeType( library );
1394
        return pm;
1395
}
1396
 
90 Franz 1397
/***************************************************************************
1398
    begin                : Wed Oct 29 2003
1399
    copyright            : (C) 2003 The Scribus Team
1400
    email                : paul@all-the-johnsons.co.uk
1401
 ***************************************************************************/
1402
// check if the file exists, if it does, ask if they're sure
1403
// return true if they're sure, else return false;
1404
 
1405
bool overwrite(QWidget *parent, QString filename)
1406
{
167 Franz 1407
        bool retval = true;
1408
        QFileInfo fi(filename);
1409
        if (fi.exists())
90 Franz 1410
        {
167 Franz 1411
        int t = QMessageBox::warning(parent, QObject::tr("Warning"),
1412
                                                QObject::tr("Do you really want to overwrite the File:\n%1 ?").arg(filename),
1413
                        QMessageBox::No, QMessageBox::Yes, QMessageBox::NoButton);
1414
            if (t == QMessageBox::No)
90 Franz 1415
                        retval = false;
1416
        }
1417
  return retval;
1418
}
124 Franz 1419
 
1420
void CopyPageItem(struct CLBuf *Buffer, PageItem *b)
1421
{
1422
        uint a;
1423
        Buffer->PType = b->PType;
1424
        Buffer->Xpos = b->Xpos;
1425
        Buffer->Ypos = b->Ypos;
1426
        Buffer->Width = b->Width;
1427
        Buffer->Height = b->Height;
1428
        Buffer->RadRect = b->RadRect;
1429
        Buffer->FrameType = b->FrameType;
1430
        Buffer->ClipEdited = b->ClipEdited;
1431
        Buffer->Pwidth = b->Pwidth;
1432
        Buffer->Pcolor = b->Pcolor;
1433
        Buffer->Pcolor2 = b->Pcolor2;
1434
        Buffer->Shade = b->Shade;
1435
        Buffer->Shade2 = b->Shade2;
1436
        Buffer->GrColor = b->GrColor;
1437
        Buffer->GrColor2 = b->GrColor2;
1438
        Buffer->GrShade = b->GrShade;
1439
        Buffer->GrShade2 = b->GrShade2;
1440
        Buffer->GrType = b->GrType;
1441
        Buffer->TxtStroke = b->TxtStroke;
1442
        Buffer->TxtFill = b->TxtFill;
1443
        Buffer->ShTxtStroke = b->ShTxtStroke;
1444
        Buffer->ShTxtFill = b->ShTxtFill;
1445
        Buffer->TxtScale = b->TxtScale;
1446
        Buffer->TxTStyle = b->TxTStyle;
1447
        Buffer->Rot = b->Rot;
1448
        Buffer->PLineArt = b->PLineArt;
1449
        Buffer->PLineEnd = b->PLineEnd;
1450
        Buffer->PLineJoin = b->PLineJoin;
1451
        Buffer->LineSp = b->LineSp;
1452
        Buffer->LocalScX = b->LocalScX;
1453
        Buffer->LocalScY = b->LocalScY;
1454
        Buffer->LocalX = b->LocalX;
1455
        Buffer->LocalY = b->LocalY;
1456
        Buffer->PicArt = b->PicArt;
1457
        Buffer->flippedH = b->flippedH;
1458
        Buffer->flippedV = b->flippedV;
1459
        Buffer->BBoxX = b->BBoxX;
1460
        Buffer->BBoxH = b->BBoxH;
1461
        Buffer->isPrintable = b->isPrintable;
1462
        Buffer->isBookmark = b->isBookmark;
1463
        Buffer->BMnr = b->BMnr;
1464
        Buffer->isAnnotation = b->isAnnotation;
1465
        Buffer->AnType = b->AnType;
1466
        Buffer->AnAction = b->AnAction;
1467
        Buffer->An_E_act = b->An_E_act;
1468
        Buffer->An_X_act = b->An_X_act;
1469
        Buffer->An_D_act = b->An_D_act;
1470
        Buffer->An_Fo_act = b->An_Fo_act;
1471
        Buffer->An_Bl_act = b->An_Bl_act;
1472
        Buffer->An_K_act = b->An_K_act;
1473
        Buffer->An_F_act = b->An_F_act;
1474
        Buffer->An_V_act = b->An_V_act;
1475
        Buffer->An_C_act = b->An_C_act;
1476
        Buffer->An_Extern = b->An_Extern;
1477
        Buffer->AnZiel = b->AnZiel;
1478
        Buffer->AnName = b->AnName;
1479
        Buffer->AnActType = b->AnActType;
1480
        Buffer->AnToolTip = b->AnToolTip;
1481
        Buffer->AnBwid = b->AnBwid;
1482
        Buffer->AnBsty = b->AnBsty;
1483
        Buffer->AnFeed = b->AnFeed;
1484
        Buffer->AnFlag = b->AnFlag;
1485
        Buffer->AnFont = b->AnFont;
1486
        Buffer->AnRollOver = b->AnRollOver;
1487
        Buffer->AnDown = b->AnDown;
1488
        Buffer->AnFormat = b->AnFormat;
1489
        Buffer->AnVis = b->AnVis;
1490
        Buffer->AnMaxChar = b->AnMaxChar;
1491
        Buffer->AnChkStil = b->AnChkStil;
1492
        Buffer->AnIsChk = b->AnIsChk;
1493
        Buffer->AnAAact = b->AnAAact;
1494
        Buffer->AnBColor = b->AnBColor;
1495
        Buffer->AnHTML = b->AnHTML;
1496
        Buffer->AnUseIcons = b->AnUseIcons;
1497
        Buffer->AnIPlace = b->AnIPlace;
1498
        Buffer->AnScaleW = b->AnScaleW;
1499
        Buffer->Extra = b->Extra;
1500
        Buffer->TExtra = b->TExtra;
1501
        Buffer->BExtra = b->BExtra;
1502
        Buffer->RExtra = b->RExtra;
1503
        Buffer->Pfile = b->Pfile;
1504
        Buffer->Pfile2 = b->Pfile2;
1505
        Buffer->Pfile3 = b->Pfile3;
1506
        QString Text = "";
1507
        if (b->Ptext.count() != 0)
167 Franz 1508
        {
1509
                for (a=0; a<b->Ptext.count(); ++a)
124 Franz 1510
                {
1511
                        if( (b->Ptext.at(a)->ch == "\n") || (b->Ptext.at(a)->ch == "\r"))
1512
                                Text += QString(QChar(5))+"\t";
157 Franz 1513
                        else if(b->Ptext.at(a)->ch == "\t")
139 Franz 1514
                                Text += QString(QChar(4))+"\t";
124 Franz 1515
                        else
1516
                                Text += b->Ptext.at(a)->ch+"\t";
1517
                        Text += b->Ptext.at(a)->cfont+"\t";
1518
                        Text += QString::number(b->Ptext.at(a)->csize / 10.0)+"\t";
1519
                        Text += b->Ptext.at(a)->ccolor+"\t";
1520
                        Text += QString::number(b->Ptext.at(a)->cextra)+"\t";
1521
                        Text += QString::number(b->Ptext.at(a)->cshade)+'\t';
1522
                        Text += QString::number(b->Ptext.at(a)->cstyle)+'\t';
1523
                        Text += QString::number(b->Ptext.at(a)->cab)+'\t';
1524
                        Text += b->Ptext.at(a)->cstroke+"\t";
1525
                        Text += QString::number(b->Ptext.at(a)->cshade2)+'\t';
1526
                        Text += QString::number(b->Ptext.at(a)->cscale)+'\n';
1527
                }
167 Franz 1528
        }
124 Franz 1529
        Buffer->Ptext = Text;
1530
        Buffer->Clip = b->Clip.copy();
1531
        Buffer->PoLine = b->PoLine.copy();
139 Franz 1532
        Buffer->TabValues = b->TabValues;
1533
        Buffer->DashValues = b->DashValues;
1534
        Buffer->DashOffset = b->DashOffset;
124 Franz 1535
        Buffer->PoShow = b->PoShow;
1536
        Buffer->BaseOffs = b->BaseOffs;
1537
        Buffer->Textflow = b->Textflow;
1538
        Buffer->Textflow2 = b->Textflow2;
1539
        Buffer->Ausrich = b->Ausrich;
1540
        Buffer->IFont = b->IFont;
1541
        Buffer->ISize = b->ISize;
1542
        Buffer->ExtraV = b->ExtraV;
1543
        Buffer->Groups = b->Groups;
1544
        Buffer->IProfile = b->IProfile;
1545
        Buffer->IRender = b->IRender;
1546
        Buffer->UseEmbedded = b->UseEmbedded;
1547
        Buffer->EmProfile = b->EmProfile;
1548
        Buffer->LayerNr = b->LayerNr;
1549
        Buffer->ScaleType = b->ScaleType;
1550
        Buffer->AspectRatio = b->AspectRatio;
1551
        Buffer->Locked = b->Locked;
1552
        Buffer->Transparency = b->Transparency;
1553
        Buffer->TranspStroke = b->TranspStroke;
1554
        Buffer->Reverse = b->Reverse;
1555
        Buffer->InvPict = b->InvPict;
1556
        Buffer->NamedLStyle = b->NamedLStyle;
1557
        Buffer->Language = b->Language;
134 Franz 1558
        Buffer->Cols = b->Cols;
135 Franz 1559
        Buffer->ColGap = b->ColGap;
124 Franz 1560
}
125 Franz 1561
 
1562
void WordAndPara(PageItem* b, int *w, int *p, int *c, int *wN, int *pN, int *cN)
1563
{
1564
        QChar Dat = QChar(32);
1565
        int para = 0;
1566
        int ww = 0;
1567
        int cc = 0;
1568
        int paraN = 0;
1569
        int wwN = 0;
1570
        int ccN = 0;
1571
        bool first = true;
1572
        PageItem *nb = b;
1573
        PageItem *nbl = b;
1574
        while (nb != 0)
167 Franz 1575
        {
125 Franz 1576
                if (nb->BackBox != 0)
1577
                        nb = nb->BackBox;
1578
                else
1579
                        break;
167 Franz 1580
        }
125 Franz 1581
        while (nb != 0)
167 Franz 1582
        {
1583
                for (uint a = 0; a < nb->Ptext.count(); ++a)
125 Franz 1584
                {
1585
                        QChar b = nb->Ptext.at(a)->ch[0];
1586
                        if (b == QChar(13))
167 Franz 1587
                        {
125 Franz 1588
                                if (a >= nb->MaxChars)
1589
                                        paraN++;
1590
                                else
1591
                                        para++;
167 Franz 1592
                        }
125 Franz 1593
                        if ((!b.isLetterOrNumber()) && (Dat.isLetterOrNumber()) && (!first))
167 Franz 1594
                        {
125 Franz 1595
                                if (a >= nb->MaxChars)
1596
                                        wwN++;
1597
                                else
1598
                                        ww++;
167 Franz 1599
                        }
125 Franz 1600
                        if (a >= nb->MaxChars)
1601
                                ccN++;
1602
                        else
1603
                                cc++;
167 Franz 1604
                Dat = b;
125 Franz 1605
                        first = false;
1606
        }
1607
                nbl = nb;
1608
                nb = nb->NextBox;
167 Franz 1609
        }
125 Franz 1610
        if (nbl->MaxChars < nbl->Ptext.count())
1611
                paraN++;
1612
        else
1613
                para++;
1614
        if (Dat.isLetterOrNumber())
167 Franz 1615
        {
125 Franz 1616
                if (nbl->MaxChars < nbl->Ptext.count())
1617
                        wwN++;
1618
                else
1619
                        ww++;
167 Franz 1620
        }
125 Franz 1621
        *w = ww;
1622
        *p = para;
1623
        *c = cc;
1624
        *wN = wwN;
1625
        *pN = paraN;
1626
        *cN = ccN;
1627
}
203 Franz 1628
 
1629
void ReOrderText(ScribusDoc *doc, ScribusView *view)
1630
{
1631
        double savScale = doc->Scale;
1632
        doc->Scale = 1.0;
1633
        doc->RePos = true;
1634
        QPixmap pgPix(10, 10);
1635
        QRect rd = QRect(0,0,9,9);
1636
        ScPainter *painter = new ScPainter(&pgPix, pgPix.width(), pgPix.height());
1637
        for (uint az=0; az<view->MasterPages.count(); az++)
1638
        {
1639
                for (uint azz=0; azz<view->MasterPages.at(az)->Items.count(); ++azz)
1640
                {
1641
                        PageItem *ite = view->MasterPages.at(az)->Items.at(azz);
1642
                        if (ite->PType == 4)
1643
                                ite->DrawObj(painter, rd);
1644
                }
1645
        }
1646
        for (uint az=0; az<view->Pages.count(); az++)
1647
        {
1648
                for (uint azz=0; azz<view->Pages.at(az)->Items.count(); ++azz)
1649
                {
1650
                        PageItem *ite = view->Pages.at(az)->Items.at(azz);
1651
                        if (ite->PType == 4)
1652
                                ite->DrawObj(painter, rd);
1653
                }
1654
        }
1655
        doc->RePos = false;
1656
        doc->Scale = savScale;
1657
        delete painter;
1658
}