workspace/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 "Misc.h"
  30 #include "FontList.h"
  31 #include "DuplicatesDialog.h"
  32 #include "PreviewSelectAction.h"
  33 #include "FontFilter.h"
  34 #include <QtGui/QGridLayout>
  35 #include <QtGui/QBoxLayout>
  36 #include <QtGui/QLabel>
  37 #include <QtGui/QSplitter>
  38 #include <QtGui/QProgressBar>
  39 #include <QtCore/QCoreApplication>
  40 #include <QtGui/QApplication>
  41 #include <QtCore/QTextStream>
  42 #include <QtGui/QComboBox>
  43 #include <QtCore/QProcess>
  44 #include <QtGui/QPainter>
  45 #include <KDE/KAboutData>
  46 #include <KDE/KToolBar>
  47 #include <KDE/KFileDialog>
  48 #include <KDE/KMessageBox>
  49 #include <KDE/KIO/Job>
  50 #include <KDE/KIO/NetAccess>
  51 #include <KDE/KPushButton>
  52 #include <KDE/KGuiItem>
  53 #include <KDE/KInputDialog>
  54 #include <KDE/KIconLoader>
  55 #include <KDE/KProgressDialog>
  56 #include <KDE/KZip>
  57 #include <KDE/KTempDir>
  58 #include <KDE/KTemporaryFile>
  59 #include <KDE/KIcon>
  60 #include <KDE/KActionMenu>
  61 #include <KDE/KToggleAction>
  62 #include <KDE/KStandardDirs>
  63 #include <KDE/KMenu>
  64 #include <KDE/KPluginFactory>
  65 #include <KDE/KPluginLoader>
  66
  67 #define CFG_GROUP                  "Main Settings"
  68 #define CFG_PREVIEW_SPLITTER_SIZES "PreviewSplitterSizes"
  69 #define CFG_GROUP_SPLITTER_SIZES   "GroupSplitterSizes"
  70 #define CFG_FONT_SIZE              "FontSize"
  71 #define CFG_FONT_MGT_MODE          "MgtMode"
  72 #define CFG_SHOW_PREVIEW           "ShowPreview"
  73
  74 K_PLUGIN_FACTORY(FontInstallFactory,
  75         registerPlugin<KFI::CKCmFontInst>();
  76         )
  77 K_EXPORT_PLUGIN(FontInstallFactory("fontinst"))
  78
  79 namespace KFI
  80 {
  81
  82 static int constModeList[]=
  83     {CGroupListItem::ALL, CGroupListItem::PERSONAL, CGroupListItem::SYSTEM, -1};
  84
  85 inline CGroupListItem::EType modeToGrp(int mode)
  86 {
  87     return (CGroupListItem::EType)(constModeList[mode]);
  88 }
  89
  90 static int grpToMode(CGroupListItem::EType type)
  91 {
  92     for(int i=0; i<3; ++i)
  93         if(constModeList[i]==type)
  94             return i;
  95     return 0;
  96 }
  97
  98 class CPushButton : public KPushButton
  99 {
 100     public:
 101
 102     CPushButton(const KGuiItem &item, QWidget *parent)
 103         : KPushButton(item, parent)
 104     {
 105         theirHeight=qMax(theirHeight, height());
 106         setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Maximum);
 107     }
 108
 109     QSize sizeHint() const
 110     {
 111         QSize sh(KPushButton::sizeHint());
 112
 113         sh.setHeight(theirHeight);
 114         if(sh.width()<sh.height())
 115             sh.setWidth(sh.height());
 116         else if(text().isEmpty())
 117             sh.setWidth(theirHeight);
 118         return sh;
 119     }
 120
 121     private:
 122
 123     static int theirHeight;
 124 };
 125
 126 class CToolBar : public KToolBar
 127 {
 128     public:
 129
 130     CToolBar(QWidget *parent)
 131         : KToolBar(parent)
 132     {
 133         theirHeight=qMax(theirHeight, height());
 134         setMovable(false);
 135         setFloatable(false);
 136         setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
 137         setFont(QApplication::font());
 138     }
 139
 140     void addSeparator()
 141     {
 142         addWidget(new QLabel(" ", this));
 143     }
 144
 145     void link(CToolBar *l)
 146     {
 147         itsLinked=l;
 148     }
 149
 150     QSize sizeHint() const
 151     {
 152         QSize sh(KToolBar::sizeHint());
 153
 154         sh.setHeight(theirHeight);
 155         return sh;
 156     }
 157
 158     void paintEvent(QPaintEvent *)
 159     {
 160         QColor col(palette().color(backgroundRole()));
 161
 162         col.setAlphaF(0.0);
 163         QPainter(this).fillRect(rect(), col);
 164     }
 165
 166     void resizeEvent(QResizeEvent *ev)
 167     {
 168         KToolBar::resizeEvent(ev);
 169         if(height()>theirHeight)
 170         {
 171             theirHeight=height();
 172             itsLinked->resize(itsLinked->width(), height());
 173         }
 174     }
 175
 176     private:
 177
 178     CToolBar  *itsLinked;
 179     static int theirHeight;
 180 };
 181
 182 class CProgressBar : public QProgressBar
 183 {
 184     public:
 185
 186     CProgressBar(QWidget *p, int h) : QProgressBar(p), itsHeight((int)(h*0.6))
 187         { setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed); }
 188
 189     virtual ~CProgressBar() { }
 190
 191     int height() const     { return itsHeight; }
 192     QSize sizeHint() const { return QSize(100, itsHeight); }
 193
 194     private:
 195
 196     int itsHeight;
 197 };
 198
 199 int CPushButton::theirHeight=0;
 200 int CToolBar::theirHeight=0;
 201
 202 CKCmFontInst::CKCmFontInst(QWidget *parent, const QVariantList&)
 203             : KCModule(FontInstallFactory::componentData(), parent),
 204               itsPreview(NULL),
 205               itsConfig(KFI_UI_CFG_FILE),
 206               itsJob(NULL),
 207               itsProgress(NULL),
 208               itsUpdateDialog(NULL),
 209               itsTempDir(NULL),
 210               itsPrintProc(NULL),
 211               itsExportFile(NULL)
 212 {
 213     setButtons(Help);
 214
 215     CFcEngine::instance()->readConfig(itsConfig);
 216     CFcEngine::setBgndCol(QApplication::palette().color(QPalette::Active, QPalette::Base));
 217     CFcEngine::setTextCol(QApplication::palette().color(QPalette::Active, QPalette::Text));
 218     KGlobal::locale()->insertCatalog(KFI_CATALOGUE);
 219     KIconLoader::global()->addAppDir(KFI_NAME);
 220
 221     KAboutData *about = new KAboutData("fontinst", 0, ki18n("KDE Font Installer"), 0, KLocalizedString(),
 222                                        KAboutData::License_GPL, ki18n("GUI front end to the fonts:/ ioslave.\n"
 223                                                                       "(c) Craig Drummond, 2000 - 2007"));
 224     about->addAuthor(ki18n("Craig Drummond"), ki18n("Developer and maintainer"), "craig@kde.org");
 225     setAboutData(about);
 226
 227     KConfigGroup cg(&itsConfig, CFG_GROUP);
 228
 229     itsRunner=new CJobRunner(this);
 230
 231     itsPreviewSplitter=new QSplitter(this);
 232     itsPreviewSplitter->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
 233
 234     QWidget     *controls=new QWidget(itsPreviewSplitter);
 235
 236     itsGroupSplitter=new QSplitter(controls);
 237     itsGroupSplitter->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
 238
 239     QStringList items;
 240     QBoxLayout  *mainLayout=new QBoxLayout(QBoxLayout::TopToBottom, this),
 241                 *controlLayout=new QBoxLayout(QBoxLayout::TopToBottom, controls);
 242
 243     itsGroupsWidget=new QWidget(itsGroupSplitter);
 244     itsFontsWidget=new QWidget(itsGroupSplitter);
 245     itsPreviewWidget=new QWidget(itsPreviewSplitter);
 246
 247     CToolBar    *toolbar=new CToolBar(this),
 248                 *previewToolbar=new CToolBar(itsPreviewWidget);
 249     QGridLayout *groupsLayout=new QGridLayout(itsGroupsWidget),
 250                 *fontsLayout=new QGridLayout(itsFontsWidget);
 251     QBoxLayout  *previewLayout=new QBoxLayout(QBoxLayout::TopToBottom, itsPreviewWidget);
 252
 253     controlLayout->setMargin(0);
 254     controlLayout->setSpacing(KDialog::spacingHint());
 255     mainLayout->setMargin(0);
 256     mainLayout->setSpacing(KDialog::spacingHint());
 257     groupsLayout->setMargin(0);
 258     groupsLayout->setSpacing(KDialog::spacingHint());
 259     fontsLayout->setMargin(0);
 260     fontsLayout->setSpacing(KDialog::spacingHint());
 261
 262     // Preview...
 263     itsPreviewControl=new CPreviewSelectAction(itsPreviewWidget);
 264
 265     previewToolbar->addAction(itsPreviewControl);
 266
 267     previewLayout->setMargin(0);
 268     previewLayout->setSpacing(KDialog::spacingHint());
 269
 270     QFrame     *previewFrame=new QFrame(itsPreviewWidget);
 271     QBoxLayout *previewFrameLayout=new QBoxLayout(QBoxLayout::LeftToRight, previewFrame);
 272
 273     previewFrameLayout->setMargin(0);
 274     previewFrameLayout->setSpacing(0);
 275     previewFrame->setFrameShape(QFrame::StyledPanel);
 276     previewFrame->setFrameShadow(QFrame::Sunken);
 277     previewFrame->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::MinimumExpanding);
 278
 279     itsPreview=new CFontPreview(previewFrame);
 280     itsPreview->setWhatsThis(i18n("This displays a preview of the selected font."));
 281     itsPreview->setContextMenuPolicy(Qt::CustomContextMenu);
 282     previewFrameLayout->addWidget(itsPreview);
 283
 284     // Toolbar...
 285     KActionMenu *settingsMenu=new KActionMenu(KIcon("configure"), i18n("Settings"), this);
 286     KAction     *changeTextAct=new KAction(KIcon("edit-rename"), i18n("Change Preview Text..."), this),
 287                 *duplicateFontsAct=new KAction(KIcon("system-search"), i18n("Scan For Duplicate Fonts..."), this);
 288                 //*validateFontsAct=new KAction(KIcon("checkmark"), i18n("Validate Fonts..."), this);
 289                 //*downloadFontsAct=new KAction(KIcon("go-down"), i18n("Download Fonts..."), this);
 290
 291     itsToolsMenu=new KActionMenu(KIcon("system-run"), i18n("Tools"), this);
 292     itsMgtMode=new KToggleAction(KIcon("preferences-desktop-font-installer"),
 293                                  i18n("Font Management Mode"), this),
 294     itsShowPreview=new KToggleAction(KIcon("view-preview"), i18n("Show Large Preview"), this);
 295     settingsMenu->addAction(itsMgtMode);
 296     itsMgtMode->setChecked(true);
 297     settingsMenu->addSeparator();
 298     settingsMenu->addAction(itsShowPreview);
 299     settingsMenu->addAction(changeTextAct);
 300     settingsMenu->setDelayed(false);
 301     itsToolsMenu->addAction(duplicateFontsAct);
 302     //itsToolsMenu->addAction(validateFontsAct);
 303     //itsToolsMenu->addAction(downloadFontsAct);
 304     itsToolsMenu->setDelayed(false);
 305     toolbar->addAction(settingsMenu);
 306     toolbar->addAction(itsToolsMenu);
 307     if(Misc::root())
 308         itsModeControl=NULL;
 309     else
 310     {
 311         itsModeControl=new QComboBox(toolbar);
 312         itsModeAct=toolbar->addWidget(itsModeControl);
 313         toolbar->addSeparator();
 314     }
 315
 316     itsFilter=new CFontFilter(toolbar);
 317     toolbar->addWidget(itsFilter);
 318
 319     // Details - Groups...
 320     itsGroupList=new CGroupList(itsGroupsWidget);
 321     itsGroupListView=new CGroupListView(itsGroupsWidget, itsGroupList);
 322
 323     if(itsModeControl)
 324         for(int i=0; i<3; ++i)
 325             itsModeControl->addItem(itsGroupList->group(modeToGrp(i))->name());
 326
 327     KPushButton *createGroup=new CPushButton(KGuiItem(QString(), "list-add",
 328                                                       i18n("Create a new group")),
 329                                              itsGroupsWidget);
 330
 331     itsDeleteGroupControl=new CPushButton(KGuiItem(QString(), "edit-delete",
 332                                                    i18n("Remove group")),
 333                                           itsGroupsWidget);
 334
 335     itsEnableGroupControl=new CPushButton(KGuiItem(QString(), "enablefont",
 336                                                    i18n("Enable all disabled fonts in the current group")),
 337                                           itsGroupsWidget);
 338
 339     itsDisableGroupControl=new CPushButton(KGuiItem(QString(), "disablefont",
 340                                                     i18n("Disable all enabled fonts in the current group")),
 341                                            itsGroupsWidget);
 342
 343     groupsLayout->addWidget(itsGroupListView, 0, 0, 1, 5);
 344     groupsLayout->addWidget(createGroup, 1, 0);
 345     groupsLayout->addWidget(itsDeleteGroupControl, 1, 1);
 346     groupsLayout->addWidget(itsEnableGroupControl, 1, 2);
 347     groupsLayout->addWidget(itsDisableGroupControl, 1, 3);
 348     groupsLayout->addItem(new QSpacerItem(itsDisableGroupControl->width(), KDialog::spacingHint(),
 349                           QSizePolicy::Expanding, QSizePolicy::Fixed), 1, 4);
 350     // Details - Fonts...
 351     itsFontList=new CFontList(itsFontsWidget);
 352     itsFontListView=new CFontListView(itsFontsWidget, itsFontList);
 353     itsFontListView->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
 354     itsFontListView->readConfig(cg);
 355
 356     itsAddFontControl=new CPushButton(KGuiItem(i18n("Add..."), "list-add",
 357                                                i18n("Install fonts")),
 358                                       itsFontsWidget);
 359
 360     itsDeleteFontControl=new CPushButton(KGuiItem(i18n("Delete..."), "edit-delete",
 361                                                   i18n("Delete all selected fonts")),
 362                                          itsFontsWidget);
 363
 364     itsEnableFontControl=new CPushButton(KGuiItem(i18n("Enable"), "enablefont",
 365                                                   i18n("Enable all selected fonts")),
 366                                          itsFontsWidget);
 367
 368     itsDisableFontControl=new CPushButton(KGuiItem(i18n("Disable"), "disablefont",
 369                                                    i18n("Disable all selected fonts")),
 370                                           itsFontsWidget);
 371
 372     fontsLayout->addWidget(itsFontListView, 0, 0, 1, 5);
 373     fontsLayout->addWidget(itsAddFontControl, 1, 0);
 374     fontsLayout->addWidget(itsDeleteFontControl, 1, 1);
 375     fontsLayout->addWidget(itsEnableFontControl, 1, 2);
 376     fontsLayout->addWidget(itsDisableFontControl, 1, 3);
 377     fontsLayout->addItem(new QSpacerItem(KDialog::spacingHint(), KDialog::spacingHint(),
 378                          QSizePolicy::Expanding, QSizePolicy::Fixed), 1, 4);
 379
 380     // Details - Status...
 381     QWidget    *statusWidget=new QWidget(this);
 382     QBoxLayout *statusLayout=new QBoxLayout(QBoxLayout::LeftToRight, statusWidget);
 383     itsStatusLabel = new QLabel(statusWidget);
 384     itsStatusLabel->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
 385     itsListingProgress=new CProgressBar(statusWidget, itsStatusLabel->height());
 386     itsListingProgress->setRange(0, 100);
 387     statusLayout->setMargin(0);
 388     statusLayout->setSpacing(KDialog::spacingHint());
 389     statusLayout->addWidget(itsStatusLabel);
 390     statusLayout->addItem(new QSpacerItem(0, itsListingProgress->height()+4,
 391                                           QSizePolicy::Fixed, QSizePolicy::Fixed));
 392     statusLayout->addWidget(itsListingProgress);
 393
 394     // Layout widgets...
 395     controlLayout->addWidget(toolbar);
 396     controlLayout->addWidget(itsGroupSplitter);
 397     mainLayout->addWidget(itsPreviewSplitter);
 398     mainLayout->addWidget(statusWidget);
 399     previewLayout->addWidget(previewToolbar);
 400     previewLayout->addWidget(previewFrame);
 401
 402     // Set size of widgets...
 403     itsPreviewSplitter->setChildrenCollapsible(false);
 404     itsGroupSplitter->setChildrenCollapsible(false);
 405     itsGroupSplitter->setStretchFactor(0, 0);
 406     itsGroupSplitter->setStretchFactor(1, 1);
 407     itsPreviewSplitter->setStretchFactor(0, 1);
 408     itsPreviewSplitter->setStretchFactor(1, 0);
 409
 410     toolbar->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
 411
 412     // Set sizes for 3 views...
 413     QList<int> defaultSizes;
 414
 415     defaultSizes+=450;
 416     defaultSizes+=150;
 417
 418     QList<int> sizes(cg.readEntry(CFG_PREVIEW_SPLITTER_SIZES, defaultSizes));
 419
 420     if(2!=sizes.count())
 421         sizes=defaultSizes;
 422
 423     itsPreviewSplitter->setSizes(sizes);
 424
 425     defaultSizes=QList<int>();
 426     defaultSizes+=100;
 427     defaultSizes+=350;
 428     sizes=cg.readEntry(CFG_GROUP_SPLITTER_SIZES, defaultSizes);
 429
 430     if(2!=sizes.count())
 431         sizes=defaultSizes;
 432
 433     itsGroupSplitter->setSizes(sizes);
 434
 435     // Connect signals...
 436     connect(itsFilter, SIGNAL(textChanged(const QString &)), itsFontListView, SLOT(filterText(const QString &)));
 437     connect(itsFilter, SIGNAL(criteriaChanged(int, qulonglong)), itsFontListView, SLOT(filterCriteria(int, qulonglong)));
 438     connect(itsGroupListView, SIGNAL(del()), SLOT(removeGroup()));
 439     connect(itsGroupListView, SIGNAL(print()), SLOT(printGroup()));
 440     connect(itsGroupListView, SIGNAL(enable()), SLOT(enableGroup()));
 441     connect(itsGroupListView, SIGNAL(disable()), SLOT(disableGroup()));
 442     connect(itsGroupListView, SIGNAL(copyFonts()), SLOT(copyFonts()));
 443     connect(itsGroupListView, SIGNAL(moveFonts()), SLOT(moveFonts()));
 444     connect(itsGroupListView, SIGNAL(itemSelected(const QModelIndex &)),
 445            SLOT(groupSelected(const QModelIndex &)));
 446     connect(itsGroupListView, SIGNAL(info(const QString &)),
 447            SLOT(showInfo(const QString &)));
 448     connect(itsGroupList, SIGNAL(refresh()), SLOT(refreshFontList()));
 449     connect(itsFontList, SIGNAL(started()), SLOT(listingStarted()));
 450     connect(itsFontList, SIGNAL(finished()), SLOT(listingCompleted()));
 451     connect(itsFontList, SIGNAL(percent(int)), itsListingProgress, SLOT(setValue(int)));
 452     connect(itsFontList, SIGNAL(status(const QString &)), itsStatusLabel,
 453             SLOT(setText(const QString &)));
 454     connect(itsFontListView, SIGNAL(del()), SLOT(deleteFonts()));
 455     connect(itsFontListView, SIGNAL(print()), SLOT(print()));
 456     connect(itsFontListView, SIGNAL(enable()), SLOT(enableFonts()));
 457     connect(itsFontListView, SIGNAL(disable()), SLOT(disableFonts()));
 458     connect(itsFontListView, SIGNAL(reload()), SLOT(reload()));
 459     connect(itsFontListView, SIGNAL(fontsDropped(const QSet<KUrl> &)),
 460            SLOT(addFonts(const QSet<KUrl> &)));
 461     connect(itsFontListView, SIGNAL(itemSelected(const QModelIndex &, bool, bool)),
 462            SLOT(fontSelected(const QModelIndex &, bool, bool)));
 463     connect(itsFontListView, SIGNAL(refresh()), SLOT(setStatusBar()));
 464     connect(itsGroupListView, SIGNAL(unclassifiedChanged()), itsFontListView, SLOT(refreshFilter()));
 465     connect(createGroup, SIGNAL(clicked()), SLOT(addGroup()));
 466     connect(itsDeleteGroupControl, SIGNAL(clicked()), SLOT(removeGroup()));
 467     connect(itsEnableGroupControl, SIGNAL(clicked()), SLOT(enableGroup()));
 468     connect(itsDisableGroupControl, SIGNAL(clicked()), SLOT(disableGroup()));
 469     connect(itsAddFontControl, SIGNAL(clicked()), SLOT(addFonts()));
 470     connect(itsDeleteFontControl, SIGNAL(clicked()), SLOT(deleteFonts()));
 471     connect(itsEnableFontControl, SIGNAL(clicked()), SLOT(enableFonts()));
 472     connect(itsDisableFontControl, SIGNAL(clicked()), SLOT(disableFonts()));
 473     connect(itsMgtMode, SIGNAL(toggled(bool)), SLOT(toggleFontManagement(bool)));
 474     connect(itsShowPreview, SIGNAL(toggled(bool)), SLOT(showPreview(bool)));
 475     connect(changeTextAct, SIGNAL(triggered(bool)), SLOT(changeText()));
 476     connect(itsPreviewControl, SIGNAL(range(const QList<CFcEngine::TRange> &)),
 477             itsPreview, SLOT(setUnicodeRange(const QList<CFcEngine::TRange> &)));
 478     connect(duplicateFontsAct, SIGNAL(triggered(bool)), SLOT(duplicateFonts()));
 479     //connect(validateFontsAct, SIGNAL(triggered(bool)), SLOT(validateFonts()));
 480     //connect(downloadFontsAct, SIGNAL(triggered(bool)), SLOT(downloadFonts()));
 481     if(itsModeControl)
 482         connect(itsModeControl, SIGNAL(activated(int)), SLOT(selectMode(int)));
 483
 484     itsMgtMode->setChecked(cg.readEntry(CFG_FONT_MGT_MODE, false));
 485     itsShowPreview->setChecked(cg.readEntry(CFG_SHOW_PREVIEW, false));
 486     showPreview(itsShowPreview->isChecked());
 487     itsPreviewWidget->setVisible(itsShowPreview->isChecked());
 488     toggleFontManagement(itsMgtMode->isChecked());
 489     selectMainGroup();
 490     itsFontList->scan();
 491
 492     toolbar->link(previewToolbar);
 493     previewToolbar->link(toolbar);
 494 }
 495
 496 CKCmFontInst::~CKCmFontInst()
 497 {
 498     KConfigGroup cg(&itsConfig, CFG_GROUP);
 499
 500     cg.writeEntry(CFG_PREVIEW_SPLITTER_SIZES, itsPreviewSplitter->sizes());
 501     cg.writeEntry(CFG_GROUP_SPLITTER_SIZES, itsGroupSplitter->sizes());
 502     cg.writeEntry(CFG_FONT_MGT_MODE, itsMgtMode->isChecked());
 503     cg.writeEntry(CFG_SHOW_PREVIEW, itsShowPreview->isChecked());
 504     itsFontListView->writeConfig(cg);
 505     delete itsTempDir;
 506     delete itsExportFile;
 507 }
 508
 509 QString CKCmFontInst::quickHelp() const
 510 {
 511     return Misc::root()
 512                ? i18n("<h1>Font Installer</h1><p> This module allows you to"
 513                       " install TrueType, Type1, and Bitmap"
 514                       " fonts.</p><p>You may also install fonts using Konqueror:"
 515                       " type fonts:/ into Konqueror's location bar"
 516                       " and this will display your installed fonts. To install a"
 517                       " font, simply copy one into the folder.</p>")
 518                : i18n("<h1>Font Installer</h1><p> This module allows you to"
 519                       " install TrueType, Type1, and Bitmap"
 520                       " fonts.</p><p>You may also install fonts using Konqueror:"
 521                       " type fonts:/ into Konqueror's location bar"
 522                       " and this will display your installed fonts. To install a"
 523                       " font, simply copy it into the appropriate folder - "
 524                       " \"%1\" for fonts available to just yourself, or "
 525                       " \"%2\" for system-wide fonts (available to all).</p>",
 526                       i18n(KFI_KIO_FONTS_USER), i18n(KFI_KIO_FONTS_SYS));
 527 }
 528
 529 void CKCmFontInst::fontSelected(const QModelIndex &index, bool en, bool dis)
 530 {
 531     itsDeleteFontControl->setEnabled(false);
 532     itsDisableFontControl->setEnabled(en);
 533     itsEnableFontControl->setEnabled(dis);
 534
 535     if(index.isValid())
 536     {
 537         CFontModelItem *mi=static_cast<CFontModelItem *>(index.internalPointer());
 538         CFontItem      *font=NULL;
 539
 540         if(mi->parent())
 541             font=static_cast<CFontItem *>(index.internalPointer());
 542         else
 543             font=(static_cast<CFamilyItem *>(index.internalPointer()))->regularFont();
 544
 545         if(font)
 546         {
 547             if(itsShowPreview->isChecked())
 548             {
 549                 KUrl url(font->isEnabled()
 550                             ? font->url()
 551                             : font->fileName().isEmpty()
 552                                 ? font->url() : KUrl::fromPath(font->fileName()));
 553
 554                 itsPreview->showFont(url, font->isEnabled() ? font->name() : QString(),
 555                                      font->styleInfo(), font->isEnabled() ? 1 : font->index());
 556             }
 557             itsDeleteFontControl->setEnabled(true);
 558         }
 559     }
 560 }
 561
 562 void CKCmFontInst::reload()
 563 {
 564     if(!working(false))
 565     {
 566         listingStarted();
 567         itsFontList->scan();
 568         itsGroupList->rescan();
 569     }
 570 }
 571
 572 void CKCmFontInst::addFonts()
 573 {
 574     if(!working())
 575     {
 576         QString filter("application/x-font-ttf application/x-font-otf "
 577                        "application/x-font-type1");
 578
 579         if(itsMgtMode->isChecked() && FC::bitmapsEnabled())
 580             filter+=" application/x-font-pcf application/x-font-bdf";
 581
 582         filter+=" fonts/package";
 583
 584         KUrl::List list=KFileDialog::getOpenUrls(KUrl(), filter, this, i18n("Add Fonts"));
 585
 586         if(list.count())
 587         {
 588             QSet<KUrl>           urls;
 589             KUrl::List::Iterator it(list.begin()),
 590                                  end(list.end());
 591
 592             for(; it!=end; ++it)
 593             {
 594                 if(KFI_KIO_FONTS_PROTOCOL!=(*it).protocol()) // Do not try to install from fonts:/ !!!
 595                 {
 596                     KUrl url(KIO::NetAccess::mostLocalUrl(*it, this));
 597
 598                     if(url.isLocalFile())
 599                     {
 600                         QString file(url.path());
 601
 602                         if(Misc::isPackage(file)) // If its a package we need to unzip 1st...
 603                         {
 604                             KZip zip(url.path());
 605
 606                             delete itsTempDir;
 607                             itsTempDir=NULL;
 608
 609                             if(zip.open(QIODevice::ReadOnly))
 610                             {
 611                                 const KArchiveDirectory *zipDir=zip.directory();
 612
 613                                 if(zipDir)
 614                                 {
 615                                     QStringList fonts(zipDir->entries());
 616
 617                                     if(fonts.count())
 618                                     {
 619                                         QStringList::ConstIterator it(fonts.begin()),
 620                                                                    end(fonts.end());
 621
 622                                         for(; it!=end; ++it)
 623                                         {
 624                                             const KArchiveEntry *entry=zipDir->entry(*it);
 625
 626                                             if(entry && entry->isFile())
 627                                             {
 628                                                 if(!itsTempDir)
 629                                                 {
 630                                                     itsTempDir=new KTempDir(KStandardDirs::locateLocal("tmp",
 631                                                                             KFI_TMP_DIR_PREFIX));
 632                                                     itsTempDir->setAutoRemove(true);
 633                                                 }
 634
 635                                                 ((KArchiveFile *)entry)->copyTo(itsTempDir->name());
 636
 637                                                 QString name(entry->name());
 638
 639                                                 //
 640                                                 // Cant install hidden fonts, therefore need to
 641                                                 // unhide 1st!
 642                                                 if(Misc::isHidden(name))
 643                                                 {
 644                                                     ::rename(QFile::encodeName(itsTempDir->name()+name).data(),
 645                                                              QFile::encodeName(itsTempDir->name()+name.mid(1)).data());
 646                                                     name=name.mid(1);
 647                                                 }
 648
 649                                                 KUrl url(itsTempDir->name()+name);
 650
 651                                                 if(!Misc::isMetrics(name))
 652                                                     urls.insert(url);
 653                                             }
 654                                         }
 655                                     }
 656                                 }
 657                             }
 658                         }
 659                         else if(!Misc::isMetrics(url))
 660                             urls.insert(url);
 661                     }
 662                     else if(!Misc::isMetrics(url))
 663                         urls.insert(url);
 664                 }
 665             }
 666             if(urls.count())
 667                 addFonts(urls);
 668         }
 669     }
 670 }
 671
 672 void CKCmFontInst::groupSelected(const QModelIndex &index)
 673 {
 674     CGroupListItem *grp=NULL;
 675
 676     if(index.isValid())
 677         grp=static_cast<CGroupListItem *>(index.internalPointer());
 678
 679     itsFontListView->setFilterGroup(grp);
 680     setStatusBar();
 681
 682     //
 683     // Check fonts listed within group are still valid!
 684     if(grp && grp->isCustom() && !grp->validated())
 685     {
 686         QSet<QString>           remList;
 687         QSet<QString>::Iterator it(grp->families().begin()),
 688                                 end(grp->families().end());
 689
 690         for(; it!=end; ++it)
 691             if(!itsFontList->hasFamily(*it))
 692                 remList.insert(*it);
 693         it=remList.begin();
 694         end=remList.end();
 695         for(; it!=end; ++it)
 696             itsGroupList->removeFromGroup(grp, *it);
 697         grp->setValidated();
 698     }
 699 }
 700
 701 void CKCmFontInst::print(bool all)
 702 {
 703     //
 704     // In order to support printing of newly installed/enabled fonts, the actual printing
 705     // is carried out by the kfontinst helper app. This way we know Qt's font list will be
 706     // up to date.
 707     if(!working() && (!itsPrintProc || QProcess::NotRunning==itsPrintProc->state()))
 708     {
 709         QString exe(KStandardDirs::findExe(QLatin1String(KFI_PRINTER), KStandardDirs::installPath("libexec")));
 710
 711         if(exe.isEmpty())
 712             KMessageBox::error(this, i18n("Failed to locate font printer."));
 713         else
 714         {
 715             QSet<Misc::TFont> fonts;
 716
 717             itsFontListView->getPrintableFonts(fonts, !all);
 718
 719             if(fonts.count())
 720             {
 721                 CPrintDialog dlg(this);
 722                 KConfigGroup cg(&itsConfig, CFG_GROUP);
 723
 724                 if(dlg.exec(cg.readEntry(CFG_FONT_SIZE, 1)))
 725                 {
 726                     static const int constSizes[]={0, 12, 18, 24, 36, 48};
 727                     QSet<Misc::TFont>::ConstIterator it(fonts.begin()),
 728                                                     end(fonts.end());
 729                     KTemporaryFile                   tmpFile;
 730                     bool                             useFile(fonts.count()>16),
 731                                                     startProc(true);
 732                     QStringList                      args;
 733
 734                     if(!itsPrintProc)
 735                         itsPrintProc=new QProcess(this);
 736                     else
 737                         itsPrintProc->kill();
 738
 739                     //
 740                     // If we have lots of fonts to print, pass kfontinst a tempory groups file to print
 741                     // instead of passing font by font...
 742                     if(useFile)
 743                     {
 744                         if(tmpFile.open())
 745                         {
 746                             QTextStream str(&tmpFile);
 747
 748                             for(; it!=end; ++it)
 749                                 str << (*it).family << endl
 750                                     << (*it).styleInfo << endl;
 751
 752                             args << "--embed" << QString().sprintf("0x%x", (unsigned int)window()->winId())
 753                                 << "--caption" << KGlobal::caption().toUtf8()
 754                                 << "--icon" << "preferences-desktop-font-installer"
 755                                 << "--size" << QString().setNum(constSizes[dlg.chosenSize() < 6 ? dlg.chosenSize() : 2])
 756                                 << "--listfile" << tmpFile.fileName()
 757                                 << "--deletefile";
 758                         }
 759                         else
 760                         {
 761                             KMessageBox::error(this, i18n("Failed to save list of fonts to print."));
 762                             startProc=false;
 763                         }
 764                     }
 765                     else
 766                     {
 767                         args << "--embed" << QString().sprintf("0x%x", (unsigned int)window()->winId())
 768                             << "--caption" << KGlobal::caption().toUtf8()
 769                             << "--icon" << "preferences-desktop-font-installer"
 770                             << "--size" << QString().setNum(constSizes[dlg.chosenSize()<6 ? dlg.chosenSize() : 2]);
 771
 772                         for(; it!=end; ++it)
 773                             args << "--pfont" << QString((*it).family.toUtf8()+','+QString().setNum((*it).styleInfo));
 774                     }
 775
 776                     if(startProc)
 777                     {
 778                         itsPrintProc->start(exe, args);
 779
 780                         if(itsPrintProc->waitForStarted(1000))
 781                         {
 782                             if(useFile)
 783                                 tmpFile.setAutoRemove(false);
 784                         }
 785                         else
 786                             KMessageBox::error(this, i18n("Failed to start font printer."));
 787                     }
 788                     cg.writeEntry(CFG_FONT_SIZE, dlg.chosenSize());
 789                 }
 790             }
 791             else
 792                 KMessageBox::information(this, i18n("There are no printable fonts.\n"
 793                                                     "You can only print non-bitmap and enabled fonts."),
 794                                          i18n("Cannot Print"));
 795         }
 796     }
 797 }
 798
 799 void CKCmFontInst::deleteFonts()
 800 {
 801     if(!working())
 802     {
 803         CJobRunner::ItemList urls;
 804         QStringList          fontNames;
 805         QSet<Misc::TFont>    fonts;
 806         bool                 hasSys(false);
 807
 808         itsDeletedFonts.clear();
 809         itsFontListView->getFonts(urls, fontNames, &fonts, &hasSys, true);
 810
 811         if(urls.isEmpty())
 812             KMessageBox::information(this, i18n("You did not select anything to delete."),
 813                                      i18n("Nothing to Delete"));
 814         else
 815         {
 816             QSet<Misc::TFont>::ConstIterator it(fonts.begin()),
 817                                              end(fonts.end());
 818             bool                             doIt=false;
 819
 820             for(; it!=end; ++it)
 821                 itsDeletedFonts.insert((*it).family);
 822
 823             switch(fontNames.count())
 824             {
 825                 case 0:
 826                     break;
 827                 case 1:
 828                     doIt = KMessageBox::Yes==KMessageBox::warningYesNo(this,
 829                             i18n("<p>Do you really want to "
 830                                     "delete</p><p>\'<b>%1</b>\'?</p>", fontNames.first()),
 831                             i18n("Delete Font"), KStandardGuiItem::del());
 832                 break;
 833                 default:
 834                     doIt = KMessageBox::Yes==KMessageBox::warningYesNoList(this,
 835                             i18np("Do you really want to delete this font?",
 836                                   "Do you really want to delete these %1 fonts?",
 837                                     fontNames.count()),
 838                             fontNames, i18n("Delete Fonts"), KStandardGuiItem::del());
 839             }
 840
 841             if(doIt && (!hasSys || itsRunner->getAdminPasswd(this)))
 842             {
 843                 itsStatusLabel->setText(i18n("Deleting font(s)..."));
 844                 doCmd(CJobRunner::CMD_DELETE, urls, KUrl());
 845             }
 846         }
 847     }
 848 }
 849
 850 void CKCmFontInst::copyFonts()
 851 {
 852     if(!working())
 853     {
 854         CJobRunner::ItemList urls;
 855         QStringList          fontNames;
 856         bool                 fromSys(itsGroupListView->isSystem());
 857
 858         itsDeletedFonts.clear();
 859         itsFontListView->getFonts(urls, fontNames, NULL, NULL, true);
 860
 861         if(urls.isEmpty())
 862             KMessageBox::information(this, i18n("You did not select anything to copy."),
 863                                      i18n("Nothing to Copy"));
 864         else
 865         {
 866             bool doIt=false;
 867
 868             switch(fontNames.count())
 869             {
 870                 case 0:
 871                     break;
 872                 case 1:
 873                     doIt = KMessageBox::Yes==KMessageBox::warningYesNo(this,
 874                             i18n("<p>Do you really want to "
 875                                     "copy</p><p>\'<b>%1</b>\'?</p>", fontNames.first()),
 876                             i18n("Copy Font"), KGuiItem(i18n("Copy")));
 877                 break;
 878                 default:
 879                     doIt = KMessageBox::Yes==KMessageBox::warningYesNoList(this,
 880                             i18np("Do you really want to copy this font?",
 881                                   "Do you really want to copy these %1 fonts?",
 882                                     fontNames.count()),
 883                             fontNames, i18n("Copy Fonts"), KGuiItem(i18n("Copy")));
 884             }
 885
 886             if(doIt && (fromSys || itsRunner->getAdminPasswd(this)))
 887             {
 888                 itsStatusLabel->setText(i18n("Copying font(s)..."));
 889                 doCmd(CJobRunner::CMD_COPY, urls, baseUrl(!fromSys));
 890             }
 891         }
 892     }
 893 }
 894
 895 void CKCmFontInst::moveFonts()
 896 {
 897     if(!working())
 898     {
 899         CJobRunner::ItemList urls;
 900         QStringList          fontNames;
 901
 902         itsDeletedFonts.clear();
 903         itsFontListView->getFonts(urls, fontNames, NULL, NULL, true);
 904
 905         if(urls.isEmpty())
 906             KMessageBox::information(this, i18n("You did not select anything to move."),
 907                                      i18n("Nothing to Move"));
 908         else
 909         {
 910             bool doIt=false;
 911
 912             switch(fontNames.count())
 913             {
 914                 case 0:
 915                     break;
 916                 case 1:
 917                     doIt = KMessageBox::Yes==KMessageBox::warningYesNo(this,
 918                             i18n("<p>Do you really want to "
 919                                     "move</p><p>\'<b>%1</b>\'?</p>", fontNames.first()),
 920                             i18n("Move Font"), KGuiItem(i18n("Move")));
 921                 break;
 922                 default:
 923                     doIt = KMessageBox::Yes==KMessageBox::warningYesNoList(this,
 924                             i18np("Do you really want to move this font?",
 925                                   "Do you really want to move these %1 fonts?",
 926                                     fontNames.count()),
 927                             fontNames, i18n("Move Fonts"), KGuiItem(i18n("Move")));
 928             }
 929
 930             if(doIt && itsRunner->getAdminPasswd(this))
 931             {
 932                 itsStatusLabel->setText(i18n("Moving font(s)..."));
 933                 doCmd(CJobRunner::CMD_MOVE, urls, baseUrl(!itsGroupListView->isSystem()));
 934             }
 935         }
 936     }
 937 }
 938
 939 void CKCmFontInst::enableFonts()
 940 {
 941     toggleFonts(true);
 942 }
 943
 944 void CKCmFontInst::disableFonts()
 945 {
 946     toggleFonts(false);
 947 }
 948
 949 void CKCmFontInst::addGroup()
 950 {
 951     bool    ok;
 952     QString name(KInputDialog::getText(i18n("Create New Group"),
 953                                        i18n("Please enter the name of the new group:"),
 954                                        i18n("New Group"), &ok, this));
 955
 956     if(ok && !name.isEmpty())
 957         itsGroupList->createGroup(name);
 958 }
 959
 960 void CKCmFontInst::removeGroup()
 961 {
 962     if(itsGroupList->removeGroup(itsGroupListView->currentIndex()))
 963         selectMainGroup();
 964 }
 965
 966 void CKCmFontInst::enableGroup()
 967 {
 968     toggleGroup(true);
 969 }
 970
 971 void CKCmFontInst::disableGroup()
 972 {
 973     toggleGroup(false);
 974 }
 975
 976 void CKCmFontInst::changeText()
 977 {
 978     if(!working())
 979     {
 980         bool             status;
 981         QRegExpValidator validator(QRegExp(".*"), 0L);
 982         QString          oldStr(CFcEngine::instance()->getPreviewString()),
 983                          newStr(KInputDialog::getText(i18n("Preview String"),
 984                                                       i18n("Please enter new string:"),
 985                                                       oldStr, &status, this, &validator));
 986
 987         if(status && oldStr!=newStr)
 988         {
 989             CFcEngine::instance()->setPreviewString(newStr);
 990             itsFontList->forceNewPreviews();
 991
 992             if(itsPreview->width()>6)
 993                 itsPreview->showFont();
 994         }
 995     }
 996 }
 997
 998 void CKCmFontInst::showPreview(bool s)
 999 {
1000     itsPreviewWidget->setVisible(s);
1001 }
1002
1003 void CKCmFontInst::duplicateFonts()
1004 {
1005     CDuplicatesDialog    dlg(this, itsRunner, itsFontList);
1006     CJobRunner::ItemList update;
1007
1008     dlg.exec();
1009
1010     if(dlg.modifiedUser())
1011         update.append(baseUrl(false));
1012     if(!Misc::root() && dlg.modifiedSys())
1013         update.append(baseUrl(true));
1014
1015     if(update.count())
1016         doCmd(CJobRunner::CMD_UPDATE, update, KUrl());
1017 }
1018
1019 //void CKCmFontInst::validateFonts()
1020 //{
1021 //}
1022
1023 //void CKCmFontInst::downloadFonts()
1024 //{
1025 //}
1026
1027 void CKCmFontInst::print()
1028 {
1029     print(false);
1030 }
1031
1032 void CKCmFontInst::printGroup()
1033 {
1034     print(true);
1035 }
1036
1037 void CKCmFontInst::listingStarted()
1038 {
1039     showInfo(i18n("Scanning font list..."));
1040     itsListingProgress->show();
1041 }
1042
1043 void CKCmFontInst::listingCompleted()
1044 {
1045     if(itsDeletedFonts.count())
1046     {
1047         QSet<QString>::Iterator it(itsDeletedFonts.begin()),
1048                                 end(itsDeletedFonts.end());
1049
1050         for(; it!=end; ++it)
1051             if(!itsFontList->hasFamily(*it))
1052                 itsGroupList->removeFamily(*it);
1053
1054         itsDeletedFonts.clear();
1055     }
1056
1057     QSet<QString> foundries;
1058
1059     itsFontList->getFoundries(foundries);
1060     itsFilter->setFoundries(foundries);
1061     refreshFamilies();
1062     itsListingProgress->hide();
1063     itsFontListView->selectFirstFont();
1064 }
1065
1066 void CKCmFontInst::refreshFontList()
1067 {
1068     itsFontListView->refreshFilter();
1069     refreshFamilies();
1070 }
1071
1072 void CKCmFontInst::refreshFamilies()
1073 {
1074     QSet<QString> enabledFamilies,
1075                   disabledFamilies,
1076                   partialFamilies;
1077
1078     itsFontList->getFamilyStats(enabledFamilies, disabledFamilies, partialFamilies);
1079     itsGroupList->updateStatus(enabledFamilies, disabledFamilies, partialFamilies);
1080     setStatusBar();
1081 }
1082
1083 void CKCmFontInst::showInfo(const QString &info)
1084 {
1085     if(info.isEmpty())
1086         if(itsLastStatusBarMsg.isEmpty())
1087             setStatusBar();
1088         else
1089         {
1090             itsStatusLabel->setText(itsLastStatusBarMsg);
1091             itsLastStatusBarMsg=QString();
1092         }
1093     else
1094     {
1095         if(itsLastStatusBarMsg.isEmpty())
1096             itsLastStatusBarMsg=itsStatusLabel->text();
1097         itsStatusLabel->setText(info);
1098     }
1099 }
1100
1101 void CKCmFontInst::setStatusBar()
1102 {
1103     int  enabled=0,
1104          disabled=0,
1105          partial=0;
1106     bool selectedEnabled=false,
1107          selectedDisabled=false;
1108
1109     if(0==itsFontList->families().count())
1110         itsStatusLabel->setText(i18n("No fonts"));
1111     else
1112     {
1113         itsFontListView->stats(enabled, disabled, partial);
1114         itsFontListView->selectedStatus(selectedEnabled, selectedDisabled);
1115
1116         QString text(i18np("1 Font", "%1 Fonts", enabled+disabled+partial));
1117
1118         if(disabled||partial)
1119             text+=i18n(" (%1 Enabled, %2 Disabled, %3 Partial)", enabled, disabled, partial);
1120
1121         itsStatusLabel->setText(text);
1122     }
1123
1124     CGroupListItem::EType type(itsGroupListView->getType());
1125
1126     bool isStd(CGroupListItem::CUSTOM==type);
1127
1128     itsAddFontControl->setEnabled(CGroupListItem::ALL==type||CGroupListItem::UNCLASSIFIED==type||
1129                                   CGroupListItem::PERSONAL==type||CGroupListItem::SYSTEM==type);
1130     itsDeleteGroupControl->setEnabled(isStd);
1131     itsEnableGroupControl->setEnabled(disabled||partial);
1132     itsDisableGroupControl->setEnabled(isStd && (enabled||partial));
1133
1134     itsGroupListView->controlMenu(itsDeleteGroupControl->isEnabled(),
1135                                   itsEnableGroupControl->isEnabled(),
1136                                   itsDisableGroupControl->isEnabled(), enabled||partial);
1137
1138     itsEnableFontControl->setEnabled(selectedDisabled);
1139     itsDisableFontControl->setEnabled(selectedEnabled);
1140     itsDeleteFontControl->setEnabled(selectedEnabled||selectedDisabled);
1141 }
1142
1143 void CKCmFontInst::addFonts(const QSet<KUrl> &src)
1144 {
1145     if(!working() && src.count() && !itsGroupListView->isCustom())
1146     {
1147         KUrl dest;
1148
1149         if(Misc::root())
1150             dest=baseUrl(true);
1151         else
1152         {
1153             switch(getCurrentGroupType())
1154             {
1155                 case CGroupListItem::ALL:
1156                 case CGroupListItem::UNCLASSIFIED:
1157                     switch(KMessageBox::questionYesNoCancel(this,
1158                            i18n("Do you wish to install the font(s) for personal use "
1159                                 "(only usable by you), or "
1160                                 "system-wide (usable by all users)?"),
1161                            i18n("Where to Install"), KGuiItem(i18n(KFI_KIO_FONTS_USER)),
1162                                 KGuiItem(i18n(KFI_KIO_FONTS_SYS))))
1163                     {
1164                         case KMessageBox::Yes:
1165                             dest=baseUrl(false);
1166                             break;
1167                         case KMessageBox::No:
1168                             if(itsRunner->getAdminPasswd(this))
1169                                 dest=baseUrl(true);
1170                             else if(KMessageBox::Yes==KMessageBox::questionYesNo(this,
1171                                     i18n("Would you like to install the font(s) for personal use?"),
1172                                     i18n("Authorization Failed")))
1173                                 dest=baseUrl(false);
1174                             else
1175                                 return;
1176                             break;
1177                         default:
1178                         case KMessageBox::Cancel:
1179                             return;
1180                     }
1181                     break;
1182                 case CGroupListItem::PERSONAL:
1183                     dest=baseUrl(false);
1184                     break;
1185                 case CGroupListItem::SYSTEM:
1186                     if(itsRunner->getAdminPasswd(this))
1187                         dest=baseUrl(true);
1188                     else if(KMessageBox::Yes==KMessageBox::questionYesNo(this,
1189                             i18n("Would you like to install the font(s) for personal use?"),
1190                             i18n("Authorization Failed")))
1191                         dest=baseUrl(false);
1192                     else
1193                         return;
1194                     break;
1195                 default:
1196                     return;
1197             }
1198         }
1199
1200         QSet<KUrl>                copy;
1201         QSet<KUrl>::ConstIterator it,
1202                                   end(src.end());
1203
1204         //
1205         // Check if font has any associated AFM or PFM file...
1206         itsStatusLabel->setText(i18n("Looking for any associated files..."));
1207
1208         if(!itsProgress)
1209         {
1210             itsProgress=new KProgressDialog(this, i18n("Scanning Files..."),
1211                                             i18n("Looking for additional files to install..."));
1212             itsProgress->setModal(true);
1213             itsProgress->setAutoReset(true);
1214             itsProgress->setAutoClose(true);
1215         }
1216
1217         itsProgress->setAllowCancel(false);
1218         itsProgress->setMinimumDuration(500);
1219         itsProgress->progressBar()->show();
1220         itsProgress->progressBar()->setRange(0, src.size());
1221         itsProgress->progressBar()->setValue(0);
1222
1223         int steps=src.count()<200 ? 1 : src.count()/10;
1224         for(it=src.begin(); it!=end; ++it)
1225         {
1226             KUrl::List associatedUrls;
1227
1228             itsProgress->setLabelText(i18n("Looking for files associated with %1", (*it).prettyUrl()));
1229             itsProgress->progressBar()->setValue(itsProgress->progressBar()->value()+1);
1230             if(1==steps || 0==(itsProgress->progressBar()->value()%steps))
1231             {
1232                 bool dialogVisible(itsProgress->isVisible());
1233                 QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
1234                 if(dialogVisible && !itsProgress->isVisible()) // User closed dialog! re-open!!!
1235                     itsProgress->show();
1236             }
1237
1238             CJobRunner::getAssociatedUrls(*it, associatedUrls, false, this);
1239             copy.insert(*it);
1240
1241             KUrl::List::Iterator aIt(associatedUrls.begin()),
1242                                  aEnd(associatedUrls.end());
1243
1244             for(; aIt!=aEnd; ++aIt)
1245                 copy.insert(*aIt);
1246         }
1247         itsProgress->close();
1248
1249         CJobRunner::ItemList installUrls;
1250
1251         end=copy.end();
1252         for(it=copy.begin(); it!=end; ++it)
1253             installUrls.append(*it);
1254
1255         itsStatusLabel->setText(i18n("Installing font(s)..."));
1256         doCmd(CJobRunner::CMD_INSTALL, installUrls, dest);
1257     }
1258 }
1259
1260 void CKCmFontInst::toggleFontManagement(bool on)
1261 {
1262     if(working())
1263         itsMgtMode->setChecked(!on);
1264     else
1265     {
1266         if(!on)
1267             itsPreviewControl->setStd();
1268         itsPreviewControl->setMode(on ? CPreviewSelectAction::ScriptsOnly : CPreviewSelectAction::Basic);
1269         itsToolsMenu->setVisible(on);
1270         itsFontListView->setMgtMode(on);
1271         itsFilter->setMgtMode(on);
1272         if(itsModeControl)
1273             itsModeAct->setVisible(!on);
1274         itsEnableFontControl->setVisible(on);
1275         itsDisableFontControl->setVisible(on);
1276         selectMainGroup();
1277         itsGroupsWidget->setVisible(on);
1278         setStatusBar();
1279     }
1280 }
1281
1282 void CKCmFontInst::selectMode(int mode)
1283 {
1284     selectGroup(modeToGrp(mode));
1285 }
1286
1287 void CKCmFontInst::selectGroup(CGroupListItem::EType grp)
1288 {
1289     QModelIndex current(itsGroupListView->currentIndex());
1290
1291     if(current.isValid())
1292     {
1293         CGroupListItem *grpItem=static_cast<CGroupListItem *>(current.internalPointer());
1294
1295         if(grpItem && grp==grpItem->type())
1296             return;
1297         else
1298             itsGroupListView->selectionModel()->select(current,
1299                                                        QItemSelectionModel::Deselect);
1300     }
1301
1302     QModelIndex idx(itsGroupList->index(grp));
1303
1304     itsGroupListView->selectionModel()->select(idx, QItemSelectionModel::Select);
1305     itsGroupListView->setCurrentIndex(idx);
1306     groupSelected(idx);
1307     itsFontListView->refreshFilter();
1308     setStatusBar();
1309 }
1310
1311 void CKCmFontInst::toggleGroup(bool enable)
1312 {
1313     QModelIndex idx(itsGroupListView->currentIndex());
1314
1315     if(idx.isValid())
1316     {
1317         CGroupListItem *grp=static_cast<CGroupListItem *>(idx.internalPointer());
1318
1319         if(grp)
1320             toggleFonts(enable, grp->name());
1321     }
1322 }
1323
1324 void CKCmFontInst::toggleFonts(bool enable, const QString &grp)
1325 {
1326     if(!working())
1327     {
1328         CJobRunner::ItemList urls;
1329         QStringList          fonts;
1330         bool                 hasSys(false);
1331
1332         itsFontListView->getFonts(urls, fonts, NULL, &hasSys, grp.isEmpty(), !enable, enable);
1333
1334         if(urls.isEmpty())
1335             KMessageBox::information(this,
1336                                      enable ? i18n("You did not select anything to enable.")
1337                                             : i18n("You did not select anything to disable."),
1338                                      enable ? i18n("Nothing to Enable") : i18n("Nothing to Disable"));
1339         else
1340             toggleFonts(urls, fonts, enable, grp, hasSys);
1341     }
1342 }
1343
1344 void CKCmFontInst::toggleFonts(CJobRunner::ItemList &urls, const QStringList &fonts, bool enable,
1345                                const QString &grp, bool hasSys)
1346 {
1347     bool doIt=false;
1348
1349     switch(fonts.count())
1350     {
1351         case 0:
1352             break;
1353         case 1:
1354             doIt = KMessageBox::Yes==KMessageBox::warningYesNo(this,
1355                        grp.isEmpty()
1356                             ? enable ? i18n("<p>Do you really want to "
1357                                             "enable</p><p>\'<b>%1</b>\'?</p>", fonts.first())
1358                                      : i18n("<p>Do you really want to "
1359                                             "disable</p><p>\'<b>%1</b>\'?</p>", fonts.first())
1360                             : enable ? i18n("<p>Do you really want to "
1361                                             "enable</p><p>\'<b>%1</b>\', "
1362                                             "contained within group \'<b>%2</b>\'?</p>",
1363                                             fonts.first(), grp)
1364                                      : i18n("<p>Do you really want to "
1365                                             "disable</p><p>\'<b>%1</b>\', "
1366                                             "contained within group \'<b>%2</b>\'?</p>",
1367                                             fonts.first(), grp),
1368                        enable ? i18n("Enable Font") : i18n("Disable Font"),
1369                        enable ? KGuiItem(i18n("Enable"), "enablefont", i18n("Enable font"))
1370                               : KGuiItem(i18n("Disable"), "disablefont", i18n("Disable font")));
1371             break;
1372         default:
1373             doIt = KMessageBox::Yes==KMessageBox::warningYesNoList(this,
1374                        grp.isEmpty()
1375                             ? enable ? i18np("Do you really want to enable this font?",
1376                                              "Do you really want to enable these %1 fonts?",
1377                                              urls.count())
1378                                      : i18np("Do you really want to disable this font?",
1379                                              "Do you really want to disable these %1 fonts?",
1380                                              urls.count())
1381                             : enable ? i18np("<p>Do you really want to enable this font "
1382                                              "contained within group \'<b>%2</b>\'?</p>",
1383                                              "<p>Do you really want to enable these %1 fonts "
1384                                              "contained within group \'<b>%2</b>\'?</p>",
1385                                              urls.count(), grp)
1386                                      : i18np("<p>Do you really want to disable this font "
1387                                              "contained within group \'<b>%2</b>\'?</p>",
1388                                              "<p>Do you really want to disable these %1 fonts "
1389                                              "contained within group \'<b>%2</b>\'?</p>",
1390                                              urls.count(), grp),
1391                        fonts,
1392                        enable ? i18n("Enable Fonts") : i18n("Disable Fonts"),
1393                        enable ? KGuiItem(i18n("Enable"), "enablefont", i18n("Enable fonts"))
1394                               : KGuiItem(i18n("Disable"), "disablefont", i18n("Disable fonts")));
1395     }
1396
1397     if(doIt && (!hasSys || itsRunner->getAdminPasswd(this)))
1398     {
1399         if(enable)
1400             itsStatusLabel->setText(i18n("Enabling font(s)..."));
1401         else
1402             itsStatusLabel->setText(i18n("Disabling font(s)..."));
1403
1404         doCmd(enable ? CJobRunner::CMD_ENABLE : CJobRunner::CMD_DISABLE, urls, KUrl());
1405     }
1406 }
1407
1408 bool CKCmFontInst::working(bool displayMsg)
1409 {
1410 return false;
1411     if(NULL!=itsJob || itsFontList->active())
1412     {
1413         if(displayMsg)
1414             KMessageBox::error(this, i18n("Sorry, the installer is currently busy. Please wait for the "
1415                                           "current operation to terminate."));
1416         return true;
1417     }
1418
1419     return false;
1420 }
1421
1422 KUrl CKCmFontInst::baseUrl(bool sys)
1423 {
1424     return Misc::root()
1425         ? KUrl(KFI_KIO_FONTS_PROTOCOL":/")
1426         : sys
1427             ? KUrl(KFI_KIO_FONTS_PROTOCOL":/"KFI_KIO_FONTS_SYS"/")
1428             : KUrl(KFI_KIO_FONTS_PROTOCOL":/"KFI_KIO_FONTS_USER"/");
1429 }
1430
1431 void CKCmFontInst::selectMainGroup()
1432 {
1433     selectGroup(/*Misc::root() || itsMgtMode->isChecked()
1434                     ? */CGroupListItem::ALL/* : CGroupListItem::PERSONAL*/);
1435     if(itsModeControl)
1436         itsModeControl->setCurrentIndex(grpToMode(/*Misc::root()
1437                                                     ? */CGroupListItem::ALL
1438                                                     /*: CGroupListItem::PERSONAL*/));
1439 }
1440
1441 void CKCmFontInst::doCmd(CJobRunner::ECommand cmd, const CJobRunner::ItemList &urls, const KUrl &dest)
1442 {
1443     itsFontList->setAutoUpdate(false);
1444     itsRunner->exec(cmd, urls, dest);
1445     CFcEngine::instance()->setDirty();
1446     setStatusBar();
1447     itsFontList->scan();
1448     itsFontList->setAutoUpdate(true);
1449     delete itsTempDir;
1450     itsTempDir=NULL;
1451 }
1452
1453 CGroupListItem::EType CKCmFontInst::getCurrentGroupType()
1454 {
1455     if(itsMgtMode->isChecked())
1456         return itsGroupListView->getType();
1457     else if(itsModeControl && itsModeControl->currentIndex() >= 0)
1458         return modeToGrp(itsModeControl->currentIndex());
1459
1460     return CGroupListItem::ALL;
1461 }
1462
1463 }
1464
1465 #include "KCmFontInst.moc"