← Back to branch summary

~ubuntu-branches/ubuntu/utopic/kde-workspace/utopic-proposed

« back to all changes in this revision

Viewing changes to kcontrol/kfontinst/kcmfontinst/KCmFontInst.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Michał Zając
  • Date: 2011-07-09 08:31:15 UTC
  • Revision ID: james.westby@ubuntu.com-20110709083115-ohyxn6z93mily9fc
Tags: upstream-4.6.90
Import upstream version 4.6.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
kcontrol/kfontinst/kcmfontinst/KCmFontInst.cpp
 
1
/*
 
2
 * KFontInst - KDE Font Installer
 
3
 *
 
4
 * Copyright 2003-2007 Craig Drummond <craig@kde.org>
 
5
 *
 
6
 * ----
 
7
 *
 
8
 * This program is free software; you can redistribute it and/or modify
 
9
 * it under the terms of the GNU General Public License as published by
 
10
 * the Free Software Foundation; either version 2 of the License, or
 
11
 * (at your option) any later version.
 
12
 *
 
13
 * This program is distributed in the hope that it will be useful,
 
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
16
 * General Public License for more details.
 
17
 *
 
18
 * You should have received a copy of the GNU General Public License
 
19
 * along with this program; see the file COPYING.  If not, write to
 
20
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 
21
 * Boston, MA 02110-1301, USA.
 
22
 */
 
23
 
 
24
#include "KCmFontInst.h"
 
25
#include "KfiConstants.h"
 
26
#include "PrintDialog.h"
 
27
#include "FcEngine.h"
 
28
#include "FontPreview.h"
 
29
#include "FontsPackage.h"
 
30
#include "Misc.h"
 
31
#include "FontList.h"
 
32
#include "DuplicatesDialog.h"
 
33
#include "FontFilter.h"
 
34
#include "PreviewSelectAction.h"
 
35
#include "PreviewList.h"
 
36
#include <QtGui/QGridLayout>
 
37
#include <QtGui/QBoxLayout>
 
38
#include <QtGui/QSplitter>
 
39
#include <QtGui/QProgressBar>
 
40
#include <QtGui/QApplication>
 
41
#include <QtGui/QComboBox>
 
42
#include <QtGui/QPainter>
 
43
#include <QtGui/QMenu>
 
44
#include <QtGui/QLabel>
 
45
#include <QtCore/QCoreApplication>
 
46
#include <QtCore/QProcess>
 
47
#include <QtCore/QTextStream>
 
48
#include <KDE/KAboutData>
 
49
#include <KDE/KToolBar>
 
50
#include <KDE/KFileDialog>
 
51
#include <KDE/KMessageBox>
 
52
#include <KDE/KIO/Job>
 
53
#include <KDE/KIO/NetAccess>
 
54
#include <KDE/KPushButton>
 
55
#include <KDE/KGlobal>
 
56
#include <KDE/KGuiItem>
 
57
#include <KDE/KInputDialog>
 
58
#include <KDE/KIconLoader>
 
59
#include <KDE/KProgressDialog>
 
60
#include <KDE/KTempDir>
 
61
#include <KDE/KTemporaryFile>
 
62
#include <KDE/KIcon>
 
63
#include <KDE/KActionMenu>
 
64
#include <KDE/KToggleAction>
 
65
#include <KDE/KStandardDirs>
 
66
#include <KDE/KMenu>
 
67
#include <KDE/KPluginFactory>
 
68
#include <KDE/KPluginLoader>
 
69
#include <KDE/KStandardAction>
 
70
#include <KDE/KZip>
 
71
 
 
72
#define CFG_GROUP                  "Main Settings"
 
73
#define CFG_PREVIEW_SPLITTER_SIZES "PreviewSplitterSizes"
 
74
#define CFG_GROUP_SPLITTER_SIZES   "GroupSplitterSizes"
 
75
#define CFG_FONT_SIZE              "FontSize"
 
76
 
 
77
K_PLUGIN_FACTORY(FontInstallFactory,
 
78
        registerPlugin<KFI::CKCmFontInst>();
 
79
        )
 
80
K_EXPORT_PLUGIN(FontInstallFactory("fontinst"))
 
81
 
 
82
namespace KFI
 
83
{
 
84
 
 
85
static QString partialIcon(bool load=true)
 
86
{
 
87
    QString name(KGlobal::dirs()->saveLocation("cache", "kfi")+"/partial.png");
 
88
 
 
89
    if(Misc::fExists(name))
 
90
    {
 
91
        if(!load)
 
92
            QFile::remove(name);
 
93
    }
 
94
    else if(load)
 
95
    {
 
96
        QString pth;
 
97
        QPixmap pix=KIconLoader::global()->loadIcon("dialog-ok", KIconLoader::Small, KIconLoader::SizeSmall,
 
98
                                                    KIconLoader::DisabledState);
 
99
 
 
100
        pix.save(name, "PNG");
 
101
    }
 
102
 
 
103
    return name;
 
104
}
 
105
 
 
106
class CPushButton : public KPushButton
 
107
{
 
108
    public:
 
109
 
 
110
    CPushButton(const KGuiItem &item, QWidget *parent)
 
111
        : KPushButton(item, parent)
 
112
    {
 
113
        theirHeight=qMax(theirHeight, KPushButton::sizeHint().height());
 
114
        setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
 
115
    }
 
116
 
 
117
    QSize sizeHint() const
 
118
    {
 
119
        QSize sh(KPushButton::sizeHint());
 
120
 
 
121
        sh.setHeight(theirHeight);
 
122
        if(sh.width()<sh.height())
 
123
            sh.setWidth(sh.height());
 
124
        else if(text().isEmpty())
 
125
            sh.setWidth(theirHeight);
 
126
        return sh;
 
127
    }
 
128
 
 
129
    static int theirHeight;
 
130
};
 
131
 
 
132
class CToolBar : public KToolBar
 
133
{
 
134
    public:
 
135
 
 
136
    CToolBar(QWidget *parent)
 
137
        : KToolBar(parent)
 
138
    {
 
139
        setMovable(false);
 
140
        setFloatable(false);
 
141
        setToolButtonStyle(Qt::ToolButtonIconOnly);
 
142
        setFont(QApplication::font());
 
143
    }
 
144
 
 
145
    void paintEvent(QPaintEvent *)
 
146
    {
 
147
        QColor col(palette().color(backgroundRole()));
 
148
 
 
149
        col.setAlphaF(0.0);
 
150
        QPainter(this).fillRect(rect(), col);
 
151
    }
 
152
};
 
153
 
 
154
class CProgressBar : public QProgressBar
 
155
{
 
156
    public:
 
157
 
 
158
    CProgressBar(QWidget *p, int h) : QProgressBar(p), itsHeight((int)(h*0.6))
 
159
        { setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed); }
 
160
 
 
161
    virtual ~CProgressBar() { }
 
162
 
 
163
    int height() const     { return itsHeight; }
 
164
    QSize sizeHint() const { return QSize(100, itsHeight); }
 
165
 
 
166
    private:
 
167
 
 
168
    int itsHeight;
 
169
};
 
170
 
 
171
int CPushButton::theirHeight=0;
 
172
 
 
173
CKCmFontInst::CKCmFontInst(QWidget *parent, const QVariantList&)
 
174
            : KCModule(FontInstallFactory::componentData(), parent),
 
175
              itsPreview(NULL),
 
176
              itsConfig(KFI_UI_CFG_FILE),
 
177
              itsJob(NULL),
 
