Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
4430 cbradney 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
8 paul 7
/***************************************************************************
8
                          util.cpp  -  description
9
                             -------------------
10
    begin                : Fri Sep 14 2001
11
    copyright            : (C) 2001 by Franz Schmid
12
    email                : Franz.Schmid@altmuehlnet.de
13
 ***************************************************************************/
14
 
15
/***************************************************************************
16
 *                                                                         *
17
 *   This program is free software; you can redistribute it and/or modify  *
18
 *   it under the terms of the GNU General Public License as published by  *
19
 *   the Free Software Foundation; either version 2 of the License, or     *
20
 *   (at your option) any later version.                                   *
21
 *                                                                         *
22
 ***************************************************************************/
9 Franz 23
 
10203 cbradney 24
 
25
#include <QBitmap>
9535 fschmid 26
#include <QByteArray>
10203 cbradney 27
#include <QCheckBox>
28
#include <QDomElement>
29
#include <QFile>
30
#include <QFileInfo>
9363 fschmid 31
#include <QImageReader>
10203 cbradney 32
#include <QList>
33
#include <QPixmap>
34
#include <QWidget>
10223 cbradney 35
#include <QDir>
10692 fschmid 36
#include <QCryptographicHash>
6125 cbradney 37
 
8 paul 38
#include <cmath>
6140 jghali 39
#include <algorithm>
10203 cbradney 40
 
41
#include "util.h"
42
 
11595 jghali 43
 
44
#include "scconfig.h"
10601 mrdocs 45
#include "scpainter.h"
11595 jghali 46
#include "scstreamfilter.h"
10601 mrdocs 47
#include "pageitem_textframe.h"
2702 craig 48
 
2730 cbradney 49
#if defined(_WIN32)
50
#if defined(_MSC_VER)
51
#define __STDC__ 1 // hack to get md5_buffer correctly identified
52
#endif
3810 cbradney 53
#include <valarray>
2730 cbradney 54
#include <windows.h>
55
#endif
56
 
10692 fschmid 57
// #include "md5.h"
2730 cbradney 58
 
3733 cbradney 59
#include "commonstrings.h"
10203 cbradney 60
#include "prefsmanager.h"
10006 cbradney 61
#include <QProcess>
3733 cbradney 62
#include "scmessagebox.h"
5351 cbradney 63
#include "scpixmapcache.h"
3733 cbradney 64
#include "scpaths.h"
128 Franz 65
 
10246 cbradney 66
extern "C"
1555 fschmid 67
{
201 Franz 68
#define XMD_H           // shut JPEGlib up
69
#if defined(Q_OS_UNIXWARE)
70
#  define HAVE_BOOLEAN  // libjpeg under Unixware seems to need this
71
#endif
72
#include <jpeglib.h>
73
#include <jerror.h>
74
#undef HAVE_STDLIB_H
75
#ifdef const
76
#  undef const          // remove crazy C hackery in jconfig.h
77
#endif
78
}
79
 
6125 cbradney 80
#include "pageitem.h"
214 Franz 81
#include "scribus.h"
6125 cbradney 82
#include "scribusdoc.h"
83
#include "scribusview.h"
8022 jghali 84
#include <zlib.h>
8 paul 85
 
3205 craig 86
 
10246 cbradney 87
using namespace std;
690 cbradney 88
 
10246 cbradney 89
void sDebug(QString message)
3240 fschmid 90
{
10592 fschmid 91
        qDebug("%s", message.toAscii().constData());
3240 fschmid 92
}
93
 
11777 jghali 94
int System(const QString exename, const QStringList & args, const QString fileStdErr, const QString fileStdOut, bool* cancel)
204 Franz 95
{
10592 fschmid 96
        QProcess proc;
11021 jghali 97
        if (!fileStdOut.isEmpty())
98
                proc.setStandardOutputFile(fileStdOut);
99
        if (!fileStdErr.isEmpty())
100
                proc.setStandardErrorFile(fileStdErr);
101
        proc.start(exename, args);
10592 fschmid 102
        if (proc.waitForStarted(5000))
4194 fschmid 103
        {
10592 fschmid 104
                while (!proc.waitForFinished(5000))
105
                {
106
                        qApp->processEvents();
11777 jghali 107
                        if (cancel && (*cancel == true))
108
                        {
109
                                proc.kill();
110
                                break;
111
                        }
4924 cbradney 112
                }
4194 fschmid 113
        }
11777 jghali 114
        if (cancel && (*cancel == true))
115
                return -1;
10592 fschmid 116
        int ex = proc.exitCode();
204 Franz 117
        return ex;
118
}
119
 
2885 fschmid 120
// On Windows, return short path name, else return longPath;
12071 subik 121
QString getShortPathName(const QString & longPath)
2885 fschmid 122
{
4505 cbradney 123
        QString shortPath(longPath);
2885 fschmid 124
#if defined _WIN32
125
        QFileInfo fInfo(longPath);
10304 jghali 126
        if (fInfo.exists())
2885 fschmid 127
        {
10304 jghali 128
                WCHAR shortName[MAX_PATH + 1];
2885 fschmid 129
                // An error should not be blocking as ERROR_INVALID_PARAMETER can simply mean
130
                // that volume does not support 8.3 filenames, so return longPath in this case
10304 jghali 131
                QString nativePath = QDir::convertSeparators(longPath);
132
                int ret = GetShortPathNameW((LPCWSTR) nativePath.utf16(), shortName, MAX_PATH);
133
                if (ret != ERROR_INVALID_PARAMETER && ret < MAX_PATH)
134
                        shortPath = QString::fromUtf16((const ushort*) shortName);
2885 fschmid 135
        }
136
#endif
137
        return shortPath;
138
}
139
 
