Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
19822 craig 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
*/
7
/***************************************************************************
8
        begin                : Feb 2015
9
        copyright            : (C) 2015 by Craig Bradney
10
        email                : cbradney@scribus.info
11
***************************************************************************/
12
 
13
/***************************************************************************
14
*                                                                         *
15
*   mainWindow program is free software; you can redistribute it and/or modify  *
16
*   it under the terms of the GNU General Public License as published by  *
17
*   the Free Software Foundation; either version 2 of the License, or     *
18
*   (at your option) any later version.                                   *
19
*                                                                         *
20
***************************************************************************/
21
 
22
#include <QComboBox>
23
#include <QDebug>
24
#include <QDomDocument>
19826 craig 25
#include <QFile>
26
#include <QFileInfo>
19822 craig 27
#include <QString>
28
#include <QStringList>
29
#include <QTableWidget>
30
#include <QTextCodec>
31
#include <QTextStream>
32
 
33
#include "downloadmanager/scdlmgr.h"
34
#include "langmgr.h"
35
#include "resourcemanager.h"
36
#include "scpaths.h"
37
#include "scribusapp.h"
38
#include "third_party/zip/scribus_zip.h"
39
#include "util.h"
40
#include "util_file.h"
41
 
42
extern ScribusQApp* ScQApp;
43
 
44
ResourceManager::ResourceManager(QWidget* parent)
45
{
46
        setupUi(this);
47
        downloadButton->setEnabled(false);
48
        downloadProgressBar->setValue(0);
49
        downloadProgressBar->setVisible(false);
50
        languageChange();
51
 
52
        connect(categoryComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(categoryChanged()));
53
        connect(updateAvailableButton, SIGNAL(clicked()), this, SLOT(updateDownloadLists()));
54
        connect(downloadButton, SIGNAL(clicked()), this, SLOT(startDownload()));
55
}
56
 
57
void ResourceManager::languageChange()
58
{
59
#if defined(Q_OS_MAC)
60
        showInFSButton->setText( tr( "Show In Finder" ) );
61
#endif
62
#if defined(Q_OS_WIN32)
63
        showInFSButton->setText( tr( "Show In Explorer" ) );
64
#endif
65
 
66
        resourceCategories.clear();
67
        resourceCategories.insert(RM_FONTS, tr("Fonts"));
68
        resourceCategories.insert(RM_HYPH, tr("Hyphenation Dictionaries"));
69
        resourceCategories.insert(RM_SPELL, tr("Spelling Dictionaries"));
70
        //resourceCategories.insert(RM_TEMPLATES, tr("Templates"));
71
        //resourceCategories.insert(RM_PROFILES, tr("Color Profiles"));
72
 
73
        dataFiles.clear();
74
        dataFiles.insert(RM_FONTS, "scribus_fonts.xml");
75
        dataFiles.insert(RM_HYPH, "scribus_hyph_dicts.xml");
76
        dataFiles.insert(RM_SPELL, "scribus_spell_dicts.xml");
77
        //dataFiles.insert(RM_TEMPLATES, "scribus_templates.xml");
78
        //dataFiles.insert(RM_PROFILES, "scribus_profiles.xml");
79
 
80
        installedTableWidget->clear();
81
        availableTableWidget->clear();
82
        categoryComboBox->clear();
83
        categoryComboBox->setInsertPolicy(QComboBox::InsertAlphabetically);
84
 
85
        QMapIterator<int, QString> i(resourceCategories);
86
        while (i.hasNext())
87
        {
88
                i.next();
89
                categoryComboBox->addItem(i.value(), i.key());
90
        }
91
        categoryChanged();
92
}
93
 
94
void ResourceManager::setFontCategory()
95
{
96
        updateInstalledFonts();
97
        updateAvailableFonts();
98
}
99
 
100
void ResourceManager::setHyphCategory()
101
{
102
        updateInstalledHyph();
103
        updateAvailableHyph();
104
}
105
 
