Subversion Repositories Scribus

Rev

Rev 16546 | Rev 17798 | 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
*/
3 paul 7
/***************************************************************************
8
                          hyphenator.cpp  -  description
9
                             -------------------
10
    begin                : Sat Nov 02 08:00:00 CEST 2002
11
    copyright            : (C) 2002 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
 ***************************************************************************/
23
#include "hyphenator.h"
13650 cbradney 24
#include "ui/hyask.h"
128 Franz 25
 
2688 craig 26
#include "scconfig.h"
128 Franz 27
 
16546 jghali 28
#include <QApplication>
10223 cbradney 29
#include <QRegExp>
30
#include <QCursor>
31
#include <QDir>
10242 subik 32
#include <QCheckBox>
8501 cbradney 33
//Added by qt3to4:
9535 fschmid 34
#include <QByteArray>
3 paul 35
#include <cstdlib>
80 Franz 36
#include <string>
12787 pierre 37
#include "langmgr.h"
1693 craig 38
#include "scpaths.h"
5781 cbradney 39
#include "scribuscore.h"
13805 jghali 40
#include "scribusdoc.h"
1866 fschmid 41
#include "prefsfile.h"
2834 cbradney 42
#include "prefsmanager.h"
5184 avox 43
#include "text/nlsconfig.h"
3 paul 44
 
10511 fschmid 45
Hyphenator::Hyphenator(QWidget* parent, ScribusDoc *dok) : QObject( parent ),
3987 craig 46
        doc(dok),
7734 cbradney 47
        hdict(0),
48
        useAble(false),
49
        codec(0),
14924 cbradney 50
        MinWordLen(doc->hyphMinimumWordLength()),
51
        HyCount(doc->hyphConsecutiveLines()),
52
        Automatic(doc->hyphAutomatic()),
53
        AutoCheck(doc->hyphAutoCheck())
3 paul 54
{
14924 cbradney 55
        //FIXME:av pick up language from charstyle
56
        QString pfad(ScPaths::instance().dictDir());
12787 pierre 57
        LanguageManager * lmgr(LanguageManager::instance());
14924 cbradney 58
        if (!lmgr->getHyphFilename(doc->hyphLanguage(), false).isEmpty() )
59
                Language = doc->hyphLanguage();
3 paul 60
        else
164 Franz 61
        {
13955 cbradney 62
                Language = PrefsManager::instance()->appPrefs.hyphPrefs.Language;
14924 cbradney 63
                doc->setHyphLanguage(Language);
164 Franz 64
        }
12787 pierre 65
//      pfad += ScCore->primaryMainWindow()->Sprachen[Language];
17501 craig 66
        pfad += lmgr->getHyphFilename( doc->hyphLanguage(), true );
106 Franz 67
        QFile f(pfad);
8501 cbradney 68
        if (f.open(QIODevice::ReadOnly))
164 Franz 69
        {
9923 fschmid 70
                QTextStream st(&f);
164 Franz 71
        QString line;
72
        line = st.readLine();
10511 fschmid 73
                codec = QTextCodec::codecForName(line.toUtf8());
106 Franz 74
                f.close();
164 Franz 75
        }
106 Franz 76
        else
164 Franz 77
        {
106 Franz 78
                useAble = false;
79
                hdict = NULL;
80
                return;
164 Franz 81
        }
10493 fschmid 82
        QByteArray fn = pfad.toLocal8Bit();
3987 craig 83
        const char * filename = fn.data();
105 Franz 84
        hdict = hnj_hyphen_load(filename);
164 Franz 85
        useAble = hdict == NULL ? false : true;
10170 fschmid 86
        rememberedWords.clear();
87
/* Add reading these special lists from prefs or doc here */
88
        ignoredWords.clear();
89
        specialWords.clear();
3 paul 90
}
91
 
92
Hyphenator::~Hyphenator()
93
{
14334 jghali 94
        if (hdict)
95
                hnj_hyphen_free(hdict);
3 paul 96
}
97
 