12192 jghali 140
// On Windows, return short path name, else return longPath;
141
QString getLongPathName(const QString & shortPath)
142
{
143
        QString longPath(shortPath);
144
#if defined _WIN32
145
        QFileInfo fInfo(longPath);
146
        if (fInfo.exists())
147
        {
148
                WCHAR longName[MAX_PATH + 1];
149
                // An error should not be blocking as ERROR_INVALID_PARAMETER can simply mean
150
                // that volume does not support long filenames, so return shortPath in this case
151
                QString nativePath = QDir::convertSeparators(shortPath);
152
                int ret = GetLongPathNameW((LPCWSTR) nativePath.utf16(), longName, MAX_PATH);
153
                if (ret != ERROR_INVALID_PARAMETER && ret < MAX_PATH)
154
                        longPath = QString::fromUtf16((const ushort*) longName);
155
        }
156
#endif
157
        return longPath;
158
}
204 Franz 159
 
8 paul 160
QString GetAttr(QDomElement *el, QString at, QString def)
161
{
162
        return el->attribute(at, def);
163
}
164
 
1109 fschmid 165
 
3158 craig 166
// Legacy implementation of LoadText with incorrect
167
// handling of unicode data. This should be retired.
168
// Use loadRawText instead.
169
// FIXME XXX
170
//
690 cbradney 171
bool loadText(QString filename, QString *Buffer)
8 paul 172
{
690 cbradney 173
        QFile f(filename);
8 paul 174
        QFileInfo fi(f);
175
        if (!fi.exists())
176
                return false;
167 Franz 177
        bool ret;
10592 fschmid 178
        QByteArray bb(f.size(), ' ');
8501 cbradney 179
        if (f.open(QIODevice::ReadOnly))
167 Franz 180
        {
10592 fschmid 181
                f.read(bb.data(), f.size());
8 paul 182
                f.close();
8546 cbradney 183
                for (int posi = 0; posi < bb.size(); ++posi)
3027 fschmid 184
                        *Buffer += QChar(bb[posi]);
3497 avox 185
                /*
186
                int len = bb.size();
187
                int oldLen = Buffer->length();
188
                Buffer->setLength( oldLen + len + 1);
189
                // digged into Qt 3.3 sources to find that. Might break in Qt 4 -- AV
190
                unsigned short * ucsString = const_cast<unsigned short *>(Buffer->ucs2()) + oldLen;
191
                char * data = bb.data();
192
                for (uint posi = 0; posi < len; ++posi)
10200 cbradney 193
                *ucsString++ = *data++;
3497 avox 194
                *ucsString = 0;
10200 cbradney 195
                */
8 paul 196
                ret = true;
167 Franz 197
        }
8 paul 198
        else
199
                ret = false;
200
        return ret;
201
}
202
 
9535 fschmid 203
bool loadRawText(const QString & filename, QByteArray & buf)
3158 craig 204
{
205
        bool ret = false;
206
        QFile f(filename);
207
        QFileInfo fi(f);
208
        if (fi.exists())
209
        {
12188 jghali 210
                // Allocating one more bytes for null terminator is unneeded with Qt4
211
                // as QByteArray ensure null termination automatically
212
                // Triggers also QDomDocument parsing errors
213
                QByteArray tempBuf(f.size() /*+ 1*/, ' ');
8501 cbradney 214
                if (f.open(QIODevice::ReadOnly))
3158 craig 215
                {
10592 fschmid 216
                        unsigned int bytesRead = f.read(tempBuf.data(), f.size());
12188 jghali 217
                        /*tempBuf[bytesRead] = '\0';*/
3158 craig 218
                        ret = bytesRead == f.size();
219
                        if (ret)
220
                                buf = tempBuf; // sharing makes this efficient
221
                }
222
        }
223
        if (f.isOpen())
224
                f.close();
225
        return ret;
226
}
227
 
5234 fschmid 228
bool loadRawBytes(const QString & filename, QByteArray & buf)
229
{
230
        bool ret = false;
231
        QFile f(filename);
232
        QFileInfo fi(f);
233
        if (fi.exists())
234
        {
10592 fschmid 235
                QByteArray tempBuf(f.size(), ' ');
8501 cbradney 236
                if (f.open(QIODevice::ReadOnly))
5234 fschmid 237
                {
10592 fschmid 238
                        unsigned int bytesRead = f.read(tempBuf.data(), f.size());
5234 fschmid 239
                        ret = bytesRead == f.size();
240
                        if (ret)
241
                                buf = tempBuf; // sharing makes this efficient
242
                }
243
        }
244
        if (f.isOpen())
245
                f.close();
246
        return ret;
247
}
248
 
8 paul 249
 