106
void ResourceManager::setSpellCategory()
107
{
108
        updateInstalledSpell();
109
        updateAvailableSpell();
110
}
111
 
112
void ResourceManager::setTemplatesCategory()
113
{
114
        updateInstalledTemplates();
115
        updateAvailableTemplates();
116
}
117
 
118
void ResourceManager::updateInstalledFonts()
119
{
120
        installedTableWidget->clear();
121
        QStringList headers;
122
        headers << tr("Description") << tr("Type") << tr("Installed") << tr("Download");
123
        installedTableWidget->setHorizontalHeaderLabels(headers);
124
        installedTableWidget->resizeColumnsToContents();
125
}
126
 
127
void ResourceManager::updateInstalledHyph()
128
{
129
        bool dictsFound=LanguageManager::instance()->findHyphDictionaries(dictionaryPaths);
130
        if (!dictsFound)
131
                return;
132
        dictionaryMap.clear();
133
        LanguageManager::instance()->findHyphDictionarySets(dictionaryPaths, dictionaryMap);
134
 
135
        installedTableWidget->clear();
136
        installedTableWidget->setRowCount(dictionaryMap.count());
137
        installedTableWidget->setColumnCount(3);
138
        QMapIterator<QString, QString> i(dictionaryMap);
139
        int row=0;
140
        while (i.hasNext())
141
        {
142
                 i.next();
143
                 int column=0;
144
                 //qDebug()<<i.key()<<i.value()<<LanguageManager::instance()->getLangFromAbbrev(i.key(), false);
145
                 QTableWidgetItem *newItem1 = new QTableWidgetItem(LanguageManager::instance()->getLangFromAbbrev(i.key()));
146
                 newItem1->setFlags(newItem1->flags() & ~Qt::ItemIsEditable);
147
                 installedTableWidget->setItem(row, column++, newItem1);
148
                 QTableWidgetItem *newItem2 = new QTableWidgetItem(i.key());
149
                 newItem2->setFlags(newItem1->flags());
150
                 installedTableWidget->setItem(row, column++, newItem2);
151
                 QTableWidgetItem *newItem3 = new QTableWidgetItem(i.value());
152
                 newItem3->setFlags(newItem1->flags());
153
                 newItem3->setToolTip(i.value());
154
                 installedTableWidget->setItem(row, column++, newItem3);
155
                 ++row;
156
        }
157
        QStringList headers;
158
        headers << tr("Language") << tr("Code") << tr("Location");
159
        installedTableWidget->setHorizontalHeaderLabels(headers);
160
        installedTableWidget->resizeColumnsToContents();
161
}
162
 
163
void ResourceManager::updateInstalledSpell()
164
{
165
        bool dictsFound=LanguageManager::instance()->findSpellingDictionaries(dictionaryPaths);
166
        if (!dictsFound)
167
                return;
168
        dictionaryMap.clear();
169
        LanguageManager::instance()->findSpellingDictionarySets(dictionaryPaths, dictionaryMap);
170
 
171
        installedTableWidget->clear();
172
        installedTableWidget->setRowCount(dictionaryMap.count());
173
        installedTableWidget->setColumnCount(3);
174
        QMapIterator<QString, QString> i(dictionaryMap);
175
        int row=0;
176
        while (i.hasNext())
177
        {
178
                 i.next();
179
                 int column=0;
180
                 //qDebug()<<i.key()<<i.value()<<LanguageManager::instance()->getLangFromAbbrev(i.key(), false);
181
                 QTableWidgetItem *newItem1 = new QTableWidgetItem(LanguageManager::instance()->getLangFromAbbrev(i.key()));
182
                 newItem1->setFlags(newItem1->flags() & ~Qt::ItemIsEditable);
183
                 installedTableWidget->setItem(row, column++, newItem1);
184
                 QTableWidgetItem *newItem2 = new QTableWidgetItem(i.key());
185
                 newItem2->setFlags(newItem1->flags());
186
                 installedTableWidget->setItem(row, column++, newItem2);
187
                 QTableWidgetItem *newItem3 = new QTableWidgetItem(i.value());
188
                 newItem3->setFlags(newItem1->flags());
189
                 newItem3->setToolTip(i.value());
190
                 installedTableWidget->setItem(row, column++, newItem3);
191
                 ++row;
192
        }
193
        QStringList headers;
194
        headers << tr("Language") << tr("Code") << tr("Location");
195
        installedTableWidget->setHorizontalHeaderLabels(headers);
196
        installedTableWidget->resizeColumnsToContents();
197
}
198
 