178
              itsProgress(NULL),
 
179
              itsUpdateDialog(NULL),
 
180
              itsTempDir(NULL),
 
181
              itsPrintProc(NULL)
 
182
{
 
183
    setButtons(Help);
 
184
 
 
185
    KGlobal::locale()->insertCatalog(KFI_CATALOGUE);
 
186
    KIconLoader::global()->addAppDir(KFI_NAME);
 
187
    KIconLoader::global()->reconfigure(KFI_NAME, KGlobal::dirs());
 
188
 
 
189
    KAboutData *about = new KAboutData("fontinst", 0, ki18n("KDE Font Installer"), 0, KLocalizedString(),
 
190
                                       KAboutData::License_GPL, ki18n("(C) Craig Drummond, 2000 - 2009"));
 
191
    about->addAuthor(ki18n("Craig Drummond"), ki18n("Developer and maintainer"), "craig@kde.org");
 
192
    setAboutData(about);
 
193
 
 
194
    KConfigGroup cg(&itsConfig, CFG_GROUP);
 
195
 
 
196
    itsGroupSplitter=new QSplitter(this);
 
197
    itsGroupSplitter->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
 
198
    QWidget *groupWidget=new QWidget(itsGroupSplitter),
 
199
            *fontWidget=new QWidget(itsGroupSplitter);
 
200
 
 
201
    itsPreviewSplitter=new QSplitter(fontWidget);
 
202
    itsPreviewSplitter->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
 
203
 
 
204
    QWidget     *toolbarWidget=new QWidget(this),
 
205
                *fontControlWidget=new QWidget(fontWidget);
 
206
    CToolBar    *toolbar=new CToolBar(toolbarWidget);
 
207
    QGridLayout *groupsLayout=new QGridLayout(groupWidget);
 
208
    QBoxLayout  *mainLayout=new QBoxLayout(QBoxLayout::TopToBottom, this),
 
209
                *toolbarLayout=new QBoxLayout(QBoxLayout::LeftToRight, toolbarWidget),
 
210
                *fontsLayout=new QBoxLayout(QBoxLayout::TopToBottom, fontWidget),
 
211
                *fontControlLayout=new QBoxLayout(QBoxLayout::LeftToRight, fontControlWidget);
 
212
 
 
213
    toolbarLayout->setMargin(0);
 
214
    toolbarLayout->setSpacing(KDialog::spacingHint());
 
215
    mainLayout->setMargin(0);
 
216
    mainLayout->setSpacing(KDialog::spacingHint());
 
217
    groupsLayout->setMargin(0);
 
218
    groupsLayout->setSpacing(KDialog::spacingHint());
 
219
    fontsLayout->setMargin(0);
 
220
    fontsLayout->setSpacing(KDialog::spacingHint());
 
221
    fontControlLayout->setMargin(0);
 
222
    fontControlLayout->setSpacing(KDialog::spacingHint());
 
223
 
 
224
    // Toolbar...
 
225
    KAction     *duplicateFontsAct=new KAction(KIcon("system-search"), i18n("Scan for Duplicate Fonts..."), this);
 
226
                //*validateFontsAct=new KAction(KIcon("checkmark"), i18n("Validate Fonts..."), this);
 
227
                //*downloadFontsAct=new KAction(KIcon("go-down"), i18n("Download Fonts..."), this);
 
228
 
 
229
    itsToolsMenu=new KActionMenu(KIcon("system-run"), i18n("Tools"), this);
 
230
    itsToolsMenu->addAction(duplicateFontsAct);
 
231
    //itsToolsMenu->addAction(validateFontsAct);
 
232
    //itsToolsMenu->addAction(downloadFontsAct);
 
233
    itsToolsMenu->setDelayed(false);
 
234
    toolbar->addAction(itsToolsMenu);
 
235
    itsFilter=new CFontFilter(toolbarWidget);
 
236
 
 
237
    // Details - Groups...
 
238
    itsGroupList=new CGroupList(groupWidget);
 
239
    itsGroupListView=new CGroupListView(groupWidget, itsGroupList);
 
240
 
 
241
    KPushButton *createGroup=new CPushButton(KGuiItem(QString(), "list-add",
 
242
                                                      i18n("Create a new group")),
 
243
                                             groupWidget);
 
244
 
 
245
    itsDeleteGroupControl=new CPushButton(KGuiItem(QString(), "edit-delete",
 
246
                                                   i18n("Remove group")),
 
247
                                          groupWidget);
 
248
 
 
249
    itsEnableGroupControl=new CPushButton(KGuiItem(QString(), "enablefont",
 
250
                                                   i18n("Enable all disabled fonts in the current group")),
 
251
                                          groupWidget);
 
252
 
 
253
    itsDisableGroupControl=new CPushButton(KGuiItem(QString(), "disablefont",
 
254
                                                    i18n("Disable all enabled fonts in the current group")),
 
255
                                           groupWidget);
 
256
 
 
257
    groupsLayout->addWidget(itsGroupListView, 0, 0, 1, 5);
 
258
    groupsLayout->addWidget(createGroup, 1, 0);
 
259
    groupsLayout->addWidget(itsDeleteGroupControl, 1, 1);
 
260
    groupsLayout->addWidget(itsEnableGroupControl, 1, 2);
 
261
    groupsLayout->addWidget(itsDisableGroupControl, 1, 3);
 
262
    groupsLayout->addItem(new QSpacerItem(itsDisableGroupControl->width(), KDialog::spacingHint(),
 
263
                          QSizePolicy::Expanding, QSizePolicy::Fixed), 1, 4);
 
264
 
 
265
    QWidget    *previewWidget = new QWidget(this);
 
266
    QBoxLayout *previewWidgetLayout = new QBoxLayout(QBoxLayout::TopToBottom, previewWidget);
 
267
    previewWidgetLayout->setMargin(0);
 
268
    previewWidgetLayout->setSpacing(0);
 
269
    
 
270
    // Preview
 
271
    QFrame     *previewFrame=new QFrame(previewWidget);
 
272
    QBoxLayout *previewFrameLayout=new QBoxLayout(QBoxLayout::LeftToRight, previewFrame);
 
273
 
 
274
    previewFrameLayout->setMargin(0);
 
275
    previewFrameLayout->setSpacing(0);
 
276
    previewFrame->setFrameShape(QFrame::StyledPanel);
 
277
    previewFrame->setFrameShadow(QFrame::Sunken);
 
278
    previewFrame->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::MinimumExpanding);
 
279
 
 
280
    itsPreview=new CFontPreview(previewFrame);
 
281
    itsPreview->setWhatsThis(i18n("This displays a preview of the selected font."));
 
282
    itsPreview->setContextMenuPolicy(Qt::CustomContextMenu);
 
283
    previewFrameLayout->addWidget(itsPreview);
 
284
    previewWidgetLayout->addWidget(previewFrame);
 
285
    itsPreview->engine()->readConfig(itsConfig);
 
286
 
 
287
    // List-style preview...
 
288
    itsPreviewList = new CPreviewListView(itsPreview->engine(), previewWidget);
 
289
    previewWidgetLayout->addWidget(itsPreviewList);
 
290
    itsPreviewList->setVisible(false);
 
291
 
 
292
    // Font List...
 
293
    itsFontList=new CFontList(fontWidget);
 
294
    itsFontListView=new CFontListView(itsPreviewSplitter, itsFontList);
 
295
    itsFontListView->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
 