250
QString CompressStr(QString *in)
251
{
252
        QString out = "";
10592 fschmid 253
        QByteArray bb(in->length(), ' ');
9997 jghali 254
        if (bb.size() == in->length())
3158 craig 255
        {
9997 jghali 256
                for (int ax = 0; ax < in->length(); ++ax)
257
                {
258
                        // bb.insert(ax, in->at(ax)); JG monstruously inefficient due to frequent memory reallocation
259
                        bb[ax] = in->at(ax).cell();
260
                        assert(in->at(ax).row() == 0);
261
                }
10018 fschmid 262
                uLong exlen = (uLong)(bb.size() * 0.001 + 16) + bb.size();
10592 fschmid 263
                QByteArray bc(exlen, ' ');
10018 fschmid 264
                if( bc.size() == static_cast<qint32>(exlen) )
9997 jghali 265
                {
266
                        int errcode = compress2((Byte *)bc.data(), &exlen, (Byte *)bb.data(), uLong(bb.size()), 9);
267
                        if (errcode != Z_OK)
268
                        {
269
                                qDebug("compress2 failed with code %i", errcode);
270
                                out = *in;
271
                        }
272
                        else {
273
                                for (uint cl = 0; cl < exlen; ++cl)
274
                                        out += QChar(bc[cl]);
275
                        }
276
                }
277
                else
278
                {
279
                        qDebug("insufficient memory to allocate %i bytes", in->length());
280
                        out = *in;
281
                }
282
        }
283
        else
284
        {
285
                qDebug("insufficient memory to allocate %i bytes", in->length());
2295 cbradney 286
                out = *in;
287
        }
8 paul 288
        return out;
289
}
290
 
11317 jghali 291
QByteArray CompressArray(const QByteArray& in)
5234 fschmid 292
{
293
        QByteArray out;
11317 jghali 294
        uLong exlen = uint(in.size() * 0.001 + 16) + in.size();
10592 fschmid 295
        QByteArray temp(exlen, ' ');
11317 jghali 296
        int errcode = compress2((Byte *)temp.data(), &exlen, (Byte *)in.data(), uLong(in.size()), 9);
297
        if (errcode == Z_OK)
5234 fschmid 298
        {
299
                temp.resize(exlen);
300
                out = temp;
301
        }
11317 jghali 302
        else
303
                qDebug("compress2 failed with code %i", errcode);
5234 fschmid 304
        return out;
305
}
306
 
11107 jghali 307
char *toAscii85( quint32 value, bool& allZero )
308
{
309
        int digit, i;
310
        static char asciiVal[6];
311
        allZero = true;
312
    for (i = 0; i < 5; ++i)
313
        {
314
                digit = value % 85;
315
                if (digit != 0)
316
                        allZero = false;
317
                asciiVal[4-i] = digit + 33;
318
                value = (value - digit) / 85;
319
    }
320
        asciiVal[5] = 0;
321
        return asciiVal;
322
}
323
 
8 paul 324
char *toHex( uchar u )
325
{
1555 fschmid 326
        static char hexVal[3];
327
        int i = 1;
328
        while ( i >= 0 )
167 Franz 329
        {
330
                ushort hex = (u & 0x000f);
331
                if ( hex < 0x0a )
1555 fschmid 332
                        hexVal[i] = '0'+hex;
167 Franz 333
                else
1555 fschmid 334
                        hexVal[i] = 'A'+(hex-0x0a);
167 Franz 335
                u = u >> 4;
1555 fschmid 336
                i--;
337
        }
338
        hexVal[2] = '\0';
339
        return hexVal;
8 paul 340
}
341
 
342
QString String2Hex(QString *in, bool lang)
343
{
344
        int i = 0;
8546 cbradney 345
        QString out("");
346
        for( int xi = 0; xi < in->length(); ++xi )
167 Franz 347
        {
8663 subik 348
                // Qt4 .cell() added ???
8799 jghali 349
                out += toHex(QChar(in->at(xi)).cell());
8 paul 350
                ++i;
351
                if ((i>40) && (lang))
167 Franz 352
                {
8 paul 353
                        out += '\n';
354
                        i=0;
355
                }
167 Franz 356
        }
8 paul 357
        return out;
358
}
359
 
360
QByteArray ComputeMD5Sum(QByteArray *in)
361
{
10692 fschmid 362
        return QCryptographicHash::hash(*in, QCryptographicHash::Md5);
363
//      QByteArray MDsum(16, ' ');
364
//      md5_buffer (in->data(), in->size(), reinterpret_cast<void*>(MDsum.data()));
365
//      return MDsum;
8 paul 366
}
367
 
10259 jghali 368
QString Path2Relative(QString Path, const QString& baseDir)
19 Franz 369
{
10259 jghali 370
        QDir d(baseDir);
9717 fschmid 371
        return d.relativeFilePath(Path);
10200 cbradney 372
}
3089 fschmid 373
 
10259 jghali 374
QString Relative2Path(QString File, const QString& baseDir)
375
{
376
        QString   absPath;
377
        QFileInfo fi(File);
378
        if (File.isEmpty())
379
                absPath = File;
380
        else if (fi.isRelative())
167 Franz 381
        {
10259 jghali 382
                QDir d(baseDir);
383
                absPath = d.absoluteFilePath(File);
384
                absPath = QDir::cleanPath(absPath);
385
        }
10200 cbradney 386
        else
10259 jghali 387
                absPath = File;
388
        return absPath;
10200 cbradney 389
}
3089 fschmid 390
 