199
void ResourceManager::updateInstalledTemplates()
200
{
201
        installedTableWidget->clear();
202
}
203
 
204
void ResourceManager::updateAvailableFonts()
205
{
206
        QFile dataFile(ScPaths::downloadDir() + dataFiles[RM_FONTS]);
207
        if (!dataFile.exists())
208
                return;
209
        dataFile.open(QIODevice::ReadOnly);
210
        QTextStream ts(&dataFile);
211
        ts.setCodec(QTextCodec::codecForName("UTF-8"));
212
        QString errorMsg;
213
        int eline;
214
        int ecol;
215
        QDomDocument doc( dataFiles[RM_FONTS] );
216
        QString data(ts.readAll());
217
        dataFile.close();
218
        if ( !doc.setContent( data, &errorMsg, &eline, &ecol ))
219
        {
220
//              qDebug()<<errorMsg<<eline<<ecol;
221
                if (data.toLower().contains("404 not found"))
222
                        qDebug()<<"File not found on server";
223
                else
224
                        qDebug()<<"Could not open file"<<dataFile.fileName();
225
                return;
226
        }
227
        fontList.clear();
228
        QDomElement docElem = doc.documentElement();
229
        QDomNode n = docElem.firstChild();
230
        while( !n.isNull() )
231
        {
232
                QDomElement e = n.toElement();
233
                if( !e.isNull() )
234
                {
235
                        if (e.tagName()=="font")
236
                        {
237
                                if (e.hasAttribute("type") && e.hasAttribute("filetype"))
238
                                {
239
                                        struct DownloadItem d;
240
                                        d.desc=e.attribute("description");
241
                                        d.download=false;
242
                                        d.files=e.attribute("files");
243
                                        d.url=e.attribute("URL");
244
                                        d.version=e.attribute("version");
245
                                        d.lang=e.attribute("language");
246
                                        d.license=e.attribute("license");
247
                                        d.filetype=e.attribute("filetype");
19823 craig 248
                                        d.movetofile=e.attribute("movetofilename");
19822 craig 249
                                        d.type=e.attribute("type").toUpper();
250
                                        QUrl url(d.url);
251
                                        if (url.isValid() && !url.isEmpty() && !url.host().isEmpty())
252
                                                fontList.append(d);
253
//                                      else
254
//                                              qDebug()<<"rm : availFonts : invalid URL"<<d.url;
255
                                }
256
                        }
257
                }
258
                n = n.nextSibling();
259
        }
260
        availableTableWidget->clear();
261
        if(fontList.isEmpty())
262
        {
263
                downloadButton->setEnabled(false);
264
                return;
265
        }
266
        availableTableWidget->setRowCount(fontList.count());
267
        availableTableWidget->setColumnCount(4);
268
        int row=0;
269
        foreach(DownloadItem d, fontList)
270
        {
271
                int column=0;
272
                //qDebug()<<d.version<<d.files<<d.url<<d.desc<<d.license;
273
                QTableWidgetItem *newItem1 = new QTableWidgetItem(d.desc);
274
                newItem1->setFlags(newItem1->flags() & ~Qt::ItemIsEditable);
275
                availableTableWidget->setItem(row, column++, newItem1);
276
                QTableWidgetItem *newItem2 = new QTableWidgetItem(d.type);
277
                newItem2->setFlags(newItem1->flags());
278
                availableTableWidget->setItem(row, column++, newItem2);
279
                QTableWidgetItem *newItem3 = new QTableWidgetItem();
280
                newItem3->setCheckState(dictionaryMap.contains(d.lang) ? Qt::Checked : Qt::Unchecked);
281
                newItem3->setFlags(newItem1->flags() & ~Qt::ItemIsUserCheckable);
282
                availableTableWidget->setItem(row, column++, newItem3);
283
                QTableWidgetItem *newItem4 = new QTableWidgetItem();
284
                newItem4->setCheckState(d.download ? Qt::Checked : Qt::Unchecked);
285
                availableTableWidget->setItem(row, column++, newItem4);
286
                ++row;
287
        }
288
        QStringList headers;
289
        headers << tr("Description") << tr("Type") << tr("Installed") << tr("Download");
290
        availableTableWidget->setHorizontalHeaderLabels(headers);
291
        availableTableWidget->resizeColumnsToContents();
292
        downloadButton->setEnabled(true);
293
}
294
 
