author | zecke <zecke> | 2002-11-08 18:09:37 (UTC) |
---|---|---|
committer | zecke <zecke> | 2002-11-08 18:09:37 (UTC) |
commit | 028753a6a3857cdcf7476e537de1cd5c471424c4 (patch) (unidiff) | |
tree | 29ea6ac56b0a0310d74096101b37cce6ec9430ef /library | |
parent | 24da3ab5dd821dd552f13fa7b22f5b3c2986eecd (diff) | |
download | opie-028753a6a3857cdcf7476e537de1cd5c471424c4.zip opie-028753a6a3857cdcf7476e537de1cd5c471424c4.tar.gz opie-028753a6a3857cdcf7476e537de1cd5c471424c4.tar.bz2 |
qwsServer belongs to QWS
and not to !QT_NO_COP
-rw-r--r-- | library/global.cpp | 4 |
1 files changed, 2 insertions, 2 deletions
diff --git a/library/global.cpp b/library/global.cpp index d02e711..9b3c51e 100644 --- a/library/global.cpp +++ b/library/global.cpp | |||
@@ -1,369 +1,369 @@ | |||
1 | /********************************************************************** | 1 | /********************************************************************** |
2 | ** Copyright (C) 2000-2002 Trolltech AS. All rights reserved. | 2 | ** Copyright (C) 2000-2002 Trolltech AS. All rights reserved. |
3 | ** | 3 | ** |
4 | ** This file is part of the Qtopia Environment. | 4 | ** This file is part of the Qtopia Environment. |
5 | ** | 5 | ** |
6 | ** This file may be distributed and/or modified under the terms of the | 6 | ** This file may be distributed and/or modified under the terms of the |
7 | ** GNU General Public License version 2 as published by the Free Software | 7 | ** GNU General Public License version 2 as published by the Free Software |
8 | ** Foundation and appearing in the file LICENSE.GPL included in the | 8 | ** Foundation and appearing in the file LICENSE.GPL included in the |
9 | ** packaging of this file. | 9 | ** packaging of this file. |
10 | ** | 10 | ** |
11 | ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE | 11 | ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE |
12 | ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. | 12 | ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. |
13 | ** | 13 | ** |
14 | ** See http://www.trolltech.com/gpl/ for GPL licensing information. | 14 | ** See http://www.trolltech.com/gpl/ for GPL licensing information. |
15 | ** | 15 | ** |
16 | ** Contact info@trolltech.com if any conditions of this licensing are | 16 | ** Contact info@trolltech.com if any conditions of this licensing are |
17 | ** not clear to you. | 17 | ** not clear to you. |
18 | ** | 18 | ** |
19 | **********************************************************************/ | 19 | **********************************************************************/ |
20 | #define QTOPIA_INTERNAL_LANGLIST | 20 | #define QTOPIA_INTERNAL_LANGLIST |
21 | #include <qpe/qpedebug.h> | 21 | #include <qpe/qpedebug.h> |
22 | #include <qpe/global.h> | 22 | #include <qpe/global.h> |
23 | #include <qpe/qdawg.h> | 23 | #include <qpe/qdawg.h> |
24 | #include <qpe/qpeapplication.h> | 24 | #include <qpe/qpeapplication.h> |
25 | #include <qpe/resource.h> | 25 | #include <qpe/resource.h> |
26 | #include <qpe/storage.h> | 26 | #include <qpe/storage.h> |
27 | #include <qpe/applnk.h> | 27 | #include <qpe/applnk.h> |
28 | #include <qpe/qcopenvelope_qws.h> | 28 | #include <qpe/qcopenvelope_qws.h> |
29 | 29 | ||
30 | #include <qfile.h> | 30 | #include <qfile.h> |
31 | #include <qlabel.h> | 31 | #include <qlabel.h> |
32 | #include <qtimer.h> | 32 | #include <qtimer.h> |
33 | #include <qmap.h> | 33 | #include <qmap.h> |
34 | #include <qdict.h> | 34 | #include <qdict.h> |
35 | #include <qdir.h> | 35 | #include <qdir.h> |
36 | #include <qmessagebox.h> | 36 | #include <qmessagebox.h> |
37 | #include <qregexp.h> | 37 | #include <qregexp.h> |
38 | 38 | ||
39 | #include <stdlib.h> | 39 | #include <stdlib.h> |
40 | #include <sys/stat.h> | 40 | #include <sys/stat.h> |
41 | #include <sys/wait.h> | 41 | #include <sys/wait.h> |
42 | #include <sys/types.h> | 42 | #include <sys/types.h> |
43 | #include <fcntl.h> | 43 | #include <fcntl.h> |
44 | #include <unistd.h> | 44 | #include <unistd.h> |
45 | 45 | ||
46 | #include <qwindowsystem_qws.h> // for qwsServer | 46 | #include <qwindowsystem_qws.h> // for qwsServer |
47 | #include <qdatetime.h> | 47 | #include <qdatetime.h> |
48 | 48 | ||
49 | #include <qfile.h> | 49 | #include <qfile.h> |
50 | 50 | ||
51 | namespace { | 51 | namespace { |
52 | // checks if the storage should be searched | 52 | // checks if the storage should be searched |
53 | bool checkStorage(const QString &path ){ // this is a small Config replacement cause config is too limited -zecke | 53 | bool checkStorage(const QString &path ){ // this is a small Config replacement cause config is too limited -zecke |
54 | QFile file(path ); | 54 | QFile file(path ); |
55 | if(!file.open(IO_ReadOnly ) ) | 55 | if(!file.open(IO_ReadOnly ) ) |
56 | return true; | 56 | return true; |
57 | 57 | ||
58 | QByteArray array = file.readAll(); | 58 | QByteArray array = file.readAll(); |
59 | QStringList list = QStringList::split('\n', QString( array ) ); | 59 | QStringList list = QStringList::split('\n', QString( array ) ); |
60 | for(QStringList::Iterator it = list.begin(); it != list.end(); ++it ){ | 60 | for(QStringList::Iterator it = list.begin(); it != list.end(); ++it ){ |
61 | if( (*it).startsWith("autocheck = 0" ) ){ | 61 | if( (*it).startsWith("autocheck = 0" ) ){ |
62 | return false; | 62 | return false; |
63 | }else if( (*it).startsWith("autocheck = 1" ) ){ | 63 | }else if( (*it).startsWith("autocheck = 1" ) ){ |
64 | return true; | 64 | return true; |
65 | } | 65 | } |
66 | } | 66 | } |
67 | return true; | 67 | return true; |
68 | } | 68 | } |
69 | } | 69 | } |
70 | 70 | ||
71 | //#include "quickexec_p.h" | 71 | //#include "quickexec_p.h" |
72 | 72 | ||
73 | class Emitter : public QObject { | 73 | class Emitter : public QObject { |
74 | Q_OBJECT | 74 | Q_OBJECT |
75 | public: | 75 | public: |
76 | Emitter( QWidget* receiver, const QString& document ) | 76 | Emitter( QWidget* receiver, const QString& document ) |
77 | { | 77 | { |
78 | connect(this, SIGNAL(setDocument(const QString&)), | 78 | connect(this, SIGNAL(setDocument(const QString&)), |
79 | receiver, SLOT(setDocument(const QString&))); | 79 | receiver, SLOT(setDocument(const QString&))); |
80 | emit setDocument(document); | 80 | emit setDocument(document); |
81 | disconnect(this, SIGNAL(setDocument(const QString&)), | 81 | disconnect(this, SIGNAL(setDocument(const QString&)), |
82 | receiver, SLOT(setDocument(const QString&))); | 82 | receiver, SLOT(setDocument(const QString&))); |
83 | } | 83 | } |
84 | 84 | ||
85 | signals: | 85 | signals: |
86 | void setDocument(const QString&); | 86 | void setDocument(const QString&); |
87 | }; | 87 | }; |
88 | 88 | ||
89 | 89 | ||
90 | class StartingAppList : public QObject { | 90 | class StartingAppList : public QObject { |
91 | Q_OBJECT | 91 | Q_OBJECT |
92 | public: | 92 | public: |
93 | static void add( const QString& name ); | 93 | static void add( const QString& name ); |
94 | static bool isStarting( const QString name ); | 94 | static bool isStarting( const QString name ); |
95 | private slots: | 95 | private slots: |
96 | void handleNewChannel( const QString &); | 96 | void handleNewChannel( const QString &); |
97 | private: | 97 | private: |
98 | StartingAppList( QObject *parent=0, const char* name=0 ) ; | 98 | StartingAppList( QObject *parent=0, const char* name=0 ) ; |
99 | 99 | ||
100 | QDict<QTime> dict; | 100 | QDict<QTime> dict; |
101 | static StartingAppList *appl; | 101 | static StartingAppList *appl; |
102 | }; | 102 | }; |
103 | 103 | ||
104 | StartingAppList* StartingAppList::appl = 0; | 104 | StartingAppList* StartingAppList::appl = 0; |
105 | 105 | ||
106 | StartingAppList::StartingAppList( QObject *parent, const char* name ) | 106 | StartingAppList::StartingAppList( QObject *parent, const char* name ) |
107 | :QObject( parent, name ) | 107 | :QObject( parent, name ) |
108 | { | 108 | { |
109 | #if QT_VERSION >= 232 && !defined(QT_NO_COP) | 109 | #if QT_VERSION >= 232 && defined(QWS) |
110 | connect( qwsServer, SIGNAL( newChannel(const QString&)), | 110 | connect( qwsServer, SIGNAL( newChannel(const QString&)), |
111 | this, SLOT( handleNewChannel(const QString&)) ); | 111 | this, SLOT( handleNewChannel(const QString&)) ); |
112 | #endif | ||
112 | dict.setAutoDelete( TRUE ); | 113 | dict.setAutoDelete( TRUE ); |
113 | #endif | ||
114 | } | 114 | } |
115 | 115 | ||
116 | void StartingAppList::add( const QString& name ) | 116 | void StartingAppList::add( const QString& name ) |
117 | { | 117 | { |
118 | #if QT_VERSION >= 232 && !defined(QT_NO_COP) | 118 | #if QT_VERSION >= 232 && !defined(QT_NO_COP) |
119 | if ( !appl ) | 119 | if ( !appl ) |
120 | appl = new StartingAppList; | 120 | appl = new StartingAppList; |
121 | QTime *t = new QTime; | 121 | QTime *t = new QTime; |
122 | t->start(); | 122 | t->start(); |
123 | appl->dict.insert( "QPE/Application/" + name, t ); | 123 | appl->dict.insert( "QPE/Application/" + name, t ); |
124 | #endif | 124 | #endif |
125 | } | 125 | } |
126 | 126 | ||
127 | bool StartingAppList::isStarting( const QString name ) | 127 | bool StartingAppList::isStarting( const QString name ) |
128 | { | 128 | { |
129 | #if QT_VERSION >= 232 && !defined(QT_NO_COP) | 129 | #if QT_VERSION >= 232 && !defined(QT_NO_COP) |
130 | if ( appl ) { | 130 | if ( appl ) { |
131 | QTime *t = appl->dict.find( "QPE/Application/" + name ); | 131 | QTime *t = appl->dict.find( "QPE/Application/" + name ); |
132 | if ( !t ) | 132 | if ( !t ) |
133 | return FALSE; | 133 | return FALSE; |
134 | if ( t->elapsed() > 10000 ) { | 134 | if ( t->elapsed() > 10000 ) { |
135 | // timeout in case of crash or something | 135 | // timeout in case of crash or something |
136 | appl->dict.remove( "QPE/Application/" + name ); | 136 | appl->dict.remove( "QPE/Application/" + name ); |
137 | return FALSE; | 137 | return FALSE; |
138 | } | 138 | } |
139 | return TRUE; | 139 | return TRUE; |
140 | } | 140 | } |
141 | #endif | 141 | #endif |
142 | return FALSE; | 142 | return FALSE; |
143 | } | 143 | } |
144 | 144 | ||
145 | void StartingAppList::handleNewChannel( const QString & name ) | 145 | void StartingAppList::handleNewChannel( const QString & name ) |
146 | { | 146 | { |
147 | #if QT_VERSION >= 232 && !defined(QT_NO_COP) | 147 | #if QT_VERSION >= 232 && !defined(QT_NO_COP) |
148 | dict.remove( name ); | 148 | dict.remove( name ); |
149 | #endif | 149 | #endif |
150 | } | 150 | } |
151 | 151 | ||
152 | static bool docDirCreated = FALSE; | 152 | static bool docDirCreated = FALSE; |
153 | static QDawg* fixed_dawg = 0; | 153 | static QDawg* fixed_dawg = 0; |
154 | static QDict<QDawg> *named_dawg = 0; | 154 | static QDict<QDawg> *named_dawg = 0; |
155 | 155 | ||
156 | static QString qpeDir() | 156 | static QString qpeDir() |
157 | { | 157 | { |
158 | QString dir = getenv("OPIEDIR"); | 158 | QString dir = getenv("OPIEDIR"); |
159 | if ( dir.isEmpty() ) dir = ".."; | 159 | if ( dir.isEmpty() ) dir = ".."; |
160 | return dir; | 160 | return dir; |
161 | } | 161 | } |
162 | 162 | ||
163 | static QString dictDir() | 163 | static QString dictDir() |
164 | { | 164 | { |
165 | return qpeDir() + "/etc/dict"; | 165 | return qpeDir() + "/etc/dict"; |
166 | } | 166 | } |
167 | 167 | ||
168 | /*! | 168 | /*! |
169 | \class Global global.h | 169 | \class Global global.h |
170 | \brief The Global class provides application-wide global functions. | 170 | \brief The Global class provides application-wide global functions. |
171 | 171 | ||
172 | The Global functions are grouped as follows: | 172 | The Global functions are grouped as follows: |
173 | \tableofcontents | 173 | \tableofcontents |
174 | 174 | ||
175 | \section1 User Interface | 175 | \section1 User Interface |
176 | 176 | ||
177 | The statusMessage() function provides short-duration messages to the | 177 | The statusMessage() function provides short-duration messages to the |
178 | user. The showInputMethod() function shows the current input method, | 178 | user. The showInputMethod() function shows the current input method, |
179 | and hideInputMethod() hides the input method. | 179 | and hideInputMethod() hides the input method. |
180 | 180 | ||
181 | \section1 Document related | 181 | \section1 Document related |
182 | 182 | ||
183 | The findDocuments() function creates a set of \link doclnk.html | 183 | The findDocuments() function creates a set of \link doclnk.html |
184 | DocLnk\endlink objects in a particular folder. | 184 | DocLnk\endlink objects in a particular folder. |
185 | 185 | ||
186 | \section1 Filesystem related | 186 | \section1 Filesystem related |
187 | 187 | ||
188 | Global provides an applicationFileName() function that returns the | 188 | Global provides an applicationFileName() function that returns the |
189 | full path of an application-specific file. | 189 | full path of an application-specific file. |
190 | 190 | ||
191 | The execute() function runs an application. | 191 | The execute() function runs an application. |
192 | 192 | ||
193 | \section1 Word list related | 193 | \section1 Word list related |
194 | 194 | ||
195 | A list of words relevant to the current locale is maintained by the | 195 | A list of words relevant to the current locale is maintained by the |
196 | system. The list is held in a \link qdawg.html DAWG\endlink | 196 | system. The list is held in a \link qdawg.html DAWG\endlink |
197 | (implemented by the QDawg class). This list is used, for example, by | 197 | (implemented by the QDawg class). This list is used, for example, by |
198 | the pickboard input method. | 198 | the pickboard input method. |
199 | 199 | ||
200 | The global QDawg is returned by fixedDawg(); this cannot be updated. | 200 | The global QDawg is returned by fixedDawg(); this cannot be updated. |
201 | An updatable copy of the global QDawg is returned by addedDawg(). | 201 | An updatable copy of the global QDawg is returned by addedDawg(). |
202 | Applications may have their own word lists stored in \l{QDawg}s | 202 | Applications may have their own word lists stored in \l{QDawg}s |
203 | which are returned by dawg(). Use addWords() to add words to the | 203 | which are returned by dawg(). Use addWords() to add words to the |
204 | updateable copy of the global QDawg or to named application | 204 | updateable copy of the global QDawg or to named application |
205 | \l{QDawg}s. | 205 | \l{QDawg}s. |
206 | 206 | ||
207 | \section1 Quoting | 207 | \section1 Quoting |
208 | 208 | ||
209 | The shellQuote() function quotes a string suitable for passing to a | 209 | The shellQuote() function quotes a string suitable for passing to a |
210 | shell. The stringQuote() function backslash escapes '\' and '"' | 210 | shell. The stringQuote() function backslash escapes '\' and '"' |
211 | characters. | 211 | characters. |
212 | 212 | ||
213 | \section1 Hardware | 213 | \section1 Hardware |
214 | 214 | ||
215 | The writeHWClock() function sets the hardware clock to the system | 215 | The writeHWClock() function sets the hardware clock to the system |
216 | clock's date and time. | 216 | clock's date and time. |
217 | 217 | ||
218 | \ingroup qtopiaemb | 218 | \ingroup qtopiaemb |
219 | */ | 219 | */ |
220 | 220 | ||
221 | /*! | 221 | /*! |
222 | \internal | 222 | \internal |
223 | */ | 223 | */ |
224 | Global::Global() | 224 | Global::Global() |
225 | { | 225 | { |
226 | } | 226 | } |
227 | 227 | ||
228 | /*! | 228 | /*! |
229 | Returns the unchangeable QDawg that contains general | 229 | Returns the unchangeable QDawg that contains general |
230 | words for the current locale. | 230 | words for the current locale. |
231 | 231 | ||
232 | \sa addedDawg() | 232 | \sa addedDawg() |
233 | */ | 233 | */ |
234 | const QDawg& Global::fixedDawg() | 234 | const QDawg& Global::fixedDawg() |
235 | { | 235 | { |
236 | if ( !fixed_dawg ) { | 236 | if ( !fixed_dawg ) { |
237 | if ( !docDirCreated ) | 237 | if ( !docDirCreated ) |
238 | createDocDir(); | 238 | createDocDir(); |
239 | 239 | ||
240 | fixed_dawg = new QDawg; | 240 | fixed_dawg = new QDawg; |
241 | QString dawgfilename = dictDir() + "/dawg"; | 241 | QString dawgfilename = dictDir() + "/dawg"; |
242 | QString words_lang; | 242 | QString words_lang; |
243 | QStringList langs = Global::languageList(); | 243 | QStringList langs = Global::languageList(); |
244 | for (QStringList::ConstIterator it = langs.begin(); it!=langs.end(); ++it) { | 244 | for (QStringList::ConstIterator it = langs.begin(); it!=langs.end(); ++it) { |
245 | QString lang = *it; | 245 | QString lang = *it; |
246 | words_lang = dictDir() + "/words." + lang; | 246 | words_lang = dictDir() + "/words." + lang; |
247 | QString dawgfilename_lang = dawgfilename + "." + lang; | 247 | QString dawgfilename_lang = dawgfilename + "." + lang; |
248 | if ( QFile::exists(dawgfilename_lang) || | 248 | if ( QFile::exists(dawgfilename_lang) || |
249 | QFile::exists(words_lang) ) { | 249 | QFile::exists(words_lang) ) { |
250 | dawgfilename = dawgfilename_lang; | 250 | dawgfilename = dawgfilename_lang; |
251 | break; | 251 | break; |
252 | } | 252 | } |
253 | } | 253 | } |
254 | QFile dawgfile(dawgfilename); | 254 | QFile dawgfile(dawgfilename); |
255 | 255 | ||
256 | if ( !dawgfile.exists() ) { | 256 | if ( !dawgfile.exists() ) { |
257 | QString fn = dictDir() + "/words"; | 257 | QString fn = dictDir() + "/words"; |
258 | if ( QFile::exists(words_lang) ) | 258 | if ( QFile::exists(words_lang) ) |
259 | fn = words_lang; | 259 | fn = words_lang; |
260 | QFile in(fn); | 260 | QFile in(fn); |
261 | if ( in.open(IO_ReadOnly) ) { | 261 | if ( in.open(IO_ReadOnly) ) { |
262 | fixed_dawg->createFromWords(&in); | 262 | fixed_dawg->createFromWords(&in); |
263 | dawgfile.open(IO_WriteOnly); | 263 | dawgfile.open(IO_WriteOnly); |
264 | fixed_dawg->write(&dawgfile); | 264 | fixed_dawg->write(&dawgfile); |
265 | dawgfile.close(); | 265 | dawgfile.close(); |
266 | } | 266 | } |
267 | } else { | 267 | } else { |
268 | fixed_dawg->readFile(dawgfilename); | 268 | fixed_dawg->readFile(dawgfilename); |
269 | } | 269 | } |
270 | } | 270 | } |
271 | 271 | ||
272 | return *fixed_dawg; | 272 | return *fixed_dawg; |
273 | } | 273 | } |
274 | 274 | ||
275 | /*! | 275 | /*! |
276 | Returns the changeable QDawg that contains general | 276 | Returns the changeable QDawg that contains general |
277 | words for the current locale. | 277 | words for the current locale. |
278 | 278 | ||
279 | \sa fixedDawg() | 279 | \sa fixedDawg() |
280 | */ | 280 | */ |
281 | const QDawg& Global::addedDawg() | 281 | const QDawg& Global::addedDawg() |
282 | { | 282 | { |
283 | return dawg("local"); | 283 | return dawg("local"); |
284 | } | 284 | } |
285 | 285 | ||
286 | /*! | 286 | /*! |
287 | Returns the QDawg with the given \a name. | 287 | Returns the QDawg with the given \a name. |
288 | This is an application-specific word list. | 288 | This is an application-specific word list. |
289 | 289 | ||
290 | \a name should not contain "/". | 290 | \a name should not contain "/". |
291 | */ | 291 | */ |
292 | const QDawg& Global::dawg(const QString& name) | 292 | const QDawg& Global::dawg(const QString& name) |
293 | { | 293 | { |
294 | createDocDir(); | 294 | createDocDir(); |
295 | if ( !named_dawg ) | 295 | if ( !named_dawg ) |
296 | named_dawg = new QDict<QDawg>; | 296 | named_dawg = new QDict<QDawg>; |
297 | QDawg* r = named_dawg->find(name); | 297 | QDawg* r = named_dawg->find(name); |
298 | if ( !r ) { | 298 | if ( !r ) { |
299 | r = new QDawg; | 299 | r = new QDawg; |
300 | named_dawg->insert(name,r); | 300 | named_dawg->insert(name,r); |
301 | QString dawgfilename = applicationFileName("Dictionary", name ) + ".dawg"; | 301 | QString dawgfilename = applicationFileName("Dictionary", name ) + ".dawg"; |
302 | QFile dawgfile(dawgfilename); | 302 | QFile dawgfile(dawgfilename); |
303 | if ( dawgfile.open(IO_ReadOnly) ) | 303 | if ( dawgfile.open(IO_ReadOnly) ) |
304 | r->readFile(dawgfilename); | 304 | r->readFile(dawgfilename); |
305 | } | 305 | } |
306 | return *r; | 306 | return *r; |
307 | } | 307 | } |
308 | 308 | ||
309 | /*! | 309 | /*! |
310 | \overload | 310 | \overload |
311 | Adds \a wordlist to the addedDawg(). | 311 | Adds \a wordlist to the addedDawg(). |
312 | 312 | ||
313 | Note that the addition of words persists between program executions | 313 | Note that the addition of words persists between program executions |
314 | (they are saved in the dictionary files), so you should confirm the | 314 | (they are saved in the dictionary files), so you should confirm the |
315 | words with the user before adding them. | 315 | words with the user before adding them. |
316 | */ | 316 | */ |
317 | void Global::addWords(const QStringList& wordlist) | 317 | void Global::addWords(const QStringList& wordlist) |
318 | { | 318 | { |
319 | addWords("local",wordlist); | 319 | addWords("local",wordlist); |
320 | } | 320 | } |
321 | 321 | ||
322 | /*! | 322 | /*! |
323 | \overload | 323 | \overload |
324 | Adds \a wordlist to the addedDawg(). | 324 | Adds \a wordlist to the addedDawg(). |
325 | 325 | ||
326 | Note that the addition of words persists between program executions | 326 | Note that the addition of words persists between program executions |
327 | (they are saved in the dictionary files), so you should confirm the | 327 | (they are saved in the dictionary files), so you should confirm the |
328 | words with the user before adding them. | 328 | words with the user before adding them. |
329 | */ | 329 | */ |
330 | void Global::addWords(const QString& dictname, const QStringList& wordlist) | 330 | void Global::addWords(const QString& dictname, const QStringList& wordlist) |
331 | { | 331 | { |
332 | QDawg& d = (QDawg&)dawg(dictname); | 332 | QDawg& d = (QDawg&)dawg(dictname); |
333 | QStringList all = d.allWords() + wordlist; | 333 | QStringList all = d.allWords() + wordlist; |
334 | d.createFromWords(all); | 334 | d.createFromWords(all); |
335 | 335 | ||
336 | QString dawgfilename = applicationFileName("Dictionary", dictname) + ".dawg"; | 336 | QString dawgfilename = applicationFileName("Dictionary", dictname) + ".dawg"; |
337 | QFile dawgfile(dawgfilename); | 337 | QFile dawgfile(dawgfilename); |
338 | if ( dawgfile.open(IO_WriteOnly) ) { | 338 | if ( dawgfile.open(IO_WriteOnly) ) { |
339 | d.write(&dawgfile); | 339 | d.write(&dawgfile); |
340 | dawgfile.close(); | 340 | dawgfile.close(); |
341 | } | 341 | } |
342 | 342 | ||
343 | // #### Re-read the dawg here if we use mmap(). | 343 | // #### Re-read the dawg here if we use mmap(). |
344 | 344 | ||
345 | // #### Signal other processes to re-read. | 345 | // #### Signal other processes to re-read. |
346 | } | 346 | } |
347 | 347 | ||
348 | 348 | ||
349 | /*! | 349 | /*! |
350 | Returns the full path for the application called \a appname, with the | 350 | Returns the full path for the application called \a appname, with the |
351 | given \a filename. Returns QString::null if there was a problem creating | 351 | given \a filename. Returns QString::null if there was a problem creating |
352 | the directory tree for \a appname. | 352 | the directory tree for \a appname. |
353 | If \a filename contains "/", it is the caller's responsibility to | 353 | If \a filename contains "/", it is the caller's responsibility to |
354 | ensure that those directories exist. | 354 | ensure that those directories exist. |
355 | */ | 355 | */ |
356 | QString Global::applicationFileName(const QString& appname, const QString& filename) | 356 | QString Global::applicationFileName(const QString& appname, const QString& filename) |
357 | { | 357 | { |
358 | QDir d; | 358 | QDir d; |
359 | QString r = getenv("HOME"); | 359 | QString r = getenv("HOME"); |
360 | r += "/Applications/"; | 360 | r += "/Applications/"; |
361 | if ( !QFile::exists( r ) ) | 361 | if ( !QFile::exists( r ) ) |
362 | if ( d.mkdir(r) == false ) | 362 | if ( d.mkdir(r) == false ) |
363 | return QString::null; | 363 | return QString::null; |
364 | r += appname; | 364 | r += appname; |
365 | if ( !QFile::exists( r ) ) | 365 | if ( !QFile::exists( r ) ) |
366 | if ( d.mkdir(r) == false ) | 366 | if ( d.mkdir(r) == false ) |
367 | return QString::null; | 367 | return QString::null; |
368 | r += "/"; r += filename; | 368 | r += "/"; r += filename; |
369 | return r; | 369 | return r; |