296
 
 
297
    itsAddFontControl=new CPushButton(KGuiItem(i18n("Add..."), "list-add",
 
298
                                               i18n("Install fonts")),
 
299
                                      fontControlWidget);
 
300
 
 
301
    itsDeleteFontControl=new CPushButton(KGuiItem(i18n("Delete"), "edit-delete",
 
302
                                                  i18n("Delete all selected fonts")),
 
303
                                         fontControlWidget);
 
304
 
 
305
    itsPreviewSplitter->addWidget(previewWidget);
 
306
    itsPreviewSplitter->setCollapsible(1, true);
 
307
 
 
308
    itsStatusLabel = new QLabel(fontControlWidget);
 
309
    itsStatusLabel->setAlignment(Qt::AlignVCenter|Qt::AlignRight);
 
310
    itsListingProgress=new CProgressBar(fontControlWidget, itsStatusLabel->height());
 
311
    itsListingProgress->setRange(0, 100);
 
312
 
 
313
    // Layout widgets...
 
314
    toolbarLayout->addWidget(toolbar);
 
315
    toolbarLayout->addItem(new QSpacerItem(KDialog::spacingHint(), 2, QSizePolicy::MinimumExpanding, QSizePolicy::Fixed));
 
316
    toolbarLayout->addWidget(itsFilter);
 
317
    mainLayout->addWidget(toolbarWidget);
 
318
    mainLayout->addWidget(itsGroupSplitter);
 
319
 
 
320
    fontControlLayout->addWidget(itsAddFontControl);
 
321
    fontControlLayout->addWidget(itsDeleteFontControl);
 
322
    fontControlLayout->addWidget(itsStatusLabel);
 
323
    fontControlLayout->addItem(new QSpacerItem(0, itsListingProgress->height()+4,
 
324
                                               QSizePolicy::Fixed, QSizePolicy::Fixed));
 
325
    fontControlLayout->addWidget(itsListingProgress);
 
326
 
 
327
    fontsLayout->addWidget(itsPreviewSplitter);
 
328
    fontsLayout->addWidget(fontControlWidget);
 
329
 
 
330
    // Set size of widgets...
 
331
    itsPreviewSplitter->setChildrenCollapsible(false);
 
332
    itsGroupSplitter->setChildrenCollapsible(false);
 
333
    itsGroupSplitter->setStretchFactor(0, 0);
 
334
    itsGroupSplitter->setStretchFactor(1, 1);
 
335
    itsPreviewSplitter->setStretchFactor(0, 1);
 
336
    itsPreviewSplitter->setStretchFactor(1, 0);
 
337
 
 
338
    // Set sizes for 3 views...
 
339
    QList<int> defaultSizes;
 
340
    defaultSizes+=300;
 
341
    defaultSizes+=220;
 
342
    itsPreviewSplitter->setSizes(cg.readEntry(CFG_PREVIEW_SPLITTER_SIZES, defaultSizes));
 
343
 
 
344
    defaultSizes.clear();
 
345
    defaultSizes+=110;
 
346
    defaultSizes+=350;
 
347
    itsGroupSplitter->setSizes(cg.readEntry(CFG_GROUP_SPLITTER_SIZES, defaultSizes));
 
348
 
 
349
    // Preview widget pop-up menu
 
350
    itsPreviewMenu = new QMenu(itsPreview);
 
351
    QAction *zoomIn=KStandardAction::create(KStandardAction::ZoomIn, itsPreview, SLOT(zoomIn()), this),
 
352
            *zoomOut=KStandardAction::create(KStandardAction::ZoomOut, itsPreview, SLOT(zoomOut()), this);
 
353
 
 
354
    itsPreviewMenu->addAction(zoomIn);
 
355
    itsPreviewMenu->addAction(zoomOut);
 
356
    itsPreviewMenu->addSeparator();
 
357
    CPreviewSelectAction *prevSel=new CPreviewSelectAction(itsPreviewMenu);
 
358
    itsPreviewMenu->addAction(prevSel);
 
359
    KAction *changeTextAct=new KAction(KIcon("edit-rename"), i18n("Change Preview Text..."), this);
 
360
    itsPreviewMenu->addAction(changeTextAct),
 
361
 
 
362
    itsPreviewListMenu = new QMenu(itsPreviewList);
 
363
    itsPreviewListMenu->addAction(changeTextAct),
 
364
 
 
365
    // Connect signals...
 
366
    connect(itsPreview, SIGNAL(atMax(bool)), zoomIn, SLOT(setDisabled(bool)));
 
367
    connect(itsPreview, SIGNAL(atMin(bool)), zoomOut, SLOT(setDisabled(bool)));
 
368
    connect(prevSel, SIGNAL(range(const QList<CFcEngine::TRange> &)),
 
369
            itsPreview, SLOT(setUnicodeRange(const QList<CFcEngine::TRange> &)));
 
370
    connect(changeTextAct, SIGNAL(triggered(bool)), SLOT(changeText()));
 
371
    connect(itsFilter, SIGNAL(textChanged(const QString &)), itsFontListView, SLOT(filterText(const QString &)));
 
372
    connect(itsFilter, SIGNAL(criteriaChanged(int, qulonglong)), itsFontListView, SLOT(filterCriteria(int, qulonglong)));
 
373
    connect(itsGroupListView, SIGNAL(del()), SLOT(removeGroup()));
 
374
    connect(itsGroupListView, SIGNAL(print()), SLOT(printGroup()));
 
375
    connect(itsGroupListView, SIGNAL(enable()), SLOT(enableGroup()));
 
376
    connect(itsGroupListView, SIGNAL(disable()), SLOT(disableGroup()));
 
377
    connect(itsGroupListView, SIGNAL(moveFonts()), SLOT(moveFonts()));
 
378
    connect(itsGroupListView, SIGNAL(zip()), SLOT(zipGroup()));
 
379
    connect(itsGroupListView, SIGNAL(itemSelected(const QModelIndex &)),
 
380
           SLOT(groupSelected(const QModelIndex &)));
 
381
    connect(itsGroupListView, SIGNAL(info(const QString &)),
 
382
           SLOT(showInfo(const QString &)));
 
383
    connect(itsGroupList, SIGNAL(refresh()), SLOT(refreshFontList()));
 
384
    connect(itsFontList, SIGNAL(listingPercent(int)), SLOT(listingPercent(int)));
 
385
    connect(itsFontList, SIGNAL(layoutChanged()), SLOT(setStatusBar()));
 
386
    connect(itsFontListView, SIGNAL(del()), SLOT(deleteFonts()));
 
387
    connect(itsFontListView, SIGNAL(print()), SLOT(print()));
 
388
    connect(itsFontListView, SIGNAL(enable()), SLOT(enableFonts()));
 
389
    connect(itsFontListView, SIGNAL(disable()), SLOT(disableFonts()));
 
390
    connect(itsFontListView, SIGNAL(fontsDropped(const QSet<KUrl> &)),
 
391
           SLOT(addFonts(const QSet<KUrl> &)));
 
392
    connect(itsFontListView, SIGNAL(itemsSelected(const QModelIndexList &)), SLOT(fontsSelected(const QModelIndexList &)));
 
393
    connect(itsFontListView, SIGNAL(refresh()), SLOT(setStatusBar()));
 
394
    connect(itsGroupListView, SIGNAL(unclassifiedChanged()), itsFontListView, SLOT(refreshFilter()));
 
395
    connect(createGroup, SIGNAL(clicked()), SLOT(addGroup()));
 
396
    connect(itsDeleteGroupControl, SIGNAL(clicked()), SLOT(removeGroup()));
 
