Subversion Repositories Scribus

Rev

Rev 3960 | 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>
2631 craig 32
#include <algorithm>
8 paul 33
#include <cstdlib>
34
#include <cmath>
213 Franz 35
#include <unistd.h>
8 paul 36
#include "md5.h"
201 Franz 37
#include <setjmp.h>
204 Franz 38
#include "qprocess.h"
128 Franz 39
 
612 cbradney 40
#ifdef _MSC_VER
41
 #if (_MSC_VER >= 1200)
42
  #include "win-config.h"
43
 #endif
128 Franz 44
#else
45
 #include "config.h"
46
#endif
47
 
201 Franz 48
extern "C" {
49
#define XMD_H           // shut JPEGlib up
50
#if defined(Q_OS_UNIXWARE)
51
#  define HAVE_BOOLEAN  // libjpeg under Unixware seems to need this
52
#endif
53
#include <jpeglib.h>
54
#include <jerror.h>
55
#undef HAVE_STDLIB_H
56
#ifdef const
57
#  undef const          // remove crazy C hackery in jconfig.h
58
#endif
59
}
60
 
214 Franz 61
#include "scribus.h"
8 paul 62
#include "libpdf/pdflib.h"
68 Franz 63
#include <ft2build.h>
64
#include FT_FREETYPE_H
65
#include FT_OUTLINE_H
66
#include FT_GLYPH_H
8 paul 67
#ifdef HAVE_LIBZ
68
        #include <zlib.h>
69
#endif
70
#ifdef HAVE_TIFF
71
        #include <tiffio.h>
72
#endif
73
#ifdef HAVE_CMS
44 Franz 74
        #include CMS_INC
8 paul 75
extern cmsHPROFILE CMSoutputProf;
76
extern cmsHPROFILE CMSprinterProf;
77
extern cmsHTRANSFORM stdTrans;
78
extern cmsHTRANSFORM stdProof;
79
extern cmsHTRANSFORM stdTransImg;
80
extern cmsHTRANSFORM stdProofImg;
81
extern bool SoftProofing;
82
extern bool Gamut;
83
extern bool CMSuse;
84
extern int IntentMonitor;
85
extern int IntentPrinter;
86
#endif
87
extern ProfilesL InputProfiles;
214 Franz 88
extern ScribusApp* ScApp;
8 paul 89
 
503 cbradney 90
using namespace std;
3118 fschmid 91
QStringList getSystemProfilesDirs(void);
203 Franz 92
void ReOrderText(ScribusDoc *doc, ScribusView *view);
125 Franz 93
void WordAndPara(PageItem* b, int *w, int *p, int *c, int *wN, int *pN, int *cN);
124 Franz 94
void CopyPageItem(struct CLBuf *Buffer, PageItem *b);
90 Franz 95
bool overwrite(QWidget *parent, QString filename);
1084 fschmid 96
int setBestEncoding(FT_Face face);
220 Franz 97
FPointArray traceChar(FT_Face face, uint chr, int chs, double *x, double *y, bool &err);
95 Franz 98
FPoint GetMaxClipF(FPointArray Clip);
1084 fschmid 99
QPixmap FontSample(QString da, int s, QString ts, QColor back, bool force = false);
418 Franz 100
QPixmap fontSamples(QString da, int s, QString ts, QColor back);
19 Franz 101
QString Path2Relative(QString Path);
20 Franz 102
QPixmap LoadPDF(QString fn, int Seite, int Size, int *w, int *h);
8 paul 103
bool GlyNames(QMap<uint, QString> *GList, QString Dat);
104
bool GlyIndex(QMap<uint, PDFlib::GlNamInd> *GListInd, QString Dat);
105
QByteArray ComputeMD5Sum(QByteArray *in);
106
char *toHex( uchar u );
107
QString String2Hex(QString *in, bool lang = true);
108
QString CompressStr(QString *in);
1968 fschmid 109
QImage scaleImage(const QImage& src, int width, int height);
8 paul 110
QString ImageToTxt(QImage *im);
111
QString ImageToCMYK(QImage *im);
112
QString ImageToCMYK_PS(QImage *im, int pl, bool pre);
1886 fschmid 113
bool isProgressive(QString fn);
202 Franz 114
void Convert2JPG(QString fn, QImage *image, int Quality, bool isCMYK);
8 paul 115
QString MaskToTxt(QImage *im, bool PDF = true);
203 Franz 116
QString MaskToTxt14(QImage *im);
8 paul 117
void Level2Layer(ScribusDoc *doc, struct Layer *ll, int Level);
2129 fschmid 118
int Layer2Level(ScribusDoc *currentDoc, int LayerNr);
8 paul 119
void BezierPoints(QPointArray *ar, QPoint n1, QPoint n2, QPoint n3, QPoint n4);
80 Franz 120
double xy2Deg(double x, double y);
8 paul 121
QPointArray FlattenPath(FPointArray ina, QValueList<uint> &Segs);
80 Franz 122
QPointArray RegularPolygon(double w, double h, uint c, bool star, double factor, double rota);
123
FPointArray RegularPolygonF(double w, double h, uint c, bool star, double factor, double rota);
8 paul 124
QPixmap loadIcon(QString nam);
1108 fschmid 125
uint getDouble(QString in, bool raw);
8 paul 126
bool loadText(QString nam, QString *Buffer);
80 Franz 127
double Cwidth(ScribusDoc *doc, QString name, QString ch, int Siz, QString ch2 = " ");
220 Franz 128
double RealCWidth(ScribusDoc *doc, QString name, QString ch, int Siz);
2283 fschmid 129
double RealCHeight(ScribusDoc *currentDoc, QString name, QString ch, int Size);
130
double RealCAscent(ScribusDoc *currentDoc, QString name, QString ch, int Size);
80 Franz 131
double QStodouble(QString in);
8 paul 132
int QStoInt(QString in);
133
QString GetAttr(QDomElement *el, QString at, QString def="0");
201 Franz 134
QImage LoadPict(QString fn, bool *gray = 0);
8 paul 135
#ifdef HAVE_CMS
136
QImage ProofPict(QImage *Im, QString Prof, int Rend, cmsHPROFILE emPr=0);
137
QImage LoadPictCol(QString fn, QString Prof, bool UseEmbedded, bool *realCMYK);
138
#else
139
QImage ProofPict(QImage *Im, QString Prof, int Rend);
140
#endif
141
QImage ProofImage(QImage *Im);
204 Franz 142
int callGS(const QStringList & args_in);
143
int copyFile(QString source, QString target);
144
int moveFile(QString source, QString target);
8 paul 145
 
146
#ifdef HAVE_CMS
147
QImage ProofPict(QImage *Im, QString Prof, int Rend, cmsHPROFILE emPr)
148
#else
149
QImage ProofPict(QImage *Im, QString Prof, int Rend)
150
#endif
151
{
152
        bool emp = false;
153
        if (Prof == "")
154
                return Im->copy();
155
#ifdef HAVE_CMS
156
        QImage out = Im->copy();
157
        if ((CMSuse) && (SoftProofing))
167 Franz 158
        {
8 paul 159
                cmsHTRANSFORM xform;
160
                cmsHPROFILE inputProf;
167 Franz 161
                if (emPr != 0)
162
                        inputProf = emPr;
163
                else
164
                {
165
                        inputProf = cmsOpenProfileFromFile(InputProfiles[Prof], "r");
8 paul 166
                        emp = true;
167 Franz 167
                }
8 paul 168
                int dcmsFlags = 0;
167 Franz 169
                dcmsFlags |= Gamut ? cmsFLAGS_GAMUTCHECK : cmsFLAGS_SOFTPROOFING;
8 paul 170
                xform = cmsCreateProofingTransform(inputProf, TYPE_RGBA_8,
167 Franz 171
                                                                                                 CMSoutputProf, TYPE_RGBA_8,
172
                                                                                                 CMSprinterProf,
173
                                                                                                 IntentPrinter,
174
                                                                                                 Rend, dcmsFlags);
8 paul 175
                for (int i=0; i < out.height(); ++i)
167 Franz 176
                {
8 paul 177
                        LPBYTE ptr = out.scanLine(i);
178
                        cmsDoTransform(xform, ptr, ptr, out.width());
167 Franz 179
                }
8 paul 180
                cmsDeleteTransform(xform);
181
                if (emp)
182
                        cmsCloseProfile(inputProf);
167 Franz 183
        }
8 paul 184
        else
167 Franz 185
        {
186
                if (CMSuse)
8 paul 187
                {
188
                        cmsHTRANSFORM xform;
189
                        cmsHPROFILE inputProf;
167 Franz 190
                        if (emPr != 0)
191
                                inputProf = emPr;
192
                        else
193
                        {
194
                                inputProf = cmsOpenProfileFromFile(InputProfiles[Prof], "r");
8 paul 195
                                emp = true;
167 Franz 196
                        }
8 paul 197
                        xform = cmsCreateTransform(inputProf, TYPE_RGBA_8,
167 Franz 198
                                                                                         CMSoutputProf, TYPE_RGBA_8,
199
                                                                                         Rend,
200
                                                                                         0);
8 paul 201
                        for (int i=0; i < out.height(); ++i)
167 Franz 202
                        {
8 paul 203
                                LPBYTE ptr = out.scanLine(i);
204
                                cmsDoTransform(xform, ptr, ptr, out.width());
167 Franz 205
                        }
8 paul 206
                        cmsDeleteTransform(xform);
207
                        if (emp)
208
                                cmsCloseProfile(inputProf);
209
                }
167 Franz 210
        }
8 paul 211
        return out;
212
#else
213
        return Im->copy();
214
#endif
215
}
216
 
217
QImage ProofImage(QImage *Im)
218
{
219
#ifdef HAVE_CMS
220
        QImage out = Im->copy();
221
        if ((CMSuse) && (SoftProofing))
167 Franz 222
        {
223
                for (int i=0; i < out.height(); ++i)
8 paul 224
                {
225
                        LPBYTE ptr = out.scanLine(i);
226
                        cmsDoTransform(stdProofImg, ptr, ptr, out.width());
227
                }
167 Franz 228
        }
8 paul 229
        else
167 Franz 230
        {
231
                if (CMSuse)
8 paul 232
                {
167 Franz 233
                        for (int i=0; i < out.height(); ++i)
8 paul 234
                        {
235
                                LPBYTE ptr = out.scanLine(i);
236
                                cmsDoTransform(stdTransImg, ptr, ptr, out.width());
237
                        }
238
                }
167 Franz 239
        }
8 paul 240
        return out;
241
#else
242
        return Im->copy();
243
#endif
244
}
245
 
204 Franz 246
/******************************************************************
247
 * Function callGS()
248
 *   build the complete list of arguments for the call of our
249
 *   System() function.
250
 *
251
 *   The gs commands are all similar and consist of a few constant
252
 *   arguments, the variablke arguments and the end arguments which
253
 *   are also invariant.
254
 ******************************************************************/
255
 
256
int callGS(const QStringList & args_in)
257
{
1913 fschmid 258
        QString cmd1 = ScApp->Prefs.gs_exe;
259
        cmd1 += " -q -dNOPAUSE";
214 Franz 260
        if (ScApp->HavePngAlpha != 0)
1913 fschmid 261
                cmd1 += " -sDEVICE=png16m";
214 Franz 262
        else
1913 fschmid 263
                cmd1 += " -sDEVICE=pngalpha";
220 Franz 264
        if (ScApp->Prefs.gs_antiText)
1913 fschmid 265
                cmd1 += " -dTextAlphaBits=4";
220 Franz 266
        if (ScApp->Prefs.gs_antiGraph)
1913 fschmid 267
                cmd1 += " -dGraphicsAlphaBits=4";
2519 craig 268
        // Add -sFONTPATH to tell gs where any additional font paths are
269
        QStringList extraFonts;
2520 craig 270
        QFile fx(ScApp->PrefsPfad+"/scribusfont.rc");
2519 craig 271
        if (fx.open(IO_ReadOnly))
272
        {
273
                QTextStream tsx(&fx);
274
                QString extraPath = tsx.read();
275
                fx.close();
276
                extraFonts = QStringList::split("\n", extraPath);
277
        }
278
        if (extraFonts.count() >= 1)
279
                cmd1 += QString(" -sFONTPATH='%1'").arg(extraFonts[0]);
2520 craig 280
        for (int i = 1; i < static_cast<int>(extraFonts.count()); ++i)
2519 craig 281
                cmd1 += QString(":'%1'").arg(extraFonts[i]);
282
        // then combine the cmdline and run gs
1913 fschmid 283
        QString extArgs = args_in.join(" ");
284
        cmd1 += " " + extArgs + " -c showpage -c quit";
2644 craig 285
        return system(cmd1.local8Bit());
204 Franz 286
}
287
 