6931 avox 98
void Hyphenator::NewDict(const QString& name)
3 paul 99
{
12787 pierre 100
//      if (!ScCore->primaryMainWindow()->Sprachen.contains(name))
101
//              return;
102
        if( LanguageManager::instance()->getHyphFilename(name, false).isEmpty() )
3 paul 103
                return;
12787 pierre 104
 
6931 avox 105
        if (Language != name)
164 Franz 106
        {
6931 avox 107
                Language = name;
108
 
109
                char *filename = NULL;
11120 malex 110
                QString pfad = ScPaths::instance().dictDir();
6931 avox 111
 
112
                if (hdict != NULL)
113
                        hnj_hyphen_free(hdict);
114
 
12787 pierre 115
                pfad +=  LanguageManager::instance()->getHyphFilename(Language, false) ;
6931 avox 116
                QFile f(pfad);
8501 cbradney 117
                if (f.open(QIODevice::ReadOnly))
6931 avox 118
                {
9923 fschmid 119
                        QTextStream st(&f);
6931 avox 120
                        QString line;
121
                        line = st.readLine();
10511 fschmid 122
                        codec = QTextCodec::codecForName(line.toUtf8());
6931 avox 123
                        f.close();
124
                }
125
                else
126
                {
127
                        useAble = false;
128
                        hdict = NULL;
129
                        return;
130
                }
10493 fschmid 131
                QByteArray fn = pfad.toLocal8Bit();
6931 avox 132
                filename = fn.data();
133
                hdict = hnj_hyphen_load(filename);
134
                useAble = hdict == NULL ? false : true;
164 Franz 135
        }
3 paul 136
}
137
 
249 Franz 138
void Hyphenator::slotNewSettings(int Wordlen, bool Autom, bool ACheck, int Num)
3 paul 139
{
140
        MinWordLen = Wordlen;
141
        Automatic = Autom;
142
        AutoCheck = ACheck;
249 Franz 143
        HyCount = Num;
14924 cbradney 144
        doc->setHyphMinimumWordLength(Wordlen);
145
        doc->setHyphAutomatic(Autom);
146
        doc->setHyphAutoCheck(AutoCheck);
147
        doc->setHyphAutoCheck(Num);
3 paul 148
}
149
 
6931 avox 150
void Hyphenator::slotHyphenateWord(PageItem* it, const QString& text, int firstC)
3 paul 151
{
5559 avox 152
        if ((!useAble))//FIXME:av || (!ScMW->Sprachen.contains(it->Language)))
164 Franz 153
                return;
3 paul 154
        const char *word;
164 Franz 155
        char *buffer;
156
        const int BORDER = 2;
9535 fschmid 157
        QByteArray te;
164 Franz 158
 
5781 cbradney 159
        //uint maxC = it->itemText.length() - 1;
3 paul 160
        QString found = text;
6931 avox 161
        if (found.contains(SpecialChars::SHYPHEN))
162
                return;
163
        // else if (findException(found, &buffer) it->itemText.hyphenateWord(firstC, found.length(), buffer);
164
        else if (signed(found.length()) >= MinWordLen)
164 Franz 165
        {
6931 avox 166
                NewDict(it->itemText.charStyle(firstC).language());
164 Franz 167
                te = codec->fromUnicode( found );
3 paul 168
                word = te.data();
169
                buffer = static_cast<char*>(malloc(strlen(word)+BORDER+3));
170
                if (buffer == NULL)
171
                        return;
2743 fschmid 172
                if (!hnj_hyphen_hyphenate(hdict, word, strlen(word), buffer))
164 Franz 173
                {
5781 cbradney 174
                        //uint i = 0;
164 Franz 175
                        buffer[strlen(word)] = '\0';
5559 avox 176
                        it->itemText.hyphenateWord(firstC, found.length(), buffer);
164 Franz 177
                }
3 paul 178
                free(buffer);
164 Franz 179
        }
3 paul 180
}
181
 