397
    connect(itsEnableGroupControl, SIGNAL(clicked()), SLOT(enableGroup()));
 
398
    connect(itsDisableGroupControl, SIGNAL(clicked()), SLOT(disableGroup()));
 
399
    connect(itsAddFontControl, SIGNAL(clicked()), SLOT(addFonts()));
 
400
    connect(itsDeleteFontControl, SIGNAL(clicked()), SLOT(deleteFonts()));
 
401
    connect(duplicateFontsAct, SIGNAL(triggered(bool)), SLOT(duplicateFonts()));
 
402
    //connect(validateFontsAct, SIGNAL(triggered(bool)), SLOT(validateFonts()));
 
403
    //connect(downloadFontsAct, SIGNAL(triggered(bool)), SLOT(downloadFonts()));
 
404
    connect(itsPreview, SIGNAL(customContextMenuRequested(const QPoint &)), SLOT(previewMenu(const QPoint &)));
 
405
    connect(itsPreviewList, SIGNAL(showMenu(const QPoint &)), SLOT(previewMenu(const QPoint &)));
 
406
 
 
407
    selectMainGroup();
 
408
    itsFontList->load();
 
409
}
 
410
 
 
411
CKCmFontInst::~CKCmFontInst()
 
412
{
 
413
    KConfigGroup cg(&itsConfig, CFG_GROUP);
 
414
 
 
415
    cg.writeEntry(CFG_PREVIEW_SPLITTER_SIZES, itsPreviewSplitter->sizes());
 
416
    cg.writeEntry(CFG_GROUP_SPLITTER_SIZES, itsGroupSplitter->sizes());
 
417
    delete itsTempDir;
 
418
    partialIcon(false);
 
419
}
 
420
 
 
421
QString CKCmFontInst::quickHelp() const
 
422
{
 
423
    return Misc::root()
 
424
               ? i18n("<h1>Font Installer</h1><p> This module allows you to"
 
425
                      " install TrueType, Type1, and Bitmap"
 
426
                      " fonts.</p><p>You may also install fonts using Konqueror:"
 
427
                      " type fonts:/ into Konqueror's location bar"
 
428
                      " and this will display your installed fonts. To install a"
 
429
                      " font, simply copy one into the folder.</p>")
 
430
               : i18n("<h1>Font Installer</h1><p> This module allows you to"
 
431
                      " install TrueType, Type1, and Bitmap"
 
432
                      " fonts.</p><p>You may also install fonts using Konqueror:"
 
433
                      " type fonts:/ into Konqueror's location bar"
 
434
                      " and this will display your installed fonts. To install a"
 
435
                      " font, simply copy it into the appropriate folder - "
 
436
                      " \"%1\" for fonts available to just yourself, or "
 
437
                      " \"%2\" for system-wide fonts (available to all).</p>",
 
438
                      i18n(KFI_KIO_FONTS_USER), i18n(KFI_KIO_FONTS_SYS));
 
439
}
 
440
 
 
441
void CKCmFontInst::previewMenu(const QPoint &pos)
 
442
{
 
443
    if(itsPreviewList->isHidden())
 
444
        itsPreviewMenu->popup(itsPreview->mapToGlobal(pos));
 
445
    else
 
446
        itsPreviewListMenu->popup(itsPreviewList->mapToGlobal(pos));
 
447
}
 
448
 
 
449
void CKCmFontInst::fontsSelected(const QModelIndexList &list)
 
450
{
 
451
    itsDeleteFontControl->setEnabled(false);
 
452
 
 
453
    if(list.count())
 
454
    {
 
455
        if(list.count()<2)
 
456
        {
 
457
            CFontModelItem *mi=static_cast<CFontModelItem *>(list.last().internalPointer());
 
458
            CFontItem      *font=mi->parent()
 
459
                                    ? static_cast<CFontItem *>(mi)
 
460
                                    : (static_cast<CFamilyItem *>(mi))->regularFont();
 
461
 
 
462
            if(font)
 
463
                itsPreview->showFont(font->isEnabled() ? font->family() : font->fileName(),
 
464
                                     font->styleInfo(), font->index());
 
465
        }
 
466
        else
 
467
            itsPreviewList->showFonts(list);
 
468
    }
 
469
    itsDeleteFontControl->setEnabled(list.count());
 
470
    itsPreviewList->setVisible(list.count()>1);
 
471
    itsPreview->parentWidget()->setVisible(list.count()<2);
 
472
}
 
473
 
 
474
void CKCmFontInst::addFonts()
 
475
{
 
476
    QString filter("application/x-font-ttf "
 
477
                   "application/x-font-otf "
 
478
                   "application/x-font-type1 "
 
479
                   "application/x-font-pcf "
 
480
                   "application/x-font-bdf "
 
481
                   "application/vnd.kde.fontspackage");
 
482
 
 
483
    KUrl::List list=KFileDialog::getOpenUrls(KUrl(), filter, this, i18n("Add Fonts"));
 
484
 
 
485
    if(list.count())
 
486
    {
 
487
        QSet<KUrl>           urls;
 
488
        KUrl::List::Iterator it(list.begin()),
 
489
                             end(list.end());
 
490
 
 
491
        for(; it!=end; ++it)
 
492
        {
 
493
            if(KFI_KIO_FONTS_PROTOCOL!=(*it).protocol()) // Do not try to install from fonts:/ !!!
 
494
            {
 
495
                KUrl url(KIO::NetAccess::mostLocalUrl(*it, this));
 
496
 
 
497
                if(url.isLocalFile())
 
498
                {
 
499
                    QString file(url.toLocalFile());
 
500
 
 
501
                    if(Misc::isPackage(file)) // If its a package we need to unzip 1st...
 
502
                        urls+=FontsPackage::extract(url.toLocalFile(), &itsTempDir);
 
503
                    else if(!Misc::isMetrics(url))
 
504
                        urls.insert(url);
 
505
                }
 
506
                else if(!Misc::isMetrics(url))
 
507
                    urls.insert(url);
 
508
            }
 
509
        }
 
510
        if(urls.count())
 
511
            addFonts(urls);
 
512
        delete itsTempDir;
 
513
        itsTempDir=NULL;
 
514
    }
 
515
}
 
516
 
 
517
void CKCmFontInst::groupSelected(const QModelIndex &index)
 
518
{
 
519
    CGroupListItem *grp=NULL;
 
520
 
 
521
    if(index.isValid())
 
522
        grp=static_cast<CGroupListItem *>(index.internalPointer());
 
523
 
 
524
    itsFontListView->setFilterGroup(grp);
 
525
    setStatusBar();
 
526
 
 
527
    //
 
528
    // Check fonts listed within group are still valid!
 
529
    if(grp && grp->isCustom() && !grp->validated())
 
530
    {
 
531
        QSet<QString>           remList;
 
532
        QSet<QString>::Iterator it(grp->families().begin()),
 
533
                                end(grp->families().end());
 
534
 
 
535
        for(; it!=end; ++it)
 
536
            if(!itsFontList->hasFamily(*it))
 
537
                remList.insert(*it);
 
538
        it=remList.begin();
 
539
        end=remList.end();
 
540
        for(; it!=end; ++it)
 
541
            itsGroupList->removeFromGroup(grp, *it);
 
542
        grp->setValidated();
 
543
    }
 
544
}
 
545
 
 
546
void CKCmFontInst::print(bool all)
 