288
int copyFile(QString source, QString target)
289
{
290
        if ((source.isNull()) || (target.isNull()))
291
                return -1;
292
        if (source == target)
293
                return -1;
294
        QFile s(source);
295
        QFile t(target);
296
        if (!s.exists())
297
                return -1;
298
        QByteArray bb(s.size());
299
        if (s.open(IO_ReadOnly))
300
        {
301
                s.readBlock(bb.data(), s.size());
302
                s.close();
303
                if (t.open(IO_WriteOnly))
304
                {
305
                        t.writeBlock(bb.data(), bb.size());
306
                        t.close();
307
                }
308
        }
309
        return 0;
310
}
311
 
312
int moveFile(QString source, QString target)
313
{
314
        if ((source.isNull()) || (target.isNull()))
315
                return -1;
316
        if (source == target)
317
                return -1;
318
        copyFile(source, target);
319
        unlink(source);
320
        return 0;
321
}
322
 
1968 fschmid 323
QImage scaleImage(const QImage& src, int width, int height)
324
{
325
        QImage dst;
326
        dst.create(width, height,32);
327
        QRgb* xelrow = 0;
328
        QRgb* tempxelrow = 0;
329
        register QRgb* xP;
330
        register QRgb* nxP;
331
        int rows, cols, rowsread, newrows, newcols;
332
        register int row, col, needtoreadrow;
333
        const uchar maxval = 255;
334
        double xscale, yscale;
335
        long sxscale, syscale;
336
        register long fracrowtofill, fracrowleft;
337
        long* as;
338
        long* rs;
339
        long* gs;
340
        long* bs;
341
        int rowswritten = 0;
342
        cols = src.width();
343
        rows = src.height();
344
        newcols = dst.width();
345
        newrows = dst.height();
346
        long SCALE;
347
        long HALFSCALE;
348
        if (cols > 4096)
349
        {
350
                SCALE = 4096;
351
                HALFSCALE = 2048;
352
        }
353
        else
354
        {
355
                int fac = 4096;
356
                while (cols * fac > 4096)
357
                {
358
                        fac /= 2;
359
                }
360
                SCALE = fac * cols;
361
                HALFSCALE = fac * cols / 2;
362
        }
363
        xscale = (double) newcols / (double) cols;
364
        yscale = (double) newrows / (double) rows;
365
        sxscale = (long)(xscale * SCALE);
366
        syscale = (long)(yscale * SCALE);
367
        if ( newrows != rows )  /* shortcut Y scaling if possible */
368
                tempxelrow = new QRgb[cols];
369
        as = new long[cols];
370
        rs = new long[cols];
371
        gs = new long[cols];
372
        bs = new long[cols];
373
        rowsread = 0;
374
        fracrowleft = syscale;
375
        needtoreadrow = 1;
376
        for ( col = 0; col < cols; ++col )
377
                rs[col] = gs[col] =  as[col] = bs[col] = HALFSCALE;
378
        fracrowtofill = SCALE;
379
        for ( row = 0; row < newrows; ++row )
380
        {
381
                if ( newrows == rows )
382
                        tempxelrow = xelrow = (QRgb*)src.scanLine(rowsread++);
383
                else
384
                {
385
                        while ( fracrowleft < fracrowtofill )
386
                        {
387
                                if ( needtoreadrow && rowsread < rows )
388
                                        xelrow = (QRgb*)src.scanLine(rowsread++);
389
                                for ( col = 0, xP = xelrow; col < cols; ++col, ++xP )
390
                                {
391
                                        as[col] += fracrowleft * qAlpha( *xP );
392
                                        rs[col] += fracrowleft * qRed( *xP );
393
                                        gs[col] += fracrowleft * qGreen( *xP );
394
                                        bs[col] += fracrowleft * qBlue( *xP );
395
                                }
396
                                fracrowtofill -= fracrowleft;
397
                                fracrowleft = syscale;
398
                                needtoreadrow = 1;
399
                        }
400
                        if ( needtoreadrow && rowsread < rows )
401
                        {
402
                                xelrow = (QRgb*)src.scanLine(rowsread++);
403
                                needtoreadrow = 0;
404
                        }
405
                        register long a=0;
406
                        for ( col = 0, xP = xelrow, nxP = tempxelrow; col < cols; ++col, ++xP, ++nxP )
407
                        {
408
                                register long r, g, b;
409
                                a = as[col] + fracrowtofill * qAlpha( *xP );
410
                                r = rs[col] + fracrowtofill * qRed( *xP );
411
                                g = gs[col] + fracrowtofill * qGreen( *xP );
412
                                b = bs[col] + fracrowtofill * qBlue( *xP );
413
                                r /= SCALE;
414
                                if ( r > maxval ) r = maxval;
415
                                g /= SCALE;
416
                                if ( g > maxval ) g = maxval;
417
                                b /= SCALE;
418
                                if ( b > maxval ) b = maxval;
419
                                a /= SCALE;
420
                                if ( a > maxval ) a = maxval;
421
                                *nxP = qRgba( (int)r, (int)g, (int)b , (int)a);
422
                                rs[col] = as[col] = gs[col] = bs[col] = HALFSCALE;
423
                        }
424
                        fracrowleft -= fracrowtofill;
425
                        if ( fracrowleft == 0 )
426
                        {
427
                                fracrowleft = syscale;
428
                                needtoreadrow = 1;
429
                        }
430
                        fracrowtofill = SCALE;
431
                }
432
                if ( newcols == cols )
433
                        memcpy(dst.scanLine(rowswritten++), tempxelrow, newcols*4);
434
                else
435
                {
436
                        register long a, r, g, b;
437
                        register long fraccoltofill, fraccolleft = 0;
438
                        register int needcol;
439
                        nxP = (QRgb*)dst.scanLine(rowswritten++);
440
                        fraccoltofill = SCALE;
441
                        a = r = g = b = HALFSCALE;
442
                        needcol = 0;
443
                        for ( col = 0, xP = tempxelrow; col < cols; ++col, ++xP )
444
                        {
445
                                fraccolleft = sxscale;
446
                                while ( fraccolleft >= fraccoltofill )
447
                                {
448
                                        if ( needcol )
449
                                        {
450
                                                ++nxP;
451
                                                a = r = g = b = HALFSCALE;
452
                                        }
453
                                        a += fraccoltofill * qAlpha( *xP );
454
                                        r += fraccoltofill * qRed( *xP );
455
                                        g += fraccoltofill * qGreen( *xP );
456
                                        b += fraccoltofill * qBlue( *xP );
457
                                        r /= SCALE;
458
                                        if ( r > maxval ) r = maxval;
459
                                        g /= SCALE;
460
                                        if ( g > maxval ) g = maxval;
461
                                        b /= SCALE;
462
                                        if ( b > maxval ) b = maxval;
463
                                        a /= SCALE;
464
                                        if ( a > maxval ) a = maxval;
465
                                        *nxP = qRgba( (int)r, (int)g, (int)b, (int)a );
466
                                        fraccolleft -= fraccoltofill;
467
                                        fraccoltofill = SCALE;
468
                                        needcol = 1;
469
                                }
470
                                if ( fraccolleft > 0 )
471
                                {
472
                                        if ( needcol )
473
                                        {
474
                                                ++nxP;
475
                                                a = r = g = b = HALFSCALE;
476
                                                needcol = 0;
477
                                        }
478
                                        a += fraccolleft * qAlpha( *xP );
479
                                        r += fraccolleft * qRed( *xP );
480
                                        g += fraccolleft * qGreen( *xP );
481
                                        b += fraccolleft * qBlue( *xP );
482
                                        fraccoltofill -= fraccolleft;
483
                                }
484
                        }
485
                        if ( fraccoltofill > 0 )
486
                        {
487
                                --xP;
488
                                a += fraccolleft * qAlpha( *xP );
489
                                r += fraccoltofill * qRed( *xP );
490
                                g += fraccoltofill * qGreen( *xP );
491
                                b += fraccoltofill * qBlue( *xP );
492
                        }
493
                        if ( ! needcol )
494
                        {
495
                                r /= SCALE;
496
                                if ( r > maxval ) r = maxval;
497
                                g /= SCALE;
498
                                if ( g > maxval ) g = maxval;
499
                                b /= SCALE;
500
                                if ( b > maxval ) b = maxval;
501
                                a /= SCALE;
502
                                if ( a > maxval ) a = maxval;
503
                                *nxP = qRgba( (int)r, (int)g, (int)b, (int)a );
504
                        }
505
                }
506
        }
507
        if ( newrows != rows && tempxelrow )// Robust, tempxelrow might be 0 1 day
508
                delete [] tempxelrow;
509
        if ( as )                               // Avoid purify complaint
510
                delete [] as;
511
        if ( rs )                               // Robust, rs might be 0 one day
512
                delete [] rs;
513
        if ( gs )                               // Robust, gs might be 0 one day
514
                delete [] gs;
515
        if ( bs )                               // Robust, bs might be 0 one day
516
                delete [] bs;
517
        return dst;
518
}
519
 
20 Franz 520
QPixmap LoadPDF(QString fn, int Seite, int Size, int *w, int *h)
19 Franz 521
{
522
        QString tmp, cmd1, cmd2;
282 Franz 523
        QString tmpFile = QDir::convertSeparators(QDir::homeDirPath()+"/.scribus/sc.png");
19 Franz 524
        QPixmap pm;
525
        int ret = -1;
526
        tmp.setNum(Seite);
204 Franz 527
        QStringList args;
528
        args.append("-r72");
529
        args.append("-sOutputFile="+tmpFile);
530
        args.append("-dFirstPage="+tmp);
531
        args.append("-dLastPage="+tmp);
1859 fschmid 532
        args.append("\""+fn+"\"");
204 Franz 533
        ret = callGS(args);
19 Franz 534
        if (ret == 0)
167 Franz 535
        {
19 Franz 536
                QImage image;
159 Franz 537
                image.load(tmpFile);
204 Franz 538
                unlink(tmpFile);
167 Franz 539
                QImage im2;
20 Franz 540
                *h = image.height();
541
                *w = image.width();
80 Franz 542
                double sx = image.width() / static_cast<double>(Size);
543
                double sy = image.height() / static_cast<double>(Size);
167 Franz 544
                double t = (sy < sx ? sx : sy);
545
                im2 = image.smoothScale(static_cast<int>(image.width() / t), static_cast<int>(image.height() / t));
19 Franz 546
                pm.convertFromImage(im2);
547
                QPainter p;
548
                p.begin(&pm);
549
                p.setBrush(Qt::NoBrush);
550
                p.setPen(Qt::black);
551
                p.drawRect(0, 0, pm.width(), pm.height());
552
                p.end();
553
                im2.detach();
167 Franz 554
        }
19 Franz 555
        return pm;
556
}
557
 