295
void ResourceManager::updateAvailableHyph()
296
{
297
        QFile dataFile(ScPaths::downloadDir() + dataFiles[RM_HYPH]);
298
        if (!dataFile.exists())
299
                return;
300
        dataFile.open(QIODevice::ReadOnly);
301
        QTextStream ts(&dataFile);
302
        ts.setCodec(QTextCodec::codecForName("UTF-8"));
303
        QString errorMsg;
304
        int eline;
305
        int ecol;
306
        QDomDocument doc( QString(dataFiles[RM_HYPH]).remove(".xml") );
307
        QString data(ts.readAll());
308
        dataFile.close();
309
        if ( !doc.setContent( data, &errorMsg, &eline, &ecol ))
310
        {
311
                if (data.toLower().contains("404 not found"))
312
                        qDebug()<<"File not found on server";
313
                else
314
                        qDebug()<<"Could not open file"<<dataFile.fileName();
315
                return;
316
        }
317
        dictList.clear();
318
        QDomElement docElem = doc.documentElement();
319
        QDomNode n = docElem.firstChild();
320
        while( !n.isNull() )
321
        {
322
                QDomElement e = n.toElement();
323
                if( !e.isNull() )
324
                {
325
                        if (e.tagName()=="dictionary")
326
                        {
327
                                if (e.hasAttribute("type") && e.hasAttribute("filetype"))
328
                                {
329
                                        if (e.attribute("type")=="hyph")
330
                                        {
331
                                                struct DownloadItem d;
332
                                                d.desc=e.attribute("description");
333
                                                d.download=false;
334
                                                d.files=e.attribute("files");
335
                                                d.url=e.attribute("URL");
336
                                                d.version=e.attribute("version");
337
                                                d.lang=e.attribute("language");
338
                                                d.license=e.attribute("license");
339
                                                d.filetype=e.attribute("filetype");
340
                                                d.type=e.attribute("type");
341
                                                QUrl url(d.url);
342
                                                if (url.isValid() && !url.isEmpty() && !url.host().isEmpty())
343
                                                        dictList.append(d);
344
                                                //else
345
                                                //      qDebug()<<"hysettings : availDicts : invalid URL"<<d.url;
346
                                        }
347
                                }
348
                        }
349
                }
350
                n = n.nextSibling();
351
        }
352
        availableTableWidget->clear();
353
        if(dictList.isEmpty())
354
        {
355
                downloadButton->setEnabled(false);
356
                return;
357
        }
358
        availableTableWidget->setRowCount(dictList.count());
359
        availableTableWidget->setColumnCount(4);
360
        int row=0;
361
        foreach(DownloadItem d, dictList)
362
        {
363
                int column=0;
364
                //qDebug()<<d.version<<d.files<<d.url<<d.desc<<d.license;
365
                QTableWidgetItem *newItem1 = new QTableWidgetItem(d.desc);
366
                newItem1->setFlags(newItem1->flags() & ~Qt::ItemIsEditable);
367
                availableTableWidget->setItem(row, column++, newItem1);
368
                QTableWidgetItem *newItem2 = new QTableWidgetItem(d.lang);
369
                newItem2->setFlags(newItem1->flags());
370
                availableTableWidget->setItem(row, column++, newItem2);
371
                QTableWidgetItem *newItem3 = new QTableWidgetItem();
372
                newItem3->setCheckState(dictionaryMap.contains(d.lang) ? Qt::Checked : Qt::Unchecked);
373
                newItem3->setFlags(newItem1->flags() & ~Qt::ItemIsUserCheckable);
374
                availableTableWidget->setItem(row, column++, newItem3);
375
                QTableWidgetItem *newItem4 = new QTableWidgetItem();
376
                newItem4->setCheckState(d.download ? Qt::Checked : Qt::Unchecked);
377
                availableTableWidget->setItem(row, column++, newItem4);
378
                ++row;
379
        }
380
        QStringList headers;
381
        headers << tr("Language") << tr("Code") << tr("Installed") << tr("Download");
382
        availableTableWidget->setHorizontalHeaderLabels(headers);
383
        availableTableWidget->resizeColumnsToContents();
384
        downloadButton->setEnabled(true);
385
}
386
 