547
{
 
548
    //
 
549
    // In order to support printing of newly installed/enabled fonts, the actual printing
 
550
    // is carried out by the kfontinst helper app. This way we know Qt's font list will be
 
551
    // up to date.
 
552
    if(!itsPrintProc || QProcess::NotRunning==itsPrintProc->state())
 
553
    {
 
554
        QString exe(KStandardDirs::findExe(QLatin1String(KFI_PRINTER), KStandardDirs::installPath("libexec")));
 
555
 
 
556
        if(exe.isEmpty())
 
557
            KMessageBox::error(this, i18n("Failed to locate font printer."));
 
558
        else
 
559
        {
 
560
            QSet<Misc::TFont> fonts;
 
561
 
 
562
            itsFontListView->getPrintableFonts(fonts, !all);
 
563
 
 
564
            if(fonts.count())
 
565
            {
 
566
                CPrintDialog dlg(this);
 
567
                KConfigGroup cg(&itsConfig, CFG_GROUP);
 
568
 
 
569
                if(dlg.exec(cg.readEntry(CFG_FONT_SIZE, 1)))
 
570
                {
 
571
                    static const int constSizes[]={0, 12, 18, 24, 36, 48};
 
572
                    QSet<Misc::TFont>::ConstIterator it(fonts.begin()),
 
573
                                                    end(fonts.end());
 
574
                    KTemporaryFile                   tmpFile;
 
575
                    bool                             useFile(fonts.count()>16),
 
576
                                                    startProc(true);
 
577
                    QStringList                      args;
 
578
 
 
579
                    if(!itsPrintProc)
 
580
                        itsPrintProc=new QProcess(this);
 
581
                    else
 
582
                        itsPrintProc->kill();
 
583
 
 
584
                    //
 
585
                    // If we have lots of fonts to print, pass kfontinst a tempory groups file to print
 
586
                    // instead of passing font by font...
 
587
                    if(useFile)
 
588
                    {
 
589
                        if(tmpFile.open())
 
590
                        {
 
591
                            QTextStream str(&tmpFile);
 
592
 
 
593
                            for(; it!=end; ++it)
 
594
                                str << (*it).family << endl
 
595
                                    << (*it).styleInfo << endl;
 
596
 
 
597
                            args << "--embed" << QString().sprintf("0x%x", (unsigned int)window()->winId())
 
598
                                << "--caption" << KGlobal::caption().toUtf8()
 
599
                                << "--icon" << "preferences-desktop-font-installer"
 
600
                                << "--size" << QString().setNum(constSizes[dlg.chosenSize() < 6 ? dlg.chosenSize() : 2])
 
601
                                << "--listfile" << tmpFile.fileName()
 
602
                                << "--deletefile";
 
603
                        }
 
604
                        else
 
605
                        {
 
606
                            KMessageBox::error(this, i18n("Failed to save list of fonts to print."));
 
607
                            startProc=false;
 
608
                        }
 
609
                    }
 
610
                    else
 
611
                    {
 
612
                        args << "--embed" << QString().sprintf("0x%x", (unsigned int)window()->winId())
 
613
                            << "--caption" << KGlobal::caption().toUtf8()
 
614
                            << "--icon" << "preferences-desktop-font-installer"
 
615
                            << "--size" << QString().setNum(constSizes[dlg.chosenSize()<6 ? dlg.chosenSize() : 2]);
 
616
 
 
617
                        for(; it!=end; ++it)
 
618
                            args << "--pfont" << QString((*it).family.toUtf8()+','+QString().setNum((*it).styleInfo));
 
619
                    }
 
620
 
 
621
                    if(startProc)
 
622
                    {
 
623
                        itsPrintProc->start(exe, args);
 
624
 
 
625
                        if(itsPrintProc->waitForStarted(1000))
 
626
                        {
 
627
                            if(useFile)
 
628
                                tmpFile.setAutoRemove(false);
 
629
                        }
 
630
                        else
 
631
                            KMessageBox::error(this, i18n("Failed to start font printer."));
 
632
                    }
 
633
                    cg.writeEntry(CFG_FONT_SIZE, dlg.chosenSize());
 
634
                }
 
635
            }
 
636
            else
 
637
                KMessageBox::information(this, i18n("There are no printable fonts.\n"
 
638
                                                    "You can only print non-bitmap and enabled fonts."),
 
639
                                         i18n("Cannot Print"));
 
640
        }
 
641
    }
 
642
}
 
643
 
 
644
void CKCmFontInst::deleteFonts()
 
645
{
 
646
    CJobRunner::ItemList urls;
 
647
    QStringList          fontNames;
 
648
    QSet<Misc::TFont>    fonts;
 
649
 
 
650
    itsDeletedFonts.clear();
 
651
    itsFontListView->getFonts(urls, fontNames, &fonts, true);
 
652
 
 
653
    if(urls.isEmpty())
 
654
        KMessageBox::information(this, i18n("You did not select anything to delete."),
 
655
                                       i18n("Nothing to Delete"));
 
656
    else
 
657
    {
 
658
        QSet<Misc::TFont>::ConstIterator it(fonts.begin()),
 
659
                                         end(fonts.end());
 
660
        bool                             doIt=false;
 
661
 
 
662
        for(; it!=end; ++it)
 
663
            itsDeletedFonts.insert((*it).family);
 
664
 
 
665
        switch(fontNames.count())
 
666
        {
 
667
            case 0:
 
668
                break;
 
669
            case 1:
 
670
                doIt = KMessageBox::Yes==KMessageBox::warningYesNo(this,
 
671
                        i18n("<p>Do you really want to "
 
672
                                "delete</p><p>\'<b>%1</b>\'?</p>", fontNames.first()),
 
673
                        i18n("Delete Font"), KStandardGuiItem::del());
 
674
            break;
 
675
            default:
 
676
                doIt = KMessageBox::Yes==KMessageBox::warningYesNoList(this,
 
677
                        i18np("Do you really want to delete this font?",
 
678
                                "Do you really want to delete these %1 fonts?",
 
679
                                fontNames.count()),
 
680
                        fontNames, i18n("Delete Fonts"), KStandardGuiItem::del());
 
681
        }
 
682
 
 
683
        if(doIt)
 
684
        {
 
685
            itsStatusLabel->setText(i18n("Deleting font(s)..."));
 
686
            doCmd(CJobRunner::CMD_DELETE, urls);
 
687
        }
 
688
    }
 
689
}
 
690
 
 
691
void CKCmFontInst::moveFonts()
 
692
{
 
693
    CJobRunner::ItemList urls;
 
694
    QStringList          fontNames;
 
695
 
 
696
    itsDeletedFonts.clear();
 
697
    itsFontListView->getFonts(urls, fontNames, NULL, true);
 
698
 
 
699
    if(urls.isEmpty())
 
700
        KMessageBox::information(this, i18n("You did not select anything to move."),
 
701
                                       i18n("Nothing to Move"));
 
702
    else
 
703
    {
 
704
        bool doIt=false;
 
705
 
 
706
        switch(fontNames.count())
 
707
        {
 
708
            case 0:
 
709
                break;
 
710
            case 1:
 
711
                doIt = KMessageBox::Yes==KMessageBox::warningYesNo(this,
 
712
                        i18n("<p>Do you really want to "
 
713
                                "move</p><p>\'<b>%1</b>\'?</p>", fontNames.first()),
 
714
                        i18n("Move Font"), KGuiItem(i18n("Move")));
 
715
            break;
 
716
            default:
 
717
                doIt = KMessageBox::Yes==KMessageBox::warningYesNoList(this,
 
718
                        i18np("Do you really want to move this font?",
 
719
                                "Do you really want to move these %1 fonts?",
 
720
                                fontNames.count()),
 
721
                        fontNames, i18n("Move Fonts"), KGuiItem(i18n("Move")));
 
722
        }
 
723
 
 
724
        if(doIt)
 
725
        {
 
726
            itsStatusLabel->setText(i18n("Moving font(s)..."));
 
727
            doCmd(CJobRunner::CMD_MOVE, urls, !itsGroupListView->isSystem());
 
728
        }
 
729
    }
 
730
}
 