201 Franz 558
QImage LoadPict(QString fn, bool *gray)
8 paul 559
{
84 Franz 560
        QString tmp, dummy, cmd1, cmd2, BBox, tmp2;
8 paul 561
        QChar tc;
562
        QImage Bild;
80 Franz 563
        double x, y, b, h;
8 paul 564
        bool found = false;
565
        int ret = -1;
282 Franz 566
        QString tmpFile = QDir::convertSeparators(QDir::homeDirPath()+"/.scribus/sc.png");
8 paul 567
        QFileInfo fi = QFileInfo(fn);
568
        QString ext = fi.extension(false).lower();
16 Franz 569
        if (ext == "pdf")
167 Franz 570
        {
204 Franz 571
                QStringList args;
572
                args.append("-r72");
573
                args.append("-sOutputFile="+tmpFile);
574
                args.append("-dFirstPage=1");
575
                args.append("-dLastPage=1");
1859 fschmid 576
                args.append("\""+fn+"\"");
204 Franz 577
                ret = callGS(args);
16 Franz 578
                if (ret == 0)
167 Franz 579
                {
16 Franz 580
                        QImage image;
159 Franz 581
                        image.load(tmpFile);
167 Franz 582
                        Bild = image.convertDepth(32);
204 Franz 583
                        unlink(tmpFile);
16 Franz 584
                }
167 Franz 585
        }
8 paul 586
        if ((ext == "eps") || (ext == "ps"))
167 Franz 587
        {
8 paul 588
                QFile f(fn);
589
                if (f.open(IO_ReadOnly))
167 Franz 590
                {
8 paul 591
                        QTextStream ts(&f);
592
                        while (!ts.atEnd())
167 Franz 593
                        {
8 paul 594
                                tc = ' ';
595
                                tmp = "";
596
                                while ((tc != '\n') && (tc != '\r'))
167 Franz 597
                                {
8 paul 598
                                        ts >> tc;
599
                                        if ((tc != '\n') && (tc != '\r'))
600
                                                tmp += tc;
167 Franz 601
                                }
286 Franz 602
                                if (tmp.startsWith("%%BoundingBox:"))
167 Franz 603
                                {
8 paul 604
                                        found = true;
286 Franz 605
                                        BBox = tmp.remove("%%BoundingBox:");
167 Franz 606
                                }
286 Franz 607
                                if (!found)
608
                                {
609
                                        if (tmp.startsWith("%%BoundingBox"))
610
                                        {
611
                                                found = true;
612
                                                BBox = tmp.remove("%%BoundingBox");
613
                                        }
614
                                }
8 paul 615
                                if (tmp.startsWith("%%EndComments"))
616
                                        break;
167 Franz 617
                        }
8 paul 618
                        f.close();
619
                        if (found)
167 Franz 620
                        {
8 paul 621
                                QTextStream ts2(&BBox, IO_ReadOnly);
286 Franz 622
                                ts2 >> x >> y >> b >> h;
204 Franz 623
                                QStringList args;
624
                                args.append("-r72");
625
                                args.append("-sOutputFile="+tmpFile);
626
                                args.append("-g"+tmp.setNum(qRound(b))+"x"+tmp2.setNum(qRound(h)));
1859 fschmid 627
                                args.append("\""+fn+"\"");
204 Franz 628
                                ret = callGS(args);
8 paul 629
                                if (ret == 0)
167 Franz 630
                                {
8 paul 631
                                        QImage image;
159 Franz 632
                                        image.load(tmpFile);
188 Franz 633
                                        image = image.convertDepth(32);
634
                                        image.setAlphaBuffer(true);
214 Franz 635
                                        if (ScApp->HavePngAlpha != 0)
636
                                        {
637
                                                int wi = image.width();
638
                                                int hi = image.height();
639
                                            for( int yi=0; yi < hi; ++yi )
8 paul 640
                                                {
214 Franz 641
                                                        QRgb *s = (QRgb*)(image.scanLine( yi ));
642
                                                        for(int xi=0; xi < wi; ++xi )
8 paul 643
                                                        {
214 Franz 644
                                                                if((*s) == 0xffffffff)
645
                                                                        (*s) &= 0x00ffffff;
646
                                                                s++;
188 Franz 647
                                                        }
648
                                        }
214 Franz 649
                                        }
188 Franz 650
                                        Bild = image.copy(static_cast<int>(x), 0, static_cast<int>(b-x), static_cast<int>(h-y));
204 Franz 651
                                        unlink(tmpFile);
8 paul 652
                                }
653
                        }
654
                }
167 Franz 655
        }
8 paul 656
#ifdef HAVE_TIFF
657
        if (ext == "tif")
167 Franz 658
        {
8 paul 659
                QImage img;
660
                QImage inI2;
2644 craig 661
                TIFF* tif = TIFFOpen(fn.local8Bit(), "r");
8 paul 662
                if(tif)
167 Franz 663
                {
8 paul 664
                        unsigned width, height,size;
665
                        TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width);
666
                        TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height);
667
                        size=width*height;
668
                        uint32 *bits=(uint32*) _TIFFmalloc(size * sizeof (uint32));
669
                        if(bits)
167 Franz 670
                        {
671
                                if (TIFFReadRGBAImage(tif, width, height, bits, 0))
8 paul 672
                                {
189 Franz 673
                                img.create(width,height,32);
674
                                img.setAlphaBuffer(true);
8 paul 675
                                        if(TIFFGetR(0x1234567)==qRed  (0x1234567) &&
676
                                                 TIFFGetG(0x1234567)==qGreen(0x1234567) &&
677
                                                 TIFFGetB(0x1234567)==qBlue (0x1234567))
167 Franz 678
                                        {
8 paul 679
                                                for(unsigned y=0; y<height; ++y)
680
                                                        memcpy(img.scanLine(height-1-y),bits+y*width,width*4);
167 Franz 681
                                        }
8 paul 682
                                        else
167 Franz 683
                                        {
8 paul 684
                                                uint32 *inp=bits;
685
                                                for(unsigned y=0; y<height; ++y)
167 Franz 686
                                                {
8 paul 687
                                                        QRgb *row=(QRgb*) (img.scanLine(height-1-y));
688
                                                        for(unsigned x=0; x<width; ++x)
167 Franz 689
                                                        {
8 paul 690
                                                                const uint32 col=*(inp++);
189 Franz 691
                                                                row[x]=qRgba(TIFFGetR(col), TIFFGetG(col), TIFFGetB(col), TIFFGetA(col));
8 paul 692
                                                        }
693
                                                }
167 Franz 694
                                        }
8 paul 695
                                        Bild = img.copy();
167 Franz 696
                                }
8 paul 697
                                _TIFFfree(bits);
167 Franz 698
                        }
8 paul 699
                        TIFFClose(tif);
700
                }
167 Franz 701
        }
8 paul 702
#endif
703
        else
167 Franz 704
        {
868 fschmid 705
                if (Bild.load(fn))
201 Franz 706
                {
868 fschmid 707
                        if (gray != 0)
708
                        {
709
                                if ((Bild.depth() == 8) && (Bild.isGrayscale()))
710
                                        *gray = true;
711
                                else
712
                                        *gray = false;
713
                        }
714
                        Bild = Bild.convertDepth(32);
201 Franz 715
                }
167 Franz 716
        }
8 paul 717
        return Bild;
718
}
719
 
720
#ifdef HAVE_CMS
721
QImage LoadPictCol(QString fn, QString Prof, bool UseEmbedded, bool *realCMYK)
722
{
84 Franz 723
        QString tmp, dummy, cmd1, cmd2, BBox, tmp2;
8 paul 724
        QChar tc;
725
        QImage Bild;
80 Franz 726
        double x, y, b, h;
8 paul 727
        bool found = false;
728
        int ret = -1;
282 Franz 729
        QString tmpFile = QDir::convertSeparators(QDir::homeDirPath()+"/.scribus/sc.png");
8 paul 730
        QFileInfo fi = QFileInfo(fn);
731
        QString ext = fi.extension(false).lower();
16 Franz 732
        if (ext == "pdf")
167 Franz 733
        {
204 Franz 734
                QStringList args;
735
                args.append("-r72");
736
                args.append("-sOutputFile="+tmpFile);
737
                args.append("-dFirstPage=1");
738
                args.append("-dLastPage=1");
1859 fschmid 739
                args.append("\""+fn+"\"");
204 Franz 740
                ret = callGS(args);
16 Franz 741
                if (ret == 0)
167 Franz 742
                {
16 Franz 743
                        QImage image;
159 Franz 744
                        image.load(tmpFile);
167 Franz 745
                        Bild = image.convertDepth(32);
204 Franz 746
                        unlink(tmpFile);
16 Franz 747
                        *realCMYK = false;
748
                }
167 Franz 749
                }
750
                if ((ext == "eps") || (ext == "ps"))
8 paul 751
                {
167 Franz 752
                        QFile f(fn);
753
                        if (f.open(IO_ReadOnly))
8 paul 754
                        {
167 Franz 755
                                QTextStream ts(&f);
756
                                while (!ts.atEnd())
8 paul 757
                                {
167 Franz 758
                                        tc = ' ';
759
                                        tmp = "";
760
                                        while ((tc != '\n') && (tc != '\r'))
8 paul 761
                                        {
167 Franz 762
                                                ts >> tc;
763
                                                if ((tc != '\n') && (tc != '\r'))
764
                                                        tmp += tc;
8 paul 765
                                        }
286 Franz 766
                                        if (tmp.startsWith("%%BoundingBox:"))
8 paul 767
                                        {
167 Franz 768
                                                found = true;
286 Franz 769
                                                BBox = tmp.remove("%%BoundingBox:");
8 paul 770
                                        }
286 Franz 771
                                        if (!found)
772
                                        {
773
                                                if (tmp.startsWith("%%BoundingBox"))
774
                                                {
775
                                                        found = true;
776
                                                        BBox = tmp.remove("%%BoundingBox");
777
                                                }
778
                                        }
167 Franz 779
                                        if (tmp.startsWith("%%EndComments"))
780
                                                break;
8 paul 781
                                }
167 Franz 782
                                f.close();
783
                                if (found)
8 paul 784
                                {
167 Franz 785
                                        QTextStream ts2(&BBox, IO_ReadOnly);
286 Franz 786
                                        ts2 >> x >> y >> b >> h;
204 Franz 787
                                        QStringList args;
788
                                        args.append("-r72");
789
                                        args.append("-sOutputFile="+tmpFile);
790
                                        args.append("-g"+tmp.setNum(qRound(b))+"x"+tmp2.setNum(qRound(h)));
1859 fschmid 791
                                        args.append("\""+fn+"\"");
204 Franz 792
                                        ret = callGS(args);
167 Franz 793
                                        if (ret == 0)
8 paul 794
                                        {
167 Franz 795
                                                QImage image;
796
                                                image.load(tmpFile);
188 Franz 797
                                                image = image.convertDepth(32);
798
                                                image.setAlphaBuffer(true);
214 Franz 799
                                                if (ScApp->HavePngAlpha != 0)
800
                                                {
801
                                                        int wi = image.width();
802
                                                        int hi = image.height();
803
                                                    for( int yi=0; yi < hi; ++yi )
8 paul 804
                                                        {
214 Franz 805
                                                                QRgb *s = (QRgb*)(image.scanLine( yi ));
806
                                                                for(int xi=0; xi < wi; ++xi )
8 paul 807
                                                                {
214 Franz 808
                                                                        if((*s) == 0xffffffff)
809
                                                                                (*s) &= 0x00ffffff;
810
                                                                        s++;
188 Franz 811
                                                                }
214 Franz 812
                                                        }
813
                                            }
188 Franz 814
                                                Bild = image.copy(static_cast<int>(x), 0, static_cast<int>(b-x), static_cast<int>(h-y));
204 Franz 815
                                                unlink(tmpFile);
167 Franz 816
                                                *realCMYK = false;
8 paul 817
                                        }
818
                                }
819
                        }
820
                }
821
#ifdef HAVE_TIFF
167 Franz 822
                if (ext == "tif")
8 paul 823
                {
167 Franz 824
                        QImage img;
825
                        QImage inI2;
2644 craig 826
                        TIFF* tif = TIFFOpen(fn.local8Bit(), "r");
167 Franz 827
                        if(tif)
8 paul 828
                        {
167 Franz 829
                        DWORD EmbedLen = 0;
830
                        LPBYTE EmbedBuffer;
831
                                unsigned width, height,size;
832
                                TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width);
833
                                TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height);
834
                                size=width*height;
835
                                uint32 *bits=(uint32*) _TIFFmalloc(size * sizeof (uint32));
836
                                if(bits)
8 paul 837
                                {
167 Franz 838
                                        if (TIFFReadRGBAImage(tif, width, height, bits, 0))
8 paul 839
                                        {
167 Franz 840
                                img.create(width,height,32);
189 Franz 841
                                img.setAlphaBuffer(true);
167 Franz 842
                                                if(TIFFGetR(0x1234567)==qRed  (0x1234567) &&
843
                                                         TIFFGetG(0x1234567)==qGreen(0x1234567) &&
844
                                                         TIFFGetB(0x1234567)==qBlue (0x1234567))
8 paul 845
                                                {
167 Franz 846
                                                        for(unsigned y=0; y<height; ++y)
847
                                                                memcpy(img.scanLine(height-1-y),bits+y*width,width*4);
8 paul 848
                                                }
167 Franz 849
                                                else
8 paul 850
                                                {
167 Franz 851
                                                        uint32 *inp=bits;
852
                                                        for(unsigned y=0; y<height; ++y)
8 paul 853
                                                        {
167 Franz 854
                                                                QRgb *row=(QRgb*) (img.scanLine(height-1-y));
855
                                                                for(unsigned x=0; x<width; ++x)
8 paul 856
                                                                {
167 Franz 857
                                                                        const uint32 col=*(inp++);
189 Franz 858
                                                                        row[x]=qRgba(TIFFGetR(col), TIFFGetG(col), TIFFGetB(col), TIFFGetA(col));
8 paul 859
                                                                }
860
                                                        }
861
                                                }
167 Franz 862
                                                Bild = img.copy();
8 paul 863
                                        }
167 Franz 864
                                        _TIFFfree(bits);
865
                                        cmsHTRANSFORM xform;
866
                                        cmsHPROFILE inputProf;
867
                                        if((TIFFGetField(tif, TIFFTAG_ICCPROFILE, &EmbedLen, &EmbedBuffer)) && (UseEmbedded))
8 paul 868
                                        {
167 Franz 869
                                                inputProf = cmsOpenProfileFromMem(EmbedBuffer, EmbedLen);
870
                                                if (static_cast<int>(cmsGetColorSpace(inputProf)) == icSigRgbData)
8 paul 871
                                                {
167 Franz 872
                                                        switch (static_cast<int>(cmsGetColorSpace(CMSprinterProf)))
8 paul 873
                                                        {
167 Franz 874
                                                                case icSigRgbData:
875
                                                                                *realCMYK = false;
876
                                                                                xform = cmsCreateTransform(inputProf, TYPE_RGBA_8, CMSprinterProf,
877
                                                                                                                                         TYPE_RGBA_8, IntentPrinter, 0);
878
                                                                                break;
879
                                                                case icSigCmykData:
880
                                                                                *realCMYK = true;
881
                                                                                xform = cmsCreateTransform(inputProf, TYPE_RGBA_8, CMSprinterProf,
882
                                                                                                                                         TYPE_CMYK_8, IntentPrinter, 0);
883
                                                                        break;
8 paul 884
                                                        }
167 Franz 885
                                                        for (int i=0; i < Bild.height(); ++i)
8 paul 886
                                                        {
167 Franz 887
                                                                LPBYTE ptr = Bild.scanLine(i);
888
                                                                cmsDoTransform(xform, ptr, ptr, Bild.width());
8 paul 889
                                                        }
890
                                                }
891
                                        }
167 Franz 892
                                        else
8 paul 893
                                        {
167 Franz 894
                                                inputProf = cmsOpenProfileFromFile(InputProfiles[Prof], "r");
895
                                                switch (static_cast<int>(cmsGetColorSpace(CMSprinterProf)))
8 paul 896
                                                {
167 Franz 897
                                                        case icSigRgbData:
898
                                                                                *realCMYK = false;
899
                                                                                xform = cmsCreateTransform(inputProf, TYPE_RGBA_8, CMSprinterProf,
900
                                                                                                                                         TYPE_RGBA_8, IntentPrinter, 0);
901
                                                                                break;
902
                                                        case icSigCmykData:
903
                                                                                *realCMYK = true;
904
                                                                                xform = cmsCreateTransform(inputProf, TYPE_RGBA_8, CMSprinterProf,
905
                                                                                                                                         TYPE_CMYK_8, IntentPrinter, 0);
906
                                                                                break;
8 paul 907
                                                }
167 Franz 908
                                                for (int i=0; i < Bild.height(); ++i)
8 paul 909
                                                {
167 Franz 910
                                                        LPBYTE ptr = Bild.scanLine(i);
911
                                                        cmsDoTransform(xform, ptr, ptr, Bild.width());
8 paul 912
                                                }
913
                                        }
167 Franz 914
                                        cmsDeleteTransform(xform);
915
                                        cmsCloseProfile(inputProf);
8 paul 916
                                }
167 Franz 917
                                TIFFClose(tif);
8 paul 918
                        }
