Subversion Repositories Scribus

Rev

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