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