731
 
 
732
void CKCmFontInst::zipGroup()
 
733
{
 
734
    QModelIndex idx(itsGroupListView->currentIndex());
 
735
 
 
736
    if(idx.isValid())
 
737
    {
 
738
        CGroupListItem *grp=static_cast<CGroupListItem *>(idx.internalPointer());
 
739
 
 
740
        if(grp)
 
741
        {
 
742
            QString fileName=KFileDialog::getSaveFileName(grp->name(), "application/zip", this, i18n("Export Group"),
 
743
                                                          KFileDialog::ConfirmOverwrite);
 
744
 
 
745
            if(!fileName.isEmpty())
 
746
            {
 
747
                KZip zip(fileName);
 
748
 
 
749
                if(zip.open(QIODevice::WriteOnly))
 
750
                {
 
751
                    QSet<QString> files;
 
752
 
 
753
                    files=itsFontListView->getFiles();
 
754
 
 
755
                    if(files.count())
 
756
                    {
 
757
                        QMap<QString, QString>                map=Misc::getFontFileMap(files);
 
758
                        QMap<QString, QString>::ConstIterator it(map.constBegin()),
 
759
                                                            end(map.constEnd());
 
760
 
 
761
                        for(; it!=end; ++it)
 
762
                            zip.addLocalFile(it.value(), it.key());
 
763
                        zip.close();
 
764
                    }
 
765
                    else
 
766
                        KMessageBox::error(this, i18n("No files?"));
 
767
                }
 
768
                else
 
769
                    KMessageBox::error(this, i18n("Failed to open %1 for writing", fileName));
 
770
            }
 
771
        }
 
772
    }
 
773
}
 
774
 
 
775
void CKCmFontInst::enableFonts()
 
776
{
 
777
    toggleFonts(true);
 
778
}
 
779
 
 
780
void CKCmFontInst::disableFonts()
 
781
{
 
782
    toggleFonts(false);
 
783
}
 
784
 
 
785
void CKCmFontInst::addGroup()
 
786
{
 
787
    bool    ok;
 
788
    QString name(KInputDialog::getText(i18n("Create New Group"),
 
789
                                       i18n("Please enter the name of the new group:"),
 
790
                                       i18n("New Group"), &ok, this));
 
791
 
 
792
    if(ok && !name.isEmpty())
 
793
        itsGroupList->createGroup(name);
 
794
}
 
795
 
 
796
void CKCmFontInst::removeGroup()
 
797
{
 
798
    if(itsGroupList->removeGroup(itsGroupListView->currentIndex()))
 
799
        selectMainGroup();
 
800
}
 
801
 
 
802
void CKCmFontInst::enableGroup()
 
803
{
 
804
    toggleGroup(true);
 
805
}
 
806
 
 
807
void CKCmFontInst::disableGroup()
 
808
{
 
809
    toggleGroup(false);
 
810
}
 
811
 
 
812
void CKCmFontInst::changeText()
 
813
{
 
814
    bool             status;
 
815
    QRegExpValidator validator(QRegExp(".*"), 0L);
 
816
    QString          oldStr(itsPreview->engine()->getPreviewString()),
 
817
                     newStr(KInputDialog::getText(i18n("Preview Text"),
 
818
                                                  i18n("Please enter new text:"),
 
819
                                                  oldStr, &status, this, &validator));
 
820
 
 
821
    if(status && oldStr!=newStr)
 
822
    {
 
823
        itsPreview->engine()->setPreviewString(newStr);
 
824
 
 
825
        if(itsPreview->width()>6)
 
826
            itsPreview->showFont();
 
827
        itsPreviewList->refreshPreviews();
 
828
    }
 
829
}
 
830
 
 
831
void CKCmFontInst::duplicateFonts()
 
832
{
 
833
    CDuplicatesDialog(this, itsFontList).exec();
 
834
}
 
835
 
 
836
//void CKCmFontInst::validateFonts()
 
837
//{
 
838
//}
 
839
 
 
840
//void CKCmFontInst::downloadFonts()
 
841
//{
 
842
//}
 
843
 
 
844
void CKCmFontInst::print()
 
845
{
 
846
    print(false);
 
847
}
 
848
 
 
849
void CKCmFontInst::printGroup()
 
850
{
 
851
    print(true);
 
852
}
 
853
 
 
854
void CKCmFontInst::listingPercent(int p)
 
855
{
 
856
    if(0==p)
 
857
    {
 
858
        showInfo(i18n("Scanning font list..."));
 
859
        itsListingProgress->show();
 
860
    }
 
861
    else if(100==p && p!=itsListingProgress->value())
 
862
    {
 
863
        removeDeletedFontsFromGroups();
 
864
 
 
865
        QSet<QString> foundries;
 
866
 
 
867
        itsFontList->getFoundries(foundries);
 
868
        itsFilter->setFoundries(foundries);
 
869
        refreshFamilies();
 
870
        itsListingProgress->hide();
 
871
        itsFontListView->selectFirstFont();
 
872
    }
 
873
    itsListingProgress->setValue(p);
 
874
}
 
875
 
 
876
void CKCmFontInst::refreshFontList()
 
877
{
 
878
    itsFontListView->refreshFilter();
 
879
    refreshFamilies();
 
880
}
 
881
 
 
882
void CKCmFontInst::refreshFamilies()
 
883
{
 
884
    QSet<QString> enabledFamilies,
 
885
                  disabledFamilies,
 
886
                  partialFamilies;
 
887
 
 
888
    itsFontList->getFamilyStats(enabledFamilies, disabledFamilies, partialFamilies);
 
889
    itsGroupList->updateStatus(enabledFamilies, disabledFamilies, partialFamilies);
 
890
    setStatusBar();
 
891
}
 
892
 
 
893
void CKCmFontInst::showInfo(const QString &info)
 
894
{
 
895
    if(info.isEmpty())
 
896
        if(itsLastStatusBarMsg.isEmpty())
 
897
            setStatusBar();
 
898
        else
 
899
        {
 
900
            itsStatusLabel->setText(itsLastStatusBarMsg);
 
901
            itsLastStatusBarMsg=QString();
 
902
        }
 
903
    else
 
904
    {
 
905
        if(itsLastStatusBarMsg.isEmpty())
 
906
            itsLastStatusBarMsg=itsStatusLabel->text();
 
907
        itsStatusLabel->setText(info);
 
908
    }
 
909
}
 
910
 
 
911
void CKCmFontInst::setStatusBar()
 
