TQt4 port kmplayer

This enables compilation under both Qt3 and Qt4


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/kmplayer@1238840 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 117 insertions, 117 deletions

diff --git a/src/xineplayer.cpp b/src/xineplayer.cpp
index 17e6fd2..8bb391f 100644
--- a/src/xineplayer.cpp
+++ b/src/xineplayer.cpp
@@ -23,13 +23,13 @@
 #include <math.h>
 #include <libgen.h>
 #include <dcopclient.h>
-#include <qcstring.h>
-#include <qtimer.h>
-#include <qfile.h>
-#include <qurl.h>
-#include <qthread.h>
-#include <qmutex.h>
-#include <qdom.h>
+#include <tqcstring.h>
+#include <tqtimer.h>
+#include <tqfile.h>
+#include <tqurl.h>
+#include <tqthread.h>
+#include <tqmutex.h>
+#include <tqdom.h>
 #include "kmplayer_backend.h"
 #include "kmplayer_callback_stub.h"
 #include "kmplayer_callback.h"
@@ -62,7 +62,7 @@ typedef struct {
 
 static KXinePlayer * xineapp;
 static KMPlayer::Callback_stub * callback;
-static QMutex mutex (true);
+static TQMutex mutex (true);
 
 static xine_t              *xine;
 static xine_stream_t       *stream;
@@ -97,31 +97,31 @@ static double               pixel_aspect;
 
 static int                  running = 0;
 static volatile int         firstframe = 0;
-static const int            event_finished = QEvent::User;
-static const int            event_progress = QEvent::User + 2;
-static const int            event_url = QEvent::User + 3;
-static const int            event_size = QEvent::User + 4;
-static const int            event_title = QEvent::User + 5;
-static const int            event_video = QEvent::User + 6;
-static QString mrl;
-static QString sub_mrl;
-static QString rec_mrl;
-static QString alang, slang;
-static QStringList alanglist, slanglist;
-
-static QString elmentry ("entry");
-static QString elmitem ("item");
-static QString attname ("name");
-static QString atttype ("type");
-static QString attdefault ("DEFAULT");
-static QString attvalue ("value");
-static QString attstart ("START");
-static QString attend ("end");
-static QString valrange ("range");
-static QString valnum ("num");
-static QString valbool ("bool");
-static QString valenum ("enum");
-static QString valstring ("string");
+static const int            event_finished = TQEvent::User;
+static const int            event_progress = TQEvent::User + 2;
+static const int            event_url = TQEvent::User + 3;
+static const int            event_size = TQEvent::User + 4;
+static const int            event_title = TQEvent::User + 5;
+static const int            event_video = TQEvent::User + 6;
+static TQString mrl;
+static TQString sub_mrl;
+static TQString rec_mrl;
+static TQString alang, slang;
+static TQStringList alanglist, slanglist;
+
+static TQString elmentry ("entry");
+static TQString elmitem ("item");
+static TQString attname ("name");
+static TQString atttype ("type");
+static TQString attdefault ("DEFAULT");
+static TQString attvalue ("value");
+static TQString attstart ("START");
+static TQString attend ("end");
+static TQString valrange ("range");
+static TQString valnum ("num");
+static TQString valbool ("bool");
+static TQString valenum ("enum");
+static TQString valstring ("string");
 
 extern "C" {
 
@@ -146,7 +146,7 @@ static void frame_output_cb(void * /*data*/, int /*video_width*/, int /*video_he
         movie_width = xine_get_stream_info(stream, XINE_STREAM_INFO_VIDEO_WIDTH);
         movie_height = xine_get_stream_info(stream, XINE_STREAM_INFO_VIDEO_HEIGHT);
         mutex.unlock ();
-        QApplication::postEvent (xineapp, new XineMovieParamEvent (movie_length, movie_width, movie_height, alanglist, slanglist, true));
+        TQApplication::postEvent (xineapp, new XineMovieParamEvent (movie_length, movie_width, movie_height, alanglist, slanglist, true));
         
     }
 
@@ -185,15 +185,15 @@ static void event_listener(void * /*user_data*/, const xine_event_t *event) {
             if (repeat_count-- > 0)
                 xine_play (stream, 0, 0);
             else
-                QApplication::postEvent (xineapp, new QEvent ((QEvent::Type) event_finished));
+                TQApplication::postEvent (xineapp, new TQEvent ((TQEvent::Type) event_finished));
             break;
         case XINE_EVENT_PROGRESS:
-            QApplication::postEvent (xineapp, new XineProgressEvent (((xine_progress_data_t *) event->data)->percent));
+            TQApplication::postEvent (xineapp, new XineProgressEvent (((xine_progress_data_t *) event->data)->percent));
             break;
         case XINE_EVENT_MRL_REFERENCE:
             fprintf(stderr, "XINE_EVENT_MRL_REFERENCE %s\n", 
             ((xine_mrl_reference_data_t*)event->data)->mrl);
-            QApplication::postEvent (xineapp, new XineURLEvent (QString::fromLocal8Bit (((xine_mrl_reference_data_t*)event->data)->mrl)));
+            TQApplication::postEvent (xineapp, new XineURLEvent (TQString::fromLocal8Bit (((xine_mrl_reference_data_t*)event->data)->mrl)));
             break;
         case XINE_EVENT_FRAME_FORMAT_CHANGE:
             fprintf (stderr, "XINE_EVENT_FRAME_FORMAT_CHANGE\n");
@@ -201,7 +201,7 @@ static void event_listener(void * /*user_data*/, const xine_event_t *event) {
         case XINE_EVENT_UI_SET_TITLE:
             {
                 xine_ui_data_t * data = (xine_ui_data_t *) event->data;
-                QApplication::postEvent(xineapp, new XineTitleEvent(data->str));
+                TQApplication::postEvent(xineapp, new XineTitleEvent(data->str));
                 fprintf (stderr, "Set title event %s\n", data->str);
             }
             break;
@@ -221,7 +221,7 @@ static void event_listener(void * /*user_data*/, const xine_event_t *event) {
             for (int i = 0; i < nr; ++i) {
                 if (!xine_get_audio_lang (stream, i, langstr))
                     continue;
-                QString ls = QString::fromLocal8Bit (langstr).stripWhiteSpace();
+                TQString ls = TQString(TQString::fromLocal8Bit (langstr)).stripWhiteSpace();
                 if (ls.isEmpty ())
                     continue;
                 if (!slang.isEmpty () && alang == ls)
@@ -234,7 +234,7 @@ static void event_listener(void * /*user_data*/, const xine_event_t *event) {
             for (int i = 0; i < nr; ++i) {
                 if (!xine_get_spu_lang (stream, i, langstr))
                     continue;
-                QString ls = QString::fromLocal8Bit (langstr).stripWhiteSpace();
+                TQString ls = TQString(TQString::fromLocal8Bit (langstr)).stripWhiteSpace();
                 if (ls.isEmpty ())
                     continue;
                 if (!slang.isEmpty () && slang == ls)
@@ -247,7 +247,7 @@ static void event_listener(void * /*user_data*/, const xine_event_t *event) {
             movie_width = w;
             movie_height = h;
             movie_length = l;
-            QApplication::postEvent (xineapp, new XineMovieParamEvent (l, w, h, alanglist, slanglist, firstframe));
+            TQApplication::postEvent (xineapp, new XineMovieParamEvent (l, w, h, alanglist, slanglist, firstframe));
             if (running && firstframe)
                 firstframe = 0;
             if (window_created && w > 0 && h > 0) {
@@ -271,16 +271,16 @@ static void event_listener(void * /*user_data*/, const xine_event_t *event) {
 using namespace KMPlayer;
 
 Backend::Backend ()
-    : DCOPObject (QCString ("Backend")) {
+    : DCOPObject (TQCString ("Backend")) {
 }
 
 Backend::~Backend () {}
 
-void Backend::setURL (QString url) {
+void Backend::setURL (TQString url) {
     mrl = url;
 }
 
-void Backend::setSubTitleURL (QString url) {
+void Backend::setSubTitleURL (TQString url) {
     sub_mrl = url;
 }
 
@@ -289,7 +289,7 @@ void Backend::play (int repeat_count) {
 }
 
 void Backend::stop () {
-    QTimer::singleShot (0, xineapp, SLOT (stop ()));
+    TQTimer::singleShot (0, xineapp, TQT_SLOT (stop ()));
 }
 
 void Backend::pause () {
@@ -323,11 +323,11 @@ void Backend::volume (int v, bool) {
 void Backend::frequency (int) {
 }
 
-void Backend::setAudioLang (int id, QString al) {
+void Backend::setAudioLang (int id, TQString al) {
     xineapp->setAudioLang (id, al);
 }
 
-void Backend::setSubtitle (int id, QString sl) {
+void Backend::setSubtitle (int id, TQString sl) {
     xineapp->setSubtitle (id, sl);
 }
 
@@ -337,10 +337,10 @@ void Backend::quit () {
     if (running)
         stop ();
     else
-        QTimer::singleShot (0, qApp, SLOT (quit ()));
+        TQTimer::singleShot (0, tqApp, TQT_SLOT (quit ()));
 }
 
-bool updateConfigEntry (const QString & name, const QString & value) {
+bool updateConfigEntry (const TQString & name, const TQString & value) {
     fprintf (stderr, "%s=%s\n", name.ascii (), (const char *) value.local8Bit ());
     bool changed = false;
     xine_cfg_entry_t cfg_entry;
@@ -358,22 +358,22 @@ bool updateConfigEntry (const QString & name, const QString & value) {
     return changed;
 }
 
-void Backend::setConfig (QByteArray data) {
-    QString err;
+void Backend::setConfig (TQByteArray data) {
+    TQString err;
     int line, column;
-    QDomDocument dom;
+    TQDomDocument dom;
     if (dom.setContent (data, false, &err, &line, &column)) {
         if (dom.childNodes().length() == 1) {
-            for (QDomNode node = dom.firstChild().firstChild();
+            for (TQDomNode node = dom.firstChild().firstChild();
                     !node.isNull ();
                     node = node.nextSibling ()) {
-                QDomNamedNodeMap attr = node.attributes ();
+                TQDomNamedNodeMap attr = node.attributes ();
                 updateConfigEntry (attr.namedItem (attname).nodeValue (),
                                    attr.namedItem (attvalue).nodeValue ());
             }
             xine_config_save (xine, configfile);
         } else
-            err = QString ("invalid data");
+            err = TQString ("invalid data");
     }
     if (callback)
         callback->errorMessage (0, err);
@@ -389,7 +389,7 @@ bool Backend::isPlaying () {
 }
 
 KXinePlayer::KXinePlayer (int _argc, char ** _argv)
-  : QApplication (_argc, _argv, false) {
+  : TQApplication (_argc, _argv, false) {
 }
 
 void KXinePlayer::init () {
@@ -441,7 +441,7 @@ void KXinePlayer::init () {
     options[i+1] = 0L;
     xine_config_register_enum (xine, "audio.visualization", 0, (char ** ) options, 0L, 0L, 0, xine_config_cb, 0L);
     if (!callback)
-        QTimer::singleShot (10, this, SLOT (play ()));
+        TQTimer::singleShot (10, this, TQT_SLOT (play ()));
 }
 
 KXinePlayer::~KXinePlayer () {
@@ -456,32 +456,32 @@ KXinePlayer::~KXinePlayer () {
     xineapp = 0L;
 }
 
-void getConfigEntries (QByteArray & buf) {
+void getConfigEntries (TQByteArray & buf) {
     xine_cfg_entry_t entry;
-    QDomDocument doc;
-    QDomElement root = doc.createElement (QString ("document"));
+    TQDomDocument doc;
+    TQDomElement root = doc.createElement (TQString ("document"));
     for (int i = xine_config_get_first_entry (xine, &entry);
             i;
             i = xine_config_get_next_entry (xine, &entry)) {
-        QDomElement elm = doc.createElement (elmentry);
-        elm.setAttribute (attname, QString (entry.key));
+        TQDomElement elm = doc.createElement (elmentry);
+        elm.setAttribute (attname, TQString (entry.key));
         if (entry.type == XINE_CONFIG_TYPE_STRING || entry.type == XINE_CONFIG_TYPE_UNKNOWN) {
             elm.setAttribute (atttype, valstring);
-            elm.setAttribute (attvalue, QString (entry.str_value));
+            elm.setAttribute (attvalue, TQString (entry.str_value));
         } else {
-            elm.setAttribute (attdefault, QString::number (entry.num_default));
-            elm.setAttribute (attvalue, QString::number (entry.num_value));
+            elm.setAttribute (attdefault, TQString::number (entry.num_default));
+            elm.setAttribute (attvalue, TQString::number (entry.num_value));
             switch (entry.type) {
                 case XINE_CONFIG_TYPE_RANGE:
                     elm.setAttribute (atttype, valrange);
-                    elm.setAttribute (attstart, QString::number (entry.range_min));
-                    elm.setAttribute (attend, QString::number (entry.range_max));
+                    elm.setAttribute (attstart, TQString::number (entry.range_min));
+                    elm.setAttribute (attend, TQString::number (entry.range_max));
                     break;
                 case XINE_CONFIG_TYPE_ENUM:
                     elm.setAttribute (atttype, valenum);
                     for (int i = 0; entry.enum_values[i]; i++) {
-                        QDomElement item = doc.createElement (elmitem);
-                        item.setAttribute (attvalue, QString (entry.enum_values[i]));
+                        TQDomElement item = doc.createElement (elmitem);
+                        item.setAttribute (attvalue, TQString (entry.enum_values[i]));
                         elm.appendChild (item);
                     }
                     break;
@@ -496,12 +496,12 @@ void getConfigEntries (QByteArray & buf) {
             }
         }
         if (entry.help)
-            elm.appendChild (doc.createTextNode (QString::fromUtf8 (entry.help)));
+            elm.appendChild (doc.createTextNode (TQString::fromUtf8 (entry.help)));
         root.appendChild (elm);
     }
     doc.appendChild (root);
-    QString exp = doc.toString ();
-    QCString cexp = exp.utf8 ();
+    TQString exp = doc.toString ();
+    TQCString cexp = exp.utf8 ();
     buf.duplicate (cexp);
     buf.resize (cexp.length ()); // strip terminating \0
 }
@@ -522,7 +522,7 @@ void KXinePlayer::play (int repeat) {
     movie_height = 0;
 
     if (mrl.startsWith ("cdda://"))
-        mrl = QString ("cdda:/") + mrl.mid (7);
+        mrl = TQString ("cdda:/") + mrl.mid (7);
     stream = xine_stream_new (xine, ao_port, vo_port);
     event_queue = xine_event_new_queue (stream);
     xine_event_create_listener_thread (event_queue, event_listener, NULL);
@@ -531,12 +531,12 @@ void KXinePlayer::play (int repeat) {
         char ** mrls = xine_get_autoplay_mrls (xine, "CD", &nr);
         running = 1;
         for (int i = 0; i < nr; i++) {
-            QString m (mrls[i]);
-            QString title;
+            TQString m (mrls[i]);
+            TQString title;
             if (xine_open (stream, mrls[i])) {
                 const char * t = xine_get_meta_info (stream, XINE_META_INFO_TITLE);
                 if (t && t[0])
-                    title = QString::fromUtf8 (t);
+                    title = TQString::fromUtf8 (t);
                 xine_close (stream);
             }
             if (callback)
@@ -552,14 +552,14 @@ void KXinePlayer::play (int repeat) {
     xine_gui_send_vo_data(stream, XINE_GUI_SEND_VIDEOWIN_VISIBLE, (void *) 1);
 
     running = 1;
-    QString mrlsetup = mrl;
+    TQString mrlsetup = mrl;
     if (!rec_mrl.isEmpty ()) {
         char * rm = strdup (rec_mrl.local8Bit ());
         char *bn = basename (rm);
         char *dn = dirname (rm);
         if (bn)
-            updateConfigEntry (QString ("media.capture.save_dir"), QString::fromLocal8Bit (dn));
-        mrlsetup += QString ("#save:") + QString::fromLocal8Bit (bn);
+            updateConfigEntry (TQString ("media.capture.save_dir"), TQString::fromLocal8Bit (dn));
+        mrlsetup += TQString ("#save:") + TQString::fromLocal8Bit (bn);
         free (rm);
     }
     if (!xine_open (stream, (const char *) mrlsetup.local8Bit ())) {
@@ -593,7 +593,7 @@ void KXinePlayer::play (int repeat) {
     }
     audio_vis = false;
     if (xine_get_stream_info (stream, XINE_STREAM_INFO_HAS_VIDEO))
-        QApplication::postEvent(xineapp, new QEvent((QEvent::Type)event_video));
+        TQApplication::postEvent(xineapp, new TQEvent((TQEvent::Type)event_video));
     else
         audio_vis = xine_config_lookup_entry
             (xine, "audio.visualization", &audio_vis_cfg_entry);
@@ -613,11 +613,11 @@ void KXinePlayer::stop () {
         xine_stop (sub_stream);
     xine_stop (stream);
     mutex.unlock ();
-    QTimer::singleShot (10, this, SLOT (postFinished ()));
+    TQTimer::singleShot (10, this, TQT_SLOT (postFinished ()));
 }
 
 void KXinePlayer::postFinished () {
-    QApplication::postEvent (xineapp, new QEvent ((QEvent::Type) event_finished));
+    TQApplication::postEvent (xineapp, new TQEvent ((TQEvent::Type) event_finished));
 }
 
 void KXinePlayer::pause () {
@@ -633,10 +633,10 @@ void KXinePlayer::pause () {
 }
 
 void KXinePlayer::finished () {
-    QTimer::singleShot (10, this, SLOT (stop ()));
+    TQTimer::singleShot (10, this, TQT_SLOT (stop ()));
 }
 
-void KXinePlayer::setAudioLang (int id, const QString & al) {
+void KXinePlayer::setAudioLang (int id, const TQString & al) {
     alang = al;
     mutex.lock ();
     if (xine_get_status (stream) == XINE_STATUS_PLAY)
@@ -644,7 +644,7 @@ void KXinePlayer::setAudioLang (int id, const QString & al) {
     mutex.unlock ();
 }
 
-void KXinePlayer::setSubtitle (int id, const QString & sl) {
+void KXinePlayer::setSubtitle (int id, const TQString & sl) {
     slang = sl;
     mutex.lock ();
     if (xine_get_status (stream) == XINE_STATUS_PLAY)
@@ -662,7 +662,7 @@ void KXinePlayer::updatePosition () {
         movie_pos = pos;
         callback->moviePosition (pos/100);
     }
-    QTimer::singleShot (500, this, SLOT (updatePosition ()));
+    TQTimer::singleShot (500, this, TQT_SLOT (updatePosition ()));
 }
 
 void KXinePlayer::saturation (int val) {
@@ -721,7 +721,7 @@ void KXinePlayer::seek (int val) {
     }
 }
 
-bool KXinePlayer::event (QEvent * e) {
+bool KXinePlayer::event (TQEvent * e) {
     switch (e->type()) {
         case event_finished: {
             fprintf (stderr, "event_finished\n");
@@ -748,7 +748,7 @@ bool KXinePlayer::event (QEvent * e) {
             if (callback)
                 callback->finished ();
             else
-                QTimer::singleShot (0, this, SLOT (quit ()));
+                TQTimer::singleShot (0, this, TQT_SLOT (quit ()));
             break;
         }
         case event_size: {
@@ -758,7 +758,7 @@ bool KXinePlayer::event (QEvent * e) {
                 callback->movieParams (se->length/100, se->width, se->height, se->height ? 1.0*se->width/se->height : 1.0, se->alang, se->slang);
                 if (se->first_frame) {
                     callback->playing ();
-                    QTimer::singleShot (500, this, SLOT (updatePosition ()));
+                    TQTimer::singleShot (500, this, TQT_SLOT (updatePosition ()));
                 }
             }
             break;
@@ -772,7 +772,7 @@ bool KXinePlayer::event (QEvent * e) {
         case event_url: {
             XineURLEvent * ue = static_cast <XineURLEvent *> (e);                
             if (callback)
-                callback->subMrl (ue->url, QString ());
+                callback->subMrl (ue->url, TQString ());
             break;
         }
         case event_title: {
@@ -783,7 +783,7 @@ bool KXinePlayer::event (QEvent * e) {
         }
         case event_video:
             if (callback)
-                callback->statusMessage ((int) KMPlayer::Callback::stat_hasvideo, QString ());
+                callback->statusMessage ((int) KMPlayer::Callback::stat_hasvideo, TQString ());
             break;
         default:
             return false;
@@ -791,33 +791,33 @@ bool KXinePlayer::event (QEvent * e) {
     return true;
 }
 
-void KXinePlayer::saveState (QSessionManager & sm) {
+void KXinePlayer::saveState (TQSessionManager & sm) {
     if (callback)
-        sm.setRestartHint (QSessionManager::RestartNever);
+        sm.setRestartHint (TQSessionManager::RestartNever);
 }
 
-XineMovieParamEvent::XineMovieParamEvent(int l, int w, int h, const QStringList & a, const QStringList & s, bool ff)
-  : QEvent ((QEvent::Type) event_size),
+XineMovieParamEvent::XineMovieParamEvent(int l, int w, int h, const TQStringList & a, const TQStringList & s, bool ff)
+  : TQEvent ((TQEvent::Type) event_size),
     length (l), width (w), height (h), alang (a), slang (s) , first_frame (ff)
 {}
 
-XineURLEvent::XineURLEvent (const QString & u)
-  : QEvent ((QEvent::Type) event_url), url (u) 
+XineURLEvent::XineURLEvent (const TQString & u)
+  : TQEvent ((TQEvent::Type) event_url), url (u) 
 {}
 
 XineTitleEvent::XineTitleEvent (const char * t)
-  : QEvent ((QEvent::Type) event_title), title (QString::fromUtf8 (t)) 
+  : TQEvent ((TQEvent::Type) event_title), title (TQString::fromUtf8 (t)) 
 {
-    QUrl::decode (title);
+    TQUrl::decode (title);
 }
 
 XineProgressEvent::XineProgressEvent (const int p)
-  : QEvent ((QEvent::Type) event_progress), progress (p) 
+  : TQEvent ((TQEvent::Type) event_progress), progress (p) 
 {}
 
 //static bool translateCoordinates (int wx, int wy, int mx, int my) {
 //    movie_width
-class XEventThread : public QThread {
+class XEventThread : public TQThread {
 protected:
     void run () {
         Time prev_click_time = 0;
@@ -1056,8 +1056,8 @@ int main(int argc, char **argv) {
     snprintf(configfile, sizeof (configfile), "%s%s", xine_get_homedir(), "/.xine/config2");
     xineapp = new KXinePlayer (argc, argv);
     window_created = true;
-    QString vo_driver ("auto");
-    QString ao_driver ("auto");
+    TQString vo_driver ("auto");
+    TQString ao_driver ("auto");
     for (int i = 1; i < argc; i++) {
         if (!strcmp (argv [i], "-vo") && ++i < argc) {
             vo_driver = argv [i];
@@ -1079,9 +1079,9 @@ int main(int argc, char **argv) {
         } else if (!strcmp (argv [i], "-window")) {
             ;
         } else if (!strcmp (argv [i], "-sub") && ++i < argc) {
-            sub_mrl = QString (argv [i]);
+            sub_mrl = TQString (argv [i]);
         } else if (!strcmp (argv [i], "-lang") && ++i < argc) {
-            slang = alang = QString (argv [i]);
+            slang = alang = TQString (argv [i]);
         } else if (!strcmp (argv [i], "-v")) {
             xine_verbose = true;
         } else if (!strcmp (argv [i], "-vv")) {
@@ -1092,15 +1092,15 @@ int main(int argc, char **argv) {
             strncpy (configfile, argv [i], sizeof (configfile));
             configfile[sizeof (configfile) - 1] = 0;
         } else if (!strcmp (argv [i], "-cb") && ++i < argc) {
-            QString str = argv [i];
-            int pos = str.find ('/');
+            TQString str = argv [i];
+            int pos = str.tqfind ('/');
             if (pos > -1) {
                 fprintf (stderr, "callback is %s %s\n", str.left (pos).ascii (), str.mid (pos + 1).ascii ());
                 callback = new KMPlayer::Callback_stub 
                     (str.left (pos).ascii (), str.mid (pos + 1).ascii ());
             }
         } else if (!strcmp (argv [i], "-rec") && i < argc - 1) {
-            rec_mrl = QString::fromLocal8Bit (argv [++i]);
+            rec_mrl = TQString::fromLocal8Bit (argv [++i]);
         } else if (!strcmp (argv [i], "-loop") && i < argc - 1) {
             repeat_count = atol (argv [++i]);
         } else {
@@ -1108,10 +1108,10 @@ int main(int argc, char **argv) {
                 delete xineapp;
                 return 1;
             }
-            mrl = QString::fromLocal8Bit (argv [i]);
+            mrl = TQString::fromLocal8Bit (argv [i]);
         }
     }
-    bool config_changed = !QFile (configfile).exists ();
+    bool config_changed = !TQFile (configfile).exists ();
 
     if (!callback && mrl.isEmpty ()) {
         fprintf (stderr, "usage: %s [-vo (xv|xshm)] [-ao (arts|esd|..)] "
@@ -1141,16 +1141,16 @@ int main(int argc, char **argv) {
     xineapp->init ();
 
     if (dvd_device)
-        config_changed |= updateConfigEntry (QString ("input.dvd_device"), QString (dvd_device));
+        config_changed |= updateConfigEntry (TQString ("input.dvd_device"), TQString (dvd_device));
     if (vcd_device)
-        config_changed |= updateConfigEntry (QString ("input.vcd_device"), QString (vcd_device));
+        config_changed |= updateConfigEntry (TQString ("input.vcd_device"), TQString (vcd_device));
     if (grab_device)
-        config_changed |= updateConfigEntry (QString ("media.video4linux.video_device"), QString (grab_device));
+        config_changed |= updateConfigEntry (TQString ("media.video4linux.video_device"), TQString (grab_device));
 
     if (config_changed)
         xine_config_save (xine, configfile);
 
-    QStringList vos = QStringList::split (',', vo_driver);
+    TQStringList vos = TQStringList::split (',', vo_driver);
     for (int i = 0; i < vos.size (); i++) {
         if (vos[i] == "x11")
             vos[i] = "xshm";
@@ -1164,7 +1164,7 @@ int main(int argc, char **argv) {
     }
     if (!vo_port)
         fprintf (stderr, "no video driver found\n");
-    QStringList aos = QStringList::split (',', ao_driver);
+    TQStringList aos = TQStringList::split (',', ao_driver);
     for (int i = 0; i < aos.size (); i++) {
         fprintf (stderr, "trying audio driver %s ..\n", aos[i].ascii ());
         ao_port = xine_open_audio_driver (xine, aos[i].ascii (), NULL);
@@ -1175,7 +1175,7 @@ int main(int argc, char **argv) {
         fprintf (stderr, "audio driver initialisation failed\n");
     stream = xine_stream_new (xine, ao_port, vo_port);
 
-    QByteArray buf;
+    TQByteArray buf;
     if (wants_config) {
         /* TODO? Opening the output drivers in front, will add more config
                  settings. Unfortunately, that also adds a second in startup..
@@ -1196,7 +1196,7 @@ int main(int argc, char **argv) {
     if (callback)
         callback->started (dcopclient.appId (), buf);
     else
-        ;//printf ("%s\n", QString (buf).ascii ());
+        ;//printf ("%s\n", TQString (buf).ascii ());
     xineapp->exec ();
 
     if (sub_stream)