TQt4 port piklab

This enables compilation under both Qt3 and Qt4 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/piklab@1238822 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
author: tpearson <tpearson@283d02a7-25f6-0310-bc7c-ecb5cbfe19da> 2011-06-30 00:15:53 +0000
committer: tpearson <tpearson@283d02a7-25f6-0310-bc7c-ecb5cbfe19da> 2011-06-30 00:15:53 +0000
commit: 0aaa8e3fc8f8a1481333b564f0922277c8d8ad59 (patch)
tree: b95c0ca86c4876dd139af376b9f4afd8917cf0cd /src/tools
parent: b79a2c28534cf09987eeeba3077fff9236df182a (diff)
download: piklab-0aaa8e3fc8f8a1481333b564f0922277c8d8ad59.tar.gz
piklab-0aaa8e3fc8f8a1481333b564f0922277c8d8ad59.zip
96 files changed, 1010 insertions, 949 deletions
diff --git a/src/tools/base/generic_tool.h b/src/tools/base/generic_tool.h
index 3b3299d..86cd3f2 100644
--- a/src/tools/base/generic_tool.h
+++ b/src/tools/base/generic_tool.h
@@ -47,11 +47,11 @@ namespace Compile
   class Data {
   public:
     Data() {}
-    Data(Tool::Category c, const QValueList<TodoItem> &i, const QString &d, const Project *p, LinkType lt)
+    Data(Tool::Category c, const TQValueList<TodoItem> &i, const TQString &d, const Project *p, LinkType lt)
       : category(c), items(i), device(d), project(p), linkType(lt) {}
     Tool::Category category;
-    QValueList<TodoItem> items;
-    QString  device;
+    TQValueList<TodoItem> items;
+    TQString  device;
     const Project *project;
     LinkType linkType;
   };
@@ -84,13 +84,13 @@ class Base
 public:
   virtual ~Base() {}
   const Group &group() const { return *_group; }
-  virtual QString baseExecutable(bool withWine, OutputExecutableType type) const = 0;
+  virtual TQString baseExecutable(bool withWine, OutputExecutableType type) const = 0;
   PURL::Directory executableDirectory() const;
   virtual bool checkExecutable() const { return true; }
-  virtual QStringList checkExecutableOptions(bool withWine) const = 0;
+  virtual TQStringList checkExecutableOptions(bool withWine) const = 0;
   virtual PURL::Directory checkExecutableWorkingDirectory() const { return PURL::Directory(); }
   virtual ::Process::LineOutput *checkExecutableProcess(const PURL::Directory &dir, bool withWine, OutputExecutableType type) const;
-  virtual bool checkExecutableResult(bool withWine, QStringList &lines) const = 0;
+  virtual bool checkExecutableResult(bool withWine, TQStringList &lines) const = 0;
 
 protected:
   Category _category;
diff --git a/src/tools/base/tool_group.cpp b/src/tools/base/tool_group.cpp
index fb347ce..ac5c75e 100644
--- a/src/tools/base/tool_group.cpp
+++ b/src/tools/base/tool_group.cpp
@@ -58,9 +58,9 @@ PURL::Directory Tool::Group::autodetectDirectory(Compile::DirectoryType, const P
   return PURL::Directory();
 }
 
-QString Tool::Group::defaultLinkerScriptFilename(Compile::LinkType type, const QString &device) const
+TQString Tool::Group::defaultLinkerScriptFilename(Compile::LinkType type, const TQString &device) const
 {
-  QString basename = device.lower();
+  TQString basename = device.lower();
   if ( type==Compile::Icd2Linking ) basename += 'i';
   return basename + '.' + PURL::extension(PURL::Lkr);
 }
@@ -73,7 +73,7 @@ bool Tool::Group::hasCustomLinkerScript(const ::Project *project) const
 PURL::Url Tool::Group::linkerScript(const ::Project *project, Compile::LinkType type) const
 {
   if ( hasCustomLinkerScript(project) ) return project->customLinkerScript();
-  QString filename = defaultLinkerScriptFilename(type, Compile::Config::device(project));
+  TQString filename = defaultLinkerScriptFilename(type, Compile::Config::device(project));
   return PURL::Url(Compile::Config::directory(*this, Compile::DirectoryType::LinkerScript), filename);
 }
 
@@ -81,12 +81,12 @@ PURL::Url Tool::Group::linkerScript(const ::Project *project, Compile::LinkType
 {
   ::Process::LineOutput *process = new ::Process::LineOutput;
   Tool::Category cat = checkDevicesCategory();
-  QString exec = base(cat)->baseExecutable(withWine, Compile::Config::outputExecutableType(*this));
+  TQString exec = base(cat)->baseExecutable(withWine, Compile::Config::outputExecutableType(*this));
   process->setup(dir.path() + exec, checkDevicesOptions(i), withWine);
   return process;
 }
 
-bool Tool::Group::checkExecutable(Tool::Category category, QStringList &lines)
+bool Tool::Group::checkExecutable(Tool::Category category, TQStringList &lines)
 {
   PURL::Directory dir = Compile::Config::directory(*this, Compile::DirectoryType::Executable);
   bool withWine = Compile::Config::withWine(*this);
@@ -102,32 +102,32 @@ void Tool::Group::initSupported()
 {
   _checkDevicesError = false;
   Tool::Category cat = checkDevicesCategory();
-  QValueList<const Device::Data *> list;
-  if ( cat==Tool::Category::Nb_Types ) list = getSupportedDevices(QString::null);
+  TQValueList<const Device::Data *> list;
+  if ( cat==Tool::Category::Nb_Types ) list = getSupportedDevices(TQString());
   else {
     PURL::Directory dir = Compile::Config::directory(*this, Compile::DirectoryType::Executable);
     for (uint i=0; i<nbCheckDevices(); i++) {
-      QStringList lines;
+      TQStringList lines;
       ::Process::LineOutput *process = checkDevicesProcess(i, dir, Compile::Config::withWine(*this));
       ::Process::State state = ::Process::runSynchronously(*process, ::Process::Start, 10000);
       if ( state==::Process::Exited ) {
-        QStringList lines = process->sout() + process->serr();
+        TQStringList lines = process->sout() + process->serr();
         list += getSupportedDevices(lines.join("\n"));
       } else _checkDevicesError = true;
       delete process;
     }
   }
-  QValueList<const Device::Data *>::const_iterator it;
+  TQValueList<const Device::Data *>::const_iterator it;
   for (it=list.begin(); it!=list.end(); ++it) addDevice((*it)->name(), *it, ::Group::Support::Tested);
 }
 
-bool Tool::Group::check(const QString &device, Log::Generic *log) const
+bool Tool::Group::check(const TQString &device, Log::Generic *log) const
 {
   const_cast<Tool::Group *>(this)->checkInitSupported();
   if ( hasCheckDevicesError() )
-    return (log ? log->askContinue(i18n("There were errors detecting supported devices for the selected toolchain (%1). Please check the toolchain configuration. Continue anyway?").arg(label())) : false);
+    return (log ? log->askContinue(i18n("There were errors detecting supported devices for the selected toolchain (%1). Please check the toolchain configuration. Continue anyway?").tqarg(label())) : false);
   if ( !device.isEmpty() && device!=Device::AUTO_DATA.name && !isSupported(device) )
-    return (log ? log->askContinue(i18n("The selected toolchain (%1) does not support device %2. Continue anyway?").arg(label()).arg(device)) : false);
+    return (log ? log->askContinue(i18n("The selected toolchain (%1) does not support device %2. Continue anyway?").tqarg(label()).tqarg(device)) : false);
   return true;
 }
 
diff --git a/src/tools/base/tool_group.h b/src/tools/base/tool_group.h
index c4adb84..86cfc64 100644
--- a/src/tools/base/tool_group.h
+++ b/src/tools/base/tool_group.h
@@ -28,10 +28,10 @@ public:
   static const char *CUSTOM_NAME;
   Group();
   bool isCustom() const { return ( name()==CUSTOM_NAME ); }
-  virtual QString comment() const { return QString::null; }
+  virtual TQString comment() const { return TQString(); }
   virtual void init();
   virtual const ::Tool::Base *base(Category category) const { return _bases[category].base; }
-  virtual QString informationText() const = 0;
+  virtual TQString informationText() const = 0;
   virtual ExecutableType preferedExecutableType() const = 0;
   virtual bool hasDirectory(Compile::DirectoryType) const { return false; }
   virtual PURL::FileType linkerScriptType() const { return PURL::Nb_FileTypes; }
@@ -40,9 +40,9 @@ public:
   virtual uint nbCheckDevices() const { return 1; }
   bool hasCheckDevicesError() const { return _checkDevicesError; }
   virtual Tool::Category checkDevicesCategory() const = 0;
-  virtual QStringList checkDevicesOptions(uint) const { return QStringList(); }
+  virtual TQStringList checkDevicesOptions(uint) const { return TQStringList(); }
   ::Process::LineOutput *checkDevicesProcess(uint i, const PURL::Directory &execDir, bool withWine) const;
-  virtual QValueList<const Device::Data *> getSupportedDevices(const QString &s) const = 0;
+  virtual TQValueList<const Device::Data *> getSupportedDevices(const TQString &s) const = 0;
   virtual CompileType compileType() const = 0;
   virtual bool needs(bool withProject, Category category) const;
   Compile::Process *createCompileProcess(const Compile::Data &data, Compile::Manager *manager) const;
@@ -52,9 +52,9 @@ public:
   virtual PURL::FileType implementationType(PURL::ToolType type) const = 0;
   virtual Compile::Process *processFactory(const Compile::Data &data) const = 0;
   const SourceGenerator *sourceGenerator() const { return _sourceGenerator; }
-  bool check(const QString &device, Log::Generic *log) const;
+  bool check(const TQString &device, Log::Generic *log) const;
   const VersionData &version() const { return _version; }
-  virtual bool generateDebugInformation(const QString &device) const { Q_UNUSED(device); return true; }
+  virtual bool generateDebugInformation(const TQString &device) const { Q_UNUSED(device); return true; }
 
 protected:
   enum NeedType { StandaloneOnly, ProjectOnly, Both };
@@ -67,15 +67,15 @@ protected:
   };
   virtual void initSupported();
   virtual BaseData baseFactory(Category category) const = 0;
-  virtual QString defaultLinkerScriptFilename(Compile::LinkType type, const QString &device) const;
+  virtual TQString defaultLinkerScriptFilename(Compile::LinkType type, const TQString &device) const;
   virtual Compile::Config *configFactory(::Project *project) const = 0;
   virtual SourceGenerator *sourceGeneratorFactory() const = 0;
-  bool checkExecutable(Tool::Category category, QStringList &lines);
+  bool checkExecutable(Tool::Category category, TQStringList &lines);
   virtual VersionData getToolchainVersion() { return VersionData(); }
 
 private:
   SourceGenerator *_sourceGenerator;
-  QMap<Category, BaseData> _bases;
+  TQMap<Category, BaseData> _bases;
   bool _checkDevicesError;
   VersionData _version;
 };
diff --git a/src/tools/boost/boost.cpp b/src/tools/boost/boost.cpp
index 86e304c..e67f833 100644
--- a/src/tools/boost/boost.cpp
+++ b/src/tools/boost/boost.cpp
@@ -15,7 +15,7 @@
 #include "devices/base/device_group.h"
 
 //----------------------------------------------------------------------------
-bool Boost::Linker::checkExecutableResult(bool, QStringList &lines) const
+bool Boost::Linker::checkExecutableResult(bool, TQStringList &lines) const
 {
   return ( lines.count()>0 && lines[0].startsWith("BoostLink ") );
 }
@@ -25,26 +25,26 @@ PURL::Directory Boost::Linker::checkExecutableWorkingDirectory() const
   return static_cast<const Group *>(_group)->checkExecutableUrl().directory();
 }
 
-QStringList Boost::Linker16::checkExecutableOptions(bool) const
+TQStringList Boost::Linker16::checkExecutableOptions(bool) const
 {
   // #### otherwise may stall...
-  QStringList args;
+  TQStringList args;
   args += "-t PIC16F873";
   args += static_cast<const Group *>(_group)->checkExecutableUrl().toExtension("obj").filename();
   return args;
 }
 
-QStringList Boost::Linker18::checkExecutableOptions(bool) const
+TQStringList Boost::Linker18::checkExecutableOptions(bool) const
 {
   // #### otherwise may stall...
-  QStringList args;
+  TQStringList args;
   args += "-t PIC18F452";
   args += static_cast<const Group *>(_group)->checkExecutableUrl().toExtension("obj").filename();
   return args;
 }
 
 //----------------------------------------------------------------------------
-QStringList Boost::Compiler::checkExecutableOptions(bool) const
+TQStringList Boost::Compiler::checkExecutableOptions(bool) const
 {
   // #### otherwise may stall...
   return static_cast<const Group *>(_group)->checkExecutableUrl().filename();
@@ -56,14 +56,14 @@ PURL::Directory Boost::Compiler::checkExecutableWorkingDirectory() const
 }
 
 //----------------------------------------------------------------------------
-Boost::Group::Group(const QString &extension, const QString &text)
+Boost::Group::Group(const TQString &extension, const TQString &text)
   : _checkExecTmp(_sview, extension)
 {
   if ( _checkExecTmp.openForWrite() ) _checkExecTmp.appendText(text);
   _checkExecTmp.close();
 }
 
-QString Boost::Group::comment() const
+TQString Boost::Group::comment() const
 {
   return i18n("The Boost toolchain needs to be run by Wine with \"Windows NT 4.0\" compatibility. This can be configured with the Wine configuration utility.");
 }
@@ -90,10 +90,10 @@ Compile::Config *Boost::Group::configFactory(::Project *project) const
   return new Boost::Config(project);
 }
 