387
void ResourceManager::updateAvailableSpell()
388
{
389
        QFile dataFile(ScPaths::downloadDir() + dataFiles[RM_SPELL]);
390
        if (!dataFile.exists())
391
                return;
392
        dataFile.open(QIODevice::ReadOnly);
393
        QTextStream ts(&dataFile);
394
        ts.setCodec(QTextCodec::codecForName("UTF-8"));
395
        QString errorMsg;
396
        int eline;
397
        int ecol;
398
        QDomDocument doc( QString(dataFiles[RM_SPELL]).remove(".xml") );
399
        QString data(ts.readAll());
400
        dataFile.close();
401
        if ( !doc.setContent( data, &errorMsg, &eline, &ecol ))
402
        {
403
                if (data.toLower().contains("404 not found"))
404
                        qDebug()<<"File not found on server";
405
                else
406
                        qDebug()<<"Could not open file"<<dataFile.fileName();
407
                return;
408
        }
409
        dictList.clear();
410
        QDomElement docElem = doc.documentElement();
411
        QDomNode n = docElem.firstChild();
412
        while( !n.isNull() )
413
        {
414
                QDomElement e = n.toElement();
415
                if( !e.isNull() )
416
                {
417
                        if (e.tagName()=="dictionary")
418
                        {
419
                                if (e.hasAttribute("type") && e.hasAttribute("filetype"))
420
                                {
421
                                        if (e.attribute("type")=="spell")
422
                                        {
423
                                                struct DownloadItem d;
424
                                                d.desc=e.attribute("description");
425
                                                d.download=false;
426
                                                d.files=e.attribute("files");
427
                                                d.url=e.attribute("URL");
428
                                                d.version=e.attribute("version");
429
                                                d.lang=e.attribute("language");
430
                                                d.license=e.attribute("license");
431
                                                d.filetype=e.attribute("filetype");
432
                                                d.type=e.attribute("type");
433
                                                QUrl url(d.url);
434
                                                if (url.isValid() && !url.isEmpty() && !url.host().isEmpty())
435
                                                        dictList.append(d);
436
                                                //else
437
                                                //      qDebug()<<"hysettings : availDicts : invalid URL"<<d.url;
438
                                        }
439
                                }
440
                        }
441
                }
442
                n = n.nextSibling();
443
        }
444
        availableTableWidget->clear();
445
        if(dictList.isEmpty())
446
        {
447
                downloadButton->setEnabled(false);
448
                return;
449
        }
450
        availableTableWidget->setRowCount(dictList.count());
451
        availableTableWidget->setColumnCount(4);
452
        int row=0;
453
        foreach(DownloadItem d, dictList)
454
        {
455
                int column=0;
456
                //qDebug()<<d.version<<d.files<<d.url<<d.desc<<d.license;
457
                QTableWidgetItem *newItem1 = new QTableWidgetItem(d.desc);
458
                newItem1->setFlags(newItem1->flags() & ~Qt::ItemIsEditable);
459
                availableTableWidget->setItem(row, column++, newItem1);
460
                QTableWidgetItem *newItem2 = new QTableWidgetItem(d.lang);
461
                newItem2->setFlags(newItem1->flags());
462
                availableTableWidget->setItem(row, column++, newItem2);
463
                QTableWidgetItem *newItem3 = new QTableWidgetItem();
464
                newItem3->setCheckState(dictionaryMap.contains(d.lang) ? Qt::Checked : Qt::Unchecked);
465
                newItem3->setFlags(newItem1->flags() & ~Qt::ItemIsUserCheckable);
466
                availableTableWidget->setItem(row, column++, newItem3);
467
                QTableWidgetItem *newItem4 = new QTableWidgetItem();
468
                newItem4->setCheckState(d.download ? Qt::Checked : Qt::Unchecked);
469
                availableTableWidget->setItem(row, column++, newItem4);
470
                ++row;
471
        }
472
        QStringList headers;
473
        headers << tr("Language") << tr("Code") << tr("Installed") << tr("Download");
474
        availableTableWidget->setHorizontalHeaderLabels(headers);
475
        availableTableWidget->resizeColumnsToContents();
476
        downloadButton->setEnabled(true);
477
}
478
 