90 Franz 391
/***************************************************************************
392
    begin                : Wed Oct 29 2003
393
    copyright            : (C) 2003 The Scribus Team
394
    email                : paul@all-the-johnsons.co.uk
395
 ***************************************************************************/
396
// check if the file exists, if it does, ask if they're sure
397
// return true if they're sure, else return false;
398
 
399
bool overwrite(QWidget *parent, QString filename)
400
{
167 Franz 401
        bool retval = true;
402
        QFileInfo fi(filename);
403
        if (fi.exists())
1555 fschmid 404
        {
7152 jghali 405
                QString fn = QDir::convertSeparators(filename);
9706 cbradney 406
                int t = QMessageBox::warning(parent, QObject::tr("File exists"),
10200 cbradney 407
                                                                         "<qt>"+ QObject::tr("A file named '%1' already exists.<br/>Do you want to replace it with the file you are saving?").arg(fn) +"</qt>",
408
                                                                                         QMessageBox::Ok | QMessageBox::Cancel, QMessageBox::Cancel);
9422 fschmid 409
                if (t == QMessageBox::Cancel)
90 Franz 410
                        retval = false;
1555 fschmid 411
        }
412
        return retval;
90 Franz 413
}
124 Franz 414
 
1957 cbradney 415
void WordAndPara(PageItem* currItem, int *w, int *p, int *c, int *wN, int *pN, int *cN)
125 Franz 416
{
417
        QChar Dat = QChar(32);
418
        int para = 0;
419
        int ww = 0;
420
        int cc = 0;
421
        int paraN = 0;
422
        int wwN = 0;
423
        int ccN = 0;
424
        bool first = true;
1957 cbradney 425
        PageItem *nextItem = currItem;
426
        PageItem *nbl = currItem;
427
        while (nextItem != 0)
167 Franz 428
        {
7994 avox 429
                if (nextItem->prevInChain() != 0)
430
                        nextItem = nextItem->prevInChain();
125 Franz 431
                else
432
                        break;
167 Franz 433
        }
1957 cbradney 434
        while (nextItem != 0)
167 Franz 435
        {
8562 jghali 436
                for (int a = qMax(nextItem->firstInFrame(),0); a <= nextItem->lastInFrame() && a < nextItem->itemText.length(); ++a)
1555 fschmid 437
                {
5184 avox 438
                        QChar b = nextItem->itemText.text(a);
5732 avox 439
                        if (b == SpecialChars::PARSEP)
167 Franz 440
                        {
5732 avox 441
                                para++;
167 Franz 442
                        }
125 Franz 443
                        if ((!b.isLetterOrNumber()) && (Dat.isLetterOrNumber()) && (!first))
167 Franz 444
                        {
5732 avox 445
                                ww++;
167 Franz 446
                        }
5732 avox 447
                        cc++;
1555 fschmid 448
                        Dat = b;
125 Franz 449
                        first = false;
1555 fschmid 450
                }
1957 cbradney 451
                nbl = nextItem;
7994 avox 452
                nextItem = nextItem->nextInChain();
167 Franz 453
        }
5732 avox 454
        if (nbl->frameOverflows()) {
125 Franz 455
                paraN++;
5736 avox 456
                for (int a = nbl->lastInFrame()+1; a < nbl->itemText.length(); ++a)
5732 avox 457
                {
5736 avox 458
                        QChar b = nbl->itemText.text(a);
5732 avox 459
                        if (b == SpecialChars::PARSEP)
460
                        {
461
                                paraN++;
462
                        }
463
                        if ((!b.isLetterOrNumber()) && (Dat.isLetterOrNumber()) && (!first))
464
                        {
465
                                wwN++;
466
                        }
467
                        ccN++;
468
                        Dat = b;
469
                        first = false;
470
                }
471
        }              
472
        else {
125 Franz 473
                para++;
5732 avox 474
        }
125 Franz 475
        if (Dat.isLetterOrNumber())
167 Franz 476
        {
5559 avox 477
                if (nbl->frameOverflows())
125 Franz 478
                        wwN++;
479
                else
480
                        ww++;
167 Franz 481
        }
125 Franz 482
        *w = ww;
483
        *p = para;
484
        *c = cc;
485
        *wN = wwN;
486
        *pN = paraN;
487
        *cN = ccN;
488
}
203 Franz 489
 