919
                }
920
#endif
921
        else
167 Franz 922
        {
8 paul 923
                cmsHTRANSFORM xform;
924
                cmsHPROFILE inputProf;
925
                Bild.load(fn);
167 Franz 926
                Bild = Bild.convertDepth(32);
8 paul 927
                inputProf = cmsOpenProfileFromFile(InputProfiles[Prof], "r");
49 paul 928
                switch (static_cast<int>(cmsGetColorSpace(CMSprinterProf)))
167 Franz 929
                {
8 paul 930
                        case icSigRgbData:
931
                                *realCMYK = false;
932
                                xform = cmsCreateTransform(inputProf, TYPE_RGBA_8, CMSprinterProf, TYPE_RGBA_8, IntentPrinter, 0);
933
                                break;
934
                        case icSigCmykData:
935
                                *realCMYK = true;
936
                                xform = cmsCreateTransform(inputProf, TYPE_RGBA_8, CMSprinterProf, TYPE_CMYK_8, IntentPrinter, 0);
937
                                break;
167 Franz 938
                }
8 paul 939
                for (int i=0; i < Bild.height(); ++i)
167 Franz 940
                {
8 paul 941
                        LPBYTE ptr = Bild.scanLine(i);
942
                        cmsDoTransform(xform, ptr, ptr, Bild.width());
167 Franz 943
                }
8 paul 944
                cmsDeleteTransform(xform);
150 Franz 945
                cmsCloseProfile(inputProf);
167 Franz 946
        }
8 paul 947
        return Bild;
948
}
949
#endif
950
 
951
QString GetAttr(QDomElement *el, QString at, QString def)
952
{
953
        return el->attribute(at, def);
954
}
955
 
956
int QStoInt(QString in)
957
{
958
        bool ok = false;
959
        int c = in.toInt(&ok);
167 Franz 960
        return ok ? c : 0;
8 paul 961
}
962
 
80 Franz 963
double QStodouble(QString in)
8 paul 964
{
965
        bool ok = false;
80 Franz 966
        double c = in.toDouble(&ok);
167 Franz 967
        return ok ? c : 0.0;
8 paul 968
}
969
 
970
QPixmap loadIcon(QString nam)
971
{
870 cbradney 972
        QString pfad = ICONDIR;
973
        pfad += nam;
8 paul 974
        QPixmap pm;
975
        pm.load(pfad);
976
        return pm;
977
}
978
 
1108 fschmid 979
uint getDouble(QString in, bool raw)
980
{
981
        QByteArray bb(4);
982
        if (raw)
983
        {
984
                bb[3] = static_cast<uchar>(QChar(in.at(0)));
985
                bb[2] = static_cast<uchar>(QChar(in.at(1)));
986
                bb[1] = static_cast<uchar>(QChar(in.at(2)));
987
                bb[0] = static_cast<uchar>(QChar(in.at(3)));
988
        }
989
        else
990
        {
991
                bb[0] = static_cast<uchar>(QChar(in.at(0)));
992
                bb[1] = static_cast<uchar>(QChar(in.at(1)));
993
                bb[2] = static_cast<uchar>(QChar(in.at(2)));
994
                bb[3] = static_cast<uchar>(QChar(in.at(3)));
995
        }
996
        uint ret;
997
        ret = bb[0] & 0xff;
998
        ret |= (bb[1] << 8) & 0xff00;
999
        ret |= (bb[2] << 16) & 0xff0000;
1000
        ret |= (bb[3] << 24) & 0xff000000;
1001
        return ret;
1002
}
1003
 
8 paul 1004
bool loadText(QString nam, QString *Buffer)
1005
{
1006
        QFile f(nam);
1007
        QFileInfo fi(f);
1008
        if (!fi.exists())
1009
                return false;
1010
        uint posi;
167 Franz 1011
        bool ret;
8 paul 1012
        QByteArray bb(f.size());
1013
        if (f.open(IO_ReadOnly))
167 Franz 1014
        {
8 paul 1015
                f.readBlock(bb.data(), f.size());
1016
                f.close();
1017
                for (posi = 0; posi < bb.size(); ++posi)
1018
                        *Buffer += bb[posi];
1019
                ret = true;
167 Franz 1020
        }
8 paul 1021
        else
1022
                ret = false;
1023
        return ret;
1024
}
1025
 
80 Franz 1026
double Cwidth(ScribusDoc *doc, QString name, QString ch, int Siz, QString ch2)
8 paul 1027
{
80 Franz 1028
        double w;
8 paul 1029
        FT_Vector  delta;
1030
        uint c1 = ch.at(0).unicode();
1031
        uint c2 = ch2.at(0).unicode();
1032
        Foi* fo = (*doc->AllFonts)[name];
1033
        if (fo->CharWidth.contains(c1))
167 Franz 1034
        {
111 Franz 1035
                w = fo->CharWidth[c1]*(Siz / 10.0);
5335 avox 1036
                // fix #3661
1037
                if (true || fo->HasKern)
167 Franz 1038
                {
8 paul 1039
                        uint cl = FT_Get_Char_Index(doc->FFonts[name], c1);
1040
                        uint cr = FT_Get_Char_Index(doc->FFonts[name], c2);
9 Franz 1041
                        FT_Get_Kerning(doc->FFonts[name], cl, cr, ft_kerning_unscaled, &delta);
111 Franz 1042
                        w += delta.x / fo->uniEM * (Siz / 10.0);
167 Franz 1043
                }
8 paul 1044
                return w;
167 Franz 1045
        }
8 paul 1046
        else
111 Franz 1047
                return static_cast<double>(Siz / 10.0);
8 paul 1048
}
1049
 
220 Franz 1050
double RealCWidth(ScribusDoc *doc, QString name, QString ch, int Siz)
1051
{
221 Franz 1052
        double w, ww;
220 Franz 1053
        uint c1 = ch.at(0).unicode();
1054
        Foi* fo = (*doc->AllFonts)[name];
1055
        if (fo->CharWidth.contains(c1))
1056
        {
1057
                uint cl = FT_Get_Char_Index(doc->FFonts[name], c1);
1058
                FT_Load_Glyph( doc->FFonts[name], cl, FT_LOAD_NO_SCALE | FT_LOAD_NO_BITMAP );
503 cbradney 1059
                w = (doc->FFonts[name]->glyph->metrics.width + fabs((double)doc->FFonts[name]->glyph->metrics.horiBearingX)) / fo->uniEM * (Siz / 10.0);
221 Franz 1060
                ww = doc->FFonts[name]->glyph->metrics.horiAdvance / fo->uniEM * (Siz / 10.0);
1061
                return QMAX(ww, w);
220 Franz 1062
        }
1063
        else
1064
                return static_cast<double>(Siz / 10.0);
1065
}
1066
 
2283 fschmid 1067
double RealCHeight(ScribusDoc *currentDoc, QString name, QString ch, int Size)
1068
{
1069
        double w;
1070
        uint c1 = ch.at(0).unicode();
1071
        FT_Face      face;
1072
        Foi* fo = (*currentDoc->AllFonts)[name];
1073
        if (fo->CharWidth.contains(c1))
1074
        {
1075
                face = currentDoc->FFonts[name];
1076
                uint cl = FT_Get_Char_Index(face, c1);
1077
                FT_Load_Glyph(face, cl, FT_LOAD_NO_SCALE | FT_LOAD_NO_BITMAP );
1078
                w = face->glyph->metrics.height / fo->uniEM * (Size / 10.0);
1079
                return w;
1080
        }
1081
        else
1082
                return static_cast<double>(Size / 10.0);
1083
}
1084
 
1085
double RealCAscent(ScribusDoc *currentDoc, QString name, QString ch, int Size)
1086
{
1087
        double w;
1088
        uint c1 = ch.at(0).unicode();
1089
        FT_Face      face;
1090
        Foi* fo = (*currentDoc->AllFonts)[name];
1091
        if (fo->CharWidth.contains(c1))
1092
        {
1093
                face = currentDoc->FFonts[name];
1094
                uint cl = FT_Get_Char_Index(face, c1);
1095
                FT_Load_Glyph(face, cl, FT_LOAD_NO_SCALE | FT_LOAD_NO_BITMAP );
1096
                w = face->glyph->metrics.horiBearingY / fo->uniEM * (Size / 10.0);
1097
                return w;
1098
        }
1099
        else
1100
                return static_cast<double>(Size / 10.0);
1101
}
1102
 