479
void ResourceManager::updateAvailableTemplates()
480
{
481
        availableTableWidget->clear();
482
}
483
 
484
void ResourceManager::categoryChanged()
485
{
486
        int category = categoryComboBox->currentData().toInt();
487
        switch (category)
488
        {
489
                case RM_FONTS:
490
                        setFontCategory();
491
                        break;
492
                case RM_HYPH:
493
                        setHyphCategory();
494
                        break;
495
                case RM_SPELL:
496
                        setSpellCategory();
497
                        break;
498
                case RM_TEMPLATES:
499
                        setTemplatesCategory();
500
                        break;
501
        }
502
}
503
 
504
void ResourceManager::updateDownloadLists()
505
{
506
        updateAvailableButton->setEnabled(false);
507
        downloadButton->setEnabled(false);
508
        downloadProgressBar->setValue(0);
509
        downloadProgressBar->setVisible(true);
510
        downloadProgressBar->setRange(0, dataFiles.count());
511
        foreach(QString f, dataFiles)
512
                ScQApp->dlManager()->addURL("http://services.scribus.net/"+f, true, ScPaths::downloadDir(), ScPaths::downloadDir());
513
        connect(ScQApp->dlManager(), SIGNAL(finished()), this, SLOT(downloadListFinished()));
514
        connect(ScQApp->dlManager(), SIGNAL(fileReceived(const QString&)), this, SLOT(updateProgressBar()));
515
        connect(ScQApp->dlManager(), SIGNAL(fileFailed(const QString&)), this, SLOT(updateProgressBar()));
516
        ScQApp->dlManager()->startDownloads();
517
}
518
 
519
void ResourceManager::downloadListFinished()
520
{
521
        disconnect(ScQApp->dlManager(), SIGNAL(finished()), this, SLOT(downloadListFinished()));
522
        disconnect(ScQApp->dlManager(), SIGNAL(fileReceived(const QString&)), this, SLOT(updateProgressBar()));
523
        disconnect(ScQApp->dlManager(), SIGNAL(fileFailed(const QString&)), this, SLOT(updateProgressBar()));
524
 
525
        int category = categoryComboBox->currentData().toInt();
526
        switch (category)
527
        {
528
                case RM_FONTS:
529
                        updateAvailableFonts();
530
                        break;
531
                case RM_HYPH:
532
                        updateAvailableHyph();
533
                        break;
534
                case RM_SPELL:
535
                        updateAvailableSpell();
536
                        break;
537
                case RM_TEMPLATES:
538
                        updateAvailableTemplates();
539
                        break;
540
        }
541
        updateAvailableButton->setEnabled(true);
542
        downloadButton->setEnabled(true);
543
        downloadProgressBar->setValue(0);
544
        downloadProgressBar->setVisible(false);
545
}
546
 