690 cbradney 490
void ReOrderText(ScribusDoc *currentDoc, ScribusView *view)
203 Franz 491
{
4593 cbradney 492
        double savScale = view->scale();
2380 cbradney 493
        view->setScale(1.0);
690 cbradney 494
        currentDoc->RePos = true;
9319 fschmid 495
        QImage pgPix(10, 10, QImage::Format_ARGB32);
10840 avox 496
        QRect rd; // = QRect(0,0,9,9);
203 Franz 497
        ScPainter *painter = new ScPainter(&pgPix, pgPix.width(), pgPix.height());
9903 fschmid 498
        for (int azz=0; azz<currentDoc->MasterItems.count(); ++azz)
203 Franz 499
        {
1957 cbradney 500
                PageItem *currItem = currentDoc->MasterItems.at(azz);
501
                if (currItem->itemType() == PageItem::PathText)
502
                        currItem->DrawObj(painter, rd);
203 Franz 503
        }
9903 fschmid 504
        for (int azz=0; azz<currentDoc->Items->count(); ++azz)
203 Franz 505
        {
3727 cbradney 506
                PageItem *currItem = currentDoc->Items->at(azz);
11388 avox 507
                currItem->layout();
508
                if (currItem->itemType() == PageItem::PathText)
509
                        currItem->DrawObj(painter, rd); //FIXME: this should be replaced by code in layout()
203 Franz 510
        }
690 cbradney 511
        currentDoc->RePos = false;
2380 cbradney 512
        view->setScale(savScale);
203 Franz 513
        delete painter;
514
}
447 cbradney 515
 
4449 subik 516
/*! \brief Helper function for sorting in sortQStringList.
517
\author 10/06/2004 - pv
4645 subik 518
\param s1 first string
519
\param s2 second string
447 cbradney 520
\retval bool t/f related s1>s2
521
 */
522
bool compareQStrings(QString s1, QString s2)
523
{
524
        if (QString::localeAwareCompare(s1, s2) >= 0)
2680 cbradney 525
                return false;
526
        return true;
447 cbradney 527
}
528
 
529
QStringList sortQStringList(QStringList aList)
530
{
531
        std::vector<QString> sortList;
532
        QStringList retList;
533
        QStringList::Iterator it;
534
        for (it = aList.begin(); it != aList.end(); ++it)
535
                sortList.push_back(*it);
536
        std::sort(sortList.begin(), sortList.end(), compareQStrings);
456 fschmid 537
        for(uint i = 0; i < sortList.size(); i++)
447 cbradney 538
                retList.append(sortList[i]);
539
        return retList;
540
}
517 fschmid 541
 
2834 cbradney 542
QString checkFileExtension(const QString &currName, const QString &extension)
543
{
544
        QString newName(currName);
545
        //If filename ends with a period, just add the extension
546
        if (newName.right(1)==".")
547
        {
10398 cbradney 548
                newName+=extension.toLower();
2834 cbradney 549
                return newName;
550
        }
551
        //If filename doesnt end with the period+extension, add it on
10398 cbradney 552
        QString dotExt("." + extension.toLower());
10592 fschmid 553
        if (!newName.endsWith(dotExt, Qt::CaseInsensitive))
2834 cbradney 554
                newName+=dotExt;
555
        return newName;
556
}
2907 subik 557
 
5781 cbradney 558
QString getFileNameByPage(ScribusDoc* currDoc, uint pageNo, QString extension)
2907 subik 559
{
9791 jghali 560
        uint number = pageNo + currDoc->FirstPnum;
5781 cbradney 561
        QString defaultName = currDoc->DocName;
2907 subik 562
        if (defaultName.isNull())
563
                defaultName = "export";
564
        else
565
        {
566
                QFileInfo fi(defaultName);
10469 cbradney 567
                defaultName = fi.completeBaseName();
2907 subik 568
        }
9791 jghali 569
        return QString("%1-%2%3.%4").arg(defaultName).arg(QObject::tr("page", "page export")).arg(number, 3, 10, QChar('0')).arg(extension);
2907 subik 570
}
3689 cbradney 571
 
3757 cbradney 572
const QString getStringFromSequence(DocumentSectionType type, uint position)
573
{
574
        QString retVal("");
575
        switch( type )
576
        {
3778 cbradney 577
                case Type_1_2_3:
578
                        retVal=QString::number(position);
579
                        break;
3757 cbradney 580
                case Type_A_B_C:
10398 cbradney 581
                        retVal=numberToLetterSequence(position).toUpper();
3778 cbradney 582
                        break;
3757 cbradney 583
                case Type_a_b_c:
3778 cbradney 584
                        retVal=numberToLetterSequence(position);
3757 cbradney 585
                        break;
586
                case Type_I_II_III:
587
                        retVal=arabicToRoman(position);
588
                        break;
589
                case Type_i_ii_iii:
590
                        //well, for lower case people will want that, even if its "wrong"
591
                        //ie, X=10, x=10000
10398 cbradney 592
                        retVal=arabicToRoman(position).toLower();
3757 cbradney 593
                        break;
8439 cbradney 594
                case Type_None:
595
                        break;
3757 cbradney 596
                default:
597
                        break;
598
        }
599
        return retVal;
600
}
601
 
602
const QString numberToLetterSequence(uint i)
603
{
604
        QString retVal("");
605
        unsigned digits = 1;
606
        unsigned offset = 0;
607
        uint column=i;
608
        --column;
609
 
610
        if( column > 4058115285U ) return  QString("@");
611
 
612
        for( unsigned limit = 26; column >= limit+offset; limit *= 26, digits++ )
613
                offset += limit;
614
 
615
        for( unsigned c = column - offset; digits; --digits, c/=26 )
616
                retVal.prepend( QChar( 'a' + (c%26) ) );
617
        return retVal;
618
}
619
 