912
{
 
913
    if(itsFontList->slowUpdates())
 
914
        return;
 
915
 
 
916
    int  enabled=0,
 
917
         disabled=0,
 
918
         partial=0;
 
919
    bool selectedEnabled=false,
 
920
         selectedDisabled=false;
 
921
 
 
922
    itsStatusLabel->setToolTip(QString());
 
923
    if(0==itsFontList->families().count())
 
924
        itsStatusLabel->setText(i18n("No fonts"));
 
925
    else
 
926
    {
 
927
        itsFontListView->stats(enabled, disabled, partial);
 
928
        itsFontListView->selectedStatus(selectedEnabled, selectedDisabled);
 
929
 
 
930
        QString text(i18np("1 Font", "%1 Fonts", enabled+disabled+partial));
 
931
 
 
932
        if(disabled||partial)
 
933
        {
 
934
            text+=i18n(" (<img src=\"%1\" />%2 <img src=\"%3\" />%4 <img src=\"%5\" />%6)",
 
935
                       KIconLoader::global()->iconPath("dialog-ok", -KIconLoader::SizeSmall),
 
936
                       enabled,
 
937
                       KIconLoader::global()->iconPath("dialog-cancel", -KIconLoader::SizeSmall),
 
938
                       disabled,
 
939
                       partialIcon(),
 
940
                       partial);
 
941
            itsStatusLabel->setToolTip(i18n("<table>"
 
942
                                            "<tr><td>Enabled fonts:</td><td>%1</td></tr>"
 
943
                                            "<tr><td>Disabled fonts:</td><td>%2</td></tr>"
 
944
                                            "<tr><td>Partially enabled fonts:</td><td>%3</td></tr>"
 
945
                                            "<tr><td>Total fonts:</td><td>%4</td></tr>"
 
946
                                            "</table>", enabled, disabled, partial, enabled+disabled+partial));
 
947
        }
 
948
 
 
949
        itsStatusLabel->setText(disabled||partial ? "<p>"+text+"</p>" : text);
 
950
    }
 
951
 
 
952
    CGroupListItem::EType type(itsGroupListView->getType());
 
953
 
 
954
    bool isStd(CGroupListItem::CUSTOM==type);
 
955
 
 
956
    itsAddFontControl->setEnabled(CGroupListItem::ALL==type||CGroupListItem::UNCLASSIFIED==type||
 
957
                                  CGroupListItem::PERSONAL==type||CGroupListItem::SYSTEM==type);
 
958
    itsDeleteGroupControl->setEnabled(isStd);
 
959
    itsEnableGroupControl->setEnabled(disabled||partial);
 
960
    itsDisableGroupControl->setEnabled(isStd && (enabled||partial));
 
961
 
 
962
    itsGroupListView->controlMenu(itsDeleteGroupControl->isEnabled(),
 
963
                                  itsEnableGroupControl->isEnabled(),
 
964
                                  itsDisableGroupControl->isEnabled(), enabled||partial, enabled||disabled);
 
965
 
 
966
    itsDeleteFontControl->setEnabled(selectedEnabled||selectedDisabled);
 
967
}
 
968
 
 
969
void CKCmFontInst::addFonts(const QSet<KUrl> &src)
 
970
{
 
971
    if(src.count() && !itsGroupListView->isCustom())
 
972
    {
 
973
        bool system;
 
974
 
 
975
        if(Misc::root())
 
976
            system=true;
 
977
        else
 
978
        {
 
979
            switch(itsGroupListView->getType())
 
980
            {
 
981
                case CGroupListItem::ALL:
 
982
                case CGroupListItem::UNCLASSIFIED:
 
983
                    switch(KMessageBox::questionYesNoCancel(this,
 
984
                           i18n("Do you wish to install the font(s) for personal use "
 
985
                                "(only available to you), or "
 
986
                                "system-wide (available to all users)?"),
 
987
                           i18n("Where to Install"), KGuiItem(i18n(KFI_KIO_FONTS_USER)),
 
988
                                KGuiItem(i18n(KFI_KIO_FONTS_SYS))))
 
989
                    {
 
990
                        case KMessageBox::Yes:
 
991
                            system=false;
 
992
                            break;
 
993
                        case KMessageBox::No:
 
994
                            system=true;
 
995
                            break;
 
996
                        default:
 
997
                        case KMessageBox::Cancel:
 
998
                            return;
 
999
                    }
 
1000
                    break;
 
1001
                case CGroupListItem::PERSONAL:
 
1002
                    system=false;
 
1003
                    break;
 
1004
                case CGroupListItem::SYSTEM:
 
1005
                    system=true;
 
1006
                    break;
 
1007
                default:
 
1008
                    return;
 
1009
            }
 
1010
        }
 
1011
 
 
1012
        QSet<KUrl>                copy;
 
1013
        QSet<KUrl>::ConstIterator it,
 
1014
                                  end(src.end());
 
1015
 
 
1016
        //
 
1017
        // Check if font has any associated AFM or PFM file...
 
1018
        itsStatusLabel->setText(i18n("Looking for any associated files..."));
 
1019
 
 
1020
        if(!itsProgress)
 
1021
        {
 
1022
            itsProgress=new KProgressDialog(this, i18n("Scanning Files..."),
 
1023
                                            i18n("Looking for additional files to install..."));
 
1024
            itsProgress->setModal(true);
 
1025
            itsProgress->setAutoReset(true);
 
1026
            itsProgress->setAutoClose(true);
 
1027
        }
 
1028
 
 
1029
        itsProgress->setAllowCancel(false);
 
1030
        itsProgress->setMinimumDuration(500);
 
1031
        itsProgress->progressBar()->show();
 
1032
        itsProgress->progressBar()->setRange(0, src.size());
 
1033
        itsProgress->progressBar()->setValue(0);
 
1034
 
 
1035
        int steps=src.count()<200 ? 1 : src.count()/10;
 
1036
        for(it=src.begin(); it!=end; ++it)
 
1037
        {
 
1038
            KUrl::List associatedUrls;
 
1039
 
 
1040
            itsProgress->setLabelText(i18n("Looking for files associated with %1", (*it).prettyUrl()));
 
1041
            itsProgress->progressBar()->setValue(itsProgress->progressBar()->value()+1);
 
1042
            if(1==steps || 0==(itsProgress->progressBar()->value()%steps))
 
1043
            {
 
1044
                bool dialogVisible(itsProgress->isVisible());
 
1045
                QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
 
1046
                if(dialogVisible && !itsProgress->isVisible()) // User closed dialog! re-open!!!
 
1047
                    itsProgress->show();
 
1048
            }
 
1049
 
 
1050
            CJobRunner::getAssociatedUrls(*it, associatedUrls, false, this);
 
1051
            copy.insert(*it);
 
1052
 
 
1053
            KUrl::List::Iterator aIt(associatedUrls.begin()),
 
1054
                                 aEnd(associatedUrls.end());
 
1055
 
 
1056
            for(; aIt!=aEnd; ++aIt)
 
1057
                copy.insert(*aIt);
 
1058
        }
 
1059
        itsProgress->close();
 
1060
 
 
1061
        CJobRunner::ItemList installUrls;
 
1062
 
 
1063
        end=copy.end();
 
1064
        for(it=copy.begin(); it!=end; ++it)
 
1065
            installUrls.append(*it);
 
1066
 
 
1067
        itsStatusLabel->setText(i18n("Installing font(s)..."));
 
1068
        doCmd(CJobRunner::CMD_INSTALL, installUrls, system);
 
1069
    }
 
1070
}
 
1071
 
 
1072
void CKCmFontInst::removeDeletedFontsFromGroups()
 
1073
{
 
1074
    if(itsDeletedFonts.count())
 
1075
    {
 
1076
        QSet<QString>::Iterator it(itsDeletedFonts.begin()),
 
1077
                                end(itsDeletedFonts.end());
 
1078
 
 
1079
        for(; it!=end; ++it)
 
1080
            if(!itsFontList->hasFamily(*it))
 
1081
                itsGroupList->removeFamily(*it);
 
1082
 
 
1083
        itsDeletedFonts.clear();
 
1084
    }
 
1085
}
 