547
void ResourceManager::downloadFilesFinished()
548
{
549
        disconnect(ScQApp->dlManager(), SIGNAL(finished()), this, SLOT(downloadFilesFinished()));
550
        disconnect(ScQApp->dlManager(), SIGNAL(fileReceived(const QString&)), this, SLOT(updateProgressBar()));
551
        disconnect(ScQApp->dlManager(), SIGNAL(fileFailed(const QString&)), this, SLOT(updateProgressBar()));
552
        categoryChanged();
553
        downloadProgressBar->setValue(0);
554
        downloadProgressBar->setVisible(false);
555
//      dlLabel->setVisible(false);
556
        downloadButton->setEnabled(true);
557
 
558
        int category = categoryComboBox->currentData().toInt();
559
        switch (category)
560
        {
561
                case RM_FONTS:
562
                        foreach(DownloadItem d, downloadList)
563
                        {
564
                                //qDebug()<<d.desc<<d.download<<d.files<<d.type;
565
                                if (d.filetype=="zip")
566
                                {
19826 craig 567
                                        QString fn(ScPaths::getUserFontDir(true)+d.files);
19822 craig 568
                                        //qDebug()<<fn;
569
                                        QFile dledFile(fn);
19826 craig 570
                                        QFileInfo fi(dledFile);
19822 craig 571
                                        if (!dledFile.exists())
572
                                                qDebug()<<"File doesnt exist"<<fn;
573
                                        else
574
                                        {
575
                                                ScZipHandler* fun = new ScZipHandler();
576
                                                if (!fun->open(fn))
577
                                                        qDebug()<<"Zip file doesnt open"<<fn;
578
                                                else
579
                                                {
580
                                                        QStringList toExtract(fun->files());
19826 craig 581
                                                        QString toDir(ScPaths::getUserFontDir(false)+fi.baseName()+"/");
582
                                                        QDir d(ScPaths::getUserFontDir(false));
583
                                                        if (!d.exists(fi.baseName()))
584
                                                                d.mkdir(fi.baseName());
19822 craig 585
                                                        foreach (QString f2e, toExtract)
586
                                                        {
19826 craig 587
                                                                //qDebug()<<"Unzipping"<<f2e<<"to"<<toDir;
588
                                                                fun->extract(f2e,toDir);
19822 craig 589
                                                        }
590
                                                }
591
                                                delete fun;
592
                                        }
593
                                }
594
                                if (d.filetype=="plain")
595
                                {
596
                                        //do nothing as the file is alread in place from dl mgr
597
                                }
598
                        }
599
                        break;
600
        }
601
 
602
}
603
 
604
void ResourceManager::updateProgressBar()
605
{
606
        downloadProgressBar->setValue(downloadProgressBar->value()+1);
607
}
608
 
