Fix FTBFS

10 files changed, 0 insertions, 2973 deletions

diff --git a/kcontrol/kfontinst/kfontinst/CMakeLists.txt b/kcontrol/kfontinst/kfontinst/CMakeLists.txt
deleted file mode 100644
index fdcb51b15..000000000
--- a/kcontrol/kfontinst/kfontinst/CMakeLists.txt
+++ /dev/null
@@ -1,36 +0,0 @@
-#################################################
-#
-#  (C) 2010-2011 Serghei Amelian
-#  serghei (DOT) amelian (AT) gmail.com
-#
-#  Improvements and feedback are welcome
-#
-#  This file is released under GPL >= 2
-#
-#################################################
-
-add_definitions( -DOS_${CMAKE_SYSTEM_NAME} )
-
-include_directories(
-  ${CMAKE_BINARY_DIR}
-  ${CMAKE_SOURCE_DIR}/kcontrol/kfontinst/lib
-  ${CMAKE_SOURCE_DIR}/kcontrol/fonts/
-  ${TDE_INCLUDE_DIR}
-  ${TQT_INCLUDE_DIRS}
-  ${FREETYPE_INCLUDE_DIRS}
-)
-
-link_directories(
-  ${TQT_LIBRARY_DIRS}
-)
-
-
-##### kfontinst (executable) ####################
-
-tde_add_executable( kfontinst
-  SOURCES
-    Main.cpp FontEngine.cpp Fontmap.cpp GetPid.c
-    XConfig.cpp
-  LINK kxftconfig-static kfontinst-shared tdeio-shared
-  DESTINATION ${BIN_INSTALL_DIR}
-)
diff --git a/kcontrol/kfontinst/kfontinst/FontEngine.cpp b/kcontrol/kfontinst/kfontinst/FontEngine.cpp
deleted file mode 100644
index 4fe823c23..000000000
--- a/kcontrol/kfontinst/kfontinst/FontEngine.cpp
+++ /dev/null
@@ -1,376 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// Class Name    : KFI::CFontEngine
-// Author        : Craig Drummond
-// Project       : K Font Installer
-// Creation Date : 29/04/2001
-// Version       : $Revision$ $Date$
-//
-////////////////////////////////////////////////////////////////////////////////
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-//
-////////////////////////////////////////////////////////////////////////////////
-// (C) Craig Drummond, 2001, 2002, 2003, 2004
-////////////////////////////////////////////////////////////////////////////////
-
-
-#include "FontEngine.h"
-#include "Misc.h"
-#include <kglobal.h>
-#include <ctype.h>
-#include <string.h>
-#include <stdlib.h>
-#include <iostream>
-#include <stdio.h>
-#include <tqregexp.h>
-#include <tqfile.h>
-#include <ft2build.h>
-#include FT_SFNT_NAMES_H
-#include FT_TRUETYPE_IDS_H
-#include FT_TRUETYPE_TABLES_H
-#include FT_TYPE1_TABLES_H
-
-namespace KFI
-{
-
-bool CFontEngine::openFont(const TQString &file, int face)
-{
-    bool ok=false;
-
-    if(file==itsPath && face==itsFaceIndex)
-    {
-        ok=NONE!=itsType;
-    }
-    else
-    {
-        closeFont();
-
-        itsWeight=WEIGHT_MEDIUM;
-        itsItalic=ITALIC_NONE;
-        itsPath=file;
-        itsFaceIndex=face;
-        itsPsName=TQString();
-
-        if(!openFontFt(file) && !itsPsName.isEmpty())
-            itsType=NONE;
-    }
-
-    return NONE!=itsType;
-}
-
-void CFontEngine::closeFont()
-{
-    closeFaceFt();
-    itsPath=TQString::null;
-    itsFaceIndex=-1;
-    itsType=NONE;
-}
-
-TQString CFontEngine::weightStr(enum EWeight w)
-{
-    switch(w)
-    {
-        case WEIGHT_THIN:
-            return "Thin";
-        case WEIGHT_ULTRA_LIGHT:
-            return "UltraLight";
-        case WEIGHT_EXTRA_LIGHT:
-            return "ExtraLight";
-        case WEIGHT_DEMI:
-            return "Demi";
-        case WEIGHT_LIGHT:
-            return "Light";
-        case WEIGHT_BOOK:
-            return "Book";
-        case WEIGHT_MEDIUM:
-            return "Medium";
-        case WEIGHT_REGULAR:
-            return "Regular";
-        case WEIGHT_SEMI_BOLD:
-            return "SemiBold";
-        case WEIGHT_DEMI_BOLD:
-            return "DemiBold";
-        case WEIGHT_BOLD:
-            return "Bold";
-        case WEIGHT_EXTRA_BOLD:
-            return "ExtraBold";
-        case WEIGHT_ULTRA_BOLD:
-            return "UltraBold";
-        case WEIGHT_HEAVY:
-            return "Heavy";
-        case WEIGHT_BLACK:
-            return "Black";
-        case WEIGHT_UNKNOWN:
-        default:
-            return "Medium";
-    }
-}
-
-CFontEngine::EWeight CFontEngine::strToWeight(const char *str)
-{
-    if(NULL==str)
-        return WEIGHT_MEDIUM; // WEIGHT_UNKNOWN;
-    else if(kasciistricmp(str, "Bold")==0)
-        return WEIGHT_BOLD;
-    else if(kasciistricmp(str, "Black")==0)
-        return WEIGHT_BLACK;
-    else if(kasciistricmp(str, "ExtraBold")==0)
-        return WEIGHT_EXTRA_BOLD;
-    else if(kasciistricmp(str, "UltraBold")==0)
-        return WEIGHT_ULTRA_BOLD;
-    else if(kasciistricmp(str, "ExtraLight")==0)
-        return WEIGHT_EXTRA_LIGHT;
-    else if(kasciistricmp(str, "UltraLight")==0)
-        return WEIGHT_ULTRA_LIGHT;
-    else if(kasciistricmp(str, "Light")==0)
-        return WEIGHT_LIGHT;
-    else if(kasciistricmp(str, "Medium")==0 || kasciistricmp(str, "Normal")==0 || kasciistricmp(str, "Roman")==0)
-        return WEIGHT_MEDIUM;
-    else if(kasciistricmp(str, "Regular")==0)
-        return WEIGHT_MEDIUM; // WEIGHT_REGULAR;
-    else if(kasciistricmp(str, "Demi")==0)
-        return WEIGHT_DEMI;
-    else if(kasciistricmp(str, "SemiBold")==0)
-        return WEIGHT_SEMI_BOLD;
-    else if(kasciistricmp(str, "DemiBold")==0)
-        return WEIGHT_DEMI_BOLD;
-    else if(kasciistricmp(str, "Thin")==0)
-        return WEIGHT_THIN;
-    else if(kasciistricmp(str, "Book")==0)
-        return WEIGHT_BOOK;
-    else
-        return WEIGHT_MEDIUM; // WEIGHT_UNKNOWN;
-}
-
-static void removeSymbols(TQString &str)
-{
-    str.replace(TQRegExp("[\\-\\[\\]()]"), " ");
-
-    int   len=str.length();
-    TQChar space(' ');
-
-    for(int c=0; c<len; ++c)
-        if(str[c].unicode()<0x20 || str[c].unicode()>0x7E)
-            str[c]=space;
-
-    str=str.simplifyWhiteSpace();
-    str=str.stripWhiteSpace();
-}
-
-static bool lookupName(FT_Face face, int nid, int pid, int eid, FT_SfntName *nameReturn)
-{
-    int n = FT_Get_Sfnt_Name_Count(face);
-
-    if(n>0)
-    {
-        int         i;
-        FT_SfntName name;
-
-        for(i=0; i<n; i++)
-            if(0==FT_Get_Sfnt_Name(face, i, &name) && name.name_id == nid && name.platform_id == pid &&
-               (eid < 0 || name.encoding_id == eid))
-            {
-                switch(name.platform_id)
-                {
-                    case TT_PLATFORM_APPLE_UNICODE:
-                    case TT_PLATFORM_MACINTOSH:
-                        if(name.language_id != TT_MAC_LANGID_ENGLISH)
-                            continue;
-                        break;
-                    case TT_PLATFORM_MICROSOFT:
-                        if(name.language_id != TT_MS_LANGID_ENGLISH_UNITED_STATES &&
-                           name.language_id != TT_MS_LANGID_ENGLISH_UNITED_KINGDOM)
-                            continue;
-                        break;
-                    default:
-                        continue;
-                }
-
-                if(name.string_len > 0)
-                {
-                    *nameReturn = name;
-                    return true;
-                }
-            }
-    }
-
-    return false;
-}
-
-static TQCString getName(FT_Face face, int nid)
-{
-    FT_SfntName name;
-    TQCString    str;
-
-    if(lookupName(face, nid, TT_PLATFORM_MICROSOFT, TT_MS_ID_UNICODE_CS, &name) ||
-       lookupName(face, nid, TT_PLATFORM_APPLE_UNICODE, -1, &name))
-        for(unsigned int i=0; i < name.string_len / 2; i++)
-            str+=0 == name.string[2*i] ? name.string[(2*i)+1] : '_';
-    else if(lookupName(face, nid, TT_PLATFORM_MACINTOSH, TT_MAC_ID_ROMAN, &name)) // Pretend that Apple Roman is ISO 8859-1
-        for(unsigned int i=0; i < name.string_len; i++)
-            str+=name.string[i];
-
-    return str;
-}
-
-bool CFontEngine::openFontFt(const TQString &file)
-{
-    enum ETtfWeight
-    {
-        TTF_WEIGHT_UNKNOWN    = 0,
-        TTF_WEIGHT_THIN       = 100 +50,
-        TTF_WEIGHT_EXTRALIGHT = 200 +50,
-        TTF_WEIGHT_LIGHT      = 300 +50,
-        TTF_WEIGHT_NORMAL     = 400 +50,
-        TTF_WEIGHT_MEDIUM     = 500 +50,
-        TTF_WEIGHT_SEMIBOLD   = 600 +50,
-        TTF_WEIGHT_BOLD       = 700 +50,
-        TTF_WEIGHT_EXTRABOLD  = 800 +50,
-        TTF_WEIGHT_BLACK      = 900 +50
-    };
-
-    bool status=FT_New_Face(itsFt.library, TQFile::encodeName(file), 0, &itsFt.face) ? false : true;
-
-    if(status)
-        itsFt.open=true;
-
-    PS_FontInfoRec t1info;
-
-    if(0==FT_Get_PS_Font_Info(itsFt.face, &t1info))
-    {
-        itsFamily=t1info.family_name;
-        itsType=TYPE_1;
-    }
-    else
-    {
-        itsFamily=getName(itsFt.face, TT_NAME_ID_FONT_FAMILY);
-        itsType=TRUE_TYPE;
-    }
-
-    if(itsFamily.isEmpty())
-        itsFamily=FT_Get_Postscript_Name(itsFt.face);
-
-    if(itsFamily.isEmpty())
-        status=false;   // Hmm... couldn't find any of the names!
-
-    if(status)
-    {
-        removeSymbols(itsFamily);
-        itsPsName=(FT_Get_Postscript_Name(itsFt.face));
-
-        if(TYPE_1==itsType)
-        {
-            itsWeight=strToWeight(t1info.weight);
-            itsItalic=t1info.italic_angle <= -4 || t1info.italic_angle >= 4 ? ITALIC_ITALIC : ITALIC_NONE;
-        }
-        else // TrueType...
-        {
-            TT_Postscript *post=NULL;
-            TT_OS2        *os2=NULL;
-            TT_Header     *head=NULL;
-            bool          gotItalic=false;
-
-            if(NULL==(os2=(TT_OS2 *)FT_Get_Sfnt_Table(itsFt.face, ft_sfnt_os2)) || 0xFFFF==os2->version)
-                itsWeight=WEIGHT_UNKNOWN;
-            else
-            {
-                FT_UShort weight=(os2->usWeightClass>0 && os2->usWeightClass<100) ? os2->usWeightClass*100 : os2->usWeightClass;
-
-                if(weight<TTF_WEIGHT_THIN)
-                    itsWeight=WEIGHT_THIN;
-                else if(weight<TTF_WEIGHT_EXTRALIGHT)
-                    itsWeight=WEIGHT_EXTRA_LIGHT;
-                else if(weight<TTF_WEIGHT_LIGHT)
-                    itsWeight=WEIGHT_LIGHT;
-                else if(/*weight<TTF_WEIGHT_NORMAL || */ weight<TTF_WEIGHT_MEDIUM)
-                    itsWeight=WEIGHT_MEDIUM;
-                else if(weight<TTF_WEIGHT_SEMIBOLD)
-                    itsWeight=WEIGHT_SEMI_BOLD;
-                else if(weight<TTF_WEIGHT_BOLD)
-                    itsWeight=WEIGHT_BOLD;
-                else if(weight<TTF_WEIGHT_EXTRABOLD)
-                    itsWeight=WEIGHT_EXTRA_BOLD;
-                else if(weight<TTF_WEIGHT_BLACK)
-                    itsWeight=WEIGHT_BLACK;
-                else if(os2->fsSelection&(1 << 5))
-                    itsWeight=WEIGHT_BOLD;
-                else
-                    itsWeight=WEIGHT_UNKNOWN;
-
-                itsItalic=os2->fsSelection&(1 << 0) ? ITALIC_ITALIC : ITALIC_NONE;
-                gotItalic=true;
-            }
-
-            if(WEIGHT_UNKNOWN==itsWeight)
-                itsWeight=NULL!=(head=(TT_Header *)FT_Get_Sfnt_Table(itsFt.face, ft_sfnt_head)) && head->Mac_Style & 1
-                             ? WEIGHT_BOLD
-                             : WEIGHT_MEDIUM;
-
-            if(!gotItalic && (head!=NULL || NULL!=(head=(TT_Header *)FT_Get_Sfnt_Table(itsFt.face, ft_sfnt_head))))
-            {
-                gotItalic=true;
-                itsItalic=head->Mac_Style & 2 ? ITALIC_ITALIC: ITALIC_NONE;
-            }
-
-            if(!gotItalic && NULL!=(post=(TT_Postscript *)FT_Get_Sfnt_Table(itsFt.face, ft_sfnt_post)))
-            {
-                struct TFixed
-                {
-                    TFixed(unsigned long v) : upper(v>>16), lower(v&0xFFFF) {}
-
-                    short upper,
-                          lower;
-
-                    float value() { return upper+(lower/65536.0); }
-                };
-
-                gotItalic=true;
-                itsItalic=0.0f==((TFixed)post->italicAngle).value() ? ITALIC_NONE : ITALIC_ITALIC;
-            }
-        }
-    }
-
-    if(!status)
-        closeFaceFt();
-
-    return status;
-}
-
-void CFontEngine::closeFaceFt()
-{
-    if(itsFt.open)
-    {
-        FT_Done_Face(itsFt.face);
-        itsFt.open=false;
-    }
-}
-
-CFontEngine::TFtData::TFtData()
-                    : open(false)
-{
-    if(FT_Init_FreeType(&library))
-    {
-        std::cerr << "ERROR: FreeType2 failed to initialise\n";
-        exit(0);
-    }
-}
-
-CFontEngine::TFtData::~TFtData()
-{
-    FT_Done_FreeType(library);
-}
-
-}
diff --git a/kcontrol/kfontinst/kfontinst/FontEngine.h b/kcontrol/kfontinst/kfontinst/FontEngine.h
deleted file mode 100644
index c534a5ef5..000000000
--- a/kcontrol/kfontinst/kfontinst/FontEngine.h
+++ /dev/null
@@ -1,142 +0,0 @@
-#ifndef __FONT_ENGINE_H__
-#define __FONT_ENGINE_H__
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Class Name    : KFI::CFontEngine
-// Author        : Craig Drummond
-// Project       : K Font Installer
-// Creation Date : 29/04/2001
-// Version       : $Revision$ $Date$
-//
-////////////////////////////////////////////////////////////////////////////////
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-//
-////////////////////////////////////////////////////////////////////////////////
-// (C) Craig Drummond, 2001, 2002, 2003, 2004
-////////////////////////////////////////////////////////////////////////////////
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <ft2build.h>
-#include FT_FREETYPE_H
-#include <tqstring.h>
-#include <tqstringlist.h>
-
-namespace KFI
-{
-
-class CFontEngine
-{
-    public:
-
-    enum EType
-    {
-        // These have PS Info / support AFM stuff...
-        TRUE_TYPE,
-        TT_COLLECTION,
-        TYPE_1,
-        NONE
-    };
-
-    enum EWeight
-    {
-        WEIGHT_UNKNOWN=0,
-        WEIGHT_THIN,
-        WEIGHT_ULTRA_LIGHT,
-        WEIGHT_EXTRA_LIGHT,
-        WEIGHT_DEMI,
-        WEIGHT_LIGHT,
-        WEIGHT_BOOK,
-        WEIGHT_MEDIUM,
-        WEIGHT_REGULAR,
-        WEIGHT_SEMI_BOLD,
-        WEIGHT_DEMI_BOLD,
-        WEIGHT_BOLD,
-        WEIGHT_EXTRA_BOLD,
-        WEIGHT_ULTRA_BOLD,
-        WEIGHT_HEAVY,
-        WEIGHT_BLACK
-    };
-
-    enum EItalic
-    {
-        ITALIC_NONE,
-        ITALIC_ITALIC,
-        ITALIC_OBLIQUE
-    };
-
-    private:
-
-    struct TFtData
-    {
-        TFtData();
-        ~TFtData();
-
-        FT_Library library;
-        FT_Face    face;
-        bool       open;
-    };
-
-    public:
-
-    CFontEngine() : itsType(NONE)               { }
-    ~CFontEngine()                              { closeFont(); }
-
-    static EType   getType(const char *fname);
-    static TQString weightStr(EWeight w);
-    static TQString italicStr(EItalic i)         { return ITALIC_NONE==i ? "r" : ITALIC_ITALIC==i ? "i" : "o"; }
-
-    //
-    // General functions - these should be used instead of specfic ones below...
-    //
-    bool            openFont(const TQString &file, int face=0);
-    void            closeFont();
-
-    //
-    const TQString & getFamilyName()   { return itsFamily; }
-    const TQString & getPsName()       { return itsPsName; }
-    EWeight         getWeight()       { return itsWeight; }
-    EItalic         getItalic()       { return itsItalic; }
-    EType           getType()         { return itsType; }
-    int             getNumFaces()     { return itsFt.open ? itsFt.face->num_faces : 1; }
-    bool            hasPsInfo()       { return itsType!=NONE; }
-
-    static EWeight  strToWeight(const char *str);
-
-    private:
-
-    bool            openFontFt(const TQString &file);
-    void            closeFaceFt();
-
-    private:
-
-    EWeight itsWeight;
-    EType   itsType;
-    EItalic itsItalic;
-    TQString itsFamily,
-            itsPsName,
-            itsPath;
-    int     itsNumFaces,
-            itsFaceIndex;   // Only for TTC fonts - at the moment...
-    TFtData itsFt;
-};
-
-}
-
-#endif
diff --git a/kcontrol/kfontinst/kfontinst/Fontmap.cpp b/kcontrol/kfontinst/kfontinst/Fontmap.cpp
deleted file mode 100644
index 2c8b80201..000000000
--- a/kcontrol/kfontinst/kfontinst/Fontmap.cpp
+++ /dev/null
@@ -1,596 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-//
-// Namespae      : KFI::Fontmap
-// Author        : Craig Drummond
-// Project       : K Font Installer
-// Creation Date : 06/06/2003
-// Version       : $Revision$ $Date$
-//
-////////////////////////////////////////////////////////////////////////////////
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-//
-////////////////////////////////////////////////////////////////////////////////
-// (C) Craig Drummond, 2003, 2004
-////////////////////////////////////////////////////////////////////////////////
-
-#include "Fontmap.h"
-#include "FontEngine.h"
-#include "XConfig.h"
-#include "FcEngine.h"
-#include "KfiConstants.h"
-#include <ksavefile.h>
-#include <tqtextstream.h>
-#include <tqdir.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <tqregexp.h>
-#include <fstream>
-#include <unistd.h>
-
-using namespace std;
-
-static const char * findSpace(const char *str)
-{
-    while(str && *str!=' ' && *str!='\t')
-        str++;
-
-    return str;
-}
-
-static bool parseLine(const char *line, TQString &ps, TQString &fname, bool &isAlias)
-{
-    static const int constMaxLen     = 127;
-    static const int constFileMaxLen = 1023;
-
-    //
-    // Format:
-    // "/<psname>  (<filename>) ; "
-    // "/<psname>  /real ; "
-
-    char a[constMaxLen+1],
-         b[constFileMaxLen+1];
-
-    char *slash1=const_cast<char*>(strchr(line, '/')),
-         *space1=slash1 ? (char*)findSpace(slash1) : NULL, //strchr(slash1, ' ') : NULL,
-         *ob=slash1 ? strchr(slash1, '(') : NULL,
-         *cb=ob ? strchr(ob, ')') : NULL,
-         *slash2=space1 && !ob && !cb ? strchr(space1, '/') : NULL,
-         *space2=slash2 ? (char*)findSpace(slash2) : NULL, // strchr(slash2, ' ') : NULL,
-         *semic=cb || space2 ? strchr(cb ? cb : space2, ';') : NULL;
-
-    if(semic && space1-slash1<constMaxLen)
-    {
-        slash1++;
-        memcpy(a, slash1, space1-slash1);
-        a[space1-slash1]='\0';
-
-        if(cb && cb-ob<constFileMaxLen)  // Then found a file entry...
-        {
-            ob++;
-            memcpy(b, ob, cb-ob);
-            b[cb-ob]='\0';
-            ps=a;
-            fname=b;
-            isAlias=false;
-            return true;
-        }
-        else if(space2 && space2-slash2<constMaxLen) // Then found an alias...
-        {
-            slash2++;
-            memcpy(b, slash2, space2-slash2);
-            b[space2-slash2]='\0';
-            ps=a;
-            fname=b;
-            isAlias=true;
-            return true;
-        }
-    }
-
-    return false;
-}
-
-//
-// Returns a PS name from an X family name...
-//    e.g. "Times New Roman" -> "TimesNewRoman"
-static TQString createX11PsName(const TQString &font)
-{
-    TQString       newName(font);
-    unsigned int  ch;
-    bool          newWord=true;
-
-    newName.replace(TQRegExp("\\-"), "_");
-
-    for(ch=0; ch<newName.length(); ++ch)
-    {
-        if(newName[ch].isSpace())
-            newWord=true;
-        else
-        {
-            if(newName[ch]==newName[ch].upper())
-            {
-                if(!newWord)
-                    newName[ch]=newName[ch].lower();
-            }
-            else
-                if(newName[ch]==newName[ch].lower())
-                {
-                    if(newWord)
-                        newName[ch]=newName[ch].upper();
-                }
-            newWord=false;
-        }
-    }
-
-    newName.replace(" ", TQString());
-    return newName;
-}
-
-static const char * getItalicStr(KFI::CFontEngine::EItalic it)
-{
-    switch(it)
-    {
-        default:
-        case KFI::CFontEngine::ITALIC_NONE:
-            return NULL;
-        case KFI::CFontEngine::ITALIC_ITALIC:
-            return "Italic";
-        case KFI::CFontEngine::ITALIC_OBLIQUE:
-            return "Oblique";
-    }
-}
-
-//
-// Create a full Ps name
-static TQString createName(const TQString &family, const TQString &weight, const char *italic)
-{
-    TQString      name;
-    TQTextOStream str(&name);
-
-    str << family;
-    if(!weight.isEmpty() || NULL!=italic)
-    {
-        str << '-';
-        if(!weight.isEmpty())
-            str << weight;
-        if(NULL!=italic)
-            str << italic;
-    }
-
-    return name;
-}
-
-static TQString getEntry(TQStringList &list, const TQString &name)
-{
-    TQStringList::Iterator it(list.begin()),
-                          end(list.end());
-
-    for( ; it!=end; ++it)
-        if(0==(*it).find('/'+name+' '))
-            return *it;
-
-    return TQString::null;
-}
-
-inline bool isAlias(const TQString &entry)
-{
-    return -1==entry.findRev(TQRegExp(")\\s*;\\s*$"));
-}
-
-static void addEntry(TQStringList &list, const TQString &name, const TQString &file, const TQString &fmapDir)
-{
-    TQString existing(getEntry(list, name));
-    bool    insert=true;
-
-    if(!existing.isEmpty())
-        if(isAlias(existing))
-            list.remove(existing);
-        else
-            insert=false;
-
-    if(insert)
-    {
-        TQString      entry;
-        TQTextOStream str(&entry);
-
-        str << '/' << name << " (";
-
-        if(0==file.find(fmapDir))
-            str << file.mid(fmapDir.length());
-        else
-            str << file;
-
-        str << ") ;";
-        list.append(entry);
-    }
-}
-
-static void addAliasEntry(TQStringList &list, const TQString &x11Name, const TQString &psName)
-{
-    if(x11Name!=psName)
-    {
-        TQString existing(getEntry(list, x11Name));
-
-        if(existing.isEmpty())
-        {
-            TQString      entry;
-            TQTextOStream str(&entry);
-
-            str << '/' << x11Name << " /" << psName << " ;";
-            list.append(entry);
-        }
-    }
-}
-
-static TQString locateFile(const char *dir, const char *file, int level=0)
-{
-    if(level<5)
-    {
-        TQDir d(dir);
-
-        if(d.isReadable())
-        {
-            const TQFileInfoList *fList=d.entryInfoList();
-
-            if(fList)
-            {
-                TQFileInfoListIterator it(*fList);
-                TQFileInfo             *fInfo;
-                TQString               str;
-
-                for(; NULL!=(fInfo=it.current()); ++it)
-                    if("."!=fInfo->fileName() && ".."!=fInfo->fileName())
-                        if(fInfo->isDir())
-                        {
-                            if(!(str=locateFile(TQFile::encodeName(fInfo->filePath()+"/"), file, level+1)).isEmpty())
-                                return str;
-                        }
-                        else
-                            if(fInfo->fileName()==file)
-                                return fInfo->filePath();
-            }
-        }
-    }
-
-    return TQString();
-}
-
-static TQString locateFile(const char *file, const char **dirs)
-{
-    int     d;
-    TQString str;
-
-    for(d=0; dirs[d]; ++d)
-        if(!(str=locateFile(dirs[d], file)).isEmpty())
-            return str;
-
-    return TQString::null;
-}
-
-#define FONTMAP "Fontmap"
-
-namespace KFI
-{
-
-namespace Fontmap
-{
-
-bool create(const TQString &dir, CFontEngine &fe)
-{
-    bool        root(Misc::root()),
-                added=false;
-    TQString     fmapDir(Misc::dirSyntax(root ? KFI_ROOT_CFG_DIR : dir));
-    CFile       old(fmapDir);
-    TQStringList entries;
-    int         i;
-    FcPattern   *pat = FcPatternCreate();
-    FcObjectSet *os = FcObjectSetBuild(FC_FILE, FC_SCALABLE, (void*)0);
-    FcFontSet   *fs = FcFontList(0, pat, os);
-
-    FcPatternDestroy(pat);
-    FcObjectSetDestroy(os);
-
-    for (i = 0; i<fs->nfont; i++)
-    {
-        TQString fName(Misc::fileSyntax(CFcEngine::getFcString(fs->fonts[i], FC_FILE)));
-        FcBool  scalable=FcFalse;
-
-        if(!fName.isEmpty() && (root || dir.isEmpty() || 0==fName.find(dir)) &&
-           FcResultMatch==FcPatternGetBool(fs->fonts[i], FC_SCALABLE, 0, &scalable) && scalable)
-        {
-            const TQStringList *existing=old.getEntries(fName);
-
-            if(existing && existing->count())
-                entries+=(*existing);
-            else
-            {
-                int face=0,
-                    numFaces=0;
-
-                do
-                {
-                    if(fe.openFont(fName, face))
-                    {
-                        if(fe.hasPsInfo())
-                        {
-                            if(0==numFaces)
-                                numFaces=fe.getNumFaces();  // Only really for TTC files...
-
-                            //
-                            // Add real
-                            addEntry(entries, fe.getPsName(), fName, fmapDir);
-                            added=true;
-
-                            //
-                            // Add fake entries for X11 generated names
-                            switch(fe.getWeight())
-                            {
-                                case CFontEngine::WEIGHT_MEDIUM:
-                                case CFontEngine::WEIGHT_REGULAR:
-                                {
-                                    TQString x11Ps(createX11PsName(fe.getFamilyName()));
-
-                                    if(CFontEngine::ITALIC_ITALIC!=fe.getItalic() &&
-                                       CFontEngine::ITALIC_OBLIQUE!=fe.getItalic())
-                                        addAliasEntry(entries,
-                                                      createName(x11Ps, "Roman",
-                                                      getItalicStr(fe.getItalic())),
-                                                      fe.getPsName());
-                                    addAliasEntry(entries,
-                                                  createName(x11Ps, NULL, getItalicStr(fe.getItalic())),
-                                                  fe.getPsName());
-                                    break;
-                                }
-                                case CFontEngine::WEIGHT_UNKNOWN:
-                                    break;
-                                default:
-                                    addAliasEntry(entries,
-                                                  createName(createX11PsName(fe.getFamilyName()),
-                                                             CFontEngine::weightStr(fe.getWeight()),
-                                                             getItalicStr(fe.getItalic())),
-                                                  fe.getPsName());
-                            }
-                        }
-                        fe.closeFont();
-                    }
-                }
-                while(++face<numFaces);
-            }
-        }
-    }
-
-    bool status=true;
-
-    if(added || entries.count()!=old.getLineCount())
-    {
-        KSaveFile   out(fmapDir+FONTMAP);
-        TQTextStream *stream=out.textStream();
-
-        if(stream)
-        {
-            TQStringList::Iterator it;
-
-            for(it=entries.begin(); it!=entries.end(); ++it)
-                *stream << *it << endl;
-        }
-        else
-            status=false;
-    }
-
-    //
-    // Ensure GS's main Fontmap references our file...
-    if(root && status)
-    {
-        static const char * constGhostscriptDirs[]=
-        {
-            "/usr/share/ghostscript/",
-            "/usr/local/share/ghostscript/",
-            "/usr/share/gs-esp/",
-            NULL
-        };
-
-        TQString gsFile=locateFile(FONTMAP, constGhostscriptDirs);
-
-        if(!gsFile.isEmpty())
-        {
-            const int constMaxLineLen=1024;
-            const char *constRLF=".runlibfile";
-
-            char     line[constMaxLineLen];
-            ifstream in(TQFile::encodeName(gsFile));
-
-            if(in)
-            {
-                TQCString fmap(TQFile::encodeName(fmapDir+FONTMAP));
-                int      lineNum=0,
-                         kfiLine=-1,
-                         gsLine=-1,
-                         ncLine=-1;
-
-                do
-                {
-                    in.getline(line, constMaxLineLen);
-
-                    if(in.good())
-                    {
-                        line[constMaxLineLen-1]='\0';
-
-                        if(strstr(line, fmap.data())!=NULL && strstr(line, constRLF)!=NULL)
-                            kfiLine=lineNum;
-                        else if(strstr(line, FONTMAP".GS")!=NULL && strstr(line, constRLF)!=NULL)
-                            gsLine=lineNum;
-                        if(-1==ncLine && '%'!=line[0])
-                            ncLine=lineNum;
-                        lineNum++;
-                    }
-                }
-                while(!in.eof() && (-1==kfiLine || -1==gsLine));
-
-                //
-                // If the file doesn't already say to use our Fontmap file, then tell it to!
-                // Also, ensure ours is .runlibfile'd before the main GS one - else problems can occur
-                if(-1==kfiLine || kfiLine>gsLine)
-                {
-                    in.clear();
-                    in.seekg(0, ios::end);
-                    int size= (streamoff) in.tellg();
-                    in.seekg(0, ios::beg);
-
-                    char *buffer=new char[size+strlen(fmap)+strlen(constRLF)+5];
-
-                    if(buffer)
-                    {
-                        bool added=false;
-
-                        buffer[0]='\0';
-                        lineNum=0;
-
-                        do
-                        {
-                            in.getline(line, constMaxLineLen);
-
-                            if(in.good())
-                            {
-                                line[constMaxLineLen-1]='\0';
-
-                                if(lineNum>=ncLine && !added)
-                                {
-                                    strcat(buffer, "(");
-                                    strcat(buffer, fmap);
-                                    strcat(buffer, ") ");
-                                    strcat(buffer, constRLF);
-                                    strcat(buffer, "\n");
-                                    added=true;
-                                }
-
-                                if(lineNum!=kfiLine)
-                                {
-                                    strcat(buffer, line);
-                                    strcat(buffer, "\n");
-                                }
-                                lineNum++;
-                            }
-                        }
-                        while(!in.eof());
-
-                        in.close();
-
-                        if(added) // Don't re-write GS's Fontmap unless we've actually added something...
-                        {
-                            KSaveFile   out(gsFile);
-                            TQTextStream *stream=out.textStream();
-
-                            if(stream)
-                                *stream << buffer;
-                        }
-                        delete [] buffer;
-                    }
-                }
-            }
-        }
-    }
-
-    return status;
-}
-
-CFile::CFile(const TQString &dir)
-     : itsDir(dir),
-       itsLineCount(0)
-{
-    ifstream f(TQFile::encodeName(dir+FONTMAP));
-
-    itsEntries.setAutoDelete(true);
-
-    if(f)
-    {
-        static const int constMaxLine=512;
-
-        char   line[constMaxLine+1];
-        TEntry *current=NULL;
-
-        while(!f.eof())
-        {
-            f.getline(line, constMaxLine);
-
-            if(!f.eof())
-            {
-                TQString ps,
-                        fname;
-                bool    isAlias;
-
-                if(parseLine(line, ps, fname, isAlias))
-                {
-                    itsLineCount++;
-
-                    TEntry *entry=getEntry(&current, fname, isAlias);
-
-                    if(!isAlias && entry && entry->psName.isEmpty())
-                        entry->psName=ps;
-
-                    if(entry)
-                        entry->entries.append(line);
-                }
-            }
-        }
-        f.close();
-    }
-}
-
-const TQStringList * CFile::getEntries(const TQString &fname)
-{
-    TEntry *entry=findEntry(0==fname.find(itsDir) ? fname.mid(itsDir.length()) : fname, false);
-
-    return entry ? &entry->entries : NULL;
-}
-
-CFile::TEntry * CFile::findEntry(const TQString &fname, bool isAlias)
-{
-    TEntry *entry=NULL;
-
-    for(entry=itsEntries.first(); entry; entry=itsEntries.next())
-        if(isAlias ? entry->psName==fname : entry->filename==fname)
-            break;
-
-    return entry;
-}
-
-CFile::TEntry * CFile::getEntry(TEntry **current, const TQString &fname, bool isAlias)
-{
-    //
-    // See if its the current one...
-    if(*current && (isAlias ? (*current)->psName==fname : (*current)->filename==fname))
-        return *current;
-
-    //
-    // See if its already known...
-    TEntry *entry=findEntry(fname, isAlias);
-
-    //
-    // If not found, then create a new entry
-    if(!entry)
-    {
-        entry=new TEntry(fname);
-        itsEntries.append(entry);
-    }
-
-    *current=entry;
-    return entry;
-}
-
-}
-
-}
diff --git a/kcontrol/kfontinst/kfontinst/Fontmap.h b/kcontrol/kfontinst/kfontinst/Fontmap.h
deleted file mode 100644
index 92d64f5fb..000000000
--- a/kcontrol/kfontinst/kfontinst/Fontmap.h
+++ /dev/null
@@ -1,79 +0,0 @@
-#ifndef __FONTMAP_H__
-#define __FONTMAP_H__
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Namespace     : KFI::Fontmap
-// Author        : Craig Drummond
-// Project       : K Font Installer
-// Creation Date : 06/06/2003
-// Version       : $Revision$ $Date$
-//
-////////////////////////////////////////////////////////////////////////////////
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-//
-////////////////////////////////////////////////////////////////////////////////
-// (C) Craig Drummond, 2003, 2004
-////////////////////////////////////////////////////////////////////////////////
-
-#include <tqstring.h>
-#include <tqstringlist.h>
-
-namespace KFI
-{
-
-class CFontEngine;
-
-namespace Fontmap
-{
-    class CFile
-    {
-        private:
-
-        struct TEntry
-        {
-            TEntry(const TQString &fname) : filename(fname) {}
-
-            TQString     filename,
-                        psName;
-            TQStringList entries;
-        };
-
-        public:
-
-        CFile(const TQString &dir);
-
-        const TQStringList * getEntries(const TQString &fname);
-        unsigned int        getLineCount() { return itsLineCount; }
-
-        private:
-
-        TEntry * findEntry(const TQString &fname, bool isAlias=false);
-        TEntry * getEntry(TEntry **current, const TQString &fname, bool isAlias=false);
-
-        private:
-
-        TQString          itsDir;
-        TQPtrList<TEntry> itsEntries;
-        unsigned int     itsLineCount;
-    };
-
-    extern bool create(const TQString &dir, CFontEngine &fe);
-}
-
-}
-
-#endif
diff --git a/kcontrol/kfontinst/kfontinst/GetPid.c b/kcontrol/kfontinst/kfontinst/GetPid.c
deleted file mode 100644
index 015ea7ce9..000000000
--- a/kcontrol/kfontinst/kfontinst/GetPid.c
+++ /dev/null
@@ -1,519 +0,0 @@
-/*
-////////////////////////////////////////////////////////////////////////////////
-//
-// File Name     : GetPid.c
-// Author        : Craig Drummond
-// Project       : K Font Installer
-// Creation Date : 19/03/2003
-// Version       : $Revision$ $Date$
-//
-////////////////////////////////////////////////////////////////////////////////
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-//
-////////////////////////////////////////////////////////////////////////////////
-// (C) Craig Drummond, 2003
-////////////////////////////////////////////////////////////////////////////////
-*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#if defined(__DragonFly__)
-#include <sys/param.h>
-#endif
-
-#include <sys/types.h>
-
-#ifndef __cplusplus
-#define bool unsigned int
-#define false 0
-#define true (!false)
-#endif
-
-#define BUFSIZE 1024
-#define PROCDIR "/proc"
-
-/*
-    Get process ID - using name of exe and parent process ID
-
-    Implemented for:
-
-        Linux         Tested on Linux 2.4
-        FreeBSD       Tested on FreeBSD 5.1 by Brian Ledbetter <brian@shadowcom.net>
-        NetBSD
-        Irix
-        Solaris       Tested on Solaris 8 x86 by Torsten Kasch <tk@Genetik.Uni-Bielefeld.DE>
-        HP-UX         Tested on HP-UX B.11.11 U 9000/800
-        AIX
-        ...else parse output of "ps -eaf"
-
-
-    Some sections of this code are copied from / inspired by ksysguard,
-    Copyright (c) 1999 - 2001 Chris Schlaeger <cs@kde.org>
-
-    To test this file, do the following:
-
-    1. Compile this file as follows:
-
-           gcc GetPid.c -DTEST_GETPID -DOS_Linux -o tst
-
-       ...replace OS_Linux with your particular OS type: OS_FreeBSD, OS_NetBSD, OS_Irix, OS_Solaris,
-       OS_HPUX, or OS_AIX
-
-    2. Start a program - such as "vi"
-    3. Do a "ps -eaf" to ensure there is *only one* process called "vi"
-    4. Get the parent process ID of your "vi" above
-    5. Call tst with that value -e.g. vi ppid=23 then ./tst vi 23
-       ...this should then print out the process ID of "vi"
-    6. Email me and let me know if it works!
-*/
-
-#if defined OS_Linux || defined __Linux__
-
-#include <dirent.h>
-#include <ctype.h>
-
-#define FOUND_NAME 1
-#define FOUND_PPID 2
-#define FOUND_ALL (FOUND_NAME+FOUND_PPID)
-
-unsigned int kfi_getPid(const char *proc, unsigned int ppid)
-{
-    bool           error=false;
-    unsigned int   pid=0;
-    DIR           *dir;
-    struct dirent *entry;
-
-    /* read in current process list via the /proc filesystem entry */
-    if(NULL!=(dir=opendir(PROCDIR)))
-    {
-        while((entry=readdir(dir)) && !error)
-            if(isdigit(entry->d_name[0]))
-            {
-                char buf[BUFSIZE];
-                FILE *fd;
-
-                snprintf(buf, BUFSIZE-1, PROCDIR"/%d/status", atoi(entry->d_name));
-
-                if(NULL!=(fd=fopen(buf, "r")))
-                {
-                    char format[32],
-                         tagformat[32],
-                         tag[32],
-                         name[64];
-                    int  found=0;
-
-                    found=0;
-                    sprintf(format, "%%%d[^\n]\n", (int) sizeof(buf) - 1);
-                    sprintf(tagformat, "%%%ds", (int) sizeof(tag) - 1);
-                    for(;found<FOUND_ALL;)
-                    {
-                        if (fscanf(fd, format, buf)!=1)
-                            break;
-                        buf[sizeof(buf)-1]='\0';
-                        sscanf(buf, tagformat, tag);
-                        tag[sizeof(tag) - 1] = '\0';
-                        if(0==strcmp(tag, "Name:"))
-                        {
-                            sscanf(buf, "%*s %63s", name);
-                            if(NULL==name || 0!=strcmp(name, proc))
-                                break;
-                            found|=FOUND_NAME;
-                        }
-                        else if(0==strcmp(tag, "PPid:"))
-                        {
-                            unsigned int proc_ppid;
-
-                            sscanf(buf, "%*s %u", &proc_ppid);
-                            if(ppid!=proc_ppid)
-                                break;
-                            found|=FOUND_PPID;
-                        }
-                    }
-                    if(FOUND_ALL==found)
-                    {
-                        if(pid)
-                            error=true;
-                        else
-                            pid=atoi(entry->d_name);
-                    }
-                    fclose(fd);
-                }
-            }
-        closedir(dir);
-    }
-
-    return error ? 0 : pid;
-}
-
-#elif defined OS_FreeBSD || defined OS_NetBSD || defined __FreeBSD__ || defined __NetBSD__ || defined OS_Darwin
-
-#include <ctype.h>
-#include <dirent.h>
-#include <pwd.h>
-#include <stdio.h>
-#include <sys/param.h>
-#if __FreeBSD_version > 500015
-#include <sys/priority.h>
-#endif
-#include <sys/sysctl.h>
-#include <sys/time.h>
-#include <sys/user.h>
-#include <unistd.h>
-unsigned int kfi_getPid(const char *proc, unsigned int ppid)
-{
-    bool              error=false;
-    unsigned int      pid=0;
-    int               mib[4];
-    size_t            len,
-                      num;
-    struct kinfo_proc *p;
-
-    mib[0] = CTL_KERN;
-    mib[1] = KERN_PROC;
-    mib[2] = KERN_PROC_ALL;
-    sysctl(mib, 3, NULL, &len, NULL, 0);
-    p=(struct kinfo_proc*)malloc(len);
-    sysctl(mib, 3, p, &len, NULL, 0);
-
-    for(num=0; num < len / sizeof(struct kinfo_proc)  && !error; num++)
-    {
-        struct kinfo_proc proc_p;
-        size_t            len;
-
-        mib[0] = CTL_KERN;
-        mib[1] = KERN_PROC;
-        mib[2] = KERN_PROC_PID;
-#if __FreeBSD_version >= 500015
-        mib[3] = p[num].ki_pid;
-#elif defined(__DragonFly__) && __DragonFly_version >= 190000
-        mib[3] = p[num].kp_pid;
-#else
-        mib[3] = p[num].kp_proc.p_pid;
-#endif
-
-        len=sizeof(proc_p);
-        if(-1==sysctl(mib, 4, &proc_p, &len, NULL, 0) || !len)
-            break;
-        else
-        {
-#if __FreeBSD_version >= 500015
-            if(proc_p.ki_ppid==ppid && p[num].ki_comm && 0==strcmp(p[num].ki_comm, proc))
-                if(pid)
-                    error=true;
-                else
-                    pid=p[num].ki_pid;
-#elif defined (__DragonFly__) && __DragonFly_version >= 190000
-            if(proc_p.kp_ppid==ppid && p[num].kp_comm && 0==strcmp(p[num].kp_comm, proc))
-                if(pid)
-                    error=true;
-                else
-                    pid=p[num].kp_pid;
-#else
-#if defined(__DragonFly__)
-	    if(proc_p.kp_eproc.e_ppid==ppid && p[num].kp_thread.td_comm && 0==strcmp(p[num].kp_thread.td_comm, proc))
-#else
-            if(proc_p.kp_eproc.e_ppid==ppid && p[num].kp_proc.p_comm && 0==strcmp(p[num].kp_proc.p_comm, proc))
-#endif
-                if(pid)
-                    error=true;
-                else
-                    pid=p[num].kp_proc.p_pid;
-#endif
-        }
-    }
-    free(p);
-
-    return error ? 0 : pid;
-}
-
-#elif defined OS_Irix || defined OS_Solaris
-
-#include <unistd.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <signal.h>
-#include <dirent.h>
-#include <pwd.h>
-#include <sys/resource.h>
-#ifdef OS_Solaris
-
-#if (!defined(_LP64)) && (_FILE_OFFSET_BITS - 0 == 64)
-#define PROCFS_FILE_OFFSET_BITS_HACK 1
-#undef _FILE_OFFSET_BITS
-#else
-#define PROCFS_FILE_OFFSET_BITS_HACK 0
-#endif
-
-#include <procfs.h>
-
-#if (PROCFS_FILE_OFFSET_BITS_HACK - 0 == 1)
-#define _FILE_OFFSET_BITS 64
-#endif
-
-#else
-#include <sys/procfs.h>
-#include <sys/sysmp.h>
-#endif 
-#include <sys/sysinfo.h>
-
-unsigned int kfi_getPid(const char *proc, pid_t ppid)
-{
-    DIR	         *procdir;
-    bool         error=false;
-    pid_t	 pid=(pid_t)0;
-
-    if(NULL!=(procdir=opendir(PROCDIR)))
-    {
-        struct dirent *de;
-
-        rewinddir(procdir);
-        while((de=readdir(procdir)) && !error)
-            if('.'==de->d_name[0])
-                continue;
-            else
-            {
-                int        fd;
-                char       buf[BUFSIZE];
-#ifdef OS_Solaris
-                psinfo_t   psinfo;
-
-                snprintf(buf, BUFSIZE - 1, "%s/%s/psinfo", PROCDIR, de->d_name);
-#else
-                prpsinfo_t psinfo;
-
-                sprintf(buf, PROCDIR"/pinfo/%ld", pid);
-#endif
-
-                if((fd=open(buf, O_RDONLY))<0)
-                    continue;
-
-#ifdef OS_Solaris
-                if(sizeof(psinfo_t)!=read(fd, &psinfo, sizeof(psinfo_t)))
-#else
-                if(ioctl(fd, PIOCPSINFO, &psinfo)<0)
-#endif
-                {
-                    close(fd);
-                    continue;
-                }
-                close(fd);
-
-                if(psinfo.pr_ppid==ppid && psinfo.pr_fname && 0==strcmp(psinfo.pr_fname, proc))
-                    if(pid)
-                        error=true;
-                    else
-                        pid=psinfo.pr_pid;
-	    }
-        closedir(procdir);
-    }
-
-    return error ? 0 : pid;
-}
-
-#elif defined OS_HPUX
-
-#include <sys/pstat.h>
-#define MAX_PROCS 50
-
-unsigned int kfi_getPid(const char *proc, unsigned int ppid)
-{
-    bool              error=false;
-    unsigned int      pid=0;
-    int               i,
-                      count,
-                      idx=0; 
-    struct pst_status pst[MAX_PROCS];
-
-    while((count=pstat_getproc(&pst[0], sizeof(pst[0]), MAX_PROCS, idx)) > 0 && !error)
-    {
-        for (i = 0; i<count && !error; i++) 
-            if(pst[i].pst_ppid==ppid && pst[i].pst_ucomm && 0==strcmp(pst[i].pst_ucomm, proc))
-                if(pid)
-                    error=true;
-                else
-                    pid=pst[i].pst_pid;
-
-        idx=pst[count-1].pst_idx+1;
-    }
-
-    return error ? 0 : pid;
-}
-
-#elif defined OS_AIX
-
-#include <procinfo.h>
-#define MAX_PROCS 50
-
-unsigned int kfi_getPid(const char *proc, unsigned int ppid)
-{
-    bool             error=false;
-    unsigned int     pid=0;
-    int              i,
-                     count,
-                     idx=0;
-    struct procsinfo pi[MAX_PROCS];
-
-    while((count=getprocs(&pi, sizeof(pi[0]), 0, 0, &pid, 1)) >0 && !error)
-    {
-        for (i = 0; i<count && !error; i++)
-            if(pi[i].pi_ppid==ppid && pi[i].pi_comm && 0==strcmp(pi[i].pi_comm, proc))
-                if(pid)
-                    error=true;
-                else
-                    pid=pi[i].pi_pid;
-
-        idx=pi[count-1].pi_idx+1;
-    }
-
-    return error ? 0 : pid;
-}
-
-#else
-#warning "Unable to determine operating system version!  This may cause the getPid() function to fail at random!"
-
-/* Default to reading "ps -eaf" output */
-
-#include <pwd.h>
-#include <limits.h>
-#include <ctype.h>
-
-#define FOUND_PID  1
-#define FOUND_PPID 2
-#define FOUND_CMD  4
-#define FOUND_ALL  (FOUND_PID+FOUND_PPID+FOUND_CMD)
-
-static int checkCmd(const char *proc, const char *cmd)
-{
-    int len=(int)strlen(cmd),
-        ch;
-
-    if(len>1)
-        for(ch=len-2; ch>=0; --ch)
-            if('/'==cmd[ch])
-                return strcmp(proc, &cmd[ch+1]);
-
-    return strcmp(proc, cmd);
-}
-
-unsigned int kfi_getPid(const char *proc, unsigned int ppid)
-{
-    bool         error=false;
-    unsigned int pid=0;
-    static int   pid_c=-1,
-                 ppid_c=-1,
-                 time_c=-1,
-                 cmd_c=-1;
-
-    char         cmd[BUFSIZE+1];
-    FILE         *p;
-
-    /* If this function has been run before, and we know the column positions, then we can grep for just our command */
-    if(-1!=pid_c && -1!=ppid_c && -1!=time_c && -1!=cmd_c)
-        snprintf(cmd, BUFSIZE, "ps -eaf | grep %s", proc);
-    else
-        strcpy(cmd, "ps -eaf");
-
-    if(NULL!=(p=popen(cmd, "r")))
-    {
-        char line[BUFSIZE+1];
-        int  c=0;
-        char *linep=NULL,
-             *token=NULL;
-
-        /* Read 1st line to determine columns... */
-        if((-1==pid_c || -1==ppid_c || -1==time_c || -1==cmd_c) && NULL!=fgets(line, BUFSIZE, p))
-        {
-            for(linep=line; -1==pid_c || -1==ppid_c || -1==time_c || -1==cmd_c; linep=NULL)
-                if(NULL!=(token=strtok(linep, " \t\n")))
-                {
-                    if(0==strcmp("PID", token))
-                        pid_c=c;
-                    else if(0==strcmp("PPID", token))
-                        ppid_c=c;
-                    else if(NULL!=strstr("TIME", token))
-                        time_c=c;
-                    else if(0==strcmp("COMMAND", token) || 0==strcmp("CMD", token))
-                        cmd_c=c;
-                    c++;
-                }
-                else
-                    break;
-        }
-
-        /* If all column headings read, then look for details... */ 
-        if(-1!=pid_c && -1!=ppid_c && -1!=time_c && -1!=cmd_c)
-            while(NULL!=fgets(line, BUFSIZE, p) && !error)
-            {
-                int found=0,
-                    ps_pid=0,
-                    offset=0;
-
-                c=0;
-                for(linep=line; FOUND_ALL!=found; linep=NULL)
-                    if(NULL!=(token=strtok(linep, " \t\n")))
-                    {
-                        if(c==pid_c)
-                        {
-                            found|=FOUND_PID;
-                            ps_pid=atoi(token);
-                        }
-                        else if(c==ppid_c)
-                        {
-                            if(((unsigned int)atoi(token))!=ppid)
-                                break;
-                            found|=FOUND_PPID;
-                        }
-                        else if(c==time_c)
-                            offset=isdigit(token[0]) ? 0 : 1;
-                        else if(c==(cmd_c+offset))
-                        {
-                            if(0!=checkCmd(proc, token))
-                                break;
-                            found|=FOUND_CMD;
-                        }
-                        c++;
-                    }
-                    else
-                        break;
-
-                if(FOUND_ALL==found)
-                {
-                    if(pid)
-                        error=true;
-                    else
-                        pid=ps_pid;
-                }
-            }
-        pclose(p);
-    }
-
-    return error ? 0 : pid;
-}
-
-#endif
-
-#ifdef TEST_GETPID
-int main(int argc, char *argv[])
-{
-    if(3==argc)
-        printf("PID %u\n", kfi_getPid(argv[1], atoi(argv[2])));
-    else
-        printf("Usage: %s <process> <parent-process-id>\n", argv[0]);
-    return 0;
-}
-#endif
diff --git a/kcontrol/kfontinst/kfontinst/Main.cpp b/kcontrol/kfontinst/kfontinst/Main.cpp
deleted file mode 100644
index 6db9b83c8..000000000
--- a/kcontrol/kfontinst/kfontinst/Main.cpp
+++ /dev/null
@@ -1,335 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-//
-// File Name     : Main.cpp
-// Author        : Craig Drummond
-// Project       : K Font Installer
-// Creation Date : 20/03/2003
-// Version       : $Revision$ $Date$
-//
-////////////////////////////////////////////////////////////////////////////////
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-//
-////////////////////////////////////////////////////////////////////////////////
-// (C) Craig Drummond, 2003, 2004
-////////////////////////////////////////////////////////////////////////////////
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include "Misc.h"
-#include "FontEngine.h"
-#include "Fontmap.h"
-#include "XConfig.h"
-#include "kxftconfig.h"
-#include <fontconfig/fontconfig.h>
-#include <tqfile.h>
-#include <stdio.h>
-
-//
-// Bug#99335 Solaris 2.6 does not have getopt.h :-(
-#ifdef HAVE_GETOPT_H
-#include <getopt.h>
-#else
-#include <unistd.h>
-#endif
-#include <iostream>
-
-#define KFI_XF86CFG "XF86Config"
-#define KFI_XORGCFG "xorg.conf"
-
-static const char * getFile(const char *entry, const char **posibilities)
-{
-    if(KFI::Misc::fExists(entry))
-        return entry;
-    else
-    {
-        int f;
-
-        for(f=0; posibilities[f]; ++f)
-            if(KFI::Misc::fExists(posibilities[f]))
-                break;
-
-        return posibilities[f];
-    }
-}
-
-static const char * constXConfigFiles[]=
-{   
-    "/etc/X11/"KFI_XORGCFG,
-    "/etc/X11/"KFI_XORGCFG"-4",
-    "/etc/"KFI_XORGCFG,
-    "/usr/X11R6/etc/X11/"KFI_XORGCFG,
-    "/usr/X11R6/etc/X11/"KFI_XORGCFG"-4",
-    "/usr/X11R6/lib/X11/"KFI_XORGCFG,
-    "/usr/X11R6/lib/X11/"KFI_XORGCFG"-4",
-
-    "/etc/X11/"KFI_XF86CFG"-4",
-    "/etc/X11/"KFI_XF86CFG,
-    "/etc/"KFI_XF86CFG"-4",
-    "/etc/"KFI_XF86CFG,
-    "/usr/X11R6/etc/X11/"KFI_XF86CFG"-4",
-    "/usr/X11R6/etc/X11/"KFI_XF86CFG,
-    "/usr/X11R6/lib/X11/"KFI_XF86CFG"-4",
-    "/usr/X11R6/lib/X11/"KFI_XF86CFG,
-
-    NULL
-};  
-
-static const char * constXfsConfigFiles[]=
-{
-    "/etc/X11/fs/config",
-    "/usr/openwin/lib/X11/fonts/fontserver.cfg",
-    NULL
-};
-
-KFI::CXConfig * getXCfg(bool root)
-{
-    if(root)
-    {
-        //
-        // Try to determine location for X and xfs config files...
-        // ...note on some systems (Solaris and HP-UX) only the xfs file will be found
-        bool          xfs=false;
-        KFI::CXConfig *xcfg=NULL;
-        TQString       xConfigFile=getFile(TQFile::encodeName(constXConfigFiles[0]), constXConfigFiles),
-                      xfsConfigFile=getFile(TQFile::encodeName(constXfsConfigFiles[0]), constXfsConfigFiles);
-            
-        // If found xfs, but not X - then assume that xfs is being used...
-        if(!xfsConfigFile.isEmpty() && xConfigFile.isEmpty())
-            xfs=true;
-        else if(!xConfigFile.isEmpty()) // Read xConfig file to determine which one...
-        {
-            xcfg=new KFI::CXConfig(KFI::CXConfig::X11, xConfigFile);
-
-            if(!xfsConfigFile.isEmpty() && xcfg->xfsInPath())
-            {
-                delete xcfg;
-                xfs=true;
-            }
-        }
-
-        // OK, if still set to X11 config, but this mentions fontconfig FPE, then delete - as we're not interested
-        // anymore...
-        if(xcfg && xcfg->fcInPath())
-            delete xcfg;
-
-        return xfs ? new KFI::CXConfig(KFI::CXConfig::XFS, xfsConfigFile) : xcfg;
-    }
-
-    return NULL;
-}
-
-static void usage(char *app)
-{
-    std::cerr << "Usage: " << app << " [OPTIONS]... [FOLDER]..." << std::endl
-              << std::endl
-              << "  Helper application for KDE's fonts:/ ioslave." << std::endl
-              << std::endl
-#ifdef HAVE_GETOPT_H
-              << "  -x, --configure_x        Configure FOLDER for regular x - i.e." << std::endl
-              << "                           create fonts.dir, fonts.scale and encodngs.dir" << std::endl
-              << std::endl
-              << "  -g, --configure_gs       Create Fontmap file. If run as root, then " << std::endl
-              << "                           no paramter is required as all fonts are " << std::endl
-              << "                           configured, and Fontmap placed in /etc/fonts" << std::endl
-              << "                           For non-root, fonts located in FOLDER are" << std::endl
-              << "                           configured, and Fontmap placed there." << std::endl
-              << std::endl
-              << "  -f, --add_to_fc_cfg      Add FOLDER to fontconfig config files." << std::endl
-              << std::endl
-              << "  -a, --add_to_x_cfg       Add FOLDER to X config files only when run as root.," << std::endl
-              << std::endl
-              << "  -r, --refresh_x          Refresh X." << std::endl
-              << std::endl
-              << "  -s, --refresh_xfs        Refresh Xfs." << std::endl
-#else
-              << "  -x                       Configure FOLDER for regular x - i.e." << std::endl
-              << "                           create fonts.dir, fonts.scale and encodngs.dir" << std::endl
-              << std::endl
-              << "  -g                       Create Fontmap file. If run as root, then " << std::endl
-              << "                           no paramter is required as all fonts are " << std::endl
-              << "                           configured, and Fontmap placed in /etc/fonts" << std::endl
-              << "                           For non-root, fonts located in FOLDER are" << std::endl
-              << "                           configured, and Fontmap placed there." << std::endl
-              << std::endl
-              << "  -f                       Add FOLDER to fontconfig config files." << std::endl
-              << std::endl
-              << "  -a                       Add FOLDER to X config files only when run as root.," << std::endl
-              << std::endl
-              << "  -r                       Refresh X." << std::endl
-              << std::endl
-              << "  -s                       Refresh Xfs." << std::endl
-#endif
-              << std::endl
-              << std::endl
-              << "  (C) Craig Drummond, 2003, 2004." << std::endl
-              << std::endl;
-
-    exit(-1);
-}
-
-void refresh(bool refreshX, bool refreshXfs, bool root)
-{
-    if(refreshX)
-        KFI::CXConfig::refreshPaths(false);
-    if(refreshXfs && root)
-        KFI::CXConfig::refreshPaths(true);
-}
-
-int main(int argc, char *argv[])
-{
-#ifdef HAVE_GETOPT_H
-    static struct option options[]=
-    {
-        { "configure_x",    0, 0, 'x' },
-        { "configure_gs",   0, 0, 'g' },
-        { "add_to_fc_cfg",  0, 0, 'f' },
-        { "add_to_x_cfg",   0, 0, 'a' },
-        { "refresh_x",      0, 0, 'r' },
-        { "refresh_xfs",    0, 0, 's' },
-        { 0,                0, 0, 0   }
-    };
-#endif
-
-    int  c=0,
-         rv=0;
-    bool doX=false,
-         doGs=false,
-         addToX=false,
-         addToFc=false,
-         refreshX=false,
-         refreshXfs=false,
-         root=KFI::Misc::root();
-
-#ifdef HAVE_GETOPT_H
-    int optIndex;
-    while(-1!=(c=getopt_long(argc, argv, "xgfars", options, &optIndex)))
-#else
-    while(-1!=(c=getopt(argc, argv, "xgfars")))
-#endif
-        switch(c)
-        {
-            case 'x':
-                doX=true;
-                break;
-            case 'g':
-                doGs=true;
-                break;
-            case 'f':
-                addToFc=true;
-                break;
-            case 'a':
-                addToX=true;
-                break;
-            case 'r':
-                refreshX=true;
-                break;
-            case 's':
-                refreshXfs=true;
-                break;
-            case '?':
-                usage(argv[0]);
-                break;
-        }
-
-    int  left=argc-optind;
-    bool folderRequired=doX || addToX || addToFc || (!root && doGs);
-
-    if (left>1 || (0==left && folderRequired) || (!doX && !doGs && !addToX && !addToFc))
-        usage(argv[0]);
-    else
-    {
-        TQString folder;
-
-        if(folderRequired)
-        {
-            folder=argv[optind];
-            unsigned int len=folder.length();
-
-            // Remove quotes...
-            if( (folder[0]==TQChar('\'') || folder[0]==TQChar('\"')) &&
-                (folder[len-1]==TQChar('\'') || folder[len-1]==TQChar('\"')))
-                folder=folder.mid(1, len-2);
-            folder=KFI::Misc::dirSyntax(folder);
-        }
-
-        if(folderRequired && !KFI::Misc::dExists(folder))
-        {
-            std::cerr << "ERROR: " << static_cast<const char *>(TQFile::encodeName(folder)) << " does not exist!" << std::endl;
-            rv=-2;
-        }
-        else
-        {
-            if(!folder.isEmpty())
-            {
-                if(0==rv && addToFc)
-                {
-                    //
-                    // Only add folder to fontconfig's config if its not already there...
-                    FcStrList *list=FcConfigGetFontDirs(FcConfigGetCurrent());
-                    FcChar8   *dir;
-                    bool      found=false;
-
-                    while((dir=FcStrListNext(list)))
-                        if(0==KFI::Misc::dirSyntax((const char *)dir).find(folder))
-                            found=true;
-
-                    if(!found)
-                    {
-                        KXftConfig *xft=new KXftConfig(KXftConfig::Dirs, root);
-
-                        xft->addDir(folder);
-                        rv=xft->apply() ? 0 : -3;
-                        delete xft;
-                   }
-                }
-
-                if(0==rv && addToX && root)
-                {
-                    KFI::CXConfig *x=NULL;
-
-                    if((x=getXCfg(true)))
-                    {
-                        x->addPath(folder);
-                        rv=x->writeConfig() ? 0 : -4;
-                        delete x;
-                    }
-                    else
-                        rv=-5;
-                }
-            }
-
-            if(0==rv && (doX || doGs))
-            {
-                if(0==rv && doX)
-                    rv=KFI::CXConfig::configureDir(folder) ? 0 : -5;
-
-                refresh(refreshX, refreshXfs, root);
-
-                if(0==rv && doGs)
-                {
-                    KFI::CFontEngine fe;
-                    rv=KFI::Fontmap::create(root ? TQString::null : folder, fe) ? 0 : -6;
-                }
-            }
-            else if(0==rv)
-                refresh(refreshX, refreshXfs, root);
-        }
-    }
-
-    return rv;
-}
diff --git a/kcontrol/kfontinst/kfontinst/Makefile.am b/kcontrol/kfontinst/kfontinst/Makefile.am
deleted file mode 100644
index 3cfcfa689..000000000
--- a/kcontrol/kfontinst/kfontinst/Makefile.am
+++ /dev/null
@@ -1,16 +0,0 @@
-bin_PROGRAMS = kfontinst
-kfontinst_SOURCES = \
-Main.cpp \
-FontEngine.cpp \
-Fontmap.cpp \
-GetPid.c \
-XConfig.cpp
-
-noinst_HEADERS= \
-FontEngine.h \
-Fontmap.h \
-XConfig.h
-
-kfontinst_LDADD = ../../fonts/libkxftconfig.la $(LIBFONTCONFIG_LIBS) $(LIBFREETYPE_LIBS) $(LIBZ) $(LIB_KIO) ../lib/libkfontinst.la
-kfontinst_LDFLAGS = $(all_libraries) $(LIBFONTCONFIG_RPATH) $(LIBFREETYPE_RPATH) $(KDE_RPATH)
-AM_CPPFLAGS= -DOS_$(UNAME) -I$(srcdir)/../lib -I$(srcdir)/../../fonts $(all_includes) $(LIBFREETYPE_CFLAGS) $(LIBFONTCONFIG_CFLAGS)
diff --git a/kcontrol/kfontinst/kfontinst/XConfig.cpp b/kcontrol/kfontinst/kfontinst/XConfig.cpp
deleted file mode 100644
index 7572e3894..000000000
--- a/kcontrol/kfontinst/kfontinst/XConfig.cpp
+++ /dev/null
@@ -1,760 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-//
-// Class Name    : KFI::CXConfig
-// Author        : Craig Drummond
-// Project       : K Font Installer
-// Creation Date : 05/05/2001
-// Version       : $Revision$ $Date$
-//
-////////////////////////////////////////////////////////////////////////////////
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-//
-////////////////////////////////////////////////////////////////////////////////
-// (C) Craig Drummond, 2001, 2002, 2003, 2004
-////////////////////////////////////////////////////////////////////////////////
-
-#include "XConfig.h"
-#include "FontEngine.h"
-#include "kxftconfig.h"
-#include <ksavefile.h>
-#include <tqtextstream.h>
-#include <fstream>
-#include <string.h>
-#include <tqdir.h>
-#include <tqregexp.h>
-#include <klocale.h>
-#include <sys/types.h>
-#include <signal.h>
-
-#if defined OS_Irix || defined OS_Solaris
-extern "C" unsigned int kfi_getPid(const char *proc, pid_t ppid);
-#else
-extern "C" unsigned int kfi_getPid(const char *proc, unsigned int ppid);
-#endif 
-
-#define UNSCALED ":unscaled"
-
-namespace KFI
-{
-
-CXConfig::CXConfig(EType type, const TQString &file)
-        : itsType(type),
-          itsFileName(file),
-          itsOk(false),
-          itsWritable(false)
-{
-    itsPaths.setAutoDelete(true);
-    readConfig();
-}
-
-bool CXConfig::configureDir(const TQString &dir)
-{
-    //
-    // On systems without mkfontscale, the following will fail, so cant base
-    // return value upon that - hence only check return value of mkfontdir
-    Misc::doCmd("mkfontscale", TQFile::encodeName(dir));
-    return Misc::doCmd("mkfontdir", TQFile::encodeName(dir));
-}
-
-bool CXConfig::readConfig()
-{
-    itsOk=false;
-
-    switch(itsType)
-    {
-        case XFS:
-            itsOk=processXfs(true);
-            break;
-        case X11:
-            itsOk=processX11(true);
-            break;
-    }
-
-    if(itsOk)
-        itsWritable=Misc::fExists(itsFileName) ? Misc::fWritable(itsFileName)
-                                               : Misc::dWritable(Misc::getDir(itsFileName));
-    else
-        itsWritable=false;
-
-    return itsOk;
-}
-
-bool CXConfig::writeConfig()
-{
-    bool written=false;
-
-    //
-    // Check if file has been written since we last read it. If so, then re-read
-    // and add any new paths that we've added...
-    if(Misc::fExists(itsFileName) && Misc::getTimeStamp(itsFileName)!=itsTime)
-    {
-        CXConfig newConfig(itsType, itsFileName);
-
-        if(newConfig.ok())
-        {
-            TPath *path;
-
-            for(path=itsPaths.first(); path; path=itsPaths.next())
-                if(TPath::DIR==path->type && !path->orig)
-                    newConfig.addPath(path->dir, path->unscaled);
-
-            written=newConfig.madeChanges() ? newConfig.writeConfig() : true;
-        }
-    }
-    else
-        switch(itsType)
-        {
-            case XFS:
-                written=processXfs(false);
-                break;
-            case X11:
-                written=processX11(false);
-                break;
-        }
-    if(written)
-        readConfig();
-
-    return written;
-}
-
-bool CXConfig::madeChanges()
-{
-    if(itsOk && itsWritable)
-    {
-        TPath *path;
- 
-        for(path=itsPaths.first(); path; path=itsPaths.next())
-            if(!path->orig)
-                return true;
-    }
-
-    return false;
-}
- 
-void CXConfig::addPath(const TQString &dir, bool unscaled)
-{
-    if(itsWritable)
-    {
-        TQString ds(Misc::dirSyntax(dir));
-
-        if(Misc::dExists(dir))
-        {
-            TPath *path=findPath(ds);
-
-            if(NULL==path)
-                itsPaths.append(new TPath(ds, unscaled, TPath::DIR, false));
-        }
-    }
-}
-
-bool CXConfig::inPath(TPath::EType type)
-{
-    if(itsOk && X11==itsType)
-    {
-        TPath *path=NULL;
-
-        for(path=itsPaths.first(); path; path=itsPaths.next())
-            if(type==path->type)
-                return true;
-    }
-
-    return false;
-}
-
-void CXConfig::refreshPaths(bool xfs)
-{ 
-    if(xfs)
-    {
-        if(Misc::root())
-        {
-            unsigned int xfsPid=kfi_getPid("xfs", 1);
-
-            if(xfsPid)
-            { 
-                TQString pid;
-
-                kill(xfsPid, SIGUSR1);
-            }
-        }
-    }
-    else
-        Misc::doCmd("xset", "fp", "rehash");
-}
-
-CXConfig::TPath * CXConfig::findPath(const TQString &dir)
-{
-    TPath   *path=NULL;
-    TQString ds(Misc::dirSyntax(dir));
- 
-    for(path=itsPaths.first(); path; path=itsPaths.next())
-        if(path->dir==ds)
-            return path;
- 
-    return NULL;
-}
-
-static void processPath(char *str, TQString &path, bool &unscaled)
-{
-    char *unsc=NULL;
-
-    unscaled=false;
- 
-    if(NULL!=(unsc=strstr(str, UNSCALED)))
-    {
-        *unsc='\0';
-        unscaled=true;
-    }
- 
-    path=str;
-
-    if(str[strlen(str)-1]!='/')
-        path+="/";
-}
-
-inline bool isWhitespace(char ch)
-{
-    return (' '==ch || '\t'==ch || '\n'==ch) ? true : false;
-}
- 
-static unsigned int commentChars(char *buffer)
-{
-    unsigned int num=0;
- 
-    if(buffer[0]=='#')
-        for(num=1; num<strlen(buffer)+1; ++num)
-            if(buffer[num]=='\n' || buffer[num]=='\0')
-                break;
- 
-    return num;
-}
-
-static bool commentedOut(char *buffer, char *sect)
-{
-    if(sect!=buffer && '\n'!=*(sect-1))
-    {
-        char *ch;
-
-        for(ch=sect-1; ch>=buffer; ch--)
-            if(*ch=='\n')
-                break;
-            else if(*ch=='#')
-                return true;
-    }
-
-    return false;
-}
-
-static char * locateSection(char *buffer, const char *section)
-{
-    const char *sectionMarker   ="Section";
-    const int   sectionMarkerLen=7;
-
-    char *s=NULL,
-         *buf=buffer;
-
-    do
-    {
-        s=strstr(buf, sectionMarker);
-
-        if(s)
-        {
-            bool com=commentedOut(buffer, s);
-
-            buf=s+sectionMarkerLen;
-            if(com)
-                s=NULL;
-            else
-            {
-                // Skip any whitespace
-                for(s+=sectionMarkerLen; s && isWhitespace(*s); s++)
-                    ;
-
-                // Now check section type
-                if(s && s==strstr(s, section))   // If found, then again skip past whitespace
-                    for(s+=strlen(section); s && isWhitespace(*s); s++)
-                        ;
-                else
-                    s=NULL;
-            }
-        }
-        else
-            break;
-    }
-    while(!s);
-
-    return s;
-}
-
-static const char *endSectionMarker   ="EndSection";
-static const int   endSectionMarkerLen=10;
-
-static char *locateEndSection(char *buffer)
-{
-    char *s=NULL,
-         *buf=buffer;
-
-    do
-    {
-        s=strstr(buf, endSectionMarker);
-
-        if(s)
-        {
-            bool com=commentedOut(buffer, s);
-
-            buf=s+endSectionMarkerLen;
-            if(com)
-                s=NULL;
-        }
-        else
-            break;
-    }
-    while(!s);
-
-    return s;
-}
-
-static char * getItem(char **start, char **end, const char *key, unsigned int &size, bool remove, char *buffer)
-{
-    static const int constMaxItemLen = 1024;
-    static char      item[constMaxItemLen+1];
-
-    unsigned int keyLen=strlen(key);
-
-    char *s=NULL,
-         *buf=*start;
-
-    do
-    {
-        s=strstr(buf, key);
-
-        if(s && s<*end)
-        {
-            bool com=commentedOut(buf, s);
-
-            buf=s+keyLen;
-            if(com)
-                s=NULL;
-            else
-            {
-                char *beg=s;
-                // Skip any whitespace
-                for(s+=keyLen; s && isWhitespace(*s); s++)
-                    ;
-
-                if(s && *s=='\"' && s<*end)
-                {
-                    char *e=strchr(s+1, '\"'),
-                         *nl=strchr(s+1, '\n');
-
-                    if(e && e<*end && (!nl || nl>e) && e-s<=constMaxItemLen)
-                    {
-                        memcpy(item, s+1, (e-s)-1);
-                        item[(e-s)-1]='\0';
-
-                        if(remove)
-                        {
-                            for(beg--; beg>=buffer && *beg!='\n' && *beg !='\"'; beg--)
-                                ;
-                            if(!nl)
-                                nl=e+1;
-                            memmove(beg, nl, ((buffer+size)-nl)+1);
-                            size-=nl-beg;
-                            *end-=nl-beg;
-                        }
-                        else
-                            *start=e+1;
-
-                        return item;
-                    }
-                    else
-                        s=NULL;
-                }
-                else
-                    s=NULL;
-            }
-        }
-        else
-            break;
-    }
-    while(!s);
-
-    return NULL;
-}
-
-bool CXConfig::processX11(bool read)
-{
-    std::ifstream x11(TQFile::encodeName(itsFileName));
-    bool          ok=false;
-
-    if(x11)
-    {
-        itsTime=Misc::getTimeStamp(itsFileName);
-
-        bool closed=false;
-
-        x11.seekg(0, std::ios::end);
-        unsigned int size=(std::streamoff) x11.tellg();
-
-        if(read)
-            itsPaths.clear();
-
-        if(size<65536) // Just incase...
-        {
-            char *buffer=new char [size+1];
-
-            if(buffer)
-            {
-                x11.seekg(0, std::ios::beg);
-                x11.read(buffer, size);
-
-                if(x11.good())
-                {
-                    char *filesStart=NULL,
-                         *filesEnd=NULL;
-
-                    closed=true;
-                    x11.close();
-                    buffer[size]='\0';
-
-                    if(NULL!=(filesStart=locateSection(buffer, "\"Files\"")) && NULL!=(filesEnd=locateEndSection(filesStart)))
-                    {
-                        char *pos=filesStart,
-                             *item;
-
-                        while(NULL!=(item=getItem(&pos, &filesEnd, "FontPath", size, !read, buffer)))
-                            if(read) // Then save paths...
-                            {
-                                TQString path;
-                                bool    unscaled;
-
-                                processPath(item, path, unscaled);
-
-                                if(NULL==findPath(path))
-                                    itsPaths.append(new TPath(path, unscaled, TPath::getType(path)));
-                            }
-
-                        if(read)
-                            ok=true;
-                        else
-                        {
-                            Misc::createBackup(itsFileName);
-
-                            KSaveFile   out(itsFileName);
-                            FILE        *fstream=out.fstream();
-
-                            if(fstream)
-                            {
-                                char  *from=buffer,
-                                      *modStart=NULL,
-                                      *modEnd=NULL;
-                                bool  foundFt=false;
-                                TPath *path;
-
-                                // Check if "freetype" OR "xtt" is loaded for usage of TTF's
-                                if(NULL!=(modStart=locateSection(buffer, "\"Module\"")) && NULL!=(modEnd=locateEndSection(modStart)))
-                                { 
-                                    pos=modStart;
-
-                                    while(NULL!=(item=getItem(&pos, &modEnd, "Load", size, false, buffer)) && !foundFt)
-                                        if(0==strcmp(item, "freetype") || 0==strcmp(item, "xtt"))
-                                            foundFt=true;
-                                }
-
-                                if(!foundFt && modStart && modEnd && modStart<filesStart) // Then write mod section first...
-                                {
-                                    fwrite(from, 1, modEnd-from, fstream);
-                                    if(!foundFt)
-                                        fputs("    Load \"freetype\"\n", fstream);    // CPD TODO: Which is better xtt of freetype? Perhaps check locale?
-                                    fwrite(modEnd, 1, endSectionMarkerLen, fstream);
-                                    from=modEnd+endSectionMarkerLen;
-                                }
-
-                                fwrite(from, 1, filesEnd-from, fstream);
-
-                                for(path=itsPaths.first(); path; path=itsPaths.next())
-                                    if(TPath::DIR!=path->type || Misc::dExists(path->dir))
-                                    {
-                                        TQCString cPath(TQFile::encodeName(Misc::xDirSyntax(path->dir)));
-
-                                        fputs("    FontPath \t\"", fstream);
-                                        fwrite(cPath.data(), 1, cPath.length(), fstream);
-                                        if(path->unscaled)
-                                            fputs(UNSCALED, fstream);
-                                        fputs("\"\n", fstream);
-                                    }
-
-                                fwrite(filesEnd, 1, endSectionMarkerLen, fstream);
-                                from=filesEnd+endSectionMarkerLen;
-
-                                if(!foundFt && modStart && modEnd && modStart>filesStart) // Then write mod section last...
-                                {
-                                    fwrite(from, 1, modEnd-from, fstream);
-                                    if(!foundFt)
-                                        fputs("    Load \"freetype\"\n", fstream);
-                                    fwrite(modEnd, 1, endSectionMarkerLen, fstream);
-                                    from=modEnd+endSectionMarkerLen;
-                                }
-                                if(((unsigned int)(from-buffer))<size)
-                                    fwrite(from, 1, size-(from-buffer), fstream);
-                                ok=true;
-                            }
-                        }
-                    }
-                }
-                delete [] buffer;
-            }
-        }
-        if(!closed)
-            x11.close();
-    }
-
-    return ok;
-}
- 
-static bool isXfsKey(const char *str)
-{
-    static const char *constKeys[]=
-    {
-        "alternate-servers",
-        "cache-balance",
-        "cache-hi-mark",
-        "cache-low-mark",
-        "catalogue",
-        "client-limit",
-        "clone-self",
-        "default-point-size",
-        "default-resolutions",
-        "deferglyphs",
-        "error-file",
-        "no-listen",
-        "port",
-        "server-number",
-        "snf-format",
-        "trusted-clients",
-        "use-syslog",
-        NULL
-    };
- 
-    for(unsigned int key=0; NULL!=constKeys[key]; ++key)
-        if(strstr(str, constKeys[key])==str)
-        {
-            unsigned int sLen=strlen(str),
-                         kLen=strlen(constKeys[key]);
- 
-            if(sLen>kLen && isWhitespace(str[kLen]) || '\0'==str[kLen] || '#'==str[kLen] || '='==str[kLen])
-                return true;
-        }
- 
-    return false;
-}
-
-static char * getXfsPath(char *buffer, unsigned int &totalSize, unsigned int offsetSize)
-{
-    // Remove & return a path from the buffer
-    const unsigned int constMaxPathLen=8192;
- 
-    static char path[constMaxPathLen];
-    bool        found=false;
-
-    if(offsetSize<totalSize) // Just to make sure soething hasn't gone horribly wrong!
-    {
-        unsigned int i;
- 
-        for(i=0; i<offsetSize && !found; i++)
-            if(!isWhitespace(buffer[i]) && ','!=buffer[i])
-            {
-                unsigned int comChars=commentChars(&buffer[i]);
- 
-                if(comChars)
-                    i+=comChars;
-                else
-                    if(isXfsKey(&buffer[i]))
-                        break;
-                    else
-                    {
-                        // A path is terminated by either a comma, another key, or eof...
- 
-                        unsigned int j=0;
- 
-                        for(j=1; j<offsetSize-i && !found; j++)
-                            if(buffer[i+j]==',' || buffer[i+j]=='\n' || buffer[i+j]=='\0' || isXfsKey(&buffer[i+j]))
-                            {
-                                if(j>0 && j<constMaxPathLen)
-                                {
-                                    memcpy(path, &buffer[i], j);
-                                    path[j]='\0';
-                                    if(buffer[i+j]==',')
-                                        j++;
-                                    memmove(buffer, &buffer[i+j], (offsetSize-(i+j))+1);
-                                    totalSize-=(i+j);
-                                    found=true;
-                                }
-                            }
-                    }
-            }
-    }
-
-    return found ? path : NULL;
-}
-
-bool CXConfig::processXfs(bool read)
-{
-    std::ifstream xfs(TQFile::encodeName(itsFileName));
-    bool          ok=false;
- 
-    if(xfs)
-    {
-        itsTime=Misc::getTimeStamp(itsFileName);
-
-        bool closed=false;
- 
-        xfs.seekg(0, std::ios::end);
-        unsigned int size= (std::streamoff) xfs.tellg();
-
-        if(read)
-            itsPaths.clear();
- 
-        if(size<32768) // Just incase...
-        {
-            char *buffer=new char [size+1];
- 
-            if(buffer)
-            {
-                xfs.seekg(0, std::ios::beg);
-                xfs.read(buffer, size);
- 
-                if(xfs.good())
-                {
-                    const char *constCatalogueStr="catalogue";
-                    char *cat=NULL;
-                    bool found=false,
-                         formatError=false;
- 
-                    closed=true;
-                    xfs.close();
-                    buffer[size]='\0';
- 
-                    // Now remove the directory lists from the buffer...
-                    do
-                        if(NULL!=(cat=strstr(buffer, constCatalogueStr)))
-                        {
-                            cat+=strlen(constCatalogueStr);
- 
-                            if(!isWhitespace(*(cat-1)))
-                            {
-                                // Check it's not been commented out - by searching back until we get to the start of the buffer,
-                                // a carriage-return, or a hash...
- 
-                                if(!commentedOut(buffer, cat))
-                                {
-                                    // Look for '='
-                                    unsigned int i;
- 
-                                    for(i=1; i<size-(cat-buffer) && !found && !formatError; ++i)
-                                        if(!isWhitespace(cat[i]))
-                                        {
-                                            unsigned int comChars=commentChars(&cat[i]);
- 
-                                            if(comChars)
-                                                i+=comChars;
-                                            else
-                                                if(cat[i]!='=' || i+1>=size-(cat-buffer))
-                                                    formatError=true;
-                                                else
-                                                {
-                                                    char *path;
- 
-                                                    cat=&cat[i+1]; // skip equals sign
-                                                    while(NULL!=(path=getXfsPath(cat, size, size-(cat-buffer))))
-                                                        if(read)
-                                                        {
-                                                            TQString str;
-                                                            bool    unscaled;
-                                                            processPath(path, str, unscaled);
- 
-                                                            if(NULL==findPath(path))
-                                                                itsPaths.append(new TPath(str, unscaled));
-                                                        }
- 
-                                                    if(!read) // then must be write...
-                                                    {
-                                                        Misc::createBackup(itsFileName);
-
-                                                        KSaveFile out(itsFileName);
-                                                        FILE      *fstream=out.fstream();
-
-                                                        if(fstream)
-                                                        {
-                                                            bool  first=true;
-                                                            TPath *p=NULL;
-
-                                                            fwrite(buffer, 1, cat-buffer, fstream);
-                                                            fputc(' ', fstream);
-                                                            for(p=itsPaths.first(); p; p=itsPaths.next())
-                                                                if(Misc::dExists(p->dir))
-                                                                {
-                                                                    TQCString cPath(TQFile::encodeName(Misc::xDirSyntax(p->dir)));
-
-                                                                    if(!first)
-                                                                    {
-                                                                        fputc(',', fstream);
-                                                                        fputc('\n', fstream);
-                                                                    }
-                                                                    fwrite(cPath.data(), 1, cPath.length(), fstream);
-                                                                    if(p->unscaled)
-                                                                        fputs(UNSCALED, fstream);
-                                                                    first=false;
-                                                                }
-                                                            fwrite(cat, 1, size-(cat-buffer), fstream);
-                                                            ok=true;
-                                                        }
-                                                    }
-                                                    else
-                                                        ok=true;
- 
-                                                    found=true;
-                                                }
-                                        }
-                                }
-                            }
-                        }
-                    while(NULL!=cat && !found && !formatError);
-                }
-                delete [] buffer;
-            }
-        }
-        if(!closed)
-            xfs.close();
-    }
- 
-    return ok;
-}
-
-
-CXConfig::TPath::EType CXConfig::TPath::getType(const TQString &d)
-{
-    TQString str(d);
-
-    str.replace(TQRegExp("\\s*"), "");
-
-    return 0==str.find("unix/:")
-               ? FONT_SERVER
-               : "fontconfig"==str
-                   ? FONT_CONFIG
-                   : DIR;
-}
-
-}
diff --git a/kcontrol/kfontinst/kfontinst/XConfig.h b/kcontrol/kfontinst/kfontinst/XConfig.h
deleted file mode 100644
index 127b243fa..000000000
--- a/kcontrol/kfontinst/kfontinst/XConfig.h
+++ /dev/null
@@ -1,114 +0,0 @@
-#ifndef __X_CONFIG_H__
-#define __X_CONFIG_H__
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Class Name    : KFI::CXConfig
-// Author        : Craig Drummond
-// Project       : K Font Installer
-// Creation Date : 05/05/2001
-// Version       : $Revision$ $Date$
-//
-////////////////////////////////////////////////////////////////////////////////
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-//
-////////////////////////////////////////////////////////////////////////////////
-// (C) Craig Drummond, 2001, 2002, 2003, 2004
-///////////////////////////////////////////////////////////////////////////////
-
-#include "Misc.h"
-#include <tqptrlist.h>
-#include <tqstring.h>
-#include <tqstringlist.h>
-#include <time.h>
-
-namespace KFI
-{
-
-class CFontEngine;
-
-class CXConfig
-{
-    public:
-
-    struct TPath
-    {
-        enum EType
-        {
-            DIR,
-            FONT_SERVER,
-            FONT_CONFIG
-        };
-
-        TPath(const TQString &d, bool u=false, EType t=DIR, bool o=true)
-           : dir(DIR==t ? Misc::dirSyntax(d) : d), unscaled(u), orig(o), type(t) {}
-
-        static EType getType(const TQString &d);
-
-        TQString dir;
-        bool    unscaled,
-                orig;          // Was dir in file when read?
-        EType   type;
-    };
-
-    enum EType
-    {
-        XFS,
-        X11
-    };
-
-    public:
-
-    CXConfig(EType type, const TQString &file);
-
-    static bool configureDir(const TQString &dir);
-
-    bool  ok()                       { return itsOk; }
-    bool  writable()                 { return itsWritable; }
-    bool  readConfig();
-    bool  writeConfig();
-    bool  madeChanges();
-    void  addPath(const TQString &dir, bool unscaled=false);
-    bool  inPath(TPath::EType type);
-    bool  xfsInPath()                { return inPath(TPath::FONT_SERVER); }
-    bool  fcInPath()                 { return inPath(TPath::FONT_CONFIG); }
-    void  refreshPaths()             { refreshPaths(XFS==itsType); }
-    void  restart();
-    EType getType()                  { return itsType; }
-
-    static void refreshPaths(bool xfs);
-
-    private:
-
-    bool processX11(bool read);
-    bool processXfs(bool read);
-
-    TPath * findPath(const TQString &dir);
-
-    private:
-
-    EType           itsType;
-    TQPtrList<TPath> itsPaths;
-    TQString         itsFileName,
-                    itsInsertPos;
-    bool            itsOk,
-                    itsWritable;
-    time_t          itsTime;
-};
-
-}
-
-#endif