1086
        
 
1087
void CKCmFontInst::selectGroup(CGroupListItem::EType grp)
 
1088
{
 
1089
    QModelIndex current(itsGroupListView->currentIndex());
 
1090
 
 
1091
    if(current.isValid())
 
1092
    {
 
1093
        CGroupListItem *grpItem=static_cast<CGroupListItem *>(current.internalPointer());
 
1094
 
 
1095
        if(grpItem && grp==grpItem->type())
 
1096
            return;
 
1097
        else
 
1098
            itsGroupListView->selectionModel()->select(current,
 
1099
                                                       QItemSelectionModel::Deselect);
 
1100
    }
 
1101
 
 
1102
    QModelIndex idx(itsGroupList->index(grp));
 
1103
 
 
1104
    itsGroupListView->selectionModel()->select(idx, QItemSelectionModel::Select);
 
1105
    itsGroupListView->setCurrentIndex(idx);
 
1106
    groupSelected(idx);
 
1107
    itsFontListView->refreshFilter();
 
1108
    setStatusBar();
 
1109
}
 
1110
 
 
1111
void CKCmFontInst::toggleGroup(bool enable)
 
1112
{
 
1113
    QModelIndex idx(itsGroupListView->currentIndex());
 
1114
 
 
1115
    if(idx.isValid())
 
1116
    {
 
1117
        CGroupListItem *grp=static_cast<CGroupListItem *>(idx.internalPointer());
 
1118
 
 
1119
        if(grp)
 
1120
            toggleFonts(enable, grp->name());
 
1121
    }
 
1122
}
 
1123
 
 
1124
void CKCmFontInst::toggleFonts(bool enable, const QString &grp)
 
1125
{
 
1126
    CJobRunner::ItemList urls;
 
1127
    QStringList          fonts;
 
1128
 
 
1129
    itsFontListView->getFonts(urls, fonts, NULL, grp.isEmpty(), !enable, enable);
 
1130
 
 
1131
    if(urls.isEmpty())
 
1132
        KMessageBox::information(this,
 
1133
                                 enable ? i18n("You did not select anything to enable.")
 
1134
                                        : i18n("You did not select anything to disable."),
 
1135
                                 enable ? i18n("Nothing to Enable") : i18n("Nothing to Disable"));
 
1136
    else
 
1137
        toggleFonts(urls, fonts, enable, grp);
 
1138
}
 
1139
 
 
1140
void CKCmFontInst::toggleFonts(CJobRunner::ItemList &urls, const QStringList &fonts, bool enable,
 
1141
                               const QString &grp)
 
1142
{
 
1143
    bool doIt=false;
 
1144
 
 
1145
    switch(fonts.count())
 
1146
    {
 
1147
        case 0:
 
1148
            break;
 
1149
        case 1:
 
1150
            doIt = KMessageBox::Yes==KMessageBox::warningYesNo(this,
 
1151
                       grp.isEmpty()
 
1152
                            ? enable ? i18n("<p>Do you really want to "
 
1153
                                            "enable</p><p>\'<b>%1</b>\'?</p>", fonts.first())
 
1154
                                     : i18n("<p>Do you really want to "
 
1155
                                            "disable</p><p>\'<b>%1</b>\'?</p>", fonts.first())
 
1156
                            : enable ? i18n("<p>Do you really want to "
 
1157
                                            "enable</p><p>\'<b>%1</b>\', "
 
1158
                                            "contained within group \'<b>%2</b>\'?</p>",
 
1159
                                            fonts.first(), grp)
 
1160
                                     : i18n("<p>Do you really want to "
 
1161
                                            "disable</p><p>\'<b>%1</b>\', "
 
1162
                                            "contained within group \'<b>%2</b>\'?</p>",
 
1163
                                            fonts.first(), grp),
 
1164
                       enable ? i18n("Enable Font") : i18n("Disable Font"),
 
1165
                       enable ? KGuiItem(i18n("Enable"), "enablefont", i18n("Enable Font"))
 
1166
                              : KGuiItem(i18n("Disable"), "disablefont", i18n("Disable Font")));
 
1167
            break;
 
1168
        default:
 
1169
            doIt = KMessageBox::Yes==KMessageBox::warningYesNoList(this,
 
1170
                       grp.isEmpty()
 
1171
                            ? enable ? i18np("Do you really want to enable this font?",
 
1172
                                             "Do you really want to enable these %1 fonts?",
 
1173
                                             urls.count())
 
1174
                                     : i18np("Do you really want to disable this font?",
 
1175
                                             "Do you really want to disable these %1 fonts?",
 
1176
                                             urls.count())
 
1177
                            : enable ? i18np("<p>Do you really want to enable this font "
 
1178
                                             "contained within group \'<b>%2</b>\'?</p>",
 
1179
                                             "<p>Do you really want to enable these %1 fonts "
 
1180
                                             "contained within group \'<b>%2</b>\'?</p>",
 
1181
                                             urls.count(), grp)
 
1182
                                     : i18np("<p>Do you really want to disable this font "
 
1183
                                             "contained within group \'<b>%2</b>\'?</p>",
 
1184
                                             "<p>Do you really want to disable these %1 fonts "
 
1185
                                             "contained within group \'<b>%2</b>\'?</p>",
 
1186
                                             urls.count(), grp),
 
1187
                       fonts,
 
1188
                       enable ? i18n("Enable Fonts") : i18n("Disable Fonts"),
 
1189
                       enable ? KGuiItem(i18n("Enable"), "enablefont", i18n("Enable Fonts"))
 
1190
                              : KGuiItem(i18n("Disable"), "disablefont", i18n("Disable Fonts")));
 
1191
    }
 
1192
 
 
1193
    if(doIt)
 
1194
    {
 
1195
        if(enable)
 
1196
            itsStatusLabel->setText(i18n("Enabling font(s)..."));
 
1197
        else
 
1198
            itsStatusLabel->setText(i18n("Disabling font(s)..."));
 
1199
 
 
1200
        doCmd(enable ? CJobRunner::CMD_ENABLE : CJobRunner::CMD_DISABLE, urls);
 
1201
    }
 
1202
}
 
1203
 
 
1204
void CKCmFontInst::selectMainGroup()
 
1205
{
 
1206
    selectGroup(/*Misc::root()
 
1207
                    ? */CGroupListItem::ALL/* : CGroupListItem::PERSONAL*/);
 
1208
}
 
1209
 
 
1210
void CKCmFontInst::doCmd(CJobRunner::ECommand cmd, const CJobRunner::ItemList &urls, bool system)
 
1211
{
 
1212
    itsFontList->setSlowUpdates(true);
 
1213
    CJobRunner runner(this);
 
1214
 
 
1215
    connect(&runner, SIGNAL(configuring()), itsFontList, SLOT(unsetSlowUpdates()));
 
1216
    runner.exec(cmd, urls, system);
 
1217
    itsFontList->setSlowUpdates(false);
 
1218
    CFcEngine::setDirty();
 
1219
    setStatusBar();
 
1220
    delete itsTempDir;
 
1221
    itsTempDir=NULL;
 
1222
    itsFontListView->repaint();
 
1223
    removeDeletedFontsFromGroups();
 
1224
    refreshFamilies();
 
1225
}
 
1226
 
 
1227
}
 
1228
 
 
1229
#include "KCmFontInst.moc"