-QValueList<const Device::Data *> Boost::Group::getSupportedDevices(const QString &) const
+TQValueList<const Device::Data *> Boost::Group::getSupportedDevices(const TQString &) const
 {
-  QValueList<const Device::Data *> list;
-  QValueVector<QString> devices = Device::lister().group("pic")->supportedDevices();
+  TQValueList<const Device::Data *> list;
+  TQValueVector<TQString> devices = Device::lister().group("pic")->supportedDevices();
   for (uint i=0; i<devices.count(); i++) {
     const Device::Data *data = Device::lister().data(devices[i]);
     if ( supportedArchitecture(static_cast<const Pic::Data *>(data)->architecture()) ) list.append(data);
diff --git a/src/tools/boost/boost.h b/src/tools/boost/boost.h
index d6142c9..34d1414 100644
--- a/src/tools/boost/boost.h
+++ b/src/tools/boost/boost.h
@@ -19,28 +19,28 @@ namespace Boost
 class Linker : public Tool::Base
 {
 private:
-  virtual QString baseExecutable(bool, Tool::OutputExecutableType) const { return "boostlink.pic.exe"; }
-  virtual bool checkExecutableResult(bool withWine, QStringList &lines) const;
+  virtual TQString baseExecutable(bool, Tool::OutputExecutableType) const { return "boostlink.pic.exe"; }
+  virtual bool checkExecutableResult(bool withWine, TQStringList &lines) const;
   virtual PURL::Directory checkExecutableWorkingDirectory() const;
 };
 
 class Linker16 : public Linker
 {
 private:
-  virtual QStringList checkExecutableOptions(bool withWine) const;
+  virtual TQStringList checkExecutableOptions(bool withWine) const;
 };
 
 class Linker18 : public Linker
 {
 private:
-  virtual QStringList checkExecutableOptions(bool withWine) const;
+  virtual TQStringList checkExecutableOptions(bool withWine) const;
 };
 
 //----------------------------------------------------------------------------
 class Compiler : public Tool::Base
 {
 private:
-  virtual QStringList checkExecutableOptions(bool withWine) const;
+  virtual TQStringList checkExecutableOptions(bool withWine) const;
   virtual PURL::Directory checkExecutableWorkingDirectory() const;
 };
 
@@ -48,9 +48,9 @@ private:
 class Group : public Tool::Group
 {
 public:
-  Group(const QString &extension, const QString &text);
+  Group(const TQString &extension, const TQString &text);
   PURL::Url checkExecutableUrl() const { return _checkExecTmp.url(); }
-  virtual QString comment() const;
+  virtual TQString comment() const;
   virtual Tool::Category checkDevicesCategory() const { return Tool::Category::Nb_Types; }
   virtual Tool::ExecutableType preferedExecutableType() const { return Tool::ExecutableType::Windows; }
   virtual Tool::CompileType compileType() const { return Tool::SeparateFiles; }
@@ -64,7 +64,7 @@ private:
   Log::StringView _sview;
   PURL::TempFile  _checkExecTmp;
 
-  virtual QValueList<const Device::Data *> getSupportedDevices(const QString &s) const;
+  virtual TQValueList<const Device::Data *> getSupportedDevices(const TQString &s) const;
   virtual Compile::Process *processFactory(const Compile::Data &data) const;
   virtual Compile::Config *configFactory(::Project *project) const;
 };
diff --git a/src/tools/boost/boost_generator.cpp b/src/tools/boost/boost_generator.cpp
index 2fa1393..0d204ad 100644
--- a/src/tools/boost/boost_generator.cpp
+++ b/src/tools/boost/boost_generator.cpp
@@ -20,9 +20,9 @@ SourceLine::List Boost::CSourceGenerator::configLines(PURL::ToolType, const Devi
   Address address = data.range(Pic::MemoryRangeType::Config).start;
   for (uint i=0; i<data.nbWords(Pic::MemoryRangeType::Config); i++) {
    const Pic::Config::Word &cword = config._words[i];
-    QStringList cnames = SourceLine::configNames(Pic::ConfigNameType::Default, pmemory, i, ok);
+    TQStringList cnames = SourceLine::configNames(Pic::ConfigNameType::Default, pmemory, i, ok);
     if ( cnames.isEmpty() ) continue;
-      QString code = "#pragma DATA ";
+      TQString code = "#pragma DATA ";
     if ( cword.name.isEmpty() ) code += toHexLabel(address, data.nbCharsAddress());
     else code += "__" + cword.name;
      code += cnames.join(" & ") + ";";
@@ -44,12 +44,12 @@ SourceLine::List Boost::CSourceGenerator::sourceFileContent(PURL::ToolType, cons
   SourceLine::List lines;
   lines.appendTitle(i18n("interrupt service routine"));
   lines.appendNotIndentedCode("void interrupt(void) {");
-  lines.appendIndentedCode(QString::null, "<< " + i18n("insert interrupt code") + " >>");
+  lines.appendIndentedCode(TQString(), "<< " + i18n("insert interrupt code") + " >>");
   lines.appendNotIndentedCode("}");
   lines.appendEmpty();
   lines.appendTitle(i18n("main program"));
   lines.appendNotIndentedCode("void main() {");
-  lines.appendIndentedCode(QString::null, "<< " + i18n("insert code") + " >>");
+  lines.appendIndentedCode(TQString(), "<< " + i18n("insert code") + " >>");
   lines.appendNotIndentedCode("}");
   return lines;
 }
@@ -73,7 +73,7 @@ SourceLine::List Boost::BasicSourceGenerator::sourceFileContent(PURL::ToolType,
   ok = true;
   lines.appendTitle(i18n("main program"));
   lines.appendNotIndentedCode("Sub main()");
-  lines.appendIndentedCode(QString::null, "<< " + i18n("insert code") + " >>");
+  lines.appendIndentedCode(TQString(), "<< " + i18n("insert code") + " >>");
   lines.appendIndentedCode("Do while 1", i18n("loop forever"));
   lines.appendIndentedCode("Loop");
   lines.appendNotIndentedCode("End Sub");
diff --git a/src/tools/boost/boostbasic.cpp b/src/tools/boost/boostbasic.cpp
index 9983874..dc449f8 100644
--- a/src/tools/boost/boostbasic.cpp
+++ b/src/tools/boost/boostbasic.cpp
@@ -11,15 +11,15 @@
 #include "boost_generator.h"
 
 //----------------------------------------------------------------------------
-bool Boost::CompilerBasic::checkExecutableResult(bool, QStringList &lines) const
+bool Boost::CompilerBasic::checkExecutableResult(bool, TQStringList &lines) const
 {
   return ( lines.count()>0 && lines[0].startsWith("BoostBasic ") );
 }
 
 //----------------------------------------------------------------------------
-QString Boost::GroupBasic::informationText() const
+TQString Boost::GroupBasic::informationText() const
 {
-  return i18n("<a href=\"%1\">BoostBasic Compiler</a> is a Basic compiler distributed by SourceBoost Technologies.").arg("http://www.sourceboost.com/Products/BoostBasic/Overview.html");
+  return i18n("<a href=\"%1\">BoostBasic Compiler</a> is a Basic compiler distributed by SourceBoost Technologies.").tqarg("http://www.sourceboost.com/Products/BoostBasic/Overview.html");
 }
 
 Tool::SourceGenerator *Boost::GroupBasic::sourceGeneratorFactory() const
diff --git a/src/tools/boost/boostbasic.h b/src/tools/boost/boostbasic.h
index 5f3b820..26cd90c 100644
--- a/src/tools/boost/boostbasic.h
+++ b/src/tools/boost/boostbasic.h
@@ -17,19 +17,19 @@ namespace Boost
 class CompilerBasic : public Compiler
 {
 private:
-  virtual bool checkExecutableResult(bool withWine, QStringList &lines) const;
+  virtual bool checkExecutableResult(bool withWine, TQStringList &lines) const;
 };
 
 class CompilerBasic16 : public CompilerBasic
 {
 public:
-  virtual QString baseExecutable(bool, Tool::OutputExecutableType) const { return "boostbasic.pic16.exe"; }
+  virtual TQString baseExecutable(bool, Tool::OutputExecutableType) const { return "boostbasic.pic16.exe"; }
 };
 
 class CompilerBasic18 : public CompilerBasic
 {
 public:
-  virtual QString baseExecutable(bool, Tool::OutputExecutableType) const { return "boostbasic.pic18.exe"; }
+  virtual TQString baseExecutable(bool, Tool::OutputExecutableType) const { return "boostbasic.pic18.exe"; }
 };
 
 //----------------------------------------------------------------------------
@@ -37,7 +37,7 @@ class GroupBasic : public Group
 {
 public:
   GroupBasic() : Group(".bas", "Sub main()\nEnd Sub\n") {}
-  virtual QString informationText() const;
+  virtual TQString informationText() const;
   virtual PURL::FileType implementationType(PURL::ToolType type) const { return (type==PURL::ToolType::Compiler ? PURL::BasicSource : PURL::Nb_FileTypes); }
 
 private:
@@ -47,8 +47,8 @@ private:
 class GroupBasic16 : public GroupBasic
 {
 public:
-  virtual QString name() const { return "boostbasic16"; }
-  virtual QString label() const { return i18n("BoostBasic Compiler for PIC16"); }
+  virtual TQString name() const { return "boostbasic16"; }
+  virtual TQString label() const { return i18n("BoostBasic Compiler for PIC16"); }
 
 private:
   virtual BaseData baseFactory(Tool::Category) const;
@@ -58,8 +58,8 @@ private:
 class GroupBasic18 : public GroupBasic
 {
 public:
-  virtual QString name() const { return "boostbasic18"; }
-  virtual QString label() const { return i18n("BoostBasic Compiler for PIC18"); }
+  virtual TQString name() const { return "boostbasic18"; }
+  virtual TQString label() const { return i18n("BoostBasic Compiler for PIC18"); }
 
 private:
   virtual BaseData baseFactory(Tool::Category) const;
diff --git a/src/tools/boost/boostc.cpp b/src/tools/boost/boostc.cpp
index 9a6ada9..74047a0 100644
--- a/src/tools/boost/boostc.cpp
+++ b/src/tools/boost/boostc.cpp
@@ -11,15 +11,15 @@
 #include "boost_generator.h"
 
 //----------------------------------------------------------------------------
-bool Boost::CompilerC::checkExecutableResult(bool, QStringList &lines) const
+bool Boost::CompilerC::checkExecutableResult(bool, TQStringList &lines) const
 {
   return ( lines.count()>0 && lines[0].startsWith("BoostC ") );
 }
 
 //----------------------------------------------------------------------------
-QString Boost::GroupC::informationText() const
+TQString Boost::GroupC::informationText() const
 {
-  return i18n("<a href=\"%1\">BoostC Compiler</a> is a C compiler distributed by SourceBoost Technologies.").arg("http://www.sourceboost.com/Products/BoostC/Overview.html");
+  return i18n("<a href=\"%1\">BoostC Compiler</a> is a C compiler distributed by SourceBoost Technologies.").tqarg("http://www.sourceboost.com/Products/BoostC/Overview.html");
 }
 
 Tool::SourceGenerator *Boost::GroupC::sourceGeneratorFactory() const
diff --git a/src/tools/boost/boostc.h b/src/tools/boost/boostc.h
index 5191560..1e30b12 100644
--- a/src/tools/boost/boostc.h
+++ b/src/tools/boost/boostc.h
@@ -17,19 +17,19 @@ namespace Boost
 class CompilerC : public Compiler
 {
 private:
-  virtual bool checkExecutableResult(bool withWine, QStringList &lines) const;
+  virtual bool checkExecutableResult(bool withWine, TQStringList &lines) const;
 };
 
 class CompilerC16 : public CompilerC
 {
 public:
-  virtual QString baseExecutable(bool, Tool::OutputExecutableType) const { return "boostc.pic16.exe"; }
+  virtual TQString baseExecutable(bool, Tool::OutputExecutableType) const { return "boostc.pic16.exe"; }
 };
 
 class CompilerC18 : public CompilerC
 {
 public:
-  virtual QString baseExecutable(bool, Tool::OutputExecutableType) const { return "boostc.pic18.exe"; }
+  virtual TQString baseExecutable(bool, Tool::OutputExecutableType) const { return "boostc.pic18.exe"; }
 };
 
 //----------------------------------------------------------------------------
@@ -37,7 +37,7 @@ class GroupC : public Group
 {
 public:
   GroupC() : Group(".c", "void main(void) {}\n") {}
-  virtual QString informationText() const;
+  virtual TQString informationText() const;
   virtual PURL::FileType implementationType(PURL::ToolType type) const { return (type==PURL::ToolType::Compiler ? PURL::CSource : PURL::Nb_FileTypes); }
 
 private:
@@ -47,8 +47,8 @@ private:
 class GroupC16 : public GroupC
 {
 public:
-  virtual QString name() const { return "boostc16"; }
-  virtual QString label() const { return i18n("BoostC Compiler for PIC16"); }
+  virtual TQString name() const { return "boostc16"; }
+  virtual TQString label() const { return i18n("BoostC Compiler for PIC16"); }
 
 private:
   virtual BaseData baseFactory(Tool::Category) const;
@@ -58,8 +58,8 @@ private:
 class GroupC18 : public GroupC
 {
 public:
-  virtual QString name() const { return "boostc18"; }
-  virtual QString label() const { return i18n("BoostC Compiler for PIC18"); }
+  virtual TQString name() const { return "boostc18"; }
+  virtual TQString label() const { return i18n("BoostC Compiler for PIC18"); }
 
 private:
   virtual BaseData baseFactory(Tool::Category) const;
diff --git a/src/tools/boost/boostc_compile.cpp b/src/tools/boost/boostc_compile.cpp
index 2298361..3c18fbe 100644
--- a/src/tools/boost/boostc_compile.cpp
+++ b/src/tools/boost/boostc_compile.cpp
@@ -11,33 +11,33 @@
 #include "boost_config.h"
 
 //----------------------------------------------------------------------------
-void Boost::Process::logStderrLine(const QString &line)
+void Boost::Process::logStderrLine(const TQString &line)
 {
   if ( parseErrorLine(line, Compile::ParseErrorData("(.*)\\((\\d+).*\\): (error|warning):(.*)", 1, 2, 4, 3)) ) return;
-  doLog(Log::LineType::Normal, line, QString::null, 0);
+  doLog(Log::LineType::Normal, line, TQString(), 0);
 }
 
 //----------------------------------------------------------------------------
-QStringList Boost::CompileFile::genericArguments(const Compile::Config &config) const
+TQStringList Boost::CompileFile::genericArguments(const Compile::Config &config) const
 {
-  QStringList args;
+  TQStringList args;
   args += "-t %DEVICE";
   args += "-i";
-  args += config.includeDirs(Tool::Category::Compiler, "-I", QString::null, ";");
+  args += config.includeDirs(Tool::Category::Compiler, "-I", TQString(), ";");
   args += config.customOptions(Tool::Category::Compiler);
   args += "%I";
   return args;
 }
 
-QString Boost::CompileFile::outputFiles() const
+TQString Boost::CompileFile::outputFiles() const
 {
   return "obj";
 }
 
 //----------------------------------------------------------------------------
-QStringList Boost::Link::genericArguments(const Compile::Config &config) const
+TQStringList Boost::Link::genericArguments(const Compile::Config &config) const
 {
-  QStringList args;
+  TQStringList args;
   args += "-t %DEVICE";
   args += "-p";
   args += "%PROJECT";
@@ -49,7 +49,7 @@ QStringList Boost::Link::genericArguments(const Compile::Config &config) const
   return args;
 }
 
-QString Boost::Link::outputFiles() const
+TQString Boost::Link::outputFiles() const
 {
   return "PURL::Lst PURL::Hex PURL::Coff PURL::AsmGPAsm stat tree casm";
 }
diff --git a/src/tools/boost/boostc_compile.h b/src/tools/boost/boostc_compile.h
index 5c3696a..a6a95d1 100644
--- a/src/tools/boost/boostc_compile.h
+++ b/src/tools/boost/boostc_compile.h
@@ -17,28 +17,31 @@ namespace Boost
 class Process : public Compile::Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QString deviceName() const { return "PIC" + _data.device; }
-  virtual void logStderrLine(const QString &line);
+  virtual TQString deviceName() const { return "PIC" + _data.device; }
+  virtual void logStderrLine(const TQString &line);
 };
 
 //----------------------------------------------------------------------------
 class CompileFile : public Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QStringList genericArguments(const Compile::Config &config) const;
-  virtual QString outputFiles() const;
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
+  virtual TQString outputFiles() const;
 };
 
 //----------------------------------------------------------------------------
 class Link : public Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QString objectExtension() const { return "obj"; }
-  virtual QStringList genericArguments(const Compile::Config &config) const;
-  virtual QString outputFiles() const;
+  virtual TQString objectExtension() const { return "obj"; }
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
+  virtual TQString outputFiles() const;
 };
 
 } // namespace
diff --git a/src/tools/boost/boostcpp.cpp b/src/tools/boost/boostcpp.cpp
index 8991de7..7b83314 100644
--- a/src/tools/boost/boostcpp.cpp
+++ b/src/tools/boost/boostcpp.cpp
@@ -12,15 +12,15 @@
 #include "boost_generator.h"
 
 //----------------------------------------------------------------------------
-bool Boost::CompilerCpp::checkExecutableResult(bool, QStringList &lines) const
+bool Boost::CompilerCpp::checkExecutableResult(bool, TQStringList &lines) const
 {
   return ( lines.count()>0 && lines[0].startsWith("BoostC++ ") );
 }
 
 //----------------------------------------------------------------------------
-QString Boost::GroupCpp::informationText() const
+TQString Boost::GroupCpp::informationText() const
 {
-  return i18n("<a href=\"%1\">BoostC++ Compiler</a> is a C compiler distributed by SourceBoost Technologies.").arg("http://www.sourceboost.com/Products/BoostCpp/Overview.html");
+  return i18n("<a href=\"%1\">BoostC++ Compiler</a> is a C compiler distributed by SourceBoost Technologies.").tqarg("http://www.sourceboost.com/Products/BoostCpp/Overview.html");
 }
 
 Tool::SourceGenerator *Boost::GroupCpp::sourceGeneratorFactory() const
diff --git a/src/tools/boost/boostcpp.h b/src/tools/boost/boostcpp.h
index bf5e2ee..7e3607d 100644
--- a/src/tools/boost/boostcpp.h
+++ b/src/tools/boost/boostcpp.h
@@ -17,19 +17,19 @@ namespace Boost
 class CompilerCpp : public Compiler
 {
 private:
-  virtual bool checkExecutableResult(bool withWine, QStringList &lines) const;
+  virtual bool checkExecutableResult(bool withWine, TQStringList &lines) const;
 };
 
 class CompilerCpp16 : public CompilerCpp
 {
 public:
-  virtual QString baseExecutable(bool, Tool::OutputExecutableType) const { return "boostc++.pic16.exe"; }
+  virtual TQString baseExecutable(bool, Tool::OutputExecutableType) const { return "boostc++.pic16.exe"; }
 };
 
 class CompilerCpp18 : public CompilerCpp
 {
 public:
-  virtual QString baseExecutable(bool, Tool::OutputExecutableType) const { return "boostc++.pic18.exe"; }
+  virtual TQString baseExecutable(bool, Tool::OutputExecutableType) const { return "boostc++.pic18.exe"; }
 };
 
 //----------------------------------------------------------------------------
@@ -37,7 +37,7 @@ class GroupCpp : public Group
 {
 public:
   GroupCpp() : Group(".cpp", "void main(void) {}\n") {}
-  virtual QString informationText() const;
+  virtual TQString informationText() const;
   virtual PURL::FileType implementationType(PURL::ToolType type) const { return (type==PURL::ToolType::Compiler ? PURL::CppSource : PURL::Nb_FileTypes); }
 
 private:
@@ -47,8 +47,8 @@ private:
 class GroupCpp16 : public GroupCpp
 {
 public:
-  virtual QString name() const { return "boostc++16"; }
-  virtual QString label() const { return i18n("BoostC++ Compiler for PIC16"); }
+  virtual TQString name() const { return "boostc++16"; }
+  virtual TQString label() const { return i18n("BoostC++ Compiler for PIC16"); }
 
 private:
   virtual BaseData baseFactory(Tool::Category) const;
@@ -58,8 +58,8 @@ private:
 class GroupCpp18 : public GroupCpp
 {
 public:
-  virtual QString name() const { return "boostc++18"; }
-  virtual QString label() const { return i18n("BoostC++ Compiler for PIC18"); }
+  virtual TQString name() const { return "boostc++18"; }
+  virtual TQString label() const { return i18n("BoostC++ Compiler for PIC18"); }
 
 private:
   virtual BaseData baseFactory(Tool::Category) const;
diff --git a/src/tools/boost/gui/boost_ui.h b/src/tools/boost/gui/boost_ui.h
index 6cafcf6..daa5047 100644
--- a/src/tools/boost/gui/boost_ui.h
+++ b/src/tools/boost/gui/boost_ui.h
@@ -18,6 +18,7 @@ namespace Boost
 class ConfigWidget : public ToolConfigWidget
 {
 Q_OBJECT
+  TQ_OBJECT
 public:
   ConfigWidget(Project *project);
   virtual void initEntries();
diff --git a/src/tools/c18/c18.cpp b/src/tools/c18/c18.cpp
index 4eb5bfd..5c2b725 100644
--- a/src/tools/c18/c18.cpp
+++ b/src/tools/c18/c18.cpp
@@ -8,7 +8,7 @@
  ***************************************************************************/
 #include "c18.h"
 
-#include <qdir.h>
+#include <tqdir.h>
 
 #include "c18_compile.h"
 #include "c18_config.h"
@@ -18,21 +18,21 @@
 #include "common/global/process.h"
 
 //----------------------------------------------------------------------------
-bool C18::Compiler::checkExecutableResult(bool, QStringList &lines) const
+bool C18::Compiler::checkExecutableResult(bool, TQStringList &lines) const
 {
   return ( lines.count()>0 && lines[0].startsWith("MPLAB C18") );
 }
 
-bool C18::Linker::checkExecutableResult(bool, QStringList &lines) const
+bool C18::Linker::checkExecutableResult(bool, TQStringList &lines) const
 {
   return ( lines.count()>0 && lines[0].startsWith("MPLINK") );
 }
 
 //----------------------------------------------------------------------------
-QValueList<const Device::Data *> C18::Group::getSupportedDevices(const QString &) const
+TQValueList<const Device::Data *> C18::Group::getSupportedDevices(const TQString &) const
 {
-  QValueVector<QString> devices = Device::lister().group("pic")->supportedDevices();
-  QValueList<const Device::Data *> list;
+  TQValueVector<TQString> devices = Device::lister().group("pic")->supportedDevices();
+  TQValueList<const Device::Data *> list;
   for (uint i=0; i<devices.count(); i++) {
     const Device::Data *data = Device::lister().data(devices[i]);
     if ( static_cast<const Pic::Data *>(data)->is18Family() ) list.append(data);
@@ -49,7 +49,7 @@ Compile::Process *C18::Group::processFactory(const Compile::Data &data) const
 
 PURL::Directory C18::Group::autodetectDirectory(Compile::DirectoryType type, const PURL::Directory &execDir, bool) const
 {
-  QDir dir(execDir.path());
+  TQDir dir(execDir.path());
   if ( !dir.cdUp() ) return PURL::Directory();
   switch (type.type()) {
     case Compile::DirectoryType::LinkerScript:
@@ -80,7 +80,7 @@ Tool::Group::BaseData C18::Group::baseFactory(Tool::Category category) const
   return BaseData();
 }
 
-QString C18::Group::informationText() const
+TQString C18::Group::informationText() const
 {
-  return i18n("<qt><a href=\"%1\">C18</a> is a C compiler distributed by Microchip.</qt>").arg("http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en010014&part=SW006011");
+  return i18n("<qt><a href=\"%1\">C18</a> is a C compiler distributed by Microchip.</qt>").tqarg("http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en010014&part=SW006011");
 }
diff --git a/src/tools/c18/c18.h b/src/tools/c18/c18.h
index fac739e..7560f78 100644
--- a/src/tools/c18/c18.h
+++ b/src/tools/c18/c18.h
@@ -17,30 +17,30 @@ namespace C18
 class Compiler : public Tool::Base
 {
 public:
-  virtual QString baseExecutable(bool, Tool::OutputExecutableType) const { return "mcc18"; }
+  virtual TQString baseExecutable(bool, Tool::OutputExecutableType) const { return "mcc18"; }
 
 private:
-  virtual QStringList checkExecutableOptions(bool) const { return "-v"; }
-  virtual bool checkExecutableResult(bool withWine, QStringList &lines) const;
+  virtual TQStringList checkExecutableOptions(bool) const { return "-v"; }
+  virtual bool checkExecutableResult(bool withWine, TQStringList &lines) const;
 };
 
 class Linker : public Tool::Base
 {
 public:
-  virtual QString baseExecutable(bool, Tool::OutputExecutableType) const { return "mplink"; }
+  virtual TQString baseExecutable(bool, Tool::OutputExecutableType) const { return "mplink"; }
 
 private:
-  virtual QStringList checkExecutableOptions(bool) const { return "/v"; }
-  virtual bool checkExecutableResult(bool withWine, QStringList &lines) const;
+  virtual TQStringList checkExecutableOptions(bool) const { return "/v"; }
+  virtual bool checkExecutableResult(bool withWine, TQStringList &lines) const;
 };
 
 //----------------------------------------------------------------------------
 class Group : public Tool::Group
 {
 public:
-  virtual QString name() const { return "c18"; }
-  virtual QString label() const { return i18n("C18 Compiler"); }
-  virtual QString informationText() const;
+  virtual TQString name() const { return "c18"; }
+  virtual TQString label() const { return i18n("C18 Compiler"); }
+  virtual TQString informationText() const;
   virtual Tool::Category checkDevicesCategory() const { return Tool::Category::Nb_Types; }
   virtual bool hasDirectory(Compile::DirectoryType type) const { return ( type!=Compile::DirectoryType::Source ); }
   virtual PURL::FileType linkerScriptType() const { return PURL::Lkr; }
@@ -50,7 +50,7 @@ public:
   virtual PURL::FileType implementationType(PURL::ToolType type) const { return (type==PURL::ToolType::Compiler ? PURL::CSource : PURL::Nb_FileTypes); }
 
 private:
-  virtual QValueList<const Device::Data *> getSupportedDevices(const QString &s) const;
+  virtual TQValueList<const Device::Data *> getSupportedDevices(const TQString &s) const;
   virtual Compile::Process *processFactory(const Compile::Data &data) const;
   virtual Compile::Config *configFactory(::Project *project) const;
   virtual BaseData baseFactory(Tool::Category category) const;
diff --git a/src/tools/c18/c18_compile.cpp b/src/tools/c18/c18_compile.cpp
index 181da36..d3ca920 100644
--- a/src/tools/c18/c18_compile.cpp
+++ b/src/tools/c18/c18_compile.cpp
@@ -13,9 +13,9 @@
 #include "devices/list/device_list.h"
 
 //-----------------------------------------------------------------------------
-QStringList C18::CompileFile::genericArguments(const Compile::Config &config) const
+TQStringList C18::CompileFile::genericArguments(const Compile::Config &config) const
 {
-  QStringList args;
+  TQStringList args;
   args += config.includeDirs(Tool::Category::Compiler, "-I");
   args += "-I" + Compile::Config::directory(group(), Compile::DirectoryType::Header).path();
   args += "$NO_AUTO_DEVICE(-p)";
@@ -26,21 +26,21 @@ QStringList C18::CompileFile::genericArguments(const Compile::Config &config) co
   return args;
 }
 
-QString C18::CompileFile::outputFiles() const
+TQString C18::CompileFile::outputFiles() const
 {
   return "PURL::Object";
 }
 
-void C18::CompileFile::logStderrLine(const QString &line)
+void C18::CompileFile::logStderrLine(const TQString &line)
 {
   // #### TODO
-  doLog(Log::LineType::Normal, line, QString::null, 0);
+  doLog(Log::LineType::Normal, line, TQString(), 0);
 }
 
 //-----------------------------------------------------------------------------
-QStringList C18::Link::genericArguments(const Compile::Config &config) const
+TQStringList C18::Link::genericArguments(const Compile::Config &config) const
 {
-  QStringList args;
+  TQStringList args;
   args += "/k%LKR_PATH";
   args += "%LKR_NAME";
   args += "/l" + Compile::Config::directory(group(), Compile::DirectoryType::Library).path();
@@ -53,13 +53,13 @@ QStringList C18::Link::genericArguments(const Compile::Config &config) const
   return args;
 }
 
-QString C18::Link::outputFiles() const
+TQString C18::Link::outputFiles() const
 {
   return "PURL::Lkr PURL::Map PURL::Hex PURL::Coff PURL::Lst PURL::Cod";
 }
 
-void C18::Link::logStderrLine(const QString &line)
+void C18::Link::logStderrLine(const TQString &line)
 {
   // #### TODO
-  doLog(Log::LineType::Normal, line, QString::null, 0);
+  doLog(Log::LineType::Normal, line, TQString(), 0);
 }
diff --git a/src/tools/c18/c18_compile.h b/src/tools/c18/c18_compile.h
index 74f0f06..1d690df 100644
--- a/src/tools/c18/c18_compile.h
+++ b/src/tools/c18/c18_compile.h
@@ -17,28 +17,31 @@ namespace C18
 class Process : public Compile::Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QString deviceName() const { return _data.device.lower(); }
+  virtual TQString deviceName() const { return _data.device.lower(); }
 };
 
 //-----------------------------------------------------------------------------
 class CompileFile : public Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QStringList genericArguments(const Compile::Config &config) const;
-  virtual QString outputFiles() const;
-  virtual void logStderrLine(const QString &line);
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
+  virtual TQString outputFiles() const;
+  virtual void logStderrLine(const TQString &line);
 };
 
 //-----------------------------------------------------------------------------
 class Link : public Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QStringList genericArguments(const Compile::Config &config) const;
-  virtual QString outputFiles() const;
-  virtual void logStderrLine(const QString &line);
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
+  virtual TQString outputFiles() const;
+  virtual void logStderrLine(const TQString &line);
 };
 
 } // namespace
diff --git a/src/tools/c18/c18_config.h b/src/tools/c18/c18_config.h
index dead1a1..db49ad7 100644
--- a/src/tools/c18/c18_config.h
+++ b/src/tools/c18/c18_config.h
@@ -20,7 +20,7 @@ public:
   Config(Project *project) : Compile::Config(project) {}
   enum { Nb_WarningLevels = 3 };
   static const char * const WARNING_LEVEL_LABELS[Nb_WarningLevels];
-  uint warningLevel() const { return QMIN(Compile::Config::warningLevel(Tool::Category::Compiler), uint(Nb_WarningLevels)); }
+  uint warningLevel() const { return TQMIN(Compile::Config::warningLevel(Tool::Category::Compiler), uint(Nb_WarningLevels)); }
   void setWarningLevel(uint level) { Compile::Config::setWarningLevel(Tool::Category::Compiler, level); }
 };
 
diff --git a/src/tools/c18/gui/c18_ui.cpp b/src/tools/c18/gui/c18_ui.cpp
index c10f328..5d0c167 100644
--- a/src/tools/c18/gui/c18_ui.cpp
+++ b/src/tools/c18/gui/c18_ui.cpp
@@ -8,7 +8,7 @@
  ***************************************************************************/
 #include "c18_ui.h"
 
-#include <qlabel.h>
+#include <tqlabel.h>
 #include "tools/c18/c18_config.h"
 
 //----------------------------------------------------------------------------
@@ -20,10 +20,10 @@ void C18::ConfigWidget::initEntries()
 {
   if ( _category==Tool::Category::Compiler ) {
     uint row = container()->numRows();
-    QLabel *label = new QLabel(i18n("Warning level:"), container());
+    TQLabel *label = new TQLabel(i18n("Warning level:"), container());
     container()->addWidget(label, row,row, 0,0);
-    _warningLevel = new QComboBox(container());
-    connect(_warningLevel, SIGNAL(activated(int)), SIGNAL(changed()));
+    _warningLevel = new TQComboBox(container());
+    connect(_warningLevel, TQT_SIGNAL(activated(int)), TQT_SIGNAL(changed()));
     for (uint i=0; i<Config::Nb_WarningLevels; i++)
       _warningLevel->insertItem(i18n(Config::WARNING_LEVEL_LABELS[i]));
     container()->addWidget(_warningLevel, row,row, 1,1);
diff --git a/src/tools/c18/gui/c18_ui.h b/src/tools/c18/gui/c18_ui.h
index d7d45c4..8ccb638 100644
--- a/src/tools/c18/gui/c18_ui.h
+++ b/src/tools/c18/gui/c18_ui.h
@@ -18,11 +18,12 @@ namespace C18
 class ConfigWidget : public ToolConfigWidget
 {
 Q_OBJECT
+  TQ_OBJECT
 public:
   ConfigWidget(Project *project);
 
 private:
-  QComboBox *_warningLevel;
+  TQComboBox *_warningLevel;
   virtual void initEntries();
   virtual void loadConfig(const Compile::Config &config);
   virtual void saveConfig(Compile::Config &config) const;
diff --git a/src/tools/cc5x/cc5x.cpp b/src/tools/cc5x/cc5x.cpp
index 5b28397..65b7b98 100644
--- a/src/tools/cc5x/cc5x.cpp
+++ b/src/tools/cc5x/cc5x.cpp
@@ -8,7 +8,7 @@
  ***************************************************************************/
 #include "cc5x.h"
 
-#include <qregexp.h>
+#include <tqregexp.h>
 
 #include "cc5x_compile.h"
 #include "cc5x_config.h"
@@ -17,16 +17,16 @@
 #include "devices/base/device_group.h"
 
 //----------------------------------------------------------------------------
-bool CC5X::Base::checkExecutableResult(bool, QStringList &lines) const
+bool CC5X::Base::checkExecutableResult(bool, TQStringList &lines) const
 {
   return ( lines.count()>0 && lines[0].startsWith("CC5X") );
 }
 
 //----------------------------------------------------------------------------
-QValueList<const Device::Data *> CC5X::Group::getSupportedDevices(const QString &) const
+TQValueList<const Device::Data *> CC5X::Group::getSupportedDevices(const TQString &) const
 {
-  QValueList<const Device::Data *> list;
-  QValueVector<QString> devices = Device::lister().group("pic")->supportedDevices();
+  TQValueList<const Device::Data *> list;
+  TQValueVector<TQString> devices = Device::lister().group("pic")->supportedDevices();
   for (uint i=0; i<devices.count(); i++) {
     const Pic::Data *data = static_cast<const Pic::Data *>(Device::lister().data(devices[i]));
     if ( data->architecture()!=Pic::Architecture::P10X && data->architecture()!=Pic::Architecture::P16X ) continue;
@@ -50,9 +50,9 @@ Compile::Config *CC5X::Group::configFactory(::Project *project) const
   return new Config(project);
 }
 
-QString CC5X::Group::informationText() const
+TQString CC5X::Group::informationText() const
 {
-  return i18n("<a href=\"%1\">CC5X</a> is a C compiler distributed by B Knudsen Data.").arg("http://www.bknd.com/cc5x/index.shtml");
+  return i18n("<a href=\"%1\">CC5X</a> is a C compiler distributed by B Knudsen Data.").tqarg("http://www.bknd.com/cc5x/index.shtml");
 }
 
 Tool::Group::BaseData CC5X::Group::baseFactory(Tool::Category category) const
diff --git a/src/tools/cc5x/cc5x.h b/src/tools/cc5x/cc5x.h
index 054a9ef..85a25ba 100644
--- a/src/tools/cc5x/cc5x.h
+++ b/src/tools/cc5x/cc5x.h
@@ -18,27 +18,27 @@ namespace CC5X
 class Base : public Tool::Base
 {
 public:
-  virtual QString baseExecutable(bool, Tool::OutputExecutableType) const { return "cc5x"; }
+  virtual TQString baseExecutable(bool, Tool::OutputExecutableType) const { return "cc5x"; }
 
 private:
-  virtual QStringList checkExecutableOptions(bool) const { return QStringList(); }
-  virtual bool checkExecutableResult(bool withWine, QStringList &lines) const;
+  virtual TQStringList checkExecutableOptions(bool) const { return TQStringList(); }
+  virtual bool checkExecutableResult(bool withWine, TQStringList &lines) const;
 };
 
 //----------------------------------------------------------------------------
 class Group : public Tool::Group
 {
 public:
-  virtual QString name() const { return "cc5x"; }
-  virtual QString label() const { return i18n("CC5X Compiler"); }
-  virtual QString informationText() const;
+  virtual TQString name() const { return "cc5x"; }
+  virtual TQString label() const { return i18n("CC5X Compiler"); }
+  virtual TQString informationText() const;
   virtual Tool::Category checkDevicesCategory() const { return Tool::Category::Nb_Types; }
   virtual Tool::ExecutableType preferedExecutableType() const { return Tool::ExecutableType::Windows; }
   virtual Tool::CompileType compileType() const { return Tool::SingleFile; }
   virtual PURL::FileType implementationType(PURL::ToolType type) const { return (type==PURL::ToolType::Compiler ? PURL::CSource : PURL::Nb_FileTypes); }
 
 private:
-  virtual QValueList<const Device::Data *> getSupportedDevices(const QString &s) const;
+  virtual TQValueList<const Device::Data *> getSupportedDevices(const TQString &s) const;
   virtual Compile::Process *processFactory(const Compile::Data &data) const;
   virtual Compile::Config *configFactory(::Project *project) const;
   virtual BaseData baseFactory(Tool::Category) const;
diff --git a/src/tools/cc5x/cc5x_compile.cpp b/src/tools/cc5x/cc5x_compile.cpp
index 6956eb8..fb17755 100644
--- a/src/tools/cc5x/cc5x_compile.cpp
+++ b/src/tools/cc5x/cc5x_compile.cpp
@@ -10,9 +10,9 @@
 
 #include "cc5x_config.h"
 
-QStringList CC5X::CompileFile::genericArguments(const Compile::Config &config) const
+TQStringList CC5X::CompileFile::genericArguments(const Compile::Config &config) const
 {
-  QStringList args;
+  TQStringList args;
   args += "-a";   // produce asm file
   args += "-CC";  // produce cod c file
   args += "-L";   // produce list file
@@ -25,13 +25,13 @@ QStringList CC5X::CompileFile::genericArguments(const Compile::Config &config) c
   return args;
 }
 
-void CC5X::CompileFile::logStderrLine(const QString &line)
+void CC5X::CompileFile::logStderrLine(const TQString &line)
 {
   if ( parseErrorLine(line, Compile::ParseErrorData("(.*):([0-9]+):(.+)\\[([0-9]+)\\](.+)", 1, 2, 5, 3)) ) return;
-  doLog(Log::LineType::Normal, line, QString::null, 0); // unrecognized
+  doLog(Log::LineType::Normal, line, TQString(), 0); // unrecognized
 }
 
-QString CC5X::CompileFile::outputFiles() const
+TQString CC5X::CompileFile::outputFiles() const
 {
   return "PURL::Lst PURL::AsmGPAsm PURL::Hex PURL::Cod occ";
 }
diff --git a/src/tools/cc5x/cc5x_compile.h b/src/tools/cc5x/cc5x_compile.h
index f400380..e17bb6f 100644
--- a/src/tools/cc5x/cc5x_compile.h
+++ b/src/tools/cc5x/cc5x_compile.h
@@ -17,11 +17,12 @@ namespace CC5X
 class CompileFile : public Compile::Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QString deviceName() const { return QString::null; }
-  virtual QStringList genericArguments(const Compile::Config &config) const;
-  virtual void logStderrLine(const QString &line);
-  virtual QString outputFiles() const;
+  virtual TQString deviceName() const { return TQString(); }
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
+  virtual void logStderrLine(const TQString &line);
+  virtual TQString outputFiles() const;
 };
 
 } // namespace
diff --git a/src/tools/cc5x/gui/cc5x_ui.h b/src/tools/cc5x/gui/cc5x_ui.h
index 7bf0a37..f234643 100644
--- a/src/tools/cc5x/gui/cc5x_ui.h
+++ b/src/tools/cc5x/gui/cc5x_ui.h
@@ -18,6 +18,7 @@ namespace CC5X
 class ConfigWidget : public ToolConfigWidget
 {
 Q_OBJECT
+  TQ_OBJECT
 public:
   ConfigWidget(Project *project);
   virtual void initEntries();
diff --git a/src/tools/ccsc/ccsc.cpp b/src/tools/ccsc/ccsc.cpp
index b28f29a..c7b3098 100644
--- a/src/tools/ccsc/ccsc.cpp
+++ b/src/tools/ccsc/ccsc.cpp
@@ -8,7 +8,7 @@
  ***************************************************************************/
 #include "ccsc.h"
 
-#include <qregexp.h>
+#include <tqregexp.h>
 
 #include "ccsc_compile.h"
 #include "ccsc_config.h"
@@ -17,9 +17,9 @@
 #include "devices/base/device_group.h"
 
 //----------------------------------------------------------------------------
-QStringList CCSC::Base::checkExecutableOptions(bool withWine) const
+TQStringList CCSC::Base::checkExecutableOptions(bool withWine) const
 {
-  QStringList args;
+  TQStringList args;
   if (withWine) {
     args += "+STDOUT";
     args += "+FM";
@@ -33,7 +33,7 @@ PURL::Directory CCSC::Base::checkExecutableWorkingDirectory() const
   return static_cast<const Group *>(_group)->checkExecutableUrl().directory();
 }
 
-bool CCSC::Base::checkExecutableResult(bool withWine, QStringList &lines) const
+bool CCSC::Base::checkExecutableResult(bool withWine, TQStringList &lines) const
 {
   if (withWine) {
     PURL::Url url = static_cast<const Group *>(_group)->checkExecutableUrl().toExtension("err");
@@ -57,10 +57,10 @@ CCSC::Group::Group()
   _checkExecTmp.close();
 }
 
-QValueList<const Device::Data *> CCSC::Group::getSupportedDevices(const QString &) const
+TQValueList<const Device::Data *> CCSC::Group::getSupportedDevices(const TQString &) const
 {
-  QValueList<const Device::Data *> list;
-  QValueVector<QString> devices = Device::lister().group("pic")->supportedDevices();
+  TQValueList<const Device::Data *> list;
+  TQValueVector<TQString> devices = Device::lister().group("pic")->supportedDevices();
   for (uint i=0; i<devices.count(); i++) {
     const Device::Data *data = Device::lister().data(devices[i]);
     Pic::Architecture arch = static_cast<const Pic::Data *>(data)->architecture();
@@ -85,9 +85,9 @@ Compile::Config *CCSC::Group::configFactory(::Project *project) const
   return new Config(project);
 }
 
-QString CCSC::Group::informationText() const
+TQString CCSC::Group::informationText() const
 {
-  return i18n("<a href=\"%1\">CCS Compiler</a> is a C compiler distributed by CCS.").arg("http://www.ccsinfo.com/content.php?page=compilers");
+  return i18n("<a href=\"%1\">CCS Compiler</a> is a C compiler distributed by CCS.").tqarg("http://www.ccsinfo.com/content.php?page=compilers");
 }
 
 Tool::Group::BaseData CCSC::Group::baseFactory(Tool::Category category) const
@@ -99,8 +99,8 @@ Tool::Group::BaseData CCSC::Group::baseFactory(Tool::Category category) const
 VersionData CCSC::Group::getToolchainVersion()
 {
   if ( !Compile::Config::withWine(*this) ) {
-    QStringList lines;
-    if ( checkExecutable(Tool::Category::Compiler, lines) && lines.count()>=1 && lines[0].contains("3.") ) return VersionData(3, 0, 0);
+    TQStringList lines;
+    if ( checkExecutable(Tool::Category::Compiler, lines) && lines.count()>=1 && lines[0].tqcontains("3.") ) return VersionData(3, 0, 0);
   }
   return VersionData(4, 0, 0); // default
 }
diff --git a/src/tools/ccsc/ccsc.h b/src/tools/ccsc/ccsc.h
index aef2005..dd8d286 100644
--- a/src/tools/ccsc/ccsc.h
+++ b/src/tools/ccsc/ccsc.h
@@ -18,11 +18,11 @@ namespace CCSC
 class Base : public Tool::Base
 {
 public:
-  virtual QString baseExecutable(bool, Tool::OutputExecutableType) const { return "ccsc"; }
+  virtual TQString baseExecutable(bool, Tool::OutputExecutableType) const { return "ccsc"; }
 
 private:
-  virtual QStringList checkExecutableOptions(bool withWine) const;
-  virtual bool checkExecutableResult(bool withWine, QStringList &lines) const;
+  virtual TQStringList checkExecutableOptions(bool withWine) const;
+  virtual bool checkExecutableResult(bool withWine, TQStringList &lines) const;
   virtual PURL::Directory checkExecutableWorkingDirectory() const;
 };
 
@@ -32,9 +32,9 @@ class Group : public Tool::Group
 public:
   Group();
   PURL::Url checkExecutableUrl() const { return _checkExecTmp.url(); }
-  virtual QString name() const { return "ccsc"; }
-  virtual QString label() const { return i18n("CCS Compiler"); }
-  virtual QString informationText() const;
+  virtual TQString name() const { return "ccsc"; }
+  virtual TQString label() const { return i18n("CCS Compiler"); }
+  virtual TQString informationText() const;
   virtual Tool::Category checkDevicesCategory() const { return Tool::Category::Nb_Types; }
   virtual Tool::ExecutableType preferedExecutableType() const { return Tool::ExecutableType::Unix; }
   virtual Tool::CompileType compileType() const { return Tool::SingleFile; }
@@ -44,7 +44,7 @@ private:
   Log::StringView _sview;
   PURL::TempFile  _checkExecTmp;
 
-  virtual QValueList<const Device::Data *> getSupportedDevices(const QString &s) const;
+  virtual TQValueList<const Device::Data *> getSupportedDevices(const TQString &s) const;
   virtual Compile::Process *processFactory(const Compile::Data &data) const;
   virtual Compile::Config *configFactory(::Project *project) const;
   virtual BaseData baseFactory(Tool::Category) const;
diff --git a/src/tools/ccsc/ccsc_compile.cpp b/src/tools/ccsc/ccsc_compile.cpp
index 56897e8..15ccedf 100644
--- a/src/tools/ccsc/ccsc_compile.cpp
+++ b/src/tools/ccsc/ccsc_compile.cpp
@@ -14,7 +14,7 @@
 #include "devices/list/device_list.h"
 #include "devices/pic/base/pic.h"
 
-QString CCSC::CompileFile::familyName() const
+TQString CCSC::CompileFile::familyName() const
 {
   const Pic::Data *pdata = static_cast<const Pic::Data *>(Device::lister().data(_data.device));
   switch (pdata->architecture().type()) {
@@ -31,13 +31,13 @@ QString CCSC::CompileFile::familyName() const
     case Pic::Architecture::Nb_Types: break;
   }
   Q_ASSERT(false);
-  return QString::null;
+  return TQString();
 }
 
-QStringList CCSC::CompileFile::genericArguments(const Compile::Config &config) const
+TQStringList CCSC::CompileFile::genericArguments(const Compile::Config &config) const
 {
   bool isVersion3 = ( static_cast<const Group &>(Main::toolGroup()).version().majorNum()==3 );
-  QStringList args;
+  TQStringList args;
   args += "+STDOUT"; // output messages on stdout
   if ( !isVersion3 ) args += "+EA";     // show all messages and warnings
   args += "-P";      // close compile windows after compilation done
@@ -55,25 +55,25 @@ QStringList CCSC::CompileFile::genericArguments(const Compile::Config &config) c
   return args;
 }
 
-void CCSC::CompileFile::logStderrLine(const QString &line)
+void CCSC::CompileFile::logStderrLine(const TQString &line)
 {
   // ignore output for wine
   if ( !Compile::Config::withWine(group()) ) parseLine(line);
 }
 
-void CCSC::CompileFile::parseLine(const QString &line)
+void CCSC::CompileFile::parseLine(const TQString &line)
 {
   Log::LineType type;
   if ( line.startsWith(">>>") )      type = Log::LineType::Warning;
   else if ( line.startsWith("***") ) type = Log::LineType::Error;
   else if ( line.startsWith("---") ) type = Log::LineType::Information;
   else {
-    doLog(Log::LineType::Normal, line, QString::null, 0); // unrecognized
+    doLog(Log::LineType::Normal, line, TQString(), 0); // unrecognized
     return;
   }
   if ( parseErrorLine(line, Compile::ParseErrorData("[*>-]+\\s\\w+\\s\\d+\\s\"([^\"]*)\"\\sLine\\s(\\d+)\\([^)]*\\):(.*)", 1, 2, 3, type)) ) return;
   if ( parseErrorLine(line, Compile::ParseErrorData("[*>-]+\\s\"([^\"]*)\"\\sLine\\s(\\d+):\\s\\w+\\s#\\d+:(.*)", 1, 2, 3, type)) ) return;
-  doLog(type, line, QString::null, 0);
+  doLog(type, line, TQString(), 0);
 }
 
 void CCSC::CompileFile::done(int code)
@@ -83,9 +83,9 @@ void CCSC::CompileFile::done(int code)
     PURL::Url url = PURL::Url(directory(), inputFilepath(0)).toExtension("err");
     Log::StringView sview;
     PURL::File file(url, sview);
-    if ( !file.openForRead() ) doLog(Log::LineType::Error, i18n("Could not find error file (%1).").arg(url.pretty()), QString::null, 0);
+    if ( !file.openForRead() ) doLog(Log::LineType::Error, i18n("Could not find error file (%1).").tqarg(url.pretty()), TQString(), 0);
     else {
-      QStringList lines = file.readLines();
+      TQStringList lines = file.readLines();
       for (uint i=0; i<lines.count(); i++) parseLine(lines[i]);
     }
   }
@@ -101,7 +101,7 @@ PURL::Url CCSC::CompileFile::url(PURL::FileType type, uint i) const
   return url.toFileType(type);
 }
 
-QString CCSC::CompileFile::outputFiles() const
+TQString CCSC::CompileFile::outputFiles() const
 {
   return "PURL::Lst PURL::Hex PURL::Coff PURL::Cod sym err esym occ";
 }
diff --git a/src/tools/ccsc/ccsc_compile.h b/src/tools/ccsc/ccsc_compile.h
index ddf8f20..949714b 100644
--- a/src/tools/ccsc/ccsc_compile.h
+++ b/src/tools/ccsc/ccsc_compile.h
@@ -17,19 +17,20 @@ namespace CCSC
 class CompileFile : public Compile::Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QString deviceName() const { return QString::null; }
-  virtual QString familyName() const;
-  virtual QStringList genericArguments(const Compile::Config &config) const;
-  virtual void logStderrLine(const QString &line);
-  virtual QString outputFiles() const;
+  virtual TQString deviceName() const { return TQString(); }
+  virtual TQString familyName() const;
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
+  virtual void logStderrLine(const TQString &line);
+  virtual TQString outputFiles() const;
   virtual PURL::Url url(PURL::FileType type = PURL::Nb_FileTypes, uint i = 0) const;
 
 protected slots:
   virtual void done(int code);
 
 private:
-  void parseLine(const QString &line);
+  void parseLine(const TQString &line);
 };
 
 } // namespace
diff --git a/src/tools/ccsc/gui/ccsc_ui.h b/src/tools/ccsc/gui/ccsc_ui.h
index 356cf22..298dcf6 100644
--- a/src/tools/ccsc/gui/ccsc_ui.h
+++ b/src/tools/ccsc/gui/ccsc_ui.h
@@ -18,6 +18,7 @@ namespace CCSC
 class ConfigWidget : public ToolConfigWidget
 {
 Q_OBJECT
+  TQ_OBJECT
 public:
   ConfigWidget(Project *project);
   virtual void initEntries();
diff --git a/src/tools/custom/custom.cpp b/src/tools/custom/custom.cpp
index 3779957..26d2bc7 100644
--- a/src/tools/custom/custom.cpp
+++ b/src/tools/custom/custom.cpp
@@ -11,10 +11,10 @@
 #include "devices/list/device_list.h"
 #include "devices/base/device_group.h"
 
-QValueList<const Device::Data *> CustomTool::Group::getSupportedDevices(const QString &) const
+TQValueList<const Device::Data *> CustomTool::Group::getSupportedDevices(const TQString &) const
 {
-  QValueVector<QString> devices = Device::lister().supportedDevices();
-  QValueList<const Device::Data *> list;
+  TQValueVector<TQString> devices = Device::lister().supportedDevices();
+  TQValueList<const Device::Data *> list;
   for (uint i=0; i<devices.count(); i++) {
     const Device::Data *data = Device::lister().data(devices[i]);
     list.append(data);
diff --git a/src/tools/custom/custom.h b/src/tools/custom/custom.h
index 770515a..a0d33b9 100644
--- a/src/tools/custom/custom.h
+++ b/src/tools/custom/custom.h
@@ -17,9 +17,9 @@ namespace CustomTool
 class Group : public Tool::Group
 {
 public:
-  virtual QString name() const { return CUSTOM_NAME; }
-  virtual QString label() const { return i18n("Custom"); }
-  virtual QString informationText() const { return QString::null; }
+  virtual TQString name() const { return CUSTOM_NAME; }
+  virtual TQString label() const { return i18n("Custom"); }
+  virtual TQString informationText() const { return TQString(); }
   virtual Tool::Category checkDevicesCategory() const { return Tool::Category::Nb_Types; }
   virtual Tool::ExecutableType preferedExecutableType() const { return Tool::ExecutableType::Unix; }
   virtual Tool::CompileType compileType() const { return Tool::AllFiles; }
@@ -27,7 +27,7 @@ public:
 
 protected:
   virtual BaseData baseFactory(Tool::Category) const { return BaseData(); }
-  virtual QValueList<const Device::Data *> getSupportedDevices(const QString &s) const;
+  virtual TQValueList<const Device::Data *> getSupportedDevices(const TQString &s) const;
   virtual Compile::Process *processFactory(const Compile::Data &) const { return 0; }
   virtual Compile::Config *configFactory(::Project *) const { return 0; }
   virtual Tool::SourceGenerator *sourceGeneratorFactory() const { return 0; }
diff --git a/src/tools/gputils/gputils.cpp b/src/tools/gputils/gputils.cpp
index 3219598..ba30f2c 100644
--- a/src/tools/gputils/gputils.cpp
+++ b/src/tools/gputils/gputils.cpp
@@ -9,7 +9,7 @@
  ***************************************************************************/
 #include "gputils.h"
 
-#include <qregexp.h>
+#include <tqregexp.h>
 
 #include "gputils_compile.h"
 #include "gputils_config.h"
@@ -18,7 +18,7 @@
 #include "gputils_generator.h"
 
 //----------------------------------------------------------------------------
-QString GPUtils::Base::baseExecutable(bool, Tool::OutputExecutableType) const
+TQString GPUtils::Base::baseExecutable(bool, Tool::OutputExecutableType) const
 {
   switch (_category.type()) {
     case Tool::Category::Assembler: return "gpasm";
@@ -26,18 +26,18 @@ QString GPUtils::Base::baseExecutable(bool, Tool::OutputExecutableType) const
     case Tool::Category::Librarian: return "gplib";
     default: break;
   }
-  return QString::null;
+  return TQString();
 }
 
-bool GPUtils::Base::checkExecutableResult(bool withWine, QStringList &lines) const
+bool GPUtils::Base::checkExecutableResult(bool withWine, TQStringList &lines) const
 {
   return ( lines.count()>0 && lines[0].startsWith(baseExecutable(withWine, Tool::OutputExecutableType::Coff)) );
 }
 
 //----------------------------------------------------------------------------
-QString GPUtils::Group::informationText() const
+TQString GPUtils::Group::informationText() const
 {
-  return i18n("<a href=\"%1\">GPUtils</a> is an open-source assembler and linker suite.<br>").arg("http://gputils.sourceforge.net");
+  return i18n("<a href=\"%1\">GPUtils</a> is an open-source assembler and linker suite.<br>").tqarg("http://gputils.sourceforge.net");
 }
 
 Tool::Group::BaseData GPUtils::Group::baseFactory(Tool::Category category) const
@@ -51,22 +51,22 @@ PURL::Directory GPUtils::Group::autodetectDirectory(Compile::DirectoryType type,
 {
   switch (type.type()) {
     case Compile::DirectoryType::LinkerScript: {
-      QString exec = execDir.path() + base(Tool::Category::Linker)->baseExecutable(withWine, Tool::OutputExecutableType::Coff);
+      TQString exec = execDir.path() + base(Tool::Category::Linker)->baseExecutable(withWine, Tool::OutputExecutableType::Coff);
       ::Process::StringOutput process;
       process.setup(exec, "-h", withWine);
       if ( ::Process::runSynchronously(process, ::Process::Start, 1000)!=::Process::Exited ) return PURL::Directory();
-      QString s = process.sout() + process.serr();
-      QRegExp re(".*Default linker script path ([^\\n]*)\\n.*");
+      TQString s = process.sout() + process.serr();
+      TQRegExp re(".*Default linker script path ([^\\n]*)\\n.*");
       if ( !re.exactMatch(s) ) return PURL::Directory();
       return PURL::Directory(re.cap(1));
     }
     case Compile::DirectoryType::Header: {
-      QString exec = execDir.path() + base(Tool::Category::Assembler)->baseExecutable(withWine, Tool::OutputExecutableType::Coff);
+      TQString exec = execDir.path() + base(Tool::Category::Assembler)->baseExecutable(withWine, Tool::OutputExecutableType::Coff);
       ::Process::StringOutput process;
       process.setup(exec, "-h", withWine);
       if ( ::Process::runSynchronously(process, ::Process::Start, 1000)!=::Process::Exited ) return PURL::Directory();
-      QString s = process.sout() + process.serr();
-      QRegExp re(".*Default header file path ([^\\n]*)\\n.*");
+      TQString s = process.sout() + process.serr();
+      TQRegExp re(".*Default header file path ([^\\n]*)\\n.*");
       if ( !re.exactMatch(s) ) return PURL::Directory();
       return PURL::Directory(re.cap(1));
     }
diff --git a/src/tools/gputils/gputils.h b/src/tools/gputils/gputils.h
index b8bcded..844bbde 100644
--- a/src/tools/gputils/gputils.h
+++ b/src/tools/gputils/gputils.h
@@ -18,22 +18,22 @@ namespace GPUtils
 class Base : public Tool::Base
 {
 public:
-  virtual QString baseExecutable(bool withWine, Tool::OutputExecutableType type) const;
+  virtual TQString baseExecutable(bool withWine, Tool::OutputExecutableType type) const;
 
 private:
-  virtual QStringList checkExecutableOptions(bool) const { return "-v"; }
-  virtual bool checkExecutableResult(bool withWine, QStringList &lines) const;
+  virtual TQStringList checkExecutableOptions(bool) const { return "-v"; }
+  virtual bool checkExecutableResult(bool withWine, TQStringList &lines) const;
 };
 
 //----------------------------------------------------------------------------
 class Group : public Tool::Group
 {
 public:
-  virtual QString name() const { return "gputils"; }
-  virtual QString label() const { return i18n("GPUtils"); }
-  virtual QString informationText() const;
+  virtual TQString name() const { return "gputils"; }
+  virtual TQString label() const { return i18n("GPUtils"); }
+  virtual TQString informationText() const;
   virtual Tool::Category checkDevicesCategory() const { return Tool::Category::Assembler; }
-  virtual QStringList checkDevicesOptions(uint) const { return "-l"; }
+  virtual TQStringList checkDevicesOptions(uint) const { return "-l"; }
   virtual PURL::Directory autodetectDirectory(Compile::DirectoryType type, const PURL::Directory &execDir, bool withWine) const;
   virtual bool hasDirectory(Compile::DirectoryType type) const { return type==Compile::DirectoryType::Header || type==Compile::DirectoryType::LinkerScript; }
   virtual PURL::FileType linkerScriptType() const { return PURL::Lkr; }
@@ -43,7 +43,7 @@ public:
 
 protected:
   virtual BaseData baseFactory(Tool::Category c) const;
-  virtual QValueList<const Device::Data *> getSupportedDevices(const QString &s) const { return GPUtils::getSupportedDevices(s); }
+  virtual TQValueList<const Device::Data *> getSupportedDevices(const TQString &s) const { return GPUtils::getSupportedDevices(s); }
   virtual Compile::Process *processFactory(const Compile::Data &data) const;
   virtual Compile::Config *configFactory(::Project *project) const;
   virtual Tool::SourceGenerator *sourceGeneratorFactory() const;
diff --git a/src/tools/gputils/gputils_compile.cpp b/src/tools/gputils/gputils_compile.cpp
index c59828c..cbe2309 100644
--- a/src/tools/gputils/gputils_compile.cpp
+++ b/src/tools/gputils/gputils_compile.cpp
@@ -15,68 +15,68 @@
 #include "coff/base/disassembler.h"
 
 //-----------------------------------------------------------------------------
-QString GPUtils::Process::deviceName() const
+TQString GPUtils::Process::deviceName() const
 {
   return toDeviceName(_data.device);
 }
 
 //-----------------------------------------------------------------------------
-void GPUtils::AssembleFile::logStderrLine(const QString &line)
+void GPUtils::AssembleFile::logStderrLine(const TQString &line)
 {
   if ( parseErrorLine(line, Compile::ParseErrorData("([^:]*):([0-9]+):(.+)\\[[0-9]+\\](.+)", 1, 2, 4, 3)) ) return;
   if ( parseErrorLine(line, Compile::ParseErrorData("([^:]*):([^:]+):([0-9]+):(.+)", 2, 3, 4, Log::LineType::Warning)) ) return;
-  doLog(Log::LineType::Normal, line, QString::null, 0); // unrecognized
+  doLog(Log::LineType::Normal, line, TQString(), 0); // unrecognized
 }
 
 //-----------------------------------------------------------------------------
-QStringList GPUtils::AssembleStandaloneFile::genericArguments(const Compile::Config &config) const
+TQStringList GPUtils::AssembleStandaloneFile::genericArguments(const Compile::Config &config) const
 {
-  QStringList args;
+  TQStringList args;
   args += "-L"; // force list
   args += "-o%O";
   uint wl = static_cast<const Config &>(config).gpasmWarningLevel();
-  if ( wl!=Config::Nb_WarningLevels ) args += "-w" + QString::number(wl);
+  if ( wl!=Config::Nb_WarningLevels ) args += "-w" + TQString::number(wl);
   args += config.includeDirs(Tool::Category::Assembler, "-I");
   args += "$NO_AUTO_DEVICE(-p%DEVICE)";
   HexBuffer::Format format = config.hexFormat();
-  if( format!=HexBuffer::Nb_Formats ) args += QString("-a") + HexBuffer::FORMATS[format];
+  if( format!=HexBuffer::Nb_Formats ) args += TQString("-a") + HexBuffer::FORMATS[format];
   args += config.customOptions(Tool::Category::Assembler);
   args += "%I";
   return args;
 }
 
-QString GPUtils::AssembleStandaloneFile::outputFiles() const
+TQString GPUtils::AssembleStandaloneFile::outputFiles() const
 {
   return "PURL::Lst PURL::Cod PURL::Hex";
 }
 
 //-----------------------------------------------------------------------------
-QStringList GPUtils::AssembleProjectFile::genericArguments(const Compile::Config &config) const
+TQStringList GPUtils::AssembleProjectFile::genericArguments(const Compile::Config &config) const
 {
-  QStringList args;
+  TQStringList args;
   args += "-c"; // relocatable code
   args += config.includeDirs(Tool::Category::Assembler, "-I");
   if ( !_data.items[0].generated ) args += "-p%DEVICE";
   uint wl = static_cast<const Config &>(config).gpasmWarningLevel() ;
-  if( wl!=Config::Nb_WarningLevels ) args += "-w" + QString::number(wl);
+  if( wl!=Config::Nb_WarningLevels ) args += "-w" + TQString::number(wl);
   args += config.customOptions(Tool::Category::Assembler);
   args += "%I";
   return args;
 }
 
-QString GPUtils::AssembleProjectFile::outputFiles() const
+TQString GPUtils::AssembleProjectFile::outputFiles() const
 {
   return "PURL::Object PURL::Lst";
 }
 
 //-----------------------------------------------------------------------------
-QStringList GPUtils::LinkProject::genericArguments(const Compile::Config &config) const
+TQStringList GPUtils::LinkProject::genericArguments(const Compile::Config &config) const
 {
-  QStringList args;
+  TQStringList args;
   args += "-o%O";
   args += "-c"; // create coff file
   HexBuffer::Format f = config.hexFormat();
-  if ( f!=HexBuffer::Nb_Formats ) args += QString("-a") + HexBuffer::FORMATS[f];
+  if ( f!=HexBuffer::Nb_Formats ) args += TQString("-a") + HexBuffer::FORMATS[f];
   args += "-m";  // with map
   args += config.includeDirs(Tool::Category::Linker, "-I");
   args += "$LKR(-s%LKR)";
@@ -86,15 +86,15 @@ QStringList GPUtils::LinkProject::genericArguments(const Compile::Config &config
   return args;
 }
 
-QString GPUtils::LinkProject::outputFiles() const
+TQString GPUtils::LinkProject::outputFiles() const
 {
   return "PURL::Lkr PURL::Map PURL::Lst PURL::Cod PURL::Coff PURL::Hex";
 }
 
 //-----------------------------------------------------------------------------
-QStringList GPUtils::LibraryProject::genericArguments(const Compile::Config &config) const
+TQStringList GPUtils::LibraryProject::genericArguments(const Compile::Config &config) const
 {
-  QStringList args;
+  TQStringList args;
   args += "-c"; // create archive
   args += "%O";
   args += config.customOptions(Tool::Category::Librarian);
@@ -103,7 +103,7 @@ QStringList GPUtils::LibraryProject::genericArguments(const Compile::Config &con
   return args;
 }
 
-QString GPUtils::LibraryProject::outputFiles() const
+TQString GPUtils::LibraryProject::outputFiles() const
 {
   return "PURL::Library";
 }
diff --git a/src/tools/gputils/gputils_compile.h b/src/tools/gputils/gputils_compile.h
index a6a09c9..97706b1 100644
--- a/src/tools/gputils/gputils_compile.h
+++ b/src/tools/gputils/gputils_compile.h
@@ -17,8 +17,9 @@ namespace GPUtils
 class Process : public Compile::Process
 {
 Q_OBJECT
+  TQ_OBJECT
 private:
-  virtual QString deviceName() const;
+  virtual TQString deviceName() const;
   virtual bool hasLinkerScript() const { return ( _data.linkType==Compile::Icd2Linking || Compile::Process::hasLinkerScript() ); }
 };
 
@@ -26,46 +27,51 @@ private:
 class AssembleFile : public Process
 {
 Q_OBJECT
+  TQ_OBJECT
 private:
-  virtual void logStderrLine(const QString &line);
+  virtual void logStderrLine(const TQString &line);
 };
 
 //-----------------------------------------------------------------------------
 class AssembleStandaloneFile : public AssembleFile
 {
 Q_OBJECT
+  TQ_OBJECT
 private:
-  virtual QString outputFiles() const;
-  virtual QStringList genericArguments(const Compile::Config &config) const;
+  virtual TQString outputFiles() const;
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
 };
 
 //-----------------------------------------------------------------------------
 class AssembleProjectFile : public AssembleFile
 {
 Q_OBJECT
+  TQ_OBJECT
 private:
-  virtual QString outputFiles() const;
-  virtual QStringList genericArguments(const Compile::Config &config) const;
+  virtual TQString outputFiles() const;
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
 };
 
 //-----------------------------------------------------------------------------
 class LinkProject : public Process
 {
 Q_OBJECT
+  TQ_OBJECT
 private:
-  virtual QString outputFiles() const;
-  virtual QStringList genericArguments(const Compile::Config &config) const;
-  virtual void logStderrLine(const QString &line) { doLog(filterType(line), line, QString::null, 0); }
+  virtual TQString outputFiles() const;
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
+  virtual void logStderrLine(const TQString &line) { doLog(filterType(line), line, TQString(), 0); }
 };
 
 //-----------------------------------------------------------------------------
 class LibraryProject : public Process
 {
 Q_OBJECT
+  TQ_OBJECT
 private:
-  virtual QString outputFiles() const;
-  virtual QStringList genericArguments(const Compile::Config &config) const;
-  virtual void logStderrLine(const QString &line) { doLog(filterType(line), line, QString::null, 0); }
+  virtual TQString outputFiles() const;
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
+  virtual void logStderrLine(const TQString &line) { doLog(filterType(line), line, TQString(), 0); }
 };
 
 } // namespace
diff --git a/src/tools/gputils/gputils_config.cpp b/src/tools/gputils/gputils_config.cpp
index 8f7bca2..7a264e6 100644
--- a/src/tools/gputils/gputils_config.cpp
+++ b/src/tools/gputils/gputils_config.cpp
@@ -15,5 +15,5 @@ const char * const GPUtils::Config::WARNING_LEVEL_LABELS[Nb_WarningLevels] = {
 
 uint GPUtils::Config::gpasmWarningLevel() const
 {
-  return QMIN(warningLevel(Tool::Category::Assembler), uint(Nb_WarningLevels));
+  return TQMIN(warningLevel(Tool::Category::Assembler), uint(Nb_WarningLevels));
 }
diff --git a/src/tools/gputils/gputils_generator.cpp b/src/tools/gputils/gputils_generator.cpp
index 3bcebac..7fd9a1f 100644
--- a/src/tools/gputils/gputils_generator.cpp
+++ b/src/tools/gputils/gputils_generator.cpp
@@ -13,12 +13,12 @@
 #include "devices/list/device_list.h"
 
 //----------------------------------------------------------------------------
-QValueList<const Device::Data *> GPUtils::getSupportedDevices(const QString &s)
+TQValueList<const Device::Data *> GPUtils::getSupportedDevices(const TQString &s)
 {
-  QStringList devices = QStringList::split(' ', s.simplifyWhiteSpace().upper());
-  QValueList<const Device::Data *> list;
+  TQStringList devices = TQStringList::split(' ', s.simplifyWhiteSpace().upper());
+  TQValueList<const Device::Data *> list;
   for (uint i=0; i<devices.count(); i++) {
-    QString name = devices[i];
+    TQString name = devices[i];
     if ( devices[i].startsWith("P1") ) name = name.mid(1);
     const Device::Data *data = Device::lister().data(name);
     if (data) list.append(data);
@@ -49,7 +49,7 @@ SourceLine::List GPUtils::SourceGenerator::sourceFileContent(PURL::ToolType, con
     lines.appendTitle(i18n("relocatable code"));
     lines.appendNotIndentedCode("PROG CODE");
     lines.appendNotIndentedCode("start");
-    lines.appendIndentedCode(QString::null, "<< " + i18n("insert code") + " >>");
+    lines.appendIndentedCode(TQString(), "<< " + i18n("insert code") + " >>");
     lines.appendIndentedCode("goto    $", i18n("loop forever"));
     lines.appendEmpty();
     lines.appendNotIndentedCode("END");
@@ -77,8 +77,8 @@ SourceLine::List GPUtils::SourceGenerator::sourceFileContent(PURL::ToolType, con
     if ( !hasShared ) {
       for (uint i=1; i<rdata.nbBanks; i++) {
         uint address = first + i*rdata.nbBytesPerBank();
-        lines.appendNotIndentedCode(QString("INT_VAR%1 UDATA ").arg(i) + toHexLabel(address, rdata.nbCharsAddress()), i18n("variables used for context saving"));
-        lines.appendNotIndentedCode(QString("w_saved%1     RES 1").arg(i), i18n("variable used for context saving"));
+        lines.appendNotIndentedCode(TQString("INT_VAR%1 UDATA ").tqarg(i) + toHexLabel(address, rdata.nbCharsAddress()), i18n("variables used for context saving"));
+        lines.appendNotIndentedCode(TQString("w_saved%1     RES 1").tqarg(i), i18n("variable used for context saving"));
       }
     }
     lines.appendEmpty();
@@ -106,7 +106,7 @@ SourceLine::List GPUtils::SourceGenerator::sourceFileContent(PURL::ToolType, con
       lines.appendIndentedCode("movwf   pclath_saved");
       lines.appendIndentedCode("clrf    PCLATH");
     }
-    lines.appendIndentedCode(QString::null, "<< " + i18n("insert interrupt code") + " >>");
+    lines.appendIndentedCode(TQString(), "<< " + i18n("insert interrupt code") + " >>");
     if (needPCLATH) {
       lines.appendIndentedCode("movf    pclath_saved,w", i18n("restore context"));
       lines.appendIndentedCode("movwf   PCLATH");
@@ -118,7 +118,7 @@ SourceLine::List GPUtils::SourceGenerator::sourceFileContent(PURL::ToolType, con
     lines.appendIndentedCode("retfie");
     lines.appendEmpty();
     lines.appendNotIndentedCode("start");
-    lines.appendIndentedCode(QString::null, "<< " + i18n("insert main code") + " >>");
+    lines.appendIndentedCode(TQString(), "<< " + i18n("insert main code") + " >>");
     lines.appendIndentedCode("goto    $", i18n("loop forever"));
     lines.appendEmpty();
     lines.appendNotIndentedCode("END");
@@ -173,30 +173,30 @@ SourceLine::List GPUtils::SourceGenerator::sourceFileContent(PURL::ToolType, con
     lines.appendIndentedCode("goto    peripheral_isr", i18n("go to start of peripheral interrupt code"));
     lines.appendEmpty();
     lines.appendNotIndentedCode("start:");
-    lines.appendIndentedCode(QString::null, "<< " + i18n("insert main code") + " >>");
+    lines.appendIndentedCode(TQString(), "<< " + i18n("insert main code") + " >>");
     lines.appendIndentedCode("goto    $", i18n("loop forever"));
     lines.appendEmpty();
     lines.appendTitle(i18n("INT pin interrupt service routine"));
     lines.appendNotIndentedCode("int_pin_isr:");
-    lines.appendIndentedCode(QString::null, "<< " + i18n("insert INT pin interrupt code") + " >>");
+    lines.appendIndentedCode(TQString(), "<< " + i18n("insert INT pin interrupt code") + " >>");
     lines.appendIndentedCode("POP");
     lines.appendIndentedCode("retfie");
     lines.appendEmpty();
     lines.appendTitle(i18n("TIMER0 interrupt service routine"));
     lines.appendNotIndentedCode("timer0_isr:");
-    lines.appendIndentedCode(QString::null, "<< " + i18n("insert TIMER0 interrupt code") + " >>");
+    lines.appendIndentedCode(TQString(), "<< " + i18n("insert TIMER0 interrupt code") + " >>");
     lines.appendIndentedCode("POP");
     lines.appendIndentedCode("retfie");
     lines.appendEmpty();
     lines.appendTitle(i18n("T0CKI interrupt service routine"));
     lines.appendNotIndentedCode("t0cki_isr:");
-    lines.appendIndentedCode(QString::null, "<< " + i18n("insert T0CKI interrupt code") + " >>");
+    lines.appendIndentedCode(TQString(), "<< " + i18n("insert T0CKI interrupt code") + " >>");
     lines.appendIndentedCode("POP");
     lines.appendIndentedCode("retfie");
     lines.appendEmpty();
     lines.appendTitle(i18n("peripheral interrupt service routine"));
     lines.appendNotIndentedCode("peripheral_isr:");
-    lines.appendIndentedCode(QString::null, "<< " + i18n("insert peripheral interrupt code") + " >>");
+    lines.appendIndentedCode(TQString(), "<< " + i18n("insert peripheral interrupt code") + " >>");
     lines.appendIndentedCode("POP");
     lines.appendIndentedCode("retfie");
     lines.appendEmpty();
@@ -229,7 +229,7 @@ SourceLine::List GPUtils::SourceGenerator::sourceFileContent(PURL::ToolType, con
     lines.appendIndentedCode("movff   STATUS,status_saved", i18n("save context"));
     lines.appendIndentedCode("movff   WREG,w_saved");
     lines.appendIndentedCode("movff   BSR,bsr_saved");
-    lines.appendIndentedCode(QString::null, "<< " + i18n("insert low priority interrupt code") + " >>");
+    lines.appendIndentedCode(TQString(), "<< " + i18n("insert low priority interrupt code") + " >>");
     lines.appendIndentedCode("movff   bsr_saved,BSR", i18n("restore context"));
     lines.appendIndentedCode("movff   w_saved,WREG");
     lines.appendIndentedCode("movff   status_saved,STATUS");
@@ -237,11 +237,11 @@ SourceLine::List GPUtils::SourceGenerator::sourceFileContent(PURL::ToolType, con
     lines.appendEmpty();
     lines.appendTitle(i18n("high priority interrupt service routine"));
     lines.appendNotIndentedCode("high_interrupt:");
-    lines.appendIndentedCode(QString::null, "<< " + i18n("insert high priority interrupt code") + " >>");
+    lines.appendIndentedCode(TQString(), "<< " + i18n("insert high priority interrupt code") + " >>");
     lines.appendIndentedCode("retfie  FAST");
     lines.appendEmpty();
     lines.appendNotIndentedCode("start:");
-    lines.appendIndentedCode(QString::null, "<< " + i18n("insert main code") + " >>");
+    lines.appendIndentedCode(TQString(), "<< " + i18n("insert main code") + " >>");
     lines.appendIndentedCode("goto    $", i18n("loop forever"));
     lines.appendEmpty();
     lines.appendNotIndentedCode("END");
diff --git a/src/tools/gputils/gputils_generator.h b/src/tools/gputils/gputils_generator.h
index 38da66d..9f2e7ac 100644
--- a/src/tools/gputils/gputils_generator.h
+++ b/src/tools/gputils/gputils_generator.h
@@ -14,7 +14,7 @@
 namespace GPUtils
 {
 
-extern QValueList<const Device::Data *> getSupportedDevices(const QString &s);
+extern TQValueList<const Device::Data *> getSupportedDevices(const TQString &s);
 
 class SourceGenerator : public Tool::SourceGenerator
 {
diff --git a/src/tools/gputils/gui/gputils_ui.cpp b/src/tools/gputils/gui/gputils_ui.cpp
index 35cdce8..bab898e 100644
--- a/src/tools/gputils/gui/gputils_ui.cpp
+++ b/src/tools/gputils/gui/gputils_ui.cpp
@@ -9,7 +9,7 @@
  ***************************************************************************/
 #include "gputils_ui.h"
 
-#include <qlabel.h>
+#include <tqlabel.h>
 #include "tools/gputils/gputils_config.h"
 
 //----------------------------------------------------------------------------
@@ -21,10 +21,10 @@ void GPUtils::ConfigWidget::initEntries()
 {
   if ( _category==Tool::Category::Assembler ) {
     uint row = container()->numRows();
-    QLabel *label = new QLabel(i18n("Warning level:"), container());
+    TQLabel *label = new TQLabel(i18n("Warning level:"), container());
     container()->addWidget(label, row,row, 0,0);
-    _gpasmWarning = new QComboBox(container());
-    connect(_gpasmWarning, SIGNAL(activated(int)), SIGNAL(changed()));
+    _gpasmWarning = new TQComboBox(container());
+    connect(_gpasmWarning, TQT_SIGNAL(activated(int)), TQT_SIGNAL(changed()));
     for (uint i=0; i<GPUtils::Config::Nb_WarningLevels; i++)
       _gpasmWarning->insertItem(i18n(GPUtils::Config::WARNING_LEVEL_LABELS[i]));
     _gpasmWarning->insertItem(i18n("as in LIST directive"));
diff --git a/src/tools/gputils/gui/gputils_ui.h b/src/tools/gputils/gui/gputils_ui.h
index 8d6daea..70b88ff 100644
--- a/src/tools/gputils/gui/gputils_ui.h
+++ b/src/tools/gputils/gui/gputils_ui.h
@@ -19,12 +19,13 @@ namespace GPUtils
 class ConfigWidget : public ToolConfigWidget
 {
 Q_OBJECT
+  TQ_OBJECT
 public:
   ConfigWidget(Project *project);
   virtual void initEntries();
 
 protected:
-  QComboBox *_gpasmWarning;
+  TQComboBox *_gpasmWarning;
   virtual void loadConfig(const Compile::Config &config);
   virtual void saveConfig(Compile::Config &config) const;
 };
diff --git a/src/tools/gui/tool_config_widget.cpp b/src/tools/gui/tool_config_widget.cpp
index 308e61b..ea2fd80 100644
--- a/src/tools/gui/tool_config_widget.cpp
+++ b/src/tools/gui/tool_config_widget.cpp
@@ -9,9 +9,9 @@
  ***************************************************************************/
 #include "tool_config_widget.h"
 
-#include <qtooltip.h>
-#include <qwidgetstack.h>
-#include <qvgroupbox.h>
+#include <tqtooltip.h>
+#include <tqwidgetstack.h>
+#include <tqvgroupbox.h>
 #include <klocale.h>
 
 #include "devices/base/hex_buffer.h"
@@ -33,32 +33,32 @@ ToolConfigWidget::ToolConfigWidget(Project *project)
   Container *container = new Container(this);
   container->setColStretch(2, 1);
   addWidget(container, 0,0, 0,0);
-  QLabel *label = new QLabel(i18n("Configuration:"), container);
+  TQLabel *label = new TQLabel(i18n("Configuration:"), container);
   container->addWidget(label, 0,0, 0,0);
   _argumentsType = new KComboBox(container);
   for (uint i=0; i<Nb_ArgumentsTypes; i++)
     _argumentsType->insertItem(i18n(ARGUMENTS_TYPE_LABELS[i]), i);
-  connect(_argumentsType, SIGNAL(activated(int)), SLOT(updateArguments()));
+  connect(_argumentsType, TQT_SIGNAL(activated(int)), TQT_SLOT(updateArguments()));
   container->addWidget(_argumentsType, 0,0, 1,1);
-  label = new QLabel(i18n("Arguments:"), container);
+  label = new TQLabel(i18n("Arguments:"), container);
   container->addWidget(label, 1,1, 0,0);
   _arguments = new KLineEdit(container);
   _arguments->setReadOnly(true);
   container->addWidget(_arguments, 1,1, 1,2);
-  KPushButton *button = new KPushButton(KGuiItem(QString::null, "help"), container);
-  connect(button, SIGNAL(clicked()), SIGNAL(displayHelp()));
+  KPushButton *button = new KPushButton(KGuiItem(TQString(), "help"), container);
+  connect(button, TQT_SIGNAL(clicked()), TQT_SIGNAL(displayHelp()));
   container->addWidget(button, 1,1, 3,3);
   _argumentsEditor = new EditListBox(1, container, "arguments_editor", EditListBox::DuplicatesAllowed,
                                      EditListBox::Add | EditListBox::Remove | EditListBox::UpDown | EditListBox::RemoveAll | EditListBox::Reset);
-  connect(_argumentsEditor, SIGNAL(changed()), SLOT(updateArguments()));
-  connect(_argumentsEditor, SIGNAL(reset()), SLOT(resetCustomArguments()));
+  connect(_argumentsEditor, TQT_SIGNAL(changed()), TQT_SLOT(updateArguments()));
+  connect(_argumentsEditor, TQT_SIGNAL(reset()), TQT_SLOT(resetCustomArguments()));
   container->addWidget(_argumentsEditor, 2,2, 0,3);
 
   _container = new Container(container);
   _container->setColStretch(2, 1);
   container->addWidget(_container, 3,3, 0,3);
 
-  connect(this, SIGNAL(changed()), SLOT(updateArguments()));
+  connect(this, TQT_SIGNAL(changed()), TQT_SLOT(updateArguments()));
 }
 
 void ToolConfigWidget::init(Tool::Category category, const Tool::Group &group)
@@ -68,7 +68,7 @@ void ToolConfigWidget::init(Tool::Category category, const Tool::Group &group)
   _config = _group->createConfig(_project);
   _tmpProject = new Project(PURL::Url());
   _tmpConfig = _group->createConfig(_tmpProject);
-  Compile::Data data(_category, QValueList<Compile::TodoItem>(), QString::null, _project, Compile::NormalLinking);
+  Compile::Data data(_category, TQValueList<Compile::TodoItem>(), TQString(), _project, Compile::NormalLinking);
   _process = _group->createCompileProcess(data, 0);
 
   initEntries();
@@ -83,11 +83,11 @@ ToolConfigWidget::~ToolConfigWidget()
   delete _config;
 }
 
-PURL::DirectoriesWidget *ToolConfigWidget::createDirectoriesEntry(const QString &text)
+PURL::DirectoriesWidget *ToolConfigWidget::createDirectoriesEntry(const TQString &text)
 {
   uint row = container()->numRows();
-  PURL::DirectoriesWidget *sdw = new PURL::DirectoriesWidget(text, _project ? _project->directory().path() : QString::null, container());
-  connect(sdw, SIGNAL(changed()), SIGNAL(changed()));
+  PURL::DirectoriesWidget *sdw = new PURL::DirectoriesWidget(text, _project ? _project->directory().path() : TQString(), container());
+  connect(sdw, TQT_SIGNAL(changed()), TQT_SIGNAL(changed()));
   container()->addWidget(sdw, row,row, 0,2);
   return sdw;
 }
@@ -95,31 +95,31 @@ PURL::DirectoriesWidget *ToolConfigWidget::createDirectoriesEntry(const QString
 void ToolConfigWidget::createCustomOptionsEntry()
 {
   uint row = container()->numRows();
-  QLabel *label = new QLabel(i18n("Custom options:"), container());
+  TQLabel *label = new TQLabel(i18n("Custom options:"), container());
   container()->addWidget(label, row,row, 0,0);
-  _customOptions = new QLineEdit(container());
-  connect(_customOptions, SIGNAL(textChanged(const QString &)), SIGNAL(changed()));
+  _customOptions = new TQLineEdit(container());
+  connect(_customOptions, TQT_SIGNAL(textChanged(const TQString &)), TQT_SIGNAL(changed()));
   container()->addWidget(_customOptions, row,row, 1,2);
 }
 
 void ToolConfigWidget::createCustomLibrariesEntry()
 {
   uint row = container()->numRows();
-  QLabel *label = new QLabel(i18n("Custom libraries:"), container());
+  TQLabel *label = new TQLabel(i18n("Custom libraries:"), container());
   container()->addWidget(label, row,row, 0,0);
-  _customLibraries = new QLineEdit(container());
-  connect(_customLibraries, SIGNAL(textChanged(const QString &)), SIGNAL(changed()));
-  QToolTip::add(_customLibraries, i18n("<qt>This values will be placed after the linked objects.</qt>")) ;
+  _customLibraries = new TQLineEdit(container());
+  connect(_customLibraries, TQT_SIGNAL(textChanged(const TQString &)), TQT_SIGNAL(changed()));
+  TQToolTip::add(_customLibraries, i18n("<qt>This values will be placed after the linked objects.</qt>")) ;
   container()->addWidget(_customLibraries, row,row, 1,2);
 }
 
 void ToolConfigWidget::createHexFormatEntry()
 {
   uint row = container()->numRows();
-  QLabel *label = new QLabel(i18n("Hex file format:"), container());
+  TQLabel *label = new TQLabel(i18n("Hex file format:"), container());
   container()->addWidget(label, row,row, 0,0);
-  _hexFormat = new QComboBox(container());
-  connect(_hexFormat, SIGNAL(activated(int)), SIGNAL(changed()));
+  _hexFormat = new TQComboBox(container());
+  connect(_hexFormat, TQT_SIGNAL(activated(int)), TQT_SIGNAL(changed()));
   for (uint i=0; i<HexBuffer::Nb_Formats; i++)
     _hexFormat->insertItem(HexBuffer::FORMATS[i]);
   _hexFormat->insertItem(i18n("as in LIST directive"));
@@ -159,9 +159,9 @@ void ToolConfigWidget::saveConfig(Compile::Config &config) const
   if (_hexFormat) config.setHexFormat(HexBuffer::Format(_hexFormat->currentItem()));
 }
 
-QStringList ToolConfigWidget::arguments(ArgumentsType type) const
+TQStringList ToolConfigWidget::arguments(ArgumentsType type) const
 {
-  if ( _tmpConfig==0 ) return QStringList();
+  if ( _tmpConfig==0 ) return TQStringList();
   saveConfig(*_tmpConfig);
   if ( type==AutomaticArguments ) return _process->genericArguments(*_tmpConfig);
   return _argumentsEditor->texts();
diff --git a/src/tools/gui/tool_config_widget.h b/src/tools/gui/tool_config_widget.h
index 5b38753..f9239b3 100644
--- a/src/tools/gui/tool_config_widget.h
+++ b/src/tools/gui/tool_config_widget.h
@@ -10,10 +10,10 @@
 #ifndef TOOL_CONFIG_WIDGET_H
 #define TOOL_CONFIG_WIDGET_H
 
-#include <qcombobox.h>
-#include <qlayout.h>
-#include <qtabwidget.h>
-#include <qvaluevector.h>
+#include <tqcombobox.h>
+#include <tqlayout.h>
+#include <tqtabwidget.h>
+#include <tqvaluevector.h>
 #include <kcombobox.h>
 #include <klineedit.h>
 
@@ -27,6 +27,7 @@ namespace PURL { class DirectoriesWidget; }
 class ToolConfigWidget : public ::ConfigWidget
 {
 Q_OBJECT
+  TQ_OBJECT
 public:
   ToolConfigWidget(Project *project);
   void init(Tool::Category category, const Tool::Group &group);
@@ -48,12 +49,12 @@ protected:
   const Tool::Group *_group;
   Tool::Category _category;
   Project       *_project;
-  QLineEdit     *_customOptions, *_customLibraries;
+  TQLineEdit     *_customOptions, *_customLibraries;
   PURL::DirectoriesWidget *_includeDirs;
-  QComboBox     *_hexFormat;
+  TQComboBox     *_hexFormat;
 
   Container *container() { return _container; }
-  PURL::DirectoriesWidget * createDirectoriesEntry(const QString &label);
+  PURL::DirectoriesWidget * createDirectoriesEntry(const TQString &label);
   void createIncludeDirectoriesEntry() { _includeDirs = createDirectoriesEntry(i18n("Include directories:")); }
   void createCustomOptionsEntry();
   void createCustomLibrariesEntry();
@@ -73,7 +74,7 @@ private:
   EditListBox      *_argumentsEditor;
   Container        *_container;
 
-  QStringList arguments(ArgumentsType type) const;
+  TQStringList arguments(ArgumentsType type) const;
 };
 
 #endif
diff --git a/src/tools/gui/tool_group_ui.cpp b/src/tools/gui/tool_group_ui.cpp
index 9bb02dd..118b8c7 100644
--- a/src/tools/gui/tool_group_ui.cpp
+++ b/src/tools/gui/tool_group_ui.cpp
@@ -11,9 +11,9 @@
 #include "tool_config_widget.h"
 #include "toolchain_config_widget.h"
 
-ToolchainConfigWidget *Tool::GroupUI::toolchainConfigWidgetFactory(QWidget *parent) const
+ToolchainConfigWidget *Tool::GroupUI::toolchainConfigWidgetFactory(TQWidget *tqparent) const
 {
-  return new ToolchainConfigWidget(static_cast<const Group &>(group()), parent);
+  return new ToolchainConfigWidget(static_cast<const Group &>(group()), tqparent);
 }
 
 ToolConfigWidget *Tool::GroupUI::createConfigWidget(Category category, ::Project *project) const
diff --git a/src/tools/gui/tool_group_ui.h b/src/tools/gui/tool_group_ui.h
index 4d1f42c..f03d633 100644
--- a/src/tools/gui/tool_group_ui.h
+++ b/src/tools/gui/tool_group_ui.h
@@ -22,7 +22,7 @@ class GroupUI : public ::Group::BaseGui
 public:
   ToolConfigWidget *createConfigWidget(Category category, ::Project *project) const;
   virtual ToolConfigWidget *configWidgetFactory(Category category, ::Project *project) const = 0;
-  virtual ToolchainConfigWidget *toolchainConfigWidgetFactory(QWidget *parent) const;
+  virtual ToolchainConfigWidget *toolchainConfigWidgetFactory(TQWidget *tqparent) const;
 };
 
 inline const GroupUI &groupui(const Base &base) { return static_cast<const GroupUI &>(*base.group().gui()); }
diff --git a/src/tools/gui/toolchain_config_center.cpp b/src/tools/gui/toolchain_config_center.cpp
index c8b889d..60df0f8 100644
--- a/src/tools/gui/toolchain_config_center.cpp
+++ b/src/tools/gui/toolchain_config_center.cpp
@@ -9,8 +9,8 @@
  ***************************************************************************/
 #include "toolchain_config_center.h"
 
-#include <qlabel.h>
-#include <qlayout.h>
+#include <tqlabel.h>
+#include <tqlayout.h>
 #include <kiconloader.h>
 
 #include "tools/list/tools_config_widget.h"
@@ -19,29 +19,29 @@
 #include "toolchain_config_widget.h"
 #include "tool_group_ui.h"
 
-ToolchainsConfigCenter::ToolchainsConfigCenter(const Tool::Group &sgroup, QWidget *parent)
-  : TreeListDialog(parent, "configure_toolchains_dialog", true,
+ToolchainsConfigCenter::ToolchainsConfigCenter(const Tool::Group &sgroup, TQWidget *tqparent)
+  : TreeListDialog(tqparent, "configure_toolchains_dialog", true,
                    i18n("Configure Toolchains"), Ok|User1|User2|Cancel, Cancel, false)
 {
   setButtonGuiItem(User1, KStdGuiItem::reset());
   setButtonGuiItem(User2, KGuiItem(i18n("Update"), "reload"));
 
   _titleBox->addStretch(1);
-  _infoButton = new KPushButton(KGuiItem(QString::null, "viewmag"), _frame);
-  connect(_infoButton, SIGNAL(clicked()), SLOT(showInformationDialog()));
+  _infoButton = new KPushButton(KGuiItem(TQString(), "viewmag"), _frame);
+  connect(_infoButton, TQT_SIGNAL(clicked()), TQT_SLOT(showInformationDialog()));
   _titleBox->addWidget(_infoButton);
 
-  QWidget *current = 0;
+  TQWidget *current = 0;
   FOR_EACH(PURL::SourceFamily, family) {
     Tool::Lister::ConstIterator it;
     for (it=Tool::lister().begin(); it!=Tool::lister().end(); ++it) {
       PURL::FileType type = it.data()->implementationType(family.data().toolType);
       if ( type==PURL::Nb_FileTypes || type.data().sourceFamily!=family ) continue;
       if ( family==PURL::SourceFamily::Asm && it.data()->implementationType(PURL::ToolType::Compiler)!=PURL::Nb_FileTypes ) continue;
-      QStringList names = family.label();
+      TQStringList names = family.label();
       names += it.data()->label();
-      QWidget *page = addPage(names);
-      QVBoxLayout *vbox = new QVBoxLayout(page);
+      TQWidget *page = addPage(names);
+      TQVBoxLayout *vbox = new TQVBoxLayout(page);
       ToolchainConfigWidget *tcw = static_cast<const ::Tool::GroupUI *>(it.data()->gui())->toolchainConfigWidgetFactory(page);
       tcw->init();
       tcw->loadConfig();
@@ -52,21 +52,21 @@ ToolchainsConfigCenter::ToolchainsConfigCenter(const Tool::Group &sgroup, QWidge
   }
   showPage(current);
   aboutToShowPageSlot(current);
-  connect(this, SIGNAL(aboutToShowPage(QWidget *)), SLOT(aboutToShowPageSlot(QWidget *)));
+  connect(this, TQT_SIGNAL(aboutToShowPage(TQWidget *)), TQT_SLOT(aboutToShowPageSlot(TQWidget *)));
 }
 
-void ToolchainsConfigCenter::aboutToShowPageSlot(QWidget *page)
+void ToolchainsConfigCenter::aboutToShowPageSlot(TQWidget *page)
 {
-  if ( !_pages.contains(page) ) _infoButton->hide();
+  if ( !_pages.tqcontains(page) ) _infoButton->hide();
   else {
     _infoButton->show();
-    QTimer::singleShot(0, _pages[page], SLOT(detect()));
+    TQTimer::singleShot(0, _pages[page], TQT_SLOT(detect()));
   }
 }
 
 void ToolchainsConfigCenter::slotApply()
 {
-  QMap<QWidget *, ToolchainConfigWidget *>::iterator it;
+  TQMap<TQWidget *, ToolchainConfigWidget *>::iterator it;
   for (it=_pages.begin(); it!=_pages.end(); ++it) it.data()->saveConfig();
 }
 
@@ -80,7 +80,7 @@ ToolchainConfigWidget *ToolchainsConfigCenter::current() const
 {
   int i = activePageIndex();
   if ( i==-1 ) return 0;
-  QMap<QWidget *, ToolchainConfigWidget *>::const_iterator it;
+  TQMap<TQWidget *, ToolchainConfigWidget *>::const_iterator it;
   for (it=_pages.begin(); it!=_pages.end(); ++it)
     if ( pageIndex(it.key())==i ) return it.data();
   Q_ASSERT(false);
diff --git a/src/tools/gui/toolchain_config_center.h b/src/tools/gui/toolchain_config_center.h
index 4b2110b..6b02f91 100644
--- a/src/tools/gui/toolchain_config_center.h
+++ b/src/tools/gui/toolchain_config_center.h
@@ -10,10 +10,10 @@
 #ifndef TOOLCHAIN_CONFIG_CENTER_H
 #define TOOLCHAIN_CONFIG_CENTER_H
 
-#include <qcheckbox.h>
-#include <qcombobox.h>
-#include <qlineedit.h>
-#include <qwidgetstack.h>
+#include <tqcheckbox.h>
+#include <tqcombobox.h>
+#include <tqlineedit.h>
+#include <tqwidgetstack.h>
 
 #include "tools/gui/tool_config_widget.h"
 #include "common/gui/dialog.h"
@@ -22,8 +22,9 @@ class ToolchainConfigWidget;
 class ToolchainsConfigCenter : public TreeListDialog
 {
 Q_OBJECT
+  TQ_OBJECT
 public:
-  ToolchainsConfigCenter(const Tool::Group &group, QWidget *parent);
+  ToolchainsConfigCenter(const Tool::Group &group, TQWidget *tqparent);
 
 public slots:
   virtual void slotOk();
@@ -32,12 +33,12 @@ public slots:
   virtual void slotUser2();
 
 private slots:
-  void aboutToShowPageSlot(QWidget *page);
+  void aboutToShowPageSlot(TQWidget *page);
   void showInformationDialog();
 
 private:
   KPushButton *_infoButton;
-  QMap<QWidget *, ToolchainConfigWidget *> _pages;
+  TQMap<TQWidget *, ToolchainConfigWidget *> _pages;
 
   ToolchainConfigWidget *current() const;
 };
diff --git a/src/tools/gui/toolchain_config_widget.cpp b/src/tools/gui/toolchain_config_widget.cpp
index aede699..d735f09 100644
--- a/src/tools/gui/toolchain_config_widget.cpp
+++ b/src/tools/gui/toolchain_config_widget.cpp
@@ -8,11 +8,11 @@
  ***************************************************************************/
 #include "toolchain_config_widget.h"
 
-#include <qlabel.h>
-#include <qlayout.h>
-#include <qtooltip.h>
-#include <qgroupbox.h>
-#include <qtabwidget.h>
+#include <tqlabel.h>
+#include <tqlayout.h>
+#include <tqtooltip.h>
+#include <tqgroupbox.h>
+#include <tqtabwidget.h>
 #include <kiconloader.h>
 #include <ktextedit.h>
 
@@ -22,8 +22,8 @@
 #include "common/gui/container.h"
 
 //----------------------------------------------------------------------------
-ToolchainConfigWidget::ToolchainConfigWidget(const Tool::Group &group, QWidget *parent)
-  : ::ConfigWidget(parent),
+ToolchainConfigWidget::ToolchainConfigWidget(const Tool::Group &group, TQWidget *tqparent)
+  : ::ConfigWidget(tqparent),
     _group(group), _dirty(false), _outputType(0), _devicesData(group.nbCheckDevices())
 {
   _config = group.createConfig(0);
@@ -41,18 +41,18 @@ void ToolchainConfigWidget::init()
   container->setColStretch(3, 1);
 
   uint row = 0;
-  QLabel *label = new QLabel(Compile::DirectoryType(Compile::DirectoryType::Executable).label() + ":", container);
+  TQLabel *label = new TQLabel(Compile::DirectoryType(Compile::DirectoryType::Executable).label() + ":", container);
   container->addWidget(label, row,row, 0,0);
   _dirs[Compile::DirectoryType::Executable] = new PURL::DirectoryWidget(container);
-  connect(_dirs[Compile::DirectoryType::Executable], SIGNAL(changed()), SLOT(forceDetect()));
+  connect(_dirs[Compile::DirectoryType::Executable], TQT_SIGNAL(changed()), TQT_SLOT(forceDetect()));
   container->addWidget(_dirs[Compile::DirectoryType::Executable], row,row, 1,3);
   row++;
 
-  label = new QLabel(i18n("Executable Type:"), container);
+  label = new TQLabel(i18n("Executable Type:"), container);
   container->addWidget(label, row,row, 0,0);
-  _execType = new QComboBox(container);
+  _execType = new TQComboBox(container);
   FOR_EACH(Tool::ExecutableType, type) _execType->insertItem(type.label());
-  connect(_execType, SIGNAL(activated(int)), SLOT(forceDetect()));
+  connect(_execType, TQT_SIGNAL(activated(int)), TQT_SLOT(forceDetect()));
   container->addWidget(_execType, row,row, 1,2);
   row++;
 
@@ -60,12 +60,12 @@ void ToolchainConfigWidget::init()
   FOR_EACH(Tool::OutputExecutableType, type)
     if ( _group.hasOutputExecutableType(type) ) nbOutputTypes++;
   if ( nbOutputTypes>1 ) {
-    label = new QLabel(i18n("Output Executable Type:"), container);
+    label = new TQLabel(i18n("Output Executable Type:"), container);
     container->addWidget(label, row,row, 0,0);
     _outputType = new KeyComboBox<Tool::OutputExecutableType>(container);
     FOR_EACH(Tool::OutputExecutableType, type)
       if ( _group.hasOutputExecutableType(type) ) _outputType->appendItem(type, type.label());
-    connect(_outputType->widget(), SIGNAL(activated(int)), SLOT(forceDetect()));
+    connect(_outputType->widget(), TQT_SIGNAL(activated(int)), TQT_SLOT(forceDetect()));
     container->addWidget(_outputType->widget(), row,row, 1,1);
     row++;
   }
@@ -75,22 +75,22 @@ void ToolchainConfigWidget::init()
   FOR_EACH(Tool::Category, k) {
     const Tool::Base *base = _group.base(k);
     if ( base==0 ) continue;
-    label = new QLabel(k.label(), container);
+    label = new TQLabel(k.label(), container);
     container->addWidget(label, row,row, 0,0);
-    _data[k].label = new QLabel(container);
+    _data[k].label = new TQLabel(container);
     container->addWidget(_data[k].label, row,row, 1,1);
-    _data[k].button = new KPushButton(KGuiItem(QString::null, "viewmag"), container);
-    connect(_data[k].button, SIGNAL(clicked()), SLOT(showDetails()));
+    _data[k].button = new KPushButton(KGuiItem(TQString(), "viewmag"), container);
+    connect(_data[k].button, TQT_SIGNAL(clicked()), TQT_SLOT(showDetails()));
     container->addWidget(_data[k].button, row,row, 2,2);
     row++;
   }
 
-  label = new QLabel(i18n("Device detection:"), container);
+  label = new TQLabel(i18n("Device detection:"), container);
   container->addWidget(label, row,row, 0,0);
-  _devicesLabel = new QLabel(container);
+  _devicesLabel = new TQLabel(container);
   container->addWidget(_devicesLabel, row,row, 1,1);
-  KPushButton *button = new KPushButton(KGuiItem(QString::null, "viewmag"), container);
-  connect(button, SIGNAL(clicked()), SLOT(showDeviceDetails()));
+  KPushButton *button = new KPushButton(KGuiItem(TQString(), "viewmag"), container);
+  connect(button, TQT_SIGNAL(clicked()), TQT_SLOT(showDeviceDetails()));
   container->addWidget(button, row,row, 2,2);
   row++;
 
@@ -99,7 +99,7 @@ void ToolchainConfigWidget::init()
     if ( type==Compile::DirectoryType::Executable ) continue;
     if ( !_group.hasDirectory(type) ) _dirs[type] = 0;
     else {
-      label = new QLabel(type.label() + ":", this);
+      label = new TQLabel(type.label() + ":", this);
       addWidget(label, row,row, 0,0);
       _dirs[type] = new PURL::DirectoryWidget(this);
       addWidget(_dirs[type], row,row, 1,3);
@@ -108,9 +108,9 @@ void ToolchainConfigWidget::init()
   }
 
   if ( !_group.comment().isEmpty() ) {
-    KTextEdit *w = new KTextEdit(_group.comment(), QString::null, this);
+    KTextEdit *w = new KTextEdit(_group.comment(), TQString(), this);
     w->setReadOnly(true);
-    w->setWordWrap(QTextEdit::WidgetWidth);
+    w->setWordWrap(TQTextEdit::WidgetWidth);
     addWidget(w, row,row, 0,3);
     row++;
   }
@@ -161,9 +161,9 @@ void ToolchainConfigWidget::checkExecutableDone()
     }
     _data[i].checkLines = _data[i].process->sout() + _data[i].process->serr();
     const Tool::Base *base = _group.base(i);
-    QString exec = base->baseExecutable(withWine(), outputType());
-    if ( base->checkExecutableResult(withWine(), _data[i].checkLines) ) _data[i].label->setText(i18n("\"%1\" found").arg(exec));
-    else _data[i].label->setText(i18n("\"%1\" not recognized").arg(exec));
+    TQString exec = base->baseExecutable(withWine(), outputType());
+    if ( base->checkExecutableResult(withWine(), _data[i].checkLines) ) _data[i].label->setText(i18n("\"%1\" found").tqarg(exec));
+    else _data[i].label->setText(i18n("\"%1\" not recognized").tqarg(exec));
     break;
   }
 }
@@ -180,12 +180,12 @@ void ToolchainConfigWidget::checkDevicesDone()
     _devicesData[i].done = true;
     break;
   }
-  QValueList<const Device::Data *> list;
+  TQValueList<const Device::Data *> list;
   for(uint i=0; i<_devicesData.count(); i++) {
     if ( !_devicesData[i].done ) return;
     list += _group.getSupportedDevices(_devicesData[i].checkLines.join("\n"));
   }
-  _devicesLabel->setText(i18n("Detected (%1)").arg(list.count()));
+  _devicesLabel->setText(i18n("Detected (%1)").tqarg(list.count()));
 }
 
 bool ToolchainConfigWidget::withWine() const
@@ -198,7 +198,7 @@ Tool::OutputExecutableType ToolchainConfigWidget::outputType() const
   return (_outputType==0 ? Compile::Config::outputExecutableType(_group) : _outputType->currentItem());
 }
 
-QString ToolchainConfigWidget::baseExecutable(Tool::Category category) const
+TQString ToolchainConfigWidget::baseExecutable(Tool::Category category) const
 {
   return _group.base(category)->baseExecutable(withWine(), outputType());
 }
@@ -226,23 +226,23 @@ void ToolchainConfigWidget::detect()
       _data[k].checkLines.clear();
       _data[k].process = checkExecutableProcess(k);
       _data[k].command = _data[k].process->prettyCommand();
-      connect(_data[k].process, SIGNAL(done(int)), SLOT(checkExecutableDone()));
-      connect(_data[k].process, SIGNAL(timeout()), SLOT(checkExecutableDone()));
-      QString exec = baseExecutable(k);
-      if ( !_data[k].process->start(10000) ) _data[k].label->setText(i18n("\"%1\" not found").arg(exec));
-      else _data[k].label->setText(i18n("Detecting \"%1\"...").arg(exec));
+      connect(_data[k].process, TQT_SIGNAL(done(int)), TQT_SLOT(checkExecutableDone()));
+      connect(_data[k].process, TQT_SIGNAL(timeout()), TQT_SLOT(checkExecutableDone()));
+      TQString exec = baseExecutable(k);
+      if ( !_data[k].process->start(10000) ) _data[k].label->setText(i18n("\"%1\" not found").tqarg(exec));
+      else _data[k].label->setText(i18n("Detecting \"%1\"...").tqarg(exec));
     }
   }
   if ( _group.checkDevicesCategory()==Tool::Category::Nb_Types ) {
-    QValueVector<QString> supported = _group.supportedDevices();
-    _devicesLabel->setText(i18n("Hardcoded (%1)").arg(supported.count()));
+    TQValueVector<TQString> supported = _group.supportedDevices();
+    _devicesLabel->setText(i18n("Hardcoded (%1)").tqarg(supported.count()));
   } else {
     for (uint i=0; i<_devicesData.count(); i++) {
       delete _devicesData[i].process;
       _devicesData[i].process = checkDevicesProcess(i);
       _devicesData[i].command = _devicesData[i].process->prettyCommand();
-      connect(_devicesData[i].process, SIGNAL(done(int)), SLOT(checkDevicesDone()));
-      connect(_devicesData[i].process, SIGNAL(timeout()), SLOT(checkDevicesDone()));
+      connect(_devicesData[i].process, TQT_SIGNAL(done(int)), TQT_SLOT(checkDevicesDone()));
+      connect(_devicesData[i].process, TQT_SIGNAL(timeout()), TQT_SLOT(checkDevicesDone()));
       _devicesData[i].done = false;
       _devicesData[i].checkLines.clear();
       if ( !_devicesData[i].process->start(10000) ) _devicesLabel->setText(i18n("Failed"));
@@ -262,11 +262,11 @@ void ToolchainConfigWidget::showDetails()
 {
   FOR_EACH(Tool::Category, k) {
     if ( sender()!=_data[k].button ) continue;
-    QString s;
+    TQString s;
     const Tool::Base *base = _group.base(k);
     if ( base->checkExecutable() ) {
-      s += i18n("<qt><b>Command for executable detection:</b><br>%1<br>").arg(_data[k].command);
-      s += i18n("<b>Version string:</b><br>%1<br></qt>").arg(_data[k].checkLines.join("<br>"));
+      s += i18n("<qt><b>Command for executable detection:</b><br>%1<br>").tqarg(_data[k].command);
+      s += i18n("<b>Version string:</b><br>%1<br></qt>").tqarg(_data[k].checkLines.join("<br>"));
     } else s += i18n("This tool cannot be automatically detected.");
     MessageBox::text(s, Log::Show);
     break;
@@ -275,10 +275,10 @@ void ToolchainConfigWidget::showDetails()
 
 void ToolchainConfigWidget::showDeviceDetails()
 {
-  QString s;
+  TQString s;
   if ( _group.checkDevicesCategory()==Tool::Category::Nb_Types ) {
     s += "<qt>";
-    QValueVector<QString> supported = _group.supportedDevices();
+    TQValueVector<TQString> supported = _group.supportedDevices();
     for (uint i=0; i<supported.count(); i++) {
       if ( i!=0 ) {
         if ( (i%10)==0 ) s += "<br>";
@@ -290,11 +290,11 @@ void ToolchainConfigWidget::showDeviceDetails()
   } else {
     uint nb = _group.nbCheckDevices();
     for (uint i=0; i<nb; i++) {
-      if ( nb==1 ) s += i18n("<qt><b>Command for devices detection:</b><br>%1<br>").arg(_devicesData[i].command);
-      else s += i18n("<qt><b>Command #%1 for devices detection:</b><br>%2<br>").arg(i+1).arg(_devicesData[i].command);
-      QString ss = _devicesData[i].checkLines.join("<br>");
-      if ( nb==1 ) s += i18n("<b>Device string:</b><br>%1<br>").arg(ss);
-      else s += i18n("<b>Device string #%1:</b><br>%2<br>").arg(i+1).arg(ss);
+      if ( nb==1 ) s += i18n("<qt><b>Command for devices detection:</b><br>%1<br>").tqarg(_devicesData[i].command);
+      else s += i18n("<qt><b>Command #%1 for devices detection:</b><br>%2<br>").tqarg(i+1).tqarg(_devicesData[i].command);
+      TQString ss = _devicesData[i].checkLines.join("<br>");
+      if ( nb==1 ) s += i18n("<b>Device string:</b><br>%1<br>").tqarg(ss);
+      else s += i18n("<b>Device string #%1:</b><br>%2<br>").tqarg(i+1).tqarg(ss);
     }
   }
   MessageBox::text(s, Log::Show);
diff --git a/src/tools/gui/toolchain_config_widget.h b/src/tools/gui/toolchain_config_widget.h
index ad7978a..b1e795d 100644
--- a/src/tools/gui/toolchain_config_widget.h
+++ b/src/tools/gui/toolchain_config_widget.h
@@ -9,8 +9,8 @@
 #ifndef TOOLCHAIN_CONFIG_WIDGET_H
 #define TOOLCHAIN_CONFIG_WIDGET_H
 
-#include <qwidgetstack.h>
-#include <qlabel.h>
+#include <tqwidgetstack.h>
+#include <tqlabel.h>
 #include <klocale.h>
 #include <kpushbutton.h>
 
@@ -26,8 +26,9 @@ namespace Tool { class Group; }
 class ToolchainConfigWidget : public ::ConfigWidget
 {
   Q_OBJECT
+  TQ_OBJECT
 public:
-  ToolchainConfigWidget(const Tool::Group &group, QWidget *parent);
+  ToolchainConfigWidget(const Tool::Group &group, TQWidget *tqparent);
   virtual ~ToolchainConfigWidget();
   const Tool::Group &group() const { return _group; }
   void init();
@@ -42,7 +43,7 @@ protected:
   bool withWine() const;
   Tool::OutputExecutableType outputType() const;
   virtual void addCustomExecutableOptions(Container *) {}
-  virtual QString baseExecutable(Tool::Category category) const;
+  virtual TQString baseExecutable(Tool::Category category) const;
   virtual ::Process::LineOutput *checkExecutableProcess(Tool::Category category) const;
   virtual ::Process::LineOutput *checkDevicesProcess(uint i) const;
 
@@ -56,30 +57,30 @@ protected:
   const Tool::Group &_group;
   Compile::Config   *_config;
   bool               _dirty;
-  QComboBox         *_execType;
+  TQComboBox         *_execType;
   KeyComboBox<Tool::OutputExecutableType> *_outputType;
-  QLabel            *_devicesLabel;
-  QMap<Compile::DirectoryType, PURL::DirectoryWidget *> _dirs;
+  TQLabel            *_devicesLabel;
+  TQMap<Compile::DirectoryType, PURL::DirectoryWidget *> _dirs;
   class ExecData {
   public:
     ExecData() : label(0), button(0), process(0) {}
     ~ExecData() { delete process; }
-    QLabel *label;
-    QString command;
-    QStringList checkLines;
+    TQLabel *label;
+    TQString command;
+    TQStringList checkLines;
     KPushButton *button;
     ::Process::LineOutput *process;
   };
-  QMap<Tool::Category, ExecData> _data;
+  TQMap<Tool::Category, ExecData> _data;
   class DevicesData {
   public:
     DevicesData() : process(0) {}
     bool done;
-    QString command;
-    QStringList checkLines;
+    TQString command;
+    TQStringList checkLines;
     ::Process::LineOutput *process;
   };
-  QValueVector<DevicesData> _devicesData;
+  TQValueVector<DevicesData> _devicesData;
 };
 
 #endif
diff --git a/src/tools/jal/gui/jal_ui.h b/src/tools/jal/gui/jal_ui.h
index aa6957e..d87d3e2 100644
--- a/src/tools/jal/gui/jal_ui.h
+++ b/src/tools/jal/gui/jal_ui.h
@@ -18,6 +18,7 @@ namespace JAL
 class ConfigWidget : public ToolConfigWidget
 {
 Q_OBJECT
+  TQ_OBJECT
 public:
   ConfigWidget(Project *project);
   virtual void initEntries() {}
diff --git a/src/tools/jal/jal.cpp b/src/tools/jal/jal.cpp
index 009ea21..11e503d 100644
--- a/src/tools/jal/jal.cpp
+++ b/src/tools/jal/jal.cpp
@@ -16,19 +16,19 @@
 #include "jal_generator.h"
 
 //----------------------------------------------------------------------------
-bool JAL::Base::checkExecutableResult(bool, QStringList &lines) const
+bool JAL::Base::checkExecutableResult(bool, TQStringList &lines) const
 {
-  QStringList tmp;
+  TQStringList tmp;
   for (uint i=0; i<lines.count(); i++)
-    if ( !lines[i].contains('\r') ) tmp += lines[i]; // ??
+    if ( !lines[i].tqcontains('\r') ) tmp += lines[i]; // ??
   lines = tmp;
   return ( lines.count()>0 && lines[0].startsWith("jal") );
 }
 
 //----------------------------------------------------------------------------
-QString JAL::Group::informationText() const
+TQString JAL::Group::informationText() const
 {
-  return i18n("<a href=\"%1\">JAL</a> is a high-level language for PIC microcontrollers.").arg("http://jal.sourceforge.net");
+  return i18n("<a href=\"%1\">JAL</a> is a high-level language for PIC microcontrollers.").tqarg("http://jal.sourceforge.net");
 }
 
 Tool::Group::BaseData JAL::Group::baseFactory(Tool::Category category) const
@@ -44,9 +44,9 @@ const char * const SUPPORTED_DEVICES[] = {
   0
 };
 
-QValueList<const Device::Data *> JAL::Group::getSupportedDevices(const QString &) const
+TQValueList<const Device::Data *> JAL::Group::getSupportedDevices(const TQString &) const
 {
-  QValueList<const Device::Data *> list;
+  TQValueList<const Device::Data *> list;
   for (uint i=0; SUPPORTED_DEVICES[i]; i++) {
     const Device::Data *data = Device::lister().data(SUPPORTED_DEVICES[i]);
     Q_ASSERT(data);
diff --git a/src/tools/jal/jal.h b/src/tools/jal/jal.h
index 0c0d790..3aa3cae 100644
--- a/src/tools/jal/jal.h
+++ b/src/tools/jal/jal.h
@@ -17,20 +17,20 @@ namespace JAL
 class Base : public Tool::Base
 {
 public:
-  virtual QString baseExecutable(bool, Tool::OutputExecutableType) const { return "jal"; }
+  virtual TQString baseExecutable(bool, Tool::OutputExecutableType) const { return "jal"; }
 
 private:
-  virtual QStringList checkExecutableOptions(bool) const { return QStringList(); }
-  virtual bool checkExecutableResult(bool withWine, QStringList &lines) const;
+  virtual TQStringList checkExecutableOptions(bool) const { return TQStringList(); }
+  virtual bool checkExecutableResult(bool withWine, TQStringList &lines) const;
 };
 
 //----------------------------------------------------------------------------
 class Group : public Tool::Group
 {
 public:
-  virtual QString name() const { return "jal"; }
-  virtual QString label() const { return i18n("JAL"); }
-  virtual QString informationText() const;
+  virtual TQString name() const { return "jal"; }
+  virtual TQString label() const { return i18n("JAL"); }
+  virtual TQString informationText() const;
   virtual Tool::Category checkDevicesCategory() const { return Tool::Category::Nb_Types; }
   virtual Tool::ExecutableType preferedExecutableType() const { return Tool::ExecutableType::Unix; }
   virtual Tool::CompileType compileType() const { return Tool::AllFiles; }
@@ -38,7 +38,7 @@ public:
 
 private:
   virtual BaseData baseFactory(Tool::Category c) const;
-  virtual QValueList<const Device::Data *> getSupportedDevices(const QString &s) const;
+  virtual TQValueList<const Device::Data *> getSupportedDevices(const TQString &s) const;
   virtual Compile::Process *processFactory(const Compile::Data &data) const;
   virtual Compile::Config *configFactory(::Project *project) const;
   virtual Tool::SourceGenerator *sourceGeneratorFactory() const;
diff --git a/src/tools/jal/jal_compile.cpp b/src/tools/jal/jal_compile.cpp
index 4d62e68..aa7d42f 100644
--- a/src/tools/jal/jal_compile.cpp
+++ b/src/tools/jal/jal_compile.cpp
@@ -8,19 +8,19 @@
  ***************************************************************************/
 #include "jal_compile.h"
 
-void JAL::CompileFile::logStderrLine(const QString &line)
+void JAL::CompileFile::logStderrLine(const TQString &line)
 {
-  if ( line.contains('\r') ) return; // what are those lines ?
+  if ( line.tqcontains('\r') ) return; // what are those lines ?
   // #### TODO
-  doLog(Log::LineType::Normal, line, QString::null, 0); // unrecognized
+  doLog(Log::LineType::Normal, line, TQString(), 0); // unrecognized
 }
 
-QStringList JAL::CompileFile::genericArguments(const Compile::Config &) const
+TQStringList JAL::CompileFile::genericArguments(const Compile::Config &) const
 {
   return "%I";
 }
 
-QString JAL::CompileFile::outputFiles() const
+TQString JAL::CompileFile::outputFiles() const
 {
   return "PURL::AsmGPAsm PURL::Hex";
 }
diff --git a/src/tools/jal/jal_compile.h b/src/tools/jal/jal_compile.h
index e63f603..c3fae70 100644
--- a/src/tools/jal/jal_compile.h
+++ b/src/tools/jal/jal_compile.h
@@ -17,11 +17,12 @@ namespace JAL
 class CompileFile : public Compile::Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QString deviceName() const { return _data.device; }
-  virtual void logStderrLine(const QString &line);
-  virtual QStringList genericArguments(const Compile::Config &config) const;
-  virtual QString outputFiles() const;
+  virtual TQString deviceName() const { return _data.device; }
+  virtual void logStderrLine(const TQString &line);
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
+  virtual TQString outputFiles() const;
 };
 
 } // namespace
diff --git a/src/tools/jal/jal_generator.cpp b/src/tools/jal/jal_generator.cpp
index 6aa9b08..ce76846 100644
--- a/src/tools/jal/jal_generator.cpp
+++ b/src/tools/jal/jal_generator.cpp
@@ -28,7 +28,7 @@ SourceLine::List JAL::SourceGenerator::sourceFileContent(PURL::ToolType, const D
 {
   SourceLine::List lines;
   lines.appendTitle(i18n("main code"));
-  lines.appendNotIndentedCode(QString::null, "<< " + i18n("insert code") + " >>");
+  lines.appendNotIndentedCode(TQString(), "<< " + i18n("insert code") + " >>");
   lines.appendNotIndentedCode("forever loop", i18n("loop forever"));
   lines.appendNotIndentedCode("end loop");
   return lines;
diff --git a/src/tools/jalv2/gui/jalv2_ui.h b/src/tools/jalv2/gui/jalv2_ui.h
index 93085c1..4944860 100644
--- a/src/tools/jalv2/gui/jalv2_ui.h
+++ b/src/tools/jalv2/gui/jalv2_ui.h
@@ -18,6 +18,7 @@ namespace JALV2
 class ConfigWidget : public ToolConfigWidget
 {
 Q_OBJECT
+  TQ_OBJECT
 public:
   ConfigWidget(Project *project);
   virtual void initEntries();
diff --git a/src/tools/jalv2/jalv2.cpp b/src/tools/jalv2/jalv2.cpp
index 1d910b8..8ea6d1e 100644
--- a/src/tools/jalv2/jalv2.cpp
+++ b/src/tools/jalv2/jalv2.cpp
@@ -16,19 +16,19 @@
 #include "tools/jal/jal_generator.h"
 
 //----------------------------------------------------------------------------
-bool JALV2::Base::checkExecutableResult(bool, QStringList &lines) const
+bool JALV2::Base::checkExecutableResult(bool, TQStringList &lines) const
 {
-  QStringList tmp;
+  TQStringList tmp;
   for (uint i=0; i<lines.count(); i++)
-    if ( !lines[i].contains('\r') ) tmp += lines[i]; // ??
+    if ( !lines[i].tqcontains('\r') ) tmp += lines[i]; // ??
   lines = tmp;
   return ( lines.count()>0 && lines[0].startsWith("jal") );
 }
 
 //----------------------------------------------------------------------------
-QString JALV2::Group::informationText() const
+TQString JALV2::Group::informationText() const
 {
-  return i18n("<a href=\"%1\">JAL V2</a> is a new compiler for the high-level language JAL.").arg("http://www.casadeyork.com/jalv2");
+  return i18n("<a href=\"%1\">JAL V2</a> is a new compiler for the high-level language JAL.").tqarg("http://www.casadeyork.com/jalv2");
 }
 
 Tool::Group::BaseData JALV2::Group::baseFactory(Tool::Category category) const
@@ -49,9 +49,9 @@ const char * const SUPPORTED_DEVICES[] = {
   0
 };
 
-QValueList<const Device::Data *> JALV2::Group::getSupportedDevices(const QString &) const
+TQValueList<const Device::Data *> JALV2::Group::getSupportedDevices(const TQString &) const
 {
-  QValueList<const Device::Data *> list;
+  TQValueList<const Device::Data *> list;
   for (uint i=0; SUPPORTED_DEVICES[i]; i++) {
     const Device::Data *data = Device::lister().data(SUPPORTED_DEVICES[i]);
     Q_ASSERT(data);
diff --git a/src/tools/jalv2/jalv2.h b/src/tools/jalv2/jalv2.h
index 80c3d02..3f1348c 100644
--- a/src/tools/jalv2/jalv2.h
+++ b/src/tools/jalv2/jalv2.h
@@ -17,20 +17,20 @@ namespace JALV2
 class Base : public Tool::Base
 {
 public:
-  virtual QString baseExecutable(bool, Tool::OutputExecutableType) const { return "jalv2"; }
+  virtual TQString baseExecutable(bool, Tool::OutputExecutableType) const { return "jalv2"; }
 
 private:
-  virtual QStringList checkExecutableOptions(bool) const { return QStringList(); }
-  virtual bool checkExecutableResult(bool withWine, QStringList &lines) const;
+  virtual TQStringList checkExecutableOptions(bool) const { return TQStringList(); }
+  virtual bool checkExecutableResult(bool withWine, TQStringList &lines) const;
 };
 
 //----------------------------------------------------------------------------
 class Group : public Tool::Group
 {
 public:
-  virtual QString name() const { return "jalv2"; }
-  virtual QString label() const { return i18n("JAL V2"); }
-  virtual QString informationText() const;
+  virtual TQString name() const { return "jalv2"; }
+  virtual TQString label() const { return i18n("JAL V2"); }
+  virtual TQString informationText() const;
   virtual bool hasDirectory(Compile::DirectoryType type) const { return type==Compile::DirectoryType::Header; }
   virtual Tool::Category checkDevicesCategory() const { return Tool::Category::Nb_Types; }
   virtual Tool::ExecutableType preferedExecutableType() const { return Tool::ExecutableType::Unix; }
@@ -39,7 +39,7 @@ public:
 
 private:
   virtual BaseData baseFactory(Tool::Category c) const;
-  virtual QValueList<const Device::Data *> getSupportedDevices(const QString &s) const;
+  virtual TQValueList<const Device::Data *> getSupportedDevices(const TQString &s) const;
   virtual Compile::Process *processFactory(const Compile::Data &data) const;
   virtual Compile::Config *configFactory(::Project *project) const;
   virtual Tool::SourceGenerator *sourceGeneratorFactory() const;
diff --git a/src/tools/jalv2/jalv2_compile.cpp b/src/tools/jalv2/jalv2_compile.cpp
index 0b1e7f5..73274aa 100644
--- a/src/tools/jalv2/jalv2_compile.cpp
+++ b/src/tools/jalv2/jalv2_compile.cpp
@@ -12,11 +12,11 @@
 #include "common/common/misc.h"
 #include "tools/list/compile_config.h"
 
-QStringList JALV2::CompileFile::genericArguments(const Compile::Config &config) const
+TQStringList JALV2::CompileFile::genericArguments(const Compile::Config &config) const
 {
-  QStringList args;
-  QStringList includes = config.includeDirs(Tool::Category::Compiler, QString::null, QString::null, ";");
-  QString s = (includes.isEmpty() ? QString::null : includes[0]);
+  TQStringList args;
+  TQStringList includes = config.includeDirs(Tool::Category::Compiler, TQString(), TQString(), ";");
+  TQString s = (includes.isEmpty() ? TQString() : includes[0]);
   PURL::Directory dir = Compile::Config::directory(group(), Compile::DirectoryType::Header).path();
   if ( !dir.isEmpty() ) {
     if ( !s.isEmpty() ) s += ";";
@@ -30,14 +30,14 @@ QStringList JALV2::CompileFile::genericArguments(const Compile::Config &config)
   return args;
 }
 
-void JALV2::CompileFile::logStderrLine(const QString &line)
+void JALV2::CompileFile::logStderrLine(const TQString &line)
 {
   if ( parseErrorLine(line, Compile::ParseErrorData("([^:]*):([0-9]+):\\s*(warning)(.+)", 1, 2, 4, 3)) ) return;
   if ( parseErrorLine(line, Compile::ParseErrorData("([^:]*):([0-9]+):\\s*(.+)", 1, 2, 3, Log::LineType::Error)) ) return;
-  doLog(Log::LineType::Normal, line, QString::null, 0); // unrecognized
+  doLog(Log::LineType::Normal, line, TQString(), 0); // unrecognized
 }
 
-QString JALV2::CompileFile::outputFiles() const
+TQString JALV2::CompileFile::outputFiles() const
 {
   return "PURL::AsmGPAsm PURL::Hex";
 }
diff --git a/src/tools/jalv2/jalv2_compile.h b/src/tools/jalv2/jalv2_compile.h
index de0257d..d145c4b 100644
--- a/src/tools/jalv2/jalv2_compile.h
+++ b/src/tools/jalv2/jalv2_compile.h
@@ -16,11 +16,12 @@ namespace JALV2
 class CompileFile : public Compile::Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QString deviceName() const { return _data.device; }
-  virtual void logStderrLine(const QString &line);
-  virtual QStringList genericArguments(const Compile::Config &config) const;
-  virtual QString outputFiles() const;
+  virtual TQString deviceName() const { return _data.device; }
+  virtual void logStderrLine(const TQString &line);
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
+  virtual TQString outputFiles() const;
 };
 
 } // namespace
diff --git a/src/tools/list/compile_config.cpp b/src/tools/list/compile_config.cpp
index 5ec8dfc..ffa1895 100644
--- a/src/tools/list/compile_config.cpp
+++ b/src/tools/list/compile_config.cpp
@@ -16,68 +16,68 @@
 //----------------------------------------------------------------------------
 PURL::Directory Compile::Config::directory(const Tool::Group &group, DirectoryType type)
 {
-  QString def;
+  TQString def;
   if ( type!=DirectoryType::Executable )
     def = group.autodetectDirectory(type, directory(group, DirectoryType::Executable), withWine(group)).path();
-  return PURL::Directory(value(group.name(), QString::null, type.key() + QString("_path"), def));
+  return PURL::Directory(value(group.name(), TQString(), type.key() + TQString("_path"), def));
 }
 void Compile::Config::setDirectory(const Tool::Group &group, DirectoryType type, const PURL::Directory &dir)
 {
-  setValue(group.name(), QString::null, type.key() + QString("_path"), dir.path());
+  setValue(group.name(), TQString(), type.key() + TQString("_path"), dir.path());
   if ( type==DirectoryType::Executable ) const_cast<Tool::Group &>(group).init();
 }
 
 bool Compile::Config::withWine(const Tool::Group &group)
 {
-  QString def = (group.preferedExecutableType()==Tool::ExecutableType::Unix ? "false" : "true");
-  return ( value(group.name(), QString::null, "with_wine", def)=="true" );
+  TQString def = (group.preferedExecutableType()==Tool::ExecutableType::Unix ? "false" : "true");
+  return ( value(group.name(), TQString(), "with_wine", def)=="true" );
 }
 void Compile::Config::setWithWine(const Tool::Group &group, bool withWine)
 {
-  setValue(group.name(), QString::null, "with_wine", withWine ? "true" : "false");
+  setValue(group.name(), TQString(), "with_wine", withWine ? "true" : "false");
   const_cast<Tool::Group &>(group).init();
 }
 
 Tool::OutputExecutableType Compile::Config::outputExecutableType(const Tool::Group &group)
 {
-  QString s = value(group.name(), QString::null, "output_type", Tool::OutputExecutableType(Tool::OutputExecutableType::Coff).key());
+  TQString s = value(group.name(), TQString(), "output_type", Tool::OutputExecutableType(Tool::OutputExecutableType::Coff).key());
   return Tool::OutputExecutableType::fromKey(s);
 }
 void Compile::Config::setOutputExecutableType(const Tool::Group &group, Tool::OutputExecutableType type)
 {
-  setValue(group.name(), QString::null, "output_type", type.key());
+  setValue(group.name(), TQString(), "output_type", type.key());
   const_cast<Tool::Group &>(group).init();
 }
 
-QString Compile::Config::value(const QString &group, const QString &subGroup, const QString &key, const QString &defaultValue)
+TQString Compile::Config::value(const TQString &group, const TQString &subGroup, const TQString &key, const TQString &defaultValue)
 {
-  QString grp = (subGroup.isEmpty() ? group : group + '-' + subGroup);
+  TQString grp = (subGroup.isEmpty() ? group : group + '-' + subGroup);
   GenericConfig gc(grp);
   return gc.readEntry(key, defaultValue);
 }
-void Compile::Config::setValue(const QString &group, const QString &subGroup, const QString &key, const QString &value)
+void Compile::Config::setValue(const TQString &group, const TQString &subGroup, const TQString &key, const TQString &value)
 {
-  QString grp = (subGroup.isEmpty() ? group : group + '-' + subGroup);
+  TQString grp = (subGroup.isEmpty() ? group : group + '-' + subGroup);
   GenericConfig gc(grp);
   gc.writeEntry(key, value);
 }
-QStringList Compile::Config::listValues(const QString &group, const QString &subGroup, const QString &key, const QStringList &defaultValues)
+TQStringList Compile::Config::listValues(const TQString &group, const TQString &subGroup, const TQString &key, const TQStringList &defaultValues)
 {
-  QString grp = (subGroup.isEmpty() ? group : group + '-' + subGroup);
+  TQString grp = (subGroup.isEmpty() ? group : group + '-' + subGroup);
   GenericConfig gc(grp);
   return gc.readListEntry(key, defaultValues);
 }
-void Compile::Config::setListValues(const QString &group, const QString &subGroup, const QString &key, const QStringList &values)
+void Compile::Config::setListValues(const TQString &group, const TQString &subGroup, const TQString &key, const TQStringList &values)
 {
-  QString grp = (subGroup.isEmpty() ? group : group + '-' + subGroup);
+  TQString grp = (subGroup.isEmpty() ? group : group + '-' + subGroup);
   GenericConfig gc(grp);
   gc.writeEntry(key, values);
 }
 
-QStringList Compile::Config::includeDirs(Tool::Category category, const QString &prefix, const QString &suffix, const QString &separator) const
+TQStringList Compile::Config::includeDirs(Tool::Category category, const TQString &prefix, const TQString &suffix, const TQString &separator) const
 {
-  QStringList list;
-  QStringList raw = rawIncludeDirs(category);
+  TQStringList list;
+  TQStringList raw = rawIncludeDirs(category);
   for (uint i=0; i<raw.size(); i++) {
     if ( separator.isEmpty() ) list.append(prefix + raw[i] + suffix);
     else if ( i==0 ) list.append(prefix + raw[i]);
@@ -89,101 +89,101 @@ QStringList Compile::Config::includeDirs(Tool::Category category, const QString
 
 HexBuffer::Format Compile::Config::hexFormat() const
 {
-  QString s = value(Tool::Category::Linker, "format", HexBuffer::FORMATS[HexBuffer::IHX32]);
+  TQString s = value(Tool::Category::Linker, "format", HexBuffer::FORMATS[HexBuffer::IHX32]);
   for (uint i=0; i<HexBuffer::Nb_Formats; i++)
     if ( s==HexBuffer::FORMATS[i] ) return HexBuffer::Format(i);
   return HexBuffer::Nb_Formats;
 }
 void Compile::Config::setHexFormat(HexBuffer::Format f)
 {
-  QString s = (f==HexBuffer::Nb_Formats ? 0 : HexBuffer::FORMATS[f]);
+  TQString s = (f==HexBuffer::Nb_Formats ? 0 : HexBuffer::FORMATS[f]);
   setValue(Tool::Category::Linker, "format", s);
 }
 
-QString Compile::Config::device(const Project *project)
+TQString Compile::Config::device(const Project *project)
 {
-  QString device = globalValue(project, "device", QString::null);
+  TQString device = globalValue(project, "device", TQString());
   return Device::lister().checkName(device);
 }
 
 const Tool::Group &Compile::Config::toolGroup(const Project *project)
 {
-  QString s = globalValue(project, "tool", QString::null);
+  TQString s = globalValue(project, "tool", TQString());
   const Tool::Group *group = Tool::lister().group(s);
   if ( group==0 ) return *Tool::lister().begin().data();
   return *group;
 }
 
-QStringList Compile::Config::customOptions(Tool::Category category) const
+TQStringList Compile::Config::customOptions(Tool::Category category) const
 {
-  return QStringList::split(' ', rawCustomOptions(category));
+  return TQStringList::split(' ', rawCustomOptions(category));
 }
 
-QStringList Compile::Config::customLibraries(Tool::Category category) const
+TQStringList Compile::Config::customLibraries(Tool::Category category) const
 {
-  return QStringList::split(' ', rawCustomLibraries(category));
+  return TQStringList::split(' ', rawCustomLibraries(category));
 }
 
-void Compile::Config::setValue(Tool::Category category, const QString &key, const QString &value)
+void Compile::Config::setValue(Tool::Category category, const TQString &key, const TQString &value)
 {
   Q_ASSERT( category!=Tool::Category::Nb_Types );
   Q_ASSERT( _project || _group );
   if (_project) _project->setValue(category.key(), key, value);
   else Config::setValue(_group->name(), category.key(), key, value);
 }
-QString Compile::Config::value(Tool::Category category, const QString &key, const QString &defaultValue) const
+TQString Compile::Config::value(Tool::Category category, const TQString &key, const TQString &defaultValue) const
 {
   Q_ASSERT( category!=Tool::Category::Nb_Types );
   Q_ASSERT( _project || _group );
   if (_project) return _project->value(category.key(), key, defaultValue);
   return Config::value(_group->name(), category.key(), key, defaultValue);
 }
-void Compile::Config::setListValues(Tool::Category category, const QString &key, const QStringList &values)
+void Compile::Config::setListValues(Tool::Category category, const TQString &key, const TQStringList &values)
 {
   Q_ASSERT( category!=Tool::Category::Nb_Types );
   Q_ASSERT( _project || _group );
   if (_project) _project->setListValues(category.key(), key, values);
   else Config::setListValues(_group->name(), category.key(), key, values);
 }
-QStringList Compile::Config::listValues(Tool::Category category, const QString &key, const QStringList &defaultValues) const
+TQStringList Compile::Config::listValues(Tool::Category category, const TQString &key, const TQStringList &defaultValues) const
 {
   Q_ASSERT( category!=Tool::Category::Nb_Types );
   Q_ASSERT( _project || _group );
   if (_project) return _project->listValues(category.key(), key, defaultValues);
   return Config::listValues(_group->name(), category.key(), key, defaultValues);
 }
-bool Compile::Config::boolValue(Tool::Category category, const QString &key, bool defaultValue) const
+bool Compile::Config::boolValue(Tool::Category category, const TQString &key, bool defaultValue) const
 {
-  QString s = value(category, key, QString::null);
+  TQString s = value(category, key, TQString());
   if ( s.isNull() ) return defaultValue;
   return !( s=="false" || s=="0" );
 }
-uint Compile::Config::uintValue(Tool::Category category, const QString &key, uint defaultValue) const
+uint Compile::Config::uintValue(Tool::Category category, const TQString &key, uint defaultValue) const
 {
   bool ok;
-  uint i = value(category, key, QString::null).toUInt(&ok);
+  uint i = value(category, key, TQString()).toUInt(&ok);
   if ( !ok ) return defaultValue;
   return i;
 }
 
-QString Compile::Config::globalValue(const Project *project, const QString &key, const QString &defaultValue)
+TQString Compile::Config::globalValue(const Project *project, const TQString &key, const TQString &defaultValue)
 {
   if (project) return project->value("general", key, defaultValue);
-  return Config::value("general", QString::null, key, defaultValue);
+  return Config::value("general", TQString(), key, defaultValue);
 }
-void Compile::Config::setGlobalValue(Project *project, const QString &key, const QString &value)
+void Compile::Config::setGlobalValue(Project *project, const TQString &key, const TQString &value)
 {
   if (project) project->setValue("general", key, value);
-  else Config::setValue("general", QString::null, key, value);
+  else Config::setValue("general", TQString(), key, value);
 }
 
-QStringList Compile::Config::globalListValues(const Project *project, const QString &key, const QStringList &defaultValues)
+TQStringList Compile::Config::globalListValues(const Project *project, const TQString &key, const TQStringList &defaultValues)
 {
   if (project) return project->listValues("general", key, defaultValues);
-  return Config::listValues("general", QString::null, key, defaultValues);
+  return Config::listValues("general", TQString(), key, defaultValues);
 }
-void Compile::Config::setGlobalListValues(Project *project, const QString &key, const QStringList &values)
+void Compile::Config::setGlobalListValues(Project *project, const TQString &key, const TQStringList &values)
 {
   if (project) project->setListValues("general", key, values);
-  else Config::setListValues("general", QString::null, key, values);
+  else Config::setListValues("general", TQString(), key, values);
 }
diff --git a/src/tools/list/compile_config.h b/src/tools/list/compile_config.h
index 13beff4..7e032a1 100644
--- a/src/tools/list/compile_config.h
+++ b/src/tools/list/compile_config.h
@@ -24,32 +24,32 @@ public:
 
   bool hasCustomArguments(Tool::Category category) const { return boolValue(category, "has_custom_arguments", false); }
   void setHasCustomArguments(Tool::Category category, bool custom) { setValue(category, "has_custom_arguments", custom); }
-  QStringList customArguments(Tool::Category category) const { return listValues(category, "custom_arguments", QStringList()); }
-  void setCustomArguments(Tool::Category category, const QStringList &args) { return setListValues(category, "custom_arguments", args); }
-  QStringList rawIncludeDirs(Tool::Category category) const { return listValues(category, "includes", "$(SRCPATH)"); }
-  QStringList includeDirs(Tool::Category category, const QString &prefix, const QString &suffix = QString::null, const QString &separator = QString::null) const;
-  void setRawIncludeDirs(Tool::Category category, const QStringList &dirs) { setListValues(category, "includes", dirs); }
-  QString rawCustomOptions(Tool::Category category) const { return value(category, "custom_options", QString::null); }
-  QStringList customOptions(Tool::Category category) const;
-  void setRawCustomOptions(Tool::Category category, const QString &value) { setValue(category, "custom_options", value); }
-  QString rawCustomLibraries(Tool::Category category) const { return value(category, "custom_libraries", QString::null); }
-  QStringList customLibraries(Tool::Category category) const;
-  void setRawCustomLibraries(Tool::Category category, const QString &value) { setValue(category, "custom_libraries", value); }
+  TQStringList customArguments(Tool::Category category) const { return listValues(category, "custom_arguments", TQStringList()); }
+  void setCustomArguments(Tool::Category category, const TQStringList &args) { return setListValues(category, "custom_arguments", args); }
+  TQStringList rawIncludeDirs(Tool::Category category) const { return listValues(category, "includes", "$(SRCPATH)"); }
+  TQStringList includeDirs(Tool::Category category, const TQString &prefix, const TQString &suffix = TQString(), const TQString &separator = TQString()) const;
+  void setRawIncludeDirs(Tool::Category category, const TQStringList &dirs) { setListValues(category, "includes", dirs); }
+  TQString rawCustomOptions(Tool::Category category) const { return value(category, "custom_options", TQString()); }
+  TQStringList customOptions(Tool::Category category) const;
+  void setRawCustomOptions(Tool::Category category, const TQString &value) { setValue(category, "custom_options", value); }
+  TQString rawCustomLibraries(Tool::Category category) const { return value(category, "custom_libraries", TQString()); }
+  TQStringList customLibraries(Tool::Category category) const;
+  void setRawCustomLibraries(Tool::Category category, const TQString &value) { setValue(category, "custom_libraries", value); }
   uint warningLevel(Tool::Category category) const { return uintValue(category, "warning_level", 0); }
-  void setWarningLevel(Tool::Category category, uint level) { setValue(category, "warning_level", QString::number(level)); }
+  void setWarningLevel(Tool::Category category, uint level) { setValue(category, "warning_level", TQString::number(level)); }
   HexBuffer::Format hexFormat() const;
   void setHexFormat(HexBuffer::Format format);
 
   static const Tool::Group &toolGroup(const Project *project);
   static void setToolGroup(Project *project, const Tool::Group &group) { setGlobalValue(project, "tool", group.name()); }
-  static QString device(const Project *project);
-  static void setDevice(Project *project, const QString &device) { setGlobalValue(project, "device", device); }
-  static QStringList customCommands(Project *project) { return globalListValues(project, "custom_shell_commands", QStringList()); }
-  static void setCustomCommands(Project *project, const QStringList &commands) { setGlobalListValues(project, "custom_shell_commands", commands); }
-  static QString globalValue(const Project *project, const QString &key, const QString &defaultValue);
-  static void setGlobalValue(Project *project, const QString &key, const QString &value);
-  static QStringList globalListValues(const Project *project, const QString &key, const QStringList &defaultValues);
-  static void setGlobalListValues(Project *project, const QString &key, const QStringList &value);
+  static TQString device(const Project *project);
+  static void setDevice(Project *project, const TQString &device) { setGlobalValue(project, "device", device); }
+  static TQStringList customCommands(Project *project) { return globalListValues(project, "custom_shell_commands", TQStringList()); }
+  static void setCustomCommands(Project *project, const TQStringList &commands) { setGlobalListValues(project, "custom_shell_commands", commands); }
+  static TQString globalValue(const Project *project, const TQString &key, const TQString &defaultValue);
+  static void setGlobalValue(Project *project, const TQString &key, const TQString &value);
+  static TQStringList globalListValues(const Project *project, const TQString &key, const TQStringList &defaultValues);
+  static void setGlobalListValues(Project *project, const TQString &key, const TQStringList &value);
 
   static PURL::Directory directory(const Tool::Group &group, DirectoryType type);
   static void setDirectory(const Tool::Group &group, DirectoryType type, const PURL::Directory &dir);
@@ -62,19 +62,19 @@ protected:
   const Tool::Group *_group;
   Project *_project;
 
-  void setValue(Tool::Category category, const QString &key, const QString &value);
-  QString value(Tool::Category category, const QString &key, const QString &defaultValue) const;
-  void setListValues(Tool::Category category, const QString &key, const QStringList &values);
-  QStringList listValues(Tool::Category category, const QString &key, const QStringList &defaultValues) const;
-  void setValue(Tool::Category category, const QString &key, bool value) { setValue(category, key, QString(value ? "true" : "false")); }
-  bool boolValue(Tool::Category category, const QString &key, bool defaultValue) const;
-  void setValue(Tool::Category category, const QString &key, uint value) { setValue(category, key, QString::number(value)); }
-  uint uintValue(Tool::Category category, const QString &key, uint defaultValue) const;
+  void setValue(Tool::Category category, const TQString &key, const TQString &value);
+  TQString value(Tool::Category category, const TQString &key, const TQString &defaultValue) const;
+  void setListValues(Tool::Category category, const TQString &key, const TQStringList &values);
+  TQStringList listValues(Tool::Category category, const TQString &key, const TQStringList &defaultValues) const;
+  void setValue(Tool::Category category, const TQString &key, bool value) { setValue(category, key, TQString(value ? "true" : "false")); }
+  bool boolValue(Tool::Category category, const TQString &key, bool defaultValue) const;
+  void setValue(Tool::Category category, const TQString &key, uint value) { setValue(category, key, TQString::number(value)); }
+  uint uintValue(Tool::Category category, const TQString &key, uint defaultValue) const;
 
-  static QString value(const QString &group, const QString &subGroup, const QString &key, const QString &defaultValue);
-  static void setValue(const QString &group, const QString &subGroup, const QString &key, const QString &value);
-  static QStringList listValues(const QString &group, const QString &subGroup, const QString &key, const QStringList &defaultValues);
-  static void setListValues(const QString &group, const QString &subGroup, const QString &key, const QStringList &values);
+  static TQString value(const TQString &group, const TQString &subGroup, const TQString &key, const TQString &defaultValue);
+  static void setValue(const TQString &group, const TQString &subGroup, const TQString &key, const TQString &value);
+  static TQStringList listValues(const TQString &group, const TQString &subGroup, const TQString &key, const TQStringList &defaultValues);
+  static void setListValues(const TQString &group, const TQString &subGroup, const TQString &key, const TQStringList &values);
 
   friend class Tool::Group;
 };
diff --git a/src/tools/list/compile_manager.cpp b/src/tools/list/compile_manager.cpp
index 00a4182..92f33a5 100644
--- a/src/tools/list/compile_manager.cpp
+++ b/src/tools/list/compile_manager.cpp
@@ -9,14 +9,14 @@
  ***************************************************************************/
 #include "compile_manager.h"
 
-#include <qtimer.h>
+#include <tqtimer.h>
 
 #include "libgui/project.h"
 #include "common/gui/misc_gui.h"
 #include "compile_config.h"
 
-Compile::Manager::Manager(QObject *parent)
-  : QObject(parent, "compile_manager"), _base(0)
+Compile::Manager::Manager(TQObject *tqparent)
+  : TQObject(tqparent, "compile_manager"), _base(0)
 {}
 
 void Compile::Manager::cleanFile(const PURL::Url &url)
@@ -39,7 +39,7 @@ bool Compile::Manager::setupFile(Operations op, const TodoItem &item)
   _todo.append(item);
   _action = Compiling;
   _wholeProject = false;
-  QTimer::singleShot(0, this, SLOT(start()));
+  TQTimer::singleShot(0, this, TQT_SLOT(start()));
   return true;
 }
 
@@ -74,7 +74,7 @@ bool Compile::Manager::setupProject(Operations op, LinkType type)
   }
   _action = Compiling;
   _wholeProject = true;
-  QTimer::singleShot(0, this, SLOT(start()));
+  TQTimer::singleShot(0, this, TQT_SLOT(start()));
   return true;
 }
 
@@ -106,9 +106,9 @@ bool Compile::Manager::setupCompile()
   for (uint i=0; i<_items.count(); i++) {
     if ( _items[i].url.fileType()!=type ) {
       if ( _operations!=Clean ) {
-        QString e = PURL::extensions(type);
+        TQString e = PURL::extensions(type);
         MessageBox::detailedSorry(i18n("The selected toolchain (%1) cannot compile file. It only supports files with extensions: %2")
-                                  .arg(Main::toolGroup().label()).arg(e), i18n("File: %1").arg(_items[i].url.pretty()), Log::Show);
+                                  .tqarg(Main::toolGroup().label()).tqarg(e), i18n("File: %1").tqarg(_items[i].url.pretty()), Log::Show);
         Log::Base::log(Log::LineType::Error, i18n("*** Aborted ***"), Log::Delayed);
         processFailed();
       }
@@ -131,9 +131,9 @@ bool Compile::Manager::setupAssemble()
     if ( _items[i].url.fileType()!=type ) {
       if ( _operations!=Clean ) {
         if ( type==PURL::Nb_FileTypes ) type = Main::toolGroup().implementationType(PURL::ToolType::Compiler);
-        QString e = PURL::extensions(type);
+        TQString e = PURL::extensions(type);
         MessageBox::detailedSorry(i18n("The selected toolchain (%1) cannot assemble file. It only supports files with extensions: %2")
-                                  .arg(Main::toolGroup().label()).arg(e), i18n("File: %1").arg(_items[i].url.pretty()), Log::Show);
+                                  .tqarg(Main::toolGroup().label()).tqarg(e), i18n("File: %1").tqarg(_items[i].url.pretty()), Log::Show);
         Log::Base::log(Log::LineType::Error, i18n("*** Aborted ***"), Log::Delayed);
         processFailed();
       }
@@ -216,7 +216,7 @@ void Compile::Manager::start()
   }
   if ( _operations & Clean ) {
     _base->files(0).onlyExistingFiles().cleanGenerated();
-    QTimer::singleShot(0, this, SLOT(start()));
+    TQTimer::singleShot(0, this, TQT_SLOT(start()));
     return;
   }
   if ( !_base->start() ) {
@@ -225,13 +225,13 @@ void Compile::Manager::start()
   }
 }
 
-void Compile::Manager::log(Log::LineType type, const QString &message, const QString &filepath, uint line)
+void Compile::Manager::log(Log::LineType type, const TQString &message, const TQString &filepath, uint line)
 {
   if ( type==Log::LineType::Error ) setError(message);
   static_cast<LogWidget *>(view())->appendLine(type, message, filepath, line);
 }
 
-void Compile::Manager::log(Log::DebugLevel level, const QString &message, const QString &filepath, uint line)
+void Compile::Manager::log(Log::DebugLevel level, const TQString &message, const TQString &filepath, uint line)
 {
   static_cast<LogWidget *>(view())->appendLine(level, message, filepath, line);
 }
@@ -249,7 +249,7 @@ void Compile::Manager::processDone()
     FileData::List list = _base->files(0).onlyExistingFiles();
     FileData::List::iterator it;
     for (it=list.begin(); it!=list.end(); ++it) emit updateFile(*it);
-    QTimer::singleShot(0, this, SLOT(start()));
+    TQTimer::singleShot(0, this, TQT_SLOT(start()));
   }
 }
 
@@ -263,18 +263,18 @@ void Compile::Manager::startCustomCommand()
 {
   delete _base;
   _base = 0;
-  QStringList commands = Compile::Config::customCommands(Main::project());
+  TQStringList commands = Compile::Config::customCommands(Main::project());
   if ( _customCommandIndex==commands.count() ) {
     Log::Base::log(Log::LineType::Information, i18n("*** Success ***"), Log::Delayed);
     emit success();
     return;
   }
-  QString command = commands[_customCommandIndex];
+  TQString command = commands[_customCommandIndex];
   _base = new CustomProcess(command);
   Compile::Data data(Tool::Category::Nb_Types, _todo, Main::device(), Main::project(), _type);
   _base->init(data, this);
   if ( !_base->start() ) {
-    Log::Base::log(Log::LineType::Error, i18n("Failed to execute custom command #%1.").arg(_customCommandIndex+1), Log::Delayed);
+    Log::Base::log(Log::LineType::Error, i18n("Failed to execute custom command #%1.").tqarg(_customCommandIndex+1), Log::Delayed);
     processFailed();
   }
 }
diff --git a/src/tools/list/compile_manager.h b/src/tools/list/compile_manager.h
index 6f617b4..0d144e6 100644
--- a/src/tools/list/compile_manager.h
+++ b/src/tools/list/compile_manager.h
@@ -14,16 +14,17 @@
 namespace Compile
 {
 
-class Manager : public QObject, public Log::Base
+class Manager : public TQObject, public Log::Base
 {
 Q_OBJECT
+  TQ_OBJECT
 public:
   enum Operation { NoOperation = 0, Clean = 1, CompileOnly = 2, Build = 4 };
-  Q_DECLARE_FLAGS(Operations, Operation)
+  TQ_DECLARE_FLAGS(Operations, Operation)
 
 public:
-  Manager(QObject *parent);
-  QString label() const { return _label; }
+  Manager(TQObject *tqparent);
+  TQString label() const { return _label; }
   bool compileFile(const TodoItem &item);
   void cleanFile(const PURL::Url &url);
   bool buildProject(LinkType type);
@@ -32,8 +33,8 @@ public:
   bool compileOnly() const { return (_operations & CompileOnly); }
   void processDone();
   void processFailed();
-  void log(Log::LineType type, const QString &message, const QString &filepath = QString::null, uint line = 0);
-  void log(Log::DebugLevel debug, const QString &message, const QString &filepath = QString::null, uint line = 0);
+  void log(Log::LineType type, const TQString &message, const TQString &filepath = TQString(), uint line = 0);
+  void log(Log::DebugLevel debug, const TQString &message, const TQString &filepath = TQString(), uint line = 0);
 
 signals:
   void success();
@@ -47,9 +48,9 @@ private:
   Operations _operations;
   enum Action { Compiling, Linking, BinToHex };
   Action     _action;
-  QValueList<TodoItem> _todo, _items;
+  TQValueList<TodoItem> _todo, _items;
   BaseProcess *_base;
-  QString    _label;
+  TQString    _label;
   LinkType   _type;
   bool       _wholeProject;
   uint       _customCommandIndex;
@@ -67,7 +68,7 @@ private:
   void startCustomCommand();
   void executeCustomCommands();
 };
-Q_DECLARE_OPERATORS_FOR_FLAGS(Manager::Operations)
+TQ_DECLARE_OPERATORS_FOR_FLAGS(Manager::Operations)
 
 } // namespace
 
diff --git a/src/tools/list/compile_process.cpp b/src/tools/list/compile_process.cpp
index 4f251bc..4d24e88 100644
--- a/src/tools/list/compile_process.cpp
+++ b/src/tools/list/compile_process.cpp
@@ -9,8 +9,8 @@
  ***************************************************************************/
 #include "compile_process.h"
 
-#include <qtimer.h>
-#include <qregexp.h>
+#include <tqtimer.h>
+#include <tqregexp.h>
 
 #include "devices/list/device_list.h"
 #include "common/global/process.h"
@@ -67,10 +67,10 @@ void Compile::FileData::List::cleanGenerated() const
 }
 
 //-----------------------------------------------------------------------------
-Compile::LogWidget::LogWidget(QWidget *parent)
-  : Log::Widget(parent, "compile_log")
+Compile::LogWidget::LogWidget(TQWidget *tqparent)
+  : Log::Widget(tqparent, "compile_log")
 {
-  connect(this, SIGNAL(clicked(int, int)), SLOT(lineClicked(int)));
+  connect(this, TQT_SIGNAL(clicked(int, int)), TQT_SLOT(lineClicked(int)));
 }
 
 void Compile::LogWidget::clear()
@@ -79,13 +79,13 @@ void Compile::LogWidget::clear()
   _map.clear();
 }
 
-void Compile::LogWidget::appendLine(Log::LineType type, const QString &message, const QString &filepath, uint line)
+void Compile::LogWidget::appendLine(Log::LineType type, const TQString &message, const TQString &filepath, uint line)
 {
   log(type, message, Log::Delayed);
   if ( !filepath.isEmpty() ) _map[paragraphs()-1] = Data(filepath, line);
 }
 
-void Compile::LogWidget::appendLine(Log::DebugLevel level, const QString &message, const QString &filepath, uint line)
+void Compile::LogWidget::appendLine(Log::DebugLevel level, const TQString &message, const TQString &filepath, uint line)
 {
   log(level, message, Log::Delayed);
   if ( !filepath.isEmpty() ) _map[paragraphs()-1] = Data(filepath, line);
@@ -93,16 +93,16 @@ void Compile::LogWidget::appendLine(Log::DebugLevel level, const QString &messag
 
 void Compile::LogWidget::lineClicked(int line)
 {
-  if ( !_map.contains(line) ) return;
+  if ( !_map.tqcontains(line) ) return;
   PURL::Url url = PURL::Url::fromPathOrUrl(_map[line].filepath);
-  TextEditor *e = ::qt_cast<TextEditor *>(Main::editorManager().openEditor(url));
+  TextEditor *e = ::tqqt_cast<TextEditor *>(Main::editorManager().openEditor(url));
   if ( e==0 ) return;
   e->setCursor(_map[line].line, 0);
 }
 
 //-----------------------------------------------------------------------------
 Compile::BaseProcess::BaseProcess()
-  : QObject(0, "compile_process"), _manager(0), _process(0)
+  : TQObject(0, "compile_process"), _manager(0), _process(0)
 {}
 
 void Compile::BaseProcess::init(const Data &data, Manager *manager)
@@ -120,14 +120,14 @@ PURL::Directory Compile::BaseProcess::directory(uint i) const
 
 bool Compile::BaseProcess::start()
 {
-  _stdout = QString::null;
-  _stderr = QString::null;
+  _stdout = TQString();
+  _stderr = TQString();
   delete _process;
   _process = new ::Process::LineSignal;
-  connect(_process, SIGNAL(done(int)), SLOT(done(int)));
-  connect(_process, SIGNAL(timeout()), SLOT(timeout()));
-  connect(_process, SIGNAL(logStdoutLine(const QString &)), SLOT(logStdoutLine(const QString &)));
-  connect(_process, SIGNAL(logStderrLine(const QString &)), SLOT(logStderrLine(const QString &)));
+  connect(_process, TQT_SIGNAL(done(int)), TQT_SLOT(done(int)));
+  connect(_process, TQT_SIGNAL(timeout()), TQT_SLOT(timeout()));
+  connect(_process, TQT_SIGNAL(logStdoutLine(const TQString &)), TQT_SLOT(logStdoutLine(const TQString &)));
+  connect(_process, TQT_SIGNAL(logStderrLine(const TQString &)), TQT_SLOT(logStderrLine(const TQString &)));
   _process->setWorkingDirectory(directory().path());
   setupProcess();
   _manager->log(Log::LineType::Command, _process->arguments().join(" "));
@@ -137,7 +137,7 @@ bool Compile::BaseProcess::start()
 void Compile::BaseProcess::done(int code)
 {
   if ( code!=0 ) {
-    _manager->log(Log::LineType::Error, i18n("*** Exited with status: %1 ***").arg(code));
+    _manager->log(Log::LineType::Error, i18n("*** Exited with status: %1 ***").tqarg(code));
     _manager->processFailed();
   } else if ( _manager->hasError() ) {
     _manager->log(Log::LineType::Error, i18n("*** Error ***"));
@@ -183,12 +183,12 @@ PURL::Url Compile::Process::url(PURL::FileType type, uint i) const
   return url.toFileType(type);
 }
 
-QString Compile::Process::filepath(PURL::FileType type, uint i) const
+TQString Compile::Process::filepath(PURL::FileType type, uint i) const
 {
   return url(type, i).relativeTo(directory(), Compile::Config::withWine(group()) ? PURL::WindowsSeparator : PURL::UnixSeparator);
 }
 
-QString Compile::Process::outputFilepath() const
+TQString Compile::Process::outputFilepath() const
 {
   if ( _data.category==Tool::Category::Librarian ) return filepath(PURL::Library);
   return filepath(PURL::Hex);
@@ -203,8 +203,8 @@ Compile::FileData::List Compile::Process::files(bool *ok) const
 {
   if (ok) *ok = true;
   FileData::List list;
-  QRegExp rexp("PURL::(.*)");
-  QStringList files = QStringList::split(" ", outputFiles());
+  TQRegExp rexp("PURL::(.*)");
+  TQStringList files = TQStringList::split(" ", outputFiles());
   for (uint i=0; i<files.count(); i++) {
     if ( rexp.exactMatch(files[i]) ) {
       PURL::FileType type = PURL::FileType::fromKey(rexp.cap(1));
@@ -228,31 +228,31 @@ Compile::FileData::List Compile::Process::files(bool *ok) const
   return list;
 }
 
-bool Compile::Process::checkIs(const QString &s, const QString &key)
+bool Compile::Process::checkIs(const TQString &s, const TQString &key)
 {
-  if ( !s.contains(key) ) return false;
+  if ( !s.tqcontains(key) ) return false;
   if ( s!=key ) qWarning("Argument should be only %s, the rest will be ignored...", key.latin1());
   return true;
 }
 
-QString Compile::Process::replaceIf(const QString &s, const QString &key, bool condition)
+TQString Compile::Process::replaceIf(const TQString &s, const TQString &key, bool condition)
 {
-  QRegExp rexp("(.*)\\$" + key + "\\(([^)]*)\\)(.*)");
+  TQRegExp rexp("(.*)\\$" + key + "\\(([^)]*)\\)(.*)");
   if ( !rexp.exactMatch(s) ) return s;
-  return rexp.cap(1) + (condition ? rexp.cap(2) : QString::null) + rexp.cap(3);
+  return rexp.cap(1) + (condition ? rexp.cap(2) : TQString()) + rexp.cap(3);
 }
 
-QStringList Compile::Process::arguments() const
+TQStringList Compile::Process::arguments() const
 {
   bool custom = _config->hasCustomArguments(_data.category);
   bool withWine = Compile::Config::withWine(group());
-  QStringList args = (custom ? _config->customArguments(_data.category) : genericArguments(*_config));
+  TQStringList args = (custom ? _config->customArguments(_data.category) : genericArguments(*_config));
   PURL::Url lkr = Main::toolGroup().linkerScript(_data.project, _data.linkType);
-  QStringList nargs;
+  TQStringList nargs;
   for (uint i=0; i<args.count(); i++) {
-    if ( args[i].contains("$(SRCPATH)") ) {
-      args[i].replace("$(SRCPATH)", directory().path());
-      args[i].replace("//", "/");
+    if ( args[i].tqcontains("$(SRCPATH)") ) {
+      args[i].tqreplace("$(SRCPATH)", directory().path());
+      args[i].tqreplace("//", "/");
     }
     args[i] = replaceIf(args[i], "WINE", withWine);
     args[i] = replaceIf(args[i], "LKR", hasLinkerScript());
@@ -267,22 +267,22 @@ QStringList Compile::Process::arguments() const
       continue;
     }
     if ( checkIs(args[i], "%LIBS") ) {
-      if (_data.project) nargs += _data.project->librariesForLinker(QString::null, withWine);
+      if (_data.project) nargs += _data.project->librariesForLinker(TQString(), withWine);
       continue;
     }
-    args[i].replace("%OBJECT", filepath(PURL::Object)); // before %O
-    args[i].replace("%O", outputFilepath());
-    args[i].replace("%COFF", filepath(PURL::Coff));
-    if (_data.project) args[i].replace("%PROJECT", _data.project->name());
-    else  args[i].replace("%PROJECT", url().basename());
-    args[i].replace("%MAP", filepath(PURL::Map));
-    args[i].replace("%SYM", url().toExtension("sym").relativeTo(directory(), withWine ? PURL::WindowsSeparator : PURL::UnixSeparator));
-    args[i].replace("%LIST", filepath(PURL::Lst));
-    args[i].replace("%DEVICE", deviceName());
-    args[i].replace("%FAMILY", familyName());
-    args[i].replace("%LKR_PATH", lkr.path()); // before %LKR
-    args[i].replace("%LKR_NAME", lkr.filename()); // before LKR
-    args[i].replace("%LKR", lkr.filepath());
+    args[i].tqreplace("%OBJECT", filepath(PURL::Object)); // before %O
+    args[i].tqreplace("%O", outputFilepath());
+    args[i].tqreplace("%COFF", filepath(PURL::Coff));
+    if (_data.project) args[i].tqreplace("%PROJECT", _data.project->name());
+    else  args[i].tqreplace("%PROJECT", url().basename());
+    args[i].tqreplace("%MAP", filepath(PURL::Map));
+    args[i].tqreplace("%SYM", url().toExtension("sym").relativeTo(directory(), withWine ? PURL::WindowsSeparator : PURL::UnixSeparator));
+    args[i].tqreplace("%LIST", filepath(PURL::Lst));
+    args[i].tqreplace("%DEVICE", deviceName());
+    args[i].tqreplace("%FAMILY", familyName());
+    args[i].tqreplace("%LKR_PATH", lkr.path()); // before %LKR
+    args[i].tqreplace("%LKR_NAME", lkr.filename()); // before LKR
+    args[i].tqreplace("%LKR", lkr.filepath());
     if ( checkIs(args[i], "%I") ) {
       for (uint k=0; k<nbFiles(); k++) nargs += inputFilepath(k);
       continue;
@@ -290,46 +290,46 @@ QStringList Compile::Process::arguments() const
     if ( !args[i].isEmpty() ) nargs += args[i];
   }
   args.clear();
-  for (uint i=0; i<nargs.count(); i++) args += QStringList::split("%SEP", nargs[i]);
+  for (uint i=0; i<nargs.count(); i++) args += TQStringList::split("%SEP", nargs[i]);
   return args;
 }
 
 void Compile::Process::setupProcess()
 {
   bool withWine = Compile::Config::withWine(group());
-  QString exec = tool()->baseExecutable(withWine, Compile::Config::outputExecutableType(group()));
-  QString path = tool()->executableDirectory().path();
+  TQString exec = tool()->baseExecutable(withWine, Compile::Config::outputExecutableType(group()));
+  TQString path = tool()->executableDirectory().path();
   _process->setup(path + exec, arguments(), withWine);
 }
 
-Log::LineType Compile::Process::filterType(const QString &type) const
+Log::LineType Compile::Process::filterType(const TQString &type) const
 {
-  QString s = type.lower();
+  TQString s = type.lower();
   if ( s.startsWith("warning") ) return Log::LineType::Warning;
   if ( s.startsWith("error") )   return Log::LineType::Error;
   if ( s.startsWith("message") ) return Log::LineType::Information;
   return Log::LineType::Normal;
 }
 
-bool Compile::Process::parseErrorLine(const QString &s, const ParseErrorData &data)
+bool Compile::Process::parseErrorLine(const TQString &s, const ParseErrorData &data)
 {
-  QRegExp re(data.pattern);
+  TQRegExp re(data.pattern);
   if ( !re.exactMatch(s) ) return false;
-  QString file;
+  TQString file;
   if ( data.indexFile>=0 ) {
     file = re.cap(data.indexFile).stripWhiteSpace();
     if ( file.endsWith(".") ) file = file.mid(0, file.length()-1);
-    if ( file=="-" ) file = QString::null;
+    if ( file=="-" ) file = TQString();
   }
   bool ok;
   int line = -1;
   if ( data.indexLine>=0 ) line = re.cap(data.indexLine).stripWhiteSpace().toUInt(&ok) - 1;
   if ( !ok ) line = -1;
-  QString message;
+  TQString message;
   if ( data.indexMessage>=0 ) message= re.cap(data.indexMessage).stripWhiteSpace();
   Log::LineType type = data.defaultLineType;
   if ( data.indexLogType>=0 ) {
-    QString s = re.cap(data.indexLogType).stripWhiteSpace();
+    TQString s = re.cap(data.indexLogType).stripWhiteSpace();
     if ( s.isEmpty() ) type = data.defaultLineType;
     else type = filterType(s);
   }
@@ -337,22 +337,22 @@ bool Compile::Process::parseErrorLine(const QString &s, const ParseErrorData &da
   return true;
 }
 
-void Compile::Process::doLog(const QString &type, const QString &message, const QString &surl, uint line)
+void Compile::Process::doLog(const TQString &type, const TQString &message, const TQString &surl, uint line)
 {
   doLog(filterType(type), message, surl, line);
 }
 
-void Compile::Process::doLog(Log::LineType type, const QString &message, const QString &surl, uint line)
+void Compile::Process::doLog(Log::LineType type, const TQString &message, const TQString &surl, uint line)
 {
   if ( surl.isEmpty() ) {
     _manager->log(type, message);
     return;
   }
   PURL::Url url = PURL::Url::fromPathOrUrl(surl);
-  QString s;
+  TQString s;
   if ( !url.isEmpty() ) {
     if ( !url.exists() && !url.isInto(directory()) ) url = PURL::Url(directory(), surl);
-    s += url.filename() + ":" + QString::number(line+1) + ": ";
+    s += url.filename() + ":" + TQString::number(line+1) + ": ";
   }
   switch (type.type()) {
     case Log::LineType::Warning:     s += i18n("warning: "); break;
@@ -367,10 +367,10 @@ void Compile::Process::doLog(Log::LineType type, const QString &message, const Q
 void Compile::CustomProcess::setupProcess()
 {
   _process->setUseShell(true);
-  _process->setup(_command, QStringList(), false);
+  _process->setup(_command, TQStringList(), false);
 }
 
-void Compile::CustomProcess::logStderrLine(const QString &line)
+void Compile::CustomProcess::logStderrLine(const TQString &line)
 {
   _manager->log(Log::LineType::Normal, line);
 }
diff --git a/src/tools/list/compile_process.h b/src/tools/list/compile_process.h
index 4fe396e..dd5ce3b 100644
--- a/src/tools/list/compile_process.h
+++ b/src/tools/list/compile_process.h
@@ -22,8 +22,8 @@ namespace Compile
 {
   class Manager;
   enum FileAction { NoAction = 0, Show = 1, InProject = 2, Generated = 8, Included = 16 };
-  Q_DECLARE_FLAGS(FileActions, FileAction)
-  Q_DECLARE_OPERATORS_FOR_FLAGS(FileActions)
+  TQ_DECLARE_FLAGS(FileActions, FileAction)
+  TQ_DECLARE_OPERATORS_FOR_FLAGS(FileActions)
 
   class FileData {
   public:
@@ -31,7 +31,7 @@ namespace Compile
     FileData(const PURL::Url &u, FileActions a) : url(u), actions(a) {}
     PURL::Url url;
     FileActions actions;
-    class List : public QValueList<FileData> {
+    class List : public TQValueList<FileData> {
     public:
       List() {}
       List(const FileData &data) { append(data); }
@@ -47,14 +47,14 @@ namespace Compile
 
   class ParseErrorData {
   public:
-    ParseErrorData(const QString &p, int iFile, int iLine, int iMessage, Log::LineType dLineType)
+    ParseErrorData(const TQString &p, int iFile, int iLine, int iMessage, Log::LineType dLineType)
       : pattern(p), indexFile(iFile), indexLine(iLine), indexMessage(iMessage), indexLogType(-1),
         defaultLineType(dLineType) {}
-    ParseErrorData(const QString &p, int iFile, int iLine, int iMessage, uint iLogType,
+    ParseErrorData(const TQString &p, int iFile, int iLine, int iMessage, uint iLogType,
                    Log::LineType dLineType = Log::LineType::Error)
       : pattern(p), indexFile(iFile), indexLine(iLine), indexMessage(iMessage), indexLogType(iLogType),
         defaultLineType(dLineType) {}
-    QString pattern;
+    TQString pattern;
     int indexFile, indexLine, indexMessage, indexLogType;
     Log::LineType defaultLineType;
   };
@@ -63,10 +63,11 @@ namespace Compile
 class LogWidget : public Log::Widget
 {
   Q_OBJECT
+  TQ_OBJECT
 public:
-  LogWidget(QWidget *parent);
-  void appendLine(Log::LineType type, const QString &message, const QString &filepath, uint line);
-  void appendLine(Log::DebugLevel debug, const QString &message, const QString &filepath, uint line);
+  LogWidget(TQWidget *tqparent);
+  void appendLine(Log::LineType type, const TQString &message, const TQString &filepath, uint line);
+  void appendLine(Log::DebugLevel debug, const TQString &message, const TQString &filepath, uint line);
   virtual void clear();
 
 private slots:
@@ -76,17 +77,18 @@ private:
   class Data {
   public:
     Data() {}
-    Data(const QString &fp, uint l) : filepath(fp), line(l) {}
-    QString filepath;
+    Data(const TQString &fp, uint l) : filepath(fp), line(l) {}
+    TQString filepath;
     uint line;
   };
-  QMap<uint, Data> _map;
+  TQMap<uint, Data> _map;
 };
 
 //-----------------------------------------------------------------------------
-class BaseProcess : public QObject
+class BaseProcess : public TQObject
 {
 Q_OBJECT
+  TQ_OBJECT
 public:
   BaseProcess();
   virtual void init(const Data &data, Manager *manager);
@@ -102,15 +104,15 @@ protected:
   Manager *_manager;
   Data    _data;
   ::Process::LineSignal *_process;
-  QString _stdout, _stderr;
+  TQString _stdout, _stderr;
 
   const Tool::Group &group() const { return Main::toolGroup(); }
   PURL::Directory directory(uint i = 0) const;
   virtual void setupProcess() = 0;
 
 protected slots:
-  virtual void logStdoutLine(const QString &line) { logStderrLine(line); }
-  virtual void logStderrLine(const QString &line) = 0;
+  virtual void logStdoutLine(const TQString &line) { logStderrLine(line); }
+  virtual void logStderrLine(const TQString &line) = 0;
   virtual void done(int code);
   void timeout();
 };
@@ -119,48 +121,50 @@ protected slots:
 class Process : public BaseProcess
 {
 Q_OBJECT
+  TQ_OBJECT
 public:
   virtual ~Process();
   virtual void init(const Data &data, Manager *manager);
   virtual bool check() const;
   virtual FileData::List files(bool *ok) const;
-  virtual QStringList genericArguments(const Compile::Config &config) const = 0;
+  virtual TQStringList genericArguments(const Compile::Config &config) const = 0;
   void checkArguments() const;
 
 protected:
   Config  *_config;
 
   virtual PURL::Url url(PURL::FileType type = PURL::Nb_FileTypes, uint i = 0) const;
-  QString filepath(PURL::FileType type, uint i=0) const;
-  virtual QString outputFilepath() const;
-  virtual QString outputFiles() const = 0;
+  TQString filepath(PURL::FileType type, uint i=0) const;
+  virtual TQString outputFilepath() const;
+  virtual TQString outputFiles() const = 0;
   uint nbFiles() const { return _data.items.count(); }
-  virtual QString inputFilepath(uint i) const { return filepath(PURL::Nb_FileTypes, i); }
-  virtual QString deviceName() const = 0;
-  virtual QString familyName() const { return QString::null; }
-  virtual QString objectExtension() const { return QString::null; }
-  virtual QString libraryExtension() const { return "lib"; }
+  virtual TQString inputFilepath(uint i) const { return filepath(PURL::Nb_FileTypes, i); }
+  virtual TQString deviceName() const = 0;
+  virtual TQString familyName() const { return TQString(); }
+  virtual TQString objectExtension() const { return TQString(); }
+  virtual TQString libraryExtension() const { return "lib"; }
   virtual bool hasLinkerScript() const { return group().hasCustomLinkerScript(_data.project); }
   FileData fileData(PURL::FileType type, FileActions actions) const;
-  bool parseErrorLine(const QString &s, const ParseErrorData &data);
-  virtual Log::LineType filterType(const QString &type) const;
-  void doLog(const QString &type, const QString &message, const QString &surl, uint line);
-  void doLog(Log::LineType type, const QString &message, const QString &surl, uint line);
+  bool parseErrorLine(const TQString &s, const ParseErrorData &data);
+  virtual Log::LineType filterType(const TQString &type) const;
+  void doLog(const TQString &type, const TQString &message, const TQString &surl, uint line);
+  void doLog(Log::LineType type, const TQString &message, const TQString &surl, uint line);
   virtual void setupProcess();
-  QStringList arguments() const;
+  TQStringList arguments() const;
   const Tool::Base *tool() const { return group().base(_data.category); }
 
 private:
-  static bool checkIs(const QString &s, const QString &key);
-  static QString replaceIf(const QString &s, const QString &key, bool condition);
+  static bool checkIs(const TQString &s, const TQString &key);
+  static TQString replaceIf(const TQString &s, const TQString &key, bool condition);
 };
 
 //-----------------------------------------------------------------------------
 class CustomProcess : public BaseProcess
 {
 Q_OBJECT
+  TQ_OBJECT
 public:
-  CustomProcess(const QString &command) : _command(command) {}
+  CustomProcess(const TQString &command) : _command(command) {}
   virtual bool check() const { return true; }
   virtual FileData::List files(bool *ok) const { if (ok) *ok = true; return FileData::List(); }
 
@@ -168,10 +172,10 @@ protected:
   virtual void setupProcess();
 
 protected slots:
-  virtual void logStderrLine(const QString &line);
+  virtual void logStderrLine(const TQString &line);
 
 private:
-  QString _command;
+  TQString _command;
 };
 
 } // namespace
diff --git a/src/tools/list/device_info.cpp b/src/tools/list/device_info.cpp
index 78ca7a7..be4169a 100644
--- a/src/tools/list/device_info.cpp
+++ b/src/tools/list/device_info.cpp
@@ -12,35 +12,35 @@
 #include "progs/list/prog_list.h"
 #include "tool_list.h"
 
-QString Device::webpageHtml(const Device::Data &data)
+TQString Device::webpageHtml(const Device::Data &data)
 {
   const Device::Documents &documents = data.documents();
-  QString url = "http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&amp;nodeId=";
+  TQString url = "http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&amp;nodeId=";
   if ( documents.webpage.isEmpty() ) url += "2044&amp;AllWords=" + data.name();
   else url += "1335&amp;dDocName=en" + documents.webpage;
   return "<a href=\"" + url + "\">" + i18n("Device Page") + "</a> ";
 }
 
-QString documentHtml(const QString &document, const QString &label)
+TQString documentHtml(const TQString &document, const TQString &label)
 {
-  if ( document.isEmpty() ) return QString::null;
+  if ( document.isEmpty() ) return TQString();
   return ", <a href=\"document://" + document + "\">" + label + "</a>";
 }
 
-QString Device::documentHtml(const Device::Data &data)
+TQString Device::documentHtml(const Device::Data &data)
 {
-  QString s = webpageHtml(data);
+  TQString s = webpageHtml(data);
   s += documentHtml(data.documents().datasheet, i18n("Datasheet"));
   s += documentHtml(data.documents().progsheet, i18n("Programming Specifications"));
   return htmlTableRow(i18n("Documents"), s);
 }
 
-QString Device::supportedHtmlInfo(const Device::Data &data)
+TQString Device::supportedHtmlInfo(const Device::Data &data)
 {
-  QString doc;
+  TQString doc;
   doc += "<hr />\n";
   doc += "<table>\n";
-  QString tools;
+  TQString tools;
   Tool::Lister::ConstIterator tit;
   for (tit=Tool::lister().begin(); tit!=Tool::lister().end(); ++tit) {
     if ( !tit.data()->isSupported(data.name()) ) continue;
@@ -49,7 +49,7 @@ QString Device::supportedHtmlInfo(const Device::Data &data)
     tools += tit.data()->label();
   }
   doc += htmlTableRow(i18n("Tools"), tools) + "\n";
-  QString progs;
+  TQString progs;
   Programmer::Lister::ConstIterator pit;
   for (pit=Programmer::lister().begin(); pit!=Programmer::lister().end(); ++pit) {
     if ( !pit.data()->isSupported(data.name()) ) continue;
diff --git a/src/tools/list/device_info.h b/src/tools/list/device_info.h
index ad69c59..036aac3 100644
--- a/src/tools/list/device_info.h
+++ b/src/tools/list/device_info.h
@@ -9,14 +9,14 @@
 #ifndef DEVICE_INFO_H
 #define DEVICE_INFO_H
 
-#include <qstring.h>
+#include <tqstring.h>
 namespace Device { class Data; }
 
 namespace Device
 {
-  extern QString webpageHtml(const Device::Data &data);
-  extern QString documentHtml(const Device::Data &data);
-  extern QString supportedHtmlInfo(const Device::Data &data);
+  extern TQString webpageHtml(const Device::Data &data);
+  extern TQString documentHtml(const Device::Data &data);
+  extern TQString supportedHtmlInfo(const Device::Data &data);
 } // namespace
 
 #endif
diff --git a/src/tools/list/tools_config_widget.cpp b/src/tools/list/tools_config_widget.cpp
index 449183d..43ca04c 100644
--- a/src/tools/list/tools_config_widget.cpp
+++ b/src/tools/list/tools_config_widget.cpp
@@ -9,8 +9,8 @@
  ***************************************************************************/
 #include "tools_config_widget.h"
 
-#include <qwidgetstack.h>
-#include <qlabel.h>
+#include <tqwidgetstack.h>
+#include <tqlabel.h>
 
 #include "tool_list.h"
 #include "tools/gui/tool_config_widget.h"
@@ -20,15 +20,15 @@
 #include "libgui/project.h"
 
 //----------------------------------------------------------------------------
-HelpDialog::HelpDialog(QWidget *parent)
-  : Dialog(parent, "help_dialog", false, i18n("Help Dialog"), Close, Close, false)
+HelpDialog::HelpDialog(TQWidget *tqparent)
+  : Dialog(tqparent, "help_dialog", false, i18n("Help Dialog"), Close, Close, false)
 {
-  QGridLayout *top = new QGridLayout(mainWidget(), 1, 1, 10, 10);
+  TQGridLayout *top = new TQGridLayout(mainWidget(), 1, 1, 10, 10);
   uint k = 0;
   for (; Compile::ARGUMENT_DATA[k].key; k++) {
-    QLabel *label = new QLabel(Compile::ARGUMENT_DATA[k].key, mainWidget());
+    TQLabel *label = new TQLabel(Compile::ARGUMENT_DATA[k].key, mainWidget());
     top->addWidget(label, k, 0);
-    label = new QLabel(i18n(Compile::ARGUMENT_DATA[k].description), mainWidget());
+    label = new TQLabel(i18n(Compile::ARGUMENT_DATA[k].description), mainWidget());
     top->addWidget(label, k, 1);
   }
   top->setColStretch(2, 1);
@@ -36,33 +36,33 @@ HelpDialog::HelpDialog(QWidget *parent)
 }
 
 //----------------------------------------------------------------------------
-ToolsConfigWidget::ToolsConfigWidget(Project *project, QWidget *parent)
-  : ::ConfigWidget(parent), _project(project), _helpDialog(0)
+ToolsConfigWidget::ToolsConfigWidget(Project *project, TQWidget *tqparent)
+  : ::ConfigWidget(tqparent), _project(project), _helpDialog(0)
 {
   uint row = 0;
 
-  QLabel *label = new QLabel(i18n("Toolchain:"), this);
+  TQLabel *label = new TQLabel(i18n("Toolchain:"), this);
   addWidget(label, row,row, 0,0);
-  _tool = new KeyComboBox<QString>(this);
+  _tool = new KeyComboBox<TQString>(this);
   Tool::Lister::ConstIterator it;
   for (it=Tool::lister().begin(); it!=Tool::lister().end(); ++it)
     _tool->appendItem(it.key(), it.data()->label());
-  connect(_tool->widget(), SIGNAL(activated(int)), SLOT(toolChanged()));
+  connect(_tool->widget(), TQT_SIGNAL(activated(int)), TQT_SLOT(toolChanged()));
   addWidget(_tool->widget(), row,row, 1,1);
-  label = new QLabel(i18n("Output type:"), this);
+  label = new TQLabel(i18n("Output type:"), this);
   addWidget(label, row,row, 2,2);
   _output = new KeyComboBox<Tool::OutputType>(this);
   FOR_EACH(Tool::OutputType, type) _output->appendItem(type, type.label());
   addWidget(_output->widget(), row,row, 3,3);
   row++;
 
-  _mainStack = new QWidgetStack(this);
+  _mainStack = new TQWidgetStack(this);
   addWidget(_mainStack, row,row, 0,4);
   row++;
-  _tabWidget = new QTabWidget(_mainStack);
+  _tabWidget = new TQTabWidget(_mainStack);
   _mainStack->addWidget(_tabWidget);
   FOR_EACH(Tool::Category, category) {
-    _stacks[category] = new KeyWidgetStack<QString>(_tabWidget);
+    _stacks[category] = new KeyWidgetStack<TQString>(_tabWidget);
     _stacks[category]->widget()->setMargin(10);
     Tool::Lister::ConstIterator it;
     for (it=Tool::lister().begin(); it!=Tool::lister().end(); ++it) {
@@ -71,13 +71,13 @@ ToolsConfigWidget::ToolsConfigWidget(Project *project, QWidget *parent)
       ToolConfigWidget *cw = static_cast<const Tool::GroupUI *>(it.data()->gui())->createConfigWidget(category, project);
       Q_ASSERT(cw);
       _stacks[category]->appendItem(it.key(), cw);
-      connect(cw, SIGNAL(displayHelp()), SLOT(displayHelp()));
+      connect(cw, TQT_SIGNAL(displayHelp()), TQT_SLOT(displayHelp()));
     }
   }
-  _customWidget = new QWidget(_mainStack);
+  _customWidget = new TQWidget(_mainStack);
   _mainStack->addWidget(_customWidget);
-  QVBoxLayout *vbox = new QVBoxLayout(_customWidget);
-  label = new QLabel(i18n("Custom shell commands:"), _customWidget);
+  TQVBoxLayout *vbox = new TQVBoxLayout(_customWidget);
+  label = new TQLabel(i18n("Custom shell commands:"), _customWidget);
   vbox->addWidget(label);
   _commandsEditor = new EditListBox(1, _customWidget, "command_editor", EditListBox::DuplicatesAllowed);
   vbox->addWidget(_commandsEditor);
@@ -87,7 +87,7 @@ ToolsConfigWidget::ToolsConfigWidget(Project *project, QWidget *parent)
 
 void ToolsConfigWidget::toolChanged()
 {
-  QString name = _tool->currentItem();
+  TQString name = _tool->currentItem();
   bool canMakeLibrary = Tool::lister().group(name)->needs(_project, Tool::Category::Librarian);
   _output->widget()->setEnabled(canMakeLibrary);
   if ( !canMakeLibrary ) _output->setCurrentItem(Tool::OutputType::Executable);
@@ -97,7 +97,7 @@ void ToolsConfigWidget::toolChanged()
     FOR_EACH(Tool::Category, k) {
       _tabWidget->removePage(_stacks[k]->widget());
       _stacks[k]->widget()->hide();
-      if ( _stacks[k]->contains(name) ) {
+      if ( _stacks[k]->tqcontains(name) ) {
         _stacks[k]->setCurrentItem(name);
         _stacks[k]->widget()->show();
         _tabWidget->addTab(_stacks[k]->widget(), i18n(k.data().title));
@@ -112,11 +112,11 @@ void ToolsConfigWidget::loadConfig()
   const Tool::Group &group = Compile::Config::toolGroup(_project);
   _tool->setCurrentItem(group.name());
   _output->setCurrentItem(_project->outputType());
-  QStringList commands = Compile::Config::customCommands(_project);
+  TQStringList commands = Compile::Config::customCommands(_project);
   _commandsEditor->setTexts(commands);
   toolChanged();
   FOR_EACH(Tool::Category, k) {
-    KeyWidgetStack<QString>::ConstIterator it;
+    KeyWidgetStack<TQString>::ConstIterator it;
     for (it=_stacks[k]->begin(); it!=_stacks[k]->end(); ++it) {
       if ( it.key()==Tool::Group::CUSTOM_NAME ) continue;
       static_cast<ToolConfigWidget *>(_stacks[k]->item(it.key()))->loadConfig();
@@ -126,13 +126,13 @@ void ToolsConfigWidget::loadConfig()
 
 void ToolsConfigWidget::saveConfig()
 {
-  QString name = _tool->currentItem();
+  TQString name = _tool->currentItem();
   Compile::Config::setToolGroup(_project, *Tool::lister().group(name));
   _project->setOutputType(_output->currentItem());
   Compile::Config::setCustomCommands(_project, _commandsEditor->texts());
   FOR_EACH(Tool::Category, k) {
-    if ( !_stacks[k]->contains(name) ) continue;
-    QWidget *w = _stacks[k]->item(name);
+    if ( !_stacks[k]->tqcontains(name) ) continue;
+    TQWidget *w = _stacks[k]->item(name);
     static_cast<ToolConfigWidget *>(w)->saveConfig();
   }
 }
diff --git a/src/tools/list/tools_config_widget.h b/src/tools/list/tools_config_widget.h
index 0f41b6a..bd4561a 100644
--- a/src/tools/list/tools_config_widget.h
+++ b/src/tools/list/tools_config_widget.h
@@ -10,9 +10,9 @@
 #ifndef TOOLS_CONFIG_WIDGET_H
 #define TOOLS_CONFIG_WIDGET_H
 
-#include <qcombobox.h>
-#include <qtabwidget.h>
-#include <qvaluevector.h>
+#include <tqcombobox.h>
+#include <tqtabwidget.h>
+#include <tqvaluevector.h>
 
 #include "common/gui/config_widget.h"
 #include "common/gui/dialog.h"
@@ -26,16 +26,18 @@ class ToolConfigWidget;
 class HelpDialog : public Dialog
 {
 Q_OBJECT
+  TQ_OBJECT
 public:
-  HelpDialog(QWidget *parent);
+  HelpDialog(TQWidget *tqparent);
 };
 
 //----------------------------------------------------------------------------
 class ToolsConfigWidget : public ConfigWidget
 {
 Q_OBJECT
+  TQ_OBJECT
 public:
-  ToolsConfigWidget(Project *project, QWidget *parent);
+  ToolsConfigWidget(Project *project, TQWidget *tqparent);
   virtual void loadConfig();
 
 public slots:
@@ -47,14 +49,14 @@ private slots:
 
 private:
   Project      *_project;
-  KeyComboBox<QString> *_tool;
+  KeyComboBox<TQString> *_tool;
   KeyComboBox<Tool::OutputType> *_output;
-  QWidgetStack *_mainStack;
-  QWidget      *_customWidget;
+  TQWidgetStack *_mainStack;
+  TQWidget      *_customWidget;
   EditListBox  *_commandsEditor;
-  QTabWidget   *_tabWidget;
-  QMap<Tool::Category, KeyWidgetStack<QString> *> _stacks;
-  QGuardedPtr<Dialog> _helpDialog;
+  TQTabWidget   *_tabWidget;
+  TQMap<Tool::Category, KeyWidgetStack<TQString> *> _stacks;
+  TQGuardedPtr<Dialog> _helpDialog;
 };
 
 #endif
diff --git a/src/tools/mpc/gui/mpc_ui.h b/src/tools/mpc/gui/mpc_ui.h
index 2fc51f9..38c0e7b 100644
--- a/src/tools/mpc/gui/mpc_ui.h
+++ b/src/tools/mpc/gui/mpc_ui.h
@@ -18,6 +18,7 @@ namespace MPC
 class ConfigWidget : public ToolConfigWidget
 {
 Q_OBJECT
+  TQ_OBJECT
 public:
   ConfigWidget(Project *project);
   virtual void initEntries() {}
diff --git a/src/tools/mpc/mpc.cpp b/src/tools/mpc/mpc.cpp
index 88f9ec2..8abb74e 100644
--- a/src/tools/mpc/mpc.cpp
+++ b/src/tools/mpc/mpc.cpp
@@ -8,7 +8,7 @@
  ***************************************************************************/
 #include "mpc.h"
 
-#include <qregexp.h>
+#include <tqregexp.h>
 
 #include "mpc_compile.h"
 #include "mpc_config.h"
@@ -17,10 +17,10 @@
 #include "devices/base/device_group.h"
 
 //----------------------------------------------------------------------------
-QValueList<const Device::Data *> MPC::Group::getSupportedDevices(const QString &) const
+TQValueList<const Device::Data *> MPC::Group::getSupportedDevices(const TQString &) const
 {
-  QValueList<const Device::Data *> list;
-  QValueVector<QString> devices = Device::lister().group("pic")->supportedDevices();
+  TQValueList<const Device::Data *> list;
+  TQValueVector<TQString> devices = Device::lister().group("pic")->supportedDevices();
   for (uint i=0; i<devices.count(); i++) {
     const Device::Data *data = Device::lister().data(devices[i]);
     Pic::Architecture arch = static_cast<const Pic::Data *>(data)->architecture();
@@ -45,9 +45,9 @@ Compile::Config *MPC::Group::configFactory(::Project *project) const
   return new Config(project);
 }
 
-QString MPC::Group::informationText() const
+TQString MPC::Group::informationText() const
 {
-  return i18n("<a href=\"%1\">MPC Compiler</a> is a C compiler distributed by Byte Craft.").arg("http://www.bytecraft.com/mpccaps.html");
+  return i18n("<a href=\"%1\">MPC Compiler</a> is a C compiler distributed by Byte Craft.").tqarg("http://www.bytecraft.com/mpccaps.html");
 }
 
 Tool::Group::BaseData MPC::Group::baseFactory(Tool::Category category) const
diff --git a/src/tools/mpc/mpc.h b/src/tools/mpc/mpc.h
index a378307..754221a 100644
--- a/src/tools/mpc/mpc.h
+++ b/src/tools/mpc/mpc.h
@@ -18,26 +18,26 @@ namespace MPC
 class Base : public Tool::Base
 {
 public:
-  virtual QString baseExecutable(bool, Tool::OutputExecutableType) const { return "mpcw"; }
+  virtual TQString baseExecutable(bool, Tool::OutputExecutableType) const { return "mpcw"; }
   virtual bool checkExecutable() const { return false; }
-  virtual QStringList checkExecutableOptions(bool) const { return QStringList(); }
-  virtual bool checkExecutableResult(bool, QStringList &) const { return true; }
+  virtual TQStringList checkExecutableOptions(bool) const { return TQStringList(); }
+  virtual bool checkExecutableResult(bool, TQStringList &) const { return true; }
 };
 
 //----------------------------------------------------------------------------
 class Group : public Tool::Group
 {
 public:
-  virtual QString name() const { return "mpcw"; }
-  virtual QString label() const { return i18n("MPC Compiler"); }
-  virtual QString informationText() const;
+  virtual TQString name() const { return "mpcw"; }
+  virtual TQString label() const { return i18n("MPC Compiler"); }
+  virtual TQString informationText() const;
   virtual Tool::Category checkDevicesCategory() const { return Tool::Category::Nb_Types; }
   virtual Tool::ExecutableType preferedExecutableType() const { return Tool::ExecutableType::Windows; }
   virtual Tool::CompileType compileType() const { return Tool::SingleFile; }
   virtual PURL::FileType implementationType(PURL::ToolType type) const { return (type==PURL::ToolType::Compiler ? PURL::CSource : PURL::Nb_FileTypes); }
 
 private:
-  virtual QValueList<const Device::Data *> getSupportedDevices(const QString &s) const;
+  virtual TQValueList<const Device::Data *> getSupportedDevices(const TQString &s) const;
   virtual Compile::Process *processFactory(const Compile::Data &data) const;
   virtual Compile::Config *configFactory(::Project *project) const;
   virtual BaseData baseFactory(Tool::Category) const;
diff --git a/src/tools/mpc/mpc_compile.cpp b/src/tools/mpc/mpc_compile.cpp
index 69ee994..8c39e3c 100644
--- a/src/tools/mpc/mpc_compile.cpp
+++ b/src/tools/mpc/mpc_compile.cpp
@@ -13,22 +13,22 @@
 #include "devices/list/device_list.h"
 #include "devices/pic/base/pic.h"
 
-QStringList MPC::CompileFile::genericArguments(const Compile::Config &) const
+TQStringList MPC::CompileFile::genericArguments(const Compile::Config &) const
 {
-  QStringList args;
+  TQStringList args;
   args += "%I";
   return args;
 }
 
-void MPC::CompileFile::logStderrLine(const QString &)
+void MPC::CompileFile::logStderrLine(const TQString &)
 {
   // ignore output
 }
 
-void MPC::CompileFile::parseLine(const QString &line)
+void MPC::CompileFile::parseLine(const TQString &line)
 {
   if ( parseErrorLine(line, Compile::ParseErrorData("(\\w+)\\s+(.*)\\s+(\\d+):\\d+:(.*)", 2, 3, 4, 1)) ) return;
-  doLog(Log::LineType::Normal, line, QString::null, 0); // unrecognized
+  doLog(Log::LineType::Normal, line, TQString(), 0); // unrecognized
 }
 
 void MPC::CompileFile::done(int code)
@@ -37,15 +37,15 @@ void MPC::CompileFile::done(int code)
   PURL::Url url = PURL::Url(directory(), inputFilepath(0)).toExtension("err");
   Log::StringView sview;
   PURL::File file(url, sview);
-  if ( !file.openForRead() ) doLog(Log::LineType::Error, i18n("Could not find error file (%1).").arg(url.pretty()), QString::null, 0);
+  if ( !file.openForRead() ) doLog(Log::LineType::Error, i18n("Could not find error file (%1).").tqarg(url.pretty()), TQString(), 0);
   else {
-    QStringList lines = file.readLines();
+    TQStringList lines = file.readLines();
     for (uint i=0; i<lines.count(); i++) parseLine(lines[i]);
   }
   Compile::Process::done(code);
 }
 
-QString MPC::CompileFile::outputFiles() const
+TQString MPC::CompileFile::outputFiles() const
 {
   return "PURL::Lst PURL::Hex PURL::Cod err";
 }
diff --git a/src/tools/mpc/mpc_compile.h b/src/tools/mpc/mpc_compile.h
index a699734..5744f1b 100644
--- a/src/tools/mpc/mpc_compile.h
+++ b/src/tools/mpc/mpc_compile.h
@@ -17,17 +17,18 @@ namespace MPC
 class CompileFile : public Compile::Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QString deviceName() const { return QString::null; }
-  virtual QStringList genericArguments(const Compile::Config &config) const;
-  virtual void logStderrLine(const QString &line);
-  virtual QString outputFiles() const;
+  virtual TQString deviceName() const { return TQString(); }
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
+  virtual void logStderrLine(const TQString &line);
+  virtual TQString outputFiles() const;
 
 protected slots:
   virtual void done(int code);
 
 private:
-  void parseLine(const QString &line);
+  void parseLine(const TQString &line);
 };
 
 } // namespace
diff --git a/src/tools/pic30/gui/pic30_ui.cpp b/src/tools/pic30/gui/pic30_ui.cpp
index 9d1b2c4..b4760dc 100644
--- a/src/tools/pic30/gui/pic30_ui.cpp
+++ b/src/tools/pic30/gui/pic30_ui.cpp
@@ -8,7 +8,7 @@
  ***************************************************************************/
 #include "pic30_ui.h"
 
-#include <qlabel.h>
+#include <tqlabel.h>
 
 #include "common/gui/purl_gui.h"
 #include "tools/pic30/pic30_config.h"
diff --git a/src/tools/pic30/gui/pic30_ui.h b/src/tools/pic30/gui/pic30_ui.h
index d9890e7..85f798c 100644
--- a/src/tools/pic30/gui/pic30_ui.h
+++ b/src/tools/pic30/gui/pic30_ui.h
@@ -19,6 +19,7 @@ namespace PIC30
 class ConfigWidget : public ToolConfigWidget
 {
 Q_OBJECT
+  TQ_OBJECT
 public:
   ConfigWidget(Project *project);
   virtual void initEntries();
diff --git a/src/tools/pic30/pic30.cpp b/src/tools/pic30/pic30.cpp
index 45b9270..e846719 100644
--- a/src/tools/pic30/pic30.cpp
+++ b/src/tools/pic30/pic30.cpp
@@ -17,9 +17,9 @@
 #include "pic30_generator.h"
 
 //----------------------------------------------------------------------------
-QString PIC30::Base::baseExecutable(bool, Tool::OutputExecutableType type) const
+TQString PIC30::Base::baseExecutable(bool, Tool::OutputExecutableType type) const
 {
-  QString s = "pic30-";
+  TQString s = "pic30-";
   if ( type==Tool::OutputExecutableType::Coff ) s += "coff";
   else s += "elf";
   s += "-";
@@ -32,16 +32,16 @@ QString PIC30::Base::baseExecutable(bool, Tool::OutputExecutableType type) const
     case Tool::Category::Nb_Types:  break;
   }
   Q_ASSERT(false);
-  return QString::null;
+  return TQString();
 }
 
-QStringList PIC30::Base::checkExecutableOptions(bool) const
+TQStringList PIC30::Base::checkExecutableOptions(bool) const
 {
   if ( _category!=Tool::Category::BinToHex ) return "--version";
-  return QStringList();
+  return TQStringList();
 }
 
-bool PIC30::Base::checkExecutableResult(bool, QStringList &lines) const
+bool PIC30::Base::checkExecutableResult(bool, TQStringList &lines) const
 {
   if ( lines.count()==0 ) return false;
   lines[0] = lines[0].stripWhiteSpace();
@@ -49,7 +49,7 @@ bool PIC30::Base::checkExecutableResult(bool, QStringList &lines) const
     case Tool::Category::Compiler:  return lines[0].startsWith("pic30");
     case Tool::Category::Assembler: return lines[0].startsWith("GNU assembler");
     case Tool::Category::Linker:    return lines[0].startsWith("GNU ld");
-    case Tool::Category::BinToHex:  return lines.join(" ").contains("Microchip ");
+    case Tool::Category::BinToHex:  return lines.join(" ").tqcontains("Microchip ");
     case Tool::Category::Librarian: return lines[0].startsWith("GNU ar");
     case Tool::Category::Nb_Types:  break;
   }
@@ -58,9 +58,9 @@ bool PIC30::Base::checkExecutableResult(bool, QStringList &lines) const
 }
 
 //----------------------------------------------------------------------------
-QString PIC30::Group::informationText() const
+TQString PIC30::Group::informationText() const
 {
-  return i18n("The <a href=\"%1\">PIC30 ToolChain</a> is a toolsuite for 16-bit PICs available from Microchip. Most of it is available under the GNU Public License.").arg("http://microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en010065&part=SW006012");
+  return i18n("The <a href=\"%1\">PIC30 ToolChain</a> is a toolsuite for 16-bit PICs available from Microchip. Most of it is available under the GNU Public License.").tqarg("http://microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en010065&part=SW006012");
 }
 
 Tool::Group::BaseData PIC30::Group::baseFactory(Tool::Category category) const
@@ -71,10 +71,10 @@ Tool::Group::BaseData PIC30::Group::baseFactory(Tool::Category category) const
   return BaseData();
 }
 
-QValueList<const Device::Data *> PIC30::Group::getSupportedDevices(const QString &) const
+TQValueList<const Device::Data *> PIC30::Group::getSupportedDevices(const TQString &) const
 {
-  QValueList<const Device::Data *> list;
-  QValueVector<QString> devices = Device::lister().group("pic")->supportedDevices();
+  TQValueList<const Device::Data *> list;
+  TQValueVector<TQString> devices = Device::lister().group("pic")->supportedDevices();
   for (uint i=0; i<devices.count(); i++) {
     const Device::Data *data = Device::lister().data(devices[i]);
     if ( static_cast<const Pic::Data *>(data)->is16bitFamily() ) list.append(data);
diff --git a/src/tools/pic30/pic30.h b/src/tools/pic30/pic30.h
index a490ed0..93e54c7 100644
--- a/src/tools/pic30/pic30.h
+++ b/src/tools/pic30/pic30.h
@@ -18,20 +18,20 @@ namespace PIC30
 class Base : public Tool::Base
 {
 public:
-  virtual QString baseExecutable(bool withWine, Tool::OutputExecutableType type) const;
+  virtual TQString baseExecutable(bool withWine, Tool::OutputExecutableType type) const;
 
 private:
-  virtual QStringList checkExecutableOptions(bool withWine) const;
-  virtual bool checkExecutableResult(bool withWine, QStringList &lines) const;
+  virtual TQStringList checkExecutableOptions(bool withWine) const;
+  virtual bool checkExecutableResult(bool withWine, TQStringList &lines) const;
 };
 
 //----------------------------------------------------------------------------
 class Group : public Tool::Group
 {
 public:
-  virtual QString name() const { return "pic30"; }
-  virtual QString label() const { return i18n("PIC30 Toolchain"); }
-  virtual QString informationText() const;
+  virtual TQString name() const { return "pic30"; }
+  virtual TQString label() const { return i18n("PIC30 Toolchain"); }
+  virtual TQString informationText() const;
   virtual bool hasDirectory(Compile::DirectoryType type) const { return type==Compile::DirectoryType::Header || type==Compile::DirectoryType::LinkerScript || type==Compile::DirectoryType::Library; }
   virtual PURL::Directory autodetectDirectory(Compile::DirectoryType type, const PURL::Directory &execDir, bool withWine) const;
   virtual bool hasOutputExecutableType(Tool::OutputExecutableType type) const { return ( type==Tool::OutputExecutableType::Coff || type==Tool::OutputExecutableType::Elf ); }
@@ -43,7 +43,7 @@ public:
 
 private:
   virtual BaseData baseFactory(Tool::Category category) const;
-  virtual QValueList<const Device::Data *> getSupportedDevices(const QString &s) const;
+  virtual TQValueList<const Device::Data *> getSupportedDevices(const TQString &s) const;
   virtual Compile::Process *processFactory(const Compile::Data &data) const;
   virtual Compile::Config *configFactory(::Project *project) const;
   virtual Tool::SourceGenerator *sourceGeneratorFactory() const;
diff --git a/src/tools/pic30/pic30_compile.cpp b/src/tools/pic30/pic30_compile.cpp
index 02cbb35..3674e4b 100644
--- a/src/tools/pic30/pic30_compile.cpp
+++ b/src/tools/pic30/pic30_compile.cpp
@@ -13,9 +13,9 @@
 #include "devices/list/device_list.h"
 
 //-----------------------------------------------------------------------------
-QStringList PIC30::CompileFile::genericArguments(const Compile::Config &config) const
+TQStringList PIC30::CompileFile::genericArguments(const Compile::Config &config) const
 {
-  QStringList args;
+  TQStringList args;
   args += "-S"; // compile only
   args += "$NO_AUTO_DEVICE(-mcpu=%DEVICE)";
   args += config.includeDirs(Tool::Category::Compiler, "-I");
@@ -25,43 +25,43 @@ QStringList PIC30::CompileFile::genericArguments(const Compile::Config &config)
   return args;
 }
 
-QString PIC30::CompileFile::outputFiles() const
+TQString PIC30::CompileFile::outputFiles() const
 {
   return "PURL::AsmPIC30";
 }
 
-void PIC30::CompileFile::logStderrLine(const QString &line)
+void PIC30::CompileFile::logStderrLine(const TQString &line)
 {
   // #### TODO
-  doLog(Log::LineType::Normal, line, QString::null, 0); // unrecognized
+  doLog(Log::LineType::Normal, line, TQString(), 0); // unrecognized
 }
 
 //-----------------------------------------------------------------------------
-QStringList PIC30::CompileStandaloneFile::genericArguments(const Compile::Config &config) const
+TQStringList PIC30::CompileStandaloneFile::genericArguments(const Compile::Config &config) const
 {
-  QStringList args = CompileFile::genericArguments(config);
+  TQStringList args = CompileFile::genericArguments(config);
   args += "%I";
   return args;
 }
 
-QString PIC30::CompileStandaloneFile::outputFiles() const
+TQString PIC30::CompileStandaloneFile::outputFiles() const
 {
   return CompileFile::outputFiles() + " PURL::Object PURL::Elf";
 }
 
 //-----------------------------------------------------------------------------
-QStringList PIC30::CompileProjectFile::genericArguments(const Compile::Config &config) const
+TQStringList PIC30::CompileProjectFile::genericArguments(const Compile::Config &config) const
 {
-  QStringList args = CompileFile::genericArguments(config);
+  TQStringList args = CompileFile::genericArguments(config);
   args += "-g";
   args += "%I";
   return args;
 }
 
 //-----------------------------------------------------------------------------
-QStringList PIC30::AssembleFile::genericArguments(const Compile::Config &config) const
+TQStringList PIC30::AssembleFile::genericArguments(const Compile::Config &config) const
 {
-  QStringList args;
+  TQStringList args;
   args += "-g";
   args += "-a=%LIST"; // listing
   args += "-o%O";
@@ -70,45 +70,45 @@ QStringList PIC30::AssembleFile::genericArguments(const Compile::Config &config)
   return args;
 }
 
-QString PIC30::AssembleFile::outputFiles() const
+TQString PIC30::AssembleFile::outputFiles() const
 {
   return "PURL::Object PURL::Lst";
 }
 
-void PIC30::AssembleFile::logStderrLine(const QString &line)
+void PIC30::AssembleFile::logStderrLine(const TQString &line)
 {
   // #### TODO
-  doLog(Log::LineType::Normal, line, QString::null, 0); // unrecognized
+  doLog(Log::LineType::Normal, line, TQString(), 0); // unrecognized
 }
 
 //-----------------------------------------------------------------------------
-QStringList PIC30::AssembleStandaloneFile::genericArguments(const Compile::Config &config) const
+TQStringList PIC30::AssembleStandaloneFile::genericArguments(const Compile::Config &config) const
 {
-  QStringList args = AssembleFile::genericArguments(config);
+  TQStringList args = AssembleFile::genericArguments(config);
   args += "$NO_AUTO_DEVICE(-p%DEVICE)";
   args += "%I";
   return args;
 }
 
 //-----------------------------------------------------------------------------
-QStringList PIC30::AssembleProjectFile::genericArguments(const Compile::Config &config) const
+TQStringList PIC30::AssembleProjectFile::genericArguments(const Compile::Config &config) const
 {
-  QStringList args = AssembleFile::genericArguments(config);
+  TQStringList args = AssembleFile::genericArguments(config);
   if ( !_data.items[0].generated ) args += "-p%DEVICE";
   args += "%I";
   return args;
 }
 
 //-----------------------------------------------------------------------------
-QString PIC30::Link::outputFilepath() const
+TQString PIC30::Link::outputFilepath() const
 {
   PURL::FileType type = Compile::Config::outputExecutableType(group()).data().type;
   return filepath(type);
 }
 
-QStringList PIC30::Link::genericArguments(const Compile::Config &config) const
+TQStringList PIC30::Link::genericArguments(const Compile::Config &config) const
 {
-  QStringList args;
+  TQStringList args;
   args += "-Map";
   args += "%MAP";
   args += "-o%O";
@@ -121,39 +121,39 @@ QStringList PIC30::Link::genericArguments(const Compile::Config &config) const
   return args;
 }
 
-QString PIC30::Link::outputFiles() const
+TQString PIC30::Link::outputFiles() const
 {
   PURL::FileType type = Compile::Config::outputExecutableType(group()).data().type;
-  return QString("PURL::Map PURL::") + type.key();
+  return TQString("PURL::Map PURL::") + type.key();
 }
 
-void PIC30::Link::logStderrLine(const QString &line)
+void PIC30::Link::logStderrLine(const TQString &line)
 {
   // #### TODO
-  doLog(Log::LineType::Normal, line, QString::null, 0); // unrecognized
+  doLog(Log::LineType::Normal, line, TQString(), 0); // unrecognized
 }
 
 //-----------------------------------------------------------------------------
-QStringList PIC30::LinkStandalone::genericArguments(const Compile::Config &config) const
+TQStringList PIC30::LinkStandalone::genericArguments(const Compile::Config &config) const
 {
-  QStringList args = Link::genericArguments(config);
+  TQStringList args = Link::genericArguments(config);
   args += config.customLibraries(Tool::Category::Linker);
   return args;
 }
 
 //-----------------------------------------------------------------------------
-QStringList PIC30::LinkProject::genericArguments(const Compile::Config &config) const
+TQStringList PIC30::LinkProject::genericArguments(const Compile::Config &config) const
 {
-  QStringList args = Link::genericArguments(config);
+  TQStringList args = Link::genericArguments(config);
   args += "%LIBS";
   args += config.customLibraries(Tool::Category::Linker);
   return args;
 }
 
 //-----------------------------------------------------------------------------
-QStringList PIC30::LibraryProject::genericArguments(const Compile::Config &) const
+TQStringList PIC30::LibraryProject::genericArguments(const Compile::Config &) const
 {
-  QStringList args;
+  TQStringList args;
   args += "-rc"; // insert new + do not warn if creating library
   args += "%O";
   args += "%LIBS";
@@ -161,36 +161,36 @@ QStringList PIC30::LibraryProject::genericArguments(const Compile::Config &) con
   return args;
 }
 
-void PIC30::LibraryProject::logStderrLine(const QString &line)
+void PIC30::LibraryProject::logStderrLine(const TQString &line)
 {
   // #### TODO
-  doLog(Log::LineType::Normal, line, QString::null, 0); // unrecognized
+  doLog(Log::LineType::Normal, line, TQString(), 0); // unrecognized
 }
 
-QString PIC30::LibraryProject::outputFiles() const
+TQString PIC30::LibraryProject::outputFiles() const
 {
   return "PURL::Library";
 }
 
 //-----------------------------------------------------------------------------
-QString PIC30::BinToHex::inputFilepath(uint) const
+TQString PIC30::BinToHex::inputFilepath(uint) const
 {
   PURL::FileType type = Compile::Config::outputExecutableType(group()).data().type;
   return filepath(type);
 }
 
-QStringList PIC30::BinToHex::genericArguments(const Compile::Config &) const
+TQStringList PIC30::BinToHex::genericArguments(const Compile::Config &) const
 {
   return "%I";
 }
 
-QString PIC30::BinToHex::outputFiles() const
+TQString PIC30::BinToHex::outputFiles() const
 {
   return "PURL::Hex";
 }
 
-void PIC30::BinToHex::logStderrLine(const QString &line)
+void PIC30::BinToHex::logStderrLine(const TQString &line)
 {
   // #### TODO
-  doLog(Log::LineType::Normal, line, QString::null, 0); // unrecognized
+  doLog(Log::LineType::Normal, line, TQString(), 0); // unrecognized
 }
diff --git a/src/tools/pic30/pic30_compile.h b/src/tools/pic30/pic30_compile.h
index c298eac..39bc243 100644
--- a/src/tools/pic30/pic30_compile.h
+++ b/src/tools/pic30/pic30_compile.h
@@ -17,110 +17,122 @@ namespace PIC30
 class Process : public Compile::Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QString deviceName() const { return _data.device; }
+  virtual TQString deviceName() const { return _data.device; }
 };
 
 //-----------------------------------------------------------------------------
 class CompileFile : public Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QStringList genericArguments(const Compile::Config &config) const;
-  virtual QString outputFiles() const;
-  virtual void logStderrLine(const QString &line);
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
+  virtual TQString outputFiles() const;
+  virtual void logStderrLine(const TQString &line);
 };
 
 //-----------------------------------------------------------------------------
 class CompileStandaloneFile : public CompileFile
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QStringList genericArguments(const Compile::Config &config) const;
-  virtual QString outputFiles() const;
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
+  virtual TQString outputFiles() const;
 };
 
 //-----------------------------------------------------------------------------
 class CompileProjectFile : public CompileFile
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QStringList genericArguments(const Compile::Config &config) const;
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
 };
 
 //-----------------------------------------------------------------------------
 class AssembleFile : public Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QString outputFilepath() const { return filepath(PURL::Object); }
-  virtual QStringList genericArguments(const Compile::Config &config) const;
-  virtual QString outputFiles() const;
-  virtual void logStderrLine(const QString &line);
+  virtual TQString outputFilepath() const { return filepath(PURL::Object); }
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
+  virtual TQString outputFiles() const;
+  virtual void logStderrLine(const TQString &line);
 };
 
 //-----------------------------------------------------------------------------
 class AssembleStandaloneFile : public AssembleFile
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QStringList genericArguments(const Compile::Config &config) const;
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
 };
 
 //-----------------------------------------------------------------------------
 class AssembleProjectFile : public AssembleFile
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QStringList genericArguments(const Compile::Config &config) const;
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
 };
 
 //-----------------------------------------------------------------------------
 class Link : public Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QString outputFilepath() const;
-  virtual QStringList genericArguments(const Compile::Config &config) const;
-  virtual QString outputFiles() const;
-  virtual void logStderrLine(const QString &line);
+  virtual TQString outputFilepath() const;
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
+  virtual TQString outputFiles() const;
+  virtual void logStderrLine(const TQString &line);
 };
 
 //-----------------------------------------------------------------------------
 class LinkStandalone : public Link
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QStringList genericArguments(const Compile::Config &config) const;
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
 };
 
 //-----------------------------------------------------------------------------
 class LinkProject : public Link
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QStringList genericArguments(const Compile::Config &config) const;
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
 };
 
 //-----------------------------------------------------------------------------
 class LibraryProject : public Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QStringList genericArguments(const Compile::Config &config) const;
-  virtual QString outputFiles() const;
-  virtual void logStderrLine(const QString &line);
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
+  virtual TQString outputFiles() const;
+  virtual void logStderrLine(const TQString &line);
 };
 
 //-----------------------------------------------------------------------------
 class BinToHex : public Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QString inputFilepath(uint i) const;
-  virtual QStringList genericArguments(const Compile::Config &config) const;
-  virtual QString outputFiles() const;
-  virtual void logStderrLine(const QString &line);
+  virtual TQString inputFilepath(uint i) const;
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
+  virtual TQString outputFiles() const;
+  virtual void logStderrLine(const TQString &line);
 };
 
 } // namespace
diff --git a/src/tools/pic30/pic30_generator.cpp b/src/tools/pic30/pic30_generator.cpp
index fe874e3..119c466 100644
--- a/src/tools/pic30/pic30_generator.cpp
+++ b/src/tools/pic30/pic30_generator.cpp
@@ -18,9 +18,9 @@ SourceLine::List PIC30::SourceGenerator::configLines(PURL::ToolType type, const
   SourceLine::List lines;
   for (uint i=0; i<data.nbWords(Pic::MemoryRangeType::Config); i++) {
     const Pic::Config::Word &cword = config._words[i];
-    QStringList cnames = SourceLine::configNames(Pic::ConfigNameType::Default, pmemory, i, ok);
+    TQStringList cnames = SourceLine::configNames(Pic::ConfigNameType::Default, pmemory, i, ok);
     if ( cnames.isEmpty() ) continue;
-    QString code;
+    TQString code;
     if ( type==PURL::ToolType::Assembler ) code += "config __" + cword.name + ", ";
     else code += "_" + cword.name + "(";
     code += cnames.join(" & ");
@@ -76,7 +76,7 @@ SourceLine::List PIC30::SourceGenerator::sourceFileContent(PURL::ToolType type,
     lines.appendIndentedCode("NOP", i18n("nop after SPLIM initialization"));
     lines.appendIndentedCode("CALL _wreg_init", i18n("call _wreg_init subroutine"));
     lines.appendEmpty();
-    lines.appendIndentedCode(QString::null, "<<" + i18n("insert code") + ">>");
+    lines.appendIndentedCode(TQString(), "<<" + i18n("insert code") + ">>");
     lines.appendEmpty();
     lines.appendNotIndentedCode("done:");
     lines.appendIndentedCode("BRA done", i18n("loop forever"));
@@ -95,7 +95,7 @@ SourceLine::List PIC30::SourceGenerator::sourceFileContent(PURL::ToolType type,
     lines.appendTitle(i18n("Timer1 interrupt service routine"));
     lines.appendNotIndentedCode("__T1Interrupt:");
     lines.appendIndentedCode("PUSH.D W4", i18n("example of context saving (push W4 and W5)"));
-    lines.appendIndentedCode(QString::null, "<<" + i18n("insert interrupt code") + ">>");
+    lines.appendIndentedCode(TQString(), "<<" + i18n("insert interrupt code") + ">>");
     lines.appendIndentedCode("BCLR IFS0, #T1IF", i18n("clear Timer1 interrupt flag status bit"));
     lines.appendIndentedCode("POP.D W4", i18n("restore context from stack"));
     lines.appendIndentedCode("RETFIE");
diff --git a/src/tools/picc/gui/picc_ui.h b/src/tools/picc/gui/picc_ui.h
index ec096c2..261e4dc 100644
--- a/src/tools/picc/gui/picc_ui.h
+++ b/src/tools/picc/gui/picc_ui.h
@@ -18,6 +18,7 @@ namespace PICC
 class ConfigWidget : public ToolConfigWidget
 {
 Q_OBJECT
+  TQ_OBJECT
 public:
   ConfigWidget(Project *project);
   virtual void initEntries();
diff --git a/src/tools/picc/picc.cpp b/src/tools/picc/picc.cpp
index f0d6e83..060aa4c 100644
--- a/src/tools/picc/picc.cpp
+++ b/src/tools/picc/picc.cpp
@@ -8,7 +8,7 @@
  ***************************************************************************/
 #include "picc.h"
 
-#include <qregexp.h>
+#include <tqregexp.h>
 
 #include "picc_compile.h"
 #include "picc_config.h"
@@ -17,36 +17,36 @@
 #include "common/global/process.h"
 
 //----------------------------------------------------------------------------
-bool PICC::Base::checkExecutableResult(bool, QStringList &lines) const
+bool PICC::Base::checkExecutableResult(bool, TQStringList &lines) const
 {
-  return lines.join(" ").contains("HI-TECH");
+  return lines.join(" ").tqcontains("HI-TECH");
 }
 
-QString PICC::BaseLite::baseExecutable(bool, Tool::OutputExecutableType) const
+TQString PICC::BaseLite::baseExecutable(bool, Tool::OutputExecutableType) const
 {
   if ( _category.type()==Tool::Category::Librarian ) return "libr";
   return "picl";
 }
 
-QString PICC::BaseNormal::baseExecutable(bool, Tool::OutputExecutableType) const
+TQString PICC::BaseNormal::baseExecutable(bool, Tool::OutputExecutableType) const
 {
   if ( _category.type()==Tool::Category::Librarian ) return "libr";
   return "picc";
 }
 
-QString PICC::Base18::baseExecutable(bool, Tool::OutputExecutableType) const
+TQString PICC::Base18::baseExecutable(bool, Tool::OutputExecutableType) const
 {
   if ( _category.type()==Tool::Category::Librarian ) return "libr";
   return "picc18";
 }
 
 //----------------------------------------------------------------------------
-QValueList<const Device::Data *> PICC::Group::getSupportedDevices(const QString &s) const
+TQValueList<const Device::Data *> PICC::Group::getSupportedDevices(const TQString &s) const
 {
-  QValueList<const Device::Data *> list;
-  QStringList lines = QStringList::split('\n', s);
+  TQValueList<const Device::Data *> list;
+  TQStringList lines = TQStringList::split('\n', s);
   for (uint i=0; i<lines.count(); i++) {
-    QRegExp re("([A-Za-z0-9]+):.*");
+    TQRegExp re("([A-Za-z0-9]+):.*");
     if ( !re.exactMatch(lines[i]) ) continue;
     const Device::Data *data = Device::lister().data(re.cap(1));
     if (data) list.append(data);
@@ -88,9 +88,9 @@ PURL::FileType PICC::Group::implementationType(PURL::ToolType type) const
 }
 
 //----------------------------------------------------------------------------
-QString PICC::PICCLiteGroup::informationText() const
+TQString PICC::PICCLiteGroup::informationText() const
 {
-  return i18n("<a href=\"%1\">PICC-Lite</a> is a freeware C compiler distributed by HTSoft.").arg("http://www.htsoft.com");
+  return i18n("<a href=\"%1\">PICC-Lite</a> is a freeware C compiler distributed by HTSoft.").tqarg("http://www.htsoft.com");
 }
 
 Tool::Group::BaseData PICC::PICCLiteGroup::baseFactory(Tool::Category category) const
@@ -101,9 +101,9 @@ Tool::Group::BaseData PICC::PICCLiteGroup::baseFactory(Tool::Category category)
 }
 
 //----------------------------------------------------------------------------
-QString PICC::PICCGroup::informationText() const
+TQString PICC::PICCGroup::informationText() const
 {
-  return i18n("<a href=\"%1\">PICC</a> is a C compiler distributed by HTSoft.").arg("http://www.htsoft.com");
+  return i18n("<a href=\"%1\">PICC</a> is a C compiler distributed by HTSoft.").tqarg("http://www.htsoft.com");
 }
 
 Tool::Group::BaseData PICC::PICCGroup::baseFactory(Tool::Category category) const
@@ -114,9 +114,9 @@ Tool::Group::BaseData PICC::PICCGroup::baseFactory(Tool::Category category) cons
 }
 
 //----------------------------------------------------------------------------
-QString PICC::PICC18Group::informationText() const
+TQString PICC::PICC18Group::informationText() const
 {
-  return i18n("<a href=\"%1\">PICC 18</a> is a C compiler distributed by HTSoft.").arg("http://www.htsoft.com");
+  return i18n("<a href=\"%1\">PICC 18</a> is a C compiler distributed by HTSoft.").tqarg("http://www.htsoft.com");
 }
 
 Tool::Group::BaseData PICC::PICC18Group::baseFactory(Tool::Category category) const
diff --git a/src/tools/picc/picc.h b/src/tools/picc/picc.h
index af44d02..ec017b9 100644
--- a/src/tools/picc/picc.h
+++ b/src/tools/picc/picc.h
@@ -17,26 +17,26 @@ namespace PICC
 class Base : public Tool::Base
 {
 private:
-  virtual QStringList checkExecutableOptions(bool) const { return "--ver"; }
-  virtual bool checkExecutableResult(bool withWine, QStringList &lines) const;
+  virtual TQStringList checkExecutableOptions(bool) const { return "--ver"; }
+  virtual bool checkExecutableResult(bool withWine, TQStringList &lines) const;
 };
 
 class BaseLite : public Base
 {
 public:
-  virtual QString baseExecutable(bool, Tool::OutputExecutableType) const;
+  virtual TQString baseExecutable(bool, Tool::OutputExecutableType) const;
 };
 
 class BaseNormal : public Base
 {
 public:
-  virtual QString baseExecutable(bool, Tool::OutputExecutableType) const;
+  virtual TQString baseExecutable(bool, Tool::OutputExecutableType) const;
 };
 
 class Base18 : public Base
 {
 public:
-  virtual QString baseExecutable(bool, Tool::OutputExecutableType) const;
+  virtual TQString baseExecutable(bool, Tool::OutputExecutableType) const;
 };
 
 //----------------------------------------------------------------------------
@@ -44,13 +44,13 @@ class Group : public Tool::Group
 {
 public:
   virtual Tool::Category checkDevicesCategory() const { return Tool::Category::Compiler; }
-  virtual QStringList checkDevicesOptions(uint) const { return "--CHIPINFO"; }
+  virtual TQStringList checkDevicesOptions(uint) const { return "--CHIPINFO"; }
   virtual Tool::ExecutableType preferedExecutableType() const { return Tool::ExecutableType::Unix; }
   virtual Tool::CompileType compileType() const { return Tool::SeparateFiles; }
   virtual PURL::FileType implementationType(PURL::ToolType type) const;
 
 private:
-  virtual QValueList<const Device::Data *> getSupportedDevices(const QString &s) const;
+  virtual TQValueList<const Device::Data *> getSupportedDevices(const TQString &s) const;
   virtual Compile::Process *processFactory(const Compile::Data &data) const;
   virtual Compile::Config *configFactory(::Project *project) const;
   virtual Tool::SourceGenerator *sourceGeneratorFactory() const { /*TODO*/ return 0; }
@@ -60,9 +60,9 @@ private:
 class PICCLiteGroup : public Group
 {
 public:
-  virtual QString name() const { return "picclite"; }
-  virtual QString label() const { return i18n("PICC Lite Compiler"); }
-  virtual QString informationText() const;
+  virtual TQString name() const { return "picclite"; }
+  virtual TQString label() const { return i18n("PICC Lite Compiler"); }
+  virtual TQString informationText() const;
 
 private:
   virtual BaseData baseFactory(Tool::Category) const;
@@ -72,9 +72,9 @@ private:
 class PICCGroup : public Group
 {
 public:
-  virtual QString name() const { return "picc"; }
-  virtual QString label() const { return i18n("PICC Compiler"); }
-  virtual QString informationText() const;
+  virtual TQString name() const { return "picc"; }
+  virtual TQString label() const { return i18n("PICC Compiler"); }
+  virtual TQString informationText() const;
 
 private:
   virtual BaseData baseFactory(Tool::Category) const;
@@ -84,9 +84,9 @@ private:
 class PICC18Group : public Group
 {
 public:
-  virtual QString name() const { return "picc18"; }
-  virtual QString label() const { return i18n("PICC-18 Compiler"); }
-  virtual QString informationText() const;
+  virtual TQString name() const { return "picc18"; }
+  virtual TQString label() const { return i18n("PICC-18 Compiler"); }
+  virtual TQString informationText() const;
 
 private:
   virtual BaseData baseFactory(Tool::Category) const;
diff --git a/src/tools/picc/picc_compile.cpp b/src/tools/picc/picc_compile.cpp
index 63fd127..ca390fc 100644
--- a/src/tools/picc/picc_compile.cpp
+++ b/src/tools/picc/picc_compile.cpp
@@ -11,9 +11,9 @@
 #include "picc_config.h"
 
 //-----------------------------------------------------------------------------
-QStringList PICC::Process::genericArguments(const Compile::Config &) const
+TQStringList PICC::Process::genericArguments(const Compile::Config &) const
 {
-  QStringList args;
+  TQStringList args;
   args += "--ERRFORMAT";
   args += "--WARNFORMAT";
   args += "--MSGFORMAT";
@@ -23,16 +23,16 @@ QStringList PICC::Process::genericArguments(const Compile::Config &) const
   return args;
 }
 
-void PICC::Process::logStderrLine(const QString &line)
+void PICC::Process::logStderrLine(const TQString &line)
 {
   // #### TODO
-  doLog(Log::LineType::Normal, line, QString::null, 0);
+  doLog(Log::LineType::Normal, line, TQString(), 0);
 }
 
 //-----------------------------------------------------------------------------
-QStringList PICC::CompileStandaloneFile::genericArguments(const Compile::Config &config) const
+TQStringList PICC::CompileStandaloneFile::genericArguments(const Compile::Config &config) const
 {
-  QStringList args = Process::genericArguments(config);
+  TQStringList args = Process::genericArguments(config);
   args += "-M%MAP";
   args += "-G%SYM";
   args += "--ASMLIST";
@@ -42,15 +42,15 @@ QStringList PICC::CompileStandaloneFile::genericArguments(const Compile::Config
   return args;
 }
 
-QString PICC::CompileStandaloneFile::outputFiles() const
+TQString PICC::CompileStandaloneFile::outputFiles() const
 {
   return "PURL::Lst PURL::Map obj PURL::Hex PURL::Coff sym sdb hxl rlf";
 }
 
 //-----------------------------------------------------------------------------
-QStringList PICC::CompileProjectFile::genericArguments(const Compile::Config &config) const
+TQStringList PICC::CompileProjectFile::genericArguments(const Compile::Config &config) const
 {
-  QStringList args = Process::genericArguments(config);
+  TQStringList args = Process::genericArguments(config);
   args += "-S";
   args += config.includeDirs(Tool::Category::Compiler, "-I");
   args += config.customOptions(Tool::Category::Compiler);
@@ -58,15 +58,15 @@ QStringList PICC::CompileProjectFile::genericArguments(const Compile::Config &co
   return args;
 }
 
-QString PICC::CompileProjectFile::outputFiles() const
+TQString PICC::CompileProjectFile::outputFiles() const
 {
   return "PURL::AsmPICC";
 }
 
 //-----------------------------------------------------------------------------
-QStringList PICC::AssembleStandaloneFile::genericArguments(const Compile::Config &config) const
+TQStringList PICC::AssembleStandaloneFile::genericArguments(const Compile::Config &config) const
 {
-  QStringList args = Process::genericArguments(config);
+  TQStringList args = Process::genericArguments(config);
   args += "-M%MAP";
   args += "-G%SYM";
   args += "--ASMLIST";
@@ -76,15 +76,15 @@ QStringList PICC::AssembleStandaloneFile::genericArguments(const Compile::Config
   return args;
 }
 
-QString PICC::AssembleStandaloneFile::outputFiles() const
+TQString PICC::AssembleStandaloneFile::outputFiles() const
 {
   return "PURL::Lst PURL::Map obj PURL::Hex sym sdb hxl rlf";
 }
 
 //-----------------------------------------------------------------------------
-QStringList PICC::AssembleProjectFile::genericArguments(const Compile::Config &config) const
+TQStringList PICC::AssembleProjectFile::genericArguments(const Compile::Config &config) const
 {
-  QStringList args = Process::genericArguments(config);
+  TQStringList args = Process::genericArguments(config);
   args += "-C";
   args += "--ASMLIST";
   args += config.includeDirs(Tool::Category::Assembler, "-I");
@@ -93,15 +93,15 @@ QStringList PICC::AssembleProjectFile::genericArguments(const Compile::Config &c
   return args;
 }
 
-QString PICC::AssembleProjectFile::outputFiles() const
+TQString PICC::AssembleProjectFile::outputFiles() const
 {
   return "obj PURL::Lst rlf";
 }
 
 //-----------------------------------------------------------------------------
-QStringList PICC::LinkProject::genericArguments(const Compile::Config &config) const
+TQStringList PICC::LinkProject::genericArguments(const Compile::Config &config) const
 {
-  QStringList args = Process::genericArguments(config);
+  TQStringList args = Process::genericArguments(config);
   args += "-O%O";
   args += "-M%MAP";
   args += "-G%SYM";
@@ -113,15 +113,15 @@ QStringList PICC::LinkProject::genericArguments(const Compile::Config &config) c
   return args;
 }
 
-QString PICC::LinkProject::outputFiles() const
+TQString PICC::LinkProject::outputFiles() const
 {
   return "PURL::Map PURL::Hex PURL::Coff sym sdb hxl";
 }
 
 //-----------------------------------------------------------------------------
-QStringList PICC::LibraryProject::genericArguments(const Compile::Config &config) const
+TQStringList PICC::LibraryProject::genericArguments(const Compile::Config &config) const
 {
-  QStringList args;
+  TQStringList args;
   args += config.customOptions(Tool::Category::Librarian);
   args += "r";
   args += "%O";
@@ -130,7 +130,7 @@ QStringList PICC::LibraryProject::genericArguments(const Compile::Config &config
   return args;
 }
 
-QString PICC::LibraryProject::outputFiles() const
+TQString PICC::LibraryProject::outputFiles() const
 {
   return "PURL::Library";
 }
diff --git a/src/tools/picc/picc_compile.h b/src/tools/picc/picc_compile.h
index 6db92ca..972a6d0 100644
--- a/src/tools/picc/picc_compile.h
+++ b/src/tools/picc/picc_compile.h
@@ -17,65 +17,72 @@ namespace PICC
 class Process : public Compile::Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QString deviceName() const { return _data.device; }
-  virtual QStringList genericArguments(const Compile::Config &config) const;
-  virtual void logStderrLine(const QString &line);
-  virtual QString objectExtension() const { return "obj"; }
+  virtual TQString deviceName() const { return _data.device; }
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
+  virtual void logStderrLine(const TQString &line);
+  virtual TQString objectExtension() const { return "obj"; }
 };
 
 //-----------------------------------------------------------------------------
 class CompileStandaloneFile : public Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QString outputFiles() const;
-  virtual QStringList genericArguments(const Compile::Config &config) const;
+  virtual TQString outputFiles() const;
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
 };
 
 //-----------------------------------------------------------------------------
 class CompileProjectFile : public Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QString outputFiles() const;
-  virtual QStringList genericArguments(const Compile::Config &config) const;
+  virtual TQString outputFiles() const;
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
 };
 
 //-----------------------------------------------------------------------------
 class AssembleStandaloneFile : public Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QString outputFiles() const;
-  virtual QStringList genericArguments(const Compile::Config &config) const;
+  virtual TQString outputFiles() const;
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
 };
 
 //-----------------------------------------------------------------------------
 class AssembleProjectFile : public Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QString outputFiles() const;
-  virtual QStringList genericArguments(const Compile::Config &config) const;
+  virtual TQString outputFiles() const;
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
 };
 
 //-----------------------------------------------------------------------------
 class LinkProject : public Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QString outputFiles() const;
-  virtual QStringList genericArguments(const Compile::Config &config) const;
+  virtual TQString outputFiles() const;
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
 };
 
 //-----------------------------------------------------------------------------
 class LibraryProject : public Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QString outputFiles() const;
-  virtual QStringList genericArguments(const Compile::Config &config) const;
+  virtual TQString outputFiles() const;
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
 };
 
 } // namespace
diff --git a/src/tools/sdcc/gui/sdcc_ui.h b/src/tools/sdcc/gui/sdcc_ui.h
index a0f0ffc..1b39fce 100644
--- a/src/tools/sdcc/gui/sdcc_ui.h
+++ b/src/tools/sdcc/gui/sdcc_ui.h
@@ -18,6 +18,7 @@ namespace SDCC
 class ConfigWidget : public ToolConfigWidget
 {
 Q_OBJECT
+  TQ_OBJECT
 public:
   ConfigWidget(Project *project);
   virtual void initEntries();
diff --git a/src/tools/sdcc/sdcc.cpp b/src/tools/sdcc/sdcc.cpp
index ba86273..bc3724d 100644
--- a/src/tools/sdcc/sdcc.cpp
+++ b/src/tools/sdcc/sdcc.cpp
@@ -17,15 +17,15 @@
 #include "sdcc_generator.h"
 
 //----------------------------------------------------------------------------
-bool SDCC::Base::checkExecutableResult(bool, QStringList &lines) const
+bool SDCC::Base::checkExecutableResult(bool, TQStringList &lines) const
 {
   return ( lines.count()>0 && lines[0].startsWith("SDCC") );
 }
 
 //----------------------------------------------------------------------------
-QString SDCC::Group::informationText() const
+TQString SDCC::Group::informationText() const
 {
-  return i18n("The <a href=\"%1\">Small Devices C Compiler</a> is an open-source C compiler for several families of microcontrollers.").arg("http://sdcc.sourceforge.net");
+  return i18n("The <a href=\"%1\">Small Devices C Compiler</a> is an open-source C compiler for several families of microcontrollers.").tqarg("http://sdcc.sourceforge.net");
 }
 
 const ::Tool::Base *SDCC::Group::base(Tool::Category category) const
@@ -50,10 +50,10 @@ SDCC::Group::Group()
   _checkDevicesTmp.close();
 }
 
-QStringList SDCC::Group::checkDevicesOptions(uint i) const
+TQStringList SDCC::Group::checkDevicesOptions(uint i) const
 {
-  QStringList options;
-  options += QString("-m") + SDCC::FAMILY_DATA[i].name;
+  TQStringList options;
+  options += TQString("-m") + SDCC::FAMILY_DATA[i].name;
   options += "-phelp";
   options += _checkDevicesTmp.url().filepath();
   return options;
@@ -103,7 +103,7 @@ Tool::SourceGenerator *SDCC::Group::sourceGeneratorFactory() const
   return new SourceGenerator;
 }
 
-bool SDCC::Group::generateDebugInformation(const QString &device) const
+bool SDCC::Group::generateDebugInformation(const TQString &device) const
 {
   switch (family(device)) {
     case P14: return false;
diff --git a/src/tools/sdcc/sdcc.h b/src/tools/sdcc/sdcc.h
index 3155273..f088bec 100644
--- a/src/tools/sdcc/sdcc.h
+++ b/src/tools/sdcc/sdcc.h
@@ -19,11 +19,11 @@ namespace SDCC
 class Base : public Tool::Base
 {
 public:
-  virtual QString baseExecutable(bool, Tool::OutputExecutableType) const { return "sdcc"; }
+  virtual TQString baseExecutable(bool, Tool::OutputExecutableType) const { return "sdcc"; }
 
 private:
-  virtual QStringList checkExecutableOptions(bool) const { return "-v"; }
-  virtual bool checkExecutableResult(bool withWine, QStringList &lines) const;
+  virtual TQStringList checkExecutableOptions(bool) const { return "-v"; }
+  virtual bool checkExecutableResult(bool withWine, TQStringList &lines) const;
 };
 
 //----------------------------------------------------------------------------
@@ -31,9 +31,9 @@ class Group : public Tool::Group
 {
 public:
   Group();
-  virtual QString name() const { return "sdcc"; }
-  virtual QString label() const { return i18n("Small Device C Compiler"); }
-  virtual QString informationText() const;
+  virtual TQString name() const { return "sdcc"; }
+  virtual TQString label() const { return i18n("Small Device C Compiler"); }
+  virtual TQString informationText() const;
   virtual const ::Tool::Base *base(Tool::Category category) const;
   virtual uint nbCheckDevices() const { return SDCC::Nb_Families; }
   virtual bool hasDirectory(Compile::DirectoryType type) const { return type==Compile::DirectoryType::Header || type==Compile::DirectoryType::LinkerScript; }
@@ -43,16 +43,16 @@ public:
   virtual Tool::ExecutableType preferedExecutableType() const { return Tool::ExecutableType::Unix; }
   virtual Tool::CompileType compileType() const { return Tool::SeparateFiles; }
   virtual Tool::Category checkDevicesCategory() const { return Tool::Category::Compiler; }
-  virtual QStringList checkDevicesOptions(uint i) const;
+  virtual TQStringList checkDevicesOptions(uint i) const;
   virtual bool needs(bool withProject, Tool::Category category) const;
   virtual PURL::FileType implementationType(PURL::ToolType type) const;
-  virtual bool generateDebugInformation(const QString &device) const;
+  virtual bool generateDebugInformation(const TQString &device) const;
 
 private:
   Log::StringView _sview;
   PURL::TempFile  _checkDevicesTmp;
   virtual BaseData baseFactory(Tool::Category category) const;
-  virtual QValueList<const Device::Data *> getSupportedDevices(const QString &s) const { return SDCC::getSupportedDevices(s); }
+  virtual TQValueList<const Device::Data *> getSupportedDevices(const TQString &s) const { return SDCC::getSupportedDevices(s); }
   virtual Compile::Process *processFactory(const Compile::Data &data) const;
   virtual Compile::Config *configFactory(::Project *project) const;
   virtual Tool::SourceGenerator *sourceGeneratorFactory() const;
diff --git a/src/tools/sdcc/sdcc_compile.cpp b/src/tools/sdcc/sdcc_compile.cpp
index a3c072f..1c2e04d 100644
--- a/src/tools/sdcc/sdcc_compile.cpp
+++ b/src/tools/sdcc/sdcc_compile.cpp
@@ -14,19 +14,19 @@
 #include "sdcc_generator.h"
 
 //-----------------------------------------------------------------------------
-QString SDCC::Process::familyName() const
+TQString SDCC::Process::familyName() const
 {
   return FAMILY_DATA[family(_data.device)].name;
 }
 
-QString SDCC::Process::deviceName() const
+TQString SDCC::Process::deviceName() const
 {
   return toDeviceName(_data.device);
 }
 
-QStringList SDCC::Process::genericArguments(const Compile::Config &) const
+TQStringList SDCC::Process::genericArguments(const Compile::Config &) const
 {
-  QStringList args;
+  TQStringList args;
   args += "-m%FAMILY";
   args += "-%DEVICE";
   args += "-V"; // verbose
@@ -34,12 +34,12 @@ QStringList SDCC::Process::genericArguments(const Compile::Config &) const
   return args;
 }
 
-QString SDCC::Process::outputFiles() const
+TQString SDCC::Process::outputFiles() const
 {
   return "PURL::Object PURL::AsmGPAsm adb p d PURL::Lst";
 }
 
-void SDCC::Process::logStderrLine(const QString &line)
+void SDCC::Process::logStderrLine(const TQString &line)
 {
   if ( parseErrorLine(line, Compile::ParseErrorData("([^:]*):([0-9]+):(error|warning|message):(.+)", 1, 2, 4, 3)) ) return;
   if ( parseErrorLine(line, Compile::ParseErrorData("([^:]*):([0-9]+):(\\w+)\\s*\\[[0-9]+\\](.+)", 1, 2, 4, 3)) ) return;
@@ -47,33 +47,33 @@ void SDCC::Process::logStderrLine(const QString &line)
   if ( parseErrorLine(line, Compile::ParseErrorData("([^:]*):([0-9]+):(.+)", 1, 2, 3, Log::LineType::Warning)) ) return;
   if ( parseErrorLine(line, Compile::ParseErrorData("([^:]*):([^:]+):([0-9]+):(.+)", 2, 3, 4, Log::LineType::Warning)) ) return;
   if ( parseErrorLine(line, Compile::ParseErrorData("([^:]+):(.+)", -1, -1, 2, 1, Log::LineType::Warning)) ) return;
-  doLog(filterType(line), line, QString::null, 0);
+  doLog(filterType(line), line, TQString(), 0);
 }
 
 //-----------------------------------------------------------------------------
-QStringList SDCC::CompileStandaloneFile::genericArguments(const Compile::Config &config) const
+TQStringList SDCC::CompileStandaloneFile::genericArguments(const Compile::Config &config) const
 {
-  QStringList args = Process::genericArguments(config);
+  TQStringList args = Process::genericArguments(config);
   args += config.includeDirs(Tool::Category::Compiler, "-I");
   args += config.customOptions(Tool::Category::Compiler);
   args += "-Wl-o%O";
   args += "-Wl-m"; // output map file
   HexBuffer::Format format = config.hexFormat();
   if( format!=HexBuffer::Nb_Formats )
-    args += QString("-Wl-a") + HexBuffer::FORMATS[format];
+    args += TQString("-Wl-a") + HexBuffer::FORMATS[format];
   args += "%I";
   return args;
 }
 
-QString SDCC::CompileStandaloneFile::outputFiles() const
+TQString SDCC::CompileStandaloneFile::outputFiles() const
 {
   return Process::outputFiles() + " PURL::Map PURL::Hex PURL::Cod rst sym mem lnk";
 }
 
 //-----------------------------------------------------------------------------
-QStringList SDCC::CompileProjectFile::genericArguments(const Compile::Config &config) const
+TQStringList SDCC::CompileProjectFile::genericArguments(const Compile::Config &config) const
 {
-  QStringList args = Process::genericArguments(config);
+  TQStringList args = Process::genericArguments(config);
   args += config.includeDirs(Tool::Category::Compiler, "-I");
   args += config.customOptions(Tool::Category::Compiler);
   args += "-c"; // compile only
@@ -82,9 +82,9 @@ QStringList SDCC::CompileProjectFile::genericArguments(const Compile::Config &co
 }
 
 //-----------------------------------------------------------------------------
-QStringList SDCC::LinkProjectFile::genericArguments(const Compile::Config &config) const
+TQStringList SDCC::LinkProjectFile::genericArguments(const Compile::Config &config) const
 {
-  QStringList args = Process::genericArguments(config);
+  TQStringList args = Process::genericArguments(config);
   args += "-Wl-c"; // create coff file
   args += "-Wl-m"; // output map file
   args += "$LKR(-Wl-s%LKR)";
@@ -97,7 +97,7 @@ QStringList SDCC::LinkProjectFile::genericArguments(const Compile::Config &confi
   return args;
 }
 
-QString SDCC::LinkProjectFile::outputFiles() const
+TQString SDCC::LinkProjectFile::outputFiles() const
 {
   return Process::outputFiles() + " PURL::Lkr PURL::Hex PURL::Cod PURL::Coff PURL::Map";
 }
diff --git a/src/tools/sdcc/sdcc_compile.h b/src/tools/sdcc/sdcc_compile.h
index 8ba4c30..c5067e6 100644
--- a/src/tools/sdcc/sdcc_compile.h
+++ b/src/tools/sdcc/sdcc_compile.h
@@ -17,12 +17,13 @@ namespace SDCC
 class Process : public Compile::Process
 {
 Q_OBJECT
+  TQ_OBJECT
 protected:
-  virtual QString deviceName() const;
-  virtual QString familyName() const;
-  virtual QStringList genericArguments(const Compile::Config &config) const;
-  virtual QString outputFiles() const;
-  virtual void logStderrLine(const QString &line);
+  virtual TQString deviceName() const;
+  virtual TQString familyName() const;
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
+  virtual TQString outputFiles() const;
+  virtual void logStderrLine(const TQString &line);
   virtual bool hasLinkerScript() const { return ( _data.linkType==Compile::Icd2Linking || Main::toolGroup().hasCustomLinkerScript(_data.project) ); }
 };
 
@@ -30,27 +31,30 @@ protected:
 class CompileStandaloneFile : public Process
 {
 Q_OBJECT
+  TQ_OBJECT
 private:
-  virtual QStringList genericArguments(const Compile::Config &config) const;
-  virtual QString outputFiles() const;
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
+  virtual TQString outputFiles() const;
 };
 
 //-----------------------------------------------------------------------------
 class CompileProjectFile : public Process
 {
 Q_OBJECT
+  TQ_OBJECT
 private:
-  virtual QStringList genericArguments(const Compile::Config &config) const;
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
 };
 
 //-----------------------------------------------------------------------------
 class LinkProjectFile : public Process
 {
 Q_OBJECT
+  TQ_OBJECT
 private:
-  virtual QStringList genericArguments(const Compile::Config &config) const;
-  virtual QString outputFiles() const;
-  virtual QString objectExtension() const { return "o"; }
+  virtual TQStringList genericArguments(const Compile::Config &config) const;
+  virtual TQString outputFiles() const;
+  virtual TQString objectExtension() const { return "o"; }
 };
 
 } // namespace
diff --git a/src/tools/sdcc/sdcc_generator.cpp b/src/tools/sdcc/sdcc_generator.cpp
index fb57ab6..0a2b0ee 100644
--- a/src/tools/sdcc/sdcc_generator.cpp
+++ b/src/tools/sdcc/sdcc_generator.cpp
@@ -18,7 +18,7 @@ const SDCC::FamilyData SDCC::FAMILY_DATA[Nb_Families] = {
   { "pic16" }
 };
 
-SDCC::Family SDCC::family(const QString &device)
+SDCC::Family SDCC::family(const TQString &device)
 {
   const Device::Data *data = Device::lister().data(device);
   switch (static_cast<const Pic::Data *>(data)->architecture().type()) {
@@ -38,12 +38,12 @@ SDCC::Family SDCC::family(const QString &device)
   return Nb_Families;
 }
 
-QString SDCC::toDeviceName(const QString &device)
+TQString SDCC::toDeviceName(const TQString &device)
 {
   return GPUtils::toDeviceName(device);
 }
 
-QValueList<const Device::Data *> SDCC::getSupportedDevices(const QString &s)
+TQValueList<const Device::Data *> SDCC::getSupportedDevices(const TQString &s)
 {
   return GPUtils::getSupportedDevices(s);
 }
@@ -60,12 +60,12 @@ SourceLine::List SDCC::SourceGenerator::configLines(PURL::ToolType type, const D
   SourceLine::List lines;
   if ( !data.is18Family() ) lines.appendNotIndentedCode("typedef unsigned int word;");
   Address address = data.range(Pic::MemoryRangeType::Config).start;
-  QString prefix = (data.nbWords(Pic::MemoryRangeType::Config)==2 || data.name().startsWith("16F9") ? "_" : "__");
+  TQString prefix = (data.nbWords(Pic::MemoryRangeType::Config)==2 || data.name().startsWith("16F9") ? "_" : "__");
   for (uint i=0; i<data.nbWords(Pic::MemoryRangeType::Config); i++) {
     const Pic::Config::Word &cword = config._words[i];
-    QStringList cnames = SourceLine::configNames(Pic::ConfigNameType::SDCC, pmemory, i, ok);
+    TQStringList cnames = SourceLine::configNames(Pic::ConfigNameType::SDCC, pmemory, i, ok);
     if ( cnames.isEmpty() ) continue;
-    QString code;
+    TQString code;
     if ( data.is18Family() ) code += "code char at ";
     else code += "word at ";
     if ( cword.name.isEmpty() ) code += toHexLabel(address, data.nbCharsAddress()) + " CONFIG";
@@ -99,7 +99,7 @@ SourceLine::List SDCC::SourceGenerator::sourceFileContent(PURL::ToolType type, c
   switch (static_cast<const Pic::Data &>(data).architecture().type()) {
     case Pic::Architecture::P16X:
       lines.appendNotIndentedCode("void isr() interrupt 0 {", i18n("interrupt service routine"));
-      lines.appendIndentedCode(QString::null, "<< " + i18n("insert interrupt code") + " >>");
+      lines.appendIndentedCode(TQString(), "<< " + i18n("insert interrupt code") + " >>");
       lines.appendNotIndentedCode("}");
       lines.appendEmpty();
       break;
@@ -111,7 +111,7 @@ SourceLine::List SDCC::SourceGenerator::sourceFileContent(PURL::ToolType type, c
     default: Q_ASSERT(false); break;
   }
   lines.appendNotIndentedCode("void main() {");
-  lines.appendIndentedCode(QString::null, "<< " + i18n("insert code") + " >>");
+  lines.appendIndentedCode(TQString(), "<< " + i18n("insert code") + " >>");
   lines.appendNotIndentedCode("}");
   return lines;
 }
diff --git a/src/tools/sdcc/sdcc_generator.h b/src/tools/sdcc/sdcc_generator.h
index e5f0101..a0f0f7e 100644
--- a/src/tools/sdcc/sdcc_generator.h
+++ b/src/tools/sdcc/sdcc_generator.h
@@ -19,9 +19,9 @@ struct FamilyData {
   const char *name;
 };
 extern const FamilyData FAMILY_DATA[Nb_Families];
-extern Family family(const QString &device);
-extern QString toDeviceName(const QString &device);
-extern QValueList<const Device::Data *> getSupportedDevices(const QString &s);
+extern Family family(const TQString &device);
+extern TQString toDeviceName(const TQString &device);
+extern TQValueList<const Device::Data *> getSupportedDevices(const TQString &s);
 
 //----------------------------------------------------------------------------
 class SourceGenerator : public Tool::SourceGenerator
@@ -36,7 +36,7 @@ private:
     const char *cname, *sdccName;
   };
   static const P16CNameData P16_CNAME_DATA[];
-  static void transformCName(QString &cname, const Pic::Data &data);
+  static void transformCName(TQString &cname, const Pic::Data &data);
 
 };
author	tpearson <tpearson@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>	2011-06-30 00:15:53 +0000
committer	tpearson <tpearson@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>	2011-06-30 00:15:53 +0000
commit	0aaa8e3fc8f8a1481333b564f0922277c8d8ad59 (patch)
tree	b95c0ca86c4876dd139af376b9f4afd8917cf0cd /src/tools
parent	b79a2c28534cf09987eeeba3077fff9236df182a (diff)
download	piklab-0aaa8e3fc8f8a1481333b564f0922277c8d8ad59.tar.gz piklab-0aaa8e3fc8f8a1481333b564f0922277c8d8ad59.zip