620
const QString arabicToRoman(uint i)
621
{
622
        QString roman("");
623
        int arabic = i;
624
        while (arabic - 1000000 >= 0){
10200 cbradney 625
                roman += "m";
626
                arabic -= 1000000;
3757 cbradney 627
        }
628
        while (arabic - 900000 >= 0){
10200 cbradney 629
                roman += "cm";
630
                arabic -= 900000;
3757 cbradney 631
        }
632
        while (arabic - 500000 >= 0){
10200 cbradney 633
                roman += "d";
634
                arabic -= 500000;
3757 cbradney 635
        }
636
        while (arabic - 400000 >= 0){
10200 cbradney 637
                roman += "cd";
638
                arabic -= 400000;
3757 cbradney 639
        }
640
        while (arabic - 100000 >= 0){
10200 cbradney 641
                roman += "c";
642
                arabic -= 100000;
3757 cbradney 643
        }
644
        while (arabic - 90000 >= 0){
10200 cbradney 645
                roman += "xc";
646
                arabic -= 90000;
3757 cbradney 647
        }
648
        while (arabic - 50000 >= 0){
10200 cbradney 649
                roman += "l";
650
                arabic -= 50000;
3757 cbradney 651
        }
652
        while (arabic - 40000 >= 0){
10200 cbradney 653
                roman += "xl";
654
                arabic -= 40000;
3757 cbradney 655
        }
656
        while (arabic - 10000 >= 0){
10200 cbradney 657
                roman += "x";
658
                arabic -= 10000;
3757 cbradney 659
        }
660
        while (arabic - 9000 >= 0){
10200 cbradney 661
                roman += "Mx";
662
                arabic -= 9000;
3757 cbradney 663
        }
664
        while (arabic - 5000 >= 0){
10200 cbradney 665
                roman += "v";
666
                arabic -= 5000;
3757 cbradney 667
        }
668
        while (arabic - 4000 >= 0){
10200 cbradney 669
                roman += "Mv";
670
                arabic -= 4000;
3757 cbradney 671
        }
672
        while (arabic - 1000 >= 0){
10200 cbradney 673
                roman += "M";
674
                arabic -= 1000;
3757 cbradney 675
        }
676
        while (arabic - 900 >= 0){
10200 cbradney 677
                roman += "CM";
678
                arabic -= 900;
3757 cbradney 679
        }
680
        while (arabic - 500 >= 0){
10200 cbradney 681
                roman += "D";
682
                arabic -= 500;
3757 cbradney 683
        }
684
        while (arabic - 400 >= 0){
10200 cbradney 685
                roman += "CD";
686
                arabic -= 400;
3757 cbradney 687
        }
688
        while (arabic - 100 >= 0){
10200 cbradney 689
                roman += "C";
690
                arabic -= 100;
3757 cbradney 691
        }
692
        while (arabic - 90 >= 0){
10200 cbradney 693
                roman += "XC";
694
                arabic -= 90;
3757 cbradney 695
        }
696
        while (arabic - 50 >= 0){
10200 cbradney 697
                roman += "L";
698
                arabic -= 50;
3757 cbradney 699
        }
700
        while (arabic - 40 >= 0){
10200 cbradney 701
                roman += "XL";
702
                arabic -= 40;
3757 cbradney 703
        }
704
        while (arabic - 10 >= 0){
10200 cbradney 705
                roman += "X";
706
                arabic -= 10;
3757 cbradney 707
        }
708
        while (arabic - 9 >= 0){
10200 cbradney 709
                roman += "IX";
710
                arabic -= 9;
3757 cbradney 711
        }
712
        while (arabic - 5 >= 0){
10200 cbradney 713
                roman += "V";
714
                arabic -= 5;
3757 cbradney 715
        }
716
        while (arabic - 4 >= 0){
10200 cbradney 717
                roman += "IV";
718
                arabic -= 4;
3757 cbradney 719
        }
720
        while (arabic - 1 >= 0){
10200 cbradney 721
                roman += "I";
722
                arabic -= 1;
3757 cbradney 723
        }
724
        return roman;
3776 cbradney 725
}
3784 cbradney 726
 
727
//CB Moved from scribus.cpp
728
void parsePagesString(QString pages, std::vector<int>* pageNs, int sourcePageCount)
729
{
730
        QString tmp(pages);
731
        QString token;
732
        int from, to, pageNr;
733
        do
734
        {
10517 cbradney 735
                if (tmp.indexOf(",") == -1)
3784 cbradney 736
                {
737
                        token = tmp;
738
                        tmp = "";
739
                }
740
                else
741
                {
10517 cbradney 742
                        token = tmp.left(tmp.indexOf(","));
743
                        tmp = tmp.right(tmp.length() - tmp.indexOf(",") - 1);
3784 cbradney 744
                }
745
 
10394 cbradney 746
                token = token.trimmed();
3784 cbradney 747
                if (token == "*") // Import all source doc pages
748
                {
749
                        for (int i = 1; i <= sourcePageCount; ++i)
750
                                pageNs->push_back(i);
751
                }
10517 cbradney 752
                else if (token.indexOf("-") != -1) // import a range of source doc pages
3784 cbradney 753
                {
10517 cbradney 754
                        from = QString(token.left(token.indexOf("-"))).toInt();
755
                        to = QString(token.right(token.length() - token.indexOf("-") - 1)).toInt();
3784 cbradney 756
                        if ((from != 0) && (to != 0))
757
                        {
758
                                if (from > sourcePageCount)
759
                                        from = sourcePageCount;
760
                                if (to > sourcePageCount)
761
                                        to = sourcePageCount;
762
                                if (from == to)
763
                                        pageNs->push_back(to);
764
                                else if (from < to)
765
                                {
766
                                        for (int i = from; i <= to; ++i)
767
                                                pageNs->push_back(i);
768
                                }
769
                                else
770
                                {
771
                                        for (int i = from; i >= to; --i)
772
                                                pageNs->push_back(i);
773
                                }
774
                        }
775
                }
776
                else // import single source doc page
777
                {
778
                        pageNr = token.toInt();
779
                        if ((pageNr > 0) && (pageNr <= sourcePageCount))
780
                                pageNs->push_back(pageNr);
781
                }
782
        } while (!tmp.isEmpty());
3793 cbradney 783
}
5184 avox 784
 
