← Back to branch summary

~neon/kmouth/master

« back to all changes in this revision

Viewing changes to wordcompletion/wordlist.cpp

  • Committer: Gunnar Schmidt
  • Date: 2003-08-19 21:50:01 UTC
  • Revision ID: git-v1:929e222a2dd1f8cd34dc8caec29e7f6a573bc59b
Made the word completion configurable

svn path=/trunk/kdeaccessibility/kmouth/; revision=243664

Show diffs side-by-side

added added

removed removed

Lines of Context:
wordcompletion/wordlist.cpp
18
18
// $Id$
19
19
 
20
20
#include <qregexp.h>
 
21
#include <qdir.h>
21
22
#include "wordlist.h"
22
23
 
23
24
#include <qapplication.h>
27
28
#include <klocale.h>
28
29
 
29
30
namespace WordList {
 
31
void addWords (WordMap &map, QString line);
30
32
 
31
33
XMLParser::XMLParser() {
32
34
}
60
62
                                     const QXmlAttributes &)
61
63
{
62
64
   if (!text.isNull() && !text.isEmpty()) {
63
 
      list += QStringList::split(QRegExp("\\W"), text);
 
65
      addWords (list, text);
64
66
      text = QString::null;
65
67
   }
66
68
   return true;
73
75
 
74
76
bool XMLParser::ignorableWhitespace (const QString &) {
75
77
   if (!text.isNull() && !text.isEmpty()) {
76
 
      list += QStringList::split(QRegExp("\\W"), text);
 
78
      addWords (list, text);
77
79
      text = QString::null;
78
80
   }
79
81
   return true;
83
85
                                   const QString &)
84
86
{
85
87
   if (!text.isNull() && !text.isEmpty()) {
86
 
      list += QStringList::split(QRegExp("\\W"), text);
 
88
      addWords (list, text);
87
89
      text = QString::null;
88
90
   }
89
91
   return true;
91
93
 
92
94
bool XMLParser::endDocument() {
93
95
   if (!text.isNull() && !text.isEmpty()) {
94
 
      list += QStringList::split(QRegExp("\\W"), text);
 
96
      addWords (list, text);
95
97
      text = QString::null;
96
98
   }
97
99
   return true;
98
100
}
99
101
 
100
 
QStringList XMLParser::getList() {
 
102
WordMap XMLParser::getList() {
101
103
   return list;
102
104
}
103
105
 
 
106
/***************************************************************************/
 
107
 
 
108
KProgressDialog *progressDialog() {
 
109
   KProgressDialog *pdlg = new KProgressDialog(0, "progressDialog", i18n("Creating word list"), i18n("Parsing the KDE documentation..."), false);
 
110
   pdlg->setAllowCancel (false);
 
111
   pdlg->showCancelButton (false);
 
112
   pdlg->setAutoReset(false);
 
113
   pdlg->setAutoClose(false);
 
114
   pdlg->progressBar()->setTotalSteps(100);
 
115
   pdlg->progressBar()->setProgress(0);
 
116
   return pdlg;
 
117
}
 
118
 
 
119
bool saveWordList (WordMap map, QString filename) {
 
120
   QFile file(filename);
 
121
   if(!file.open(IO_WriteOnly))
 
122
      return false;
 
123
 
 
124
   QTextStream stream(&file);
 
125
   stream.setEncoding (QTextStream::UnicodeUTF8);
 
126
 
 
127
   stream << "WPDictFile\n";
 
128
   WordMap::ConstIterator it;
 
129
   for (it = map.begin(); it != map.end(); ++it)
 
130
      stream << it.key() << "\t" << it.data() << "\t2\n";
 
131
   file.close();
 
132
   return true;
 
133
}
 
134
 
 
135
/***************************************************************************/
 
136
 
 
137
void addWords (WordMap &map, QString line) {
 
138
   QStringList words = QStringList::split(QRegExp("\\W"), line);
 
139
   
 
140
   QStringList::ConstIterator it;
 
141
   for (it = words.begin(); it != words.end(); ++it) {
 
142
      if (!(*it).contains(QRegExp("\\d|_"))) {
 
143
         QString key = (*it).lower();
 
144
         if (map.contains(key))
 
145
            map[key] += 1;
 
146
         else
 
147
            map[key] = 1;
 
148
      }
 
149
   }
 
150
}
 
151
 
 
152
void addWords (WordMap &map, WordMap add) {
 
153
   WordList::WordMap::ConstIterator it;
 
154
   for (it = add.begin(); it != add.end(); ++it)
 
155
      if (map.contains(it.key()))
 
156
         map[it.key()] += it.data();
 
157
      else
 
158
         map[it.key()] = it.data();
 
159
}
 
160
 
 
161
void addWordsFromFile (WordMap &map, QString filename, QTextStream::Encoding encoding, QTextCodec *codec) {
 
162
   QFile xmlfile(filename);
 
163
   QXmlInputSource source (&xmlfile);
 
164
   XMLParser parser;
 
165
   QXmlSimpleReader reader;
 
166
   reader.setFeature ("http://trolltech.com/xml/features/report-start-end-entity", true);
 
167
   reader.setContentHandler (&parser);
 
168
   
 
169
   WordMap words;
 
170
   if (reader.parse(source)) // try to load the file as an xml-file
 
171
      addWords(map, parser.getList());
 
172
   else {
 
173
      QFile wpdfile(filename);
 
174
      if (wpdfile.open(IO_ReadOnly)) {
 
175
         QTextStream stream(&wpdfile);
 
176
         stream.setEncoding (QTextStream::UnicodeUTF8);
 
177
 
 
178
         if (!stream.atEnd()) {
 
179
            QString s = stream.readLine();
 
180
            if (s == "WPDictFile") { // Contains the file a weighted word list?
 
181
               // We can assume that weighted word lists are always UTF8 coded.
 
182
               while (!stream.atEnd()) {
 
183
                  QString s = stream.readLine();
 
184
                  if (!(s.isNull() || s.isEmpty())) {
 
185
                     QStringList list = QStringList::split("\t", s);
 
186
                     bool ok;
 
187
                     int weight = list[1].toInt(&ok);
 
188
                     if (ok && (weight > 0)) {
 
189
                        if (map.contains(list[0]))
 
190
                           map[list[0]] += weight;
 
191
                        else
 
192
                           map[list[0]] = weight;
 
193
                     }
 
194
                  }
 
195
               }
 
196
            }
 
197
            else { // Count the words in an ordinary text file
 
198
               QFile file(filename);
 
199
               if (file.open(IO_ReadOnly)) {
 
200
                  QTextStream stream(&file);
 
201
                  if (codec != 0)
 
202
                     stream.setCodec (codec);
 
203
                  else
 
204
                     stream.setEncoding (encoding);
 
205
                  while (!stream.atEnd())
 
206
                     addWords (map, stream.readLine());
 
207
               }
 
208
            }
 
209
         }
 
210
      }
 
211
   }
 
212
}
 
213
 
 
214
}
 
215
#include <kdebug.h>
 
216
namespace WordList {
 
217
 
 
218
WordMap parseFiles (QStringList files, QTextStream::Encoding encoding, QTextCodec *codec, KProgressDialog *pdlg) {
 
219
   int progress = 0;
 
220
   int steps = files.count();
 
221
   int percent = 0;
 
222
   
 
223
   WordMap map;
 
224
   QStringList::ConstIterator it;
 
225
   for (progress = 1, it = files.begin(); it != files.end(); ++progress, ++it) {
 
226
      addWordsFromFile (map, *it, encoding, codec);
 
227
 
 
228
      if (steps != 0 && progress*100/steps > percent) {
 
229
         percent = progress*100/steps;
 
230
         pdlg->progressBar()->setProgress(percent);
 
231
         qApp->processEvents (20);
 
232
      }
 
233
   }
 
234
   return map;
 
235
}
 
236
 
 
237
WordMap mergeFiles  (QMap<QString,int> files, KProgressDialog *pdlg) {
 
238
   pdlg->setLabel (i18n("Merging dictionaries..."));
 
239
   pdlg->show();
 
240
   qApp->processEvents (20);
 
241
   
 
242
   int progress = 0;
 
243
   int steps = files.count();
 
244
   int percent = 0;
 
245
   float totalWeight = 0;
 
246
   long long maxWeight = 0;
 
247
   
 
248
   QMap<QString,float> map;
 
249
   QMap<QString,int>::ConstIterator it;
 
250
   for (progress = 1, it = files.begin(); it != files.end(); ++progress, ++it) {
 
251
      WordMap fileMap;
 
252
      addWordsFromFile (fileMap, it.key(), QTextStream::UnicodeUTF8, 0);
 
253
 
 
254
      long long weight = 0;
 
255
      WordMap::ConstIterator iter;
 
256
      for (iter = fileMap.begin(); iter != fileMap.end(); ++iter)
 
257
         weight += iter.data();
 
258
      float factor = 1.0 * it.data() / weight;
 
259
      totalWeight += it.data();
 
260
      if (weight > maxWeight)
 
261
         maxWeight = weight;
 
262
      
 
263
      for (iter = fileMap.begin(); iter != fileMap.end(); ++iter)
 
264
         if (map.contains(iter.key()))
 
265
            map[iter.key()] += iter.data() * factor;
 
266
         else
 
267
            map[iter.key()] = iter.data() * factor;
 
268
 
 
269
      if (steps != 0 && progress*100/steps > percent) {
 
270
         percent = progress*100/steps;
 
271
         pdlg->progressBar()->setProgress(percent);
 
272
         qApp->processEvents (20);
 
273
      }
 
274
   }
 
275
   
 
276
   float factor;
 
277
   if (1.0 * maxWeight * totalWeight > 1000000000)
 
278
      factor = 1000000000 / totalWeight;
 
279
   else
 
280
      factor = 1.0 * maxWeight;
 
281
   
 
282
   WordMap resultMap;
 
283
   QMap<QString,float>::ConstIterator iter;
 
284
   for (iter = map.begin(); iter != map.end(); ++iter)
 
285
      resultMap[iter.key()] = (int)(factor * iter.data() + 0.5);
 
286
   
 
287
   return resultMap;
 
288
}
 
289
 
 
290
WordMap parseKDEDoc (QString language, KProgressDialog *pdlg) {
 
291
   pdlg->setLabel (i18n("Parsing the KDE documentation..."));
 
292
   pdlg->show();
 
293
   qApp->processEvents (20);
 
294
   
 
295
   QStringList files = KApplication::kApplication()->dirs()->findAllResources ("html", language + "/*.docbook", true, true);
 
296
   if ((files.count() == 0) && (language.length() == 5)) {
 
297
      language = language.left(2);
 
298
      files = KApplication::kApplication()->dirs()->findAllResources ("html", language + "/*.docbook", true, true);
 
299
   }
 
300
 
 
301
   return parseFiles (files, QTextStream::UnicodeUTF8, 0, pdlg);
 
302
}
 
303
 
 
304
WordMap parseFile (QString filename, QTextStream::Encoding encoding, QTextCodec *codec, KProgressDialog *pdlg) {
 
305
   pdlg->setLabel (i18n("Parsing file..."));
 
306
   pdlg->show();
 
307
   qApp->processEvents (20);
 
308
   
 
309
   QStringList files = filename;
 
310
 
 
311
   return parseFiles (files, encoding, codec, pdlg);
 
312
}
 
313
 
 
314
WordMap parseDir (QString directory, QTextStream::Encoding encoding, QTextCodec *codec, KProgressDialog *pdlg) {
 
315
   pdlg->setLabel (i18n("Parsing directory..."));
 
316
   pdlg->show();
 
317
   qApp->processEvents (20);
 
318
   
 
319
   QStringList directories;
 
320
   directories += directory;
 
321
   QStringList files;
 
322
   for (QStringList::Iterator it = directories.begin(); it != directories.end(); it = directories.remove(it)) {
 
323
      QDir dir(*it);
 
324
      const QFileInfoList *entries = dir.entryInfoList ("*", QDir::Dirs | QDir::Files | QDir::NoSymLinks | QDir::Readable);
 
325
      if (entries != 0) {
 
326
         QFileInfoListIterator iter (*entries);
 
327
         while ((iter.current()) != 0) {
 
328
            QString name = iter.current()->fileName();
 
329
            if (name != "." && name != "..") {
 
330
               if (iter.current()->isDir())
 
331
                  directories += iter.current()->filePath ();
 
332
               else
 
333
                  files += iter.current()->filePath ();
 
334
            }
 
335
            ++iter;
 
336
         }
 
337
      }
 
338
   }
 
339
 
 
340
   return parseFiles (files, encoding, codec, pdlg);
 
341
}
104
342
 
105
343
/***************************************************************************/
106
344
 
250
488
   }
251
489
}
252
490
 
253
 
/***************************************************************************/
254
 
 
255
 
void addWordsFromFile (WordMap &map, QString filename) {
256
 
   QFile file(filename);
257
 
   QXmlInputSource source (&file);
258
 
   XMLParser parser;
259
 
   QXmlSimpleReader reader;
260
 
   reader.setFeature ("http://trolltech.com/xml/features/report-start-end-entity", true);
261
 
   reader.setContentHandler (&parser);
262
 
   
263
 
   if (reader.parse(source)) {
264
 
      QStringList words = parser.getList();
265
 
      QStringList::ConstIterator it;
266
 
      for (it = words.begin(); it != words.end(); ++it) {
267
 
         if (!(*it).contains(QRegExp("\\d|_"))) {
268
 
            QString key = (*it).lower();
269
 
            if (map.contains(key))
270
 
               map[key] += 1;
271
 
            else
272
 
               map[key] = 1;
273
 
         }
274
 
      }
275
 
   }
276
 
}
277
 
 
278
 
WordMap checkWordList(WordMap &map, QString dict, QString aff);
279
 
 
280
 
WordMap createWordList (QString language, QString dictionary) {
281
 
   KProgressDialog *pdlg = new KProgressDialog(0, "progressDialog", i18n("Creating word list"), i18n("Parsing the KDE documentation..."), false);
282
 
   pdlg->setAllowCancel (false);
283
 
   pdlg->showCancelButton (false);
284
 
   pdlg->setLabel (i18n("Parsing the KDE documentation..."));
285
 
   pdlg->setAutoReset(false);
286
 
   pdlg->setAutoClose(false);
287
 
   pdlg->progressBar()->setTotalSteps(100);
288
 
   pdlg->progressBar()->setProgress(0);
289
 
   pdlg->show();
290
 
   qApp->processEvents (20);
291
 
   
292
 
   int progress = 0;
293
 
   int steps = 0;
294
 
   int percent = 0;
295
 
         
296
 
   QStringList files = KApplication::kApplication()->dirs()->findAllResources ("html", language + "/*.docbook", true, true);
297
 
   if ((files.count() == 0) && (language.length() == 5)) {
298
 
      language = language.left(2);
299
 
      files = KApplication::kApplication()->dirs()->findAllResources ("html", language + "/*.docbook", true, true);
300
 
   }
301
 
 
302
 
   steps = files.count();
303
 
   
304
 
   WordMap map;
305
 
   QStringList::ConstIterator it;
306
 
   for (progress = 1, it = files.begin(); it != files.end(); ++progress, ++it) {
307
 
      addWordsFromFile (map, *it);
308
 
 
309
 
      if (steps != 0 && progress*100/steps > percent) {
310
 
         percent = progress*100/steps;
311
 
         pdlg->progressBar()->setProgress(percent);
312
 
         qApp->processEvents (20);
313
 
      }
314
 
   }
 
491
WordMap spellCheck  (WordMap map, QString dictionary, KProgressDialog *pdlg) {
315
492
 
316
493
   if (dictionary.endsWith(".dic")) {
317
494
      AffMap prefixes;
320
497
      loadAffFile (dictionary.left(dictionary.length()-4) + ".aff", prefixes, suffixes);
321
498
 
322
499
      pdlg->progressBar()->reset();
 
500
      pdlg->setAllowCancel (false);
 
501
      pdlg->showCancelButton (false);
 
502
      pdlg->setAutoReset(false);
 
503
      pdlg->setAutoClose(false);
323
504
      pdlg->setLabel (i18n("Performing spell check..."));
324
505
      pdlg->progressBar()->setTotalSteps(100);
325
506
      pdlg->progressBar()->setProgress(0);
326
507
      qApp->processEvents (20);
327
 
      progress = 0;
328
 
      steps = 0;
329
 
      percent = 0;
 
508
      int progress = 0;
 
509
      int steps = 0;
 
510
      int percent = 0;
330
511
 
331
512
      QFile dfile(dictionary);
332
513
      if (dfile.open(IO_ReadOnly)) {
359
540
         }
360
541
      }
361
542
 
362
 
      pdlg->close();
363
 
      delete pdlg;
364
543
      return checkedMap;
365
544
   }
366
 
   else {
367
 
      pdlg->close();
368
 
      delete pdlg;
 
545
   else
369
546
      return map;
370
 
   }
371
 
}
372
 
 
373
 
}
 
547
}
 
548
 
 
549
}
 
550
 
 
551
#include "wordlist.moc"