80 Franz 1103
QPointArray RegularPolygon(double w, double h, uint c, bool star, double factor, double rota)
8 paul 1104
{
167 Franz 1105
        uint cx = star ? c * 2 : c;
80 Franz 1106
        double seg = 360.0 / cx;
1107
        double sc = rota + 180.0;
1108
        double di = factor;
8 paul 1109
        int mx = 0;
1110
        int my = 0;
1111
        QPointArray pts = QPointArray();
1112
        for (uint x = 0; x < cx; ++x)
167 Franz 1113
        {
8 paul 1114
                sc = seg * x + 180.0 + rota;
1115
                if (star)
167 Franz 1116
                {
1117
                        double wf = x % 2 == 0 ? w / 2 : w / 2 * di;
1118
                        double hf = x % 2 == 0 ? h / 2 : h / 2 * di;
1119
                        mx = qRound(sin(sc / 180 * M_PI) * (wf) + (w/2));
1120
                        my = qRound(cos(sc / 180 * M_PI) * (hf) + (h/2));
1121
                }
8 paul 1122
                else
167 Franz 1123
                {
8 paul 1124
                        mx = qRound(sin(sc / 180 * M_PI) * (w/2) + (w/2));
1125
                        my = qRound(cos(sc / 180 * M_PI) * (h/2) + (h/2));
167 Franz 1126
                }
8 paul 1127
                pts.resize(x+1);
1128
                pts.setPoint(x, mx, my);
167 Franz 1129
        }
8 paul 1130
        return pts;
1131
}
1132
 
80 Franz 1133
FPointArray RegularPolygonF(double w, double h, uint c, bool star, double factor, double rota)
8 paul 1134
{
167 Franz 1135
        uint cx = star ? c * 2 : c;
80 Franz 1136
        double seg = 360.0 / cx;
1137
        double sc = rota + 180.0;
1138
        double di = factor;
1139
        double mx = 0;
1140
        double my = 0;
8 paul 1141
        FPointArray pts = FPointArray();
1142
        for (uint x = 0; x < cx; ++x)
167 Franz 1143
        {
8 paul 1144
                sc = seg * x + 180.0 + rota;
1145
                if (star)
167 Franz 1146
                {
1147
                        double wf = x % 2 == 0 ? w / 2 : w / 2 * di;
1148
                        double hf = x % 2 == 0 ? h / 2 : h / 2 * di;
1149
                        mx = qRound(sin(sc / 180 * M_PI) * (wf) + (w/2));
1150
                        my = qRound(cos(sc / 180 * M_PI) * (hf) + (h/2));
1151
                }
8 paul 1152
                else
167 Franz 1153
                {
8 paul 1154
                        mx = sin(sc / 180 * M_PI) * (w/2) + (w/2);
1155
                        my = cos(sc / 180 * M_PI) * (h/2) + (h/2);
167 Franz 1156
                }
8 paul 1157
                pts.resize(x+1);
1158
                pts.setPoint(x, mx, my);
167 Franz 1159
        }
8 paul 1160
        return pts;
1161
}
1162
 
1163
QPointArray FlattenPath(FPointArray ina, QValueList<uint> &Segs)
1164
{
1165
        QPointArray Bez(4);
1166
        QPointArray outa, cli;
1167
        Segs.clear();
1168
        if (ina.size() > 3)
167 Franz 1169
        {
1170
                for (uint poi=0; poi<ina.size()-3; poi += 4)
8 paul 1171
                {
167 Franz 1172
                        if (ina.point(poi).x() > 900000)
8 paul 1173
                        {
1174
                                outa.resize(outa.size()+1);
1175
                                outa.setPoint(outa.size()-1, cli.point(cli.size()-1));
80 Franz 1176
                                Segs.append(outa.size());
8 paul 1177
                                continue;
167 Franz 1178
                        }
8 paul 1179
                        BezierPoints(&Bez, ina.pointQ(poi), ina.pointQ(poi+1), ina.pointQ(poi+3), ina.pointQ(poi+2));
1180
                        cli = Bez.cubicBezier();
1181
                        outa.putPoints(outa.size(), cli.size()-1, cli);
167 Franz 1182
                }
8 paul 1183
                outa.resize(outa.size()+1);
1184
                outa.setPoint(outa.size()-1, cli.point(cli.size()-1));
167 Franz 1185
        }
8 paul 1186
        return outa;
1187
}
1188
 
80 Franz 1189
double xy2Deg(double x, double y)
8 paul 1190
{
1191
        return (atan2(y,x)*(180.0/M_PI));
1192
}
1193
 
1194
void BezierPoints(QPointArray *ar, QPoint n1, QPoint n2, QPoint n3, QPoint n4)
1195
{
1196
        ar->setPoint(0, n1);
1197
        ar->setPoint(1, n2);
1198
        ar->setPoint(2, n3);
1199
        ar->setPoint(3, n4);
1200
        return;
1201
}
1202
 
1203
void Level2Layer(ScribusDoc *doc, struct Layer *ll, int Level)
1204
{
1205
        for (uint la2 = 0; la2 < doc->Layers.count(); ++la2)
167 Franz 1206
        {
1207
                if (doc->Layers[la2].Level == Level)
8 paul 1208
                {
1209
                        ll->Sichtbar = doc->Layers[la2].Sichtbar;
1210
                        ll->Drucken = doc->Layers[la2].Drucken;
1211
                        ll->LNr = doc->Layers[la2].LNr;
1212
                        break;
1213
                }
167 Franz 1214
        }
8 paul 1215
}
1216
 
2129 fschmid 1217
int Layer2Level(ScribusDoc *currentDoc, int LayerNr)
1218
{
1219
        for (uint la2 = 0; la2 < currentDoc->Layers.count(); ++la2)
1220
        {
1221
                if (currentDoc->Layers[la2].LNr == LayerNr)
1222
                        return currentDoc->Layers[la2].Level;
1223
        }
1224
        return 0;
1225
}
1226
 
8 paul 1227
QString ImageToTxt(QImage *im)
1228
{
1229
        int h = im->height();
1230
        int w = im->width();
1231
        QString ImgStr = "";
1232
        for( int yi=0; yi < h; ++yi )
167 Franz 1233
        {
8 paul 1234
                QRgb * s = (QRgb*)(im->scanLine( yi ));
1235
                for( int xi=0; xi < w; ++xi )
167 Franz 1236
                {
8 paul 1237
                        QRgb r=*s++;
1238
                        unsigned char u=qRed(r);
1239
                        ImgStr += u;
1240
                        u=qGreen(r);
1241
                        ImgStr += u;
1242
                        u=qBlue(r);
1243
                        ImgStr += u;
1244
                }
167 Franz 1245
        }
8 paul 1246
        return ImgStr;
1247
}
1248
 
1249
QString ImageToCMYK(QImage *im)
1250
{
1251
        int h = im->height();
1252
        int w = im->width();
1253
        QString ImgStr = "";
1254
        for( int yi=0; yi < h; ++yi )
167 Franz 1255
        {
8 paul 1256
                QRgb * s = (QRgb*)(im->scanLine( yi ));
1257
                for( int xi=0; xi < w; ++xi )
167 Franz 1258
                {
201 Franz 1259
                        QRgb r=*s;
8 paul 1260
                        int c = 255 - qRed(r);
1261
                        int m = 255 - qGreen(r);
1262
                        int y = 255 - qBlue(r);
1263
                        int k = QMIN(QMIN(c, m), y);
201 Franz 1264
                        *s = qRgba(m - k, y - k, k, c - k);
8 paul 1265
                        ImgStr += c - k;
1266
                        ImgStr += m - k;
1267
                        ImgStr += y - k;
1268
                        ImgStr += k;
201 Franz 1269
                        s++;
8 paul 1270
                }
167 Franz 1271
        }
8 paul 1272
        return ImgStr;
1273
}
1274
 
1275
QString ImageToCMYK_PS(QImage *im, int pl, bool pre)
1276
{
1277
        int h = im->height();
1278
        int w = im->width();
1279
        QString ImgStr = "";
1280
        if (pre)
167 Franz 1281
        {
1282
                for( int yi=0; yi < h; ++yi )
8 paul 1283
                {
1284
                        QRgb * s = (QRgb*)(im->scanLine( yi ));
1285
                        for( int xi=0; xi < w; ++xi )
167 Franz 1286
                        {
8 paul 1287
                                QRgb r=*s++;
1288
                                int c = qRed(r);
1289
                                int m = qGreen(r);
1290
                                int y = qBlue(r);
1291
                                int k = qAlpha(r);
1292
                                if (pl == -1)
167 Franz 1293
                                {
8 paul 1294
                                        ImgStr += c;
1295
                                        ImgStr += m;
1296
                                        ImgStr += y;
1297
                                        ImgStr += k;
167 Franz 1298
                                }
8 paul 1299
                                else
167 Franz 1300
                                {
8 paul 1301
                                        if (pl == -2)
1302
                                                ImgStr += QMIN(255, qRound(0.3 * c + 0.59 * m + 0.11 * y + k));
1303
                                        if (pl == 1)
1304
                                                ImgStr += c;
1305
                                        if (pl == 2)
1306
                                                ImgStr += m;
1307
                                        if (pl == 3)
1308
                                                ImgStr += y;
1309
                                        if (pl == 0)
1310
                                                ImgStr += k;
1311
                                }
1312
                        }
1313
                }
167 Franz 1314
        }
8 paul 1315
        else
167 Franz 1316
        {
1317
                for( int yi=0; yi < h; ++yi )
8 paul 1318
                {
1319
                        QRgb * s = (QRgb*)(im->scanLine( yi ));
1320
                        for( int xi=0; xi < w; ++xi )
167 Franz 1321
                        {
8 paul 1322
                                QRgb r=*s++;
1323
                                int c = 255 - qRed(r);
1324
                                int m = 255 - qGreen(r);
1325
                                int y = 255 - qBlue(r);
1326
                                int k = QMIN(QMIN(c, m), y);
1327
                                if (pl == -1)
167 Franz 1328
                                {
8 paul 1329
                                        ImgStr += c - k;
1330
                                        ImgStr += m - k;
1331
                                        ImgStr += y - k;
1332
                                        ImgStr += k;
167 Franz 1333
                                }
8 paul 1334
                                else
167 Franz 1335
                                {
8 paul 1336
                                        if (pl == -2)
1337
                                                ImgStr += QMIN(255, qRound(0.3 * c + 0.59 * m + 0.11 * y + k));
1338
                                        if (pl == 1)
1339
                                                ImgStr += c - k;
1340
                                        if (pl == 2)
1341
                                                ImgStr += m - k;
1342
                                        if (pl == 3)
1343
                                                ImgStr += y - k;
1344
                                        if (pl == 0)
1345
                                                ImgStr += k;
1346
                                }
1347
                        }
1348
                }
167 Franz 1349
        }
8 paul 1350
        return ImgStr;
1351
}
1352
 
1353
QString MaskToTxt(QImage *im, bool PDF)
1354
{
1355
        int h = im->height();
1356
        int w = im->width();
167 Franz 1357
        int w2;
1358
        w2 = w / 8;
1359
        if ((w % 8) != 0)
1360
                w2++;
8 paul 1361
        QString ImgStr = "";
1362
        for( int yi=0; yi < h; ++yi )
167 Franz 1363
        {
8 paul 1364
                uchar * s = im->scanLine( yi );
1365
                for( int xi=0; xi < w2; ++xi )
167 Franz 1366
                {
8 paul 1367
                        unsigned char u = *(s+xi);
167 Franz 1368
                        ImgStr += PDF ? ~u : u;
8 paul 1369
                }
167 Franz 1370
        }
8 paul 1371
        return ImgStr;
1372
}
1373
 
203 Franz 1374
QString MaskToTxt14(QImage *im)
1375
{
1376
        int h = im->height();
1377
        int w = im->width();
1378
        QString ImgStr = "";
1379
        for( int yi=0; yi < h; ++yi )
1380
        {
1381
                QRgb * s = (QRgb*)(im->scanLine( yi ));
1382
                for( int xi=0; xi < w; ++xi )
1383
                {
1384
                        QRgb r=*s++;
1385
                        unsigned char u=qAlpha(r);
1386
                        ImgStr += u;
1387
                }
1388
        }
1389
        return ImgStr;
1390
}
1391
 
201 Franz 1392
typedef struct my_error_mgr
1393
{
1394
  struct jpeg_error_mgr pub;            /* "public" fields */
1395
  jmp_buf setjmp_buffer;  /* for return to caller */
1396
} *my_error_ptr;
1397
 
1398
/*
1399
 * Here's the routine that will replace the standard error_exit method:
1400
 */
1401
 
1402
static void my_error_exit (j_common_ptr cinfo)
1403
{
1404
  my_error_ptr myerr = (my_error_ptr) cinfo->err;
1405
  (*cinfo->err->output_message) (cinfo);
1406
  longjmp (myerr->setjmp_buffer, 1);
1407
}
1408
 
