workspace/kcontrol/kfontinst/lib/DisabledFonts.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 "DisabledFonts.h"
  25 #include "Fc.h"
  26 #include "Misc.h"
  27 #include "KfiConstants.h"
  28 #include <QtCore/QDir>
  29 #include <QtXml/QDomDocument>
  30 #include <QtXml/QDomElement>
  31 #include <QtXml/QDomNode>
  32 #include <QtCore/QFile>
  33 #include <QtCore/QTextStream>
  34 #include <QtCore/QTemporaryFile>
  35 #include <KDE/KLocale>
  36 #include <KDE/KStandardDirs>
  37 #include <fontconfig/fontconfig.h>
  38 #include <stdio.h>
  39 #include <unistd.h>
  40 #include <sys/types.h>
  41 #include <sys/stat.h>
  42 #include <fcntl.h>
  43 #include <errno.h>
  44 #include <signal.h>
  45
  46 namespace KFI
  47 {
  48
  49 #define FILE_NAME     "disabledfonts"
  50 #define DISABLED_DOC  "disabledfonts"
  51 #define FONT_TAG      "font"
  52 #define FILE_TAG      "file"
  53 #define PATH_ATTR     "path"
  54 #define FOUNDRY_ATTR  "foundry"
  55 #define FAMILY_ATTR   "family"
  56 #define WEIGHT_ATTR   "weight"
  57 #define WIDTH_ATTR    "width"
  58 #define SLANT_ATTR    "slant"
  59 #define FACE_ATTR     "face"
  60 #define LANGS_ATTR    "langs"
  61 #define LANG_SEP      ","
  62
  63 // Simple lock file class...
  64 class CLockFile
  65 {
  66     public:
  67
  68     CLockFile(const QString &fileName)
  69         : itsName(QFile::encodeName(fileName+".lock")),
  70           itsFd(-1)
  71     {
  72     }
  73
  74     ~CLockFile()
  75     {
  76         if(itsFd>=0)
  77         {
  78             close(itsFd);
  79             ::unlink(itsName.constData());
  80         }
  81     }
  82
  83     bool lock()
  84     {
  85         int pid(0);
  86
  87         itsFd=open(itsName.constData(), O_WRONLY|O_CREAT|O_EXCL, 0644);
  88
  89         if(itsFd<0 && EEXIST==errno)
  90         {
  91             // Open file read only to ascertain pid of process that currently is locking the file...
  92             int fd(open(itsName.constData(), O_RDONLY));
  93
  94             if(fd>=0)
  95             {
  96                 read(fd, &pid, sizeof(int));
  97                 close(fd);
  98
  99                 if(0==kill(pid, 0)) // Process is still alive, give it 5 seconds to release the lock...
 100                     sleep(5);
 101                 else // Process is not alive, remove file...
 102                     ::unlink(itsName.constData());
 103             }
 104             // else could not open file - perhaps it was removed in between the 2 open calls?
 105
 106             // Try to lock again...
 107             itsFd=open(itsName.constData(), O_WRONLY|O_CREAT|O_EXCL, 0644);
 108         }
 109
 110         if(itsFd<0)
 111             return false;
 112
 113         pid=getpid();
 114         write(itsFd, &pid, sizeof(int));
 115         return true;
 116     }
 117
 118     private:
 119
 120     QByteArray itsName;
 121     int        itsFd;
 122 };
 123
 124 static QString changeName(const QString &f, bool enable)
 125 {
 126     QString file(Misc::getFile(f)),
 127             dest;
 128
 129     if(enable && Misc::isHidden(file))
 130         dest=Misc::getDir(f)+file.mid(1);
 131     else if (!enable && !Misc::isHidden(file))
 132         dest=Misc::getDir(f)+QChar('.')+file;
 133     else
 134         dest=f;
 135     return dest;
 136 }
 137
 138 static bool changeFileStatus(const QString &f, bool enable)
 139 {
 140     QString dest(changeName(f, enable));
 141
 142     if(dest==f)  // File is already enabled/disabled
 143         return true;
 144
 145     if(Misc::fExists(dest) && !Misc::fExists(f)) // File is already enabled/disabled
 146         return true;
 147
 148     if(0==::rename(QFile::encodeName(f).data(), QFile::encodeName(dest).data()))
 149     {
 150         QStringList files;
 151
 152         Misc::getAssociatedFiles(f, files);
 153
 154         if(files.count())
 155         {
 156             QStringList::const_iterator fIt,
 157                                   fEnd=files.constEnd();
 158
 159             for(fIt=files.constBegin(); fIt!=fEnd; ++fIt)
 160                 ::rename(QFile::encodeName(*fIt).data(),
 161                          QFile::encodeName(changeName(*fIt, enable)).data());
 162         }
 163         return true;
 164     }
 165     return false;
 166 }
 167
 168 static bool changeStatus(const CDisabledFonts::TFileList &files, bool enable)
 169 {
 170     QStringList                         mods;
 171     CDisabledFonts::TFileList::ConstIterator it(files.begin()),
 172                                         end(files.end());
 173
 174     for(; it!=end; ++it)
 175         if(changeFileStatus((*it).path, enable))
 176             mods.append((*it).path);
 177         else
 178             break;
 179
 180     if(mods.count()!=files.count())
 181     {
 182         //
 183         // Failed to enable/disable a file - so need to revert any
 184         // previous changes...
 185         QStringList::ConstIterator sit(mods.begin()),
 186                                    send(mods.end());
 187         for(; sit!=send; ++sit)
 188             changeFileStatus(*sit, !enable);
 189         return false;
 190     }
 191     return true;
 192 }
 193
 194 CDisabledFonts::LangWritingSystemMap CDisabledFonts::theirLanguageForWritingSystem[]=
 195 {
 196     { QFontDatabase::Latin, (const FcChar8 *)"en" },
 197     { QFontDatabase::Greek, (const FcChar8 *)"el" },
 198     { QFontDatabase::Cyrillic, (const FcChar8 *)"ru" },
 199     { QFontDatabase::Armenian, (const FcChar8 *)"hy" },
 200     { QFontDatabase::Hebrew, (const FcChar8 *)"he" },
 201     { QFontDatabase::Arabic, (const FcChar8 *)"ar" },
 202     { QFontDatabase::Syriac, (const FcChar8 *)"syr" },
 203     { QFontDatabase::Thaana, (const FcChar8 *)"div" },
 204     { QFontDatabase::Devanagari, (const FcChar8 *)"hi" },
 205     { QFontDatabase::Bengali, (const FcChar8 *)"bn" },
 206     { QFontDatabase::Gurmukhi, (const FcChar8 *)"pa" },
 207     { QFontDatabase::Gujarati, (const FcChar8 *)"gu" },
 208     { QFontDatabase::Oriya, (const FcChar8 *)"or" },
 209     { QFontDatabase::Tamil, (const FcChar8 *)"ta" },
 210     { QFontDatabase::Telugu, (const FcChar8 *)"te" },
 211     { QFontDatabase::Kannada, (const FcChar8 *)"kn" },
 212     { QFontDatabase::Malayalam, (const FcChar8 *)"ml" },
 213     { QFontDatabase::Sinhala, (const FcChar8 *)"si" },
 214     { QFontDatabase::Thai, (const FcChar8 *)"th" },
 215     { QFontDatabase::Lao, (const FcChar8 *)"lo" },
 216     { QFontDatabase::Tibetan, (const FcChar8 *)"bo" },
 217     { QFontDatabase::Myanmar, (const FcChar8 *)"my" },
 218     { QFontDatabase::Georgian, (const FcChar8 *)"ka" },
 219     { QFontDatabase::Khmer, (const FcChar8 *)"km" },
 220     { QFontDatabase::SimplifiedChinese, (const FcChar8 *)"zh-cn" },
 221     { QFontDatabase::TraditionalChinese, (const FcChar8 *)"zh-tw" },
 222     { QFontDatabase::Japanese, (const FcChar8 *)"ja" },
 223     { QFontDatabase::Korean, (const FcChar8 *)"ko" },
 224     { QFontDatabase::Vietnamese, (const FcChar8 *)"vi" },
 225     { QFontDatabase::Other, NULL },
 226
 227     // The following is only used to save writing system data for disabled fonts...
 228     { QFontDatabase::Telugu, (const FcChar8 *)"Qt-Telugu" },
 229     { QFontDatabase::Kannada, (const FcChar8 *)"Qt-Kannada" },
 230     { QFontDatabase::Malayalam, (const FcChar8 *)"Qt-Malayalam" },
 231     { QFontDatabase::Sinhala, (const FcChar8 *)"Qt-Sinhala" },
 232     { QFontDatabase::Myanmar, (const FcChar8 *)"Qt-Myanmar" },
 233     { QFontDatabase::Ogham, (const FcChar8 *)"Qt-Ogham" },
 234     { QFontDatabase::Runic, (const FcChar8 *)"Qt-Runic" },
 235
 236     { QFontDatabase::Any, NULL }
 237 };
 238
 239 // Cache qstring->ws value
 240
 241 static QMap<QString, qulonglong> constWritingSystemMap;
 242
 243 void CDisabledFonts::createWritingSystemMap()
 244 {
 245     // check if we have created the cache yet...
 246     if(constWritingSystemMap.isEmpty())
 247         for(int i=0; QFontDatabase::Any!=theirLanguageForWritingSystem[i].ws; ++i)
 248             if(theirLanguageForWritingSystem[i].lang)
 249                 constWritingSystemMap[(const char *)theirLanguageForWritingSystem[i].lang]=
 250                     ((qulonglong)1)<<theirLanguageForWritingSystem[i].ws;
 251 }
 252
 253 CDisabledFonts::CDisabledFonts(bool sys)
 254               : itsTimeStamp(0),
 255                 itsModified(false),
 256                 itsMods(0)
 257 {
 258     QString path;
 259
 260     createWritingSystemMap();
 261
 262     if(Misc::root() || sys)
 263         path=KFI_ROOT_CFG_DIR;
 264     else
 265     {
 266         path=KGlobal::dirs()->localxdgconfdir();
 267
 268         if(!Misc::dExists(path))
 269             Misc::createDir(path);
 270     }
 271
 272     itsFileName=path+'/'+FILE_NAME".xml";
 273
 274     itsModifiable=Misc::fWritable(itsFileName) ||
 275                   (!Misc::fExists(itsFileName) && Misc::dWritable(Misc::getDir(itsFileName)));
 276
 277     load();
 278     if(itsModified)
 279         save();
 280 }
 281
 282 void CDisabledFonts::reload()
 283 {
 284     save();
 285     itsTimeStamp=0;
 286     load();
 287     save(); // This will only do a second save, if the 'load' set the modfified flag...
 288 }
 289
 290 bool CDisabledFonts::refresh()
 291 {
 292     time_t ts=Misc::getTimeStamp(itsFileName);
 293
 294     if(!ts || ts!=itsTimeStamp)
 295     {
 296         save();
 297         load();
 298         return true;
 299     }
 300     return false;
 301 }
 302
 303 //
 304 // Do not always lock during a load, as we may be trying to read global file (but not as root),
 305 // or this load might be being called within the save() - so cant lock as is already!
 306 void CDisabledFonts::load(bool lock)
 307 {
 308     CLockFile lf(itsFileName);
 309
 310     lock=lock && itsModifiable;
 311
 312     if(!lock || lf.lock())
 313     {
 314         time_t ts=Misc::getTimeStamp(itsFileName);
 315
 316         if(!ts || ts!=itsTimeStamp)
 317         {
 318             itsTimeStamp=ts;
 319
 320             QFile f(itsFileName);
 321
 322             if(f.open(QIODevice::ReadOnly))
 323             {
 324                 itsFonts.clear();
 325                 itsModified=false;
 326
 327                 QDomDocument doc;
 328
 329                 if(doc.setContent(&f))
 330                     for(QDomNode n=doc.documentElement().firstChild(); !n.isNull(); n=n.nextSibling())
 331                     {
 332                         QDomElement e=n.toElement();
 333
 334                         if(FONT_TAG==e.tagName())
 335                         {
 336                             TFont font;
 337
 338                             if(font.load(e, itsModified))
 339                                 itsFonts.add(font);
 340                             else
 341                                 itsModified=true;
 342                         }
 343                     }
 344
 345                 f.close();
 346             }
 347         }
 348     }
 349 }
 350
 351 bool CDisabledFonts::save()
 352 {
 353     bool rv(true);
 354
 355     if(itsModified)
 356     {
 357         CLockFile lf(itsFileName);
 358
 359         if(lf.lock())
 360         {
 361             time_t ts=Misc::getTimeStamp(itsFileName);
 362
 363             if(Misc::fExists(itsFileName) && ts!=itsTimeStamp)
 364             {
 365                 // Timestamps differ, so possibly file was modified by another process...
 366                 merge(CDisabledFonts(*this));
 367             }
 368
 369             QTemporaryFile temp(itsFileName);
 370
 371             temp.setAutoRemove(false);
 372
 373             if(!temp.open())
 374                 return false;
 375
 376             QFile file(temp.fileName());
 377
 378             if(!file.open(QIODevice::WriteOnly))
 379             {
 380                 temp.setAutoRemove(true);
 381                 return false;
 382             }
 383
 384             QTextStream str(&file);
 385
 386             str << "<"DISABLED_DOC">" << endl;
 387
 388             TFontList::Iterator it(itsFonts.begin()),
 389                                 end(itsFonts.end());
 390
 391             for(; it!=end; ++it)
 392                 str << (*it);
 393             str << "</"DISABLED_DOC">" << endl;
 394             itsModified=false;
 395             file.setPermissions(QFile::ReadOwner|QFile::WriteOwner|
 396                                 QFile::ReadGroup|QFile::ReadOther);
 397             file.close();
 398             rv=::rename(QFile::encodeName(file.fileName()), QFile::encodeName(itsFileName));
 399             if(rv)
 400             {
 401                 itsTimeStamp=Misc::getTimeStamp(itsFileName);
 402                 itsMods=0;
 403             }
 404         }
 405     }
 406
 407     return rv;
 408 }
 409
 410 static QString expandHome(const QString &path)
 411 {
 412         QString mpath = path;
 413     return !mpath.isEmpty() && '~'==mpath[0]
 414         ? 1==mpath.length() ? QDir::homePath() : mpath.replace(0, 1, QDir::homePath())
 415         : mpath;
 416 }
 417
 418 bool CDisabledFonts::TFile::load(QDomElement &elem)
 419 {
 420     if(elem.hasAttribute(PATH_ATTR))
 421     {
 422         bool ok(false);
 423
 424         path=expandHome(elem.attribute(PATH_ATTR));
 425         foundry=elem.attribute(FOUNDRY_ATTR);
 426
 427         if(elem.hasAttribute(FACE_ATTR))
 428             face=elem.attribute(FACE_ATTR).toInt(&ok);
 429
 430         if(!ok || face<0)
 431             face=0;
 432         return Misc::fExists(path);
 433     }
 434
 435     return false;
 436 }
 437
 438 QString CDisabledFonts::TFileList::toString(bool skipFirst) const
 439 {
 440     QString       s;
 441     QTextStream   str(&s, QIODevice::WriteOnly);
 442     ConstIterator it(begin()),
 443                   e(end());
 444
 445     if(skipFirst && it!=e)
 446         ++it;
 447
 448     for(; it!=e; ++it)
 449         str << (*it).path << endl
 450             << (*it).foundry << endl
 451             << (*it).face << endl;
 452
 453     return s;
 454 }
 455
 456 void CDisabledFonts::TFileList::fromString(QString &s)
 457 {
 458     clear();
 459     QTextStream str(&s, QIODevice::ReadOnly);
 460
 461     while(!str.atEnd())
 462     {
 463         QString path(str.readLine()),
 464                 foundry(str.readLine()),
 465                 face(str.readLine());
 466
 467         if(face.isEmpty())
 468             break;
 469         else
 470             append(TFile(path, face.toInt(), foundry));
 471     }
 472 }
 473
 474 bool CDisabledFonts::TFont::load(QDomElement &elem, bool &modified)
 475 {
 476     if(elem.hasAttribute(FAMILY_ATTR))
 477     {
 478         bool ok(false);
 479         int  weight(KFI_NULL_SETTING), width(KFI_NULL_SETTING), slant(KFI_NULL_SETTING),
 480              tmp(KFI_NULL_SETTING);
 481
 482         family=elem.attribute(FAMILY_ATTR);
 483
 484         if(elem.hasAttribute(WEIGHT_ATTR))
 485         {
 486             tmp=elem.attribute(WEIGHT_ATTR).toInt(&ok);
 487             if(ok)
 488                 weight=tmp;
 489         }
 490         if(elem.hasAttribute(WIDTH_ATTR))
 491         {
 492             tmp=elem.attribute(WIDTH_ATTR).toInt(&ok);
 493             if(ok)
 494                 width=tmp;
 495         }
 496
 497         if(elem.hasAttribute(SLANT_ATTR))
 498         {
 499             tmp=elem.attribute(SLANT_ATTR).toInt(&ok);
 500             if(ok)
 501                 slant=tmp;
 502         }
 503
 504         styleInfo=FC::createStyleVal(weight, width, slant);
 505
 506         if(elem.hasAttribute(LANGS_ATTR))
 507         {
 508             QStringList langs(elem.attribute(LANGS_ATTR).split(LANG_SEP, QString::SkipEmptyParts));
 509
 510             QStringList::ConstIterator it(langs.begin()),
 511                                        end(langs.end());
 512
 513             for(; it!=end; ++it)
 514                 writingSystems|=constWritingSystemMap[*it];
 515         }
 516
 517         if(elem.hasAttribute(PATH_ATTR))
 518         {
 519             TFile file;
 520
 521             if(file.load(elem))
 522                 files.add(file);
 523             else
 524                 modified=true;
 525         }
 526         else
 527             for(QDomNode n=elem.firstChild(); !n.isNull(); n=n.nextSibling())
 528             {
 529                 QDomElement ent=n.toElement();
 530
 531                 if(FILE_TAG==ent.tagName())
 532                 {
 533                     TFile file;
 534
 535                     if(file.load(ent))
 536                         files.add(file);
 537                     else
 538                         modified=true;
 539                 }
 540             }
 541
 542         return files.count()>0;
 543     }
 544
 545     return false;
 546 }
 547
 548 const QString & CDisabledFonts::TFont::getName() const
 549 {
 550     if(name.isEmpty())
 551         name=FC::createName(family, styleInfo);
 552     return name;
 553 }
 554
 555 CDisabledFonts::TFontList::Iterator CDisabledFonts::TFontList::locate(const TFont &t)
 556 {
 557     return find(t);
 558 }
 559
 560 CDisabledFonts::TFontList::Iterator CDisabledFonts::TFontList::locate(const Misc::TFont &t)
 561 {
 562     return locate((TFont &)t);
 563 }
 564
 565 void CDisabledFonts::TFontList::add(const TFont &t) const
 566 {
 567     (const_cast<TFontList *>(this))->insert(t);
 568 }
 569
 570 bool CDisabledFonts::disable(const TFont &font)
 571 {
 572     static const int constMaxMods=100;
 573
 574     TFontList::Iterator it=itsFonts.locate(font);
 575
 576     if(it==itsFonts.end())
 577     {
 578         TFont newFont(font.family, font.styleInfo, font.writingSystems);
 579
 580         if(changeStatus(font.files, false))
 581         {
 582             TFileList::ConstIterator it(font.files.begin()),
 583                                      end(font.files.end());
 584
 585             for(; it!=end; ++it)
 586                 newFont.files.add(TFile(changeName((*it).path, false), (*it).face, (*it).foundry));
 587
 588             itsFonts.add(newFont);
 589             itsModified=true;
 590
 591             if(++itsMods>constMaxMods)
 592                 save();
 593             return true;
 594         }
 595         else
 596         {
 597             TFileList::ConstIterator it(font.files.begin()),
 598                                      end(font.files.end());
 599
 600             for(; it!=end; ++it)
 601             {
 602                 QString modName(changeName((*it).path, false));
 603                 if(Misc::fExists(modName))
 604                     newFont.files.add(TFile(modName, (*it).face, (*it).foundry));
 605                 else
 606                     break;
 607             }
 608
 609             if(newFont.files.count()==font.files.count())
 610             {
 611                 itsFonts.add(newFont);
 612                 itsModified=true;
 613                 if(++itsMods>constMaxMods)
 614                     save();
 615                 return true;
 616             }
 617         }
 618     }
 619     else
 620         return true; // Already disabled...
 621
 622     return false;
 623 }
 624
 625 bool CDisabledFonts::enable(TFontList::Iterator font)
 626 {
 627     if(font!=itsFonts.end())
 628     {
 629         if(changeStatus((*font).files, true))
 630         {
 631             itsFonts.erase(font);
 632             itsModified=true;
 633             return true;
 634         }
 635         else
 636         {
 637             QStringList              mod;
 638             TFileList::ConstIterator fit((*font).files.begin()),
 639                                      fend((*font).files.end());
 640
 641             for(; fit!=fend; ++fit)
 642             {
 643                 QString modName(changeName((*fit).path, true));
 644                 if(Misc::fExists(modName))
 645                     mod.append((*fit).path);
 646                 else
 647                     break;
 648             }
 649
 650             if(mod.count()==(*font).files.count())
 651             {
 652                 itsFonts.erase(font);
 653                 itsModified=true;
 654                 return true;
 655             }
 656         }
 657     }
 658     else
 659         return true; // Already enabled...
 660
 661     return false;
 662 }
 663
 664 CDisabledFonts::TFontList::Iterator CDisabledFonts::find(const QString &name, int face)
 665 {
 666     TFontList::Iterator it(itsFonts.begin()),
 667                         end(itsFonts.end());
 668     QString             fontName(name);
 669
 670     if('.'==fontName[0])
 671         fontName=fontName.mid(1);
 672
 673     for(; it!=end; ++it)
 674         if((*it).getName()==fontName)
 675             break;
 676
 677     if(it==end && '.'==name[0])
 678         for(it=itsFonts.begin(); it!=end ; ++it)
 679         {
 680             TFileList::ConstIterator fit((*it).files.begin()),
 681                                      fend((*it).files.end());
 682
 683             for(; fit!=fend; ++fit)
 684                 if(Misc::getFile((*fit).path)==name && (*fit).face==face)
 685                     return it;
 686         }
 687     return it;
 688 }
 689
 690 //
 691 // This constrcutor is only used internally, and is called in ::save() when it has been
 692 // detected that the file has been modified by another process...
 693 CDisabledFonts::CDisabledFonts(const CDisabledFonts &o)
 694               : itsFileName(o.itsFileName),
 695                 itsTimeStamp(o.itsTimeStamp),
 696                 itsModified(false),
 697                 itsModifiable(false)
 698 {
 699     load(false);
 700 }
 701
 702 void CDisabledFonts::merge(const CDisabledFonts &other)
 703 {
 704     TFontList::ConstIterator it(other.itsFonts.begin()),
 705                              end(other.itsFonts.end());
 706
 707     for(; it!=end; ++it)
 708     {
 709         TFontList::Iterator existing(itsFonts.locate(*it));
 710
 711         if(existing!=itsFonts.end())
 712         {
 713             TFileList::ConstIterator fit((*it).files.begin()),
 714                                      fend((*it).files.end());
 715
 716             for(; fit!=fend; ++fit)
 717                 if(!(*existing).files.contains(*fit))
 718                 {
 719                     (*existing).files.add(*fit);
 720                     itsModified=true;
 721                 }
 722         }
 723         else
 724         {
 725             itsFonts.add(*it);
 726             itsModified=true;
 727         }
 728     }
 729 }
 730
 731 }
 732
 733 QTextStream & operator<<(QTextStream &s, const KFI::CDisabledFonts::TFile &f)
 734 {
 735     s << PATH_ATTR"=\"" << KFI::Misc::encodeText(KFI::Misc::contractHome(f.path), s) << "\" "
 736       << FOUNDRY_ATTR"=\"" << KFI::Misc::encodeText(f.foundry, s) << "\" ";
 737
 738     if(f.face>0)
 739         s << FACE_ATTR"=\"" << f.face << "\" ";
 740
 741     return s;
 742 }
 743
 744 QTextStream & operator<<(QTextStream &s, const KFI::CDisabledFonts::TFont &f)
 745 {
 746     int weight, width, slant;
 747
 748     KFI::FC::decomposeStyleVal(f.styleInfo, weight, width, slant);
 749
 750     s << " <"FONT_TAG" "FAMILY_ATTR"=\"" << KFI::Misc::encodeText(f.family, s) << "\" ";
 751
 752     if(KFI_NULL_SETTING!=weight)
 753         s << WEIGHT_ATTR"=\"" << weight << "\" ";
 754     if(KFI_NULL_SETTING!=width)
 755         s << WIDTH_ATTR"=\"" << width << "\" ";
 756     if(KFI_NULL_SETTING!=slant)
 757         s << SLANT_ATTR"=\"" << slant << "\" ";
 758
 759     QStringList                              ws;
 760     QMap<QString, qulonglong>::ConstIterator wit(KFI::constWritingSystemMap.begin()),
 761                                              wend(KFI::constWritingSystemMap.end());
 762
 763     for(; wit!=wend; ++wit)
 764         if(f.writingSystems&wit.value())
 765             ws+=wit.key();
 766
 767     if(ws.count())
 768         s << LANGS_ATTR"=\"" << ws.join(LANG_SEP) << "\" ";
 769
 770     if(1==f.files.count())
 771         s << *(f.files.begin()) << "/>" << endl;
 772     else
 773     {
 774         KFI::CDisabledFonts::TFileList::ConstIterator it(f.files.begin()),
 775                                                       end(f.files.end());
 776
 777         s << '>' << endl;
 778         for(; it!=end; ++it)
 779             s << "  <"FILE_TAG" " << *it << "/>" << endl;
 780         s << " </"FONT_TAG">" << endl;
 781     }
 782
 783     return s;
 784 }