5890 subik 785
void tDebug(QString message)
786
{
787
        QDateTime debugTime;
10592 fschmid 788
        qDebug("%s", QString("%1\t%2").arg(debugTime.currentDateTime().toString("hh:mm:ss:zzz")).arg(message).toAscii().constData());
5890 subik 789
}
6116 fschmid 790
 
9970 fschmid 791
 
9991 fschmid 792
QString readLinefromDataStream(QDataStream &s)
9970 fschmid 793
{
794
        QString ret = "";
9991 fschmid 795
        uchar charData;
9970 fschmid 796
        while (!s.atEnd())
797
        {
9991 fschmid 798
                s >> charData;
799
                if (charData == '\x0A')
800
                        break;
801
                if (charData == '\x0D')
9970 fschmid 802
                {
9991 fschmid 803
                        quint64 oldPos = s.device()->pos();
804
                        s >> charData;
805
                        if (charData != '\x0A')
806
                                s.device()->seek(oldPos);
9970 fschmid 807
                        break;
808
                }
9991 fschmid 809
                ret += QChar(charData);
9970 fschmid 810
        }
811
        return ret.trimmed();
812
}
10648 fschmid 813
 
814
void setCurrentComboItem(QComboBox *box, QString text)
815
{
816
        box->blockSignals(true);
817
        int ind = box->findText(text);
818
        if (ind > -1)
819
                box->setCurrentIndex(ind);
820
        box->blockSignals(false);
821
}
10988 fschmid 822
 
823
QString getDashString(int dashtype, double linewidth)
824
{
12055 jghali 825
        QString dashString;
826
        QVector<double> dashArray;
827
        getDashArray(dashtype, linewidth, dashArray);
828
        for (int a = 0; a < dashArray.size(); ++a)
829
        {
830
                dashString += QString::number(dashArray.at(a));
831
                if (a < (dashArray.size() - 1))
832
                        dashString += " ";
833
        }
834
        return dashString;
835
}
836
 