1886 fschmid 1409
bool isProgressive(QString fn)
1410
{
1411
        struct jpeg_decompress_struct cinfo;
1412
        struct my_error_mgr         jerr;
1413
        FILE     *infile;
1414
        bool ret = false;
1415
        cinfo.err = jpeg_std_error (&jerr.pub);
1416
        jerr.pub.error_exit = my_error_exit;
1417
        infile = NULL;
1418
        if (setjmp (jerr.setjmp_buffer))
1419
        {
1420
                jpeg_destroy_decompress (&cinfo);
1421
                if (infile)
1422
                        fclose (infile);
1423
                return ret;
1424
        }
1425
        jpeg_create_decompress (&cinfo);
2644 craig 1426
        if ((infile = fopen (fn.local8Bit(), "rb")) == NULL)
1886 fschmid 1427
                return ret;
1428
        jpeg_stdio_src(&cinfo, infile);
1429
        jpeg_read_header(&cinfo, TRUE);
1430
        ret = jpeg_has_multiple_scans(&cinfo);
1431
        fclose (infile);
1432
        jpeg_destroy_decompress (&cinfo);
1433
        return ret;
1434
}
1435
 
202 Franz 1436
void Convert2JPG(QString fn, QImage *image, int Quality, bool isCMYK)
201 Franz 1437
{
1438
        struct jpeg_compress_struct cinfo;
1439
        struct my_error_mgr         jerr;
1440
        FILE     *outfile;
1441
        JSAMPROW row_pointer[1];
1442
        row_pointer[0] = 0;
1443
        cinfo.err = jpeg_std_error (&jerr.pub);
1444
        jerr.pub.error_exit = my_error_exit;
1445
        outfile = NULL;
1446
        if (setjmp (jerr.setjmp_buffer))
1447
        {
1448
                jpeg_destroy_compress (&cinfo);
1449
                if (outfile)
1450
                        fclose (outfile);
1451
                return;
1452
        }
1453
        jpeg_create_compress (&cinfo);
2644 craig 1454
        if ((outfile = fopen (fn.local8Bit(), "wb")) == NULL)
201 Franz 1455
                return;
1456
        jpeg_stdio_dest (&cinfo, outfile);
1457
        cinfo.image_width  = image->width();
1458
        cinfo.image_height = image->height();
1459
        if (isCMYK)
1460
        {
1461
                cinfo.in_color_space = JCS_CMYK;
1462
                cinfo.input_components = 4;
1463
        }
1464
        else
1465
        {
1466
                cinfo.in_color_space = JCS_RGB;
1467
                cinfo.input_components = 3;
1468
        }
1469
        jpeg_set_defaults (&cinfo);
202 Franz 1470
        int qual[] = { 95, 85, 75, 50, 25 };  // These are the JPEG Quality settings 100 means best, 0 .. don't discuss
1471
        jpeg_set_quality (&cinfo, qual[Quality], true);
201 Franz 1472
        jpeg_start_compress (&cinfo, TRUE);
1473
        row_pointer[0] = new uchar[cinfo.image_width*cinfo.input_components];
1474
        int w = cinfo.image_width;
1475
        while (cinfo.next_scanline < cinfo.image_height)
1476
        {
1477
                uchar *row = row_pointer[0];
1478
                if (isCMYK)
1479
                {
1480
                        QRgb* rgba = (QRgb*)image->scanLine(cinfo.next_scanline);
1481
                        for (int i=0; i<w; ++i)
1482
                        {
1483
                                *row++ = qAlpha(*rgba);
1484
                                *row++ = qRed(*rgba);
1485
                                *row++ = qGreen(*rgba);
1486
                                *row++ = qBlue(*rgba);
1487
                                ++rgba;
1488
                        }
1489
                }
1490
                else
1491
                {
1492
                        QRgb* rgb = (QRgb*)image->scanLine(cinfo.next_scanline);
1493
                        for (int i=0; i<w; i++)
1494
                        {
1495
                                *row++ = qRed(*rgb);
1496
                                *row++ = qGreen(*rgb);
1497
                                *row++ = qBlue(*rgb);
1498
                                ++rgb;
1499
                        }
1500
                }
1501
                jpeg_write_scanlines (&cinfo, row_pointer, 1);
1502
        }
1503
        jpeg_finish_compress (&cinfo);
1504
        fclose (outfile);
1505
        jpeg_destroy_compress (&cinfo);
1506
        delete [] row_pointer[0];
1507
}
1508
 
8 paul 1509
QString CompressStr(QString *in)
1510
{
1511
        QString out = "";
1512
#ifdef HAVE_LIBZ
1513
        QByteArray bb(in->length());
1514
        for (uint ax = 0; ax < in->length(); ++ax)
1515
                bb[ax] = uchar(QChar(in->at(ax)));
1516
        uLong exlen = uint(bb.size() * 0.001 + 16) + bb.size();
1517
        QByteArray bc(exlen);
1518
        compress2((Byte *)bc.data(), &exlen, (Byte *)bb.data(), uLong(bb.size()), 9);
1519
        for (uint cl = 0; cl < exlen; ++cl)
1520
                out += bc[cl];
1521
#else
1522
        out = *in;
1523
#endif
1524
        return out;
1525
}
1526
 
1527
char *toHex( uchar u )
1528
{
1529
    static char hexVal[3];
1530
    int i = 1;
1531
    while ( i >= 0 )
167 Franz 1532
        {
1533
                ushort hex = (u & 0x000f);
1534
                if ( hex < 0x0a )
8 paul 1535
                hexVal[i] = '0'+hex;
167 Franz 1536
                else
8 paul 1537
                hexVal[i] = 'A'+(hex-0x0a);
167 Franz 1538
                u = u >> 4;
8 paul 1539
                        i--;
167 Franz 1540
    }
8 paul 1541
    hexVal[2] = '\0';
1542
    return hexVal;
1543
}
1544
 
1545
QString String2Hex(QString *in, bool lang)
1546
{
1547
        int i = 0;
1548
        QString out = "";
1549
        for( uint xi = 0; xi < in->length(); ++xi )
167 Franz 1550
        {
8 paul 1551
                out += toHex(uchar(QChar(in->at(xi))));
1552
                ++i;
1553
                if ((i>40) && (lang))
167 Franz 1554
                {
8 paul 1555
                        out += '\n';
1556
                        i=0;
1557
                }
167 Franz 1558
        }
8 paul 1559
        return out;
1560
}
1561
 
1562
QByteArray ComputeMD5Sum(QByteArray *in)
1563
{
1564
        QByteArray MDsum(16);
49 paul 1565
        md5_buffer (in->data(), in->size(), reinterpret_cast<void*>(MDsum.data()));
8 paul 1566
        return MDsum;
1567
}
1568
 
19 Franz 1569
QString Path2Relative(QString Path)
1570
{
1571
        QString Ndir = "";
1572
        QStringList Pdir = QStringList::split("/", QDir::currentDirPath());
1573
        QFileInfo Bfi = QFileInfo(Path);
1574
        QStringList Bdir = QStringList::split("/", Bfi.dirPath(true));
1575
        bool ende = true;
1576
        uint dcoun = 0;
1577
        uint dcoun2 = 0;
1578
        while (ende)
167 Franz 1579
        {
19 Franz 1580
                if (Pdir[dcoun] == Bdir[dcoun])
1581
                        dcoun++;
1582
                else
1583
                        break;
1584
                if (dcoun > Pdir.count())
1585
                        break;
167 Franz 1586
        }
19 Franz 1587
        dcoun2 = dcoun;
1588
        for (uint ddx2 = dcoun; ddx2 < Pdir.count(); ddx2++)
1589
                Ndir += "../";
1590
        for (uint ddx = dcoun2; ddx < Bdir.count(); ddx++)
1591
                Ndir += Bdir[ddx]+"/";
1592
        Ndir += Bfi.fileName();
1593
        return Ndir;
1594
}
1595
 
1084 fschmid 1596
int setBestEncoding(FT_Face face)
8 paul 1597
{
1598
        FT_ULong  charcode;
895 fschmid 1599
        FT_UInt   gindex;
875 fschmid 1600
        bool foundEncoding = false;
895 fschmid 1601
        int countUniCode = 0;
2734 cbradney 1602
        int chmapUniCode = -1;
1603
        int chmapCustom = -1;
1084 fschmid 1604
        int retVal = 0;
2728 cbradney 1605
        //FT_CharMap defaultEncoding = face->charmap;
2737 cbradney 1606
//      int defaultchmap=face->charmap ? FT_Get_Charmap_Index(face->charmap) : 0;
1607
// Since the above function is only available in FreeType 2.1.9 its replaced by
1608
// the following line, assuming that the default charmap has the index 0
1609
        int defaultchmap = 0;
391 Franz 1610
        for(int u = 0; u < face->num_charmaps; u++)
1611
        {
895 fschmid 1612
                if (face->charmaps[u]->encoding == FT_ENCODING_UNICODE )
391 Franz 1613
                {
895 fschmid 1614
                        FT_Set_Charmap(face, face->charmaps[u]);
1615
                        chmapUniCode = u;
1616
                        gindex = 0;
1617
                        charcode = FT_Get_First_Char( face, &gindex );
1618
                        while ( gindex != 0 )
875 fschmid 1619
                        {
895 fschmid 1620
                                countUniCode++;
1621
                                charcode = FT_Get_Next_Char( face, charcode, &gindex );
875 fschmid 1622
                        }
1623
                }
895 fschmid 1624
                if (face->charmaps[u]->encoding == FT_ENCODING_ADOBE_CUSTOM)
875 fschmid 1625
                {
895 fschmid 1626
                        chmapCustom = u;
1627
                        foundEncoding = true;
1084 fschmid 1628
                        retVal = 1;
1629
                        break;
875 fschmid 1630
                }
1064 cbradney 1631
                else if (face->charmaps[u]->encoding == FT_ENCODING_MS_SYMBOL)
1632
                {
1633
                        chmapCustom = u;
1634
                        foundEncoding = true;
1084 fschmid 1635
                        retVal = 2;
1636
                        break;
1064 cbradney 1637
                }
875 fschmid 1638
        }
2728 cbradney 1639
        int mapToSet=defaultchmap;
2734 cbradney 1640
        if (chmapUniCode>0 && countUniCode >= face->num_glyphs-1)
1084 fschmid 1641
        {
2728 cbradney 1642
                mapToSet=chmapUniCode;
1643
                //FT_Set_Charmap(face, face->charmaps[chmapUniCode]);
1084 fschmid 1644
                retVal = 0;
1645
        }
2728 cbradney 1646
        else
1647
        if (foundEncoding)
1648
        {
1649
                mapToSet=chmapCustom;
1650
                //FT_Set_Charmap(face, face->charmaps[chmapCustom]);
1651
        }
895 fschmid 1652
        else
1084 fschmid 1653
        {
2728 cbradney 1654
                mapToSet=defaultchmap;
1655
                //FT_Set_Charmap(face, defaultEncoding);
1084 fschmid 1656
                retVal = 0;
1657
        }
2728 cbradney 1658
 
1659
        //Fixes #2199, missing glyphs from 1.2.1->1.2.2
1660
        //If the currently wanted character map is not already Unicode...
1661
        //if (FT_Get_Charmap_Index(face->charmap)!=chmapUniCode)
1662
        if (mapToSet!=chmapUniCode)
1663
        {
1664
                //Change map so we can count the chars in it
1665
                FT_Set_Charmap(face, face->charmaps[mapToSet]);
1666
                //Count the characters in the current map
1667
                gindex = 0;
1668
                int countCurrMap=0;
1669
                charcode = FT_Get_First_Char( face, &gindex );
1670
                while ( gindex != 0 )
1671
                {
1672
                        countCurrMap++;
1673
                        charcode = FT_Get_Next_Char( face, charcode, &gindex );
1674
                }
1675
                //If the last Unicode map we found before has more characters,
1676
                //then set it to be the current map.
1677
                if (countUniCode>countCurrMap)
1678
                {
1679
                        mapToSet=chmapUniCode;
1680
                        //FT_Set_Charmap(face, face->charmaps[chmapUniCode]);
1681
                        retVal = 0;
1682
                }
1683
        }
2737 cbradney 1684
//      if (face->charmap == NULL || mapToSet!=FT_Get_Charmap_Index(face->charmap))
2728 cbradney 1685
                FT_Set_Charmap(face, face->charmaps[mapToSet]);
1084 fschmid 1686
        return retVal;
895 fschmid 1687
}
1688
 