182
void Hyphenator::slotHyphenate(PageItem* it)
183
{
5559 avox 184
        if ((!useAble) || !(it->asTextFrame()) || (it->itemText.length() == 0))
164 Franz 185
                return;
5559 avox 186
 
357 Franz 187
        doc->DoDrawing = false;
5559 avox 188
 
3 paul 189
        const char *word;
164 Franz 190
        char *buffer;
191
        const int BORDER = 2;
3 paul 192
        QString text = "";
193
        QString buf;
9535 fschmid 194
        QByteArray te;
5559 avox 195
 
6931 avox 196
        int startC = 0;
15522 jghali 197
        if (it->itemText.lengthOfSelection() > 0)
164 Franz 198
        {
6931 avox 199
                startC = it->itemText.startOfSelection();
200
                text = it->itemText.text(startC, it->itemText.lengthOfSelection());
164 Franz 201
        }
5559 avox 202
        else {
203
                text = it->itemText.text(0, it->itemText.length());
204
        }
6931 avox 205
 
206
        int firstC = 0;
3 paul 207
        int lastC = 0;
208
        int Ccount = 0;
209
        QString found = "";
210
        QString found2 = "";
9769 fschmid 211
        rememberedWords.clear();
5781 cbradney 212
        //uint maxC = it->itemText.length() - 1;
9380 fschmid 213
        qApp->changeOverrideCursor(QCursor(Qt::WaitCursor));
7029 avox 214
        QRegExp wordBoundary("\\w");
215
        QRegExp whiteSpace("\\s|\\W|\\d|\\n|\\r|\\t");
6931 avox 216
        while ((firstC+Ccount < signed(text.length())) && (firstC != -1) &&
217
                        (lastC < signed(text.length())))
164 Franz 218
        {
10511 fschmid 219
                firstC = text.indexOf(wordBoundary, firstC+Ccount);
3 paul 220
                if (firstC < 0)
221
                        break;
7029 avox 222
                if (firstC > 0 && text.at(firstC-1) == SpecialChars::SHYPHEN)
223
                {
224
                        Ccount = 1;
225
                        continue;
226
                }
10511 fschmid 227
                lastC = text.indexOf(whiteSpace, firstC);
3 paul 228
                if (lastC < 0)
7029 avox 229
                        lastC = signed(text.length());
3 paul 230
                Ccount = lastC - firstC;
7029 avox 231
                if (lastC < signed(text.length()) && text.at(lastC) == SpecialChars::SHYPHEN)
232
                {
233
                        ++Ccount;
234
                        continue;
235
                }
1933 fschmid 236
                if (Ccount > MinWordLen-1)
164 Franz 237
                {
10398 cbradney 238
                        found = text.mid(firstC, Ccount).toLower();
3 paul 239
                        found2 = text.mid(firstC, Ccount);
6931 avox 240
                        if (found.contains(SpecialChars::SHYPHEN))
241
                                break;
242
 
243
                        NewDict(it->itemText.charStyle(firstC).language());
244
 
164 Franz 245
                        te = codec->fromUnicode( found );
3 paul 246
                        word = te.data();
247
                        buffer = static_cast<char*>(malloc(strlen(word)+BORDER+3));
248
                        if (buffer == NULL)
249
                                break;
2743 fschmid 250
                        if (!hnj_hyphen_hyphenate(hdict, word, strlen(word), buffer))
164 Franz 251
                        {
8547 cbradney 252
                                int i = 0;
164 Franz 253
                                buffer[strlen(word)] = '\0';
3 paul 254
                                bool hasHyphen = false;
118 Franz 255
                                for (i = 1; i < found.length()-1; ++i)
164 Franz 256
                                {
257
                                        if(buffer[i] & 1)
3 paul 258
                                        {
259
                                                hasHyphen = true;
260
                                                break;
261
                                        }
164 Franz 262
                                }
10170 fschmid 263
                                QString outs = "";
264
                                QString input = "";
265
                                outs += found2[0];
266
                                for (i = 1; i < found.length()-1; ++i)
6931 avox 267
                                {
10170 fschmid 268
                                        outs += found2[i];
269
                                        if(buffer[i] & 1)
270
                                                outs += "-";
6931 avox 271
                                }
10170 fschmid 272
                                outs += found2.right(1);
273
                                input = outs;
274
                                if (!ignoredWords.contains(found2))
275
                                {
276
                                        if (!hasHyphen)
277
                                                it->itemText.hyphenateWord(startC + firstC, found.length(), NULL);
278
                                        else if (Automatic)
13112 fschmid 279
                                        {
280
                                                if (specialWords.contains(found2))
281
                                                {
282
                                                        outs = specialWords.value(found2);
283
                                                        uint ii = 1;
284
                                                        for (i = 1; i < outs.length()-1; ++i)
285
                                                        {
286
                                                                QChar cht = outs[i];
287
                                                                if (cht == '-')
288
                                                                        buffer[ii-1] = 1;
289
                                                                else
290
                                                                {
291
                                                                        buffer[ii] = 0;
292
                                                                        ++ii;
293
                                                                }
294
                                                        }
295
                                                }
10170 fschmid 296
                                                it->itemText.hyphenateWord(startC + firstC, found.length(), buffer);
13112 fschmid 297
                                        }
10170 fschmid 298
                                        else
3 paul 299
                                        {
10170 fschmid 300
                                                if (specialWords.contains(found2))
164 Franz 301
                                                {
10170 fschmid 302
                                                        outs = specialWords.value(found2);
12094 jghali 303
                                                        uint ii = 1;
10170 fschmid 304
                                                        for (i = 1; i < outs.length()-1; ++i)
305
                                                        {
306
                                                                QChar cht = outs[i];
307
                                                                if (cht == '-')
12094 jghali 308
                                                                        buffer[ii-1] = 1;
10170 fschmid 309
                                                                else
12094 jghali 310
                                                                {
10170 fschmid 311
                                                                        buffer[ii] = 0;
12094 jghali 312
                                                                        ++ii;
313
                                                                }
10170 fschmid 314
                                                        }
164 Franz 315
                                                }
10179 fschmid 316
                                                if (rememberedWords.contains(input))
9769 fschmid 317
                                                {
10170 fschmid 318
                                                        outs = rememberedWords.value(input);
12094 jghali 319
                                                        uint ii = 1;
9769 fschmid 320
                                                        for (i = 1; i < outs.length()-1; ++i)
321
                                                        {
322
                                                                QChar cht = outs[i];
323
                                                                if (cht == '-')
12094 jghali 324
                                                                        buffer[ii-1] = 1;
9769 fschmid 325
                                                                else
12094 jghali 326
                                                                {
10170 fschmid 327
                                                                        buffer[ii] = 0;
12094 jghali 328
                                                                        ++ii;
329
                                                                }
9769 fschmid 330
                                                        }
331
                                                        it->itemText.hyphenateWord(firstC, found.length(), buffer);
332
                                                }
333
                                                else
334
                                                {
10170 fschmid 335
                                                        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
336
                                                        PrefsContext* prefs = PrefsManager::instance()->prefsFile->getContext("hyhpen_options");
337
                                                        int xpos = prefs->getInt("Xposition", -9999);
338
                                                        int ypos = prefs->getInt("Yposition", -9999);
339
                                                        HyAsk *dia = new HyAsk((QWidget*)parent(), outs);
340
                                                        if ((xpos != -9999) && (ypos != -9999))
341
                                                                dia->move(xpos, ypos);
342
                                                        qApp->processEvents();
343
                                                        if (dia->exec())
344
                                                        {
345
                                                                outs = dia->Wort->text();
12094 jghali 346
                                                                uint ii = 1;
10170 fschmid 347
                                                                for (i = 1; i < outs.length()-1; ++i)
348
                                                                {
349
                                                                        QChar cht = outs[i];
350
                                                                        if (cht == '-')
12094 jghali 351
                                                                                buffer[ii-1] = 1;
10170 fschmid 352
                                                                        else
12094 jghali 353
                                                                        {
10170 fschmid 354
                                                                                buffer[ii] = 0;
12094 jghali 355
                                                                                ++ii;
356
                                                                        }
10170 fschmid 357
                                                                }
358
                                                                if (!rememberedWords.contains(input))
359
                                                                        rememberedWords.insert(input, outs);
360
                                                                if (dia->addToIgnoreList->isChecked())
361
                                                                {
362
                                                                        if (!ignoredWords.contains(found2))
363
                                                                                ignoredWords.insert(found2);
364
                                                                }
365
                                                                if (dia->addToExceptionList->isChecked())
366
                                                                {
367
                                                                        if (!specialWords.contains(found2))
368
                                                                                specialWords.insert(found2, outs);
369
                                                                }
370
                                                                it->itemText.hyphenateWord(firstC, found.length(), buffer);
371
                                                        }
372
                                                        else
373
                                                        {
374
                                                                free(buffer);
375
                                                                buffer = NULL;
376
                                                                prefs->set("Xposition", dia->xpos);
377
                                                                prefs->set("Yposition", dia->ypos);
378
                                                                delete dia;
379
                                                                break;
380
                                                        }
9769 fschmid 381
                                                        prefs->set("Xposition", dia->xpos);
382
                                                        prefs->set("Yposition", dia->ypos);
383
                                                        delete dia;
10170 fschmid 384
                                                        qApp->changeOverrideCursor(QCursor(Qt::WaitCursor));
9769 fschmid 385
                                                }
164 Franz 386
                                        }
3 paul 387
                                }
164 Franz 388
                        }
3 paul 389
                        free(buffer);
390
                        buffer = NULL;
164 Franz 391
                }
3 paul 392
                if (Ccount == 0)
393
                        Ccount++;
164 Franz 394
        }
9380 fschmid 395
        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
357 Franz 396
        doc->DoDrawing = true;
9769 fschmid 397
        rememberedWords.clear();
3 paul 398
}
2621 fschmid 399
 
400
void Hyphenator::slotDeHyphenate(PageItem* it)
401
{
5721 avox 402
        if (!(it->asTextFrame()) || (it ->itemText.length() == 0))
2621 fschmid 403
                return;
5559 avox 404
 
15522 jghali 405
        if (it->itemText.lengthOfSelection() > 0)
13054 pierre 406
        {
13144 fschmid 407
//              int start = it->itemText.startOfSelection();
13054 pierre 408
                it->itemText.hyphenateWord(it->itemText.startOfSelection(), it->itemText.lengthOfSelection(), NULL);
409
        }
410
        else {
411
                uint a = it->itemText.length();
412
                it->itemText.hyphenateWord(0, a, NULL);
413
        }
9380 fschmid 414
        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
2621 fschmid 415
        doc->DoDrawing = true;
416
}