837
void getDashArray(int dashtype, double linewidth, QVector<double> &m_array)
838
{
839
        m_array.clear();
840
        if ((dashtype == 1) || (dashtype == 0))
841
                return;
842
        double Dt = qMax(1.0*linewidth, 0.1);
843
        double Sp = qMax(2.0*linewidth, 0.1);
844
        double Da = qMax(4.0*linewidth, 0.1);
10988 fschmid 845
        switch (dashtype)
846
        {
847
                case 1:
848
                        break;
849
                case 2:
12055 jghali 850
                        m_array << Da << Sp;
10988 fschmid 851
                        break;
852
                case 3:
12055 jghali 853
                        m_array << Dt << Sp;
10988 fschmid 854
                        break;
855
                case 4:
12055 jghali 856
                        m_array << Da << Sp << Dt << Sp;
10988 fschmid 857
                        break;
858
                case 5:
12055 jghali 859
                        m_array << Da << Sp << Dt << Sp << Dt << Sp;
10988 fschmid 860
                        break;
861
// Additional line styles taken from Inkscape
11177 fschmid 862
                case 6:
12055 jghali 863
                        m_array << qMax(1.0 * linewidth, 0.01) << qMax(1.0 * linewidth, 0.01);
10988 fschmid 864
                        break;
865
                case 7:
12055 jghali 866
                        m_array << qMax(1.0 * linewidth, 0.01) << qMax(3.0 * linewidth, 0.01);
10988 fschmid 867
                        break;
868
                case 8:
12055 jghali 869
                        m_array << qMax(1.0 * linewidth, 0.01) << qMax(4.0 * linewidth, 0.01);
10988 fschmid 870
                        break;
871
                case 9:
12055 jghali 872
                        m_array << qMax(1.0 * linewidth, 0.01) << qMax(6.0 * linewidth, 0.01);
10988 fschmid 873
                        break;
874
                case 10:
12055 jghali 875
                        m_array << qMax(1.0 * linewidth, 0.01) << qMax(8.0 * linewidth, 0.01);
10988 fschmid 876
                        break;
877
                case 11:
12055 jghali 878
                        m_array << qMax(1.0 * linewidth, 0.01) << qMax(12.0 * linewidth, 0.01);
10988 fschmid 879
                        break;
880
                case 12:
12055 jghali 881
                        m_array << qMax(1.0 * linewidth, 0.01) << qMax(24.0 * linewidth, 0.01);
10988 fschmid 882
                        break;
883
                case 13:
12055 jghali 884
                        m_array << qMax(1.0 * linewidth, 0.01) << qMax(48.0 * linewidth, 0.01);
10988 fschmid 885
                        break;
886
                case 14:
12055 jghali 887
                        m_array << qMax(2.0 * linewidth, 0.01) << qMax(1.0 * linewidth, 0.01);
10988 fschmid 888
                        break;
889
                case 15:
12055 jghali 890
                        m_array << qMax(3.0 * linewidth, 0.01) << qMax(1.0 * linewidth, 0.01);
10988 fschmid 891
                        break;
892
                case 16:
12055 jghali 893
                        m_array << qMax(4.0 * linewidth, 0.01) << qMax(1.0 * linewidth, 0.01);
10988 fschmid 894
                        break;
895
                case 17:
12055 jghali 896
                        m_array << qMax(6.0 * linewidth, 0.01) << qMax(1.0 * linewidth, 0.01);
10988 fschmid 897
                        break;
898
                case 18:
12055 jghali 899
                        m_array << qMax(8.0 * linewidth, 0.01) << qMax(1.0 * linewidth, 0.01);
10988 fschmid 900
                        break;
901
                case 19:
12055 jghali 902
                        m_array << qMax(10.0 * linewidth, 0.01) << qMax(1.0 * linewidth, 0.01);
10988 fschmid 903
                        break;
904
                case 20:
12055 jghali 905
                        m_array << qMax(12.0 * linewidth, 0.01) << qMax(1.0 * linewidth, 0.01);
10988 fschmid 906
                        break;
907
                case 21:
12055 jghali 908
                        m_array << qMax(2.0 * linewidth, 0.01) << qMax(2.0 * linewidth, 0.01);
10988 fschmid 909
                        break;
910
                case 22:
12055 jghali 911
                        m_array << qMax(3.0 * linewidth, 0.01) << qMax(3.0 * linewidth, 0.01);
10988 fschmid 912
                        break;
913
                case 23:
12055 jghali 914
                        m_array << qMax(4.0 * linewidth, 0.01) << qMax(4.0 * linewidth, 0.01);
10988 fschmid 915
                        break;
916
                case 24:
12055 jghali 917
                        m_array << qMax(6.0 * linewidth, 0.01) << qMax(6.0 * linewidth, 0.01);
10988 fschmid 918
                        break;
919
                case 25:
12055 jghali 920
                        m_array << qMax(8.0 * linewidth, 0.01) << qMax(8.0 * linewidth, 0.01);
10988 fschmid 921
                        break;
922
                case 26:
12055 jghali 923
                        m_array << qMax(10.0 * linewidth, 0.01) << qMax(10.0 * linewidth, 0.01);
10988 fschmid 924
                        break;
925
                case 27:
12055 jghali 926
                        m_array << qMax(12.0 * linewidth, 0.01) << qMax(12.0 * linewidth, 0.01);
10988 fschmid 927
                        break;
928
                case 28:
12055 jghali 929
                        m_array << qMax(2.0 * linewidth, 0.01) << qMax(4.0 * linewidth, 0.01);
10988 fschmid 930
                        break;
931
                case 29:
12055 jghali 932
                        m_array << qMax(2.0 * linewidth, 0.01) << qMax(6.0 * linewidth, 0.01);
10988 fschmid 933
                        break;
934
                case 30:
12055 jghali 935
                        m_array << qMax(6.0 * linewidth, 0.01) << qMax(2.0 * linewidth, 0.01);
10988 fschmid 936
                        break;
937
                case 31:
12055 jghali 938
                        m_array << qMax(4.0 * linewidth, 0.01) << qMax(8.0 * linewidth, 0.01);
10988 fschmid 939
                        break;
940
                case 32:
12055 jghali 941
                        m_array << qMax(8.0 * linewidth, 0.01) << qMax(4.0 * linewidth, 0.01);
10988 fschmid 942
                        break;
943
                case 33:
12055 jghali 944
                        m_array << qMax(2.0 * linewidth, 0.01) << qMax(1.0 * linewidth, 0.01);
945
                        m_array << qMax(0.5 * linewidth, 0.01) << qMax(1.0 * linewidth, 0.01);
10988 fschmid 946
                        break;
947
                case 34:
12055 jghali 948
                        m_array << qMax(8.0 * linewidth, 0.01) << qMax(2.0 * linewidth, 0.01);
949
                        m_array << qMax(1.0 * linewidth, 0.01) << qMax(2.0 * linewidth, 0.01);
10988 fschmid 950
                        break;
951
                case 35:
12055 jghali 952
                        m_array << qMax(0.5 * linewidth, 0.01) << qMax(0.5 * linewidth, 0.01);
10988 fschmid 953
                        break;
954
                case 36:
12055 jghali 955
                        m_array << qMax(0.25 * linewidth, 0.01) << qMax(0.25 * linewidth, 0.01);
10988 fschmid 956
                        break;
957
                case 37:
12055 jghali 958
                        m_array << qMax(0.1 * linewidth, 0.01) << qMax(0.1 * linewidth, 0.01);
11177 fschmid 959
                        break;
10988 fschmid 960
                default:
961
                        break;
962
        }
963
}