1689
bool GlyNames(QMap<uint, QString> *GList, QString Dat)
1690
{
1691
        bool error;
1692
        char *buf[50];
1693
        FT_Library library;
1694
        FT_Face face;
1695
        FT_ULong  charcode;
1696
        FT_UInt gindex;
1697
        error = FT_Init_FreeType(&library);
1698
        error = FT_New_Face(library, Dat, 0, &face);
1699
        setBestEncoding(face);
77 Franz 1700
        gindex = 0;
167 Franz 1701
        charcode = FT_Get_First_Char(face, &gindex );
1702
        while (gindex != 0)
1703
        {
8 paul 1704
                FT_Get_Glyph_Name(face, gindex, buf, 50);
49 paul 1705
                GList->insert(charcode, QString(reinterpret_cast<char*>(buf)));
167 Franz 1706
        charcode = FT_Get_Next_Char(face, charcode, &gindex );
1707
        }
8 paul 1708
        FT_Done_FreeType( library );
1709
        return true;
1710
}
1711
 
1712
bool GlyIndex(QMap<uint, PDFlib::GlNamInd> *GListInd, QString Dat)
1713
{
1714
        struct PDFlib::GlNamInd gln;
1715
        bool error;
1716
        char *buf[50];
1717
        FT_Library library;
1718
        FT_Face face;
1719
        FT_ULong  charcode;
167 Franz 1720
        FT_UInt   gindex;
1721
        uint counter1 = 32;
1722
        uint counter2 = 0;
8 paul 1723
        error = FT_Init_FreeType(&library);
1724
        error = FT_New_Face(library, Dat, 0, &face);
895 fschmid 1725
        setBestEncoding(face);
77 Franz 1726
        gindex = 0;
167 Franz 1727
        charcode = FT_Get_First_Char(face, &gindex );
1728
        while (gindex != 0)
1729
        {
8 paul 1730
                FT_Get_Glyph_Name(face, gindex, buf, 50);
1731
                gln.Code = counter1 + counter2;
49 paul 1732
                gln.Name = "/"+QString(reinterpret_cast<char*>(buf));
8 paul 1733
                GListInd->insert(charcode, gln);
167 Franz 1734
        charcode = FT_Get_Next_Char(face, charcode, &gindex );
1735
        counter1++;
1736
        if (counter1 > 255)
1737
                {
8 paul 1738
                        counter1 = 32;
1739
                        counter2 += 0x100;
1740
                }
167 Franz 1741
        }
8 paul 1742
        FT_Done_FreeType( library );
1743
        return true;
1744
}
1745
 
1746
FPoint firstP;
1747
bool FirstM;
1748
 
1749
int traceMoveto( FT_Vector *to, FPointArray *composite )
1750
{
1751
        double tox = ( to->x / 64.0 );
1752
        double toy = ( to->y / 64.0 );
1753
        if (!FirstM)
167 Franz 1754
        {
68 Franz 1755
                composite->addPoint(firstP);
1756
                composite->addPoint(firstP);
1757
                composite->setMarker();
167 Franz 1758
        }
8 paul 1759
        else
1760
                FirstM = false;
68 Franz 1761
        composite->addPoint(FPoint(tox, toy));
1762
        composite->addPoint(FPoint(tox, toy));
8 paul 1763
        firstP = FPoint(tox, toy);
1764
        return 0;
1765
}
1766
 
1767
int traceLineto( FT_Vector *to, FPointArray *composite )
1768
{
1769
        double tox = ( to->x / 64.0 );
1770
        double toy = ( to->y / 64.0 );
120 Franz 1771
        if (composite->size() > 4)
167 Franz 1772
        {
120 Franz 1773
                FPoint b1 = composite->point(composite->size()-4);
1774
                FPoint b2 = composite->point(composite->size()-3);
1775
                FPoint b3 = composite->point(composite->size()-2);
1776
                FPoint b4 = composite->point(composite->size()-1);
1777
                FPoint n1 = FPoint(tox, toy);
1778
                FPoint n2 = FPoint(tox, toy);
1779
                FPoint n3 = FPoint(tox, toy);
1780
                FPoint n4 = FPoint(tox, toy);
1781
                if ((b1 == n1) && (b2 == n2) && (b3 == n3) && (b4 == n4))
1782
                        return 0;
167 Franz 1783
        }
68 Franz 1784
        composite->addPoint(FPoint(tox, toy));
1785
        composite->addPoint(FPoint(tox, toy));
1786
        composite->addPoint(FPoint(tox, toy));
1787
        composite->addPoint(FPoint(tox, toy));
8 paul 1788
        return 0;
1789
}
1790
 
1791
int traceQuadraticBezier( FT_Vector *control, FT_Vector *to, FPointArray *composite )
1792
{
1793
        double x1 = ( control->x / 64.0 );
1794
        double y1 = ( control->y / 64.0 );
1795
        double x2 = ( to->x / 64.0 );
1796
        double y2 = ( to->y / 64.0 );
120 Franz 1797
        if (composite->size() > 4)
167 Franz 1798
        {
120 Franz 1799
                FPoint b1 = composite->point(composite->size()-4);
1800
                FPoint b2 = composite->point(composite->size()-3);
1801
                FPoint b3 = composite->point(composite->size()-2);
1802
                FPoint b4 = composite->point(composite->size()-1);
1803
                FPoint n1 = FPoint(x2, y2);
1804
                FPoint n2 = FPoint(x1, y1);
1805
                FPoint n3 = FPoint(x2, y2);
1806
                FPoint n4 = FPoint(x2, y2);
1807
                if ((b1 == n1) && (b2 == n2) && (b3 == n3) && (b4 == n4))
1808
                        return 0;
167 Franz 1809
        }
68 Franz 1810
        composite->addPoint(FPoint(x2, y2));
1811
        composite->addPoint(FPoint(x1, y1));
1812
        composite->addPoint(FPoint(x2, y2));
1813
        composite->addPoint(FPoint(x2, y2));
8 paul 1814
        return 0;
167 Franz 1815
}
8 paul 1816
 
1817
int traceCubicBezier( FT_Vector *p, FT_Vector *q, FT_Vector *to, FPointArray *composite )
1818
{
1819
        double x1 = ( p->x / 64.0 );
1820
        double y1 = ( p->y / 64.0 );
1821
        double x2 = ( q->x / 64.0 );
1822
        double y2 = ( q->y / 64.0 );
1823
        double x3 = ( to->x / 64.0 );
1824
        double y3 = ( to->y / 64.0 );
120 Franz 1825
        if (composite->size() > 4)
167 Franz 1826
        {
120 Franz 1827
                FPoint b1 = composite->point(composite->size()-4);
1828
                FPoint b2 = composite->point(composite->size()-3);
1829
                FPoint b3 = composite->point(composite->size()-2);
1830
                FPoint b4 = composite->point(composite->size()-1);
1831
                FPoint n1 = FPoint(x3, y3);
1832
                FPoint n2 = FPoint(x2, y2);
1833
                FPoint n3 = FPoint(x3, y3);
1834
                FPoint n4 = FPoint(x3, y3);
1835
                if ((b1 == n1) && (b2 == n2) && (b3 == n3) && (b4 == n4))
1836
                        return 0;
167 Franz 1837
        }
8 paul 1838
        composite->setPoint(composite->size()-1, FPoint(x1, y1));
68 Franz 1839
        composite->addPoint(FPoint(x3, y3));
1840
        composite->addPoint(FPoint(x2, y2));
1841
        composite->addPoint(FPoint(x3, y3));
1842
        composite->addPoint(FPoint(x3, y3));
8 paul 1843
        return 0;
1844
}
1845
 
1846
FT_Outline_Funcs OutlineMethods =
1847
{
1848
        (FT_Outline_MoveTo_Func) traceMoveto,
1849
        (FT_Outline_LineTo_Func) traceLineto,
1850
        (FT_Outline_ConicTo_Func) traceQuadraticBezier,
1851
        (FT_Outline_CubicTo_Func) traceCubicBezier,
1852
        0,
1853
 
1854
};
1855
 
220 Franz 1856
FPointArray traceChar(FT_Face face, uint chr, int chs, double *x, double *y, bool *err)
8 paul 1857
{
220 Franz 1858
        bool error = false;
8 paul 1859
        FT_UInt glyphIndex;
1860
        FPointArray pts, pts2;
1861
        pts.resize(0);
220 Franz 1862
        pts2.resize(0);
8 paul 1863
        firstP = FPoint(0,0);
1864
        FirstM = true;
220 Franz 1865
        error = FT_Set_Char_Size( face, 0, chs*64, 72, 72 );
1866
        if (error)
1867
        {
1868
                *err = error;
1869
                return pts2;
1870
        }
8 paul 1871
        glyphIndex = FT_Get_Char_Index(face, chr);
220 Franz 1872
        if (glyphIndex == 0)
1873
        {
1874
                *err = true;
1875
                return pts2;
1876
        }
1877
        error = FT_Load_Glyph( face, glyphIndex, FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP );
1878
        if (error)
1879
        {
1880
                *err = error;
1881
                return pts2;
1882
        }
1883
        error = FT_Outline_Decompose(&face->glyph->outline, &OutlineMethods, reinterpret_cast<void*>(&pts));
1884
        if (error)
1885
        {
1886
                *err = error;
1887
                return pts2;
1888
        }
87 Franz 1889
        *x = face->glyph->metrics.horiBearingX / 64.0;
1890
        *y = face->glyph->metrics.horiBearingY / 64.0;
8 paul 1891
        QWMatrix ma;
1892
        ma.scale(1, -1);
1893
        pts.map(ma);
1894
        pts.translate(0, chs);
1895
        pts2.putPoints(0, pts.size()-2, pts, 0);
1896
        return pts2;
1897
}
90 Franz 1898
 
95 Franz 1899
FPoint GetMaxClipF(FPointArray Clip)
1900
{
1901
        FPoint np, rp;
1902
        double mx = 0;
1903
        double my = 0;
1904
        for (uint c = 0; c < Clip.size(); ++c)
167 Franz 1905
        {
95 Franz 1906
                np = Clip.point(c);
1907
                if (np.x() > 900000)
1908
                        continue;
1909
                if (np.x() > mx)
1910
                        mx = np.x();
1911
                if (np.y() > my)
1912
                        my = np.y();
167 Franz 1913
        }
95 Franz 1914
        rp = FPoint(mx, my);
1915
        return rp;
1916
}
1917
 
1084 fschmid 1918
QPixmap FontSample(QString da, int s, QString ts, QColor back, bool force)
92 Franz 1919
{
1920
        FT_Face face;
1921
        FT_Library library;
95 Franz 1922
        double x, y, ymax;
92 Franz 1923
        bool error;
1924
        int  pen_x;
95 Franz 1925
        FPoint gp;
92 Franz 1926
        error = FT_Init_FreeType( &library );
1927
        error = FT_New_Face( library, da, 0, &face );
1084 fschmid 1928
        int encode = setBestEncoding(face);
92 Franz 1929
        double uniEM = static_cast<double>(face->units_per_EM);
95 Franz 1930
        int h = qRound(face->height / uniEM) * s + 1;
1931
        double a = static_cast<double>(face->descender) / uniEM * s + 1;
92 Franz 1932
        int w = qRound((face->bbox.xMax - face->bbox.xMin) / uniEM) * s * (ts.length()+1);
1933
        QPixmap pm(w, h);
1934
        pm.fill();
1935
        pen_x = 0;
95 Franz 1936
        ymax = 0.0;
92 Franz 1937
        ScPainter *p = new ScPainter(&pm, pm.width(), pm.height());
1938
        p->setFillMode(1);
1939
        p->setLineWidth(0.0);
1940
        p->setBrush(back);
1941
        p->drawRect(0.0, 0.0, static_cast<double>(w), static_cast<double>(h));
1942
        p->setBrush(Qt::black);
1084 fschmid 1943
        FPointArray gly;
1944
        uint dv;
1945
        dv = ts[0].unicode();
1946
        error = false;
1947
        gly = traceChar(face, dv, s, &x, &y, &error);
1948
        if (((encode != 0) || (error)) && (!force))
167 Franz 1949
        {
221 Franz 1950
                error = false;
1084 fschmid 1951
                FT_ULong  charcode;
1952
                FT_UInt gindex;
1953
                gindex = 0;
1954
                charcode = FT_Get_First_Char(face, &gindex );
1955
                for (uint n = 0; n < ts.length(); ++n)
167 Franz 1956
                {
1084 fschmid 1957
                        gly = traceChar(face, charcode, s, &x, &y, &error);
1958
                        if (error)
1959
                                break;
1960
                        if (gly.size() > 3)
1961
                        {
1962
                                gly.translate(static_cast<double>(pen_x) / 64.0, a);
1963
                                gp = GetMaxClipF(gly);
1964
                                ymax = QMAX(ymax, gp.y());
1965
                                p->setupPolygon(&gly);
1966
                                p->fillPath();
1967
                        }
1968
                        pen_x += face->glyph->advance.x;
1969
                        charcode = FT_Get_Next_Char(face, charcode, &gindex );
1970
                        if (gindex == 0)
1971
                                break;
167 Franz 1972
                }
1973
        }
1084 fschmid 1974
        else
1975
        {
1976
                for (uint n = 0; n < ts.length(); ++n)
1977
                {
1978
                        dv = ts[n].unicode();
1979
                        error = false;
1980
                        gly = traceChar(face, dv, s, &x, &y, &error);
1981
                        if (gly.size() > 3)
1982
                        {
1983
                                gly.translate(static_cast<double>(pen_x) / 64.0, a);
1984
                                gp = GetMaxClipF(gly);
1985
                                ymax = QMAX(ymax, gp.y());
1986
                                p->setupPolygon(&gly);
1987
                                p->fillPath();
1988
                        }
1989
                        pen_x += face->glyph->advance.x;
1990
                }
1991
        }
92 Franz 1992
        p->end();
95 Franz 1993
        pm.resize(QMIN(qRound(gp.x()), w), QMIN(qRound(ymax), h));
92 Franz 1994
        delete p;
1995
        FT_Done_FreeType( library );
1996
        return pm;
1997
}
1998
 