609
void ResourceManager::startDownload()
610
{
611
        int rows=availableTableWidget->rowCount();
612
        QStringList filesToDownload;
613
        for (int i=0; i<rows; ++i)
614
        {
615
                QTableWidgetItem *dlItem=availableTableWidget->item(i,3);
616
                if (dlItem->checkState()==Qt::Checked)
617
                        filesToDownload<<availableTableWidget->item(i,0)->text();
618
        }
619
        if (filesToDownload.isEmpty())
620
                return;
19823 craig 621
        //qDebug()<<filesToDownload;
19822 craig 622
        downloadButton->setEnabled(false);
623
        downloadList.clear();
624
        downloadProgressBar->setValue(0);
625
        downloadProgressBar->setVisible(true);
626
//      dlLabel->setVisible(true);
627
        int dlCount=0;
628
 
629
        //Set up destination
630
        QString destinationFolder;
631
        int category = categoryComboBox->currentData().toInt();
632
        switch (category)
633
        {
634
                case RM_FONTS:
635
                        destinationFolder=ScPaths::getUserFontDir(true);
636
                        break;
637
                case RM_HYPH:
638
                        destinationFolder=ScPaths::getUserDictDir(true);
639
                        break;
640
                case RM_SPELL:
641
                        destinationFolder=ScPaths::getUserDictDir(true);
642
                        break;
643
                case RM_TEMPLATES:
644
                        destinationFolder=ScPaths::getUserDictDir(true);
645
                        break;
646
        }
647
        switch (category)
648
        {
649
                case RM_FONTS:
650
                        foreach(DownloadItem d, fontList)
651
                        {
652
                                if (filesToDownload.contains(d.desc))
653
                                {
654
                                        if (d.filetype=="zip")
655
                                        {
656
                                                QStringList plainURLs(d.files.split(";", QString::SkipEmptyParts));
657
                                                foreach (QString s, plainURLs)
658
                                                {
659
                                                        //qDebug()<<"Requesting:"<<d.url+"/"+s;
19823 craig 660
                                                        ScQApp->dlManager()->addURL(d.url+"/"+s, true, ScPaths::downloadDir(), destinationFolder, d.files);
19822 craig 661
                                                        ++dlCount;
662
                                                }
663
                                                downloadList.append(d);
664
                                                d.download=true;
665
                                        }
666
                                        if (d.filetype=="plain")
667
                                        {
668
                                                QStringList plainURLs(d.files.split(";", QString::SkipEmptyParts));
669
                                                foreach (QString s, plainURLs)
670
                                                {
671
                                                        ScQApp->dlManager()->addURL(d.url+"/"+s, true, ScPaths::downloadDir(), destinationFolder);
672
                                                        ++dlCount;
673
                                                }
674
                                                downloadList.append(d);
675
                                                d.download=true;
676
                                        }
677
                                }
678
                        }
679
                        break;
680
                case RM_HYPH:
681
                case RM_SPELL:
682
                        foreach(DownloadItem d, dictList)
683
                        {
684
                                if (filesToDownload.contains(d.lang))
685
                                {
686
                                        if (d.filetype=="zip")
687
                                        {
688
                                                QStringList plainURLs(d.files.split(";", QString::SkipEmptyParts));
689
                                                foreach (QString s, plainURLs)
690
                                                {
691
                                                        ScQApp->dlManager()->addURL(d.url+"/"+s, true, ScPaths::downloadDir(), destinationFolder);
692
                                                        ++dlCount;
693
                                                }
694
                                                downloadList.append(d);
695
                                                d.download=true;
696
                                        }
697
                                        if (d.filetype=="plain")
698
                                        {
699
                                                //qDebug()<<d.url<<d.files;
700
                                                QStringList plainURLs(d.files.split(";", QString::SkipEmptyParts));
701
                                                foreach (QString s, plainURLs)
702
                                                {
703
                                                        ScQApp->dlManager()->addURL(d.url+"/"+s, true, ScPaths::downloadDir(), destinationFolder);
704
                                                        ++dlCount;
705
                                                }
706
                                                downloadList.append(d);
707
                                                d.download=true;
708
                                        }
709
                                }
710
                        }
711
                        break;
712
                default:
713
                        break;
714
        }
715
        if (dlCount>0)
716
        {
717
                downloadProgressBar->setRange(0, dlCount);
718
                connect(ScQApp->dlManager(), SIGNAL(finished()), this, SLOT(downloadFilesFinished()));
719
                connect(ScQApp->dlManager(), SIGNAL(fileReceived(const QString&)), this, SLOT(updateProgressBar()));
720
                connect(ScQApp->dlManager(), SIGNAL(fileFailed(const QString&)), this, SLOT(updateProgressBar()));
721
                ScQApp->dlManager()->startDownloads();
722
        }
723
}
724