418 Franz 1999
/** Same as FontSample() with \n strings support added.
2000
09/26/2004 petr vanek
2001
*/
2002
QPixmap fontSamples(QString da, int s, QString ts, QColor back)
2003
{
2004
        QStringList lines = QStringList::split("\n", ts);
2005
        QPixmap ret(640, 480);
2006
        QPixmap sample;
2007
        QPainter *painter = new QPainter(&ret);
2008
        int y = 0;
2009
        int x = 0;
2010
        ret.fill(back);
2011
        for ( QStringList::Iterator it = lines.begin(); it != lines.end(); ++it ) {
2012
                sample = FontSample(da, s, *it, back);
1084 fschmid 2013
                if (!sample.isNull())
2014
                        painter->drawPixmap(0, y, sample, 0, 0);
418 Franz 2015
                y = y + sample.height();
2016
                if (x < sample.width())
2017
                        x = sample.width();
2018
        } // for
2019
        delete(painter);
2020
        QPixmap final(x, y);
1084 fschmid 2021
        if ((x != 0) && (y != 0))
2022
        {
2023
                QPainter *fpainter = new QPainter(&final);
2024
                fpainter->drawPixmap(0, 0, ret, 0, 0, x, y);
2025
                delete(fpainter);
2026
        }
418 Franz 2027
        return final;
2028
}
2029
 
90 Franz 2030
/***************************************************************************
2031
    begin                : Wed Oct 29 2003
2032
    copyright            : (C) 2003 The Scribus Team
2033
    email                : paul@all-the-johnsons.co.uk
2034
 ***************************************************************************/
2035
// check if the file exists, if it does, ask if they're sure
2036
// return true if they're sure, else return false;
2037
 
2038
bool overwrite(QWidget *parent, QString filename)
2039
{
167 Franz 2040
        bool retval = true;
2041
        QFileInfo fi(filename);
2042
        if (fi.exists())
90 Franz 2043
        {
167 Franz 2044
        int t = QMessageBox::warning(parent, QObject::tr("Warning"),
2045
                                                QObject::tr("Do you really want to overwrite the File:\n%1 ?").arg(filename),
2046
                        QMessageBox::No, QMessageBox::Yes, QMessageBox::NoButton);
2047
            if (t == QMessageBox::No)
90 Franz 2048
                        retval = false;
2049
        }
2050
  return retval;
2051
}
124 Franz 2052
 
2053
void CopyPageItem(struct CLBuf *Buffer, PageItem *b)
2054
{
2055
        uint a;
2056
        Buffer->PType = b->PType;
2057
        Buffer->Xpos = b->Xpos;
2058
        Buffer->Ypos = b->Ypos;
2059
        Buffer->Width = b->Width;
2060
        Buffer->Height = b->Height;
2061
        Buffer->RadRect = b->RadRect;
2062
        Buffer->FrameType = b->FrameType;
2063
        Buffer->ClipEdited = b->ClipEdited;
2064
        Buffer->Pwidth = b->Pwidth;
2065
        Buffer->Pcolor = b->Pcolor;
2066
        Buffer->Pcolor2 = b->Pcolor2;
2067
        Buffer->Shade = b->Shade;
2068
        Buffer->Shade2 = b->Shade2;
295 Franz 2069
        Buffer->GrColor = "";
2070
        Buffer->GrColor2 = "";
2071
        Buffer->GrShade = 100;
2072
        Buffer->GrShade2 = 100;
2073
        Buffer->fill_gradient = b->fill_gradient;
124 Franz 2074
        Buffer->GrType = b->GrType;
292 Franz 2075
        Buffer->GrStartX = b->GrStartX;
2076
        Buffer->GrStartY = b->GrStartY;
2077
        Buffer->GrEndX = b->GrEndX;
2078
        Buffer->GrEndY = b->GrEndY;
124 Franz 2079
        Buffer->TxtStroke = b->TxtStroke;
2080
        Buffer->TxtFill = b->TxtFill;
2081
        Buffer->ShTxtStroke = b->ShTxtStroke;
2082
        Buffer->ShTxtFill = b->ShTxtFill;
2083
        Buffer->TxtScale = b->TxtScale;
2084
        Buffer->TxTStyle = b->TxTStyle;
2085
        Buffer->Rot = b->Rot;
2086
        Buffer->PLineArt = b->PLineArt;
2087
        Buffer->PLineEnd = b->PLineEnd;
2088
        Buffer->PLineJoin = b->PLineJoin;
2089
        Buffer->LineSp = b->LineSp;
2090
        Buffer->LocalScX = b->LocalScX;
2091
        Buffer->LocalScY = b->LocalScY;
2092
        Buffer->LocalX = b->LocalX;
2093
        Buffer->LocalY = b->LocalY;
2094
        Buffer->PicArt = b->PicArt;
2095
        Buffer->flippedH = b->flippedH;
2096
        Buffer->flippedV = b->flippedV;
2097
        Buffer->BBoxX = b->BBoxX;
2098
        Buffer->BBoxH = b->BBoxH;
2099
        Buffer->isPrintable = b->isPrintable;
2100
        Buffer->isBookmark = b->isBookmark;
2101
        Buffer->BMnr = b->BMnr;
2102
        Buffer->isAnnotation = b->isAnnotation;
2103
        Buffer->AnType = b->AnType;
2104
        Buffer->AnAction = b->AnAction;
2105
        Buffer->An_E_act = b->An_E_act;
2106
        Buffer->An_X_act = b->An_X_act;
2107
        Buffer->An_D_act = b->An_D_act;
2108
        Buffer->An_Fo_act = b->An_Fo_act;
2109
        Buffer->An_Bl_act = b->An_Bl_act;
2110
        Buffer->An_K_act = b->An_K_act;
2111
        Buffer->An_F_act = b->An_F_act;
2112
        Buffer->An_V_act = b->An_V_act;
2113
        Buffer->An_C_act = b->An_C_act;
2114
        Buffer->An_Extern = b->An_Extern;
2115
        Buffer->AnZiel = b->AnZiel;
2116
        Buffer->AnName = b->AnName;
2117
        Buffer->AnActType = b->AnActType;
2118
        Buffer->AnToolTip = b->AnToolTip;
2119
        Buffer->AnBwid = b->AnBwid;
2120
        Buffer->AnBsty = b->AnBsty;
2121
        Buffer->AnFeed = b->AnFeed;
2122
        Buffer->AnFlag = b->AnFlag;
2123
        Buffer->AnFont = b->AnFont;
2124
        Buffer->AnRollOver = b->AnRollOver;
2125
        Buffer->AnDown = b->AnDown;
2126
        Buffer->AnFormat = b->AnFormat;
2127
        Buffer->AnVis = b->AnVis;
2128
        Buffer->AnMaxChar = b->AnMaxChar;
2129
        Buffer->AnChkStil = b->AnChkStil;
2130
        Buffer->AnIsChk = b->AnIsChk;
2131
        Buffer->AnAAact = b->AnAAact;
2132
        Buffer->AnBColor = b->AnBColor;
2133
        Buffer->AnHTML = b->AnHTML;
2134
        Buffer->AnUseIcons = b->AnUseIcons;
2135
        Buffer->AnIPlace = b->AnIPlace;
2136
        Buffer->AnScaleW = b->AnScaleW;
2137
        Buffer->Extra = b->Extra;
2138
        Buffer->TExtra = b->TExtra;
2139
        Buffer->BExtra = b->BExtra;
2140
        Buffer->RExtra = b->RExtra;
2141
        Buffer->Pfile = b->Pfile;
2142
        Buffer->Pfile2 = b->Pfile2;
2143
        Buffer->Pfile3 = b->Pfile3;
2144
        QString Text = "";
2145
        if (b->Ptext.count() != 0)
167 Franz 2146
        {
2147
                for (a=0; a<b->Ptext.count(); ++a)
124 Franz 2148
                {
2149
                        if( (b->Ptext.at(a)->ch == "\n") || (b->Ptext.at(a)->ch == "\r"))
2150
                                Text += QString(QChar(5))+"\t";
157 Franz 2151
                        else if(b->Ptext.at(a)->ch == "\t")
139 Franz 2152
                                Text += QString(QChar(4))+"\t";
124 Franz 2153
                        else
2154
                                Text += b->Ptext.at(a)->ch+"\t";
2155
                        Text += b->Ptext.at(a)->cfont+"\t";
2156
                        Text += QString::number(b->Ptext.at(a)->csize / 10.0)+"\t";
2157
                        Text += b->Ptext.at(a)->ccolor+"\t";
2158
                        Text += QString::number(b->Ptext.at(a)->cextra)+"\t";
2159
                        Text += QString::number(b->Ptext.at(a)->cshade)+'\t';
2160
                        Text += QString::number(b->Ptext.at(a)->cstyle)+'\t';
2161
                        Text += QString::number(b->Ptext.at(a)->cab)+'\t';
2162
                        Text += b->Ptext.at(a)->cstroke+"\t";
2163
                        Text += QString::number(b->Ptext.at(a)->cshade2)+'\t';
2164
                        Text += QString::number(b->Ptext.at(a)->cscale)+'\n';
2165
                }
167 Franz 2166
        }
124 Franz 2167
        Buffer->Ptext = Text;
2168
        Buffer->Clip = b->Clip.copy();
2169
        Buffer->PoLine = b->PoLine.copy();
340 Franz 2170
        Buffer->ContourLine = b->ContourLine.copy();
2171
        Buffer->UseContour = b->UseContour;
139 Franz 2172
        Buffer->TabValues = b->TabValues;
2173
        Buffer->DashValues = b->DashValues;
2174
        Buffer->DashOffset = b->DashOffset;
124 Franz 2175
        Buffer->PoShow = b->PoShow;
2176
        Buffer->BaseOffs = b->BaseOffs;
2177
        Buffer->Textflow = b->Textflow;
2178
        Buffer->Textflow2 = b->Textflow2;
2179
        Buffer->Ausrich = b->Ausrich;
2180
        Buffer->IFont = b->IFont;
2181
        Buffer->ISize = b->ISize;
2182
        Buffer->ExtraV = b->ExtraV;
2183
        Buffer->Groups = b->Groups;
2184
        Buffer->IProfile = b->IProfile;
2185
        Buffer->IRender = b->IRender;
2186
        Buffer->UseEmbedded = b->UseEmbedded;
2187
        Buffer->EmProfile = b->EmProfile;
2188
        Buffer->LayerNr = b->LayerNr;
2189
        Buffer->ScaleType = b->ScaleType;
2190
        Buffer->AspectRatio = b->AspectRatio;
2191
        Buffer->Locked = b->Locked;
205 Franz 2192
        Buffer->LockRes = b->LockRes;
124 Franz 2193
        Buffer->Transparency = b->Transparency;
2194
        Buffer->TranspStroke = b->TranspStroke;
2195
        Buffer->Reverse = b->Reverse;
2196
        Buffer->InvPict = b->InvPict;
2197
        Buffer->NamedLStyle = b->NamedLStyle;
2198
    &n